关于static初始化的小例子

最新推荐文章于 2022-07-14 18:10:58 发布

夏了夏天c

最新推荐文章于 2022-07-14 18:10:58 发布

阅读量996

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/m1111121/article/details/8811757

版权

Java 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

 public class a {
	 int m=print("qqqqqqqq");
	 static int q=print("qwertyu");
	 static int print(String s){
		System.out.println(s);
		return 12;}
	public static void main(String[] args){
		//a aa=new a();
	}
}

class SelfCounter {

private static int count; //1
private int id = count++; //2
public String toString() {
return "SelfCounter " + id;//3 }
}
class WithFinalFields {
final SelfCounter scf = new SelfCounter(); //4
static final SelfCounter scsf = new SelfCounter(); //5
public String toString() {
return "scf = " + scf + "\nscsf = " + scsf; //6
}
}
public class a {
public static void main(String args[]) {
System.out.println("First object:");
System.out.println(new WithFinalFields());
System.out.println("Second object:");
System.out.println(new WithFinalFields()); }
}

结果： First object:

scf =SelfCounter 1

scsf =SelfCounter 0

Second object:

scf =SelfCounter 2

scsf =SelfCounter 0

分析：1、执行System.out.println(new WithFinalFields()); 会初始化 WithFinalFields类，首先执行static final SelfCounter scsf = new SelfCounter();初始化 SelfCounter类，count=0；id=0，count变为1；

再执行final SelfCounter scf = new SelfCounter();再初始SelfCounter类，；id=1，count变为2（静态变量只初始化一次）；

执行 WithFinalFields类的 toString方法，调用 SelfCounter的toString方法两次，分别输出scf =SelfCounter 1（初始化scf时，id=1），scsf =SelfCounter 0（初始化scsf时，id=0），因为scf和scsf对象拥有不同的内存存储变量，所以它们的变量互不影响，不会叠加覆盖。

2、再次执行 System.out.println(new WithFinalFields()); 初始化 WithFinalFields类，只会初始化final SelfCounter scf = new SelfCounter();不再初始化static final SelfCounter scsf = new SelfCounter();（静态对象只会初始化一次），初始化 SelfCounter类；id=2，count变为3；

执行 WithFinalFields类的 toString方法，调用 SelfCounter的toString方法两次，分别输出scf =SelfCounter 2（初始化scf时，id=2），scsf =SelfCounter 0（只初始化一次初始化scsf，id=0）。

为了便于大家了解，可以看下面的例子：

class SelfCounter {
private static int count = 0;
private int id = count++;
public SelfCounter(String type){
System.out.println(count+"：count的值");
System.out.println(type+"：type");//判断是先执行了谁
System.out.println(id+"：id的值");
}
public String toString() {
return "SelfCounter " + id;
}
}

class WithFinalFields {
final SelfCounter scf = new SelfCounter("scf");
static final SelfCounter scsf = new SelfCounter("scsf"); //static 只初始化一次而且是最先初始化的不会再执行第二次了
public String toString() {
return "scf = " + scf + "\n"+
"scsf = " + scsf;
}
}

public class Test19 {
public static void main(String args[]) {
System.out.println("First object:");
System.out.println(new WithFinalFields()+"\n");
System.out.println("Second object:");
System.out.println(new WithFinalFields());
}
}

/**
* 执行后的结果
* First object:
1：count的值
scsf：type
0：id的值
2：count的值
scf：type
1：id的值
scf = SelfCounter 1
scsf = SelfCounter 0

Second object:
3：count的值
scf：type
2：id的值
scf = SelfCounter 2
scsf = SelfCounter 0
*/

继承与初始化

 class Insect { 
	  int i = 9; 
	  int j; 
	  Insect() { 
	    prt("i = " + i + ", j = " + j); 
	    j = 39; 
	  } 
	  static int x1 =  
	    prt("static Insect.x1 initialized"); 
	  static int prt(String s) { 
	    System.out.println(s); 
	    return 47; 
	  } 
	} 
	 
	 
	public class Beetle extends Insect { 
	  int k = prt("Beetle.k initialized"); 
	  Beetle() { 
	    prt("k = " + k); 
	    prt("j = " + j); 
	  } 
	  static int x2 = 
	    prt("static Beetle.x2 initialized"); 
	  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

分析：先初始化基类，初始化其静态变量x1，输出static Insect.x initialized （注意：构造器是不初始化的，除非是new了个对象）；初始化子类静态变量x2，输出static Beetle.x initialized（注意：构造器是不初始化的，除非是new了个对象），初始化结束，执行程序，输出Beetle constructor ，执行Beetle b = new Beetle()时，先挨个初始化基类变量或者对象（静态的初试过了，不再初始化了），最后调用基类的构造器，输出i = 9, j = 0 ，回到子类，挨个初始化子类变量或者对象，初始化变量k，输出Beetleconstructor （静态的初试过了，不再初始化了），最后调用子类构造器，输出k = 63 j = 39 。

比较这两个例子：

