静态初始化块_非静态初始化块可以接受参数 - CSDN
精华内容
参与话题
  • 在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子类首先执行父类的实例块和父类的构造方法,然后是子类的实例块和构造方法

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


    展开全文
  • 静态初始化块

    2019-07-18 17:43:29
    1、上溯到Object类,先执行Object的静态初始化块,再向下执行子类的静态初始化块,直到我们的类的静态初始化块为止。 2、构造方法执行顺序和上面顺序一样。 static静态初始化块 public class User3 { int id; /...

    静态初始化块执行顺序(学完继承再看这里):

    1、上溯到Object类,先执行Object的静态初始化块,再向下执行子类的静态初始化块,直到我们的类的静态初始化块为止。

    2、构造方法执行顺序和上面顺序一样。

    static静态初始化块

    public class User3 {
        int id;        //id
        String name;   //账户名
        String pwd;   //密码
        static String company; //公司名称
        static {
            System.out.println("执行类的初始化工作");
            company = "北京尚学堂";
            printCompany();
        }  
        public static void printCompany(){
            System.out.println(company);
        }  
        public static void main(String[] args) {
            User3  u3 = new User3();
        }
    }

     

    展开全文
  • 初始化块与静态初始化块

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

    1、初始化块(构造代码块):
    (1)作用:给对象进行初始化。对象一建立就运行,且优先于构造函数的运行
    (2)与构造函数的区别:初始化块给所有对象进行统一初始化,构造函数只给对应对象初始化。是Java在创建对象时隐示执行的,在Javac编译后初始化块内代码会被还原到构造器里,而且在最前面。先执行父类初始化块后子类的。
    (3)应用:不接受参数,将所有构造函数共性的东西定义在构造代码块中。

    3Java创建对象过程的初始化顺序:先初始化块或者声明时赋值>构造器中的初始化。创建过程包括类加载、分配内存、并行处理、初始化、对象设置、执行init方法。

     

    public class A{
    { a=9;}
    int a=6;
    public st...main(...){
       print....(new A().a)
    }
    }
    输出6,即创建对象时首先统一为成员们分配内存(类已加载),然后初始化块与声明后的赋值执行顺序看代码顺序

    2static静态初始化块:
    (1)作用:给类进行初始化。随着类的加载而执行,且只执行一次
    (2)与构造代码块的区别:
    1)构造代码块用于初始化对象,每创建一个对象就会被执行一次;静态代码块用于初始化类,随着类的加载而执行,都只执行一次
    2静态代码块优先于构造代码块的执行

    4、顺序

    JVM在装载类时)先装载类的静态成员,再执行静态初始化块(同样,当一个类有继承自某类时,则会先装载该父类,那么,父类的装载或执行顺序,也都如句子所述)。

    (在创建类的实例时)先执行实例初始化块,再执行构造器;但对于一棵继承树中,会先调用父类的构造方法,那么其执行顺序也如句子所述。

    5例子:
    Class A{ int n = 0;}那么你创建对象 A a = new A();之后就可以使用a.n属性

    Class A{  {  int a= 0;  }  } 放在块里面n就不是A的成员,就不能使用a.n属性前者把n作为对象的成员;后者只是实例化一个对象时声明一个局部变量a。有本质区别。

    public class Test {
    static {
    System.out.println("我是静态块");
    }
    }
    当创建Test 类的一个对象的时候,比如new Test() ,是这样,首先是类加载,然后才能new对象,静态块在类加载的时候就执行了,这就说明静态块在new对象之前就会执行,而且一个类在第一次被使用的时候 会被加载,然后在整个应用程序的生命周期当中不会再次被加载了,就加载这一次,所以这就说明,静态块就执行一次,不会执行第二遍!

     

    展开全文
  • Java中的static 静态初始化块

    千次阅读 2018-07-13 11:53:08
    静态初始化块,用于类的初始化操作!在静态初始化块中不能直接访问非static成员。public class Use1 { int m_id; String m_name; String m_pwd; static String m_school; static { // 用来对类的初始化操作,...

    构造方法用于对象的初始化!

    静态初始化块,用于类的初始化操作!

    在静态初始化块中不能直接访问非static成员。

    public class Use1 {
        int m_id;
        String m_name;
        String m_pwd;

        static String m_school;

        static {           // 用来对类的初始化操作,例如static的成员变量,但在块中必须是静态函数与静态成员

            System.out.println("执行类的初始化工作!");
            m_school = "北京大学";
            printSchool();
        }
        
        public static void printSchool() {
            System.out.println(m_school);
        }
        public static void main(String[] args) {
            Use1 wang = null;
        }
    }


    展开全文
  • static静态初始化块(详解与代码)

    千次阅读 2019-06-12 20:57:57
    我们在内存分析和this的...在静态初始化块中不能直接访问非static成员,因为非static成员是从属与对象的,而静态初始化块是从属于类的,静态初始化块执行的时候,对象还没有生成。 下面我们用代码来见证一下 pub...
  • 父类静态成员和静态初始化块,按在代码中出现的顺序依次执行。 2>子类静态成员和静态初始化块,按在代码中出现的顺序依次执行。 3>父类实例成员和实例初始化块,按在代码中出现的顺序依次执行。 4>执行...
  • Java中静态初始化块、初始化块、构造方法的执行顺序 java里初始化一个类的对象,通过初始化块或者构造方法进行数据赋值。与其相关的执行代码有这么几种: 静态初始化块 初始化块 构造方法 静态初始化块 静态初始化...
  • 1.所有的静态初始化块都优先执行,其次才是非静态的初始化块和构造函数,它们的执行顺序是:  1)父类的静态初始化块  2)子类的静态初始化块  3)父类的初始化块  4)父类的构造函数  5)子类的初始化块  6)子类的...
  • 这里写自定义目录标题初始化块初始化块和成员变量初始化块和构造函数静态初始化块 初始化块 初始化块对Java对象进行初始化工作。 一个类里可以有多个初始化块。 按照定义的先后顺序执行。 [修饰符]{ //初始化块代码...
  • 原文链接: ... class Parent { public static String p_StaticField = "父类--静态变量"; public String p_Field = "父类--变量"; // 代码 { System.out.println(p_
  • JAVA之静态初始化块

    2018-07-19 11:25:53
    用static修饰的初始化块就称为静态初始化块。 需要特别注意:静态初始化块只在类加载时执行,且只会执行一次,同时静态初始化块只能给静态变量赋值,不能初始化普通的成员变量。 看一段代码: public class ...
  • 我们大家都知道,对于静态变量、静态初始化块、变量、初始化块、构造器,它们的初始化顺序以此是(静态变量、静态初始化块)>(变量、初始化块)>构造器。我们也可以通过下面的测试代码来验证这一点:  ...
  • 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
  • java基础-延伸,变量的初始化顺序从这篇文章java基础-反射1(类型信息,Class对象简介,Class对象初始化) 我们可以了解到类在第一次使用时类加载到内存中的顺序有三个步骤 类的加载:由类加载器执行,根据类名查找...
  • 静态初始化块静态初始化块 他们到底有什么区别呢?今天就浅谈一下JAVA中静态初始化块和非静态初始化块的区别 静态初始化块 定义:  static{} 执行优先级高于非静态的初始化块,它会在对象装载到系统的时候...
  • 我们大家都知道,对于静态变量、静态初始化块、变量、初始化块、构造器,它们的初始化顺序以此是(静态变量、静态初始化块)>(变量、初始化块)>构造器。我们也可以通过下面的测试代码来验证这一点:  Java代码 ...
  • 当创建一个对象时,会先初始化类,然后在
  • 大家在去参加面试的时候,经常会遇到这样的考题:给你两个类的代码,它们之间是继承的关系,每个类里只有...我们大家都知道,对于静态变量、静态初始化块、变量、初始化块、构造器,它们的初始化顺序以此是(静态变量
  • 关于Java的静态初始化块

    万次阅读 2010-02-12 22:30:00
    这里我们主要讨论下静态初始化块这种情况。 静态初始化块是在类被加载的时候就执行的一块程序,并且一直存在直到程序关闭。也就是说当程序被执行,即classloader将该java程序编译后的class文件加载后,就能执行到...
  • 在Java中,有两种初始化块:静态初始化块和非静态初始化块。它们都是定义在类中,用大括号{}括起来,静态代码块在大括号外还要加上static关键字。 非静态初始化块: 作用:给对象进行初始化。对象一建立就运行,且...
1 2 3 4 5 ... 20
收藏数 274,376
精华内容 109,750
关键字:

静态初始化块