精华内容
下载资源
问答
  • 类初始化和实例初始化

    千次阅读 2019-02-22 16:38:37
    一、类初始化过程 1.一个类要创建实例需先加载并初始化该类 (1)、main方法下的类需要先加载和初始化  (2)、一个子类初始化需要先初始化他的父类 (3)、一个类初始化就是执行<clinit> ()方法  ...

     

     

    一、类初始化过程

    1.一个类要创建实例需先加载并初始化该类

    (1)、main方法下的类需要先加载和初始化 

    (2)、一个子类初始化需要先初始化他的父类

    (3)、一个类初始化就是执行<clinit>  ()方法

           说明: <clinit>  ()方法由静态变量显示赋值代码和静态代码块组成,静态变量显示赋值代码和静态代码块从上到下顺序执行,<clinit>方法只执行一次   

    二、实例初始化过程

    1.实例初始化就是执行<init>()方法

    (1)<init>()方法可能重载有多个,有几个构造器就有几个<init>()方法

    (2)<init>()方法由非静态变量显示赋值代码和非静态代码块、对应构造器代码组成

    (3)非静态变量显示赋值代码和非静态代码块从上到下顺序执行,最后执行构造器代码

    (4)每次创建实例对象,调用对应构造器,执行的都是<init>()方法

    (5)<init>()方法的首行是super()或super(实参列表),即对应父类的<init>()方法

    方法的重写Override

    1.哪些方法不可以被重写

    (1)、静态方法

    (2)、private方法(子类方法不可见)

    (3)final方法

    2.对象多态性

    (1)、子类如果重写了父类的方法,通过子类调用的一定是子类重写过的方法

    (2)、非静态方法默认调用的是this

    (3)、this对象在构造器或者说<init>()方法中就是正在被创建的对象

    展开全文
  • Java 类初始化

    千次阅读 2018-09-09 18:02:02
    Java 类初始化介绍 java语言在使用过程中最先开始就是初始化,在工作中如果遇到什么问题需 要定位往往到最后也可能是初始化的问题,因此掌握初始化的顺序很重要。 根据java 语言特性,本人针对初始化中常遇到的...

    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

    展开全文
  • 类初始化阶段详解

    千次阅读 2018-03-04 20:46:24
    一个Java的完整的生命周期会经历加载、连接、初始化、使用、和卸载五个阶段,当然也有在加载或者连接之后没有被初始化就直接被使用的情况。如图所示: 初始化做了什么 为的静态变量赋予正确的初始值...

    一个Java类的完整的生命周期会经历加载、连接、初始化、使用、和卸载五个阶段,当然也有在加载或者连接之后没有被初始化就直接被使用的情况。如图所示:
    类加载的生命周期

    类的初始化做了什么

    • 为类的静态变量赋予正确的初始值。
    • 执行类的静态代码块。

    按照顺序自上而下运行类中的变量赋值语句和静态语句,如果有父类,则首先按照顺序运行父类中的变量赋值语句和静态语句。

    什么时候类会被初始化

    • 只有类或接口被Java程序首次主动使用时才初始化他们。

    主动使用(7种)

    • 创建类的实例(new)。
    • 访问某个类或接口的静态变量,或者对该静态变量赋值。
    • 调用类的静态方法。
    • 通过反射方式执行以上三种行为。
    • 初始化子类的时候,会触发父类的初始化。
    • Java虚拟机启动时被标明为启动类的类。(有main方法的类)
    • JDK 1.7开始提供的动态语言支持。(了解即可)

    除了以上7种情况,其它使用Java类的方式都被看作是对类的被动使用,都不会导致类的初始化。


    类的静态字段和类初始化

    根据主动使用导致类的初始化规则,访问类的静态变量会导致类的初始化。

    /**
     * 对于静态字段来说,只有直接定义了该字段的类才会被初始化,
     * 当一个类初始化时,要求其父类全部都已经初始化完毕了。
     *
     * -XX:+TraceClassLoading,用于追踪类的加载信息并打印。
     * -XX:+TraceClassUnLoading,用于追踪类的卸载信息并打印。
     */
    public class MyTest1 {
        public static void main(String[] args) {
            System.out.println(MyChild1.str2);
        }
    }
    
    class MyParent1 {
        public static String str = "hello world";
    
        static {
            System.out.println("MyParent1 static block");
        }
    
    }
    
    class MyChild1 extends MyParent1 {
        public static String str2 = "welcome";
        static {
            System.out.println("MyChild1 static block");
        }
    }
    
    

    打印的结果是:

    MyParent1 static block
    MyChild1 static block
    welcome
    

    访问MyChild1类的静态字段str2,使得类MyChild1被初始化,子类的初始化触发父类的初始化,所以MyParent1类初始化。

    如果访问MyChild1.str,那么打印的结果变成:

    MyParent1 static block
    hello world
    

    因为对于静态字段来说,只有直接定义了该字段的类才会被初始化


    类的编译期常量和类初始化

    public class MyTest2 {
        public static void main(String[] args) {
            System.out.println(MyParent2.str);
        }
    }
    
    class MyParent2 {
        public static final String str = "hello world";
        static {
            System.out.println("MyParent2 static block");
        }
    }
    

    打印结果:

    hello world
    

    这里MyParent2的静态代码块没有执行,说明MyParent2没有被初始化!其实MyParent2类在这里没有被主动使用,所以没初始化。因为静态字段str 是常量。常量在编译阶段会存入到调用这个常量的方法所在类的常量池中。本质上,调用类并没有直接引用到定义常量的类,因此不会触发定义常量类的初始化,也不会加载这个类。


    类的运行期常量和类初始化

    public class MyTest3 {
        public static void main(String[] args) {
            System.out.println(MyParent3.str);
        }
    }
    
    class MyParent3 {
        public static final String str = UUID
    									.randomUUID()
    									.toString();
    
        static {
            System.out.println("MyParent3 static block");
        }
    }
    

    打印结果:

    MyParent3 static block
    4e5bc60b-ec26-40c1-aeea-a5eddcb2dbaf
    

    静态代码块执行,说明类MyParent3 被初始化。这个例子与上个例子不一样的是这里的常量不是编译阶段就可以确定的,它要运行期间才确定。
    当一个常量的值并非编译期间可以确定的,那么其值就不会被放到调用类的常量池中,这时在程序运行时,会导致主动使用这个常量所在的类,显然会导致这个类会初始化。


    接口初始化规则

    • 接口中的字段默认都是public static final。
    • 接口中不能定义静态代码块。
    • 当一个接口初始化时,并不要求其父接口都完成了初始化只有在真正使用到父接口的时候(如引用到接口中所定义的常量时),才会初始化(但子接口初始化,父接口一定会被加载)。
    public class MyTest5 {
        public static void main(String[] args) {
            System.out.println(MyChild5.b);
        }
    }
    
    
    interface MyParent5 {
        int a = new Random().nextInt(4);
        Thread thread1 = new Thread() {
            {
                System.out.println("MyParent5初始化了");
            }
        };
    }
    
    interface MyChild5 extends MyParent5 {
        int b = 4;
    
        Thread thread2 = new Thread() {
            {
                System.out.println("MyChild5初始化了");
            }
        };
    }
    

    打印结果:

    4
    

    因为接口里不能定义静态代码块,所以为了能看出接口是否被初始化,这里我在接口里定义个Thread类型的变量,并返回个对象引用。如果接口初始化了,它的Thread类型的变量一定会被实例化,就会执行定义的构造代码块里的代码。(静态代码块,局部代码块,构造代码块区别。

    这里没有打印构造代码块里的内容,说明接口没有被初始化。这是因为接口中的字段默认都是public static final。访问接口的(静态常量)字段不会导致接口初始化,这里跟访问类的静态常量字段一样的,所以上面的结论适用于接口。


    子接口初始化不会导致父接口初始化

    把上面的例子做个改动,如下。

    interface MyChild5 extends MyParent5 {
        int b = new Random().nextInt(4);
    
        Thread thread2 = new Thread() {
            {
                System.out.println("MyChild5初始化了");
            }
        };
    
      // public static int b = 4;
    }
    

    打印结果:

    MyChild5初始化了
    0
    

    这里的常量是运行期间才能确定,所以MyChild5接口被初始化。但是从结果明显看出,仅仅初始化了子接口并没有初始化父接口!
    但是类的初始化是:初始化子类的时候,会触发父类的初始化。这就是类的初始化和接口初始化的区别了。


    直接访问父接口定义的常量

    继续改进代码,如下:

    public class MyTest5 {
        public static void main(String[] args) {
            System.out.println(MyChild5.a);
        }
    }
    

    打印结果:

    MyParent5初始化了
    0
    

    直接访问父接口的静态常量字段a(运行期间确定),导致父接口初始化。


    实现类初始化不会导致接口初始化

    public class MyTest5 {
        public static void main(String[] args) {
            System.out.println(MyChild5.b);
        }
    }
    
    interface MyParent5 {
        int a = new Random().nextInt(4);
        Thread thread1 = new Thread() {
            {
                System.out.println("MyParent5初始化了");
            }
        };
    }
    
    class MyChild5 implements MyParent5 {
        public static Thread thread2 = new Thread() {
            {
                System.out.println("MyChild5初始化了");
            }
        };
        public static int b = 4;
    }
    

    打印结果:

    MyChild5初始化了
    4
    

    这个例子说明,子类被初始化了,但是它实现的接口没有初始化。


    总结

    类只有被首次主动使用时才会被初始化,主动使用有7种形式。这里我并没有对每一种主动使用都去举例论证。这几个例子是我在学习《深入理解JVM》这门课程时感觉最难理解的,也是最重要的知识点。

    • 编译期常量和运行期常量对类初始化的影响。
    • 初始化对于类与接口的异同点。

    其它几种对类的主动使用,大家可以自己去通过代码去验证文章的结论,这样能加深自己的理解。

    展开全文
  • JAVA类初始化顺序总结

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

    类的初始化

    初始化顺序

    首先来看下,当一个类从main入口方法,对于静态变量、静态初始化块、变量、初始化块、构造器,它们的初始化顺序:

    public class ClassLoadTest {
        private static User user = new User();
        static {
            System.err.println("static code block");
        }
    
    
        {
            System.err.println("code block");
        }
        private Student student = new Student();
        public ClassLoadTest(){
            System.err.println("Constructor");
        }
        public static void main(String[] args) {
            System.err.println("mian ==>");
            new ClassLoadTest();
        }
    }
    
    class Student{
        public Student(){
            System.err.println("student initint===>");
        }
    }
    
    class User {
        public User() {
            System.err.println("user initing===>");
        }
    }
    

    结论:

    正常类的加载顺序:静态变量/静态代码块 -> main方法 -> 非静态变量/代码块 -> 构造方法

    说明:静态代码块与静态变量的执行顺序同代码定义的顺序;非静态变量与代码块的执行顺序同代码执行顺序

    继承的情况

    class Parent {
    	/* 静态变量 */
    	public static String p_StaticField = "父类--静态变量";
    	/* 变量 */
    	public String p_Field = "父类--变量";
    	protected int i = 9;
    	protected int j = 0;
    	/* 静态初始化块 */
    	static {
    		System.out.println( p_StaticField );
    		System.out.println( "父类--静态初始化块" );
    	}
    	/* 初始化块 */
    	{
    		System.out.println( p_Field );
    		System.out.println( "父类--初始化块" );
    	}
    	/* 构造器 */
    	public Parent()
    	{
    		System.out.println( "父类--构造器" );
    		System.out.println( "i=" + i + ", j=" + j );
    		j = 20;
    	}
    }
    
    public class SubClass extends Parent {
    	/* 静态变量 */
    	public static String s_StaticField = "子类--静态变量";
    	/* 变量 */
    	public String s_Field = "子类--变量";
    	/* 静态初始化块 */
    	static {
    		System.out.println( s_StaticField );
    		System.out.println( "子类--静态初始化块" );
    	}
    	/* 初始化块 */
    	{
    		System.out.println( s_Field );
    		System.out.println( "子类--初始化块" );
    	}
    	/* 构造器 */
    	public SubClass()
    	{
    		System.out.println( "子类--构造器" );
    		System.out.println( "i=" + i + ",j=" + j );
    	}
    
    
    	/* 程序入口 */
    	public static void main( String[] args )
    	{
    		System.out.println( "子类main方法" );
    		new SubClass();
    	}
    }
    

    初始化顺序:

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

    结论:

    • 子类的静态变量和静态初始化块的初始化是在父类的变量、初始化块和构造器初始化之前就完成了;
    • 静态变量、静态初始化块顺序取决于它们在类中出现的先后顺序
    • 变量、初始化块初始化顺序取决于它们在类中出现的先后顺序

    分析

    • (1)访问SubClass.main()(这是一个static方法),于是装载器就会为你寻找已经编译的SubClass类的代码(也就是SubClass.class文件)。在装载的过程中,装载器注意到它有一个基类,于是再装载基类。不管你创不创建基类对象,这个过程总会发生。如果基类还有基类,那么第二个基类也会被装载,依此类推;

    • (2)执行基类的static初始化,然后是下一个派生类的static初始化,依此类推。这个顺序非常重要,因为派生类的“static初始化”有可能要依赖基类成员的正确初始化;

    • (3)当所有必要的类都已经装载结束,开始执行main()方法体,并用new SubClass()创建对象;

    • (4)类SubClass存在父类,则调用父类的构造函数,你可以使用super来指定调用哪个构造函数。基类的构造过程以及构造顺序,同派生类的相同。首先基类中各个变量按照字面顺序进行初始化,然后执行基类的构造函数的其余部分;

    • (5)对子类成员数据按照它们声明的顺序初始化,执行子类构造函数的其余部分;

    static变量

    public class Test {
    
    	static {
    		i = 0; // 给变量复制可以正常编译通过
    		// System.out.print(i); // 这句编译器会提示“非法向前引用”
    	}
    	static int i = 1;
    	
    	static int j = 1;
    	
    	static{
    		j = 2;
    	}
    
    	public static void main(String[] args){
    		System.out.println(Test.i); //1
    		System.out.println(Test.j); //2
    	}
    }
    

    不触发初始化实例

    /**
    * 被动使用类字段演示一:
    * 通过子类引用父类的静态字段,不会导致子类初始化
    **/
    class SuperClass {
    
    	static {
    		System.out.println("SuperClass init!");
    	}
    	
    	public static int value = 123;
    	}
    
    class SubClass extends SuperClass {
    
    	static {
    		System.out.println("SubClass init!");
    	}
    }
    
    /**
    * 非主动使用类字段演示
    **/
    public class NotInitialization {
    
    	public static void main(String[] args) {
    		// System.out.println(SubClass.value);
    		//SuperClass init!
    		//123
    	
    		/**
    		* 被动使用类字段演示二:
    		* 通过数组定义来引用类,不会触发此类的初始化
    		**/
    		SuperClass[] sca = new SuperClass[10];
    	}
    }
    

    被动使用类字段

    /**
    * 被动使用类字段演示三:
    *
    * 常量在编译阶段会存入调用类的常量池中,本质上没有直接引用到定义常量的类,
    * 因此不会触发定义常量的类的初始化。
    
    **/
    public class ConstClass {
    
    	static {
    		System.out.println("ConstClass init!");
    	}
    	
    	public static final String HELLOWORLD = "hello world";
    }
    
    public class Test {
    	public static void main(String[] args){
    		System.out.println(ConstClass.HELLOWORLD);
    	}
    }
    

    输出

    hello world
    

    这里没有初始化ConstClass类,是因为在编译的时候,常量(static final 修饰的)会存入调用类的常量池【这里说的是main函数所在的类的常量池】,调用的时候本质上没有引用到定义常量的类,而是直接访问了自己的常量池

    静态方法调用

    当调用目标类的静态变量或静态方法时,不会触发该类的代码块或构造方法的执行,示例如下:

    public class ClassLoadTest {
    	public static void main(String[] args) {
    		// System.err.println(Handler.user);
    		Handler.print();
    	}
    }
    
    class Handler {
    	public static User user = new User();
    	static {
    		System.err.println("static code block");
    	}
    	{
    		System.err.println("code block");
    	}
    	public Handler(){
    		System.err.println("Constructor");
    	}
    	public static void print(){
    		System.err.println("static method");
    	}
    }
    
    class User {
    	public User() {
    		System.err.println("user initing===>");
    	}
    }
    

    参考 {#articleHeader13}

    java类的初始化顺序–http://blog.sina.com.cn/s/blog_4cc16fc50100bjjp.html

    Java类加载的时机 ——https://blog.csdn.net/imzoer/article/details/8038249

    展开全文
  • 最详细类初始化的顺序,一看就懂

    千次阅读 2019-06-06 15:31:25
    这方面知识一直没有整理,但大家经常讨论的静态变量、成员变量、静态初始化块、非静态初始化块、构造器,及继承父类时,它们的初始化顺序都是怎样的,所以找了个机会认真整理一下,帮助大家脱坑: 首先介绍一下这...
  • Java 类初始化(详解)

    万次阅读 多人点赞 2017-02-22 23:53:25
    JVM 如何进行初始化,实例的初始化,构造器的作用与调用。
  • java面试题-类初始化顺序

    千次阅读 2018-03-19 13:58:22
    所以这个时候子类不需要进行类初始化)。 6):直接运行一个main函数入口的类。 所有的JVM实现,在首次主动使用某类的时候才会加载该类。 被动使用例子: 7):子类调用父类的静态变量,子类不会被初始化。只有父类被...
  • Python类初始化 (Python class init) Whenever a beginner starts learning the Python programming language, they come across something like __init__ which usually they don’t fully understand. In this ...
  • 当父类的__init__构造函数中需要对数据进行初始化时, 在其派生的子类的__inti__方法中需要额外调用父类的__init__函数完成父类的初始化; class Base(): def __init__(self,character="%"): self.character =...
  • 接口初始化和类初始化区别

    千次阅读 2017-11-09 20:59:10
    虚拟机规范严格规定了有且只有四种情况必须立即对进行初始化: 1. 遇到new、getstatic、putstatic、invokestatic这四条字节码指令时, 如果还没有进行过初始化,则需要先触发其初始化。 生成这四条指令最常见...
  • Java的类初始化的详解

    千次阅读 2014-12-29 23:02:06
    前两周看到了Java编程思想的初始化的加载那里,一直没找时间把它总结出来,对于初始化的加载过程,感觉Java编程思想讲的较浅还不够深入,于是我结合Java疯狂讲义2和人家博客后,就打算按照自己的理解来把它...
  • 大部分面向对象语言都有一个叫做构造函数的特殊方法,当它被创建的时候就会创建和初始化对象。这里Python和它们有一点点不同,Python有一个构造函数和一个初始化函数。在大部分情况下,构造函数很少能...
  • python类初始化属性在def __init__()中定义,实例化对象后可直接调用 python类非初始化属性在def func()中定义,实例化对象后,先调用调用函数,再调用属性 代码 class Mdata(object): def __init__(self): ...
  • 父类静态域——>子类静态域——>父类成员初始化——>父类构造块——>父类构造方法——>子类成员初始化——>子类构造块——>子类构造方法;
  • 使用匿名内部类初始化集合类

    千次阅读 2017-04-25 22:54:37
    List<String> list = new ArrayList(){ { add("a");...这种写法,是使用匿名内部,继承自ArrayList,同时菱形运算符里的String不能省略,否则Eclipse会提示错误'<>' cannot be used with anonym
  • Java初始化、变量的初始化

    万次阅读 2018-06-02 15:21:23
    Java初始化、变量的初始化知识点Java常量, final 修饰,值被设定后不能再被修改静态变量里, static 修饰,顾名思义,无须创建对象,便可在内存中申请一个存储空间进行存储成员变量, 也称实例变量,它随着当前...
  • 最近接手实习生写的一个项目A,主要是往HDFS里写...其中把对HDFS的操作封装成了一个: public class HDFS { private static final String HDFS_ADDR = Config.HDFS_PATH; private static FileSystem fs; stati
  • 简单概括一下,从IDEA中java文件运行开始→java文件会通过java编译器转换为class文件→class文件由加载器子系统处理→加载完后JVM对进行分配处理→最后由jvm与操作系统、硬件交互。 简单概括就是以上几步过程,...
  • 类初始化

    千次阅读 2016-10-25 15:29:22
    主动引用类初始化是类加载过程的最后一个阶段,到初始化阶段,才真正开始执行类中的Java程序代码。虚拟机规范严格规定了有且只有四种情况必须立即对类进行初始化: 遇到new、getstatic、putstatic、invokestatic这四...
  • 深入理解Java对象的创建过程:初始化与实例化

    万次阅读 多人点赞 2017-05-18 14:17:45
    类初始化过程中或初始化完毕后,根据具体情况才会去对类进行实例化。本文试图对JVM执行类初始化和实例化的过程做一个详细深入地介绍,以便从Java虚拟机的角度清晰解剖一个Java对象的创建过程。
  • c++中的类继承以及类初始化顺序

    千次阅读 2013-12-11 20:59:37
    对于以及继承, 几个主要的问题: 1) 继承方式: public/protected/private继承. 这是c++搞的, 实际上继承方式是一种允许子类控制的思想. 子类通过public继承, 可以把基类真实还原, 而private继承则完全把基类...
  • 问题描述刚宿舍的问了个问题,简单的说就是编程遇到了如下的这种情况:class Node(object): def __init__(self ,childrenList=[], name = '.' ): self.name = name self.childrenList = childrenList ...
  • java静态方法和实例方法以及父子类初始化加载顺序

    万次阅读 多人点赞 2015-09-23 12:36:15
    Java程序启动class文件被读取时被加载,如果有static方法,此时会分配内存,非static方法实例化类时才在内存中分配控件存储,引用存储在堆栈中,实体存储在堆中 最大的区别在于内存。 静态方法在程序开始时生成...
  • @java的加载顺序 Java的加载顺序 父类静态代变量、 父类静态代码块、 子类静态变量、 子类静态代码块、 父类非静态变量(父类实例成员变量)、 父类构造函数、 子类非静态变量(子类实例成员变量)、 子类构造...
  • springboot之初始化操作

    千次阅读 2019-07-30 00:20:25
    springboot之初始化操作简介CommandLineRunnerApplicationRunner两者顺序是ApplicationRunner 在前,CommandLineRunner 在后 简介 大多数情况下,我们项目启动后执行一些初始化操作,springboot为我们提供了,...
  • 文章目录类加载机制类加载机制分类、类加载器、双亲委派机制类加载机制分类类加载器双亲委派机制加载.class文件的方式类生命周期类生命周期结束类加载过程JVM初始化步骤类加载时机类初始化时机类的初始化类的实例化 ...
  • c++初始化原理

    千次阅读 2018-08-17 23:11:54
    一、初始化时带括号和不带括号的区别 class Test4 { public: Test3 t3; Test4(){ t3 = Test3(); cout &lt;&lt; "Test4" &lt;&lt; endl; } }; int main() { Test3 t3; cout &...
  • python 的继承及初始化

    千次阅读 2019-05-17 09:38:39
    #初始化基类函数方法2:使用super函数,每个都被初始化一次,建议方式 super(C3, self).__init__(**kwargs) #按照继承关系逐步初始化基类 def myprint(self): #函数重写 print 'cbase3' if __name__=='__...
  • Java初始化顺序

    万次阅读 多人点赞 2018-07-05 10:03:23
    对于静态变量、静态初始化块、变量、初始化块、构造器,它们的初始化顺序依次是(静态... * 初始化顺序 * 静态变量-&gt;静态初始化块-&gt;变量-&gt;初始化块-&gt;构造器 * @author xiayunan ...
  • 和对象的初始化

    千次阅读 2018-06-03 17:26:29
    本文主要通过例子来理解 Java 中和对象的初始化顺序问题

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,213,311
精华内容 885,324
关键字:

类初始化