一、标识符：凡是自己命名的都是标识符
1.标识符的定义规则：
- 由26个字母大小写，0-9，_或$组成；
- 数字不能开头；
- 不可以用用关键字、保留字，但可以包含关键字和保留字；
- java严格区分大小写；
- 标识符不能包含空格.
2.java中名称的命名规范：
- 包名:多单词组成时，所有字母都小写xxxyyy；
- 类名、接口：多单词组成时，所有单词首字母大写：XxxYyy；
- 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz;
- 常量名：所有字母大写，多单词时，每个单词用下划线连接；XXX_YYY_ZZ；
二、计算机中的进制：
1 public static void testBinerary() {
2 int num1 = 0b110;
3 int num2 = 110;
4 int num3 = 0127;
5 int num4 = 0x110A;
6 System.out.println("num1="+num1);//打印出来的都是10进制
7 System.out.println("num2="+num2);
8 System.out.println("num3="+num3);
9 System.out.println("num4="+num4);
10 //自动转换
11 int i= 60;
12 String s1 = Integer.toHexString(i);
13 String s2 = Integer.toBinaryString(i);
14 System.out.println(s1+","+s2);
15
16View Code
三、变量：内存中的一个存储区块，用于内存中保存数据，包含变量类型 变量名 和存储值。
基本说明
- 声明，后使用（变量在方法内声明，必须赋值（初始化）才能使用；在类中声明，会带默认值）；
- 使用变量访问区块数据；
- 变量只有在共有作用域中才有效；
- 同一个作用域内不能定义重名的变量；
java中的数据类型：
- 基本数据类型：byte short int long float double char boolean
- 引用数据类型：类 接口 数组
- 基本类型的默认值
1 public class TestBase {
2 byte a;
3 int b;
4 short c;
5 long d;
6 float e;
7 double f;
8 char g;
9 boolean h;
10
11 @Test
12 public void test1() {
13 System.out.println(a);//0
14 System.out.println(b);//0
15 System.out.println(c);//0
16 System.out.println(d);//0
17 System.out.println(e);//0.0
18 System.out.println(f);//0.0
19 System.out.println(g);//
20 System.out.println(h);//false
21View Code
变量的使用：
1 /**
2 *整型变量的使用；
3 *byte = 8bit 可以表示2^8个数 -128 ~127；1字节</br>
4 *short 可以表示2^16个数；2字节</br>
5 *int 可以表示2^32个数；4个字节</br>
6 *long 可以表示2^64个数 8个字节,必须以大写的L/l的结尾；
7 */
8 public void testInteger() {
9 //byte 的范围 -128 ~127
10 byte b1 = 1;
11 byte b2 = 127;
12 //long变量 必须以大写的L/l的结尾
13 long l = 34444444444L;
14 }
15
16 /**
17 *浮点型（带小数点的）：
18 * float：4字节 7位有效数字
19 * double：8字节
20 */
21 public void testFloat() {
22 double d1 = 123.1;
23 System.out.println(d1+1);
24 //float 定义 后面加f/F结尾
25 float f1 = 123.1f;
26 System.out.println(f1);
27 }
28 /**
29 *字符型：
30 *
31 *<p>1个字符 = 2字节</br>
32 * 声明char 变量，通常使用单引号</br>
33 * 允许使用转义符‘\’ 来将其后的字符转变为特殊字符型常量；如\n'表示回车</br>
34 * 直接使用Unicode值来表示字符常量 \\uXXXX 其中 XXXX代表一个十六进制整数</br>
35 * </br>
36 */
37 public static void testChar() {
38 //''里面只有写一个字符
39 char a = 'a';
40 System.out.println(a);
41 //转义字符
42 char c1 = '\n';//回车
43 char c2 = '\t';//制表符
44 char c3 = 97;//十进制的a
45 char c4 = '\u0061';//16进制a
46 char c5 = '\u34c7';//㓇
47 System.out.println("a"+c1);
48 System.out.println("hello"+c2+"world");
49 System.out.println(c3);//对应ASC码
50 System.out.println(c4);
51 System.out.println(c5);
52 }
53
54 /**
55 *boolean：只能取两个值之一：true false
56 *<p>常在判断 or 循环结构中使用
57 */
58 public void testBoolean(){
59 boolean bb1 = true;
60 System.out.println(bb1);
61
62
View Code
基本本数据类型之间的运算规则 (这里讨论的基本数据运算，不包含Boolean)
1.自动提升：小的范围 和 大范围的做运算时 用大范围的数据类型来接收：
byte、short、char --> int --> long-->float --> double <br>
byte short char 之间做运算或者跟跟自身做运算 ，都需要用int接收
2.强制类型转换：自动类型提升的逆运算；可能会导致精度损失
需要使用强转符：（）
3.整型常量 默认是int 浮点型常量默认是 double；
1 /**
2 * 自动类型提升
3 */
4 public static void testOperation() {
5 byte b1 = 2;
6 int i1 = 3;
7 int res = b1 + i1;
8 char c1 = 97;
9 short s = 1;
10 // char res2 = c1 +s; //char + short 运算
11 // res2 = b1 +c1;//char + byte 运算
12 // char res2 = b1 +s;//short + byte 运算
13 System.out.println(res);
14 }
15 /**
16 *强制类型转换
17 */
18 public static void testConversion() {
19 double d1 = 12.3;
20 int i = (int)d1;
21 System.out.println(i);
22 }
23
24 /**
25 *整型常量 默认是int 浮点型常量默认是 double；
26 *
27 */
28 public static void testSpecial() {
29 byte b1 = 12;
30 //byte res = b1+1;//报错：1是int ,所以这里需要用int接收
31 float f = 1.1f;
32 //float res2 = f+1.2;//报错：1.2默认是double，double的范围比float大不能自动类型提升；
33
View Code
String类型变量的使用
- String属于引用数据类型；（其他的引用数据类型有 类 和接口 数组）
- 声明String类型变量时，使用“”；
- String 可以和8中数据类型做运算，运算只能是连接运算，运算的结果是String类型；
1 public static void testOperation() {
2 boolean b = true;
3 String s = "s";
4 System.out.println(s+b);//这里的“+”是连接运算；
5 char c='a';
6 int num = 100;
7 String str = "hello";
8 System.out.println(c+num+str);//c+num 是加法运算，后面是连接运算
9 System.out.println(c+str+num);//c+str 是连接运算，后面是连接运算
10 System.out.println(c+(num+str));//(num+str)连接，都是连接
11 System.out.println((c+num)+str);//c+num 是加法运算，后面是连接运算
12 System.out.println(str+c+num);//都是连接
13 System.out.println("*"+"\t"+"*");
14 System.out.println("*"+("\t"+"*"));
15 System.out.println('*'+'\t'+"*");
16 System.out.println('*'+('\t'+"*"));
17 //String strw = 123;//声明String类型变量时，使用“”
18 String str1 = 123+"";
19 //int num1 = (int)str1;//不能强转int Integer.parseint(str1)
20View Code
四、运算：
算术运算符（ + - * / % ++ -- ....）
1 public static void testAri() {
2 //除法
3 int num1 = 12;
4 int num2 = 5;
5 System.out.println(num1/5);
6 double d1 = 12;
7 double d2 = 5;
8 double res = d1/d2;
9 double res1 = num1/num2+0.0;
10 double res2 = (0.0+num1)/num2;
11 System.out.println("res:"+res);
12 System.out.println("res1:"+res1);
13 System.out.println("res2:"+res2);
14
15 //++运算，前++，先自增，再运算；后++，先运算后自增1；
16 int a1 = 10;
17 int b1 = ++a1;
18 System.out.println("a1:"+a1+",b1:"+b1);
19
20 int a2 = 10;
21 int b2 = a2++;
22 System.out.println("a2:"+a2+",b2:"+b2);
23
24 short s1 = 10;
25 s1++; //s1 = (short)(s1+1);++不会改变自身数据类型
26
27 byte bb1 = 127;
28 bb1++;
29 System.out.println("bb1:"+bb1);
30
31
32 //取余,结果的符号与被摩数的符号一样
33 int m1 = 12;//被模数
34 int n1 = 5;//模数
35 System.out.println("m1 % n1 = "+ m1%n1);
36
37 int m2 = -12;//被模数
38 int n2 = 5;//模数
39 System.out.println("m2 % n2 = "+ m2%n2);
40
41 int m3 = -12;//被模数
42 int n3 = -5;//模数
43 System.out.println("m3 % n3 = "+ m3%n3);
44
45 int m4 = 12;//被模数
46 int n4 = -5;//模数
47 System.out.println("m4 % n4 = "+ m4%n4);
48View Code
tips:前++ 和 后++ 的具体区别，可以查看
赋值运算：= +=,-+,/+,%=
1 public static void testSetValue() {
2 //赋值符号
3 int i1 = 10;
4 int j1 = 10;
5
6 //连接赋值；
7 int i2,j2;
8 i2= j2 =10;
9
10 int i3,j3 =20;
11
12 int num1 =10;
13 num1 +=2;//num1 = num1+2
14 System.out.println(num1);
15
16 short s1 = 10;
17 s1+=2;//+= 不能改变变量的数据类型
18 System.out.println(s1);
19
20 int i = 1;
21 i *= 0.1;
22 System.out.println("i:"+i);//i=0
23
24 int m = 2;
25 int n = 3;
26 n *= m++;
27 System.out.println("m:"+m);
28 System.out.println("n:"+n);
29
30 int nn = 10;
31 nn += nn++ +(++nn);// nn = nn+(nn++ +(++nn))
32 System.out.println(nn);
33
34
35View Code
比较运算： == != < > <= >=
- 比较运算的结果是boolean类型；只能是true or false;
- < > <= >=:只能使用在数值类型的数据之间;
- ==：不仅可以使用在数值类型数据之间，还可以使用在其他引用类型变量之间;
逻辑运算：只能适用于boolean的变量
1 public static void testLogic() {
2 //区分& 和 &&
3 //相同点：& 和 && 的运算结果相同；当符号左边是true时，二者都会执行右边运算；
4 //不同点：当符号左边是false是，& 还是执行右边运算， && 不执行；
5 boolean b1 = false;
6 int num1 = 10;
7 if(b1 &(num1 ++>0)) {
8 System.out.println("if");
9
10 }else {
11 System.out.println("else");
12 }
13 System.out.println(num1);
14 int num2 = 10;
15 if(b1 &&(num2 ++>0)) {
16 System.out.println("if");
17
18 }else {
19 System.out.println("else");
20 }
21 System.out.println(num2);
22
23 // 区分： | 和 ||
24 //相同点：| 和 || 的运算结果相同；当符号左边是false时，二者都会执行右边运算；
25 //不同点：当符号左边是true是，| 还是执行右边运算， || 不执行；
26 boolean b2 = true;
27 int num3 = 10;
28 if(b2 |(num3 ++>0)) {
29 System.out.println("if");
30
31 }else {
32 System.out.println("else");
33 }
34 System.out.println(num3);
35 int num4 = 10;
36 if(b2 ||(num4 ++>0)) {
37 System.out.println("if");
38
39 }else {
40 System.out.println("else");
41 }
42 System.out.println(num4);
43 }
44View Code
位运算：操作的是整型的数据
- x<<n x*2^n
- x>>n x*2^-n
- >>> 无符号右移：
- &:与
- |：或
- ^:异或
面试题：最高效的计算 2*8 2<<3
1 public static void testBitAri() {
2 int i = 21;
3 System.out.println("i<<2:"+(i<<2));//21*2^2
4 System.out.println("i>>:"+(i>>2));
5
6 int m = 12;
7 int n = 5;
8 System.out.println("m&n:"+(m&n));
9 System.out.println("m|n:"+(m|n));
10 System.out.println("m|n:"+(m^n));
11
12 //交换两个变量的方式
13 //方式一：
14 int num1 = 10;
15 int num2 = 20;
16 int temp = num1;
17 num1 = num2 ;
18 num2 = temp;
19 System.out.println("num1:"+num1+",num2:"+num2);
20 //方式二：
21 num1 = num1+num2;
22 num2 = num1-num2;
23 num1 = num1-num2;
24 System.out.println("num1:"+num1+",num2:"+num2);
25 //方式三： m =（m^n）^n
26
27 num1 = num1^num2;
28 num2 = num1^num2;
29 num1 = num1^num2;
30 System.out.println("num1:"+num1+",num2:"+num2);
31View Code
三元运算符：（表达式)? 表达式一：表达式二
- 条件表达式的结果是boolean类型；
- 根据条件表达式的结果，决定执行表达式一or 二； true:表达式一，否则：表达式二
- 表达式一 和表达式二 要求是一直的；
- 凡是使用3元运算符的，都可以改写成 if else;反之 不成立
- 如果既可以使用三元运算符，又可以用if else ,就使用 三元运算符，因为运行效率高
1 public static void testThreeAri() {
2 //获取两个数的较大值
3 int m= 12;
4 int n = 5;
5 int max = m>n?m:n;
6 String res = m>n?"m 大":(m==n?"相等":"n大");
7 System.out.println(max);
8 System.out.println(res);
9
10 if(m>n) {
11 System.out.println("m大");
12 }else {
13
14
15 }
16View Code
五、流程控制:
分支结构：1.if else
if(条件表达式){
}
if(条件表达式){
}else{
}
if(条件表达式){
}else if{
}....
else{
}
分支结构：2.switch case
switch("表达式"){
case 常量一：
执行语句
///break;
case 常量二：
执行语句；
///break;
...
default:
执行语句；
}
switch(表达式) 这个表达式只能是如下6种数据类型： byte short int char int 枚举 String
case后只能加常量;
break 关键字是可选的；
default：相当于if-else 中的else default是可选的；而且位置是可变的（比如：default可以放在第一个case之前）；
说明：如果switch中的多个case的执行语句相同，则可以考虑合并；
1 public static void testSwitchCase() {
2 int num = 4;
3 switch (num) {
4 case 1:
5 System.out.println("one");
6 break;
7 case 2:
8 System.out.println("two");
9 break;
10 case 3:
11 System.out.println("three");
12 break;
13 default:
14 System.out.println("其他");
15 }
16
17 //case 0 到case5 合并了；（）
18 int score = 78;
19 switch (score/10) {
20 case 0:
21 case 1:
22 case 2:
23 case 3:
24 case 4:
25 case 5:
26 System.out.println("不合格！");
27 break;
28 case 6:
29 case 7:
30 case 8:
31 case 9:
32 case 10:
33 System.out.println("合格！");
34 break;
35
36 }
37
38View Code
for 循环
- 循环结构的4个要素：
1.初始化条件；
2.循环条件（boolean）；
3.循环体；
4.迭代条件
- for循环的结构
for(1;2;4){
3
}
- for循环写法：
1 //for循环方法一
2 // list.size()获取list的元素个数 //"\t"空格
3 for (int i = 0; i < list.size(); i++) {
4 System.out.println(list.get (i)+ "\t");
5 }
6 //for循环方法二
7 for (String string : list) {
8 System.out.println(string + "\t");
9 }
10
11 //for循环方法三
12
13 for (Iterator iterator = list.iterator(); iterator.hasNext();) {
14 String string = (String) iterator.next();
15 System.out.println(string + "\t");
16
View Code
扩展：
- for 循环获取一段数据：截取 长度为 500;
1 //测试for循环
2 @Test
3 public void test2() {
4 List<Person> list = new ArrayList<>();
5 for (int i = 0; i < 2000; i++) {
6 Person person = new Person();
7 person.setAge(i);
8 person.setName("test_" + i);
9 list.add(person);
10 }
11 int size = list.size();
12 int insertbatch = 500;
13 for (int from = 0, to = 0; from < size; from = to) {
14 to = Math.min(from + insertbatch, size);
15 List<Person> itemList = list.subList(from, to);
16 System.out.println("start");
17 System.out.println(itemList);
18 System.out.println("end");
19 }
20
- for 的无限循环： for(;;)
- for 循环取最大公约数：
1 public static void testFor() {
2 Scanner scanner = new Scanner(System.in);
3 System.out.println("请输入第一个数：");
4 int num1 = scanner.nextInt();
5 System.out.println("请输入第二个数：");
6 int num2 = scanner.nextInt();
7 int min = num1>num2?num2:num1;
8 int max = num1>num2?num1:num2;
9 for(int i=min;i>=1;i--) {
10 if(num1%i ==0 && num2%i == 0) {
11 System.out.println("他们之间的最大公约数是："+i);
12 break;
13 }
14 }
15 for(int i=max;i<=(min*max);i++){
16 if(i%min ==0 && i%max==0) {
17 System.out.println("他们之间最小公倍数是："+i);
18 break;
19 }
20 }
21View Code
while 循环
循环结构的4个要素：
1.初始化条件；
2.循环条件（boolean）
3.循环体
4.迭代条件
while循环的结构
1
while(2){
3
4
}
while 无限循环 ： while(true)
for循环和while循环可以相互转换
1 public static void testWhile() {
2 int i=1;
3 while(i<=100) {
4 if(i%2==0) {
5 System.out.println(i);
6 }
7 i++;
8 }
9View Code
do while 循环:
循环结构的4个要素：
1.初始化条件；
2.循环条件（boolean）
3.循环体
4.迭代条件
1
do({
3;
4;
}while(2)
do while至少会执行一次循环体
1 public static void testDoWhile() {
2 int i=1;
3 do {
4 if(i%2==0) {
5 System.out.println(i);
6 }
7 i++;
8 }while(i<=100);
9
10
11View Code
break和continue 关键字的使用
break：switch- case ；循环结构中使用（结束当前循环）
continue： 循环结构中使用（结束当次循环）
关键字后面不能有执行语句；
1 public static void testBreakContinue() {
2 for(int i=1;i<10;i++) {
3 if(i % 4 ==0) {
4 System.out.println(i);
5 //break; 1,2,3
6 //continue 1 2 3 5 6 7 9
7 }
8 }
9 }
10
11 public static void testBreakContinue1() {
12 label:for(int i=1;i<4;i++) {
13 for(int j=1;j<10;j++) {
14 if( j%4 ==0) {
15 //break;//结束当前for循环
16 //break label;//结束标识的层的循环
17 continue label;//结束指定标识的一层循环结构；
18 }
19 System.out.println(j);
20 }
21 }
22View Code
for-for 循环 9 9 乘法表 ，100以内质数...
1 public static void testForFor1() {
2 for(int i=1;i<=5;i++) {
3 for(int j=1;j<=i;j++) {
4 System.out.print("*");
5 }
6 System.out.print("\n");
7 }
8
9
10 }
11 //9 9 乘法表
12 public static void testForFor2() {
13 for(int i=1;i<=9;i++) {
14 for(int j=1;j<=i;j++) {
15 System.out.print(i+"*"+j+"="+i*j+" ");
16 }
17 System.out.print("\n");
18 }
19 }
20
21 public static void testForFor() {
22 for(int i=2;i<=100;i++) {
23 boolean flag = false;
24 for(int j=2;j<i;j++) {//普通算法 高级算法：for(int j=2;j<=Mth.sqrt(i);j++);
25 if(i % j == 0 ) {
26 flag = true;
27 break;
28 }
29 }
30 if(!flag) {
31 System.out.println("100以内的质数："+i);
32 }
33
34 }
35 }
36
37 public static void testForFor3() {
38 label:for(int i=2;i<=100;i++) {
39 for(int j=2;j<i;j++) {//普通算法 高级算法：for(int j=2;j<=Mth.sqrt(i);j++);
40 if(i % j == 0 ) {
41 continue label;
42 }
43 }
44 System.out.println("100以内的质数："+i);
45
46 }
47View Code
我从来不相信什么懒洋洋的自由。我向往的自由是通过勤奋和努力实现的更广阔的人生。 我要做一个自由又自律的人，靠势必实现的决心认真地活着。