JavaSE易错概念总结

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;
}
}
动态绑定机制：程序执行过程，如果调用了对象的【成员方法】时，会将方法和对象的实际内存进行绑定，然后调用。