super关键字跟this关键字类似，也是指对象的引用，不同的是它指向分类对象的引用
 
在同一个类中如果有继承关系，属性和方法都可以被子类继承，子类如何显示调用父类的普通方法呢？这就要使用super关键字啦
 
super关键字的规则：
 
若要在子类构造方法中调用父类构造方法，在子类构造方法中的第一条语句要用super关键字嘞调用
 
1、调用父类构造方法的语法
 
super() 或 super(实参列表);//必须是第一句
 
2、调用父类的普通方法语法
 
super.methodname() 或 super.methodname(实参列表)
 
 

Java中super关键字及super()的使用：
 
1、super的使用：
 
（1）super是一个关键字。
 
（2）super和this很类似，我们对比着学习。
 
 
2、先复习一下this关键字的使用。
 
（1）this能出现在实例方法和构造方法中；
 （2）this的语法是“this.”和“this()”；
 （3）this不能出现在静态方法中；
 （4）this大部分情况下是可以省略的；
 （5）this.什么时候不能省略呢？
 在区分局部变量和实例变量时不能省略。例如：
 
Public void setName(String name){
	this.name = name;
}
 
（6）this()只能出现在构造方法的第一行，通过当前的构造方法去调用“本类”中的对应的构造方法，目的是：代码复用。
 
 
3、super关键字：
 
（1）super能出现在实例方法和构造方法中。
 
（2）super的语法是“super.”和“super()”。
 
（3） super不能出现在静态方法中。
 
（4） super大部分情况下是可以省略的。
 
（5）super.什么时候不能省略呢？
 别急，我们想一下this指向的是什么，是当前对象自己。super和this类似，它指向了当前对象自己的父类型特征（也就是继承过来的那些东西）。
 
super和this区别是：this可以看做一个引用变量，保存了该对象的地址，是当前对象整体，而super代表的是父类型特征，是子类局部的一些东西，这些继承过来的东西已经在子类里面了，你可以输出整体this，但不能输出父类型特征super。因为super指向的东西不是一个整体，没法打印输出。
 
System.out.println(this);  //输出this.toString()的值
System.out.println(super);  //编译报错，需要'.'
 
当在子类对象中，子类想访问父类的东西，可以使用“super.”的方式访问。例如：方法覆盖后，子类内部虽然重写了父类的方法，但子类也想使用一下父类的被覆盖的方法，此时可以使用“super.”的方式。当子类中出现和父类一样的属性或者方法，此时，你要想去调用父类的那个属性或者方法，此时“super.”不能省略。
 
this和super都只能在对象内部使用。
 this代表当前对象本身，super代表当前对象的父类型特征。
 
 
总结：“this.”是一个实例对象内部为了区分实例变量和局部变量。
 而“super.”是一个实例对象为了区分是子类的成员还是父类的成员。
 父类有，子类也有，子类想访问父类的，“super.”不能省略。**
 
 
（6）super()只能出现在构造方法的第一行，通过当前的构造方法去调用“父类”中的对应的构造方法，目的是：创建子类对象时，先初始化父类型特征。
 
用通俗的话来讲，要想有儿子，得先有父亲。
 
 
我们来看下面代码：
 写两个类，Animal和Cat，Cat继承Animal。
 
//父类，Animal类
class Animal {
	//构造函数
	public Animal() {
		System.out.println("Animal类的无参数构造函数执行");
	}
}

//子类，Cat类
class Cat extends Animal{
	//构造函数
	public Cat() {
		System.out.println("Cat类的无参数构造函数执行");
	}
}
 
执行下面一行代码：
 
Cat c1 = new Cat(); 
 
运行输出结果为：
     Animal类的无参数构造函数执行
     Cat类的无参数构造函数执行
 
我们发现实例化一个子类的对象，也就是调用了子类的构造方法，为什么父类的无参数构造方法也执行了，并在子类构造方法执行之前就已经执行了父类的无参数构造方法，好奇怪。
 
刚刚在上面的super关键字的使用第6点，我已经说了，super()和this()方法一样，都只能在构造方法的第一行出现。我们猜想，难道子类的构造方法第一行有一个隐形的super()方法？答案是肯定的。
 
我们把子类的构造方法的第一行给它加上super()：
 
//子类，Cat类
class Cat extends Animal{
	//构造函数
	public Cat() {
		super();
		System.out.println("Cat类的无参数构造函数执行");
	}
}
 
再执行下面代码：
 
Cat c1 = new Cat(); 
 
