Java ——基础语法
package myhello; // 本类所在的包的路径 import af.util.AfMath; // 导入对应的类 import java.util.Random; // 导入随机数的类 public class HelloWorld
{ public static void main(String[] args)
{
int a = ;
int i;
int total = ;
int score = ;
System.out.println(a > );
// 空语句 只有一个 ;
;
// 复合语句 {} 包含的
{
;
}
// if 语句
if (score > )
System.out.println("及格");
else
System.out.println("不及格"); for (i = ; i <= ; i++)
{
total += i * i;
}
System.out.println(total); // break 为跳出单层循环 // 创建数据对象
int[] b = new int[];
// 等号右侧:创建了一个数组对象
// 等号左侧:变量 b 称为该对应的引用
// 称作 变量 b 指向了一个对象
// 有时也简称为: b 是一个对象,或 b 是对象的名字 b[] = ;
b[] = ;
b[] = ; int[] arr = { , , , }; System.out.println(arr.length); // arr[4] = 128; 数组越界 // 对应与引用
int[] c = { , , , };
int[] d = c;
// c 指向了一个对象
// c 和 d 指向相同的对象
// c 和 d 都是该对象的引用
d[] = ;
for (int k = ; k < ; k++)
{
System.out.print(c[k] + " ");
} // 空对象
// null 表示一个引用不指向任何对象
int[] e = { , , , };
int[] f = e;
e = null; // 空指针错误
/*
* for (int t = 0; t < 4; t++) { System.out.print(e[t]+" "); }
*/
for (i = ; i < ; i++)
{
System.out.print(f[i] + " ");
} // 类 class
// 类:类型,描述某一类事物的共性
// 对象:一个具体实例
// 用来描述一种数据类型
// 一个class可以若干基本类型的组合
Student s1 = new Student();
s1.id = "";
s1.name = "Jenrry";
s1.sex = true;
s1.cellphone = "";
// Student 是一个类型
// 所有的 Student 都有 id,name,sex,cellphone这几个属性
// s1是一个Student 类型的对象
// 数组
Student[] s2 = new Student[]; // 类的嵌套
s1.cards.bankCardNumber = "";
s1.cards.schoolCardNumber = ""; // java 会有默认值 // 类的方法
// 类.属性:描述 类有什么
// 类.方法:描述 类能做什么
// 属性命名一般使用名词性短语 方法一般是动词性短语
Student s3 = new Student();
s3.show();
s3.show2(); // 获取最大指
int[] a1 = { , , };
int[] aa1 = { , , , };
int result = ;
for (i = ; i < a1.length; i++)
{
if (a1[i] > result)
{
result = a1[i];
}
}
System.out.print("\n");
System.out.print("最大值:" + result);
MyMath a2 = new MyMath();
System.out.print("\n");
a2.getMax(aa1);
int result2 = a2.getMax2(aa1);
System.out.print("\n");
System.out.print("最大值:" + result2); // return语句执行后,函数不再往下执行,直接退出方法
MyMath n = new MyMath();
boolean res = n.check2(aa1);
System.out.print("结果为:" + res); // 给定一个int值,结果打印一个三角形
MyMath n2 = new MyMath();
System.out.print("\n");
n2.print();
n2.print(-);
// 数组里能被8整除
int[] arr2 = { , , , , , , , , , };
MyMath n3 = new MyMath();
int[] result3 = n3.find8(arr2); // 返回类型可以是一个对象
Student stu = n.createNew("", "你好"); // 像素
Screen s = new Screen();
s.height = ;
s.width = ;
int p = s.pixel(s.width, s.height);
System.out.println("像素值是:" + p);
// 用 that指定
int p2 = s.pixel2(s);
System.out.println("像素值2是:" + p2);
// 当前对象 this
int p3 = s.pixel3();
System.out.println("像素值3是:" + p3); // 显示从 m,n之前所有的质数 用到this
MyMath n4 = new MyMath();
n4.showPrimes(, );
// this. 一般可以省略 重名不能省略 // 有一个换游戏币的机器,可以投1元、5、10元,最后按出货按钮,可以吐出游戏币
// 每个游戏币=1元人民币
Machine n5 = new Machine(); n5.insertCash();
n5.insertCash();
n5.insertCash();
// 出货
int coins = n5.exchange();
System.out.println("拿到了" + coins + "个游戏币"); // 用户输入:数组data
// 把打他数组里面,所有的质数都放到result
PrimeFilter filter = new PrimeFilter();
int[] a4 = { , , , };
int[] a5 = { , , , };
filter.put(a4);
filter.put(a5);
int[] numbers = filter.values();
// 对象=属性+方法
// 属性就是数据
// 方法就是算法
// 对象就是数据和算法的整合体
// 给它所需的数据>>让它干活>>取出结果
// 面向对象程序设计 // 访问修饰符
// public private
// 可见性
// private 不可访问,即不可见
// public 可以访问,即可见 // 构造方法
// 用于构造对象的方法 当创建对象时调用的方法
// 规则: 方法名与类名相同;无返回值
Student2 stu2 = new Student2("", "Jenrry", true);
// 默认构造方法 无参数
// 如果没有构造方法,java编译器会默认一个空的构造方法
/*
* public Student2() {
*
* }
*
*/ // 对象的销毁
// 程序员只管创建对象,不管销毁对象,对象的销毁由系统自动完成
// 当对象不再被使用时,由垃圾回收机制GC自动回收 GC: Garbage Collect
// 对象不再被使用。即对象失去引用 // extends 继承
// 在 java语言里,用exends来表示两个类的父子关系
// public class B extends A
// 表示B继承A
// A:父类 B:子类
// 当B继承于A时,自动继承A中的public 属性/方法
MyVideoFile file = new MyVideoFile();
file.size = ;
file.name = "文档";
file.duration = ;
file.info();
file.play();
file.stop(); // 重写
// 如果父类的方法不满足要求,则可以在子类里重写一遍
file.info(); // 父类构造方法
// 子类会先调用父类构造方法 再调用子类的构造方法
// 可以用 super 制定调用哪个构造方法
// 创建一个对象时,构造方法被调用
Child ch = new Child();
System.out.println("exit"); // 单根继承
// java语言里,一个类只能extend是一个父类
// 继承只能有1个父亲,但是可以有一个继承链
// 即 A -> B -> C -> D ……
// 看继承链 右键 Quick Type Hierarchy
// 在 java 语言中,Object 类是所有类的父类 上面的快捷键可以展示出来
// 如果一个类没有指定父类,则它默认父类就是 Object // 重写 toString() 方法
// toString() 是 Object 的一个方法
Student Stu = new Student();
Stu.id = "";
Stu.name = "";
Stu.sex = true;
System.out.println(Stu);// 重写 toString 函数,修改 Stu 显示的格式 // 多态
// java里,包含:重载 Overload ;重写 Override ;泛型
// 有一个饼干,是苹果味饼干
Pie pi = new ApplePie();
// 有一个宝宝
Baby bb = new Baby();
// 宝宝要吃饼干
bb.eat(pi);
// 语法上:
// 1. 子类转换成父类顺理成章(隐式转换)
// 如上 Pie pi = ApplePie();
// 2. 父类转换成子类型要谨慎 需要显式转换 // 多态
MyVideoFile f1 = new MyVideoFile();
f1.name = "abc.mp4";
f1.size = ;
f1.duration = ; MyFile file2 = f1;
file2.info();
// 注意 当调用一个方法是,不是看引用(声明)的类型,而是看对象的实际类型
// file 指向的是一个MyVideoFile对象,因而调用的是子类的info()方法
// 在 java里,由于所有的类型都是Object的直接或者间接子类
// 所以。 Object x = new MyVideoFile(); 是没有问题的。 // 包
// 右键点击包名, show in -> System Explorer
// 建立目录是用 . 分隔
// 一个类XXX,对应的文件是 XXX.java
// 类的全路径: af.util.AfMath
// 类的文件路径: af/util/AfMath.java // 导入类
AfMath a8 = new AfMath(); // 类改名
// 左窗口右键对应的类 -> refactor->rename
// 改属性名、方法名 对应属性/方法 右键-> refactor -> rename // 快捷键
// 注释:选中要注释的行 ctrl+ /
// 查看定义: CTRL+鼠标点击
// 打开提示: ATL+ /
// 格式化选中代码: CTRL+SHIFT+F // 静态方法(全局方法)
// 该方法与类的关系不大。随便拷贝到别的类里也仍然可以运行,没有语法错误;没有this对象
// 动态方法
// 该方法与类关系密切。如果拷贝到别的类里就失去意义,有语法错误。
// 静态方法用 static 修饰
// 静态方法调用无需创建对象,因为是一个全局的
boolean result5 = Example.isPrime(); // Math 类
// 有很多数据计算相关的静态方法
// 和 String类似,Math 也是 java 语言自带的类
// abs(a): 求a的绝对值
// pow(a,b): 求a的b次幂
// sqrt(a) : 求a的平方根
// round(a): 四舍五入
// sin/cos/tan:
// 应用 Math. // 程序入口:
// main 方法,仅有一个格式
// 可以有多个,用于类的调试
// 如有多个 入口需指定 // 字符串
// 字符串长度 String s = ""; int n = s.length();
// 注:中文字符和英文字符都只占一个字符
// 空字符串和null是两回事;空字符串是一个正常的字符串对象;null不指向任何对象
// 截断 substring(begin,end) ; s.substring
// 相等 equals 注:不能使用 == 符号来验证
// 比较 compareTo
// 忽略大小写比较 compareToIgnoreCase()
// 格式化 format
// 查找 indexOf
// 前缀 startWith()
// 后缀 endsWith // 基本类型与包装类型
// 在java里面。每一个基本类型都对应一个包装类型
// long -> Long
// int -> Integer
// short -> Short
// byte -> Byte
// double -> Double
// float -> Float
// boolean -> Boolean
// 包装类型: 将对应的基本类型封装在内,得到一个类大概就是这种形式
// class Integer
// {
// private int value = 0;
// ... Getter/Setter/...方法
// }
// 使用Integer等包装类,就可以统一用“对象”的思路;来处理问题
// 所有的类都是Object的子类,Interger也是,但 int,double,boolean 却不是,他们是基本的数据类型
// Java是面向对象的编程语言,一切都是对象,但是为了编程的方便还是引入了基本数据类型,为了能够将这些基本数据类型当成对象操作,Java为每一个基本数据类型都引入了对应的包装类型
// 基本类型和包装类型的转换
// Integer ai= new Integer(10);
// int bi = ai.intValue();
// // 也可以简写,java支持自动转换
// Integer ki =123;
// int mi = ki;
// 数值-> String
// int -> String
// String s = String.valueOf(123);
// String -> int
// int a = Integer.valueOf("123"); // 为什么要设计这些包装类:
// 1. 提供一些用于转换的方法;
// 2. 将所有类型统一成类的范围,都是Object的子类 // 控制台
// 在上个世纪,在图形界面出现之前、一种基于文字的用户交互界面
AfConsole cf = new AfConsole();
cf.print("请输入用户名:");
String username = cf.readString("");
cf.print("请输入密码:");
String password = cf.readString(""); if (password.equals(""))
{
cf.println(username + ",你好!欢迎进入系统!");
} else
{
cf.println("密码错误!");
} // 随机数
// Random 类是JDK里自带的基本类
// java.util.Random
// 使用Random可以生成随机数
// Random rand = new Random();
// int s = rand.nextInt(1000);
// nextInt(1000)表示生成一个0~1000 的随机数
Random rand = new Random();
for (i = ; i < ; i++)
{
int sr = rand.nextInt();
System.out.println("生成随机数:" + sr);
}
// 抽3个人获奖 ,不能重复
int[] resultr = new int[];
int count = ;
Random rand2 = new Random();
while (count < )
{
// 抽一个幸运员工。sra是它的号码
int sra = rand2.nextInt();
// 检查sra是否已经中过奖,检查sra是否在result里
boolean exist = false;
for (i = ; i < count; i++)
{
if (resultr[i] == sra)
{
exist = true;
break;
}
}
if (exist)
{
continue;
} else
{
resultr[count] = sra;
count++;
}
} // 字符
// 一个字符 char c1 = 'A';
// 字符编码
// 地球上所有的文字和符号都有一个编码Unicode,其中,把 0 -128 之前的称为 ASCII码,仅英文、数字、英文标点符号等,对应键盘上的按键 // 字符与字符串
// String -》 char
// String str = "afanihao阿发你好";
// char ch = str.charAt(8);//下标从0开始计数
// char[] chs= str.toCharArray();
// char -> String
// char[] chs = {'阿','发'.'你'.'好'};
// String str = new String(chs,1,3);
// str += '的'; // 在字符串字符中查找字符
// String str ="afanihao阿发你好";
// int p = str.indexOf('发');
// System.out.println("位置" + p); // 容器:存储对象的东西
// 容器是一个设计上的术语,不是一个语法的概念
// 比如说,数组就是一个容器 // 链表: 一种组织数据的方式
Monkey m1 = new Monkey(, "");
Monkey m2 = new Monkey(, "");
Monkey m3 = new Monkey(, "");
Monkey m4 = new Monkey(, ""); m1.next = m2;
m2.next = m3;
m3.next = m4;
m4.next = null; Monkey node = m1;
while (node != null)
{
System.out.println("链表中的节点:" + node);
node = node.next;
} // 链表插入和删除节点
// 1.插入到末尾
Monkey m5 = new Monkey(, "");
m4.next = m5;
// 正规写法,从头开始
Monkey tail = m1;
while (true)
{
if (tail.next == null)
break;
tail = tail.next;
}
tail.next = m5;
// 2.插到头节点之后
Monkey head = m1;
m5.next = m1.next;
m1.next = m5; // 3.插到300 之后
node = m1;
while (node != null)
{
if (node.id == )
{
m5.next = node.next;
node.next = m5;
break;
}
node = node.next;
} // 插入节点
// 有头链表:用一个固定的加节点来充当头节点。
// 此节点不算作链表长度,仅用于简化算法
// 有头链表的构造
// 创建一个假节点,作为链表的头节点
Monkey head1 = new Monkey(, "");
head1.next = m1;
// 遍历
Monkey m = head1.next;
while (m != null)
{
System.out.println("链表");
m = m.next;
}
// 有头链表:插入节点
// 直接插入假节点后面
m5.next = head1.next;
head1.next = m5;
// 有头链表:删除节点200
Monkey node1 = head.next;
Monkey prov = head1;
while (node1 != null)
{
if (node1.id == )
{
prov.next = node1.next;
break;
}
prov = node1;
node1 = node1.next;
}
// 或者采用如下
Monkey node3 = head1;
while (node.next != null)
{
if (node.next.id == )
{
node.next = node.next.next;
break;
}
node = node.next;
} // 链表只是容器的一种实现方法 } }
package myhello; import java.io.BufferedReader;
import java.io.InputStreamReader; public class AfConsole
{
BufferedReader reader; public AfConsole()
{
InputStreamReader n = new InputStreamReader(System.in);
reader = new BufferedReader(n);
} // 输出显示一个字符串
public void print(String s)
{
System.out.print(s);
} // 输出显示一个字符串,并换行
public void println(String s)
{
System.out.println(s);
} // 从控制台读取用户输入,读取一个字符串
// 如果用户直接按了回车,则返回默认值
public String readString(String defValue)
{
try
{
return reader.readLine();
} catch (Exception e)
{
return defValue;
}
} // 从控制台读取用户输入,读取一个整数
// 如果用户直接按了回车,则返回默认值
public int readInt(int defValue)
{
try
{
String s = readString(null);
return Integer.valueOf(s);
} catch (Exception e)
{
return defValue;
}
}
}
package myhello; public class ApplePie extends Pie
{ public ApplePie()
{
// TODO Auto-generated constructor stub
} }
package myhello; public class Baby
{ public void eat(Pie p)
{ } }
package myhello; public class Child extends Parent
{ public Child()
{
// TODO Auto-generated constructor stub
// 显示指定父类的那个构造函数
// 子类会默认先去父类的构造函数
// 除非先显示的取某个构造函数
super(23);
System.out.println("子类的构造方法……");
} }
package myhello; public class Example
{ // 判断n是否为质数
public static boolean isPrime(int n)
{
for (int i = 2; i < n; i++)
{
if (n % i == 0)
{
return false;
}
}
return true;
} }
package myhello; public class Machine
{
public int money = 0;// 机器里投入了多少钱
// 人民币 :1,5,10 public void insertCash(int cash)
{
if (cash > 10)
{
System.out.println("只能识别1元,5元,10元");
return;
}
this.money += cash;
System.out.println("当前余额:" + this.money);
} // 交易完成
public int exchange()
{
int numOfCoin = this.money / 1;
this.money = 0;
System.out.println("交易完成,当前余额清0" + this.money);
return numOfCoin;
}
}
package myhello; // 一个一个猴子从头至尾排列
public class Monkey
{ public int id;// 编号
public String name; // 名字
public Monkey next; // 它后面的猴子
// null 表示后面没有猴子 public Monkey()
{ } public Monkey(int id, String name)
{
this.id = id;
this.name = name;
} @Override
public String toString()
{
// TODO Auto-generated method stub
// return super.toString();
return String.format("(%s,%s)", name, id);
} }
package myhello; public class MonkeyList
{
private Monkey head = new Monkey(0, "0"); public MonkeyList()
{
// TODO Auto-generated constructor stub
} // 添加一个对象
public void add(Monkey n)
{
n.next = head.next;
head.next = n;
} // 按编号查找
public Monkey get(int id)
{
Monkey n = head.next;
while (n.next != null)
{
if (n.id == id)
return n;
n = n.next;
}
return null;
} }
package myhello; public class MyFile
{
public long size;// 文件大小
public String name;// 文件名 // 显示文件信息
public void info()
{
System.out.println("文件" + name + " 大小" + size);
}
}
package myhello; public class MyMath
{
public void getMax(int[] data)
{
int result = 0;
for (int i = 0; i < data.length; i++)
{
if (data[i] > result)
{
result = data[i];
}
}
System.out.print("最大值:" + result);
} public int getMax2(int[] data)
{
int result = 0;
for (int i = 0; i < data.length; i++)
{
if (data[i] > result)
{
result = data[i];
}
}
return result;
} public boolean check(int[] arr)
{
boolean result = false;
int sum = 0;
for (int i = 0; i < arr.length; i++)
{
sum += sum + arr[i];
if (sum > 100)
{
result = true;
break;
}
}
return result;
} // check 可以写成如下
public boolean check2(int[] a)
{
int sum = 0;
for (int i = 0; i < a.length; i++)
{
sum += sum + a[i];
if (sum > 100)
{
return true;
}
}
return false;
} // 给定一个int值,结果打印一个三角形
public void print(int n)
{
if (n <= 0)
{
System.out.print("小于0");
return;
}
int rows = 0; // 行数
int cols = 0; // 列数
for (int k = 1; k <= n; k++)
{
System.out.print(k + " ");
cols++;
if (cols > rows)
{
System.out.print("\n");
rows++;
cols = 0;
}
}
} // 数组里能被8整除
public int[] find8(int[] arr)
{
int[] temp = new int[arr.length];
int count = 0;
for (int i = 0; i < arr.length; i++)
{
if (arr[i] % 8 == 0)
{
temp[count] = arr[i];
count++;
}
}
int[] result = new int[count];
for (int i = 0; i < count; i++)
{
result[i] = temp[i];
}
return result; } public Student createNew(String id, String name)
{
Student temp = new Student();
temp.id = id;
temp.name = name;
return temp;
} // 判断n是否为质数
public boolean isPrime(int n)
{
for (int i = 2; i < n; i++)
{
if (n % i == 0)
{
return false;
}
}
return true;
} // 显示m,n之前所有的质数
public void showPrimes(int m, int n)
{
for (int i = m; i <= n; i++)
if (this.isPrime(i))
{
System.out.println("质数:" + i);
}
} }
package myhello; public class MyVideoFile extends MyFile
{
// 父类的public成员自动继承 // 添加子类的特性
public int duration;// 时长 public void play()
{
System.out.println("播放视频" + this.name);
} public void stop()
{
System.out.println("停止播放" + this.name);
} public MyVideoFile()
{
// TODO Auto-generated constructor stub
} @Override
// 右键-source-override/...
public void info()
{
// TODO Auto-generated method stub
// 完全重写
// System.out.println("文件名:" + this.name + ",大小:" + this.size + ",时长:" +
// this.duration);
// 补充
super.info();
System.out.println("时长:" + this.duration);
} }
package myhello; public class Parent
{
int a;
public Parent()
{
// TODO Auto-generated constructor stub
System.out.println("父类的构造方法……");
}
public Parent(int a)
{
this.a = a;
} }
package myhello; public class Pie
{ public Pie()
{
// TODO Auto-generated constructor stub
} }
package myhello; public class PrimeFilter
{
public int[] result = new int[512];
public int total = 0; // 用户输入:数组data
// 把打他数组里面,所有的质数都放到result
public void put(int[] data)
{
for (int i = 0; i < data.length; i++)
{
if (this.isPrime(data[i]))
{
this.result[total] = data[i];
this.total += 1;
}
}
} public boolean isPrime(int n)
{
for (int i = 2; i < n; i++)
{
if (n % i == 0)
{
return false;
}
}
return true;
} // 取出最终过滤得到所有的质数
public int[] values()
{
int[] r = new int[total];
for (int i = 0; i < this.total; i++)
{
r[i] = this.result[i]; }
return r;
} }
package myhello; public class Screen
{
public int width;
public int height; public int pixel(int v, int h)
{
return v * h;
} public int pixel2(Screen that)
{
int result = that.width * that.height;
return result;
} public int pixel3()
{
int result = this.height * this.width;
return result;
}
}
package myhello; public class Student
{
public String id;
public String name;
public boolean sex;
public String cellphone;
// 类的嵌套
public StudentCards cards = new StudentCards(); // 类的方法 public void show()
{
System.out.print("\n");
for (int i = 0; i < 10; i++)
{
System.out.print("报数 " + (i + 1));
}
}
@Override
public String toString()
{
// TODO Auto-generated method stub
// return super.toString();
String s = "学号:"+ id+",姓名:"+name;
if (sex)
{
s = s+ ",性别:男";
}
else
{
s = s + ",性别:女";
}
return s;
}
public void show2(int maxNumber)
{
System.out.print("\n");
for (int i = 0; i < maxNumber; i++)
{
System.out.print("count " + (i + 1));
}
} }
package myhello; public class Student2
{
public String id;
public String name;
public boolean sex; // 构造方法
public Student2(String id, String name, boolean sex)
{
this.id = id;
this.name = name;
this.sex = sex;
}
// 默认构造方法 无参数
public Student2()
{
this.id = "000";
this.name = "Jenrry";
this.sex = true;
}
}
package myhello; public class StudentCards
{
public String schoolCardNumber;
public String bankCardNumber;
}
Java ——基础语法的更多相关文章
- java面向对象编程——第二章 java基础语法
第二章 java基础语法 1. java关键字 abstract boolean break byte case catch char class const continue default do ...
- Java基础语法(下篇)
Java基础语法(下篇) 内容概要: (1)函数的定义 (2)函数的特点 (3)函数的应用 (4)函数的重载 ...
- Java基础语法(上篇)
Java基础语法(上篇) 知识概要: (1)关键字的表示与规范 (2)标示符 (3)注释 (4 ...
- java——基础语法
java基础语法 1.关键字:java赋予特殊含义的单词. 2.标识符:程序中开发人员自定义的名词,例如:类名,函数名,变量名(注意事项:①不能以阿拉伯数字开头②不能采用关键字). 3.常量:固定的数 ...
- java基础语法(二)--单列模式
java基础语法(二)--单列模式 /** * 功能:单列模式 * @author Administrator * */ public class SingletonTest { public sta ...
- java基础语法(一)
java基础语法(一) 1.类是一种抽象的概念,对象是类的一种具体表示形式,是具体的概念.先有类,然后由类来生成 对象(Object).对象又叫做实例(Instance). 2.类由两大部分构成:属性 ...
- Java基础语法入门01
Java基础语法入门01 学习java你要先进行去了解JDK,JRE,JVM JDK Java开发工具包 JRE Java语言开发的运行环境 JVM Java虚拟机,用于Java语言的跨平台所用. 当 ...
- Java匹马行天下之JavaSE核心技术——Java基础语法
Java基础语法 一. 认识Java 1. Java 简介 java 是一种高级的面向对象的程序设计语言,使用Java语言编写的程序时跨平台的.从pc到手机,都有Java开发的程序和游戏,Java ...
- JAVA基础语法——标识符、修饰符、关键字(个人整理总结)
JAVA基础语法——标识符.修饰符.关键字 一 . 标识符 1.1 什么是标识符 就是程序员在定义java程序时,自定义的一些名字,例如helloworld 程序里关键字class 后跟的Dem ...
- JavaSE入门学习7:Java基础语法之语句(下)
继续接着Java基础语法来:JavaSE入门学习5:Java基础语法(一)和JavaSE入门学习6:Java基础语法(二). 语句 Java经常使用的3种循环:while.do...while,for ...
随机推荐
- IIS服务器多站点 的 https证书使用443端口 解决方案
默认情况一个服务器的IIS只能绑定一个HTTPS也就是443端口 要实现多个站点对应HTTPS只能更改IIS配置 首先把每个站点分配个不同端口,如443.444.445…(证书一定要是多域的) 然后重 ...
- 21天打造分布式爬虫-urllib库(一)
1.1.urlopen函数的用法 #encoding:utf-8 from urllib import request res = request.urlopen("https://www. ...
- html 可编辑的下拉框
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...
- Kotlin 最佳实践
为什么写此文 Kotlin很烦,Gralde很烦,还都是升级狂,加一块更烦.几个月不接触Kotlin,再次上手时便一片迷茫.所以记录此文,以便再次上手时查阅. 使用Gradle创建Kotlin项目 m ...
- dva reduxRouter 跳转路由的参数
应该由 新页面的 this.props.location获取
- C#字符串分割成列表及相反转换
在实际开发中,一些老系统,特别是ERP,在做数据交换的时候,保存的是文本格式,然后以一个特殊符号隔开.如 2018-01-02 12:33:20#24.4#20.0|2018-01-03 11:33: ...
- JAVA 面试知识点
参考:https://www.cnblogs.com/java1024/p/8594784.html 反射: JAVA反射机制是在运行状态中, 对于任意一个类,都能够知道这个类的所有属性和方法: 对于 ...
- java操作远程共享目录
一.前言 根据客户反馈,在进行文件下载的时候,新增远程共享目录,下载对应的文件到远程共享目录,采用常用的IO操作模式,提示下载成功,但是客户去远程共享目录查看对应的下载文件,反馈说没有找到对应的文件. ...
- Maven教程4(私服-nexus)
仓库管理器也叫私服或代理仓库 仓库管理器有两个服务目的:首先它的角色是一个高度可配置的介于你的组织与公开Maven仓库之间的代理,其次它为你的组织提供了一个可部署你组织内部生成的构件的地方. 1Nex ...
- 金山wps面经
前言: 金山wps笔试是好久之前的了,忘记具体几号了.当时在华师参加的宣讲会,然后线下笔试通过了, 昨天(4月2号通知现场面试).今天是在华工酒店进行面试的,一二面一起进行的 一面: 1: 自我介绍 ...