当一个类继承于另一个类，子类中没有父类的方法时，用子类的对象调用方法时，会首先在子类中查找，如果子类中没有该方法，再到父类中查找。
 
当一个方法只在父类中定义时，调用该方法时会使用父类中的属性。
 
如果该方法中又调用了其他方法，那么还是按照之前的顺序，先在子类中查找，再在父类中查找。如果在子类中找到，调用子类的方法会使用子类的属性。

一、自动调用父类无参构造方法
 
//这是父类
public class SuperClass {

    //父类无参构造方法
    public SuperClass(){
        System.out.println("父类无参构造方法");
    }

    //父类带参构造方法
    public SuperClass(String str){
        System.out.println(str);
    }
}
 
//这是子类
//这是子类
public class SubClass extends SuperClass{

    //子类无参构造方法
    public SubClass(){
        System.out.println("子类无参构造方法");
    }

    //子类带参构造方法
    public SubClass(String str){
        System.out.println(str);
    }
}
 
//这是测试类
public class TestMain {

    public static void main(String[] args) {
        SubClass sc1 = new SubClass();
        SubClass sc2 = new SubClass("子类带参构造方法");
    }
}
 
输出结果：
 
 
 
父类无参构造方法
 子类无参构造方法
 父类无参构造方法
 子类带参构造方法
 
 
总结：在子类初始化时会自动调用父类的无参构造方法（只调用无参构造方法，不调用带参构造方法）
 
二、手动调用父类无参构造方法
 
//这是父类
public class SuperClass {

    //父类无参构造方法
    public SuperClass(){
        System.out.println("父类无参构造方法");
    }

    //父类带参构造方法
    public SuperClass(String str){
        System.out.println(str);
    }
}
 
//这是子类
public class SubClass extends SuperClass{

    //子类无参构造方法
    public SubClass(){
        super();
        System.out.println("子类无参构造方法");
    }

    //子类带参构造方法
    public SubClass(String str){
	    super();
        System.out.println(str);
    }
}
 
//这是测试类
public class TestMain {

    public static void main(String[] args) {
        SubClass sc1 = new SubClass();
        SubClass sc2 = new SubClass("子类带参构造方法");
    }
}
 
输出结果：
 
 
 
父类无参构造方法
 子类无参构造方法
 父类无参构造方法
 子类带参构造方法
 
 
总结：子类也可以手动调用父类的无参构造方法
 
三、手动调用父类的带参构造方法
 
//这是父类
public class SuperClass {

    //父类无参构造方法
    public SuperClass(){
        System.out.println("父类无参构造方法");
    }

    //父类带参构造方法
    public SuperClass(String str){
        System.out.println(str);
    }
}
 
//这是子类
public class SubClass extends SuperClass{

    //子类无参构造方法
    public SubClass(){
        super("子类调用父类的带参构造方法");
        System.out.println("子类无参构造方法");
    }

    //子类带参构造方法
    public SubClass(String str){
        super("子类调用父类的带参构造方法");
        System.out.println(str);
    }
}
 
//这是测试类
public class TestMain {

    public static void main(String[] args) {
        SubClass sc1 = new SubClass();
        SubClass sc2 = new SubClass("hello world");
    }
}
 
输出结构：
 
 
 
子类调用父类的带参构造方法
 子类无参构造方法
 子类调用父类的带参构造方法
 子类带参构造方法
 
 
总结：子类初始化时不会自动调用父类的带参构造方法，如果用到了父类的带参构造方法，则需要手动去调用，手动调用父类的构造方法后，子类不再自动调用父类的无参构造方法；
 
注意：不管是子类手动调用父类的无参构造方法，还是手动调用父类的带参构造方法，代码必须写在子类构造方法的第一行

正文
 
class FatherClass{
    public FatherClass(){
        System.out.println("父类 无参 构造函数");
    }
    public FatherClass(int i){
        System.out.println("父类 一个参数构造函数super = "+i);
    }
    public FatherClass(int i,String j){
        System.out.println("父类 一个参数构造函数superi = "+i+",superj = "+j);
    }

}

