精华内容
下载资源
问答
  • 面试题 以下代码执行结果 public class Test { class Super{ int flag=1; Super(){ test(); } void test(){ System.out.println("Super.test() flag="+flag); } ...

    面试题

    以下代码执行结果

    public class Test {
        class Super{
            int flag=1;
            Super(){
                test();
            }  void test(){
                System.out.println("Super.test() flag="+flag);
            }
        }
        class Sub extends Super{
            Sub(int i){
                flag=i;
                System.out.println("Sub.Sub()flag="+flag);
            }  void test(){
                System.out.println("Sub.test()flag="+flag);
            }
        }
        public static void main(String[] args) {  new Test().new Sub(5);
        }
    }
    

    结果:

    Sub.test()flag=1
    Sub.Sub()flag=5
    

    解析

    1.继承中代码执行顺序

    1.父类静态对象,父类静态代码块
    2.子类静态对象,子类静态代码块
    3.父类非静态对象,父类非静态代码块
    4.父类构造函数
    5.子类非静态对象,子类非静态代码块
    6.子类构造函数

    2.java多态的实现

    • 继承:在多态中必须存在有继承关系的子类和父类。
    • 重写:子类对父类中某些方法进行重新定义,在调用这些方法时就会调用子类的方法。
    • 向上转型:在多态中需要将子类的引用赋给父类对象,只有这样该引用才能够具备技能调用父类的方法和子类的方法。

    而这里的test方法就是重写。

    3.分析代码

    在执行new Test().new Sub(5);之前,先创建变量flag = 1,然后调用父类的构造方法,父类的构造方法中调用了test,由于java多态的实现。会调用子类重写的test而不是父类test,所以第一句打印的是:Sub.test()flag=1,接着调用子类的构造方法,子类中将5赋给父类的成员变量flag,接着打印:Sub.Sub()flag=5。

    结论

    • 继承中代码执行顺序如上
    • java中子类对父类中某些方法进行重新定义,在调用这些方法时就会调用子类的方法。
    展开全文
  • 本篇文章是对java中子类继承父类,程序运行顺序进行了详细的分析介绍,需要的朋友参考下
  • java程序, 在子类继承父类时, 执行顺序是怎样的呢? 代码实现: /** * super 子类通过super调用父类的成员,也可以super()调用父类构造方法 但是也是必须放在第一句 * */ public class TestExtends2 { ...

    在java程序中, 在子类继承父类时, 执行顺序是怎样的呢?

    代码实现:

    /**
     * super  子类通过super调用父类的成员,也可以super()调用父类构造方法   但是也是必须放在第一句
     *
     */
    public class TestExtends2 {
    
        public static void main(String[] args) {
            new Child();
    
        }
    
    }
    /**
     * 父类静态代码段
     * 子类静态代码段
     * 父类代码段
     * 父类构造方法
     * 子类代码段
     * 子类构造方法
     *
     */
    class Parent{
        static{
            System.out.println("父类静态代码段");
        }
        {
            System.out.println("父类代码段");
        }
        public Parent(){
            System.out.println("====父类构造方法====");
        }
    }
    class Child extends Parent{
        private A a = new A();
        private static A b = new A();
        static{
            System.out.println("**子类类静态代码段");
        }
        {
            System.out.println("**子类代码段");
        }
        public Child(){
            super();//调用父类构造方法    必须放在第一句
            System.out.println("**====子类类构造方法====");
        }
    
        public void test(){
    
        }
    }
    class A{
        public A(){
            System.out.println("****A***");
        }
    }
    

    执行结果:

    这里写图片描述

    可见:

     * 父类静态代码段
     * 子类静态代码段
     * 父类代码段
     * 父类构造方法
     * 子类代码段
     * 子类构造方法
    
    展开全文
  • Java中继承执行顺序

    千次阅读 2017-01-15 14:59:48
    若类C继承类B,类B继承类A,则类C既有从类B那里继承下来的属性与方法,也有从类A那里继承下来的属性与方法,还可以有自己新定义的属性和方法继承来的属性和方法尽管是隐式的,但仍是类C的属性和方法继承是在一些...
    首先明白为什么要继承?
    (1)继承关系是传递的。若类C继承类B,类B继承类A,则类C既有从类B那里继承下来的属性与方法,也有从类A那里继承下来的属性与方法,还可以有自己新定义的属性和方法。继承来的属性和方法尽管是隐式的,但仍是类C的属性和方法。继承是在一些比较一般的类的基础上构造、建立和扩充新类的最有效的手段。   (2)继承简化了人们对事物的认识和描述,能清晰体现相关类间的层次结构关系。   (3)继承提供了软件复用功能。若类B继承类A,那么建立类B时只需要再描述与基类(类A)不同的少量特征(数据成员和成员方法)即可。这种做法能减小代码和数据的冗余度,大大增加程序的重用性。   (4)继承通过增强一致性来减少模块间的接口和界面,大大增加了程序的易维护性。   (5)提供多重继承机制。从理论上说,一个类可以是多个一般类的特殊类,它可以从多个一般类中继承属性与方法,这便是多重继承。Java出于安全性和可靠性的考虑,仅支持单重继承,而通过使用接口机制来实现多重继承
    子类继承父类之后只能重写父类中的protected和public方法,默认没有修饰词的是friendly,同样可以重写,但是private方法就不能重写,即使子类中的方法名和父类的private方法一致,也只能看做是一个新的方法,而不是重写。
    override也就是重写,覆写。

    package ex;

    public class Father {
    public Father()
    {
    System.out.println("这是父类的构造方法");
    }
    public void name()
    {
    System.out.println("这是父类里的name!!!");
    }
    }


    package ex;
    public class Son extends Father {
    Son()
    {
    System.out.println("这是子类的构造方法");
    }
    public void name()
    {
    System.out.println("这个是子类里的name!!!");
    }
    }

    public class Text {
    public static void main(String[] args) {
    // TODO Auto-generated method stub
    Son ss=new Son();
    ss.name();
    }
    }


    执行结果:
    这是父类的构造方法
    这是子类的构造方法
    这个是子类里的name!!!



      
    1. //InheritTest.java 使用继承方式实现目标  
    2. class Animal{  
    3.     private void beat(){  
    4.         System.out.println("心脏跳动...");  
    5.     }  
    6.     public void breath(){  
    7.         beat();  
    8.         System.out.println("吸一口气,呼一口气,呼吸中...");  
    9.     }  
    10. }  
    11. //继承Animal,直接复用父类的breath()方法  
    12. class Bird extends Animal{  
    13.     //创建子类独有的方法fly()  
    14.     public void fly(){  
    15.         System.out.println("我是鸟,我在天空中自由的飞翔...");  
    16.     }  
    17. }  
    18. //继承Animal,直接复用父类的breath()方法  
    19. class Wolf extends Animal{  
    20.     //创建子类独有的方法run()  
    21.     public void run(){  
    22.         System.out.println("我是狼,我在草原上快速奔跑...");  
    23.     }  
    24. }  
    25. public class InheritTest{  
    26.     public static void main(String[] args){  
    27.         //创建继承自Animal的Bird对象新实例b  
    28.         Bird b=new Bird();  
    29.         //新对象实例b可以breath()  
    30.         b.breath();  
    31.         //新对象实例b可以fly()  
    32.         b.fly();  
    33.         Wolf w=new Wolf();  
    34.         w.breath();  
    35.         w.run();  
    36. /* 
    37. ---------- 运行Java程序 ---------- 
    38. 心脏跳动... 
    39. 吸一口气,呼一口气,呼吸中... 
    40. 我是鸟,我在天空中自由的飞翔... 
    41. 心脏跳动... 
    42. 吸一口气,呼一口气,呼吸中... 
    43. 我是狼,我在草原上快速奔跑... 
    44.  
    45. 输出完毕 (耗时 0 秒) - 正常终止 
    46. */  
    47.     }  
    48. }  
    49.   
    50. //CompositeTest.java  使用组合方式实现目标  
    51. class Animal{  
    52.     private void beat(){  
    53.         System.out.println("心脏跳动...");  
    54.     }  
    55.     public void breath(){  
    56.         beat();  
    57.         System.out.println("吸一口气,呼一口气,呼吸中...");  
    58.     }  
    59. }  
    60. class Bird{  
    61.     //定义一个Animal成员变量,以供组合之用  
    62.     private Animal a;  
    63.     //使用构造函数初始化成员变量  
    64.     public Bird(Animal a){  
    65.         this.a=a;  
    66.     }  
    67.     //通过调用成员变量的固有方法(a.breath())使新类具有相同的功能(breath())  
    68.     public void breath(){  
    69.         a.breath();  
    70.     }  
    71.     //为新类增加新的方法  
    72.     public void fly(){  
    73.         System.out.println("我是鸟,我在天空中自由的飞翔...");  
    74.     }  
    75. }  
    76. class Wolf{  
    77.     private Animal a;  
    78.     public Wolf(Animal a){  
    79.         this.a=a;  
    80.     }  
    81.     public void breath(){  
    82.         a.breath();  
    83.     }  
    84.     public void run(){  
    85.         System.out.println("我是狼,我在草原上快速奔跑...");       
    86.     }  
    87. }  
    88. public class CompositeTest{  
    89.     public static void main(String[] args){  
    90.         //显式创建被组合的对象实例a1  
    91.         Animal a1=new Animal();  
    92.         //以a1为基础组合出新对象实例b  
    93.         Bird b=new Bird(a1);  
    94.         //新对象实例b可以breath()  
    95.         b.breath();  
    96.         //新对象实例b可以fly()  
    97.         b.fly();  
    98.         Animal a2=new Animal();  
    99.         Wolf w=new Wolf(a2);  
    100.         w.breath();  
    101.         w.run();  
    102. /* 
    103. ---------- 运行Java程序 ---------- 
    104. 心脏跳动... 
    105. 吸一口气,呼一口气,呼吸中... 
    106. 我是鸟,我在天空中自由的飞翔... 
    107. 心脏跳动... 
    108. 吸一口气,呼一口气,呼吸中... 
    109. 我是狼,我在草原上快速奔跑... 
    110.  
    111. 输出完毕 (耗时 0 秒) - 正常终止 
    112. */  
    113.     }  
    114. }  
    展开全文
  • 继承中的构造方法执行顺序

    千次阅读 2019-04-17 09:25:57
    继承中的构造方法执行顺序 在子父类,创建子类对象,调用子类的构造方法, 在子类的构造方法的第一行代码如果没有调用父类的构造或者没有调用子类的其他构造,则默认调用父类无参构造。 为什么要调用父类构造...

    继承中的构造方法执行顺序

    在子父类中,创建子类对象,调用子类的构造方法,

    在子类的构造方法的第一行代码如果没有调用父类的构造或者没有调用子类的其他构造,则默认调用父类无参构造。

     

    为什么要调用父类构造?

     因为需要给父类的成员变量初始化。肯定会先把父类的构造执行完毕,在去执行子类构造中的其他代码。

     

    super(实参列表);语句   在子类的构造方法中使用,用来调用父类中的构造方法(具体哪一个由传递的参数决定),并且只能在构造方法第一行使用

    this(实参列表); 语句    在类的构造方法中使用,用来调用本类中的其它构造方法(具体哪一个由传递的参数决定),并且只能在构造方法的第一行使用

     

    例如:下面这个例子中,首先调用子类的无参构造,因为第一行是this语句,所以这里不调用父类的无参构造。(第一行是this或super都不调用),然后执行this(1),调用的子类的有参构造,但是子类的有参构造第一行代码没有调用父类的构造或子类的其他构造,所以默认调用父类的无参构造。所以最终的输出结果为:“我是父类的无参构造”--->“我是子类的有参构造”--->“我是子类无参构造”

    package com.itheima;
    
    public class ExtendsDemo6 {
    	public static void main(String[] args) {
    		Zi z=new Zi();
    	}
    }
    
    class Die {
    	public Die() {
    		System.out.println("我是父类无参构造");
    	}
    
    	public Die(int num) {
    		System.out.println("我是父类有参构造");
    	}
    }
    
    class Zi extends Die {
    	public Zi() {
    		this(1);
    		System.out.println("我是子类无参构造");
    	}
    
    	public Zi(int num) {
    		System.out.println("我是子类有参构造");
    	}
    }
    展开全文
  • 类B继承类A,当实例化一个B类型时,执行顺序为: A的静态代码块->B的静态代码块->A的构造代码块->A的无参构造函数->B的构造代码块->B的无参构造函数public class Test1 { ...
  • java 子类继承父类各方法执行顺序

    千次阅读 2018-05-01 18:24:03
    结论: java中子类继承父类各方法执行顺序:(这里只写jvm自动调用的方法的顺序,包括静态代码块、代码块、构造方法) 1、第一次创建子类对象 父类静态代码块 子类静态代码块 父类代码块 父类构造方法 子类...
  • demo class A{ static { System.out.println("父类静态代码块"); } public A(){ ...父类构造方法"); } { System.out.println("父类初始化块"); } } public class B ...
  • Java继承类的执行顺序

    千次阅读 2016-09-06 14:14:36
    Java继承类的执行顺序
  • 原文地址:https://blog.csdn.net/SnailMann/article/details/78665874得到的结论是:先执行父类构造函数,再执行子类构造函数父类:Animal.java[java] view plain copypackage extendsdemo; public class ...
  • 接下来就要说一个含有多层继承关系的对象的构造方法调用顺序是什么样的。 父类的构造方法总是在子类的构造方法中被调用,而且按照继承层次逐渐向上链接,来使得每个父类的构造方法都能得到调用。实际是向上链接到最...
  • 执行顺序,父类的静态代码块,子类的静态代码块,父类的代码块,父类的无参构造方法,子类的代码块,子类的无参构造方法   如查子类有参的构造函数 new Children(“a”,"b"); 执行顺序:...
  • java中方法执行顺序

    千次阅读 2016-10-04 12:23:28
    静态平级---->new的先执行代码块 再执行构造器,按照顺序执行 static{}代码块--->如果是...如果是static int x=method()(method是静态方法)直接执行method方法中的内容-->如果后面再没有static修饰的内容执行main
  • Java中,子类实例化时会调用父类构造方法,子类父类方法中会有一个函数生成表,执行时实现动态链接,子类重写父类方法执行顺序也是这样  对于执行父类构造方法的问题。可以归纳为两种情况 1,如果...
  • java继承中new子类对象的执行顺序

    千次阅读 2017-05-13 19:55:10
    下面测试代码块,静态代码块,构造器的初始化顺序 public class TestExtends { public static void main(String[] args) { A a = new A(5); /*输出结果: * B constructor A.draw(), radius = 0 A constructor A....
  • Java中继承,子类和父类的静态代码块、普通代码块、构造方法执行顺序Java中继承,子类和父类的静态代码块、普通代码块、构造方法执行顺序父类代码子类代码测试结果结论(个人结论仅供参考) Java中继承,子类和...
  • Java继承中方法的覆盖和重载

    千次阅读 2016-05-05 17:06:32
    在类继承中,子类可以修改从父类继承来的方法,也就是说子类能创建一个与父类方法有不同功能的方法,但具有相同的名称、返回值类型、参数列表。 如果在新类定义一个方法,其名称、返回值类型和参数列表正好与...
  • 如果b类继承自a类,在main方法中new出b的对象(不带参数),那么他执行顺序是: 父类a的静态方法-->类b的静态方法-->父类a的非静态方法(不指定方法名)-->父类a的无参构造--> 这个时候在父类无参构造里面调用了父类...
  • java new一个类对象,类各部分执行顺序:  静态代码块—非静态代码块—构造函数—一般方法。 public class father { private String name; father(){ System.out.println("--父类的无参构造函数--"); } ...
  • java中继承后,子类和父类的静态代码块、构造代码块与构造方法执行顺序分析 首先是未实现继承前的执行顺序 程序如下: 执行结果如下: 未实现继承前代码的执行顺序很好理解… 实现继承后代码的执行顺序又是怎么...
  • java代码执行顺序

    万次阅读 2018-08-20 15:58:52
     java的代码执行顺序是自上而下,从左到右,方法是以main方法为主方法(通常情况下,事实上很多时候也会不用主方法)。但是就像HTMLCSS有执行先后顺序一样,java中类的内容也是有先后执行顺序的。java中类的...
  • 父类静态代码块-子类静态代码块-父类非静态代码块-父类构造方法-子类非静态代码块-子类构造方法
  • 在测试类创建了Student对象,应该先执行的是父类的构造方法,然后在执行子类的构造方法,但是执行父类构造方法的时候,为什么调用的是子类的f()方法。 然后把f()方法的public改成private的话,又是另一种结果...
  • Java中Static执行顺序

    千次阅读 2018-08-11 16:09:15
    static方法就是没有this的方法。在static方法内部不能调用非静态方法,反过来是可以的。而且可以在没有创建任何对象的前提下,仅仅通过类本身来调用static方法。也就是说说被static关键字修饰的方法或者变量**不需要...
  • java中方法继承

    千次阅读 2019-03-15 16:18:40
    继承的定义:一个类可以继承另外一个类,继承这个类以后就继承了他所有的属性和方法。 格式表达为:class 子类extends 父类{} 叫法: 继承其他类的类叫做子类,派生类。 被继承的类叫做父类,超类,基类。 ...
  •  由于这边不是java的运行环境不能使用debug查看具体的执行顺序,所以在以下演示代码,将使用红色序号标志重要的行,在分析会更容易理解、明了。 演示代码如下:此代码的输出值为:0 package util;
  • java继承中父类和子类静态、非静态代码块,构造函数,静态方法执行顺序
  • Java程序运行时,第一件事情就是试图访问main方法,因为main相等于程序的入口,如果没有main方法,程序将无法启动,main方法更是占一个独立的线程,找到main方法后,是不是就会执行mian方法块里的第一句话呢?...
  • java 各部分的执行顺序

    千次阅读 2018-08-28 11:36:21
    package com.fjf.test.classloadoreder; /** * * *参考:... * 测试类加载的顺序 * @author fjf * 2018年8月28日 11:07:16 * * 若类还未被加载 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 237,746
精华内容 95,098
关键字:

java继承中方法的执行顺序

java 订阅