 public class a {
	 int m=print("new一个对象才会初始化我");
	 static int q=print("总会初始化我");
	 static int print(String s){
		System.out.println(s);
		return 12;}
	public static void main(String[] args){
		a aa=new a();
	}
}

结果： new一个对象才会初始化我

总会初始化我

 public class a {
	 int m=print("new一个对象才会初始化我");
	 static int q=print("总会初始化我");
	 static int print(String s){
		System.out.println(s);
		return 12;}
	public static void main(String[] args){
		//a aa=new a();
	}
}

结果：总会初始化我

综合分析：只有在new一个对象时，才会按顺序执行初始化（先静态后非静态），不然的话非静态是不会初始化的，静态是总会初始化的。

类似的例子

class  Animal { 
	 	  int i = 9; 
	  int j; 
	  int k = prt("Animal.k initialized");
	  Animal() { 
	    prt("i = " + i + ", j = " + j); 
	    j = 39; 
	  } 
	  static int x1 =  
	    prt("static IAnimal.x1 initialized"); 
	  static int prt(String s) { 
	    System.out.println(s); 
	    return 47; 
	  } 
	} 

 class Insect extends Animal { 
	 	  int i = 9; 
	  int j; 
	  int k = prt("Insect.k initialized");
	  Insect() { 
	    prt("i = " + i + ", j = " + j); 
	    j = 39; 
	  } 
	  static int x1 =  
	    prt("static Insect.x1 initialized"); 
	  static int prt(String s) { 
	    System.out.println(s); 
	    return 47; 
	  } 
	} 
	 
	
	public class a extends Insect { 
	  int k = prt("Beetle.k initialized"); 
	  a() { 
	    prt("k = " + k); 
	    prt("j = " + j); 
	  } 
	  static int x2 = 
	    prt("static Beetle.x2 initialized"); 
	  static int prt(String s) { 
	    System.out.println(s); 
	    return 63; 
	  } 
	  public static void main(String[] args) { 
	    prt("Beetle constructor"); 
	   // a b = new a(); 
	  } 
	}

结果：static IAnimal.x1 initialized
static Insect.x1 initialized
static Beetle.x2 initialized
Beetle constructor

class  Animal { 
	 	  int i = 9; 
	  int j; 
	  int k = prt("Animal.k initialized");
	  Animal() { 
	    prt("i = " + i + ", j = " + j); 
	    j = 39; 
	  } 
	  static int x1 =  
	    prt("static IAnimal.x1 initialized"); 
	  static int prt(String s) { 
	    System.out.println(s); 
	    return 47; 
	  } 
	} 

 class Insect extends Animal { 
	 	  int i = 9; 
	  int j; 
	  int k = prt("Insect.k initialized");
	  Insect() { 
	    prt("i = " + i + ", j = " + j); 
	    j = 39; 
	  } 
	  static int x1 =  
	    prt("static Insect.x1 initialized"); 
	  static int prt(String s) { 
	    System.out.println(s); 
	    return 47; 
	  } 
	} 
	 
	
	public class a extends Insect { 
	  int k = prt("Beetle.k initialized"); 
	  a() { 
	    prt("k = " + k); 
	    prt("j = " + j); 
	  } 
	  static int x2 = 
	    prt("static Beetle.x2 initialized"); 
	  static int prt(String s) { 
	    System.out.println(s); 
	    return 63; 
	  } 
	  public static void main(String[] args) { 
	    prt("Beetle constructor"); 
	     a b = new a(); 
	  } 
	}

结果：static IAnimal.x1 initialized
static Insect.x1 initialized
static Beetle.x2 initialized
Beetle constructor
Animal.k initialized
i = 9, j = 0
Insect.k initialized
i = 9, j = 0
Beetle.k initialized
k = 63
j = 39

夏了夏天c

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
关于static初始化的小例子

public class a { int m=print("qqqqqqqq"); static int q=print("qwertyu"); static int print(String s){ System.out.println(s); return 12;} public static void main(String[] args){ //a aa=new
复制链接

扫一扫