精华内容
下载资源
问答
  • 静态初始化块

    2021-03-10 01:24:05
    2、静态初始化块是类相关的 系统将在类初始化阶段执行静态初始化块,而不是在创建对象时才执行 因此静态初始化块总是比普通初始化块先执行 3、静态初始化块是类相关的 ,通常用于对整个类进行初始化处理,通常用于对...

    静态初始化块

     

    基本概念:

    1、如果定义初始化块时使用了static 修饰符,则这个初始化块就变成了静态初始化块,也被称为类初始化块(普通初始化块负责对对象执行初始化,类初始化块则负责对类进行初始化)

    2、静态初始化块是类相关的 系统将在类初始化阶段执行静态初始化块,而不是在创建对象时才执行 因此静态初始化块总是比普通初始化块先执行

    3、静态初始化块是类相关的 ,通常用于对整个类进行初始化处理,通常用于对类变量执行初始化处理。静态初始化块不能对实例变量进行初始化处理

    4、静态初始化块也被称为类初始化块,也属于类的静态成员,同样需要遵循静态成员不能访问非静态成员的规则,因此静态初始化块不能访问非静态成员,包括不能访问实例变量和实例方法

    5、与普通初始化块类似的是,系统在类初始化阶段执行静态初始化块时,不仅会执行本类的静态初始化块,而且还会一直上溯到 java.lang.Object 类(如果它包含静态初始化块)

    先执行 java .lang.Object类的静态初始化块(如果有),然后执行其父类的静态初始化块……最后才执行该类的静态初始化块,经

    过这个过程,才完成了该类的初始化过程。

    只有当类初始化完成后,才可以在系统中使用这个类,包括问这个类的类方法、类变量或者用这个类来创建实例
     
     

    class Root {
        static {
            System.out.println("Root的--静态初始化代码块");
        }
        {
            System.out.println("Root的--普通初始化代码块");
        }
        public Root(){
            System.out.println("Root的--无参构造");
        }
    }
    
    
    class Mid extends Root{
        static {
            System.out.println("Mid的--静态初始化代码块");
        }
        {
            System.out.println("Mid的--普通初始化代码块");
        }
        public Mid(){
            System.out.println("Mid的--无参构造");
        }
        public Mid(String msg){
            //通过 this 调用同一类中重载的构造器
            this () ;
            System.out.println("Mid 的带参数构造器,其参数值:"+msg);
        }
    }
    
    
    class Leaf extends Mid{
        static {
            System.out.println("Leaf的--静态初始化代码块");
        }
        {
            System.out.println("Leaf的--普通初始化代码块");
        }
        public Leaf(){
            // 通过 super 调用父类中有一个字符串参数的构造器
            super("正在 -- 调用父类中有一个字符串参数的构造器" ) ;
            System.out.println("Leaf的--无参构造");
        }
    }
    
    public class Tests {
        public static void main(String[] args) {
            new Leaf() ;
            new Leaf() ;
        }
    }
    
    

     
     

    Root的--静态初始化代码块
    Mid的--静态初始化代码块
    Leaf的--静态初始化代码块
    Root的--普通初始化代码块
    Root的--无参构造
    Mid的--普通初始化代码块
    Mid的--无参构造
    Mid 的带参数构造器,其参数值:正在 -- 调用父类中有一个字符串参数的构造器
    Leaf的--普通初始化代码块
    Leaf的--无参构造
        
        
        
    Root的--普通初始化代码块
    Root的--无参构造
    Mid的--普通初始化代码块
    Mid的--无参构造
    Mid 的带参数构造器,其参数值:正在 -- 调用父类中有一个字符串参数的构造器
    Leaf的--普通初始化代码块
    Leaf的--无参构造
    
    Process finished with exit code 0
    
    

     
     

    在这里插入图片描述

     
     

    第一次创建 Leaf 对象时,因为系统中还不存在 Leaf 类,因此需要先加载并初始化 Leaf 类,

    初始化 Leaf 类时会先执行其顶层父类的静态初始化块,再执行其直接父类的静态初始化块,最后才执行 Leaf 本身的静态初始化块

    一旦Leaf 类初始化成功后, Leaf 类在该虚拟机里将一直存在,因此当第一创建 Leaf 实例时无须再次对 Lea 类进行初始化

    每次创建 Leaf 对象时,都需要

    先执行最顶层父类的初始 块、构造器 …然后执行其父类的初始化块、构造器……最后才执行 Leaf 类的初始化块和构造器

    Java 系统加载并初始化某个类时,总是保证该类的所有父类(包括直接父类和间接父类)全部加载并初始化

    静态初始化块和声明静态成员变量时所指定的初始值都是该类的初始化代码,它们的执行顺序与源程序中的排列顺序相同。
     
     

    public class StaticlnitTest{
        //先执行静态初始化块将a静态成员变量赋值为6
     static{ 
        a = 6; 
     }
    //再将a静态成员变量赋值为9
    static int a = 9; 
    public static void main(String[] args) {
        //下面代码将输出
    System out println(StaticlnitTest.a);
      }
    } 
    
    

     
     

    程序中定义了两次对 a 静态成员变量进行赋值,执行结果是 a 值为 9,这表明 static int a =9 这行代码位于静态初始化块之后执行。

    如果将 a = 6与 static int a = 9; 调换顺

    序,将可以看到程序输出6 ,这是由于静态初始化块中代码再次将 a 的值设为6

     
     

    在这里插入图片描述

    展开全文
  • 今天就浅谈一下JAVA中静态初始化块和非静态初始化块的区别静态初始化块定义:static{}执行优先级高于非静态的初始化块,它会在对象装载到系统的时候执行一次,执行完成便销毁,它仅能初始化类变量,即static修饰的...

    众所周知在JAVA编程语言中有两种初始化块:

    静态初始化块

    非静态初始化块

    他们到底有什么区别呢?今天就浅谈一下JAVA中静态初始化块和非静态初始化块的区别

    静态初始化块

    定义:

    static{}

    执行优先级高于非静态的初始化块,它会在对象装载到系统的时候执行一次,执行完成便销毁,它仅能初始化类变量,即static修饰的数据成员。

    执行优先级:1

    非静态初始化块

    定义:

    {}

    执行的时候如果有静态初始化块,先执行静态初始化块再执行非静态初始化块,在每个对象生成时都会被执行一次,它可以初始化类的实例变量。非静态初始化块会在构造函数执行时,在构造函数主体代码执行之前被运行。

    执行优先级:2

    package temp;

    public class TempStatic {

    //自定义变量

    public int num=0;

    //创建的一个对象但是并没有实例化,我们把实例化交给非静态初始化块

    public TempStaticOne temp;

    //非静态初始化块

    {

    System.out.println("我是非静态初始化块..");

    this.num=1;

    this.temp = new TempStaticOne();

    }

    //静态初始化块

    static{

    System.out.println("我是静态初始化块...");

    }

    //构造函数

    public TempStatic(){

    System.out.println("我是构造方法..");

    }

    //自定义方法

    public void Show(){

    System.out.println("变量最终结果为:"+num);

    }

    }

    执行结果:

    我是静态初始化块...

    我是非静态初始化块..

    我是非静态方法初始化对象的测试..

    我是构造方法..

    变量最终结果为:1

    展开全文
  • 在Java中,有两种初始化块:静态初始化块和非静态初始化块。 它们都是定义在类中,用大括号{}括起来,静态代码块在大括号外还要加上static关键字。 非静态初始化块(构造代码块): 作用:给对象进行初始化。对象一...

    https://blog.csdn.net/shuyizhi/article/details/79700054
    首先置顶一篇static关键字的总结!很通俗易懂,特此记下

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

    它们都是定义在类中,用大括号{}括起来,静态代码块在大括号外还要加上static关键字。

    非静态初始化块(构造代码块):
    作用:给对象进行初始化。对象一建立就运行,且优先于构造函数的运行。
    与构造函数的区别:非静态初始化块给所有对象进行统一初始化,构造函数只给对应对象初始化。
    应用:将所有构造函数共性的东西定义在构造代码块中。

    对于普通的类而言,可以放在初始化块中的初始化工作其实完全可以放到构造函数中进行,只不过有时会带来些许不便,如有多个构造器,就要在多个地方加上初始化函数完成初始化工作,而如果放到初始化块中的话则只要写一次即可。
    但是,如果只是这一点便利的话,还不足以使用初始化块,其实初始化块真正体现其独一无二的作用是在匿名内部类中,由于是匿名内部类,因而无法写构造方法,但是很多时候还是要完成相应的初始化工作,这时就需要用到初始化块了,特别是Android中大量地使用匿名内部类,初始化块的作用就十分突出

    静态初始化块:
    作用:给类进行初始化。随着类的加载而执行,且只执行一次
    与构造代码块的区别:
    1)构造代码块用于初始化对象,每创建一个对象就会被执行一次;静态代码块用于初始化类,随着类的加载而执行,不管创建几个对象,都只执行一次。
    2)静态代码块优先于构造代码块的执行
    3)都定义在类中,一个带static关键字,一个不带static

    比如可以记录第一次访问类的日志,或方便单例模式的初始化等。对于单例模式,可以先用static块初始化一些可能还被其他类访问的基础参数,等到真正需要加载大量资源的时候(getInstance)再构造单体,在构造函数中加载资源。

    构造函数、非静态初始化块、静态代码块都是用于初始化,三者的执行顺序依次是:静态代码块>构造代码块>构造函数。
    其实初始化块就是构造器的补充,初始化块是不能接收任何参数的,定义的一些所有对象共有的属性、方法等内容时就可以用初始化块初始化了。

    静态初始化块的作用就是当JVM在装载类时,你想让它做一些事情,那么,就可以用静态初始化块。这几者的执行顺序是:

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

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

    执行顺序
    所有的静态初始化块都优先执行,其次才是非静态的初始化块和构造函数,它们的执行顺序是:

    父类的静态初始化块
    子类的静态初始化块
    父类的初始化块
    父类的构造函数
    子类的初始化块
    子类的构造函数

    静态初始化块执行一次时有如下例子:

    import java.util.*;
    
    class Test
    {
        public static void main(String[] args)
        {
            System.out.println("Test");
            System.out.println(T.num);
        }
    }
    
    class T
    {
        static
        {
            System.out.println("之前加载");
        }
        static int n = new Scanner(System.in).nextInt();
        static final int num = n;
        static
        {
            System.out.println("之后加载");
        }
    }
    

    当程序运行到System.out.println(T.num);这句时,那么就进行对
    类T的加载–》连接–》初始化,
    它运行完第一个static静态初始化块之后,发现第二条语句是一个阻塞式的语句,需要你输入一个数之后程序才能继续运行,那么当你输入12后按回车,程序马上执行每二个静态初始化块,最后才执行把 n的值赋值给常量num,那么最后才调用到System.out.println(T.num);这条语句打印出常量num的值

    也就是说static初始化块与static型变量,是按照你定义的先后次序来执行的(无论有多少个static初始化块和多少个static型变量)

    由static修饰的变量称为静态变量,其实质上就是一个全局变量。如果某个内容是被所有对象所共享,那么该内容就应该用静态修饰;没有被静态修饰的内容,其实是属于对象的特殊描述。

    不同的对象的实例变量将被分配不同的内存空间, 如果类中的成员变量有类变量,那么所有对象的这个类变量都分配给相同的一处内存,改变其中一个对象的这个类变量会影响其他对象的这个类变量,也就是说对象共享类变量。

    这里介绍下成员变量和类变量的区别:

    1、两个变量的生命周期不同

      成员变量随着对象的创建而存在,随着对象的回收而释放。
    
      静态变量随着类的加载而存在,随着类的消失而消失。
    

    2、调用方式不同

      成员变量只能被对象调用。
    
      静态变量可以被对象调用,还可以被类名调用。
    

    3、别名不同

      成员变量也称为实例变量。
    
      静态变量也称为类变量。
    

    4、数据存储位置不同

      成员变量存储在堆内存的对象中,所以也叫对象的特有数据。
    
      静态变量数据存储在方法区(共享数据区)的静态区,所以也叫对象的共享数据。
    

    static 关键字,是一个修饰符,用于修饰成员(成员变量和成员函数)。

    特点:

    1、想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。

    2、被静态修饰的成员,可以直接被类名所调用。也就是说,静态的成员多了一种调用方式。类名.静态方式。

    3、静态随着类的加载而加载。而且优先于对象存在。
    

    弊端:

    1、有些数据是对象特有的数据,是不可以被静态修饰的。因为那样的话,特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以,在定义静态时,必须要明确,这个数据是否是被对象所共享的。

    2、静态方法只能访问静态成员,不可以访问非静态成员。

      因为静态方法加载时,优先于对象存在,所以没有办法访问对象中的成员。
    

    3、静态方法中不能使用this,super关键字。

      因为this代表对象,而静态在时,有可能没有对象,所以this无法使用。
    

    什么时候定义静态成员呢?或者说:定义成员时,到底需不需要被静态修饰呢?

    成员分两种:

    1、成员变量。(数据共享时静态化)

      该成员变量的数据是否是所有对象都一样:
    
      如果是,那么该变量需要被静态修饰,因为是共享的数据。 
    
      如果不是,那么就说这是对象的特有数据,要存储到对象中。 
    

    2、成员函数。(方法中没有调用特有数据时就定义成静态)

      如果判断成员函数是否需要被静态修饰呢?
    
      只要参考,该函数内是否访问了对象中的特有数据:
    
      如果有访问特有数据,那方法不能被静态修饰。
    
      如果没有访问过特有数据,那么这个方法需要被静态修饰。
    

    成员变量和静态变量的区别:

    1、成员变量所属于对象。所以也称为实例变量。

      静态变量所属于类。所以也称为类变量。
    

    2、成员变量存在于堆内存中。

      静态变量存在于方法区中。
    

    3、成员变量随着对象创建而存在。随着对象被回收而消失。

      静态变量随着类的加载而存在。随着类的消失而消失。
    

    4、成员变量只能被对象所调用 。

      静态变量可以被对象调用,也可以被类名调用。
    

    所以,成员变量可以称为对象的特有数据,静态变量称为对象的共享数据。

    展开全文
  • 众所周知在JAVA编程语言中有两种初始化块: 静态初始化块静态初始化块 静态初始化块 定义: ...非静态初始化块 ...执行的时候如果有静态初始化块,先执行静态初始化块再执行非静态初始化块

    众所周知在JAVA编程语言中有两种初始化块:

    • 静态初始化块

    • 非静态初始化块

    静态初始化块

    定义:

    static
    {
    }
    1. 执行优先级高于非静态的初始化块。
    2. 它会在对象装载到系统的时候执行一次,执行完成便销毁。
    3. 它仅能初始化类变量,即static修饰的数据成员。

    非静态初始化块

    定义:

    {
    }
    1. 执行的时候如果有静态初始化块,先执行静态初始化块再执行非静态初始化块。
    2. 在每个对象生成时都会被执行一次,它可以初始化类的实例变量。
    3. 非静态初始化块会在构造函数执行时,在构造函数主体代码执行之前被运行。
    展开全文
  • 所谓“块”,就是用{}所包含的代码段,它们在逻辑上常常是一个整体。...非静态初始化块主要用于对象的初始化操作,在每次创建对象时都要调用一次,其执行顺序在构造方法之前。由于非静态成员不能在静态方法中...
  • 今天无聊,看了一下java语言基础知识,对 实例初始化块,静态初始化块 的执行顺便,有了一点了解,便记下来,方便以后查阅。在一个类定义中,初始化块,就是一块用 { } 大括号括起来的代码段。但“实例初始化块”...
  • 静态初始化块静态初始化块 他们到底有什么区别呢?今天就浅谈一下JAVA中静态初始化块和非静态初始化块的区别 静态初始化块 定义: static{} 执行优先级高于非静态的初始化块,它会在对象装载到系统的时候...
  • 使用初始化块初始化实例变量。...给出了一个演示Java中的非静态初始化块的程序,如下所示:示例publicclassDemo{staticint[]numArray=newint[10];{System.out.println("\nRunningnon-staticinitialization...
  • 2 初始化块:普通初始化块、静态初始化块(类初始化块) 3 4 下面程序创建了三个类:Root,Mid和Leaf, 5 者三个类都提供了静态初始化块和普通初始化块, 6 而且Mid类里还是用this调用重载构造区,而 7 Leaf...
  • 这里写自定义目录标题初始化块初始化块和成员变量初始化块和构造函数静态初始化块 初始化块 初始化块对Java对象进行初始化工作。 一个类里可以有多个初始化块。 按照定义的先后顺序执行。 [修饰符]{ //初始化块代码...
  • 初始化块的使用(变量,静态变量,方法...直接使用静态初始化块可以解决问题 static { name="张三"; } 初始化代码块初始化方法 上面的方法不可行 能否初始化静态方法 error 尝试使用初始化块初始化构造方法 ...
  • JAVA 初始化块 静态初始化块 构造方法执行顺序 类初始化顺序如下 父类的静态初始化块 子类的静态初始化块 父类的初始化块 父类的构造器 子类的初始化块 子类的构造器 代码演示 创建父类 ClassA,子类ClassB继承自...
  • 需要注意的是,静态初试化块只在类加载的时候执行一次,同时静态初始化块只能给静态变量赋值,不能初始化普通的成员变量。 例子 package com.zhangyu; public class MyTest { String name; //普通初始化块 { ...
  • (所谓的初始化方法init()是另一回事, 在构造方法之后执行, 注意不要混淆)在Java中,有两种初始化块:静态初始化块和非静态初始化块。它们都是定义在类中,用大括号{}括起来,静态代码块在大括号外还要加上static关键字...
  • 在Java中,有两种初始化块:静态初始化块和非静态初始化块.静态初始化块:使用static定义,当类装载到系统时执行一次.若在静态初始化块中想初始化变量,那仅能初始化类变量,即static修饰的数据成员.非静态初始化块:在每个...
  • 2.特点:静态初始化块调用时机:加载类。只会调用一次,随类加载而加载。类只会加载一次。普通初始化块调用时机:调对象。会调用多次,随着对象的创建而加载。3.一个类中有多个普通初始化块和静态初始化块。静态的要...
  • 但是,静态初始化块只能初始化静态实例变量。当加载类时,这些块仅执行一次。一个类中可以有多个静态初始化块,它们按在程序中出现的顺序被调用。给出了一个演示Java中的静态初始化块的程序,如下所示:示例...
  • 今天就浅谈一下JAVA中静态初始化块和非静态初始化块的区别 静态初始化块 定义: static{} 执行优先级高于非静态的初始化块,它会在对象装载到系统的时候执行一次,执行完成便销毁,它仅能初始化类变量,...
  • 在Java中,有两种初始化块:静态初始化块和非静态初始化块。它们都是定义在类中,用大括号{}括起来,静态代码块在大括号外还要加上static关键字。 2.1 非静态初始化块(构造代码块): 作用: 给对象进行初始化。对象...
  • 1.所有的静态初始化块都优先执行,其次才是非静态的初始化块和构造函数,它们的执行顺序是:  1)父类的静态初始化块  2)子类的静态初始化块  3)父类的初始化块  4)父类的构造函数  5)子类的初始化块  6)子类的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,554
精华内容 4,221
关键字:

静态初始化块