java认知盲点（2）

8. 继承中的问题：

(1) A:一个类的静态代码块,构造代码块,构造方法的执行流程
        静态代码块 > 构造代码块 > 构造方法
    B:静态的内容是随着类的加载而加载
        静态代码块的内容会优先执行
    C:子类初始化之前先会进行父类的初始化

举个例子：

class Fu {
    static {
        //2.运行过程中首先加载父类中的静态代码块。
        System.out.println("静态代码块Fu");
    }
//4.调用则对构造代码块和构造方法进行加载
    {
        System.out.println("构造代码块Fu");
    }

    public Fu() {
        System.out.println("构造方法Fu");
    }
}

class Zi extends Fu {
    static {
        //3.然后加载子类中的静态代码块。
        System.out.println("静态代码块Zi");
    }
//5.调用则对构造代码块和构造方法进行加载
    {
        System.out.println("构造代码块Zi");
    }

    public Zi() {
        System.out.println("构造方法Zi");
    }
}

class ExtendsTest2 {
    public static void main(String[] args) {
        Zi z = new Zi();//1.开始需求用到子类，则对子类进行加载，然后在调用。
    }
}

因此结果应为：
静态代码块Fu
静态代码块Zi
构造代码块Fu
构造方法Fu
构造代码块Zi
构造方法Zi

(2) A:成员变量的问题
        int x = 10; //成员变量是基本类型
        Student s = new Student(); //成员变量是引用类型
    B:一个类的初始化过程
        成员变量的初始化
            默认初始化
            显示初始化
            构造方法初始化
    C:子父类的初始化(分层初始化)
        先进行父类初始化，然后进行子类初始化。

例子：

class X {
    Y b = new Y();//2.初始化Y()
    X() {
        System.out.print("X");//4.输出X;
    }
}

class Y {
    Y() {
        System.out.print("Y");//3.输出Y
    }
}

public class Z extends X {
    Y y = new Y();//5.初始化完父类初始子类，输出Y；
    Z() {
        //super();
        //注意：此处的super只是表示要优先初始化父类，在初始化子类而不是直接进入Z()中。
        System.out.print("Z");//6.最后才进入并输出Z；
    }
    public static void main(String[] args) {
        new Z(); //1.首先加载Z(),Z()有父类先对父类进行初始化。
    }
}

结果：YXYZ

问题：
    虽然子类中构造方法默认有一个super()
    初始化的时候，不是按照那个顺序进行的。
    而是按照分层初始化进行的。
    它仅仅表示要先初始化父类数据，再初始化子类数据。

9. 继承中的问题：

名称	方法重载	方法重写
英文	Overloading	Overriding
定义	方法名称相同	方法名称、参数类型、
定义	方法名称相同	返回值类型全部相同
定义	参数的类型或个数不同	被重写的方法不能拥有更严格的权限
定义	对权限没有要求
范围	发生在一个类中	发生在继承类中

方法重写：
在子类中，出现和父类中一模一样的方法声明的现象。
方法重载：
同一个类中，出现的方法名相同，参数列表不同的现象。
重载：
public int A(int i);
public double A(int i);
这2个方法不能构成重载，会有编译错误。
而：
public int A(int i):
public double A(double i);
这2个方法可以形成重载。

10.String和StringBuffer中的问题：

形式参数问题
String作为参数传递
StringBuffer作为参数传递
形式参数：
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数

注意：
String作为参数传递，效果和基本类型作为参数传递是一样的。
举例：

public class StringBufferDemo {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "world";
        System.out.println(s1 + "---" + s2);// hello---world
        change(s1, s2);
        System.out.println(s1 + "---" + s2);// hello---world

        StringBuffer sb1 = new StringBuffer("hello");
        StringBuffer sb2 = new StringBuffer("world");
        System.out.println(sb1 + "---" + sb2);// hello---world
        change(sb1, sb2);
        System.out.println(sb1 + "---" + sb2);// hello---worldworld

    }

    public static void change(StringBuffer sb1, StringBuffer sb2) {
        sb1 = sb2;//赋值时和基本常量一样操作
        sb2.append(sb1);//添加是将其加入到字符缓冲区中
    }

    public static void change(String s1, String s2) {
    //String作为参数传递，效果和基本类型作为参数传递是一样的。
        s1 = s2;
        s2 = s1 + s2;
    }
}