运行输出结果为：
     Animal类的无参数构造函数执行
     Cat类的无参数构造函数执行
 
和刚才的子类构造方法没加super()是一样的。
 
所以说当子类的构造方法内第一行没有出现“super()”时，系统会默认给它加上无参数的"super()"方法。
 
 
阅读仔细的人会发现，为什么是没有“this()和super()”就写上“super()”？有“this()”就不能写上“super()”吗？那我问你，当构造方法第一行有"this()"时，你还能手动添加“super()”吗？显然不行，因为“this()”也只能出现在第一行，你不能在它前面写任何代码。所以我们又得出一个结论：构造方法中“this()”和“super()”不能同时出现，也就是“this()”和“super()”都只能出现在构造方法的第一行。
 
上面谈的都是无参数的“super”方法，我们也可以在构造方法的第一行使用有参数的“super(父类构造函数的参数列表)”，但值得注意的是，当子类构造方法执行有参数的“super(参数列表)”方法，你得确保父类中也有对应的有参数构造方法，不然会编译报错。同样我要提醒一下，当子类构造方法的第一行执行super()无参数方法，那么父类中一定要有无参数构造方法，有的人可能会在父类中写了有参数的构造方法，却忽略了写无参数构造方法，那么在子类构造方法内就会报错，因为当你在一个类中写了有参数的构造方法时，无参数构造方法就会不存在，你需要自己补上无参数的构造方法，这是一个良好的编程习惯。
 
无论你子类构造方法有没有“this()”和“super()”方法，实例化子类对象一定一定会执行对应的父类构造方法，即不管实例化了一个怎样的孩子，它一定会先实例化一个对应的父亲。
 
 
下面给道例题练习一下this()和super()方法：
 
public class MyTest {
	
	public static void main(String[] args) {
		new Cat(); 
	}
}

//父类，Animal类
class Animal {
	//构造函数
	public Animal() {
		super();
		System.out.println("1：Animal类的无参数构造函数执行");
	}
	public Animal(int i) {
		super();
		System.out.println("2：Animal类的有int参数构造函数执行");
	}
}

//子类，Cat类
class Cat extends Animal{
	//构造函数
	public Cat() {
		this("");
		System.out.println("3：Cat类的无参数构造函数执行");
	}
	public Cat(String str) {
		super(5);
		System.out.println("4：Cat类的有String参数构造函数执行");
	}
}
 
输出结果为：
 2：Animal类的有int参数构造函数执行
 4：Cat类的有String参数构造函数执行
 3：Cat类的无参数构造函数执行
 
我们又可以得出一个结论：不管你创建什么对象，Object对象的无参数构造方法一定会先执行，因为Object是所有类的根类。
 
 
说了这么多，super()到底什么时候使用？来看下面代码：
 
public class MyTest {
	
	public static void main(String[] args) {
		Cat c1 = new Cat(3); 
		System.out.println("名字：" + c1.getName() + "，年龄：" + c1.getAge());
	}
}

//父类，Animal类
class Animal {
	//私有属性：名字
	private String name;
	
	//setter and getter
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	
	//构造函数
	public Animal() {
		
	}
	public Animal(String name) {
		this.name = name;
	}
}

//子类，Cat类
class Cat extends Animal{
	//私有字段：年龄
	private int age;
	
	//setter and getter
	public void setAge(int age) {
		this.age = age;
	}
	public int getAge() {
		return age;
	}
	
	//构造函数
	public Cat() {
		
	}
	public Cat(int age) {
		this.age = age;
	}
}
 
输出结果：名字：null，年龄：3
 
我们也知道，没有给c1的name赋值嘛，当然为默认值null啦。
 确实如此，所以我们给Cat加一个构造方法，给name和age都赋值。
 如下：
 
public Cat(String name, int age) {
	this.name = name; //报错
	this.age = age
}
 
显然这样做是会报错的，因为name已经被父类封装成private的了，不能直接访问，可能有的人会这样做：
 
public Cat(String name, int age) {
	setName(name);
	this.age = age;
}
 
显然这样做的确可以做到给父类的name赋值，但这样做是不建议的，我们在构造方法中通常只调用构造方法，不会去调用实例方法，况且当不止一个变量时，用set方法时，我们就要调用好多个实例方法去完成多个变量的赋值。这时候为什么不考虑使用super()方法呢？如下：
 
public Cat(String name, int age) {
	super(name);
	this.age = age;
}
 
