Java多态及类初始化顺序

标签：Java 及类子类 System 多态 static println 父类 out

多态

多态是Java面向对象的三大特性之一，多态建立于封装和继承之上，指对于父类中定义的属性和方法被子类继承后，可以具有不同的数据类型或表现出不同的行为。
可分为编译时多态和运行时多态，编译时多态是静态的，通过方法的重载体现，通过编译之后会产生不同的方法；运行时多态通过动态绑定实现。
Java实现多态有3个必要条件：继承、重写和向上转型。

继承：多态中必须存在子类继承父类的关系；
重写：子类对父类方法进行重写，运行时就会动态调用子类重写的方法；
向上转型：将子类的引用赋给父类对象，父类类型引用名 = new 子类类型();。

多态的实现

一个对象的编译类型和运行类型可以不一致，编译类型在定义对象时就确定了，不能改变，运行类型可以随运行时具体传入的对象引用而改变。
编译类型由=左边的类型确定，运行类型由=右边的类型确定。
instanceof操作符用于判断对象的运行类型是否为XX类型或其子类型。

看下面的的例子：

class A {
    int val1 = 1;
    void test() {
        System.out.println("A test");
    }

    void test2() {
        System.out.println("A test2");
    }
}
public class B extends A {
    int val1 = 11;
    int val2 = 2;
    @Override
    public void test() {
        System.out.println("B test");
    }
    public void test3() {
        System.out.println("B test3");
    }

    public static void main(String[] args) {
        A a = new B(); //向上转型
        a.test(); // 调用子类重写的方法
        a.test2(); //调用父类方法
        ((B) a).test3(); //无法直接调用子类特有方法
        B b = (B)a; //向下转型
        b.test(); //调用子类重写的方法
        b.test2(); //调用父类方法
        b.test3(); //调用子类特有方法
        System.out.println(a.val1); //访问父类成员变量
        System.out.println(((B) a).val2); //无法直接访问子类特有成员变量
        System.out.println(b.val1);
        System.out.println(b.val2);
    }
}

输出：

B test
A test2
B test3
B test
A test2
B test3
1
2
11
2

动态绑定

动态绑定又称后期绑定，即在运行时根据具体对象的类型进行绑定。

当调用对象方法时，该方法会和该对象的内存地址/运行类型绑定；
当调用对象属性时，无动态绑定机制，哪里声明，哪里使用。

静态绑定又称前期绑定，程序执行前方法就已经被绑定，Java中的方法只有final、static、private和构造方法是前期绑定。

向上转型与向下转型

多态的向上转型：
父类的引用指向了子类的对象，父类类型引用名 = new 子类类型();，子类对象可以调用父类的所有成员，但不能调用子类特有的成员（在编译阶段，能调用哪些成员是由编译类型决定），最终运行效果看子类[运行类型]的具体实现（调用方法时，先从子类[运行类型]开始查找）。

多态的向下转型：
子类类型引用名 = (子类类型) 父类引用，只能强转父类的引用，不能强转父类的对象；要求父类的引用必须是指向当前目标类型的对象；向下转型后可以调用子类类型的所有成员。

多态的应用

多态数组
数组的定义类型为父类类型，里面保存的实际元素类型为子类类型。

public static void main(String[] args) {
    //Person Student Teacher都有say()方法
    Person[] persons = new Person[5];
    persons[0] = new Person("adam", 18);
    persons[1] = new Student("adam", 18, 99);
    persons[2] = new Student("bob", 19, 70.1);
    persons[3] = new Teacher("chuck", 30, 3000);
    persons[4] = new Teacher("dick", 29, 3100);

    for (int i = 0; i < persons.length; i++) {
        //persons[i]编译类型为Person，运行类型根据实际情况由JVM判断
        System.out.println(persons[i].say()); //动态绑定机制
        //teach()是Teacher类特有方法，study()是Student类特有方法
        if (persons[i] instanceof Student) {
            ((Student) persons[i]).stduy(); //向下转型
        } else if (persons[i] instanceof Teacher) {
            ((Teacher) persons[i]).teach(); //向下转型
        } else {
            System.out.println("类型有误");
        }
    }
}

