1. 关键字

2. 保留字

所谓保留字，现Java版本未使用，但以后版本可能使用 goto，const

3. 变量

3.1. 字面量

• 整型字面量：100,100L。 不带任何符号的整型字面量可以根据字面量值大大小去适配对应的类型。若字面量值超出类型则会报错。例如：byte a=128;
• 浮点型字面量：3.5，3.5f，3.123e2
• 字符字面量：'a','\u123'
• 布尔字面量：true，false
• 引用字面量：null
• 类型字面量：String.class等

3.2. 按照数据分类

3.2.1. 基本数据类型

3.2.1.1. 数值

3.2.1.1.1. 整型

虽然整数默认为int型，若大于int时则默认为long，但它可以根据整数大小查看能否自动到byte，int等类型中。常用整型如下：

• byte-1
• short-2
• int-4
• long-8

byte a=128; //报错,超出了byte的范围
short b=128; //正确，若赋值超过了short的类型，也将会报错

3.2.1.1.2. 浮点型

默认是double，常用类型如下：

• float-4
• double-8

float f=3.14;//类型不匹配，小数默认为double

float f=3.14f;

double d=1/2;//d的结果为0.0，用于后面表达式的运算结果为int型，且表示整数，故结果为0；而需要double类型，故将0强制转为double，结果为0.0

3.2.1.2. 字符

char-2

char c1='\u0123'; //unicode值来表示

char c2='中';

3.2.1.3. 布尔

boolean-不确定，即由JVM自己去实现。为了加速数据的读取，一般boolean对应的是4字节

3.2.1.4. 基本数据之间运算

boolean除外。 当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。一个复杂表达式也满足（复杂表达式的运算也是多个两个数的运算结合而来，故每次两个数的运算都必须满足上述规律）
byte， char ， short 类型之间变量相互运算的时候，其结果默认是 int 型（除了+=,++等操作），即Java在做运算的时候，若操作数均在int范围内，则一律在int空间内做运算。

byte a=1;
a=a+1;//报错，由于整型常量默认为int型，故a先做提升为int。故结果为int型
a+=1;//正确，此方式在c语言中的汇编语言与a=a+1是一样的
a++;// 正确
// 这两种本质：a=(byte)(a+1);

/**************/
byte a=1,b=2;
short c=3;
a=a+b; // 错误，a+b的结果为int
a+=b; // 正确 
c=a+c; // 错误，a+c的结果为int

/**************/
int i=2;
i*=1.6;//结果小数被截断 i=(int)(i*1.6)

3.2.2. 引用数据类型

• 类calss，例如字符串是一个类类型
• 接口interface
• 数组[]

String可以和8种基本数据类型变量做运算，且运算只能为连接运算：+，运算结果为String。

String属于引用类型,声明String类型变量时，使用""
char c='';//报错，必须要放一个字符

/**************/
char c='a';
int num=10;
String str="hello";
str=c+num+str;//结果为107hello，加法从左往右运算，遇到两个基本类型，开始做加法运算，运算完结果后继续向后，遇到后面为字符串时，开始拼接。

3.2.2.1. 数组

数组声明和初始化问题：数组的长度只能在=的右边定义。即右边要么指定元素个数；要么指定数组元素的值。
数组一旦初始化完成，则数组的长度也就确定了，即数组的属性length的值。

int[] ids;//声明数组，数组为引用类型，初始化需要使用new
ids=new int[]{1,2,3,4,5};//静态初始化数组（数组的初始化和数组元素的赋值同时进行）
int []a={1,2,3,5};//自动推断类型的数组
String[] names=new String[5];//动态初始化——只是数组初始化，并没有进行数组元素的初始化


int [5] a=new int[5];  // 初始化错误写法
int[] a=new int[2]{1,2}; //初始化错误写法


int[][] arr1=new int[][]{{1,2,3},{4,5},{7,8,9}};
// arr1是一个引用类型，指向的是引用类型的数组，arr1[0]是一个引用类型，指向的是一个一维数组。
int[][] arr2=new int[2][3];
int[][] arr3=new int[2][]; // arr3[0]是一个引用类型，指向的是null

int []a[];int a[][];int [][]a; // 这三个都是指代二维数组的声明


int[][] arr3=new int[][3]; // 初始化错误写法
int[2][3] arr3=new int[][]; // 初始化错误写法
int[2][3] arr3=new int[2][3]; //初始化错误写法

char []arr1=new char[]{'a','b','c'}; //arr1.length长度为3

3.2.2.2. Arrays

Arrays工具类，专门来操作数组的方法。

3.3. 类型转换

• 隐式转换：容量小的往容量大的转换

cahr c='c';
int d=c;