这样就显得文雅，美观多了。
 
 
总结：
 1、this和super一样，都是对象内部的引用变量，只能出现在对象内部；
 
2、 this指向当前对象自己，super指向当前对象的父类型特征，故this的东西比super多，也就是super是this的一部分；
 
3、 this()和super()都只能出现在构造方法的第一行，故this()和super()方法不能共存，当一个类的构造方法第一行中没有this()，也没有super()，系统默认有super()方法；
 
4、this()是构造方法中调用本类其他的构造方法，super()是当前对象构造方法中去调用自己父类的构造方法。
 

super 关键字主要有三个作用：
 
从子类访问父类的成员变量
从子类访问父类的成员方法
从子类构造器访问父类的构造器
 
下面我将从这三个方面做一些细节说明和注意事项。
 
从子类访问父类的成员变量
 
使用 super 关键字从子类访问父类的成员变量需要遵循访问修饰符的限制。如下图所示，父类的私有变量子类是无法访问到的，其他类型的变量也都有一定的作用域。
 
 
从子类访问父类的成员方法
 
使用 super 关键字从子类访问父类的成员方法需要遵循访问修饰符的限制。如下图所示，父类的私有方法子类是无法访问到的，其他类型的方法也都有一定的作用域。
 
 
从子类构造器访问父类的构造器
 
使用 super 关键字从子类构造器访问父类的构造器我们需要注意以下两点：
 
在子类构造器中使用 super() 调用父类中的其他构造器时，该语句必须处于构造器的首行，否则编译器会报错。
子类构造器如果没有显示使用 super() 调用父类的构造器，那么会默认调用 super() 的无参构造器。
 
下面我会写一些案例来帮助理解以上两点注意事项。
 
 
父类有一个 public 无参构造器，代码如下：
 
public class Parent {
    public Parent() {
        System.out.println("我是父类的无参构造器");
    }
}

public class Son extends Parent {
    public Son() {
        super();
        System.out.println("我是子类的无参构造器");
    }

    public static void main(String[] args) {
        Son son = new Son();
    }
}
 
控制台输出如下：
 
我是父类的无参构造器
我是子类的无参构造器
 
 
父类有一个 public 有参构造器，代码如下：
 
public class Parent {
    public Parent(int a) {
        System.out.println("我是父类的有参构造器，参数为" + a);
    }
}

public class Son extends Parent {
    public Son() {
        super(6);
        System.out.println("我是子类的无参构造器");
    }

    public static void main(String[] args) {
        Son son = new Son();
    }
}
 
控制台输出如下：
 
我是父类的有参构造器，参数为6
我是子类的无参构造器
 
 
父类只有一个 private 无参构造器
 
如果父类只有一个 private 无参构造器，那么子类在创建子类构造器时会报错。因为子类构造器在创建时一定要调用一个父类构造器（无论是显示调用还是隐式调用都可以），但父类只有一个 private 无参构造器，而这个构造器因为是 private 的，所以子类是访问不到的，也就是说子类没有可以调用的父类构造器，所以会报错。
 
 
注意
 
super 关键字不能用在 static 方法中。因为 super 代表对父类对象的引用，指向父类对象，而静态方法是属于类范畴的东西。

