精华内容
下载资源
问答
  • 来吧,直接上代码~ /** * Created by gjj on 2018-04-18. */ public class Father { ...父类静态代码块"); } { System.out.println("父类构造代码块"); } public Fathe...
    来吧,直接上代码~
    /**
     * Created by gjj on 2018-04-18.
     */
    public class Father {
        static{
            System.out.println("父类静态代码块");
        }
        {
            System.out.println("父类构造代码块");
        }
        public Father(){
            System.out.println("父类构造函数");
        }
        public void ccc () {
            System.out.println("父类普通方法");
        }
        static class Son extends Father {
            private String abb = "1";
            static{
                System.out.println("子类静态代码块");
            }
            {
                System.out.println("子类构造码块");
            }
            public void abb () {
                System.out.println("子类普通方法");
            }
            public Son(){
                System.out.println("子类构造函数");
            }
        }
        public static void main(String[] args) {
            Father c = new Son();
        }
    }
    程序执行结果:
    E:\software\JAVA\JDK1.8\bin\java 
    父类静态代码块
    子类静态代码块
    父类构造代码块
    父类构造函数
    子类构造代码块
    子类构造函数
    
    
    Process finished with exit code 0
    
     

    所以执行顺序是 父类静态代码块 -> 子类静态代码块 -> 父类构造代码块 -> 父类构造函数 -> 子类构造代码块 -> 子类构造函数

    简单来说就是 先执行静态代码块 ,再执行父类的构造代码块和构造函数,最后执行子类的构造代码块和构造函数

    ~不喜欢篮球的摄影师不是一个好程序员~

    展开全文
  • 1、第一个文件Print.java public class Print {  public Print(String s){  System.out.print(s + " ");  } } 2、第二个文件Test1.java public class Test1...
    1、第一个文件Print.java
    
    1. public class Print {

    2.     public Print(String s){
    3.         System.out.print(+ " ");
    4.     }
    5. }

    2、第二个文件Test1.java
    1. public class Test1 {

    2.     public static Print obj1 = new Print("1");
    3.     
    4.     public Print obj2 = new Print("2");

    5.     public static Print obj3 = new Print("3");
    6.     
    7.     static{
    8.         new Print("4");
    9.     }
    10.     
    11.     public static Print obj4 = new Print("5");
    12.     
    13.     public Print obj5 = new Print("6");
    14.     
    15.     public Test1(){
    16.         new Print("7");
    17.     }
    18.     
    19. }

    3、第三个文件Test2.java
    1. public class Test2 extends Test1{

    2.     static{
    3.         new Print("a");
    4.     }
    5.     
    6.     public static Print obj1 = new Print("b");
    7.     
    8.     public Print obj2 = new Print("c");
    9.     
    10.     public Test2(){
    11.         new Print("d");
    12.     }
    13.     
    14.     public static Print obj3 = new Print("e");
    15.     
    16.     public Print obj4 = new Print("f");
    17.     
    18.     public static void main(String [] args){
    19.         Test1 obj1 = new Test2();
    20.         Test1 obj2 = new Test2();
    21.     }
    22. }

    执行main方法,程序输出顺序为: 1 3 4 5 a b e 2 6 7 c f d 2 6 7 c f d
    输出结果表明,程序的执行顺序为:
    如果类还没有被加载:
    1、先执行父类的静态代码块和静态变量初始化,并且静态代码块和静态变量的执行顺序只跟代码中出现的顺序有关。
    2、执行子类的静态代码块和静态变量初始化。
    3、执行父类的实例变量初始化
    4、执行父类的构造函数
    5、执行子类的实例变量初始化
    6、执行子类的构造函数
    如果类已经被加载:
    则静态代码块和静态变量就不用重复执行,再创建类对象时,只执行与实例相关的变量初始化和构造方法。
    展开全文
  • 父类静态(代码块,变量赋值二者按顺序执行) 子类静态 父类构造代码块 父类构造方法 子类构造代码块 子类构造方法 普通方法在实列调用的时候执行,肯定位于上面之后了 1 //父类A 2 public class A { ...

    父类静态(代码块,变量赋值二者按顺序执行)

    子类静态

    父类构造代码块

    父类构造方法

    子类构造代码块

    子类构造方法

    普通方法在实列调用的时候执行,肯定位于上面之后了

     1 //父类A
     2 public class A {
     3 
     4      A() {
     5          System.out.println("A构造方法");
     6      }
     7 
     8     {
     9          System.out.println("A构造代码块");
    10      }
    11     
    12          static{
    13          System.out.println("A静态码块");
    14      }
    15 
    16     public static void main(String[] args) {
    17             C c1=new C();        
    18         }
    //子类C
    public class C extends A {
        static {
            System.out.println("C的静态代码块");
        }
        {
             System.out.println("C构造代码块");
         }
         C() {
            System.out.println("C的构造方法");
        }
    }

    结果:

     这样就很明了了,下面稍微扩展一下,如果在main中出现 new A()呢?我们来看

     1 //父类A
     2 public class A {
     3 
     4     static{
     5          System.out.println("A静态码块");
     6      }
     7     
     8      A() {
     9          System.out.println("A构造方法");
    10      }
    11      
    12     {
    13          System.out.println("A构造代码块");
    14      }
    15     public static void main(String[] args) {
    16             A a=new A();
    17             C c1=new C();
    18         }    
    //子类C
    public class C extends A {
        static {
            System.out.println("C的静态代码块");
        }
        {
             System.out.println("C构造代码块");
         }
         C() {
            System.out.println("C的构造方法");
        }
    }

    结果:

      结果先执行完父类A,只执行子类C,并不是执行完A的静态就执行C的静态,这里可能有误区。

    博主实测,欢迎指正。

    转载于:https://www.cnblogs.com/walytong/p/9766308.html

    展开全文
  • JAVA父类子类静态代码块、非静态代码块、构造函数的加载顺序为:父类静态代码块>子类静态代码块>父类非静态代码块>父类构造函数>子类非静态代码块>子类构造函数。而对于多个静态代码块,它们加载顺序是按照文件...

    一顿操作猛如虎,算了直接上代码:

    /**
     * @author LGH
     * @date 2020/7/22 16:59
     */
    public class Supper {
        static {
            System.out.println("父类--静态代码块1");
        }
    
        {
            System.out.println("父类--非静态代码块1");
        }
    
        public Supper() {
            System.out.println("父类--构造函数");
        }
    
    
        public static void main(String[] args) {
            System.out.println("main函数");
            new Child();
        }
    
        static {
            System.out.println("父类--静态代码块2");
        }
    
        {
            System.out.println("父类--非静态代码块2");
        }
    }
    
    class Child extends Supper {
        static {
            System.out.println("子类--静态代码块");
        }
        {
            System.out.println("子类--非静态代码块");
        }
        public Child() {
            System.out.println("子类--构造函数");
        }
    } 

    将Supper作为启动类,运行结果如下:

    父类--静态代码块1
    父类--静态代码块2
    main函数
    子类--静态代码块
    父类--非静态代码块1
    父类--非静态代码块2
    父类--构造函数
    子类--非静态代码块
    子类--构造函数
    将Child作为启动类,运行结果如下:
    父类--静态代码块1
    父类--静态代码块2
    子类--静态代码块
    main函数
    父类--非静态代码块1
    父类--非静态代码块2
    父类--构造函数
    子类--非静态代码块
    子类--构造函数

    通过上面的例子,我们可以看出,JAVA中父类与子类静态代码块、非静态代码块、构造函数的加载顺序为:

    父类静态代码块>子类静态代码块>父类非静态代码块>父类构造函数>子类非静态代码块>子类构造函数。

    而对于多个静态代码块,它们加载顺序是按照文件中的先后位置进行加载,非静态代码块相同。

           当我们将Supper作为启动类时,由于main函数在Super类中,所以当调用main函数时,会首先加载Supper类的静态代码块,然后执行main函数,而在main函数中,会实例化子类Child类的对象,因此会加载子类的静态代码块;当我们将Child作为启动类时,由于main函数在父类Supper类中,所以会先加载父类的静态代码块和子类的静态代码块,然后执行main函数。

    如有披露或问题欢迎留言或者入群探讨

    展开全文
  • Java中的静态变量和静态代码块是在类加载的时候就执行的,实例化对象时,先声明并实例化变量再执行构造函数。如果子类继承父类,则先执行父类的静态变量和静态代码块,再执行子类的静态变量和静态代码块。同样,接着...
  • 子类静态代码块 ->父类非静态代码块 -> 父类构造函数 -> 子类非静态代码块 -> 子类构造函数。 package com.java; public class BassClass { public BassClass() { } { System.out.println("I'm .....
  • 废话不多说,直接上代码,我们先创建父类SuperClass,代码如下:public class SuperClass { static{ System.out.println("1.SuperClass Status Block"); } { System.out.println("3.SuperClass ...
  • 1.父类静态初始化代码块子类静态初始化代码块 2.父类构造代码块父类构造方法 3.子类构造代码块、子类构造方法 代码举例: public class HelloB extends HelloA { public HelloB() { System.out.println...
  • 子类静态代码块>>③父类非静态代码块>>④父类构造函数>>⑤子类非静态代码块>>⑥子类构造函数 大致总结: 父类早于子类,静态早于非静态,非静态早于...
  • //子类静态代码块 static{ System.out.println("子类静态代码块"); } //子类的构造方法 public B(){ System.out.println("子类的构造方法"); } //子类的普通方法 public void test(){ System.out....
  • package page6; class testParent{ public testParent(){ System.out.println("我是父类... System.out.println("我在父类静态块当中"); } { System.out.println("我在父类静态块当中"); } } pub
  • 执行顺序:对于静态变量、静态初始化块、...父类子类 都有动态代码块静态快时 父类子类 都有动态代码块静态快时 class Father { { System.out.println("父类构造块");// 3 } static { System.out.printl
  • 父类静态代码块 ->子类静态代码块 ->父类B非静态代码块 ->父类B构造函数 ->子类A非静态代码块 ->子类A构造函数 例如:略
  • Java父类静态代码块、非静态代码块、构造方法的执行顺序 class B{ static{ System.out.println(“父类B静态代码块”); } { System.out.println(“父类B非静态代码块”); } public B(){ System.out.println(...
  • System.out.println("父类静态代码块"); } { System.out.println("父类构造代码块"); } public Father(){ System.out.println("父类构造函数"); } static class Son extends Father { static{ .
  • 在学习Java基础期间,子父类静态代码块、构造代码块、构造方法的执行顺序容易混淆,现在通过一段程序来说明它们的执行顺序。 一、先看一个简单的静态测试程序: 运行结果: 执行父类静态代码...
  • 实例化子类时,父类与子类中的静态代码块、实例代码块、静态变量、实例变量、构造函数的执行...2.子类静态代码块与子类静态变量赋值(取决于代码书写顺序) 3.父类实例变量赋值与父类代码块(取决于代码书写顺序) 4.
  • public class Super {static {System.out.println("父类--静态代码块1");}{System.out.println("父类--非静态代码块1");}public Super() {System.out.println("父类--构造函数");}public static void main(String[] ...
  • class Test2_Extends{ //主函数 public static void main(String[] args){ Zi z=new Zi(); //创建对象 } ...3.父类进入内存,静态代码块会加载,子类进入内存,子类静态代码块会加载; 4.子类构...
  • 当你知道了这些都指的是什么了,直接在程序里面写一遍不就行了,运行完记住顺序。 所以重点是记住代码都是什么样子的,怎么写的 package shunxu; public class shunxun {... System.out.println("a构造代码块"); } s
  • 当创建子类对象时,子父类中静态代码块,代码块,构造器的加载顺序: 父类静态代码块 子类静态代码块 父类非静态代码块 父类构造器 子类非静态代码块 子类构造器
  • Java中继承,子类父类静态代码块、普通代码块、构造方法的执行顺序Java中继承,子类父类静态代码块、普通代码块、构造方法的执行顺序父类代码子类代码测试结果结论(个人结论仅供参考) Java中继承,子类和...
  • 昨天去宣讲会现场做了一份java开发工程师的笔试题,碰到一个关于java中子类和父类中的静态方法和构造方法的执行顺序,当时一直没明白父类静态代码块、静态变量、和构造方法和子类静态代码块、静态变量、构造方法...
  • 今天突然想起以前做的一个试题,有关子类父类静态代码块中执行顺序的问题,在代码中子类父类静态代码块是怎么执行的,有覆盖吗,是继承的还是怎么样的?对此做了一个小的测试: 一个People父类: public ...
  • 父类静态代码块 > 子类静态代码块 Java虚拟机加载类时,就会执行该块代码。 父类构造函数 > 子类构造函数 (先有父亲,后有孩子) 如果是多级继承关系的话,高层的父类首先执行,然后依次递减。 总结:静态...
  •  下面做的实验,主要是验证 当new 一个子类时,子类和它的父类中 静态成员变量,静态代码块,实例成员变量,实例代码块,构造方法 这5部分的执行顺序  父类代码: package _test; public abs

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 79,977
精华内容 31,990
关键字:

java父类子类静态代码块

java 订阅