笔者之前一直很疑惑：为什么别人的源代码中的类要继承，居然一定要写super，而且必须写在第一行。不然就会报错。
 
刚刚开始还以为是别人的源代码中写了注解还是什么鬼的代码。查过诸多的资料之后发现。
 
请注意正解来了！请注意正解来了！请注意正解来了！
 
这个是Java的规定：子类继承父类，子类的构造方法必须调用super（）即父类的构造方法，而且必须放在构造方法的第一行。
 
那么问题又来，为什么我写的类有时候都不用去调用父类的构造方法？
 
因为：如果父类"只"有无参构造方法，且不打算重写子类的构造方法，为节省代码量，子类构造方法可以不写，但是实际上是已经写了，系统默认调用父类无参构造方法super()，即默认会在子类的构造方法中的第一行加上父类的无参构造方法
 
下面是我自己的研制代码截图：当父类有无参构造函数或者，没有生命构造函数的时候，是不会报错的
 

 
子类：
 

 
当父类不包含无参构造函数的的时候，几句报错：
 

 
子类：
 

 
这个时候只要在子类构造函数第一行中添加构造函数就可以
 

 
最好再次总结：子类构造函数必须在构造函数第一行调用父类构造函数，
 
当子类构造函数没有调用父类构造函数的时候是因为父类构造包含无参构造函数，
 
为了节省代码，
 
系统会自动添加调用。
 


 
此文出处：https://blog.csdn.net/jcaksonsen/article/details/51564382
 

先说说对构造函数的理解：
 
1，函数名于类名相同。
 
2，没有返回值。
 
3，没有return。
 
4，每个类都有一个默认无参的构造函数，初始化该类的时候，先走构造函数，用于初始化成员变量和方法。
 
5，一个类如果自定义了构造函数，则默认的无参构造函数没有了，如果需要无参的构造函数，必须手动添加。
 
再说说子类和父类关于super()方法的调用：
 
1，super(); 就是调用父类的构造函数。
 
2，如果父类自定义了有参的构造函数，子类必须自定义构造函数，并且在构造函数的第一行调用父类的带参的构造函数super();。（这块我个人理解为，如果子类没有自定义构造函数，那默认的是无参的构造函数，无参的构造函数默认调用父类的无参的构造函数，但是父类自定义了有参的构造函数，就没有无参的构造函数了，所以这个编译是失败的。）
 
3，如果父类只自定义了无参的构造函数，那么子类如果自定义了构造函数，不论有参每参，都默认调用父类无参的构造函数，这个时候，子类构造函数不用加super();
 
 
 
以上，是我个人的理解，如果有问题，请各位及时留言指正。
 
 
 
 

原则：当父类仅有带有参数的构造方法时，子类的构造方法中必须使用super(参数)
 
super()表示父类的构造方法，子类默认调用父类无参构造方法。
 
一旦父类仅定义了带参数的构造方法，表示创建父类必须使用带参数构造方法，不接受new父类时不带参数，那么此时子类里默认的调用super()就会报错，不带参数的父类构造方法不存在，必须手动加上含有参数的构造方法。
 
public class practice {
    public static void main(String[] args) {
        Sun s =new Sun();
        s.show();
    }
}
class Dad{
    public int age;
    Dad(int age)
    {
        this.age = age;
    }
    void show(){
        System.out.println(age);
    }
}
class Sun extends Dad{
    public int age=10;
    public Sun()
    {
        super(35);
    }
}
 
如果去掉super将会提示错误信息There is no default constructor available in 'basic.Dad'

 
 
在子类继承父类时，由于同时会继承到父类的成员变量和成员方法，同时子类也可以定义与父类同名的成员方法来覆盖父类方法。这次问题的起因是做到了一道很懵的选择题，才发现自己对super关键字还没有很理解，查阅资料后，终于理清楚这块的知识点，特地总结如下：
 
 
一、super关键字的作用
 
使用super关键字调用父类构造函数
使用super关键字父类成员变量
使用super关键字父类成员方法
 
二、使用super调用父类构造函数
 
1.super
 
先看下面一段代码：
 