一、this和super关键字区别
 1.为什么要使用super？
 子类要访问父类方法或变量。
 子类中调用父类的构造方法。
 this:
 this关键字只能用于方法的方法体内，表示对“调用方法的那个对象”的引用。当一个对象创建后，Java虚拟机(JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是this。因此，this只能在类中的非静态方法中使用，静态方法和静态代码块中绝对不能出现this。
 
super:
 super关键字和this的作用类似，将被隐藏的父类的成员变量和成员方法变为可见，或者说用来引用被隐藏的父类的成员成员变量和成员方法。
 
二、使用场景：
 1.使用super和this调用成员变量和方法
 
有时会遇到子类中的成员变量或方法与父类中的成员变量或方法同名。因为子类的成员变量或方法名优先级高，所以子类的同名成员变量或方法就隐藏了父类的成员变量或方法，就需要用到super。看不懂看代码，自己试着理解
 
class Country{
    String name;
    void value() {
        name = "china";
    }
}
public class City extends Country{
    String name;
    void value() {
        name = "Xian";
        super.value();
        //不调用此方法时，super.name返回的是父类的成员变量的值null
        System.out.println(name);
        System.out.println(super.name);
    }
    public static void main(String[] args) {
        City c=new City();
        c.value();
    }
}
//运行结果：
//Xian
//china
 
为了在子类中引用父类中的成员变量name和方法value()，在代码中使用了super、super.name和super.value()。若不调用super.value()，super.name返回父类的成员变量默认值null，调用此方法时，super.value()方法把成员变量name赋值为China，再利用super.name调用父类的成员变量的值。另外，要注意的是super.name 调用的是父类的成员变量的值。
 
class Country{
    String name="shanxi";
    String value(String name) {
        name = "china";
        return name;
    }
}

public class City extends Country{
    String name;
    String value(String name) {
        name = "Xian";
        super.value("失败");
        //不调用此方法时，super.name返回的是父类的成员变量的值null
        System.out.println(name);
        System.out.println(super.name);
        return name;
    }
    public static void main(String[] args) {
        City c=new City();
        c.value("成功");
    }
//Xian
//shanxi
 
此时，super.name返回的值是父类成员变量的值shanxi，而此时的super.value()方法是不起作用的。
 
2.用super和this调用构造方法
 

class Person{
    public static void prt(String s){
        System.out.println(s);
    }
    Person(){
        prt("A Person");
    }
    Person(String name){
        prt("A Person name is:"+name);
    }
}


public class Chinese extends Person{
    Chinese(){
        super();//调用父类的无参构造方法（1）
        prt("A chinese");//（4）

    }
    Chinese(String name){
        super(name);//调用父类具有相同形参的构造方法（2）
        prt("his name is:"+name);
    }
    Chinese(String name,int age){
        this(name);//调用当前子类中具有相同形参的构造方法（3）
        prt("his age is:"+age);

    }

    public static void main(String[] args) {
        Chinese cn=new Chinese();
        cn=new Chinese("zhiwen");
        cn=new Chinese("zhiwen",38);

    }

//A Person
//A chinese
//A Person name is:zhiwen
//his name is:zhiwen
//A Person name is:zhiwen
//his name is:zhiwen
//his age is:38
 
在这段代码中，this和super不再是像以前那样用“.”连接一个方法或成员，而是直接在其后跟上适当的参数，因此它的意义也就有了新的变化。super后加参数表示用来调用父类中具有相同形式的参数的构造方法，如（1）和（2）处。this后加参数表示调用的是当前类具有相同形式参数的构造方法，如（3）处。当然，在Chinese的各个重载构造方法中，this和super的一般用法仍可使用，比如（4）处，你可以将它替换为“this.prt”（因为它继承了父类中的那个prt方法）或者使用“super.prt”（因为它父类中的方法且可以被子类访问到），他照样可以运行，但这样似乎有点画蛇添足的感觉。
 
3.子类的构造方法如果要引用super的话，必须把super放在方法的首行
 
class Base{
    Base(){
        System.out.println("Base");
    }
}
public class Checket extends Base{
    Checket(){
        super();//调用父类的构造方法，一定要放在这个方法的首个语句
        System.out.println("Checket");
    }

    public static void main(String[] args) {
        Checket c=new Checket();

    }
//Base
// Checket
}

 
如果想使用super调用父类构造的方法，但是没有放在第一行的话，那么在super之前的语句，肯定是为了满足自己想要完成某些行为的语句，但是又用super调用父类的构造方法，那么以前所做的修改就都回到以前了，就是说又成了父类的构造方法了。
 
总结：
 1.不能同时出现在一个同一个构造函数调用其他构造函数
 super(参数）：调用父类中的某一个构造方法，应该为构造方法中的第一条语句。
 this(参数):调用本类中另一种形式的构造方法，应该为构造方法中的第一条语句。
 this()和super()不能同时出现在一个构造方法里面，因为this必然会调用其他构造方法，其他构造方法中必然也会有super语句的存在，在同一个构造方法里面有相同的语句就失去了语句的意义，编译也不会通过。
 2.调用构造函数的区别：
 super：引用当前对象的直接父类中的成员，用来访问直接父类中被隐藏的成员变量或方法。父类与子类中有相同的成员时使用，如：super.变量名或super.成员方法名(实参）。
 this：代表当前对象名，在程序中易产生二义性之处，应使用this来指明当前对象。如果方法的形参与类中的成员变量同名，这时需用this来指明成员变量名。
 3.使用的前提不一样：
 super关键字必须要有继承才能使用；
 this关键字不需要存在继承也可以使用。
 4.其他：
 调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含的调用super()，如果父类中
 没有这种构造方法，那么在编译的时候会报错。
 
this和super都指的是对象，所以均不可以在static方法中使用。