• 强制转换：容量大的往容量小的转换必须要强制

int a=5;
short b=(short)a;

3.4. 按照声明位置分类

3.4.1. 成员变量

• 实例变量：不以static修饰的变量
• 类变量：以static修饰的变量

3.4.2. 局部变量

• 形参：方法，构造器中定义的变量
• 方法局部变量：在方法内定义的变量
• 代码块局部变量：在代码块内定义的变量

3.5. 运算符

• 算数运算符 +(正号),-(负号),+,-,*,/,%,++(前置，后置),--(前置，后置),+(字符串拼接)

int n=10；

n+=n++ + ++n;//n=n+n++ + ++n;先把n取出来为10，后面为n++；故结果为20，然后n变为11，后续遇到++n,先n变为12，再与上述结果20相加，故结果为32。10+10+12。而在c语言中n+=n++ + ++n的结果为34，

//本质上n+=n++ + ++n是n=n+(n++ + ++n),从左往右读取，第一个操作符+后面优先级高，故先算括号里面，第一个为n++，先把10拿出来，再n变为11，后面又遇到+操作符，++n：先对11进行加1，得到12，故括号计算完结果为22，n为12；此时而在c编译器中会对第一个n重新取值，即n为12.故结果为34；而java编译器不会对n重新取值，n值仍然为原来的10，故结果为32

// ，而n=n+n++ + ++n的结果为33，从左往右读取，后面遇到n++，故进行计算，把10取出来，n变为11，后续又遇到操作符+，故与第一个同级操作符，因此先计算前面的，对第一个n从新加载数据，变为11，故第一个+操作符完成以后，第一个操作数变为21，n值为11，即后续执行21+ ++n;故结果为33，n值为12。

• 赋值运算符 = 两侧数据类型不一致时，需要自动转换或强制转换成左侧需要的类型。从右至左，例如：x=y=z=j;

int i=10;

int j=20;

System.out.println(i=j);//先将j赋值给i，再输出i

• 关系运算符
  >,>=,<,<=：只能用于数值类型之间
  ==：可以用于数值类型，引用类型
  instanceof
• 逻辑运算符
  操作对象都是boolean类型。
  &&,||：存在着短路特性，&&：只要前面条件为假，后面条件不执行；||：只要前面条件为真，后面条件不执行。
  &,|：不存在短路特性。这两个运算符也可进行条件与，或判断（本质为位运算，当遇到boolean时也可以进行运算）
  !：逻辑非
  ^：逻辑异或
• 位运算符
  <<：每移动一位相当于*2
>>：最高位补符号位，每移动一位相当于/2
>>>：最高位补0
&,|
~：取反
  ^：异或
• 逗号运算符
  从左至右执行

x=4,y=5;

• 三元运算符 三元运算符返回值的类型必须要求一致。
  ?:

int a=ture?1:1.0; //错误，a的类型应该设置为double。


/**********/
Object o1=true?new Integer(1):new Double(2.0);// 由于编译的时候要求三元运算符的类型要统一，故Integer被提升为Double

System.out.println(o1);//结果为1.0，自动拆箱

/**********/
Object o2;

if (true){

    o2=new Integer(1);

}else {

    o2=new Double(2.0);

}

System.out.println(o1);//结果为1，自动拆箱

• 其它运算符
  new--创建对象
  ()--强制转换，改变运算符顺序，函数调用
  []--索引运算符
  .--成员运算符

3.5.1. 运算符的优先级与结合性

默认从左往右执行，若执行过程中遇见优先级高的则保存前面的执行结果，执行优先级较高的，执行完毕后，再返回来执行。例如：n=n+n++ + ++n：先执行n++，再执行第一个加法，随后执行++n，最后执行第二个加法

4. 流程控制

4.1. 顺序结构

4.2. 分支结构

• if...else
• switch...case

4.2.1. switch使用注意事项

1. switch表达式结果只能为如下类型：byte，short，char，int，枚举，String。case只能为常量
2. default的位置可选，不一定放在末尾
3. 注意有无break的区别

int a=10
switch  (a){
    case 0:
    case 1:
    case 2:
    case 3:
        System.out.println("条件0,1,2,3执行相同的逻辑");
        break;
    case 4:
    case 5:
    case 6:
        System.out.println("条件4,5,6执行相同的逻辑");
        break; 
    default:
}

4.3. 循环结构

• while
• do...while
• for(){}
• for...each

4.3.1. 循环中关键字

• break：break默认跳出包裹此关键字最近的一层循环，可用label来标记跳出标识的一层循环结构。
• continue： continue默认结束包裹此关键最近一层循环的当前循环，可用label来标记结束指定标识的一层循环结构的当次循环。