类初始化学习笔记

类：是描述某一类事物的特性。

对象：是对某类事物的具体描述，对象就是类的实例。

例：person （人）就是类，王思聪就是这个"person"类的对象，他的身高、体重等就是对象的属性。

类初始化（类），实例初始化（对象）过程

类名对象名 = new 类名（）

先执行静态代码块，且只执行一次。构造代码块每次调用构造方法都执行。

class Fu {
    public int i = 5;
    private int h = test();
    private static int j = method();

    static {
        System.out.println("父类静态代码块");
    }

    {
        System.out.println("父类构造代码块");
    }

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

    public int test(){
        System.out.println("父类非静态成员变量方法");
        return 1;
    }

    public static int method(){
        System.out.println("父类静态成员变量方法");
        return 1;
    }
}

class Zi extends Fu {
    public int i = 10;
    private int h = test();
    private static int j = method();

    static {
        System.out.println("子类静态代码块");
    }

    {
        System.out.println("子类构造代码块");
    }

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

    public int test(){
        System.out.println("子类非静态成员变量方法");
        return 1;
    }

    public static int method(){
        System.out.println("子类静态成员变量方法");
        return 1;
    }
    public void result(){
        int i = 30;
        System.out.println(i); //30
        System.out.println(this.i); //10
        System.out.println(super.i); //5
    }
}

public class ExtendsTest {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.result();
    }
}

执行结果：

父类静态成员变量方法
父类静态代码块
子类静态成员变量方法
子类静态代码块
子类非静态成员变量方法
父类构造代码块
父类构造方法
子类非静态成员变量方法
子类构造代码块
子类构造方法
30
10
5

静态代码块 > 构造代码块 > 构造方法

子类初始化之前先会进行父类的初始化

静态成员变量方法和静态代码块从上到下的顺序依次执行

非静态成员变量方法和构造代码块从上到下的顺序依次执行，构造方法最后执行

非静态成员变量方法前面有一个默认的对象this，this表示正在创建的对象，这里是在创建Son对象，所以test()执行的是子类的非静态成员变量方法（方法的重写）

this：调用本类（当前类）。

super：调用父类。

方法的重写(Override)

用于继承关系中，方法名，返回值，参数列表必须相同

例：

class Father {
 
 public void show() {
  System.out.println("show Father");
 }

}

class Son extends Father {
 
 public void show() {
  System.out.println("show Son");
 }

}

哪些方法不可以被重写

被final修饰的方法

被static修饰的方法

被private修饰的方法

对象的多态性

1.向上转型（自动完成）：父类父类对象 = 子类实例

class Fu{
 public void show() {
   System.out.println("Fu");
 }
}
class Zi extends Fu{
 public void show() {
     System.out.println("Zi");
 }
}
public class Test {
       public static void main(String[] args) {
        Fu a=new Zi(); //向上转型
        a.show();
 
}

2.向下转型（强制转换）：子类子类对象 =(子类) 父类实例;

class Fu{
 public void show() {
   System.out.println("Fu");
 }
}
class Zi extends Fu{
 public void show() {
     System.out.println("Zi");
 }
}
public class Test {
       public static void main(String[] args) {
       Fu1 a=new Zi1(); //向下转型
          Zi1 b=(Zi1) a;
          b.show();
}

方法的重载（Overload）

方法名一致，方法的参数个数不同或参数类型不同，与返回值无关

例：

public class Test {   

public void add(int x){
    
 }
public int add(int y, int x){
    return ;
 }
}

方法的参数传递机制

public class Parameter {
     public static void main(String[] args) {
        Parameter P = new Parameter();
        // 实际参数为“王思”
        p.show("王思");
    }

    public void show(String name) {
        // 形式参数为 name
        System.out.print(name);
    }   
}

1.形参是基本数据类型（在栈里面开内存）：值传递；不会影响到实际参数。

（byte、short、char、int、long、float、double、boolean）

public class Test2 {
    public static void main(String[] args) {
        Test2 t = new Test2();
        int x = 13;
        t.method(x);
        System.out.println("method调用完后的x: " + x); //13
    }
    private void method(int x){
        System.out.println("method中重新赋值之前的x: " + x); //13
        x = 20;
        System.out.println("method中重新赋值之后的x: " + x); //20
    }
}

2.实参是引用数据类型（在堆里面开内存 new）：地址值传递；会影响到实际参数。

特殊类型:String，包装类（Byte、Short、Character、Integer、long、Float、Double、Boolean）

public class Test2 {
    public static void main(String[] args) {
        int[] a = new int []{1, 2, 4};
        method(a);
        System.out.println("调用完method方法之后：" + a[1]); //1
    }
    public static void method(int[] a){
        System.out.println("method内修改a[1]之前：" + a[1]); //15
        a[1] = 15;
        System.out.println("method内修改a[1]之后：" + a[1]); //15
    }
}