float比double范围大，精度差一倍
byte a=9+1; √ byte b=a+1; ×
计算机二进制存储的是补码
+=不改变变量类型
for可无循环体，while不可
成员变量：有默认值(char：’\u0000’，boolean：false，引用类型：null)
二维数组必须定义外层：int[][] arr = new int[外层][内层];
String传值仍然是地址值 String的不可变性是因为底层数组被final修饰
Integer的数据直接赋值，如果在-128到127之间，会直接从缓冲池里获取数据，所以比较地址值会相等
int i = 0; i = i++; System.out.println(i); // 0
i++不是原子性 分3步，放到cpu、+1、取回，两个i++各循环100编，可能结果：2-200
boolean类型get方法是isXxx
Object类equals是==
类的初始化： main方法所在类先初始化；子类初始化前先要初始化父类；静态代码块/静态变量按顺序执行且只执行一次 顺序： 父类静态代码块/静态变量->子类静态代码块/静态变量->父类非静态代码块/非静态变量->父类构造器->子类非静态代码块/非静态变量->子类构造器
静态代码块，在类加载时可以执行，但不一定会执行 举例：如果调用类的静态成员变量是final则不运行静态代码块，但没有final默认会调用静态代码块，如果没有静态代码块则会自动生成(参考scala静态代码块反编译解析)
public class StaticTest { public static void main(String[] args) { System.out.println(“a=” + MyClass.a); System.out.println(“b=” + new MyClass().b); } } class MyClass { static { a = 10; // a在=左，可以不用MyClass.a // a = a + 1; // a在=右不用MyClass.a会报错； System.out.println(“a=” + MyClass.a); } { b = 12; // b在=左，可以不用this.b System.out.println(“b=” + this.b); } static int a = 1; int b = 2; }
final： 修饰：类、方法、成员变量、【形参】 特点：1.类不能被继承 2.方法不能被重写 3.变量是一个常量 4.修饰形参，方法内不能对形参赋新值，否则报错
abstract： 修饰：类和方法 特点：1.不能实例化 2.子类必须重写所有抽象方法才能实例化，否则仍为抽象类 3.修饰方法，没有方法体，只能存在抽象类中
异常捕获的catch中，如果return的变量是基本类型，不受finally中变量修改的影响
throw手动抛异常后面的语句不执行
创建Lock实现对象ReentrantLock，保证多线程使用同一Lock对象->调用lock()->unlock()释放(必须释放否则造成锁死 写在finally中)
String连接操作判断地址是否相同：有变量(final除外)就在堆中重新开辟空间
List构造器显式赋值给的是容量，但只有add等操作时才会改变size大小， Collections.copy(dest, list)操作时dest长度不能小于list长度，所以需要先撑开目标List大小： List dest = Arrays.asList(new Object[list.size()]);
Collections.copy(dest, list)是浅拷贝
泛型方法可以是静态的，但静态方法中不能使用类的泛型(没造对象前不能确定类的泛型的类型) 不能直接new E[]，而应该是：E[] e = (E[])new Object[capacity];
数组通过Arrays工具类转成集合后，因为其本质还是数组，所以只能修改不能增删：List list = Arrays.asList(“hello”, “world”, “java”);
重写和重载题： 重写： public static void main(String[] args) { byte b = 10; test(b); // 优先匹配相同类型，没有则自动精度提升 // byte不能转char // byte = 10 => 0000 1010 // short = 10 => 0000 0000 0000 1010 // int = 10 => 0000 0000 0000 0000 0000 0000 0000 1010 } public static void test( byte b ) { System.out.println(“b”); } public static void test( int i ) { System.out.println(“i”); } public static void test( short s ) { System.out.println(“s”); } public static void test( char c ) { System.out.println(“c”); }
重载： public class TestOverride { public static void main(String[] args) { User user = new User(); System.out.println(user.sum()); // User没有sum()所以调用父类中sum() // getI()子类中有，所以动态绑定调用子类中的 // i作为属性不存在重写，所以i相当于this.i // 综上，20+10=30 } } class Person { public int i = 10; public int sum() { return getI() + 10; } public int getI() { return i; } } class User extends Person { public int i = 20; public int getI() { return i; } } 动态绑定机制：程序执行过程，如果调用了对象的【成员方法】时，会将方法和对象的实际内存进行绑定，然后调用。
