首页 > 试题广场 >

给出下列JAVA程序执行结果: &nbs...

[单选题]
给出下列JAVA程序执行结果:       
public class Test {

 public static Test t1=new Test();  

  {  
   System.out.println("blockA");  
  }  
  
  static {  
   System.out.println("blockB");  
  } 
  
  public static void main(String[] args){  
   Test t2=new Test();       
  }    
 }
  • blockA,blockB,blockA
  • blockB,blockA,blockA
  • blockA,blockB
  • blockB,blockA
为啥不是B
发表于 2019-08-23 00:46:02 回复(0)
创建类的静态变量和实例变量都会触发类加载。类加载时静态代码块只加载一次。在运行 Test t2=new Test();  时创建实例变量 触发类加载,在加载该类时 public static Test t1=new Test();   创建类静态变量 触发类加载。首先执行public static Test t1=new Test(); 打印blockA blockB.
后执行 Test t2=new Test();  打印blockA 

发表于 2019-05-15 17:31:11 回复(3)
代码块->构造方法->静态代码块,其中静态代码块只会执行一次
public class Main {

 public static Main t1=new Main();
 

  {  
   System.out.println("blockA");  
  }  
  static {  
	   System.out.println("blockB");  
	  } 
  
   Main(){
	   System.out.println("BlockC");
   }
  
  
  public static void main(String[] args){  
	  Main t2=new Main(); 
	  System.out.println();
	  Main t3=new Main(); 
  }    
 }
输出结果为:
blockA
BlockC
blockB
blockA
BlockC

blockA
BlockC

发表于 2019-09-03 21:40:50 回复(4)
执行main方法导致类的初始化:
1.先初始化静态变量 t1=new Test() -> blockA
2.静态代码块  -> blockB
最后Test t2=new Test();       ->blockA
发表于 2020-02-24 22:49:47 回复(0)
Test t2=new Test(); 时,触发类加载
类加载过程中,遇到了静态变量public static Test t1=new Test();
所以先进行类初始化,执行普通代码块和构造函数,这是只有普通代码块,执行了普通代码块
类初始化完成后继续类加载过程,执行静态代码块
然后进行t2的类初始化,执行普通代码块和构造函数,这里只有普通方法,加载了普通方法代码块
注意,在类中如果没有类初始化,则加载流程 静态代码块>普通代码块>构造函数

package structproject;

class T {
	static T t = new T();
	public T() {
		System.out.println("structure");
	}
	{
		System.out.println("common code!");
	}
	static {
		System.out.println("static code!");
	}
	
}
public class CTest {
	public static void main(String[] args) {
		T t = new T();
	}
}


输出
common code!
structure
static code!
common code!
structure

先执行类中初始化
common code!
structure
继续完成类加载
static code!
继续类初始化
common code!
structure
发表于 2020-01-30 09:52:43 回复(0)
本来我也很迷惑为什么不选B,后来自己试验了一下就懂了,静态代码块和静态变量是同级别的,谁写在前面,就先执行谁,题目中是先初始化静态变量
public class test {


    static {
        System.out.println("blockB");
    }
    public static test t1=new test();
    
    {
        System.out.println("blockA");
    }
    

    public static void main(String[] args){
        System.out.println("进入主方法");
        test t2=new test();
    }
}
输出:
blockB
blockA
进入主方法
blockA

原题目如下:
public class test {

    public static test t1=new test();
    
    static {
        System.out.println("blockB");
    }
    
    {
        System.out.println("blockA");
    }

    public static void main(String[] args){
        System.out.println("进入主方法");
        test t2=new test();
    }
}
输出:
blockA
blockB
进入主方法
blockA


发表于 2020-03-31 16:29:21 回复(0)
先执行代码块,后执行构造方法,后执行静态代码块。
发表于 2021-03-18 16:52:58 回复(0)
你说神奇不神奇




编辑于 2020-03-31 18:27:48 回复(0)
应该是B啊 静态代码块在加载的解剖阶段就执行了
发表于 2019-10-09 15:59:55 回复(0)
先静态成员变量
发表于 2019-09-20 17:11:44 回复(0)
加载类时,static按顺序执行,所以先遇到 public static Test t1=new Test();  而这个实例就要执行普通代码块,即blockA;然后继续遇到static初始代码块并执行,即blockb;然后遇到public static void main,执行 Test t2=new Test();  这时,前面的两个static已经执行了,不用再执行,只用执行普通初始代码块,即blocka。综上,正确顺序是ABA
发表于 2019-09-04 16:37:58 回复(0)
加载类的时候,触发了创建test2静态对象,但是创建对象前需要先加载代码块才行,所以先执行代码块,静态对象加载完成,之后加载静态代码块。所以是aba
发表于 2019-09-02 19:28:38 回复(0)

整体分两步:1,加载类。
                          如果类中有静态修饰部分,则静态部分按顺序执行。此步执行结果AB
                     2、调用构造方法/构造代码块,执行结果A
发表于 2019-08-29 15:19:31 回复(0)
为什么blockA不会输出三次?Test的代码块执行了几次?
发表于 2019-05-22 21:17:39 回复(0)
(转)执行顺序:
    第一步,准备加载类
    第二步,静态变量和静态代码块的加载顺序由编写先后决定
    第三步,静态块,然后执行静态代码块
    第四步,new一个类,但在new之前要处理匿名代码块
    第五步,按照顺序加载匿名代码块和类的变量
    第六步,最后加载构造函数,完成对象的建立
    静态方法,调用的时候才加载
上面的题目:先处理静态变量,变量new了Test对象,new对象的时候先加载匿名代码块,所以这样是把new对象执行匿名代码块的过程提前到静态块之前了?
发表于 2019-05-17 09:44:43 回复(4)