面向对象---静态初始化块,普通初始化块,构造器的加载顺序

初始化块:

  包括静态初始化块和普通初始化块。

  初始化块初是构造器的补充,初始化块总在构造器之前执行。

  初始化块的修饰词只能是static。

  系统可以使用初始化块来进行对象的初始化操作。

基本用法:

  如果有一段初始化处理代码对所有对象完全相同,且无需接收任何参数,就可把这段初始化处理代码提取到初始化中去。

优点:

  提高初始化代码的复用,提高应用的维护性。

下面代码主要说明静态初始化块,普通初始化块,构造器的加载顺序:

/**
 *
 * @author wuyong
 * @email [email protected]
 * @date2016年10月29日下午4:13:45
 */
//三个继承关系的类
public class A {
    static{
        System.out.println("A的静态初始化块");
    }
    {
        System.out.println("A的普通初始化块");
    }
    public A() {
        System.out.println("A的无参构造器");
    }
}

public class B extends A{

    static{
        System.out.println("B的静态初始化块");
    }
    {
        System.out.println("B的普通初始化块");
    }
    public B() {
        System.out.println("B的无参构造器");
    }
    public B(String string) {
        //通过this调用本类中的重载的构造器
        this();
        System.out.println("B的有参构造器,他的参数构造值string="+string);
    }

}

public class C extends B{
    static{
        System.out.println("C的静态初始化块");
    }
    {
        System.out.println("C的普通初始化块");
    }
    public C() {
        super("传入B有参构造器的的参数");
        System.out.println("C的无参构造器");
    }

    /*
     * 初始化化块、构造器在继承关系的执行顺序:
     * 都不仅会执行本类中的初始化化块、构造器,
     * 也会上溯到Object类,先执行Object的初始
     * 化化块、构造器,然后在执行其父类的。。。
     * 最后才会执行自身的初始化化块、构造器。
     *
     *
     * 第一次创建C对象,因为系统中还不存在C类,因此需要先加载并初始化C类,
     * 初始化C类时会先执行其顶层的父类的静态初始化块,在执行其直接父类的
     * 静态初始化块,最后在执行C本身的静态初始化块。
     * C类初始化成功后,C类在该虚拟机里将一直存在,所以第二次创建C类的对象
     * 时不要在在对C类进行初始化,就不要再执行静态初始化块。
     *
     */
    public static void main(String[] args) {
        System.out.println("第一次创建C的对象----");
        new C();
        System.out.println("第二次创建C的对象----");
        new C();
    }
    /*
     * 输出结果:
     * A的静态初始化块
        B的静态初始化块
        C的静态初始化块
        第一次创建C的对象----
        A的普通初始化块
        A的无参构造器
        B的普通初始化块
        B的无参构造器
        B的有参构造器,他的参数构造值string=传入B有参构造器的的参数
        C的普通初始化块
        执行C的无参构造器
        第二次创建C的对象----
        A的普通初始化块
        A的无参构造器
        B的普通初始化块
        B的无参构造器
        B的有参构造器,他的参数构造值string=传入B有参构造器的的参数
        C的普通初始化块
        执行C的无参构造器
     */
}
时间: 2024-10-08 10:09:08

面向对象---静态初始化块,普通初始化块,构造器的加载顺序的相关文章

静态代码块 和 main 函数 谁先加载???

学习编程中,当我们遇到问题的时候,如何解决我们的问题? 动手编程,编一个小程序 就很容易 看见自己想要的结果和答案! 今天学习了 static {}  静态代码块,但是 搞不清楚 他和static main() 函数 谁先加载? 于是: 自己编写了一个小段代码: 代码如下: package stu.love.a; public class StaticDemo1 { static { System.out.println("a"); } /** * @param args */ pub

Java 类的实例变量初始化的过程 静态块、非静态块、构造函数的加载顺序

Java 类的实例变量初始化的过程 静态块.非静态块.构造函数的加载顺序 先看一道Java面试题: 1 public class Baset { 2 private String baseName = "base"; 3 // 构造方法 4 public Baset() { 5 callName(); 6 } 7 // 成员方法 8 public void callName() { 9 // TODO Auto-generated method stub 10 System.out.p

Java基础6:代码块与代码加载顺序

Java基础6:代码块与代码加载顺序 代码块:用{}包围的代码 java中的代码块按其位置划分为四种: 局部代码块 位置:局部位置(方法内部) 作用:限定变量的生命周期,尽早释放,节约内存 调用:调用其所在的方法时执行 public class 局部代码块 {@Testpublic void test (){   B b = new B();   b.go();}}class B {   B(){}   public void go() {       //方法中的局部代码块,一般进行一次性地调

《Java编程思想》学习01:普通类的初始化加载顺序分析

<Java编程思想>学习01:普通类的初始化加载顺序分析 本文根据控制变量法,分析普通类(没有extends,implement)初始化的加载顺序: 参考<Java编程思想>第五章 源码 StaticClass1类 package com.tyj.study.thinkinjava; /* * *@Description: *@Author:TYJ *@Date: create in 2019/7/9 17:22 */ public class StaticClass1 { { S

(转)面试题--JAVA中静态块、静态变量加载顺序详解

1 public class Test { //1.第一步,准备加载类 2 3 public static void main(String[] args) { 4 new Test(); //4.第四步,new一个类,但在new之前要处理匿名代码块 5 } 6 7 static int num = 4; //2.第二步,静态变量和静态代码块的加载顺序由编写先后决定 8 9 { 10 num += 3; 11 System.out.println("b"); //5.第五步,按照顺序加

Java---类加载机制,构造方法,静态变量,父类,变量加载顺序

直接上代码: 代码1: public class ConstroctTest { private static ConstroctTest test = new ConstroctTest(); //静态变量sta1 未赋予初始值 public static int sta1; //静态变量sta1 赋予初始值20 public static int sta2 = 20; //构造方法中对于静态变量赋值 private ConstroctTest() { sta1 ++ ; sta2 ++ ;

java 成员变量 静态变量代码块 静态代码快加载顺序

序言 基类A 类B继承实现了A类 1在new B一个实例时首先要进行类的装载.(类只有在使用New调用创建的时候才会被java类装载器装入)2,在装载类时,先装载父类A,再装载子类B3,装载父类A后,完成静态动作(包括静态代码和变量,它们的级别是相同的,安装代码中出现的顺序初始化)4,装载子类B后,完成静态动作类装载完成,开始进行实例化1,在实例化子类B时,先要实例化父类A2,实例化父类A时,先成员实例化(非静态代码)3,父类A的构造方法4,子类B的成员实例化(非静态代码)5,子类B的构造方法

Java误区: 静态代码块,会在类被加载时自动执行?

JAVA静态代码块会在类被加载时自动执行? 很多Java开发者的思想,被这个思想深深的轮奸了n遍,传播这个错误思想的博客,在网上一堆,越来越多的人被轮奸. 如:http://blog.csdn.net/leeyu35/article/details/7755304 那么我们程序来证明这句话是错误的: class MyClass1 { static {//静态块 System.out.println("static block "); } } public class Main { Cl

代码块与静态代码块与静态方法的加载顺序

  public abstract class ClassLoadingTest { public static void main(String[] args) { User user3 = new User(); } } public class User { public static User user= new User("wang",18); public static void userSay(){ System.out.println("调用userSay静态