精华内容
下载资源
问答
  • 主要介绍了Java类加载连接和初始化,结合具体实例形式分析了java类加载、连接、初始化相关原理与实现技巧,需要的朋友可以参考下
  • Java在进行对象创建时:检查是否已经类加载、分配内存、初始化为零值、对象元数据设置、初始化。该的函数的字节码如下: 反编译的代码如下: 至此,、实例的实例化顺序复习完成。 四、初始化顺序总结...

    一、代码镇帖

    package javase.jvm;
    
    public class ClassInitTest {
    
        private static final String staticCodeBlock = " static code block ";
        private static final String codeBlock = " code block ";
        private static final String constructor = " constructor ";
    
        private static String className = ClassInitTest.class.getSimpleName();
    
        static {
            //静态初始代码块,用于验证主函数类的加载
            System.out.println(className + staticCodeBlock);
        }
    
        static class Motherland{
    
            static final String name = "China";
    
            static {
                System.out.println("Motherland " + staticCodeBlock);
                //对类的静态变量进行赋值,但是不能使用定义在静态代码块后面的变量
                age = 79;
            }
    
            //一个静态字段
            static Motherland motherland = new Motherland();
    
            //静态字段
            static int age = 78;
            static int count;
    
            {
                //构造代码块
                System.out.println("Motherland " + codeBlock);
            }
    
            //私有构造器
            private Motherland(){
                System.out.println("Motherland " + constructor);
                age ++;
                count ++;
            }
        }
    
        static class Successor extends Motherland{
    
            static String name = "cyf";
    
            int count1 = getCount2();
    
            int count2 = 2;
    
            static {
                System.out.println("Successor " + staticCodeBlock);
                name = "chuyf";
            }
    
            {
                System.out.println("Successor " + codeBlock);
                count2 = 0;
            }
    
            Successor(){
                System.out.println("Successor " + constructor);
            }
    
            int getCount2(){
                return count2;
            }
        }
    
        public static void main(String[] args){
    
            System.out.println("Motherland name: " + Motherland.name);
    
            System.out.println("Successor name: " + Successor.name);
    
            System.out.println("Motherland age: " + Motherland.age);
    
            Successor successor = new Successor();
    
            System.out.println("successor count1: " + successor.count1 + "\t" + "successor count2: " + successor.count2);
    
            System.out.println("Motherland age: " + Motherland.age);
    
            System.out.println("Motherland count: " + Motherland.count);
        }
    }
    

    二、代码输出

    ClassInitTest static code block //主函数类初始化
    Motherland name: China //输出静态常量
    Motherland  static code block //父类静态代码块
    Motherland  code block //父类构造代码块
    Motherland  constructor //父类构造函数
    Successor  static code block //子类静态代码块
    Successor name: chuyf //输出
    Motherland age: 78 //输出
    Motherland  code block //父类构造代码块
    Motherland  constructor //父类构造函数
    Successor  code block //子类构造代码块
    Successor  constructor //子类构造函数
    successor count1: 0	successor count2: 0 //输出对象值
    Motherland age: 79 //输出
    Motherland count: 2 //输出
    

    三、输出分析

    1. 当虚拟机启动时,虚拟机会先初始化要执行的主类(包含main函数的类)。

    第一个输出表示当前主类已经被加载。

    1. 当实例化对象、读取或设置类的静态字段(final修饰的常量除外)、调用类静态方法时将触发类的加载。

    第75行输出父类的静态字段,但是并没有引起父类的加载。在编译时,常量传播将该常量直接放置在主类的常量池里面,于是对父类静态字段的引用变成了对自己类常量池的一个引用。使用javap -c -v ClassInitTest.class 命令,可以在Constant pool里面找到这个常量#60 = Utf8 Motherland name: China,所以第75行没有引起其他的类加载(主类已经被加载了)

    1. 当初始化一个类时,如果发现其父类没有进行初始化,则先触发其父类的初始化(所以Object类肯定最先被初始化)。

    在第77行访问子类的时候将触发其进行类加载,然后触发其父类的加载,所以输出的为:父类静态代码块(第三行输出) > 子类静态代码块(第六行输出)的大致顺序。之间输出了其他的信息先不管

    1. 虚拟机类加载机制

    类的生命周期主要有以下几个阶段:加载、验证、准备、解析、初始化、使用、卸载 七个阶段。除了解析阶段为了支持动态语言可以在初始化后开始,其他的阶段都是顺序开始,交叉进行的。

    加载:通过全限定类名获取一个字节流,将其静态存储结构转换为运行时数据结构,并创建一个代表该类的Class对象作为访问该类信息的入口。

    验证:确保Class文件里面的字节流不会危害虚拟机本身。包含文件格式验证(是否符合Class文件格式规范、是否被当前虚拟机支持)、元数据验证(字节码描述信息语义分析)、字节码验证(程序语义是否合法、符合逻辑)、符号引用验证(自身信息的匹配验证)。

    准备:为类变量分配空间并设置类变量的初始值。常量将被直接赋值为常量值,而不是初始值。

    解析:将符号引用解析为直接引用的过程(符号上的逻辑关系转换为虚拟机内存之间的联系)。

    初始化:类构造器的执行过程。编译器顺序收集类变量的赋值操作和静态代码块的语句合并而成。

    1. 解释第77行导致的输出

    第77行对子类静态字段的读取引发对子类的加载,子类引发对父类的加载。

    父类加载过程:

    1. 准备阶段将常量赋值,将静态变量赋值为初始值,准备阶段后各个静态变量的值:name = "China"; motherland = null; age = 0; count = 0;
    2. 初始化阶段收集赋值操作和static代码块对类变量进行初始化。第一个操作,执行静态代码块(第三行输出),对age进行赋值操作,该操作后,各个静态变量的值为:name = "China"; motherland = null; age = 79; count = 0;。第二个操作,初始化motherland,对motherland的初始化需要进行构造,所以需要依次调用构造代码块(第四行输出)和构造函数(第五行输出)。第一步过后,各个变量的值:name = "China"; motherland = [object]; age = 80; count = 1;第三个操作,执行对age的赋值操作,改操作后,各个静态变量的值为:name = "China"; motherland = [object]; age = 78; count = 1;至此父类加载初始化完毕。

    子类加载过程:

    1. 准备阶段类变量:name = null;
    2. 初始化阶段,48行将其赋值为:“cyf”,但是在紧随其后的静态代码块(第六行输出)将其修改为:“chuyf”。至此子类初始化完成。
    1. 第79行不会导致类加载,因为都已经被加载过了。
    2. 第81行导致的输出解释

    对父类的影响:

    1. 第81行对对象的实例化会调用父类的构造代码块(第九行输出)和构造函数(第十行输出),会将age变为79(第十四行输出),count变为2(第十五行输出)。

    对子类的影响:

    1. Java在进行对象创建时:检查是否已经类加载、分配内存、初始化为零值、对象元数据设置、初始化。该类的函数的字节码如下:
      在这里插入图片描述
      反编译的代码如下:
      在这里插入图片描述
      至此,类、实例的实例化顺序复习完成。

    四、初始化顺序总结

    1. 父类类构造函数(顺序的静态字段赋值语句与static代码块)
    2. 子类类构造函数(顺序的静态字段赋值语句与static代码块)
    3. 父类的构造代码块和构造函数
    4. 子类类的构造代码块和构造函数

    注:

    1. 在进行初始化时,常量在准备阶段就已经赋值,而类静态变量为零值。
    2. 当执行顺序前的初始化操作去使用后续未初始化的值时将会访问到零值(准备阶段),常量除外。
    3. 常量在编译阶段的传播优化不会导致该常量声明类的加载。
    4. 类构造是线程安全的,所以注意类构造的时间。
    5. 最好的方法是看字节码文件,实例变量赋值、构造代码块和构造函数被整合到<init>函数,静态代码块和静态变量赋值被整合到<cinit>函数。
    展开全文
  • JAVA类加载初始化顺序

    千次阅读 2018-08-20 15:03:05
    的生命周期 7个阶段依次为:Loading Verification Preparation Resolution Initialization Using...于是java默认的查找加载顺序是自顶向下的,树状结构 双亲委托的意图是保证java类型体系中最基础的行为一...

     

    类的生命周期

    7个阶段依次为:Loading Verification Preparation Resolution Initialization Using Unloading

    类加载的双亲委派模型

    各个加载器都是先委托自己的父加载器加载类,若确实没加载到再自己来加载

    于是java默认的类查找加载顺序是自顶向下的,树状结构

    双亲委托的意图是保证java类型体系中最基础的行为一致,优先加载JDK中的类

    加载器主要有四种:

    • jvm启动类加载器bootstrap loader,用c++实现为jvm的一部分(仅指sun的hotspot),负责 JAVA_HOME/lib下面的类库中的类的加载,这个加载器,java程序无法引用到。

    • 扩展类加载器Extension Loader,由sun.misc.Launcher$ExtClassLoader类实现,可在java中使用,负责JAVA_HOME/lib/ext 目录和java.ext.dir目录中类库的类的加载。

    • 应用系统类加载器Application System Loader,由sun.misc.Louncher$AppClassLoader实现,负责加载用户类路径中类库中的类,如果没有使用自定义的加载器,这个就是默认的 加载器!

    • 用户自定义加载器 自己定义从哪里加载类的二进制流

     

    加载 验证 准备 初始化和卸载 的顺序是确定的,而“解析”不一定在初始化之前,很有可能在初始化之后,实现java的伟大特性。

    package com.cyb.diffcult.类加载;
    
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    
    /**
     * 作者 : iechenyb<br>
     * 类描述: final 修饰的为常量 子类继承父类时的初始化顺序 
     * 1.首先初始化父类的static变量和块,按出现顺序
     * 2.初始化子类的static变量和块,按出现顺序 
     * 3.初始化父类的普通变量,调用父类的构造函数 
     * 4.初始化子类的普通变量,调用子类的构造函数<br>
     * 创建时间: 2018年1月18日
     */
    public class Singleton2 {
    	Log log = LogFactory.getLog(getClass());
    	public static final int a = init(5, "static final int a");
    	public static int counter1;// 在构造方法*
    	public static int counter2 = init2("static int c2", 120);// 在构造方法执行之后执行
    	public final int c = init(6, "final int c");
    	public int counter3 = init3("int c3", 110);// 初始化-最后
    	public static final int b = init(4, "static final int b");
    	public final int d = init(7, " final int d");
    	public static int counter4 = init2("static int c4", 0);// 在构造方法执行之后执行
    
    	static {
    		System.out.println("静态语句块1");
    	}
    
    	private Singleton2(String msg) {
    		System.out.println(msg);
    	}
    
    	private static int init(int num, String bs) {
    		System.out.println("初始化常量" + bs);
    		return num;
    	}
    
    	private Singleton2() {
    		System.out.println("构造方法执行!");
    		++counter1;
    		++counter2;
    		++counter3;
    	}
    
    	static {
    		System.out.println("静态语句块2");
    	}
    	private static Singleton2 sin = new Singleton2();// 与静态语句块按照顺序执行
    
    	public static int init2(String msg, int val) {
    		System.out.println(msg);
    		return val;
    	}
    
    	public int init3(String msg, int val) {
    		System.out.println(msg);
    		return val;
    	}
    
    	public static Singleton2 getInstance() {
    		return sin;
    	}
    
    	public static void main(String[] args) {
    		Singleton2 sin = Singleton2.getInstance();
    		System.out.println(sin.counter1);// 1
    		System.out.println(sin.counter2);// 1
    		System.out.println(sin.counter3);// 110->666
    		
    	}
    	/**
    	 *  初始化常量static final int a
    		static int c2
    		初始化常量static final int b
    		static int c4
    		静态语句块1
    		静态语句块2
    		初始化常量final int c
    		int c3
    		初始化常量 final int d
    		构造方法执行!
    		1
    		121
    		111
    	 */
    }
    

    执行顺序:

    /**
     * 常量分 普通常量 和静态常量
     * 作者 : iechenyb<br>
     * 类描述: final 修饰的为常量 子类继承父类时的初始化顺序 
     * 1.首先初始化父类的static变量和块,按出现顺序
     * 2.初始化子类的static变量和块,按出现顺序 
     * 3.初始化父类的普通变量,调用父类的构造函数 
     * 4.初始化子类的普通变量,调用子类的构造函数<br>
     * 创建时间: 2018年1月18日
     */

    展开全文
  • Java 类初始化

    千次阅读 2018-09-09 18:02:02
    根据java 语言特性,本人针对初始化中常遇到的一些关键点做了总结,当然是基于代码之上的,主要针对JVM加载一个之后,的属性等在内存中的初始化,主要静态的变量非静态的变量,以及静态代码块,普通代码块等...

    Java 类初始化介绍

    java语言在使用过程中最先开始就是初始化,在工作中如果遇到什么问题需 要定位往往到最后也可能是初始化的问题,因此掌握初始化的顺序很重要。
    根据java 语言特性,本人针对初始化中常遇到的一些关键点做了总结,当然是基于代码之上的,主要针对JVM加载一个类之后,类的属性等在内存中的初始化,主要静态的变量和非静态的变量,以及静态代码块,普通代码块等。具体参考下面的图:
    这里写图片描述

    简单介绍下图的意思,java类对象初始化主要包括:
    静态基本变量;
    静态类变量;
    静态代码块;
    普通基本变量;
    普通类类型变量;
    普通代码块;
    构造方法;
    初始化的时候主要就是这些属性,但是该类继承自父类,则初始化顺序号包括基类的这些属性,即初始化属性包括本类的这些属性+父类的这些属性,并且基类的属性和本类的属性交叉初始化。


    无继承关系初始化

    2.1: 首先查看基本代码

    首先看TestB.java类

    private  static String tag = "TestB";
    //静态变量
    private static int  staticVarA = initVar("staticVarA");
    
    //静态代码块
    static{
        initVar("static init block ");
    }
    //普通变量
    private  int normalA = initVar("normalA");
    
    // 普通代码块
    {
        initVar("normal init block");
    }
    
    public TestB(){
        System.out.println(initVar("constructor"));
    }
    static int initVar(String str){
    
        System.out.println(tag +" "+str);
    
        return 2018;
    }
    

    其次是 JavaInitWithMain.java 类

    private  static String tag = "JavaInitWithMain";
    //静态变量
    private static int  staticVarA = initVar("staticVarA");
    
    //静态代码块
    static{
        initVar("static init block ");
    }
    //普通变量
    private  int normalA = initVar("normalA");
    
    // 普通代码块
    {
        initVar("normal init block");
    }
    
    private static TestB nB = new TestB();
    
    private TestB nb2 = new TestB();
    
    public JavaInitWithMain(){
        System.out.println(initVar("constructor"));
    }
    static int initVar(String str){
    
        System.out.println(tag +" "+str);
    
        return 2020;
    }
    
    
    public static void main(String[] args) {
        System.out.println("-------main method-------");
        System.out.println("do nothing");
    
    }
    

    接下来是运行结果:

    这里写图片描述

    结果分析:

    代码很简单,分别在2个类中的基本属性,在JavaInitWithMain 类中的main方法中不做任何操作,查看结果。
    根据结果可知,JVM加载了JavaInitWithMain类之后初始化了该类的属性,顺序是 静态的—>非静态的—->构造方法,静态的包括静态的基本变量,静态的类类型变量,静态代码块,这三个的顺序是 程序员的书写顺序。
    得出结论:无继承关系时的初始化顺序 静态属性(静态基本变量,静态类类型变量,静态代码块)—>非静态的属性(基本类型变量,基本类类型变量,基本代码块)—>构造方法

    存在继承关系的初始化

    类基本不变,增加TestB的子类TheSonofTestB,如下

    public class TheSonofTestB extends TestB {

    private  static String tag = "TheSonofTestB";
    //静态变量
    private static int  staticVarA = initVar("staticVarA");
    
    //静态代码块
    static{
        initVar("static init block ");
    }
    //普通变量
    private  int normalA = initVar("normalA");
    
    // 普通代码块
    {
        initVar("normal init block");
    }
    
    public TheSonofTestB(){
        System.out.println(initVar("constructor"));
    }
    static int initVar(String str){
    
        System.out.println(tag +" "+str);
    
        return 2019;
    }
    

    }

    JavaInitWithMain中增加静态的属性,同时为了方便查看去掉了改类中的静态类变量和静态类类型变量,如下:
    private static TheSonofTestB sonNB = new TheSonofTestB();

    查看 输出结果,如下:

    同样分析下结果:
    初始化sonNB 时先去初始化其基类的静态属性,然后初始化TheSonofTestB的静态属性,接下来是父类的基本变量,父类的构造,子类的基本变量,最后子类自己的构造。

    得出结论:
    不管是本类存在继承还是本类的类对象属性存在继承,在初始化时都是:
    父类的静态属性—->子类的静态属性—->父类的基本类型属性—->父类的构造—>子类的基本属性—->子类的构造

    这里写图片描述

    写在最后

    最后我想说2点:
    1:不管存在不存在继承,静态的属性—>非静态的属性—->构造方法 都是初始化的顺序,存在继承时,依然一样,只不过父类和子类的这些属性交替进行
    2:思考问题:
    子类如果覆盖了父类的静态属性,那么调用子类的静态属性时,静态属性的值应该是什么?子类是静态属性共有几个?各位可自行试验

    代码工程在:
    https://github.com/android-zhao/JavaInit

    展开全文
  • 加载、验证、准备、初始化和卸载这5个阶段的顺序是肯定的,加载过程必须按照这种顺序按部就班地开始,而解析阶段则不一定:它在某些情况下可以在初始化阶段后再开始,这是为了支持Java语言的运行时绑定(也被...

    类从被加载到虚拟机内存中开始,到卸载出内存为止,它的整个生命周期包括:加载,验证,准备,解析,初始化,使用,卸载7个阶段。其中验证、准备、解析三个部分统称为连接。7个阶段的顺序如图:

    这里写图片描述

    加载、验证、准备、初始化和卸载这5个阶段的顺序是肯定的,类的加载过程必须按照这种顺序按部就班地开始,而解析阶段则不一定:它在某些情况下可以在初始化阶段后再开始,这是为了支持Java语言的运行时绑定(也被称为动态绑定或者晚期绑定)。注意,这里笔者写的是按部就班地“开始”,而不是按部就班地“进行”或“完成”,强调这点是因为这些阶段通常都是互相交叉地混合式进行的,通常会在一个阶段执行的过程中调用、激活另外一个阶段。

    什么情况下需要开始类加载过程的第一个阶段:加载?Java虚拟机规范中并没有进行强制约束,这点可以交给虚拟机的具体实现来自由把握。但是对于初始化阶段,虚拟机规范则是严格规定了下面的几种情况必须立即对类进行“初始化”(而加载、验证、准备自然需要在此之前开始):

    • 创建类的实例
    • 访问类的静态变量(注意:当访问类的静态并且final修饰的变量时,不会触发类的初始化。),或者为静态变量赋值。
    • 调用类的静态方法(注意:调用静态且final的成员方法时,会触发类的初始化!一定要和静态且final修饰的变量区分开!!
    • 使用java.lang.reflect包的方法对类进行反射调用的时候,如果类没有进行过初始化,则需要先触发其初始化。如:Class.forName("bacejava.Langx");
    • 注意通过类名.class得到Class文件对象并不会触发类的加载。
    • 初始化某个类的子类
    • 直接使用java.exe命令来运行某个主类(java.exe运行,本质上就是调用main方法,所以必须要有main方法才行)。
    • 注意:通过子类调用父类的静态成员时,只会初始化父类而不会初始化子类。 因为没有调用子类的相关静态成员,这也叫做能不加载不加载原则。
    • 注意:调用静态成员时,会加载静态成员真正所在的类及其父类。 这也好理解,因为本类的父类没有加载就会先去加载父类。
    • 注意:类的加载成功后,即静态成员都被加载后,是不会再加载第二次的。只有非静态成员,如非静态成员变量、非静态代码块、非静态方法(不调用不加载)、构造方法都会被多次实例化的时候多次加载。
    • 注意:如果静态属性有 final 修饰时,则不会加载,当成常量使用。例:public static final int a =123; public static final int a=5/3*2+1;public static final double a=Math.PI;等
    • 注意:但是静态属性 有final修饰 时也有情况会被加载,public static final int a=getNum();这样也会被加载。getNum()是静态方法,并且不管这个静态方法是子类的还是父类的;
    • 在上面触发类被初始化的情况称为对类的主动引用,除此之外,那些引用类的方式没有触发初始化的叫做被动引用

    在《深入理解java虚拟机之jvm高级特性与最佳实践》中有一段耐人寻味的讲解:

    展开全文
  • 如果这段代码的执行结果你都指导,你对类加载初始化的时机就已经掌握了。 看完此代码,你在自己的IDE上敲一敲此段代码,然后再来看我的总结,你就知道类初始化的时机,遇到什么才会触发初始化。 总结: 1、...
  • Java类加载机制(初始化顺序)

    千次阅读 2018-01-06 16:25:16
    之前写过一篇关于Java中普通代码块static代码块的区别,大致讲解了普通代码块Static代码的区别,但是并没有讲它们的加载执行顺序,本章就细细的将一下加载机制(初始化顺序)。 生命周期 的字节码从...
  • 类加载器(ClassLoader),顾名思义,即加载类的东西。 在我们使用一个之前,JVM需要先将该的字节码文件(.class...class的装载包括3个步骤:加载(loading),连接(link),初始化(initialize) 1、由new关...
  • JAVA类初始化顺序总结

    万次阅读 多人点赞 2018-09-27 23:16:24
    初始化 {#articleHeader1} 初始化顺序 首先来看下,当一个从main入口方法,对于静态变量、静态初始化块、变量、初始化块、构造器,它们的初始化顺序: public class ClassLoadTest { private static User user...
  • Java类加载、链接和初始化

    千次阅读 2016-08-30 15:14:29
    Java类加载、链接、初始化
  • @java类加载顺序 Java类加载顺序 父类静态代变量、 父类静态代码块、 子类静态变量、 子类静态代码块、 父类非静态变量(父类实例成员变量)、 父类构造函数、 子类非静态变量(子类实例成员变量)、 子类构造...
  • 函数(即初始化父类对象)  2).会给所有的非静态变量赋默认值  3).给所有的非静态成员变量赋值(即等号后面的值),此时count3  没有重新赋值而count4重新赋值为3,然后调用构造方法 4.接着给下面的静态...
  • Java类初始化、变量的初始化

    万次阅读 2018-06-02 15:21:23
    Java类初始化、变量的初始化知识点Java常量, final 修饰,值被设定后不能再被修改静态变量里, static 修饰,顾名思义,无须创建对象,便可在内存中申请一个存储空间进行存储成员变量, 也称实例变量,它随着当前...
  • Java类初始化 实例化区别

    千次阅读 2020-09-23 17:13:30
    初始化只在类加载的时候执行一次。的实例化:是指创建一个对象的过程。这个过程中会在堆中开辟内存,将一些非静态的方法,变量存放在里面。在程序执行的过程中,可以创建多个对象,既多次实例化。每次实例化都会...
  • 浅谈Java类加载初始化阶段

    千次阅读 2016-01-18 22:04:30
    类加载初始化阶段对变量赋予正确的值。主要有两种初始化方式,一种是通过变量初始化语句;一种是静态初始化语句。如下述代码所示,前者是变量初始化语句,后者是静态初始化语句。
  • Java代码在编译后会转化成Java字节码,字节码被类加载加载到JVM里,JVM执行字节码,最终需要转化成汇编指令在CPU上执行,Java中所使用的并发机制依赖于JVM的实现CPU的指令。 ...
  • java类初始化和构造函数

    千次阅读 2015-07-24 15:44:24
    本人小白一枚,看java类初始化的时候好晕的说,我觉着书上虽然说的对,但总觉得有些信息没说出来,没说清楚,看了好多文章博客的,现在有些感悟,来小写下总结,也算是为以后再次复习种个好果子。  先摘一下书上...
  • 什么是加载 jvm将class文读取到内存中,经过对class文件的校验、转换解析、初始化最终在jvm的heap方法区分配内存形成可以被jvm直接使用的类型的过程。...加载 验证 准备 初始化和卸载 的...
  • Java类加载过程对象实例详解

    千次阅读 2017-11-19 17:21:28
     从被加载虚拟机内存中开始,到卸载出内存为止,他的整个生命周期包括:加载、验证、准备、解析、初始化、使用卸载。其中验证、准备、解析3个阶段统称为连接。 ![的生命周期]...
  • Java 类初始化(详解)

    万次阅读 多人点赞 2017-02-22 23:53:25
    JVM 如何进行初始化,实例的初始化,构造器的作用与调用。
  • JAVA类加载和初始化

    千次阅读 2015-04-23 22:25:06
    Java程序运行由java虚拟机负责。加载到虚拟机内存到卸载出内存,包括 加载-----链接-----初始化-----使用------卸载 链接具体包括:验证-----准备-----解析   加载:由类加载器执行...初始化:该具有基类,
  • 简单概括一下,从IDEA中java文件运行开始→java文件会通过java编译器转换为class文件→class文件由类加载器子系统处理→加载完后JVM对进行分配处理→最后由jvm与操作系统、硬件交互。 简单概括就是以上几步过程,...
  • Java加载类并不一定初始化

    千次阅读 2019-06-25 19:04:13
    假设有class Student 一、加载类初始化的情况...这两种情况下,加载类,但是不会“链接“初始化” 通过命令:java -verbose:class test查看类加载加载类情况可知加载了。 但是这个的静态属性在方法区...
  • java静态方法实例方法以及父子类初始化加载顺序

    万次阅读 多人点赞 2015-09-23 12:36:15
    Java程序启动class文件被读取时加载,如果有static方法,此时会分配内存,非static方法实例化类时才在内存中分配控件存储,引用存储在堆栈中,实体存储在堆中 最大的区别在于内存。 静态方法在程序开始时生成...
  • 类加载和初始化

    千次阅读 2019-01-27 20:25:47
    程序使用某个时,如果该没有被加载到内存中,则系统会通过加载、连接、初始化3个步骤对该进行初始化类加载指的是将的class 文件读入内存,并创建一个java.lang.Class 对象,程序使用任何时系统都会建立...
  • Java类初始化的详解

    千次阅读 2014-12-29 23:02:06
    前两周看到了Java编程思想的初始化及类的加载那里,一直没找时间把它总结出来,对于初始化和类加载过程,感觉Java编程思想讲的较浅还不够深入,于是我结合Java疯狂讲义2和人家博客后,就打算按照自己的理解来把它...
  • 一个加载进内存到卸载出内存为止,一共经历7个阶段: 加载—&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;验证—&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;...
  • java梳理-深入理解类加载初始化

    千次阅读 2016-04-11 18:25:26
    概述 类加载器(class loader)用来加载 Java Java 虚拟机中。一般来说,Java 虚拟机使用 Java 的方式如下:Java 源程序(.java 文件)在经过 Java 编译器编译之后就被转换成 Java 字节代码(.class 文件)。...
  • Java类加载机制的七个...而 JVM 虚拟机执行 class 字节码的过程可以分为七个阶段:加载、验证、准备、解析、初始化、使用、卸载。 加载 下面是对于加载过程最为官方的描述。 加载阶段是类加载过程的第一个阶...
  • Java类初始化顺序 Java 父类构造函数,父类静态成员变量,父类普通成员变量,父类静态代码块,父类代码块, 子类构造函数 子类静态成员变量,子类普通成员变量,子类静态代码块,子类代码块执行顺序 没有继承...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 457,051
精华内容 182,820
关键字:

java类的初始化和类加载

java 订阅