初始化块_静态初始化块 - CSDN
精华内容
参与话题
  • Java初始化块

    千次阅读 多人点赞 2018-03-26 13:22:52
    初始化块分为静态初始化块和普通初始化块。其好处是减少多个构造器内重用的代码;特点:一:public class TestInit1 { public static void main(String[] args) { System.out.println((int)(Math.random()*40+1...

    代码初始化块是类的成员之一,每次类的创建会隐式的调用它。本质上是一个代码块,或方法体。

    初始化块分为静态初始化块和普通初始化块。其好处是减少多个构造器内重用的代码;

    特点:

    一:

    public class TestInit1 {
    	
    	public static void main(String[] args) {
    		System.out.println((int)(Math.random()*40+1));
    		System.out.println(InitDemo1.a);//加载类
    		new InitDemo1();
    	}
    }
    class InitDemo1{
    	static int a =100;
    	{
    		System.out.println("我是普通初始化块");
    	}
    	static{
    		System.out.println("我是静态初始化块");
    	}
    }


    普通初始化块:创建对象时隐式调用

    静态初始化块:类加载时隐式调用


    二:

    public class TestInit2 {
    	public static void main(String[] args) {
    		new InitDemo2();
    		new InitDemo2();
    		new InitDemo2();
    		new InitDemo2();
    		new InitDemo2();
    	}
    }
    class InitDemo2{
    	static int a =100;
    	{
    		System.out.println("我是普通初始化块");
    	}
    	static{
    		System.out.println("我是静态初始化块");
    	}
    }


    静态初始化块只调用一次(类加载时),而普通初始化块可以调用多次,随着对象的创建而加载


    三:

    public class TestInit3 {
    	public static void main(String[] args) {
    		new InitDemo3();//加载+创建对象
    	}
    }
    class InitDemo3{
    	{
    		System.out.println("我是普通初始化块1");
    	}
    	static{
    		System.out.println("我是静态初始化块1");
    	}
    	{
    		System.out.println("我是普通初始化块2");
    	}
    	{
    		System.out.println("我是普通初始化块3");
    	}
    	static{
    		System.out.println("我是静态初始化块2");
    	}
    	static{
    		System.out.println("我是静态初始化块3");
    	}
    }

    一个类中可以有多个静态初始化块和多个普通初始化块;静态初始化块的执行要早于普通初始化块;同一个类型的初始化块的执行顺序取决于定义的先后顺序!


    四:

    public class TestInit4 {
    	public static void main(String[] args) {
    		InitDemo4 id = new InitDemo4();
    	}
    }
    class InitDemo4{
    	public InitDemo4(){
    		System.out.println("我是构造器");
    	}
    	String a=msg("普通属性初始化1");
    	public static String msg(String info){
    		System.out.println(info);
    		return info;
    	}
    	static{
    		System.out.println("静态初始化块2");
    	}
    	static String b=msg("静态属性初始化1");
    	{
    		System.out.println("我是普通初始化块1");
    	}
    	String c=msg("普通属性初始化2");
    	{
    		System.out.println("我是普通初始化块2");
    	}
    	static String d=msg("静态属性初始化2");
    	static{
    		System.out.println("静态初始化块1");
    	}
    }

    在一个类中如果有多个不同的初始化块,初始化属性,构造器,

    执行顺序是:静态初始化块|静态属性初始化 > 普通初始化块|普通属性初始化 > 构造器


    五:

    public class TestInit5 {
    	public static void main(String[] args) {
    		InitDemo5 id = new InitDemo5();
    	}
    }
    
    class Grand {
    	public Grand() {
    		System.out.println("我是爷爷类的构造器");
    	}
    
    	String a = fun("爷爷类的普通属性初始化");
    
    	public static String fun(String info) {
    		System.out.println(info);
    		return info;
    	}
    
    	static {
    		System.out.println("爷爷类的静态代码块");
    	}
    	{
    		System.out.println("爷爷类的普通代码块");
    	}
    	static String d = fun("爷爷类的静态属性初始化");
    }
    
    class Father extends Grand {
    	public Father() {
    		System.out.println("我是爷爷类的构造器");
    		System.out.println("我是父类的构造器");
    	}
    
    	String a = method("父类的普通属性初始化");
    
    	public static String method(String info) {
    		System.out.println(info);
    		return info;
    	}
    
    	static {
    		System.out.println("父类的静态代码块");
    	}
    	{
    		System.out.println("父类的普通代码块");
    	}
    	static String d = method("父类的静态属性初始化");
    }
    
    class InitDemo5 extends Father {
    	public InitDemo5() {
    		System.out.println("我是子类的构造器");
    	}
    
    	String a = msg("子类的普通属性初始化");
    
    	public static String msg(String info) {
    		System.out.println(info);
    		return info;
    	}
    
    	static {
    		System.out.println("子类的静态代码块");
    	}
    	{
    		System.out.println("子类的普通代码块");
    	}
    	static String d = msg("子类的静态属性初始化");
    }

    在父子类中,执行顺序是:

    爷爷类的静态初始化块|静态属性初始化>
    父类静态初始化块|静态属性初始化>

    子类静态初始化块|静态属性初始化>

    爷爷类普通初始化块|普通属性初始化>构造器>
    父类普通初始化块|普通属性初始化>构造器>
    子类普通初始化块|普通属性初始化>构造器



    六:静态初始化块中遵循静态成员的特点,只能直接访问静态成员!也就是在静态初始化块只能修改静态成员。

    题->

    class A{
    	final int x;
    	final static  int y;
    	public A(){
    		y=10;
    		x=100;//×
    	}
    	{
    		x=100;
    		y=10;//×
    	}
    }
    普通初始化块只能初始化普通的变量,普通的构造器也只能初始化普通的变量。


    展开全文
  • 初始化块

    2019-06-09 19:19:26
    初始化块 开发工具与关键技术:MyEclipse 10、java 作者:陈智鸿 撰写时间:2019-06-08 初始化块根据是否使用static修饰分为两类: 1.不使用static修饰的是初始化块 初始化块相当于是对构造器的补充,用于创建对象时...

    初始化块

    开发工具与关键技术:MyEclipse 10、java
    作者:陈智鸿
    撰写时间:2019-06-08

    初始化块根据是否使用static修饰分为两类:
    1.不使用static修饰的是初始化块
    初始化块相当于是对构造器的补充,用于创建对象时给对象的初始化,在构 造器之前执行 如果一段初始化代码对所有构造器完全相同,且无需接收参数,那就可以将 其提取到非静态初始化代码块中 实际上,经过编译后,非静态块已经添加到构造器中,且位于所有构造器代码的前面。
    2.使用static修饰的是静态初始化块
    静态初始化块用static修饰,又叫类初始化块。静态初始化块负责对类进行初始化,因此类初始化块是在类初始化阶段就执行静态块跟静态方法一样,不能访问非静态成员因为静态块是在类的初始化阶段完成的,因此在创建某个类的第二个对象时,该类的静态块就不会执行了
    一、单个类中初始化块、静态初始化块、构造器的执行顺序 在单个类中,静态初始化块(多个时从上往下执行),初始化块(多个时从上往下执行),构造器。
    示例代码:

    public class ClassTest {
    	public static void main(String[] args) {
    		Class1 class1 = new Class1();
    	}
    }
    
    class Class1{
    	
    	//构造器
    	public Class1(){
    		System.out.println("Class1构造器");
    	}
    	
    	//初始化块
    	{
    		System.out.println("Class1初始化块1");
    	}
    	{
    		System.out.println("Class1初始化块2");
    	}
    	
    	//静态初始化块
    	static{
    		System.out.println("Class1静态初始化块1");
    	}
    	static{
    		System.out.println("Class1静态初始化块2");
    	}
    }
    

    运行结果截图:
    在这里插入图片描述
    二、多个类的继承中初始化块、静态初始化块、构造器的执行顺序。
    在继承中,先执行父类的静态块,在执行子类的静态块,然后,再执行父类的非静态块和构造器,在执行子 类的非静态块和构造器。如果子类还有被继承在执行被继承的子类,以此类推
    示例代码和上面的差不多,只是多增了两个类,和多调用了两个类,类的内容基本一致。

    public class ClassTest {
    	public static void main(String[] args) {
    		Class1 class1 = new Class1();
    		Class2 class2 = new Class2();
    		Class3 class3 = new Class3();
    	}
    }
    
    class Class1{
    	
    	//构造器
    	public Class1(){
    		System.out.println("Class1构造器");
    	}
    	
    	//初始化块
    	{
    		System.out.println("Class1初始化块1");
    	}
    	{
    		System.out.println("Class1初始化块2");
    	}
    	
    	//静态初始化块
    	static{
    		System.out.println("Class1静态初始化块1");
    	}
    	static{
    		System.out.println("Class1静态初始化块2");
    	}
    }
    
    class Class2{
    	//构造器
    	public Class2(){
    		System.out.println("Class2构造器");
    	}
    	
    	//初始化块
    	{
    		System.out.println("Class2初始化块1");
    	}
    	{
    		System.out.println("Class2初始化块2");
    	}
    	
    	//静态初始化块
    	static{
    		System.out.println("Class2静态初始化块1");
    	}
    	static{
    		System.out.println("Class2静态初始化块2");
    	}
    }
    
    class Class3{
    	//构造器
    	public Class3(){
    		System.out.println("Class3构造器");
    	}
    	
    	//初始化块
    	{
    		System.out.println("Class3初始化块1");
    	}
    	{
    		System.out.println("Class3初始化块2");
    	}
    	
    	//静态初始化块
    	static{
    		System.out.println("Class3静态初始化块1");
    	}
    	static{
    		System.out.println("Class3静态初始化块2");
    	}
    }
    

    运行结果截图:
    在这里插入图片描述

    展开全文
  • JAVA初始化块

    2019-03-05 22:53:34
    作用于构造器基本相同,但优先级更高(在执行构造器代码前执行) 语法: 修饰符 ...假设一个类中有两个构造器,这两个构造器中有相同的代码,我们就可以把相同的代码提取出来,加到初始化块中,这样...

    作用于构造器基本相同,但优先级更高(在执行构造器代码前执行)
    语法:

    修饰符
    {
    	可执行语句;
    }
    

    一个例子:

    class a
    {
    	int a;
    	{
    		a = 5;
    	}
    }
    

    修饰符只能是static(静态初始化块)或省略。由于初始化块没有名字,所以只能被隐式地执行。
    实例初始化块执行时机:
    假设一个类中有两个构造器,这两个构造器中有相同的代码,我们就可以把相同的代码提取出来,加到初始化块中,这样以后修改程序时修改一个地方即可,并且初始化块会在调用构造器前执行。因此逻辑上位于构造器前部的并且无需传入参数的代码可以放在初始化块中。
    Java允许创建多个初始化块,但没什么意义 。
    定义field时赋值和初始化块中的赋值优先级关系:
    JDK编译器会把“初始块的代码”和“field声明时的赋值代码”都提取到构造器中执行,因此只需要看field声明赋值语句和代码块的先后关系,后面的会覆盖前面的赋值语句。可以用javap -c 类名查看先后关系,一目了然。

    静态初始化块执行时机:
    负责对类初始化,类被加载后初始化类时就会执行。JVM只会对一个类初始化一次,因此静态初始化块只会执行一次。
    static field声明时赋值和静态初始化块中的赋值语句与实例初始化块的情形相同,在前面的赋值语句会被后面的覆盖掉。

    初始化类的时机:
    1.访问了类的静态方法或field。
    2.初始化了改类的子类。
    3.反射Class.forName(类名字符串)
    4.该类作为主类使用,即有main方法且程序确实从此处开始执行。
    5.创建了类的对象。
    6.这种情况不会初始化类:

    Apple a;
    

    以上代码不会初始化Apple类。

    展开全文
  • 在Java中,有两种初始化块:静态初始化块和非静态初始化块.静态初始化块:使用static定义,当类装载到系统时执行一次.若在静态初始化块中想初始化变量,那仅能初始化类变量,即static修饰的数据成员.非静态初始化块:在每个...

    http://www.cnblogs.com/woshijpf/articles/3632489.html

     

    在Java中,有两种初始化块:静态初始化块和非静态初始化块.

    静态初始化块:使用static定义,当类装载到系统时执行一次.若在静态初始化块中想初始化变量,那仅能初始化类变量,即static修饰的数据成员.
    非静态初始化块:在每个对象生成时都会被执行一次,可以初始化类的实例变量.

    非静态初始化块会在构造函数执行时,且在构造函数主体代码执行之前被运行.

    括号里的是初始化块,这里面的代码在创建java对象时执行,而且在构造器之前执行!

    其实初始化块就是构造器的补充,初始化块是不能接收任何参数的,定义的一些所有对象共有的属性、方法等内容时就可以用初始化块了初始化!!

    好处是可以提高初始化块的复用,提高整个应用的可维护性。--《疯狂java讲义》

     

     

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

     

     

    运行结果:

    程序的运行结果为:
    父类--静态变量
    父类--静态初始化块
    子类--静态变量
    子类--静态初始化块
    父类--变量
    父类--初始化块
    父类--构造器
    -------------------
    父类--变量
    父类--初始化块
    父类--构造器
    子类--变量
    子类--初始化块
    子类--构造器
    -------------------
    父类--变量
    父类--初始化块
    父类--构造器
    子类--变量
    子类--初始化块
    子类--构造器

     

    分析:

    父类--静态变量 
    父类--静态初始化块 
    子类--静态变量 
    子类--静态初始化块 
    首先java虚拟机加载这两个类,静态块(类块)执行(只执行一次),随后如果产生实例就执行变量块(实例块),再构造方法


     如果在Parent类中

    public static void main(String[] args) {
    Parent p;
    }
    执行:
    结果:
    父类--静态变量
    父类--静态初始化块

    如果在Parent类中
    public static void main(String[] args) {
        new Parent();
    }


    父类--静态变量
    父类--静态初始化块
    父类--变量
    父类--初始化块
    父类--构造器

    若果在SubClass中
    public static void main(String[] args) { 
          new Parent(); 
    }    
    执行:
    结果:因为Java虚拟机加载了两个类(main方法在子类中执行)没有产生子类
    父类--静态变量
    父类--静态初始化块
    子类--静态变量
    子类--静态初始化块
    父类--变量
    父类--初始化块
    父类--构造器

    在Subclass类中
     public static void main(String[] args) { 
          new Parent(); 
        System.out.println("-------------------"); 
          new SubClass(); 
         
        }    
    执行
    结果:new子类首先执行父类的实例块和父类的构造方法,然后是子类的实例块和构造方法

    父类--静态变量
    父类--静态初始化块
    子类--静态变量
    子类--静态初始化块
    父类--变量
    父类--初始化块
    父类--构造器
    -------------------
    父类--变量
    父类--初始化块
    父类--构造器
    子类--变量
    子类--初始化块
    子类--构造器

    展开全文
  •     ...与构造器作用非常类似的是初始化块,它也可以对Java对象进行初始化操作。 初始化块      &nbsp...
  • 初始化块与静态初始化块

    千次阅读 2017-06-13 17:03:29
    1、初始化块(构造代码块): (1)作用:给对象进行初始化。对象一建立就运行,且优先于构造函数的运行。 (2)与构造函数的区别:初始化块给所有对象进行统一初始化,构造函数只给对应对象初始化。是Java在创建...
  • java静态初始化块、实例初始化块

    千次阅读 2017-12-02 14:19:41
    public class Demo1 { public Demo1() { System.out.println("父类... System.out.println("父类静态初始化块"); } { System.out.println("父类实例初始化块"); } public void method() { System.out.prin
  • 1. 初始化块:  1) 在类中可以定义和方法平行的代码块,例如:public class A { { /* 初始化块 */ } ... },即直接用花括号括起来的代码块;  2) 这种代码块就是初始化代码块,用于给数据成员初始化,里面可以调用...
  • 我们大家都知道,对于静态变量、静态初始化块、变量、初始化块、构造器,它们的初始化顺序以此是(静态变量、静态初始化块)>(变量、初始化块)>构造器。我们也可以通过下面的测试代码来验证这一点:  Java代码 ...
  • java基础-延伸,变量的初始化顺序从这篇文章java基础-反射1(类型信息,Class对象简介,Class对象初始化) 我们可以了解到类在第一次使用时类加载到内存中的顺序有三个步骤 类的加载:由类加载器执行,根据类名查找...
  • 大家在去参加面试的时候,经常会遇到这样的考题:给你两个类的代码,它们之间是继承的关系,每个类里只有...我们大家都知道,对于静态变量、静态初始化块、变量、初始化块、构造器,它们的初始化顺序以此是(静态变量
  • class Parent { public static String p_StaticField = "父类--静态变量"; public String p_Field = "父类--变量"; // 代码块 ... System.out.println("父类--初始化块"); } // 构造函数 public Par
  • Java的初始化块、静态初始化块、构造函数的执行顺序及用途探究 - BlackStorm - 博客园 https://www.cnblogs.com/BlackStorm/p/5699965.html Java的初始化块、静态初始化块、构造函数的执行顺序及用途探究  ...
  • Java类的初始化块总结

    千次阅读 2017-10-20 18:13:12
    Java使用构造方法来对单个对象进行初始化操作,使用构造方法先完成整个Java对象的状态初始化,然后将Java对象返回给程序,从而...一个类里可以有多个初始化块,相同类型的初始化块之间有顺序:前面定义的初始化块先执行
  • Java中静态初始化块初始化块、构造方法的执行顺序 java里初始化一个类的对象,通过初始化块或者构造方法进行数据赋值。与其相关的执行代码有这么几种: 静态初始化块 初始化块 构造方法 静态初始化块 静态初始化...
  • 初学Java,初始化块(十三)

    千次阅读 2012-02-06 17:59:40
    初始化块是什么?在Java中就是在构造器之前执行的一段代码,它的用处是,如果一段初始化处理代码对所有对象完全相同,且无须接受任何参数,就可以把这段提取到初始化块中.在C#中,没有初始化块public class Person ...
  • 理解初始化块和静态初始化块案例

    千次阅读 2014-02-26 18:54:04
    初始化块的使用分析: 一个类里可以有多个初始化块; 如果一个类里定义了两个普通初始化块,则前面定义的初始化块先执行,后面定义的初始化块后执行; 初始化块虽然也是Java类里的一种成员,但它没有名字,也就...
  • public class People { public static int num=0;//静态变量 ... static//静态初始化块 { System.out.println(num+":静态初始化块"); } {//实例初始化块 System.out.println(num+":实例初始化块");
  • Java中初始化块的真实作用

    千次阅读 2014-05-27 10:36:18
    对于普通的类而言,可以放在初始化块中的初始化工作其实完全可以放到构造函数中进行,只不过有时会带来些许不便,如有多个构造器,就要在多个地方加上初始化函数完成初始化工作,而如果放到初始化块中的话则只要写一...
  • 在Java中,有两种初始化块:静态初始化块和非静态初始化块。它们都是定义在类中,用大括号{}括起来,静态代码块在大括号外还要加上static关键字。 非静态初始化块: 作用:给对象进行初始化。对象一建立就运行,且...
1 2 3 4 5 ... 20
收藏数 685,159
精华内容 274,063
关键字:

初始化块