精华内容
下载资源
问答
  • unity 静态代码块和构造方法执行时机次数.pdf
  • import java.lang.reflect.... * 验证静态代码块和构造代码块执行顺序 * * 1.加载父类静态代码块 * 2.加载子类静态代码块 * 3.加载父类构造代码块 * 4.父类构造方法 * 5.子类构造代码块 * 6.子类构造方法
    package com.uno.staticBlock;
    
    import java.lang.reflect.Field;
    import java.util.Vector;
    
    /**
     * 验证静态代码块和构造代码块执行顺序
     * 
     * 1.加载父类静态代码块
     * 2.加载子类静态代码块
     * 3.加载父类构造代码块
     * 4.父类构造方法
     * 5.子类构造代码块
     * 6.子类构造方法
     * @author uno
     *
     */
    public class StaticBlock {
    
    	//1.加载MyClass时,不一定会执行static代码块
    	static ClassLoader loader = Thread.currentThread().getContextClassLoader();
    	public static void main(String[] args) {
    		printClassesOfClassLoader(loader);
    //		testClassLoader();
    		new SON();
    		printClassesOfClassLoader(loader);
    	}
    	/**
    	 * 测试静态代码块是否执行
    	 * 
    	 * 2017年11月20日
    	 * author: leipan
    	 */
    	public static void testClassLoader(){
    //		System.out.println("此方法加载class后不会执行static代码块," + MyClass.class + ",但会加载到ClassLoader中。");
    	}
    	
    	
    	 public static void printClassesOfClassLoader(ClassLoader loader){  
    	        try {  
    	            Field classesF = ClassLoader.class.getDeclaredField("classes");  
    	            classesF.setAccessible(true);  
    	            Vector<Class<?>> classes = (Vector<Class<?>>) classesF.get(loader);  
    	            for(Class c : classes) {  
    	                System.out.println(c);  
    	            }  
    	        } catch (NoSuchFieldException e) {  
    	            e.printStackTrace();  
    	        } catch (IllegalAccessException e) {  
    	            e.printStackTrace();  
    	        }  
    	    }  
    }
    
    class Father {
    	static {
    		System.out.println("Father static exec。");
    	}
    	{
    		System.out.println("Father unstatic exec。");
    	}
    	
    	public Father (){
    		System.out.println("Father Construction。");
    	}
    }
    class SON extends Father{
    	static {
    		System.out.println("myClass static exec。");
    	}
    	{
    		System.out.println("myClass unstatic exec。");
    	}
    	public SON (){
    		System.out.println("Son construction。");
    	}
    }
    


    结果:

    class com.uno.staticBlock.StaticBlock
    Father static exec。
    myClass static exec。
    Father unstatic exec。
    Father Construction。
    myClass unstatic exec。
    Son construction。
    class com.uno.staticBlock.StaticBlock
    class com.uno.staticBlock.Father
    class com.uno.staticBlock.SON
    


    展开全文
  • 静态代码块以及构造函数的执行先后顺序,一直很迷惑,现用下面的这段小程序来简明扼要的叙述一下,以加深理解,与君共勉....    public class Fu {  static {
      对静态代码块以及构造函数的执行先后顺序,一直很迷惑,现用下面的这段小程序来简明扼要的叙述一下,以加深理解,与君共勉....
                                 

                    public class Fu {

                                          static {
                                                System.out.print(1);

                                                      }

                                          public Fu() {
                                                 System.out.print(2);
                                                     }
                                              }

                   public class Zi extends Fu {

                                           static {
                                                System.out.print("a");
                                                     }

                                           public Zi() {
                                                System.out.print("b");
                                                       }
                                               }

               public class demo {

                              public static void main(String[] args) {
                                             Fu fu = new Zi();
                                             fu = new Zi();
                                                          }
                                                 }

    1.
           当父类与子类都有静态代码块和构造函数的时候,执行顺序如下:

           父类静态代码块 > 子类静态代码块 java虚拟机加载类时,就会执行该块代码。

           父类构造函数 > 子类构造函数 (先有父亲,后有孩子)

           如果是多级继承关系的话,高层的父类首先执行,然后依次递减

        总结:静态优先执行,父类优先于子类执行
                    静态代码块是在JVM加载类的时候执行的,而且静态代码块执行且仅执行一次


    2.

           在调用类中的方法时,在方法体执行之前,首先要对类中的成员变量进行赋值,如果代码中没有赋具体的值,就会赋予变量默认值。成员变量的赋值顺序按照前后顺序进行。如果代码中既有直接赋值,也有构造方法赋值,那么根据先后顺序执行

    展开全文
  • 若仅声明为static,打印Parent.CITY_NAME时会先执行静态代码块,而打印Parent.RG_CODE却不会。 public static final Color COLOR_RED=new Color(255,0,0); 引用类似这些非常数静态域时会执行static代码块, 2...

    Java在它开始运行之前并非被完全加载,其各个部分仅在必需时才加载。

    import java.awt.Color;


    import smallbird.Tools;


    public class Parent {

    public static final String RG_CODE="025";

    public static String CITY_NAME="南京";

    public static Color COLOR_RED=new Color(255,0,0); 

    public static final Object obj=new Child();

    static {
    System.out.println("static code block."+Tools.getNowDate());
    }


    public Parent() {
    System.out.println("Parent's Constructor."+Tools.getNowDate());
    }

    public void speak() {
    System.out.println("Parent's speak.");
    }
    }


    1、建议将一些常量声明为final static编译期常量。


    若仅声明为static,打印Parent.CITY_NAME时会先执行静态代码块,而打印Parent.RG_CODE却不会。

    public static final Color COLOR_RED=new Color(255,0,0); 引用类似这些非常数静态域时会执行static代码块,

    2、使用.class来获得对类的引用不会初始化


    3、先初始化静态属性,再执行静态代码块

    System.out.println("test: "+new Parent());

    执行结果:

    Parent's Constructor.2015-06-29 22:06:55,577
    Child's Constructor.
    static code block.2015-06-29 22:06:55,578
    Parent's Constructor.2015-06-29 22:06:55,578
    test: basic.Parent@ae94e92

    展开全文
  • 当父类与子类都有静态代码块和构造函数的时候,执行顺序如下: 父类静态代码块 > 子类静态代码块 父类构造函数 > 子类构造函数(先有父亲,后有孩子) 如果是多级继承关系的话,最高层的父类首先执行,然后依次...
    public class A {
    
        static{
            System.out.print(1);
        }
        public A(){
            System.out.print(2);
        }
    }
    
    public class B extends A{
    
        static{
            System.out.print("a");
        }
        public B(){
            System.out.print("b");
        }
    }
    
    public class C {
    
        public static void main(String[] args){
            A a = new B();
            a = new B();
        }
    }
    
    
    父类与子类执行的先后顺序
    静态变量的执行特性
    方法重写(override)的注意事项
    1.
    当父类与子类都有静态代码块和构造函数的时候,执行顺序如下:
    父类静态代码块 > 子类静态代码块
    父类构造函数 > 子类构造函数(先有父亲,后有孩子)
    如果是多级继承关系的话,最高层的父类首先执行,然后依次递减
    
    总结:静态优先执行,父类优先执行
    注意:静态代码块是在JVM加载类的时候执行的,而且静态代码块执行且仅执行一次
    
    2.
    在调用类中的方法时,在方法体执行之前,首先要对类中的成员变量进行赋值,如果代码中没有赋具体的值,也有默认值。成员变量的赋值顺序按照前后顺序进行。
    如果有既有直接赋值,也有构造方法赋值,那么根据先后顺序执行
    
    3.
    重写(Override) 重载(Overload)
     重载是方法名字,返回类型一致,唯一不同的是方法的参数不同(参数类型不同,或者参数类型不同)
    
    重写:
    1. 发生方法重写的两个方法返回值,方法名,参数列表必须完全一致
    2. 子类抛出的异常不能超过父类相应的方法抛出的异常
    3. 子类方法的访问级别不能低于父类相应方法的访问级别(public,package,protected, private)
    
    多态:父类的引用指向了子类的对象,调用时执行的方法也是子类的方法,父类的方法并不会被执行
    
    所谓多态就是父类或者接口类型的引用可以指向子类或者实现该接口的类的实例(对象)
    
    看了上面的说明,大家也应该知道上面的程序输出结果了。
    输出结果为:1a2b2b
    

    
    
    展开全文
  • 其中一篇是“Java常见笔试、面试题目深度剖析第二讲:方法重写详解、静态代码块构造方法执行顺序问题 ”。 虽然张龙老师讲解的这些知识在做开发的时候不一定要用到,但是确实有一点是我以前所不了解的。干脆直接...
  • 下面小编就为大家带来一篇java中的静态代码块、构造代码块、构造方法详解。小编觉得挺好的,现在分享给大家。给大家一个参考。一起跟随小编过来看看吧
  • 接下来看探讨静态代码块,构造代码块和构造方法间的执行顺序 输出结果为: 看到main方法中的第一行语句并不是最先被执行,同时也看到static块只会执行一次 static块(静态代码块)可以置于类中的任何地方,类...
  • 静态代码块以及构造函数的执行先后顺序,一直很迷惑,直到最近看到一段代码,发现终于弄懂了,所以这篇文章主要给大家介绍了关于如何判断java中静态代码块构造方法的执行顺序的相关资料,需要的朋友可以参考下。
  • 静态方法在访问本类的成员时,只允许访问静态成员(即静态成员变量静态方法),注意图一,调用静态方法时只执行了静态代码块和静态方法,而不允许访问实例成员变量实例方法;实例方法则无此限制 static{}静态...
  • 构造代码块、静态代码块构造方法是三种不同的代码块,那么他们到底有什么区别呢? 一、简单认识一下构造代码块、静态代码块构造方法 class A { //构造代码块 { System.out.println("构造代码块A"); } //...
  • JAVA中静态方法,静态代码块构造方法的输出顺序 今天学习JAVA的时候遇到了一些问题,分不清楚静态方法,静态代码块以及构造方法的调用顺序,写了一个代码帮助我解决了这些问题,如果你也有同样的疑问,不防看看...
  • Java静态代码块、构造代码块、构造方法的执行顺序静态代码优先于非静态的代码,是因为被static修饰的成员都是类成员,会随着JVM加载类的时候加载而执行,而没有被static修饰的成员也被称为实例成员,需要创建对象才...
  • 在学习Java基础期间,子父类的静态代码块、构造代码块、构造方法的执行顺序容易混淆,现在通过一段程序来说明它们的执行顺序。 一、先看一个简单的静态测试程序: 运行结果: 执行父类的静态代码...
  • 静态代码块,构造代码块,构造方法的执行顺序? 静态代码块 -- 构造代码块 -- 构造方法 静态代码块:只执行一次 构造代码块:每次调用构造方法都执行 ...
  • 最近在刷牛客网的题目看到有关静态代码块、构造代码块、构造方法的执行顺序的问题,因为基础不牢固没选出正确答案,当然要将这个知识点重新掌握,写篇博客来记录一下学习的过程。  先了解一下相关概念: 静态...
  • 直接上代码,简洁明了!... System.out.println("静态代码块"); } {//构造方法块 System.out.println("构造方法块"); } public Main(){//构造方法 System.out.println("构造方法"); } publi...
  • 静态代码块和构造代码块

    千次阅读 2014-06-19 02:32:45
    Java有四种代码块,分别是普通代码块(如方法后大括号中的代码)、构造代码块、静态代码块、同步代码块(与多线程数据安全有关)。 1.静态代码块 使用static关键字修饰的代码块称为静态代码块,一般用于初始...
  • 静态初始化代码块、构造代码块构造方法 (2)如果有父类子类,执行顺序: 1.父类静态初始化代码块、子类静态初始化代码块 2.父类构造代码块、父类构造方法 3.子类构造代码块、子类构造方法 代码举例: ...
  • 执行顺序记住两个优先: 静态优先,父类优先!... //静态代码块 static{ System.out.println("父类的静态代码块"); } //父类的构造方法 public A(){ System.out.println("父类的构造方法"); } }代码:子类B
  • //执行顺序:(优先级从高到低)静态代码块>mian方法>构造代码块>构造方法。 //其中静态代码块只执行一次。构造代码块在每次创建对象是都会执行。 1 普通代码块 普通代码块:在方法或语句中出现的{}就称为普通代码...
  • 静态代码块:使用static修饰,在类加载的时候先执行。 构造代码块:出现在成员位置,执行顺序上,优先于构造方法执行。 构造方法:与类同名且没有返回值,相同的部分抽取出来执行。 例子: /* 在程序中出现的{}括...
  • 父类的静态代码块 b.子类的静态代码块 c.父类的构造代码块 d.父类的构造方法 e.子类的构造代码块 f.子类的构造方法演示父类:package t1;/** * Created by Administrator on 2017/6/4. */ public class ...
  • 执行顺序静态代码块>main()方法>构造方法>普通代码块简单的给大家分析一下,当jvm加载类的时候是将类文件中的内容一行一行的加载到内存中的(除了实例变量,因为这是对象私有的),但不执行任何语句,即使...
  • 当然,首先大家得知道静态代码块是跟着类的加载而加载的,而构造代码块和构造方法是随着对象的加载而加载的,相比这个问题大家都已经很熟悉了。 以下是测试用的一个小Demo,便于更清楚的说明事实:   package ...
  • 首先要知道静态代码块是随着类的加载而加载,而构造代码块和构造方法都是随着对象的创建而加载 当时做了这么一个小案例(想必这个大多数学java的都做过,不知道是否都理解了) class Fu{ static { System.out.pr...
  • 首先要知道静态代码块是随着类的加载而加载,而构造代码块和构造方法都是随着对象的创建而加载 当时做了这么一个小案例(想必这个大多数学java的都做过,不知道是否都理解了) class Fu{ static { System.out....
  • java中类的静态代码块、构造代码块、构造方法、静态成员的初始化顺序:  首先,在类加载时,为类中的静态成员变量分配内存空间,并为其赋予默认值(整数型为0,浮点型为0.0,布尔型为false,字符型为'\u0000',引用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 231,099
精华内容 92,439
关键字:

静态代码块和构造方法