一、Java命名规则
类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
二、Java数据类型
基本数据类型(内置数据类型)
byte 8位、有符号、-128—127，默认值0 short 16位、有符号、-32768—32767，默认值0 int 32位、有符号、-2,147,483,648—2,147,483,647，默认值0 long 64位、有符号、-9,223,372,036,854,775,808—+，默认值0L float 32位、有符号、符合IEEE 754标准的浮点数，默认值0.0F double 64位、有符号、符合IEEE 754标准的浮点数，默认值0.0 boolean 1位，true/false，全是小写 char 16位Unicode字符，常量用' ' Java对Unicode支持采用的是UTF-16的编码实现；在UTF-16下，Java的一个Unicode字符由1或2个char（代码单元）表示。
UTF-32和Unicode码表基本一一对应，固定四个字节。 Unicode定义的范围太大了，其实99%的人使用的字符编码不会超过2个字节，所以如果统一用4个字节，数据冗余太大，16位是最好的。遇到超过16位才能表示的字符，可以通过代理技术，采用32位标识。所以现在绝大部分机器实现Unicode采用UTF-16的方案 整数默认为int型，浮点数默认为double型。
基本类型的取值范围，已经以常量的形式定义在对应的包装类中。如Byte.SIZE、Byte.MIN_VALUE、Byte.MAX_VALUE。"E+数字"表示E之前的数字要乘以10的多少次方。比如3.14E3就是3.14 × 103 =3140，3.14E-3 就是 3.14 x 10-3 =0.00314。
引用数据类型
对象、数组都是引用数据类型。
所有引用类型的默认值都是null。
一个引用变量可以用来引用任何与之兼容的类型。
数组
（1）声明数组
dataType[] arrayRefVar; // 首选的方法 或 dataType arrayRefVar[]; // 效果相同，但不是首选方法
建议使用 dataType[] arrayRefVar 的声明风格声明数组变量。 dataType arrayRefVar[] 风格是来自 C/C++ 语言 ，在Java中采用是为了让 C/C++ 程序员能够快速理解java语言。
（2）创建数组
arrayRefVar = new dataType[arraySize];
上面的语法语句做了两件事：
1、使用 dataType[arraySize] 创建了一个数组。
2、把新创建的数组的引用赋值给变量 arrayRefVar。
数组变量的声明，和创建数组可以用一条语句完成，如下所示：
dataType[] arrayRefVar = new dataType[arraySize];
还可以使用如下的方式创建数组：
dataType[] arrayRefVar = {value0, value1, ..., valuek};
（3）处理数组
数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环或者 foreach 循环。
for (int i = 0; i < myList.length; i++) {
System.out.println(myList[i] + " "); }
foreach循环
for (double element: myList) {
System.out.println(element); }
（4）多维数组
int a[][] = new int[2][3];
String s[][] = new String[2][]; s[0] = new String[2]; s[1] = new String[3];
类型转换
自动类型转化
整型、实型（常量）、字符型数据可以混合运算。
运算中，不同类型的数据先转化为同一类型，然后进行运算。
转换从低级到高级。
低 ------------------------------------------------------------> 高 byte、short、char—> int —> long—> float —> double 强制类型转化
把容量大的类型转换为容量小的类型时必须使用强制类型转换。
| 格式：(type)value |
注：转换的数据类型必须是兼容的；不能对boolean类型进行类型转换。
三、常量
四、变量
变量作用域
局部变量（本地变量）
(1)局部变量声明在方法、构造方法或者语句块中
(2)局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁。
(3)访问修饰符不能用于局部变量。
(4)局部变量只在声明它的方法、构造方法或者语句块中可见。
(5)局部变量是在栈上分配的。
(6)局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用成员变量(实例变量、属性)
(1)类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。
(2)如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。
(3)实例变量声明在一个类中，但在方法、构造方法和语句块之外。
(4)实例变量在对象创建的时候创建，在对象被销毁的时候销毁。
(5)实例变量可以声明在使用前或者使用后。
(6)访问修饰符可以修饰实例变量；实例变量具有默认值。
(7)数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。
(8)实例变量可以直接通过变量名访问类变量(静态变量、静态属性)
(1)在类中以static关键字声明，但必须在构造方法和语句块之外。
(2)无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
(3)静态变量除了被声明为常量外很少使用。静态变量储存在静态存储区。
(4)静态变量在程序开始时创建，在程序结束时销毁。
(5)与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
(6)默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。
(7)变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
(8)静态变量可以通过：ClassName.VariableName的方式访问
五、修饰符
访问修饰符
修饰符用来定义类(接口)、方法或者变量，通常放在语句的最前端。
修饰符 当前类 同一包内 子孙类 其他包类 public Y Y Y Y protected Y Y Y default Y Y
private Y 注：上表空单元行代表N。
访问控制继承关系
父类中声明为 public 的方法在子类中也必须为 public。
父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
父类中声明为 private 的方法，不能够被继承。
非访问修饰符
static：用来创建类方法和类变量
静态变量 声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被成为类变量。局部变量不能被声明为 static 变量。 静态方法 声明独立于对象的静态方法。静态方法不能使用类的非静态变量。 对类变量和方法的访问可以直接使用classname.variablename 和 classname.methodname 的方式访问。 final:final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
final 变量 final 变量能被显式地初始化并且只能初始化一次。被声明为 final 的对象的引用不能指向不同的对象，但是 final 对象里的数据可以被改变，也就是说 final 对象的引用不能改变，但是里面的值可以改变。final 修饰符通常和 static 修饰符一起使用来创建类常量。 final方法 类中的 final 方法可以被子类继承，但是不能被子类修改，声明 final 方法的主要目的是防止该方法的内容被修改。 final类 final 类不能被继承，没有类能够继承 final 类的任何特性。 abstract：用来创建抽象类和抽象方法。
abstract方法 抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。抽象方法不能被声明成 final 和 static。任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。抽象方法的声明以分号结尾，例如：public abstract sample();。 abstract类 抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类。抽象类可以包含抽象方法和非抽象方法。 synchronized
transient：序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的 量。该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。
public int b; // 持久化 public transient int limit = 55; // 不会持久化
volatile：volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
六、运算符
算数运算符
算数运算符 描述 例子（A=10，B=20） + 加法，相加运算符两侧的值 A + B 等于 30 - 减法，左操作数减去右操作数 A – B 等于 -10 * 乘法，相乘操作符两侧的值 A * B等于200 / 除法，左操作数除以右操作数 B / A等于2 % 取模，左操作数除右操作数的余数 B%A等于0 ++ 自增，操作数的值增加1 B++ 或 ++B 等于 21（区别详见下文） -- 自减，操作数的值减少1 B-- 或 --B 等于 19（区别详见下文） 前缀自增自减法(++a,--a): 先进行自增或者自减运算，再进行表达式运算。后缀自增自减法(a++,a--): 先进行表达式运算，再进行自增或者自减运算。
关系运算符
关系运算符 例子（A=10，B=20） == (A == B）为假(非真) != (A != B) 为真 > (A > B）非真 < (A < B）为真 >= (A>= B）为假 <= (A <= B）为真 位运算符
应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。位运算符作用在所有的位上，并且按位运算。
位运算符 描述 例子（A=60，B=13） & 如果相对应位都是1，则结果为1，否则为0 (A＆B），得到12，即0000 1100 | 如果相对应位都是0，则结果为0，否则为1 (A | B）得到61，即 0011 1101 ^ 如果相对应位值相同，则结果为0，否则为1 (A ^ B）得到49，即 0011 0001 ~ 按位补运算符翻转操作数的每一位，即0变成1，1变成0。 (～A）得到-61，即1100 0011 << 按位左移运算符。左操作数按位左移右操作数指定的位数。 A << 2得到240，即 1111 0000 >> 按位右移运算符。左操作数按位右移右操作数指定的位数。 A >> 2得到15即 1111 >>> 按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 A>>>2得到15即0000 1111 逻辑运算符
逻辑运算符 例子(A=true,B=false) && （A && B）为假 || （A | | B）为真 ! !(A && B）为真 短路逻辑运算符当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。
赋值运算符
其他运算符
条件运算符：条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。
instanceof：该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）
String name = 'James';boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真
如果被比较的对象兼容于右侧类型,该运算符仍然返回true
Java运算符优先级
七、程序结构
顺序结构
分支结构
if
if(布尔表达式){ //如果布尔表达式的值为true} else{ //如果布尔表达式的值为false}switch
switch(expression){ case value : //语句 break; //可选 case value : //语句 break; //可选 //你可以有任意数量的case语句 default : //可选 //语句 }-
switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串类型了，同时 case 标签必须为字符串常量或字面量。 switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号 case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句 switch 语句可以包含一个 default 分支，该分支必须是 switch 语句的最后一个分支。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句
循环结构
while
while( 布尔表达式 ) { //循环内容 }do...while
do { //代码语句 }while(布尔表达式);for
for(初始化; 布尔表达式; 更新) { //代码语句 }-
最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句 然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句 执行一次循环后，更新循环控制变量 再次检测布尔表达式。循环执行上面的过程 增强for
Java5 引入了一种主要用于数组的增强型 for 循环。
for(声明语句 : 表达式){ //代码句子 }声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
int [] numbers = {10, 20, 30, 40, 50}; for(int x : numbers ){ System.out.print( x ); }
用于控制结构的关键字
break
break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。
break 跳出最里层的循环，并且继续执行该循环下面的语句。
continue
continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在 for 循环中，continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。
八、方法
方法重载
一个类的两个方法拥有相同的名字，但是有不同的参数列表。
Java编译器根据方法签名判断哪个方法应该被调用。
构造方法
当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。
不管是否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个默认构造方法，它把所有成员初始化为0。
一旦定义了自己的构造方法，默认构造方法就会失效。
构造方法被调用的几种方式：
（1）当前类的其他构造方法通过this语句调用它；
（2）当前类的子类的构造方法通过super语句调用它；
（3）在程序中通过new语句调用它。
可变参数
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。
public static void printMax( double... numbers) { if (numbers.length == 0) { System.out.println("No argument passed"); return; } double result = numbers[0]; for (int i = 1; i < numbers.length; i++){ if (numbers[i] > result) result = numbers[i]; } System.out.println("The max value is " + result); }finalize()方法
Java 允许定义这样的方法，它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做 finalize( )，它用来清除回收对象。
一般格式是：
protected void finalize(){ // 在这里终结代码 }关键字 protected 是一个限定符，它确保 finalize() 方法不会被该类以外的代码调用。
Cake c1 = new Cake(1); c1=null; System.gc(); //调用Java垃圾收集器 class Cake extends Object { private int id; public Cake(int id) { this.id = id; System.out.println("Cake Object " + id + "is created"); } protected void finalize() throws java.lang.Throwable { super.finalize(); System.out.println("Cake Object " + id + "is disposed"); } }