`
Arron.li
  • 浏览: 136209 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

JAVA面试题解惑系列(类的初始化顺序)

    博客分类:
  • Java
阅读更多

网址:http://zangweiren.iteye.com

大家在去参加面试的时候,经常会遇到这样的考题:给你两个类的代码,它们之间是继承的关系,每个类里只有构造器方法和一些变量,构造器里可能还有一段代码 对变量值进行了某种运算,另外还有一些将变量值输出到控制台的代码,然后让我们判断输出的结果。这实际上是在考查我们对于继承情况下类的初始化顺序的了 解。

我们大家都知道,对于静态变量、静态初始化块、变量、初始化块、构造器,它们的初始化顺序依次是(静态变量、静态初始化块)>(变量、初始化块)>构造器。我们也可以通过下面的测试代码来验证这一点:


  1. public   class  InitialOrderTest {  
  2.   
  3.     // 静态变量   
  4.     public   static  String staticField =  "静态变量" ;  
  5.     // 变量   
  6.     public  String field =  "变量" ;  
  7.   
  8.     // 静态初始化块   
  9.     static  {  
  10.         System.out.println(staticField);  
  11.         System.out.println("静态初始化块" );  
  12.     }  
  13.   
  14.     // 初始化块   
  15.     {  
  16.         System.out.println(field);  
  17.         System.out.println("初始化块" );  
  18.     }  
  19.   
  20.     // 构造器   
  21.     public  InitialOrderTest() {  
  22.         System.out.println("构造器" );  
  23.     }  
  24.   
  25.     public   static   void  main(String[] args) {  
  26.         new  InitialOrderTest();  
  27.     }  
  28. }  
public class InitialOrderTest {

	// 静态变量
	public static String staticField = "静态变量";
	// 变量
	public String field = "变量";

	// 静态初始化块
	static {
		System.out.println(staticField);
		System.out.println("静态初始化块");
	}

	// 初始化块
	{
		System.out.println(field);
		System.out.println("初始化块");
	}

	// 构造器
	public InitialOrderTest() {
		System.out.println("构造器");
	}

	public static void main(String[] args) {
		new InitialOrderTest();
	}
}


运行以上代码,我们会得到如下的输出结果:

  1. 静态变量
  2. 静态初始化块
  3. 变量
  4. 初始化块
  5. 构造器


这与上文中说的完全符合。那么对于继承情况下又会怎样呢?我们仍然以一段测试代码来获取最终结果:


  1. class  Parent {  
  2.     // 静态变量   
  3.     public   static  String p_StaticField =  "父类--静态变量" ;  
  4.     // 变量   
  5.     public  String p_Field =  "父类--变量" ;  
  6.   
  7.     // 静态初始化块   
  8.     static  {  
  9.         System.out.println(p_StaticField);  
  10.         System.out.println("父类--静态初始化块" );  
  11.     }  
  12.   
  13.     // 初始化块   
  14.     {  
  15.         System.out.println(p_Field);  
  16.         System.out.println("父类--初始化块" );  
  17.     }  
  18.   
  19.     // 构造器   
  20.     public  Parent() {  
  21.         System.out.println("父类--构造器" );  
  22.     }  
  23. }  
  24.   
  25. public   class  SubClass  extends  Parent {  
  26.     // 静态变量   
  27.     public   static  String s_StaticField =  "子类--静态变量" ;  
  28.     // 变量   
  29.     public  String s_Field =  "子类--变量" ;  
  30.     // 静态初始化块   
  31.     static  {  
  32.         System.out.println(s_StaticField);  
  33.         System.out.println("子类--静态初始化块" );  
  34.     }  
  35.     // 初始化块   
  36.     {  
  37.         System.out.println(s_Field);  
  38.         System.out.println("子类--初始化块" );  
  39.     }  
  40.   
  41.     // 构造器   
  42.     public  SubClass() {  
  43.         System.out.println("子类--构造器" );  
  44.     }  
  45.   
  46.     // 程序入口   
  47.     public   static   void  main(String[] args) {  
  48.         new  SubClass();  
  49.     }  
  50. }  
class Parent {
	// 静态变量
	public static String p_StaticField = "父类--静态变量";
	// 变量
	public String p_Field = "父类--变量";

	// 静态初始化块
	static {
		System.out.println(p_StaticField);
		System.out.println("父类--静态初始化块");
	}

	// 初始化块
	{
		System.out.println(p_Field);
		System.out.println("父类--初始化块");
	}

	// 构造器
	public Parent() {
		System.out.println("父类--构造器");
	}
}

public class SubClass extends Parent {
	// 静态变量
	public static String s_StaticField = "子类--静态变量";
	// 变量
	public String s_Field = "子类--变量";
	// 静态初始化块
	static {
		System.out.println(s_StaticField);
		System.out.println("子类--静态初始化块");
	}
	// 初始化块
	{
		System.out.println(s_Field);
		System.out.println("子类--初始化块");
	}

	// 构造器
	public SubClass() {
		System.out.println("子类--构造器");
	}

	// 程序入口
	public static void main(String[] args) {
		new SubClass();
	}
}


运行一下上面的代码,结果马上呈现在我们的眼前:

  1. 父类--静态变量
  2. 父类--静态初始化块
  3. 子类--静态变量
  4. 子类--静态初始化块
  5. 父类--变量
  6. 父类--初始化块
  7. 父类--构造器
  8. 子类--变量
  9. 子类--初始化块
  10. 子类--构造器


现在,结果已经不言自明了。大家可能会注意到一点,那就是,并不是父类完全初始化完毕后才进行子类的初始化,实际上子类的静态变量和静态初始化块的初始化是在父类的变量、初始化块和构造器初始化之前就完成了。

那么对于静态变量和静态初始化块之间、变量和初始化块之间的先后顺序又是怎样呢?是否静态变量总是先于静态初始化块,变量总是先于初始化块就被初始化了呢?实际上这取决于它们在类中出现的先后顺序。我们以静态变量和静态初始化块为例来进行说明。

同样,我们还是写一个类来进行测试:


  1. public   class  TestOrder {  
  2.     // 静态变量   
  3.     public   static  TestA a =  new  TestA();  
  4.       
  5.     // 静态初始化块   
  6.     static  {  
  7.         System.out.println("静态初始化块" );  
  8.     }  
  9.       
  10.     // 静态变量   
  11.     public   static  TestB b =  new  TestB();  
  12.   
  13.     public   static   void  main(String[] args) {  
  14.         new  TestOrder();  
  15.     }  
  16. }  
  17.   
  18. class  TestA {  
  19.     public  TestA() {  
  20.         System.out.println("Test--A" );  
  21.     }  
  22. }  
  23.   
  24. class  TestB {  
  25.     public  TestB() {  
  26.         System.out.println("Test--B" );  
  27.     }  
  28. }  
public class TestOrder {
	// 静态变量
	public static TestA a = new TestA();
	
	// 静态初始化块
	static {
		System.out.println("静态初始化块");
	}
	
	// 静态变量
	public static TestB b = new TestB();

	public static void main(String[] args) {
		new TestOrder();
	}
}

class TestA {
	public TestA() {
		System.out.println("Test--A");
	}
}

class TestB {
	public TestB() {
		System.out.println("Test--B");
	}
}


运行上面的代码,会得到如下的结果:

  1. Test--A
  2. 静态初始化块
  3. Test--B


大家可以随意改变变量a、变量b以及静态初始化块的前后位置,就会发现输出结果随着它们在类中出现的前后顺序而改变,这就说明静态变量和静态初始化块是依照他们在类中的定义顺序进行初始化的。同样,变量和初始化块也遵循这个规律。

了解了继承情况下类的初始化顺序之后,如何判断最终输出结果就迎刃而解了。

分享到:
评论

相关推荐

    臧圩人--JAVA面试题解惑系列合集.pdf

    **1.1 JAVA面试题解惑系列(一)——类的初始化顺序** - **知识点**:类的初始化顺序涉及静态变量、静态初始化块、实例变量、实例初始化块及构造器的执行顺序。在继承关系中,父类的初始化先于子类进行,且静态部分...

    JAVA面试题解惑系列类的初始化顺序JAVA程序员JAVA工程师面试必看.pdf

    理解这个初始化顺序对解决面试题和编写可靠的代码至关重要。在实际编程中,我们有时需要依赖这种初始化顺序来确保数据的正确初始化,特别是在处理复杂的继承结构和多线程场景时。因此,熟练掌握类初始化顺序是每个...

    JAVA面试题解惑系列——类的初始化顺序

    总结来说,对于Java面试中常出现的关于类初始化顺序的问题,开发者应当掌握以下几点: 1. 单个类内成员的初始化顺序:静态变量、静态初始化块、变量、初始化块、构造器。 2. 在继承关系中,子类的静态成员会在父类...

    JAVA面试题解惑系列合集

    《JAVA面试题解惑系列合集》这篇文章详细地讨论了Java面试中常见的一些知识点和问题。它包括了从类的初始化顺序、String对象的创建数量、变量的覆盖、final关键字、传值和传引用的区别、字符串的处理、日期和时间的...

    JAVA面试题解惑系列(一)——类的初始化顺序-JAVA程序员JAVA工程师面试必看.pdf,这是一份不错的文件

    JAVA面试题解惑系列(一)——类的初始化顺序 JAVA 是一门面向对象的编程语言,类的初始化顺序是 JAVA 程序员和 JAVA 工程师面试中一个非常重要的知识点。本文将详细讲解类的初始化顺序,并提供了相关的测试代码,...

    JAVA面试题解惑系列

    ### JAVA面试题解惑系列:类的初始化顺序详解 在JAVA面试中,考察候选人对类初始化顺序的理解是一项常见且重要的环节。本篇文章旨在深入解析这一主题,帮助读者掌握类初始化的详细过程,尤其是在继承关系中的类如何...

    Java面试题解惑系列

    来自网络,主要包括以下内容:1、类初始化的顺序;2、到底创建了几个String对象;3、变量(属性)的覆盖;4、final,finally,finalize;5.传了值还是传了引用;6.String杂谈;7.日期与时间的处理;8.基本类型总结;9....

    JAVA面试题解惑系列.doc

    《JAVA面试题解惑系列——类的初始化顺序》 在Java编程中,理解类的初始化顺序是面试中常见的考察点,因为它直接关系到程序的执行逻辑。本文将深入探讨类的初始化过程,以及在继承场景下如何理解这个过程。 首先,...

    JAVA面试题解惑系列.docx

    JAVA面试题解惑系列 在 Java 中,类的初始化顺序是一个经常被问到的面试题。 nhiều 开发者可能会混淆类的初始化顺序,特别是在继承的情况下。下面我们来探讨一下类的初始化顺序。 首先,让我们看一下类的初始化...

    JAVA面试题解惑系列(一)——类的初始化顺序-JAVA程序员JAVA工程师面试必看.pdf

    "子类--构造器"); } public static void main(String[] args) { new SubClass(); } } 当我们运行这段代码时,会看到以下输出...所以,对于Java程序员和工程师来说,掌握类的初始化顺序是非常基础且重要的知识点。

    经典JAVA面试题解惑系列合集

    JAVA面试题解惑系列(一)——类的初始化顺序 在Java编程语言中,理解类的初始化顺序是非常重要的,尤其是在涉及继承的情况下。本节将详细介绍类初始化的规则,并通过实例来帮助理解。 ##### 类的初始化顺序规则 ...

Global site tag (gtag.js) - Google Analytics