Java继承中的super()关键字

super关键字

super 表示使用它的类的父类。super 可用于：
调用父类的构造方法；
调用父类的方法（子类覆盖了父类的方法时）；
访问父类的数据域（可以这样用但没有必要这样用）。
调用父类的构造方法语法：

	super();  

	或   

	super(参数列表);

注意：super 语句必须是子类构造方法的第一条语句。不能在子类中使用父类构造方法名来调用父类构造方法。 父类的构造方法不被子类继承。调用父类的构造方法的唯一途径是使用 super 关键字，如果子类中没显式调用，则编译器自动将 super(); 作为子类构造方法的第一条语句。这会形成一个构造方法链。

静态方法中不能使用 super 关键字。

调用父类的方法语法：

	super.方法名(参数列表);

如果是继承的方法，是没有必要使用 super 来调用，直接即可调用。但如果子类覆盖或重写了父类的方法，则只有使用 super 才能在子类中调用父类中的被重写的方法。

---

java文件被编译成class文件时，在子类的所有构造函数中的第一行（第
一个语句）会默认自动添加 super() 语句，在执行子类的构造函数前，总是会先执行父类中的构造函数。

在编写代码要注意：

1.如果父类中不含 默认构造函数（就是 类名() ），那么子类中的super()语句就会执行失败，系统就会报错。一般 默认构造函数 编译时会自动添加，但如果类中已经有一个构造函数时，就不会添加。

2.执行父类构造函数的语句只能放在函数内语句的首句，不然会报错。
在继承关系中，在调用函数（方法）或者类中的成员变量时，JVM（JAVA虚拟机）会先检测当前的类（也就是子类）是否含有该函数或者成员变量，如果有，就执行子类中的，如果没有才会执行父类中的。如下：

public class Start{
	public static void main(String[] args){
   	 	Cat cat=new Cat("Jack","黑色");
   	 	cat.eat();
    	cat.run();
    	cat.sleep();
  }

}

class Animal {
	String name;

	public Animal(){}//必须要写这个构造函数，不然Cat类的代码会出错

	public Animal(String name){
    	this.name=name;
}
    void eat() {
    	System.out.println(name+"正在吃");
}

	void run(){
        System.out.println(name+"正在奔跑");
}

    void sleep(){
    System.out.println(name+"正在睡觉");
 }
}

class Cat extends Animal{
	 String color;
	 public Cat(String name,String color)
	{ 
    	this.name=name;
    	this.color=color;
}
   void eat(){
    System.out.println(color+"的"+name+"正在吃鱼");
    }
}

运行结果如下：

        黑色的Jack正在吃鱼
       Jack正在奔跑
       Jack正在睡觉

3.子类的所有构造方法内部， 第一行会（隐式）自动先调用父类的无参构造函数super()；如果子类构造方法第一行显式调用了父类构造方法，系统就不再调用无参的super()了。

实例：

 class Base {
	public Base() {
    	System.out.println("Base--默认构造方法");
}

	public Base(int c){
    	System.out.println("Base--有参构造方法--" + c);
 }
}

public class Derived extends Base {
	public Derived() {
    // super(); //系统会自动隐式先调用父类的无参构造函数 super(); //必须是第一行，否则不能编译 
    	System.out.println("Derived--默认构造方法");
}

	public Derived(int c) {
    // super(); //系统会自动隐式先调用父类的无参构造函数 super(); //必须是第一行，否则不能编译
    	System.out.println("Derived--有参构造方法" + c);
}

	public Derived(int a, int b) {
    super(a); //如果子类构造方法第一行显式调用了父类构造方法，系统就不再调用无参的super()了。
    	System.out.println("Derived--有参构造方法--" + b);
}

	public static void main(String[] args) {
   	 	System.out.println("============子类无参============");
     	Derived no = new Derived();
   		System.out.println("============子类有参============");
    	Derived have = new Derived(33);
    	System.out.println("============子类有参============");
    	Derived have2 = new Derived(33, 55);
 }
}

运行结果如下：

============子类无参============
Base--默认构造方法
Derived--默认构造方法
============子类有参============
Base--默认构造方法
Derived--有参构造方法33
============子类有参============
Base--有参构造方法--33
Derived--有参构造方法--55

### 注意：如果父类没有无参构造函数，创建子类时，不能编译，除非在构造函数代码体中的第一行显式调用父类有参构造函数。