关键字：其实就是一个计算机语言对指定的单词赋予了特殊的含义，比如class public static void ，都是固定的写法，你并不能随便的变化，也就是不是自己定义的。特点：都是英文小写单词。
标识符：比如class Demo中的Demo，就是在程序中起的名字。 包含0-9，a-z，$, _ 注意：1、数字不可以开头 2、名称不可以使用关键字 3、数字不可以开头 4、名字中不可以有其他符号包括空格
类型转换，类型转换分为自动类型转换和强制类型转换两种。
自动类型转换：将一种类型的值赋给另一种类型的变量时发生的类型转换，自动类型转换需要满足以下两个条件：1）转换前的类型和转换后的类型兼容；2）转换后的类型的表示范围大于转换前的类型的表示范围。通常的转换如下：
byte→short→char→int→long→float→double 白芍茶因狼服大宝
1 public class TypeCast {
2 public static void main(String[] args) {
3 int i = 100;
4 char c1 = 'a';//注意用char生命的是要加''的
5 byte b = 3;
6 long l = 567L;//声明长整形的变量，其后要加上类型符L
7 float f = 1.89f;//声明float类型的变量，其后要加上类型符f
8 double d = 2.1;
9 int i1 = i + c1; // char类型的变量c1自动转换为int类型参加运算
10 long l1 = l - i1; // int类型的变量i1自动转换为long类型参加运算
11 float f1 = b * f; // byte类型的变量b自动转换为float类型参加运算
12 /* int类型的变量i1自动转换为与f1一致的float类型f1/i1计算结果为float类型. 然后再转换为与d一致的double类型。 */
13 double d1 = d + f1 / i1;
14 System.out.println("i1=" + i1);
15 System.out.println("l1=" + l1);
16 System.out.println("f1=" + f1);
17 System.out.println("d1=" + d1);
18 }
19 }
i1=197
l1=370
f1=5.67
d1=2.1287817269563676
强制类型转换：当要将一个类型表示范围的数赋值给表示范围小的数的时候，例如要将一个double类型的数赋值给int类的数的时候，就需要强制类型转换，语法格式如下：
data_type var1=(data_type)var2;
例如：
float flag = 30.33f;
int num = (int)flag;
在强制类型转换中会丢失精度。在上面的例子中num的值是30。
说明：由于float和double表示的都是约数，所以不要用它们表示需要精确的数，比如货币等，如果要表示精确值，需要使用java.math.BigDecimal类。
需要注意的细节
1、每个字母都有对应的ASCII码（注意每一句的结果）
package day2; public class n1 { public static void main(String[] args) { System.out.println("a"+1); System.out.println('a'+1); System.out.println('a'+'1'); System.out.println("5+5="+5+5); //System.out.println('5+5='+5+5); System.out.println(5+5); System.out.println("5+5="+(5+5)); } }
a1
98
146
5+5=55
10
5+5=10
a的ASCII码是97 1的ASCII是49。
关键点：字符串和任何数据做+动作，都是相连接，生成一个新的字符串
2、容易忽视的精度问题
比如：
package day2; import java.util.Scanner; public class n1 { public static void main(String[] args) { byte b1=1; byte b2=2; byte b; //b= b1+b2;//这里是会出现错误的
b= (byte)(b1+b2)//这里是对的 // b =b1+2;//这里也是不对的 b=1+2; // b=b+b1;//这里也是不对的 b+=b1;//这里虽然看起来和上面的一样，但是还是有区别的 System.out.println(b); } }
在这里涉及到自动强制转换的问题，还有不允许丢失精度的问题，还有一个赋值符号可以自动强制转换的问题。
byte类型的两个变量相加或者一个byte和其他的类型相加的时候会出现错误，是不允许的，容易丢失精度，因为变量的值是变化的，比如，给byte b1 = 127 byte b2 = 2 即使b = 127+2也会出现错误的情况。这是什么原因？因为在赋值的时候默认为把int型的常量赋值给byte类型的变量，程序自动识别这个byte型的变量是否能够容得下这个整形的常量，如果容得下，那么就会将这个数字转为byte类型，但是如果容不下就会报错byte b = b1+b2 或者byte b = b1+6这种情况出现了精度丢失的情况。
还有+=与=的问题：赋值符号有= += -+ /+ *= %= 赋值符号有一个功能就是自动强制转换数值类型，所以当人们怕出现错误的时候经常把b = b+b1 写成b+=b1
算数运算符：
常见问题1：
int x=427; x=x/100*100;
我们一看肯定=427，但是实际上程序的结果是400，因为两个整形的相除结果是不会得到double型的，在427/100的时候结果就已经变成了400
关于自增自减得问题：
一般不做运算的情况下++a和a++没有什么区别但是在变量参与运算的时候就出现了差别
比如
b=++a 运算过程： 右边a=a+1; a=4; 左边b=a; b=4 b=a++ 运算过程：因为++在a的后面说明先把a赋值给b，然后再进行自加运算： 现将a变量中的数据，进行临时存储 temp=a 自增运算 a=a+1 a=4 将临时存储的a的数据赋值给b b = temp
易错点：
package day2; import java.util.Scanner; public class n1 { public static void main(String[] args) { int a = 3; int bb = 2; int c = a++;//先进行临时存储，再赋值 int d = ++a; System.out.println(c+" "+d); } }
在这里我们也许会以为结果是3 4
但是正确结果是3 5（因为上面a已经进行过一次自加运算）
赋值运算：
易错点：特殊short
short s = 3; // s=s+6;//这里是错的 s+=6;//这里是对的
这是为什么呢？s是short，6是int，short会转变成int，再赋值给short的时候转换不过来会丢失精度
s+=6本身是赋值运算，因为+=是赋值运算，会有一个自动转换的过程，总之记住这种特殊情况
byte a ,b;
short c ,d;
a=a+b;
a=a+6;
c=c+d;
c=d+6;
a+=b;//yes
c+=d;//yes
a=1+3;//yes
c=3+2//yes
逻辑运算符：
&：只要两边有一个为false，结果就为false，两边都为true那么结果为true。无论左边是什么，两边都运算
|：只要两边有一个true结果就为true，两边都为false，结果为false。两边都运算
&&：当左边为false时，右边不参与运算，但是当左边是true的时候右边还是要看的
||：当左边为true时，右边不参与运算，当左边是false的时候右边还是要看的
^:两边结果一致，那么运算结果为false，如果不一致结果为true。
位运算符：（这个是比较重要的，因为运算起来比较快）用于操作二进制位的符号
左移<< 又移>> 无符号右移>>>
比如3<<2=12,每往左移一位就是乘以2的次幂，方便进行乘以2的次幂运算
3*2^2 = 12
3<<3 : 3*2^3 = 24
右移6>>1 6/(2^1)
6>>2:6/(2^2)
也就是说做乘右除
右移是除以2的次幂运算
左移的时候空位出现在低位，用0补位
右移的时候出现在高位，原来高位是什么就用什么补位
>>>空位出现在高位，无论高位是什么。空位都用0补
&：
6&3：
省略前面的0：
110
& 011
------------
010=2
6|3
110 | 011 ----------- 111 =7
***一个数异或另外一个数两次还是本身**********
~：取反 ~6=-7（因为-6是6取反加1，这个只取反，没有加1）
位运算的速度非常快，比加减乘除快
判断结构
if else if else
虽然是多行，但是是单条语句
虽然由多个代码块组成，但是只有一个会执行
比如：
package day2; import java.util.Scanner; public class n1 { public static void main(String[] args) { int x = 3; if(x>1) System.out.println("a"); else if(x>2) System.out.println("b"); else System.out.println("c"); System.out.println("over"); } }
a
over
虽然x>2这个条件也满足但是，记住if else if else 只能有一个执行
一个if 对应一个else
比如：
package day2; import java.util.Scanner; public class n1 { public static void main(String[] args) { int x = 3; if(x>1) System.out.println("a"); if(x>2) System.out.println("b"); if(x>3) System.out.println("dd"); else System.out.println("c"); System.out.println("over"); } }
a
b
c
over
注意switch结构，注意
switch（条件）
{ case X：
break;
case x:
break;
……
default：
……
}
举例
package day2; import java.util.Scanner; public class n1 { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); while(true) { int x = scanner.nextInt(); switch( x) { case 1: case 2: case 3: System.out.println("spring"); break; case 4: case 5: case 6: System.out.println("summer"); break; case 7: case 8: case 9: System.out.println("autome"); break; default: System.out.println("winter"); } } } }
if 和switch 语句的应用场景
1、如果对具体个数的数值进行判断，用if也可以，用switch也可以，但是建议使用switch因为switch会提高效率
2、如果要对区间进行判断的话，用if语句
3、如果运算结果是布尔型，用if语句
while do 与 do while区别
while (){do}，满足条件执行语句，但是do{} while;无论是否满足条件，第一次的do都执行
for( ; ; )//for语句的最简单无限循环模式 {} while(true)//while语句的最简单无限循环模式 {}
关于转义字符" "
比如九九乘法表
package day3; public class test1 { public static void main(String[] args) { int i; int j; for(i=1;i<=9;i++) { for(j=1;j<=i;j++) System.out.print(j+"*"+i+"="+(i*j)+" "); System.out.println(); } } }
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 //这个地方开始不对齐
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
但是你要是用了" "制表符，就会变得非常整齐
package day3; public class test1 { public static void main(String[] args) { int i; int j; for(i=1;i<=9;i++) { for(j=1;j<=i;j++) System.out.print(j+"*"+i+"="+(i*j)+" "); System.out.println(); } } }
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
JAVA语言综合题目
1、
package day3; public class test1 { public static void main(String[] args) { int x=1,y=1; if(x++==2 & ++y==2) {x=7;} System.out.println(x+" "+y); } }
2 2
分析：这道题看起来应该是x=7 y=2，但是实际上++在x的后面，也就是x有一个暂存变量的过程，现将x=1赋值给temp然后x再自加，这里是用的temp与2进行比较，所以这里就是false，右边++y=2没错
false &true = false，所以x=7不能执行，但是最终x++是做了自加运算的，所以x=2
2、
package day3; public class test1 { public static void main(String[] args) { int x=1,y=1; if(x++==2 && ++y==2)//一个是x先比较再自加，另外一个是先自加在比较 {x=7;} System.out.println(x+" "+y); } }
2 1
分析：x=2能理解，但是为什么y=1呢？因为这里涉及到&&，&&有个特点那就是左边只要错了右边就不执行了，左边x++！=2，所以右边不执行，所以y还是=1
3、
package day3; public class test1 { public static void main(String[] args) { int x=1,y=1; if(x++==2 | ++y==2) {x=7;} System.out.println(x+" "+y); } }
7 2
|是左右都看的，左边x++==2false，右边++y=2true，左右都执行了，false|true = true，所以x=7,y=2
4、
package day3; public class test1 { public static void main(String[] args) { int x=1,y=1; if(x++==1 || ++y==2) {x=7;} System.out.println(x+" "+y); } }
7 1
分析：x=1 x++==1 true 因为中间是||左边对了中间不读，结果就是true所以x=7,y=1
这么来说的话就是“|”如果左边对的话右边也是读的，“&”如果左边错误的话右边也是读的。“&&”，左边错了的话右边就不读了，“||”左边对的话，右边也不读了
5、
package day3; public class test1 { public static void main(String[] args) { boolean b = true; if(b==false) System.out.println("a"); else if(b) System.out.println("b"); else if(!b) System.out.println("c"); else System.out.println("d"); } }
b
记住 if（不能是赋值符号）
6、
package day3; public class test1 { public static void main(String[] args) { int x = 2,y=3; switch(x) { default: { y++; System.out.println("1"); } case 3: { y++; System.out.println("2"); } case 4: { y++; System.out.println("3"); } } System.out.println(y); } }
1
2
3
6
分析：如果忽视细节肯定以为这道题的答案是4 1，但是要注意的是case后面没有break啊，而且把default放在case前面和放在后面是完全不一样的，如果放在后面的话，如果case情况不符合就不会执行case里面的内容，但是要是default放在前面的话就不管case括号里面的内容是否符合都会执行case{}的内容。
+++++++++