精华内容
下载资源
问答
  • 类的整个加载过程包括加载、验证、准备、解析、初始5个阶段。我这里只讨论我们在笔试题中比较关心的、影响程序输出的部分。类加载:在准备阶段,static变量在方法区被分配内存,然后内存被初始零值(注意和...

    类是在任何static成员被访问时加载的(构造器也是static方法)。类的整个加载过程包括加载、验证、准备、解析、初始化5个阶段。我这里只讨论我们在笔试题中比较关心的、影响程序输出的部分。

    类加载:

    准备阶段,static变量在方法区被分配内存,然后内存被初始化零值(注意和static变量初始化的区别)。

    初始化阶段,执行类构造器<clinit>()方法(注意和实例构造器<init>()方法不同)。虚拟机会保证子类的<clinit>()方法执行之前,父类的<clinit>()方法已经执行。

    在执行<clinit>()方法时,按照类定义中static变量的赋值语句和static代码段的书写顺序,依次执行。

    子类调用基类的静态方法时,相当于基类调用自己的静态方法,所以子类的static不会初始化。例子如下:

    Child.sMethodBase(); // 类的定义在最后面

    这一句的执行结果为:

    基类initPrint2 静态变量s4:null
    基类静态方法sMethodBase 静态变量s4:基类静态变量s4

    创建对象:

    虚拟机在遇到new指令时,首先检查类是否加载过,在类加载检查通过后,虚拟机为对象分配内存,分配完内存后会将内存空间初始化为零值(不包括对象头)。所以对象的实例字段在初始化之前就有了零值。

    执行new指令之后会接着执行实例构造器<init>方法,这时才开始对象的初始化。

    进入构造器时,如果有基类,会进入基类的无参构造器(或者用super()显式指定的基类构造器)。在构造之前,先按照实例字段和非static代码段的书写顺序,依次初始化,最后执行构造器的语句。

    super()语句要按基类的次序,放在构造器最前面,否则编译器会报错。

    创建子类对象的例子如下:

    Child child = new Child("s");

    输出结果为:

    基类initPrint2 静态变量s4:null
    子类initPrint2 静态变量s2:null
    基类initPrint1 实例变量s3:null
    基类initPrint1 静态变量s4:基类静态变量s4
    基类构造器 int i
    子类initPrint1 实例变量s1:null
    子类initPrint1 静态变量s2:子类静态变量s2
    子类构造器

    可见,确实是先加载类(第1、2行发生在static变量的初始化阶段),然后再创建对象(第3行及以后)。创建的过程也是从父类到子类,先是非static变量的初始化(初始化前已经有默认值了,如第3行和第6行所示),然后执行构造器语句。

    上面用到的类的定义如下:

    class Base {
        private int x3 = initPrint1();
        public String s3 = "基类实例变量s3";
    
        private static int x4 = initPrint2();
        private static String s4 = "基类静态变量s4";
    
        private int initPrint1() {
            System.out.println("基类initPrint1 实例变量s3:" + s3);
            System.out.println("基类initPrint1 静态变量s4:" + s4);
            return 11;
        }
    
        private static int initPrint2() {
            System.out.println("基类initPrint2 静态变量s4:" + s4);
            return 21;
        }
    
        public Base(int i) {
            System.out.println("基类构造器 int i");
        }
    
        public void callName() {
            System.out.println(s3);
        }
    
        public static void sMethodBase() {
            System.out.println("基类静态方法sMethodBase 静态变量s4:"+s4);
        }
    }
    
    class Child extends Base {
        private int x1 = initPrint1();
        public String s1 = "子类实例变量s1";
    
        private static int x2 = initPrint2();
        private static String s2 = "子类静态变量s2";
    
        private int initPrint1() {
            System.out.println("子类initPrint1 实例变量s1:" + s1);
            System.out.println("子类initPrint1 静态变量s2:" + s2);
            return 11;
        }
    
        private static int initPrint2() {
            System.out.println("子类initPrint2 静态变量s2:" + s2);
            return 21;
        }
    
        public Child(String s) {
            super(1);
            System.out.println("子类构造器");
        }
    
        public void callName() {
            System.out.println(s1);
        }
    
        public static void sMethodChild() {
            System.out.println("子类静态方法sMethodChild 静态变量s2:"+s2);
        }
    }


    方法和字段的重写

    另一个基础的问题是子类对父类的override。

    方法的重写有运行时绑定的效果,子类实例如果重写了基类的方法,即使向上转型为基类,调用的仍是子类的方法。而且在方法中的字段也会优先认为是子类的字段。

    但是字段并没有运行时绑定一说,向上转型后调用的就是基类的字段。

    同时静态方法与类关联,并不是与单个对象关联,它也没有运行时绑定。

    class Base {
        public String s1 = "基类实例变量s1";
        private static String s2 = "基类静态变量s2";
    
        public void f() {
            System.out.println("基类方法");
        }
    
    }
    
    class Child extends Base {
        public String s1 = "子类实例变量s1";
        private static String s2 = "子类静态变量s2";
    
        public void f() {
            System.out.println("子类方法");
        }
    }

    对于上面的两个类,当如下使用时:

            Child child = new Child();
            System.out.println(((Base)child).s1);
            ((Base)child).f();

    输出的结果为:

    基类实例变量s1
    子类方法

    需要补充说明的是,private的方法虽然可以重写,但已经不是传统意义上的override,因为父类的private方法对子类不可见,所以子类重写的函数被认为是新函数,在父类函数中将子类向上转型时,调用的仍是父类的private方法,这是在类加载的解析阶段就确定的。

    class Base {
        public String s1 = "基类实例变量s1";
    
        private void f() {
            System.out.println("基类方法");
        }
    
        public static void main(String[] args) {
            Child child = new Child();
            System.out.println(((Base)child).s1);
            ((Base)child).f();
    
        }
    
    }
    
    class Child extends Base {
        public String s1 = "子类实例变量s1";
    
        public void f() {
            System.out.println("子类方法");
        }
    }

    Base的main函数运行结果为:

    基类实例变量s1
    基类方法

    解析阶段中确定唯一调用版本的方法有static方法、private方法、实例构造器和父类方法4类,满足“编译器可知,运行期不变”的要求

    综合题

    最后我们来看一道牛客网上的题目:

    public class Base
    {
        private String baseName = "base";
        public Base()
        {
            callName();
        }
     
        public void callName()
        {
            System. out. println(baseName);
        }
     
        static class Sub extends Base
        {
            private String baseName = "sub";
            public void callName()
            {
                System. out. println (baseName) ;
            }
        }
        public static void main(String[] args)
        {
            Base b = new Sub();
        }
    }

    程序的输出结果是什么呢?

    5

    4

    3

    2

    1

    null (子类重写了父类的public方法,public实例方法属于运行时绑定的方法,实际调用时,传入的this引用的是一个子类对象,所以定位到了子类的函数,而父类构造时,子类还未构造,子类实例变量还没有初始化,为零值)。如果将Base里面的public callName()修改为private  callName()结果会是什么呢?

    5

    4

    3

    2

    1

    base(子类并没有真正重写父类的callName()方法,它们是两个不同的方法,private方法在类加载阶段解析,满足“编译器可知,运行期不变”的要求,和调用者的实际类型无关,根据上下文信息,父类构造器中的方法被指定为父类中的私有方法)。


    上一篇:Java中的反射

    下一篇:ThoughWorks编程体验

    展开全文
  • 本文主要向大家介绍了JAVA语言中类的实例化过程变量的初始化顺序讲解,附常见笔试程序阅读分析,通过具体的内容向大家展示,希望对大家学习JAVA语言有所帮助。类是在任何static成员被访问时加载的(构造器也是...

    本文主要向大家介绍了JAVA语言中类的实例化过程变量的初始化顺序讲解,附常见笔试程序阅读题分析,通过具体的内容向大家展示,希望对大家学习JAVA语言有所帮助。

    类是在任何static成员被访问时加载的(构造器也是static方法)。类的整个加载过程包括加载、验证、准备、解析、初始化5个阶段。我这里只讨论我们在笔试题中比较关心的、影响程序输出的部分。

    类加载:

    在准备阶段,static变量在方法区被分配内存,然后内存被初始化零值(注意和static变量初始化的区别)。

    在初始化阶段,执行类构造器()方法(注意和实例构造器()方法不同)。虚拟机会保证子类的()方法执行之前,父类的()方法已经执行。

    在执行()方法时,按照类定义中static变量的赋值语句和static代码段的书写顺序,依次执行。

    子类调用基类的静态方法时,相当于基类调用自己的静态方法,所以子类的static不会初始化。例子如下:

    Child.sMethodBase(); // 类的定义在最后面

    这一句的执行结果为:

    基类initPrint2 静态变量s4:null

    基类静态方法sMethodBase 静态变量s4:基类静态变量s4

    创建对象:

    虚拟机在遇到new指令时,首先检查类是否加载过,在类加载检查通过后,虚拟机为对象分配内存,分配完内存后会将内存空间初始化为零值(不包括对象头)。所以对象的实例字段在初始化之前就有了零值。

    执行new指令之后会接着执行实例构造器方法,这时才开始对象的初始化。

    进入构造器时,如果有基类,会进入基类的无参构造器(或者用super()显式指定的基类构造器)。在构造之前,先按照实例字段和非static代码段的书写顺序,依次初始化,最后执行构造器的语句。

    super()语句要按基类的次序,放在构造器最前面,否则编译器会报错。

    创建子类对象的例子如下:

    Child child = new Child("s");

    输出结果为:

    基类initPrint2 静态变量s4:null

    子类initPrint2 静态变量s2:null

    基类initPrint1 实例变量s3:null

    基类initPrint1 静态变量s4:基类静态变量s4

    基类构造器 int i

    子类initPrint1 实例变量s1:null

    子类initPrint1 静态变量s2:子类静态变量s2

    子类构造器

    可见,确实是先加载类(第1、2行发生在static变量的初始化阶段),然后再创建对象(第3行及以后)。创建的过程也是从父类到子类,先是非static变量的初始化(初始化前已经有默认值了,如第3行和第6行所示),然后执行构造器语句。

    上面用到的类的定义如下:

    class Base {

    private int x3 = initPrint1();

    public String s3 = "基类实例变量s3";

    private static int x4 = initPrint2();

    private static String s4 = "基类静态变量s4";

    private int initPrint1() {

    System.out.println("基类initPrint1 实例变量s3:" + s3);

    System.out.println("基类initPrint1 静态变量s4:" + s4);

    return 11;

    }

    private static int initPrint2() {

    System.out.println("基类initPrint2 静态变量s4:" + s4);

    return 21;

    }

    public Base(int i) {

    System.out.println("基类构造器 int i");

    }

    public void callName() {

    System.out.println(s3);

    }

    public static void sMethodBase() {

    System.out.println("基类静态方法sMethodBase 静态变量s4:"+s4);

    }

    }

    class Child extends Base {

    private int x1 = initPrint1();

    public String s1 = "子类实例变量s1";

    private static int x2 = initPrint2();

    private static String s2 = "子类静态变量s2";

    private int initPrint1() {

    System.out.println("子类initPrint1 实例变量s1:" + s1);

    System.out.println("子类initPrint1 静态变量s2:" + s2);

    return 11;

    }

    private static int initPrint2() {

    System.out.println("子类initPrint2 静态变量s2:" + s2);

    return 21;

    }

    public Child(String s) {

    super(1);

    System.out.println("子类构造器");

    }

    public void callName() {

    System.out.println(s1);

    }

    public static void sMethodChild() {

    System.out.println("子类静态方法sMethodChild 静态变量s2:"+s2);

    }

    }

    方法和字段的重写

    另一个基础的问题是子类对父类的override。

    方法的重写有运行时绑定的效果,子类实例如果重写了基类的方法,即使向上转型为基类,调用的仍是子类的方法。而且在方法中的字段也会优先认为是子类的字段。

    但是字段并没有运行时绑定一说,向上转型后调用的就是基类的字段。

    同时静态方法与类关联,并不是与单个对象关联,它也没有运行时绑定。

    class Base {

    public String s1 = "基类实例变量s1";

    private static String s2 = "基类静态变量s2";

    public void f() {

    System.out.println("基类方法");

    }

    }

    class Child extends Base {

    public String s1 = "子类实例变量s1";

    private static String s2 = "子类静态变量s2";

    public void f() {

    System.out.println("子类方法");

    }

    }

    对于上面的两个类,当如下使用时:

    Child child = new Child();

    System.out.println(((Base)child).s1);

    ((Base)child).f();

    输出的结果为:

    基类实例变量s1

    子类方法

    需要补充说明的是,private的方法虽然可以重写,但已经不是传统意义上的override,因为父类的private方法对子类不可见,所以子类重写的函数被认为是新函数,在父类函数中将子类向上转型时,调用的仍是父类的private方法,这是在类加载的解析阶段就确定的。

    class Base {

    public String s1 = "基类实例变量s1";

    private void f() {

    System.out.println("基类方法");

    }

    public static void main(String[] args) {

    Child child = new Child();

    System.out.println(((Base)child).s1);

    ((Base)child).f();

    }

    }

    class Child extends Base {

    public String s1 = "子类实例变量s1";

    public void f() {

    System.out.println("子类方法");

    }

    }

    Base的main函数运行结果为:

    基类实例变量s1

    基类方法

    解析阶段中确定唯一调用版本的方法有static方法、private方法、实例构造器和父类方法4类,满足“编译器可知,运行期不变”的要求。

    综合题

    最后我们来看一道牛客网上的题目:

    public class Base

    {

    private String baseName = "base";

    public Base()

    {

    callName();

    }

    public void callName()

    {

    System. out. println(baseName);

    }

    本文由职坐标整理并发布,希望对同学们有所帮助。了解更多详情请关注编程语言JAVA频道!

    展开全文
  • Java类实例的初始化顺序

    千次阅读 2013-09-22 23:15:32
    阿里巴巴2013校园招聘笔试题倒数第二题:java类、对象初始化顺序的分析

    今晚是阿里巴巴 2013 校园招聘的杭州站笔试。下午匆忙看了两张历年试卷,去现场打了瓶酱油。

    题目总体考察点偏基础,倒数第二题(Java 附加题)比较有趣,考察了 Java 初始化机制的细节,在此摘录出来。

    题目

    求如下 java 代码的输出:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    
    class T  implements Cloneable{
      public static int k = 0;
      public static T t1 = new T("t1");
      public static T t2 = new T("t2");
      public static int i = print("i");
      public static int n = 99;
      
      public int j = print("j");
      {
          print("构造快");
      }
      
      static {
          print("静态块");
      }
      
      public T(String str) {
          System.out.println((++k) + ":" + str + "    i=" + i + "  n=" + n);
          ++n; ++ i;
      }
      
      public static int print(String str){
          System.out.println((++k) +":" + str + "   i=" + i + "   n=" + n);
          ++n;
          return ++ i;
      }
      
      public static void main(String[] args){
          T t = new T("init");
      }
    }
    

    分析

    代码主要考察的是类、变量初始化的顺序。

    一般的,我们很清楚类需要在被实例化之前初始化,而对象的初始化则是运行构造方法中的代码。

    本题的代码显然没有这么简单了。本题中涉及到了static {…} 和 {…}这种形式的代码块,以及在类的静态变量中初始化该类的对象这种交错的逻辑,容易让人焦躁(类似于密集恐惧症吧=()。实际上,按照类的装载、链接和初始化逻辑,以及对象初始化的顺序来思考,不难得到答案。

    代码组成

    • 成员变量 2~6 行的变量是 static 的,为类 T 的静态成员变量,需要在类加载的过程中被执行初始化;第 8 行的int j则为实例成员变量,只再类被实例化的过程中初始化。

    • 代码段 9~11 行为实例化的代码段,在类被实例化的过程中执行;13~15 行为静态的代码段,在类被加载、初始化的过程中执行。

    • 方法 方法public static int print(String str) 为静态方法,其实现中牵涉到 k,i,n 三个静态成员变量,实际上,这个方法是专门用来标记执行顺序的方法;T 的构造方法是个实例化方法,在 T 被实例化时调用。

    • main 方法 main 方法中实例化了一个 T 的实例。

    执行顺序分析

    在一个对象被使用之前,需要经历的过程有:类的装载 -> 链接(验证 -> 准备 -> 解析) -> 初始化 -> 对象实例化。(详情参见《Java 类的装载、链接和初始化》),这里需要注意的点主要有:

    • 在类链接之后,类初始化之前,实际上类已经可以被实例化了。

      就如此题代码中所述,在众多静态成员变量被初始化完成之前,已经有两个实例的初始化了。实际上,此时对类的实例化,除了无法正常使用类的静态承运变量以外(还没有保证完全被初始化),JVM 中已经加载了类的内存结构布局,只是没有执行初始化的过程。比如第 3 行public static T t1 = new T("t1");,在链接过程中,JVM 中已经存在了一个 t1,它的值为 null,还没有执行new T("t1")。又比如第 5 行的public static int i = print("i");,在没有执行初始化时,i 的值为 0.

    • 先执行成员变量自身初始化,后执行static {…}{…}代码块中的内容。

      如此策略的意义在于让代码块能处理成员变量相关的逻辑。如果不使用这种策略,而是相反先执行代码块,那么在执行代码块的过程中,成员变量并没有意义,代码块的执行也是多余。

    • 类实例化的过程中,先执行隐式的构造代码,再执行构造方法中的代码 这里隐式的构造代码包括了{}代码块中的代码,以及实例成员变量声明中的初始化代码,以及父类的对应的代码(还好本题中没有考察到父类这一继承关系,否则更复杂;))。为何不是先执行显示的构造方法中的代码,再执行隐式的代码呢?这也很容易解释:构造方法中可能就需要使用到实例成员变量,而这时候,我们是期待实例变量能正常使用的。

    有了如上的分析,也就能推到出最终的输出结果了。实际上,这几个原则都不需要死记硬背,完全能通过理解整个 JVM 的执行过程来梳理出思路的。

    答案

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    
    1:j   i=0   n=0
    2:构造快   i=1   n=1
    3:t1    i=2  n=2
    4:j   i=3   n=3
    5:构造快   i=4   n=4
    6:t2    i=5  n=5
    7:i   i=6   n=6
    8:静态块   i=7   n=99
    9:j   i=8   n=100
    10:构造快   i=9   n=101
    11:init    i=10  n=102
    

    参考:

    展开全文
  • java类的初始化顺序常会出现在java的笔试和面试中,本文将通过实践代码对java类的初始化顺序做个分析! 首先结论话语放前面,java类的初始化顺序依次如下: 1.父类静态成员和静态初始化快,按在代码中出现的顺序...

    java类的初始化顺序

    java类的初始化顺序常会出现在java的笔试和面试题中,本文将通过实践代码对java类的初始化顺序做个分析!

    首先结论话语放前面,java类的初始化顺序依次如下:

    1.父类静态成员和静态初始化快,按在代码中出现的顺序依次执行。
    2.子类静态成员和静态初始化块,按在代码中出现的顺序依次执行。
    3. 父类的实例成员和实例初始化块,按在代码中出现的顺序依次执行,且每创建一个对象就执行一次。
    4.执行父类的构造方法。
    5.子类实例成员和实例初始化块,按在代码中出现的顺序依次执行,且每创建一个对象就执行一次。
    6.执行子类的构造方法。

    演示实例1:

     

    public class ClassInitOrder {
    
    	public static void main(String[] args) {
    		Child c1 = new Child();
    		
    	}
    }
    
    class Father{
    	
    	static {
    		System.out.println("Father的static块……");
    	}
    	//初始化块
    
    	{
    		System.out.println("Father的初始化块……");
    	}
    	//构造方法
    	public Father(){
    		System.out.println("Father的构造方法被调用……");
    	}
    }
    
    class Child extends Father{
    	
    	static {
    		System.out.println("Child的static块……");
    	}
    	
            //初始化块
    	{
    		System.out.println("Child的初始化块……");
    	}
    	
            //构造方法
    	public Child(){
    		System.out.println("Child的构造方法被调用……");
    	}
    }

     

    程序结果:

    从结果可以看出,类在初始化的时候,顺序是:

    静态成员-->初始化块-->构造方法,然后按照这个顺序,父类与子类依次执行,即先父类的静态成员,再子类静态成员,接着父类初始化块,再子类初始化块,依此类推……

     

    演示实例2:

     

    public class ClassInitOrder {
    
    	public static void main(String[] args) {
    		Child c1 = new Child();
    		Child c2 = new Child();
    	}
    }
    
    
    class Child{
    	
    	static {
    		System.out.println("Child的static块……");
    	}
    	
    	{
    		System.out.println("Child的初始化块……");
    	}
    	
    	public Child(){
    		System.out.println("Child的构造方法被调用……");
    	}
    }

     

    程序结果:

    从结果可以看出,static块在在整个程序运行过程中,只执行一次,即static块是针对类的,不是针对对象的,static块或者说static的成员,在程序运行时第一次被访问的时候(该类的第一个对象被创建时)只初始化一次,之后不再执行;而初始化块是针对对象的,每创建一个对象,就执行一次。

     

    演示实例3:

     

    public class ClassInitOrder {
    
    	public static void main(String[] args) {
    		Child c1 = new Child();
    		
    	}
    }
    
    class Child{
    	static int a, b = 3;
    	
    	static {
    		a++;
    		System.out.println("a = " + a);
    	}
    	
    	static {
    		a = b;
    		System.out.println("a = " + a);
    	}
    	
    }


    结果:

     

    把两个static块位置换一下

     

    public class ClassInitOrder {
    
    	public static void main(String[] args) {
    		Child c1 = new Child();
    		
    	}
    }
    
    class Child{
    	static int a, b = 3;
    	
    	static {
    		a = b;
    		System.out.println("a = " + a);
    	}
    	
    	static {
    		a++;
    		System.out.println("a = " + a);
    	}
    	
    }


    结果:

     

    从结果可以看出,当类中存在多个static块或者static成员时,按照他们在程序中出现的顺序依次执行!

     

    希望对读者有帮助,转载请注明出处!

    展开全文
  • 就是父子类的初始化顺序,比如new一个子类的实例对象,我只知道先执行父类的静态代码和构造函数,在执行子类的静态代码和构造函数。至于,子类的静态代码先执行还是父类的构造函数先执行自己就搞不清楚了,至于成员...
  • Java程序初始化顺序

    2016-05-25 17:43:53
    Java程序的初始化顺序其他Java笔试面试题目: Java面试笔试试题积累(每天更新)在Java语言中,当实例化对象的时候,对象所在类的所有成员变量首先要进行初始化,当所有类成员完成初始化之后才会调用对象所在类的构造方法...
  • 就是父子类的初始化顺序,比如new一个子类的实例对象,我只知道先执行父类的静态代码和构造函数,在执行子类的静态代码和构造函数。至于,子类的静态代码先执行还是父类的构造函数先执行自己就搞不清楚了,至于成员...
  • Java类的加载顺序

    2021-01-21 17:09:58
    不过我们可以换个直接问法,如果A和B中有静态变量,静态语句块,非静态变量,非静态语句块,构造函数,静态方法,非静态方法,同时A继承B,请问当实例化A时,内部加载顺序是什么?  当时我也是一头...
  • 初始化顺序实例

    2014-08-14 11:32:45
    Java类实例的初始化顺序 看阿里巴巴一道笔试题如下: class T implements Cloneable{ public static int k = 0; public static T t1 = new T("t1"); public static T t2 = new T("t2&...
  • Java笔试题大汇总

    2010-01-09 22:46:49
    java运行时系统根据调用该方法的实例,来决定调用哪个方法。对子类的一个实例,如果子类重写了父类的方法,则运行时系统调用子类的方法;如果子类继承了父类的方法(未重写),则运行时系统调用父类的方法。 6 ...
  • 昨天参加了阿里的笔试,有一个选做,考了java类的各个成员的执行顺序,小结了一下,希望对大家有帮助   属性、方法、构造方法和自由块都是类中的成员,在创建对象时,各成员的执行顺序如下: (1)父类静态...
  • Java笔试真题】:构造方法、成员变量初始以及静态成员变量初始三者先后顺序是什么样? 【解答】: 当第一次被加载时候,静态变量会首先初始,接着编译器会把实例变量初始化为默认值,然后执行构造方法...
  • Java笔试真题】:构造方法、成员变量初始以及静态成员变量初始三者先后顺序是什么样? 【解答】:当第一次被加载时候,静态变量会首先初始,接着编译器会把实例变量初始化为默认值,然后执行构造方法...
  • java面试

    2019-05-26 22:46:48
    IT行业经典非技术面试汇总 ...java类的初始实例初始加载顺序 https://blog.csdn.net/qq_38815856/article/details/90107122 java最全的单例模式详解 https://blog.csdn.net/qq_3...
  • Android笔试面试整理

    2017-02-28 09:08:49
    Android笔试面试一、java基础篇1)类初始化的顺序,静态块与构造函数的调用顺序一个类的实例化过程: 1,首先会执行类中static代码块(不管代码块是否在类的开头还是末尾处),如果这个类有父类,同样会优先查找...
  • 1. 一道阿里的笔试题解析: /** * 加载方法不等于执行方法,初始化变量则会赋值 * 加载顺序应为 加载静态方法-初始化静态变量-执行静态代码块 * 实例化时 先加载非静态方法-实例化非静态变量-执行构造代码块-执行...
  • Java面试笔试资料大全

    热门讨论 2011-07-22 14:33:56
    74、什么是java序列,如何实现java序列?或者请解释Serializable接口作用。 51 75、描述一下JVM加载class文件原理机制? 52 76、heap和stack有什么区别。 52 77、GC是什么? 为什么要有GC? 52 78、垃圾回收...
  • 2.3.2 初始化顺序表 2.3.3 计算顺序表长度 2.3.4 插入结点 2.3.5 追加结点 2.3.6 删除结点 2.3.7 查找结点 2.3.8 显示所有结点 2.3.9 顺序表操作实例 2.4 链表结构 2.4.1 什么是链表结构 2.4.2 准备数据 2.4.3 追加...
  • 近期做牛客网的Java开发笔试题,发现这类型题目较多,很容易混淆,特将相关概念和相关示例整理如下,供大家参考^_^ 1. 静态代码块在加载时即运行,而且只运行一次,并且优先于各种代码块以及构造函数运行。如果...
  • 74、什么是java序列,如何实现java序列?或者请解释Serializable接口作用。 51 75、描述一下JVM加载class文件原理机制? 52 76、heap和stack有什么区别。 52 77、GC是什么? 为什么要有GC? 52 78、垃圾回收...
  • 工厂模式:工厂模式是一种经常被使用到的模式,根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例, 通常这一组类有一个公共的抽象父类并且实现了相同的方法,但是这些方法针对不同的数据进行了...
  • Java面试宝典2010版

    2013-12-19 19:32:29
    27、内部类可以引用它的包含类的成员吗?有没有什么限制?......................... 20 28、AnonymousInner Class (匿名内部类) 是否可以extends(继承)其它类,是否可以implements(实现)interface(接口)?............
  • JavaScript笔记

    2018-09-28 11:21:56
    D []--实例化一个空数组对象 实例化空数组:var arr=[]; 特点:元素个数不限定,元素类型不限制 13.Array 对象常用方法: |--1.join()方法--用于把数组中所有元素放入一个字符串 | eparato表示要使用...

空空如也

空空如也

1 2
收藏数 26
精华内容 10
关键字:

java类的实例化顺序笔试题

java 订阅