class SonClass extends FatherClass{
    public SonClass(){
//      super(22);//line 1
        System.out.println("子类 无参 构造函数");
    }
    public SonClass(int a){
        super(33,"Hello");//line 2
        System.out.println("子类一个参数构造函数sub = "+a);
    }
    public void fun(int a){//子类中定义一个实例函数
        //super(33,"Hello");//构造函数调用必须声明在构造函数中,这行代码不注释的话会报错
        System.out.println("子类一个参数构造函数sub = "+a);
    }
}
public class ConstructorExtend {//测试子类继承父类的构造函数
    public static void main(String args[]){
//  FatherClass fa = new FatherClass();
//  FatherClass fa1 = new FatherClass(100);
//  SonClass son = new SonClass();
    SonClass son1 = new SonClass(200);
    son1.fun(2);
    }
}
 
子类 调用 父类的构造函数：（构造函数不会被继承，只是被子类调用而已）
 
1、子类所有的 构造函数 默认调用父类的无参构造函数（其实是默认省略掉了一行代码：super();）;省略掉的这行super()代码可以自行添加到构造函数的第一行（必须是第一行，否则报错）
 
2、如果父类没有定义构造函数，系统会默认定义一个无参无返回值的构造函数，子类继承时无需（无需的意思是：可以写可以不写）在子类构造函数中显式调用super( )；如果父类定义了有参构造函数，此时子类的构造函数中第一行必须显式调用父类定义的某个有参数构造函数。即，显式调用对应的参数个数、对应参数类型与此super( [arg0][,arg1]…. )的父类构造函数。
 
3、如果子类的某个构造函数 想 调用父类的其他的带参数的构造函数，在构造函数的第一行人为添加 super(val1,val2[,val3…]),super()括号中的变量数量由想调用的父类的构造函数中的变量数量决定。如代码中的line 2，调用的是父类构造函数中两个参数的构造函数，那么Super(20,”Hello”)就两个变量。
 
4、自行添加super(val1,val2,…),就可以指定调用父类的那个参数类型和数量一致的构造函数。之后在此子类构造函数中，系统不会再默认调用父类无参构造函数；
 
5、如果子类的每个构造函数都自行添加super([val1,]….),除非人为调用父类无参构造函数，否则的话父类的无参构造函数可以不写。有super指定调用的父类构造函数存在即可
 
6、super指代父类对象，可以在子类中使用 super.父类方法名(); 调用父类中的方法（无论是类方法还是实例方法都可以)，此外调用实例方法还可以在方法内部实例化再调用
 
 
作者简洁
 
 
 
作者：小碗汤，一位热爱、认真写作的小伙，目前维护原创公众号：『我的小碗汤』，专注于写golang、docker、kubernetes等知识等提升硬实力的文章，期待你的关注。 转载说明：务必注明来源（注明：来源于公众号：我的小碗汤， 作者：小碗汤）
 

背景
 
子类继承父类，重写了父类方法。面试中经常考到方法的调用，以及构造函数先后顺序。
 
例子
 
定义父类，申明方法say()
 
public class TestParent {
    protected static String name = "parent";
    TestParent(){
        say();
    }
    public void say(){
        System.out.println("Hello"+ name);
    }
}

 
定义子类，申明方法say()
 
public class TestChild extends TestParent{
    private String name = "child";
    
    TestChild(){
        say();
    }
    public void say(){//重写say()
        //super.say();super关键字指定调用父类方法
        System.out.println("Hello"+ name);
    }
    public static void main(String[] args) {
        TestParent a = new TestChild();
    }
}
 
运行main方法时，当时想都没想认为是
 
Helloparent
Hellochild
 
其实是错误的，在执行父类的构造方法时，调用的并不是父类的say()方法，而是子类重写的say()，此时子类非静态变量并未加载,所以输出是“null”。要想指定调用父类方法可用super.say()来指定，若想执行父类构造函数时输出name，可将子类变量设置为static/final，有了static/final关键字，便会先于构造函数执行。
 
Hellonull
Hellochild
 
PS:父类子类加载顺序
 
父类静态变量
 父类静态代码块
 子类静态变量
 子类静态代码块
 父类非静态变量
 父类非静态代码块
 父类构造函数
 子类非静态变量
 子类非静态代码块
 子类构造函数
 静态资源存放在方法区，线程共享，只会加载一次。