多态参数
方法定义的形参类型为父类类型，实参类型允许为子类类型。

public class PloyTest {
    public static void main(String[] args) {
        //父类Employee，子类Worker和Manager继承Employee
        Worker frank = new Worker("Frank", 1000);
        Manager gordon = new Manager("Gordon", 20000, 2000);
        PloyTest ployTest = new PloyTest();
        ployTest.showEmpAnnual(frank);
        ployTest.showEmpAnnual(gordon);

        ployTest.testWork(frank);
        ployTest.testWork(gordon);
    }

    public void showEmpAnnual(Employee e) {
        System.out.println(e.getAnnual());
    }

    public void testWork(Employee e) {
        if (e instanceof Worker) {
            //work()为Worker类专有方法
            ((Worker) e).work(); //向下转型
        } else if (e instanceof Manager) {
            //manage()为Manager类专有方法
            ((Manager) e).manage(); //向下转型
        } else {
            System.out.println("无操作");
        }
    }
}

类初始化顺序

静态代码块：static{}声明，在JVM加载类时执行，且仅执行一次；
构造代码块：在类中用{}声明，每次实例化对象时执行。
执行顺序是：静态代码块->main方法->构造代码块->构造方法。

对于单个类的情况

public class TestA {
    public static int val1;
    public int val2;

    static {
        val1 = 1;
        System.out.println("A静态代码块" + val1);
        val3 = 3;
        // System.out.println(val3);
        // 编译异常Illegal forward reference
    }
    static int val3;
    {
        val2 = 2;
        System.out.println("A构造代码块" + val2);
    }

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

    public static void main(String[] args) {
        TestA testA1 = new TestA();
        TestA testA2 = new TestA();
    }
}

输出：

A静态代码块1
A构造代码块2
A构造方法
A构造代码块2
A构造方法

对于单个类来说，静态变量、静态代码化块、变量、构造代码块、构造方法，执行顺序是：
（静态变量、静态代码块）早于（变量、构造代码块）早于构造方法。
另外，类初始化时规定了，静态代码块只能访问到声明于它之前的静态变量，对于声明在静态代码块之后的变量，只能赋值不能访问，否则出现编译异常非法前向引用。

对于继承的情况

class A {
    A() {
        System.out.println("A constructor");
    }

    static {
        System.out.println("A static");
    }
    {
        System.out.println("A code block");
    }
}
public class B extends A {
    B() {
        System.out.println("B constructor");
    }

    static {
        System.out.println("B static");
    }
    {
        System.out.println("B code block");
    }

    public static void main(String[] args) {
        System.out.println("B main");
        A a = new A();
        System.out.println("---");
        B b = new B();
        System.out.println("---");
    }
}

输出：

A static
B static
B main
A code block
A constructor
---
A code block
A constructor
B code block
B constructor
---

对于继承的情况，类初始化顺序是：父类静态成员及静态代码块 -> 子类静态成员及静态代码块 -> 子类main方法 -> 父类普通成员初始化 -> 父类构造方法 -> 子类普通成员初始化 -> 子类构造方法。

多态的情况：

package test;
class A {
    A() {
        System.out.println("A constructor");
    }

    static {
        System.out.println("A static");
    }
    {
        System.out.println("A code block");
    }
}
public class B extends A {
    B() {
        System.out.println("B constructor");
    }

    static {
        System.out.println("B static");
    }
    {
        System.out.println("B code block");
    }

    public static void main(String[] args) {
        System.out.println("main");
        A a = new B();
    }
}

输出：

A static
B static
main
A code block
A constructor
B code block
B constructor

最后运行时绑定的对象是子类对象。

标签：Java,及类,子类,System,多态,static,println,父类,out
From： https://www.cnblogs.com/KRDecad3/p/17761992.html