class Base{
    public Base(String s){
        System.out.print("B");
    }
}
public class Derived extends Base{
    public Derived (String s) {
        System.out.print("D");
    }
    public static void main(String[] args){
        new Derived("C");
    }
}

上述代码执行结果为：
A BD
B DB
C C
D 编译错误
 
正确答案是：D
 首先，在分析代码前，我们需要知道在继承中，子类是会拥有所有父类非privat的成员方法和成员变量。因此在实例化一个子类对象时，一定是会首先执行父类的构造函数，再执行子类的构造方法，确保该对象拥有父类的成员方法和成员变量。那么在调用时，就必须要给个标志让父类知道是调用哪个构造方法，这个关键字就是super，而且必须将super放在方法块的第一行。
 我们接着看上述代码，如果在子类的Derived方法中第一行加上super(s)就可以通过编译同时将s传给父类的构造方法，最终输出BD。
 通常情况下，子类的构造方法都应该通过super关键字来调用父类的构造函数，以及给父类构造函数传参。但我们也注意到，也存在没有写super也没有发生编译错误的，这又是什么情况呢？
 事实上，每个子类的构造方法都有super关键字来通知父类，如果我们没有写出来，编译器就会默认生成一个super()。此时调用的是父类的无参构造方法，所以，我们当然要确定父类是有一个无参构造方法的，这样编译才不会报错。如果想调用父类有参构造函数就要给super()中传入参数。
 
接下来，对比一下：
 
没有无参构造方法，也没有super的情况：
 
 鼠标放上去，提示父类中没有默认的构造方法，建议加上super(n)
 
 我们继续编译得到错误提示如下，原因是在实例化子类时，父类没有可以默认调用的无参构造方法，而父类拥有的带参构造方法也没有给其传入参数。
 
 
解决方法有两种，加无参构造函数或super
 
拥有无参构造函数，可以省略super
 
 当增加无参构造方法，解决了编译错误的问题，此时一定不是调用带参构造方法（就算它们长的有点像）而是调用无参构造函数。这点可以通过运行结果看出。
 
加上super，不需要有无参构造函数
 
 当在子类中加上super关键字后，调用哪一个构造函数就可以通过super()括号中传入的参数决定。使用super调用父类的构造方法就相当与给父类构造方法中传入实例化的某些参数。
 运行结果：
 
 
2.super和this
 
当然会有人有点混淆 super 和 this 关键字的概念。但其实super不是一个对象的引用， 不能将 super 赋给另一个对象变量， 它只是一个指示编译器调用父类方法的特殊关键字。
 另外，在一个普通类中，当一个构造方法需要使用this关键字调用另一个构造方法时，this也是需要写到方法体的第一行。
 那就又有问题了，当在一个子类中，一个构造方法既需要使用super还需要使用this时到底该把哪一个放在第一行呢？
 答案是保留this关键字放在首位，因为再使用this调用到其它的构造方法还会再次调用super()穿参数给父类。
 
三、使用super调用父类成员变量
 
当子类与父类有相同的成员变量时，调用时会默认调用子类的成员变量，但如果我们想调用父类的成员变量就应该加上super关键字。
 示例如下：
 
class Father{
    public int age = 50;
}
public class Son extends Father {
    public int age = 20;
    public void print(){
        System.out.println(super.age);
        System.out.println(this.age);
    }
    public static void main(String[] args) {
        Son s = new Son();
        s.print();
    }
}

执行结果：
50
20
 
这里super.age打印出的时父类的age属性，而this.age打印出子类的age属性。
 
四、使用super调用父类的成员函数
 
同样，当子类与父类有相同的成员函数时，称为方法覆盖。具体可参考另一篇博客—>方法重载和覆盖有什么区别？在对象调用时会默认调用子类的成员变量，但如果我们想调用父类的成员函数就可以通过加上super关键字来实现。
 示例入下：
 
class Father{
    public void print(){
        System.out.println("1.Father");
    }
}
public class Son extends Father {
    public void print(){
        super.print();
        System.out.println("2.Son");
    }
    public static void main(String[] args) {
        Son s = new Son();
        s.print();
    }
}

执行结果：
1.Father
2.Son

 
ok，以上就是自己简单总结的super用法，有什么问题欢迎大家指正。