• JAVA继承初始化过程


    我们有必要对整个初始化过程有所认识,其中包括继承,对这个过程中发生的事情有一个整体性的概念。请观察下述代码:

    //: Beetle.java
    // The full process of initialization.
    class Insect {
        int i = 9;
        int j;
        static int x1 = prt("static Insect.x1 initialized");//注意这里是static字段
        
        Insect() {
            prt("i = " + i + ", j = " + j);
            j = 39;
        }
    
        
        static int prt(String s) {
            System.out.println(s);
            return 47;
        }
    
    }
    
    public class Beetle extends Insect {
        int k = prt("Beetle.k initialized");
        static int x2 = prt("static Beetle.x2 initialized");//注意这里是static字段
    
        Beetle() {
            prt("k = " + k);
            prt("j = " + j);
        }
    
        static int prt(String s) {
            System.out.println(s);
            return 63;
        }
    
        public static void main(String[] args) {
            prt("Beetle constructor");
            Beetle b = new Beetle();
        }
    }

    该程序的输出如下:
    static Insect.x initialized
    static Beetle.x initialized
    Beetle constructor
    i = 9, j = 0
    Beetle.k initialized
    k = 63
    j = 39

    对Beetle 运行Java 时,发生的第一件事情是装载程序到外面找到那个类
    在装载过程中,装载程序注意它有一个基础类(即extends 关键字要表达的意思),所以随之将其载入。
    无论是否准备生成那个基础类的一个对象,这个过程都会发生(请试着将对象的创建代码当作注释标注出来,自己去证实)。
    若基础类含有另一个基础类,则另一个基础类随即也会载入,以此类推。
    接下来,会在根基础类(此时是Insect)执行static 初始化,再在下一个衍生类执行,以此类推。
    保证这个顺序是非常关键的,因为衍生类的初始化可能要依赖于对基础类成员的正确初始化。
    此时,必要的类已全部装载完毕,所以能够创建对象。
    首先,这个对象中的所有基本数据类型都会设成它们的默认值,而将对象句柄设为null 。随后会调用基础类构建器。
    在这种情况下,调用是自动进行的。但也完全可以用super 来自行指定构建器调用(就象在Beetle()构建器中的第一个操作一样)。
    基础类的构建采用与衍生类构建器完全相同的处理过程。基础顺构建器完成以后,实例变量会按本来的顺序得以初始化。
    最后,执行构建器剩余的主体部分。

    构造器顺序:

    class AA{
        AA(){System.out.println("AA");}
    }
    
    class BB{
        BB(){System.out.println("BB");}
    }
    
    public class Test extends BB{
        private AA aa = new AA();//组合
        Test(){System.out.println("Test");}
        
        public static void main(String[] args) {
            Test  ee= new Test();
        }
    }

    //输出:
    BB
    AA
    Test

    扩展例子:

    package com.com;
    
    class AA{
        AA(){System.out.println("AA");}
    }
    
    class BB{
        static int i = prt("BB static");
        BB(){System.out.println("BB");}
        
        static int prt(String s) {
            System.out.println(s);
            return 47;
        }
    }
    
    
    
    public class TestMain extends BB{
        private AA aa = new AA();
        
        TestMain(){
            System.out.println("Test");
        }
        
        public static void main(String[] args) {
            System.out.println("TestMain:main");
            
            TestMain  ee= new TestMain();
        }
    }

    //输出:

    BB static
    TestMain:main
    BB
    AA
    Test

    结论:复杂对象构造器顺序如下:
    (1)在其他任何事物发生之前,将分配给对象的存储空间初始化为2进制的0,并且加载类(当然就包括初始化类的static成员).
    (2)调用基类构造器(并且递归调用)
    (3)按声明顺序调用成员初始化方法(这里就是说Test类组合部分AA的初始化部分)
    (4)调用派生类构造器主体。

    动态绑定:
    JAVA中除了static和final方法(private方法属于final方法),其他所有的方法都是动态绑定的。
    我们要知道private方法被自动认为是final方法,而且对派生类是屏蔽的,也就是说如果派生类重写了改方法是一个新的方法,所以说只有非private方法才可以被覆盖。

    继承和清理:
    一般我们是不必担心对象清理的问题,因为会留给垃圾回收器来处理。
    如果我们一定要自己清理对象,那么就必须自己维护好清理顺序。主要有这样几个方面需要注意:
    1. 要为新类定义一个清理函数(比如dispose),我们自己维护,派生类复写基类的该方法
    2. 派生类在该方法的实现最后必须调用基类的dispose方法
    3.还必须注意成员对象销毁的顺序必须要和声明的顺序相反(因为成员初始化时按声明的顺序来构造的)
    实际上也就是和C++的析构函数类似。

    构造器内部的多态行为:(在构造器内部调用多态方法)

    class AA{
        void draw(){System.out.println("AA:draw");}
        AA()
        {
            System.out.println("before:draw");
            draw();
            System.out.println("after:draw");
        }
    }
    
    class BB extends AA{
        private int rad = 1;
        BB(int i)
        {
            rad = i;
            System.out.println("BB:rad = "+rad);
        }
        void draw(){System.out.println("BB:draw--rad = " + rad);}
    
    }
    
    public class Test{
        public static void main(String[] str)
        {
            new BB(5);
        }
    }

    //输出:
    before:draw
    BB:draw--rad = 0 //这里不是1,因为会先将分配给对象的存储空间初始化为2进制的0.
    after:draw
    BB:rad = 5

    显然调用draw函数的多态性了。上面的输出结果很诡异,也给我们有了很好的提示。
    总结:
    编写构造器法则:
    用尽可能简单的方法使对象进入正常状态,如果可以的话,避免调用其他方法。在构造中唯一能够安全调用的方法就是基类中的final方法(private方法也属于final方法),因为final方法不可能存在多态的可能。

    接口基本知识:
    interface Intest
    {
    int VALUE = 5;//接口中字段默认就是static和final的
    void play();//默认是public
    void adjust();
    }

  • 相关阅读:
    java学习day39--SSM整合(方案二)
    java学习day39--SSM整合(方案一)
    @PathVariable注解的作用
    Ajax接收Json数据,调用template模板循环渲染页面的方法
    JS中的DOM与BOM
    关于req.params、req.query、req.body等请求对象
    EJS 高效的 JavaScript 模板引擎
    JavaScript中的变量在内存中的具体存储形式
    JavaScript规定了几种语言类型?
    移动端电商项目总结
  • 原文地址:https://www.cnblogs.com/lijunamneg/p/2893111.html
Copyright © 2020-2023  润新知