java冷门知识点整理

Java基础知识整理

数据类型：

== 和 !=： 两个new出来的Integer比较，如果值的范围介于-128和127之间，则比较Integer也能得到正确结果，其归功于Integer内部维护的IntegerCache的缓存。但是如果使用Integer.valueOf()创建的Integer那就全是false了。

16进制：

int value1 = 0x2f;
int value2 = 0x2F; //16进制以0x开头

8进制：

int value = 0177; //8进制以0开头

2进制：

byte byteValue = (byte)0b00110101;
int value = 0b00101111101011111010111110101111; //2进制以0b开头

float，long和double后缀：f/F, l/L, d/D：double类型后缀可以省略；long类型如果结果小于int最大值即（2^31-1，2147483647）则无所谓，超出后缀加l/L；float类型在float范围内的整数(正负都行)不用加后缀，因为int自动转换为float。*Float，Long，Double这些包装类无论什么情况都要加后缀！

获取该数的2进制String： Integer.toBinaryString(…)；Long.toBinaryString(…)

System.out.printf("%x%n", hex); //16进制输出(%x)和换行(%n)，仅限于System.out.printf()

数字中的下划线：

//不影响运算和打印，只是阅读时更加清晰
double value = 341_435_936.445_667;
int value = 0b0010_1111_1010_1111_1010_1111_1010_1111;
long value = 0x7f_e9_b7_aa;
/*
注意以下情况：
1. 仅限单 _，不能多条相连。
2. 数值开头和结尾不允许出现 _。
3. F、D 和 L 的前后禁止出现 _。
4. 二进制前导 b 和十六进制 x 前后禁止出现 _。
*/

科学计数法：

// 大写 E 和小写 e 的效果相同:
float expFloat = 1.39e-43f;
expFloat = 1.39E-43f;
double expDouble = 47e47d; // 'd' 是可选的
double expDouble2 = 47e47; // 自动转换为 double，因为编译器通常会将指数作为 double 类型来处理

range(…)方法，含头不含尾

gc：

停止-复制(stop-and-copy)：从栈和静态区出发，遍历所有的引用，将存活对象从当前堆复制到另一个堆，清空当前堆(开启后程序会停止)

标记-清扫(mark-and-swap)：从栈和静态区出发，遍历所有的引用，对存活的标记，遍历结束清扫所有未标记对象(开启后程序会停止，剩下堆空间不连续)

年代数：记录存活次数

对象稳定则使用标记-清扫，碎片过多则使用停止-复制

类中初始化顺序：

/**
父类静态变量、
父类静态代码块、
子类静态变量、
子类静态代码块、
父类非静态变量（父类实例成员变量）、
父类构造函数、
子类非静态变量（子类实例成员变量）、
子类构造函数。

注意：在其他类中(非父非子)子类的创建中，无论是父类还是子类的public static void main都不会被加载，虽然他们都被static修饰！
*/

public class Fu {
    public Fu(){
        System.out.println("Fu Fu()");
    }

    static {System.out.println("Fu static {}1");}

    {System.out.println("Fu {}1");}

    static int int1 = getInt();

    public static void print(){
        System.out.println("Fu print()");
    }

    static {System.out.println("Fu static {}2");}

    {System.out.println("Fu {}2");}

    public static int getInt(){
        System.out.println("Fu getInt()");
        return 1;
    }

   public void say() {
       System.out.println("Fu say()");
   }

    public static void main(String[] args) {
        System.out.println("Fu main");
    }
}

public class Zi1 extends Fu{
    public Zi1(){
        System.out.println("Zi Zi1()");
    }
    static {System.out.println("Zi static {}1");}

    {System.out.println("Zi {}1");}

    static int int1 = getInt();

    public static void print() {
        System.out.println("Zi print()");
    }

    static {System.out.println("Zi static {}2");}

    {System.out.println("Zi {}2");}

    public static int getInt(){
        System.out.println("Zi getInt()");
        return 1;
    }

    @Override
    public void say() {
        System.out.println("Zi say()");
    }

    public static void main(String[] args) {
        System.out.println("Zi main");
    }
}

public class Test {
    public static void main(String[] args) {
        Zi1 zi1 = new Zi1();
    }
}

/**
运行结果：
Fu static {}1
Fu getInt()
Fu static {}2
Zi static {}1
Zi getInt()
Zi static {}2
Fu {}1
Fu {}2
Fu Fu()
Zi {}1
Zi {}2
Zi Zi1()	
*/

protected

父类在包1，子类在包2,

在包2子类的代码中

报错：

1. 创建的父类调用父类的protected方法报错
2. 创建的其他 本包或其他包 子类调用父类的protected方法报错

成功调用父类protected方法：

1. 子类自己调用自己(新建自己的实例调用父类protected方法)
2. this.父类protected方法名
3. super.父类protected方法名

在包2其他类中

main方法中创建任何子类或者父类均不可调用父类任何protected方法

在包1其他类中

main方法中创建任何子类或者父类均可以调用父类protected方法

final：如果修饰基本变量的话使得其值不可改变；如果修饰对象的话，那么这个对象的引用不能改变，但是对象里的内容是可以被改变的。final修饰的对象可在代码块{}中复制，初始直接等号赋值或者在构造方法中赋值，但是static final只能初始等号赋值，其他均报错。

不可变常量：final static修饰，命名全部使用大写，单词之间用下划线分隔。

重写：父类中的private方法不会报错但是结果仍然是被重写前的结果，重写并不生效。如果使用@Override注解的可以检测出问题。

class Fu {
    public int field = 0;
    
    public int getField() {
    	return field;
	}
}

class Zi extends Fu {
    public int field = 1;
    
    @Override
    public int getField() {
    	return field;
    }
    
    public int getSuperField() {
    	return super.field;
    }
}

Fu fu = new Zi();

//注意此时用fu.xx获取类中的field时返回的是父类中的参数(0)，跟子类没有半毛钱的关系，但fu.getXx返回的是你期望的值(1)
//实际情况中field都会用private修饰，不会出现这种情况

接口中default修饰的方法：接口中新增default修饰的方法时，实现这个接口的类可以选择不实现这个方法。但是注意，这个default修饰的方法在接口中需要有body即{ … }，不能是抽象方法。

接口中static修饰的方法：和default方法一样，可以理解为是static版本的default，但是方法不能同时被static和default关键字修饰。

内部类：

public class InnerClassTest {

    private int value = 1;
	void printInnerValue(){
        InnerClass innerClass = new InnerClass();
        System.out.println(innerClass.value);
    }
    
    class InnerClass{ //要是该内部类是private，在除了这个类中创建时会报错
        private int value = 2;
        // 内部类可以无条件访问外部类private field
        
        void printValue(){
            System.out.println(value); // 如果InnerClass没有value结果是1，否则是2
            System.out.println(InnerClassTest.value); // 报错
            System.out.println(InnerClassTest.this.value); // 2
        }
        
        InnerClass getInnerClass(){
        	return new InnerClass();
    	}
    }

    public static void main(String[] args) {
        InnerClassTest innerClassTest = new InnerClassTest();
        // 内部类的创建必须依赖于外部类先创建
        InnerClassTest.InnerClass innerClass = innerClassTest.new InnerClass();
        InnerClass innerClass1 = innerClassTest.getInnerClass();
        innerClass.printValue();
    }
}

接口中可以存在内部类，且创建有限度高于正常类。

interface interface1 {

    static void speak2() {
        System.out.println("interface1 speak2()");
    }

    default void speak() {
        System.out.println("interface1 speak()");
    }

    class innerClass {
        public static void main(String[] args) {
            interface1.innerClass innerClass = new innerClass();
            innerClass.print1();
            System.out.println("interface1 innerClass main()");
        }

        void print1() {
            System.out.println("interface1 innerClass print1()");
        }
    }

    static void main(String[] args) {
        System.out.println("interface1 main()");
    }
}

class innerClass{
    void print2() {
        System.out.println("innerClass print2");
    }
}

public class Test implements interface1 {
    public static void main(String[] args) {
        interface1.innerClass innerClass1 = new interface1.innerClass();
        innerClass1.print1();
        innerClass innerClass2 = new innerClass();
        innerClass2.print1();
        innerClass2.print2(); // 这里报错
    }
}

正则 https://www.runoob.com/java/java-regular-expressions.html 中文 [\\u2E80-\\u9FFF]

Stream

流在转换为集合或者操作后无法再次利用，即无法二次利用。