关于Java继承中super的使用

super关键字的使用：

三种情况：
1.在子类中使用父类的成员变量（同名）。
2.子类重写了父类的方法时，本来应该直接调用子类的方法，用super来执行父类中的方法。
3.子类不会继承父类的构造方法（构造方法不会被继承也不会被重写），使用super来用父类的构造方法。（写在子类构造方法的第一句！！！）

第一个例子：（情况1和情况2）

class Sum{
    int n;
    float f() {
        float sum=0;
        for(int i=0;i<=n;i++) {
            sum=sum+i;
        }
        return sum;
    }
}
class Average extends Sum{
    int n;
    //子类重写父类的方法
    float f() {
        float c;
        super.n=n;    //情况1：把100传给父类的n
        c=super.f();  //情况2：调用父类的f()方法，n=100，返回sum的值给c，此时c=5050.0
        return c/n;   //返回5050.0/100的值给result_1
    }
    //子类新增的方法
    float g() {
        float c;
        c=super.f();  //情况2：调用父类的f()方法，此时c=5050.0
        return c/2;   //返回c/2的值给result_2
    }
}
public class Example4_17{ 
    //一切从main方法开始。。。
    public static void main(String args[]) {
        Average aver=new Average();  //创建aver对象
        aver.n=100;                  //给子类的n赋值100
        float result_1=aver.f();     //调用子类的f()方法，结果赋给result_1
  	float result_2=aver.g();     //调用子类的g()方法，结果赋给result_2
  	System.out.println("result_1="+result_1);
 	System.out.println("result_2="+result_2);
    }
}

结果：

result_1=50.5
result_2=2525.0

第二个例子：（情况3）

class Student{
    int number;
    String name;
    //无参的构造方法(默认构造方法)
    Student(){}
    //有两个参数的构造方法(重载)        
    Student(int number,String name){
  	this.number=number;
  	this.name=name;
  	System.out.println("I am"+name+",my number is"+number);
    }
}
class Univer_Student extends Student{
    boolean 婚否;
    Univer_Student(int number,String name,boolean b){
        super(number,name);   //情况3：调用父类的Student(int number,String name)方法
        婚否=b;
        System.out.println("婚否："+婚否);
    }
}
public class Example4_18 {
    //一切从main开始。。。
    public static void main(String[] args) {
    //用子类创建对象Zhang
    Univer_Student Zhang=new Univer_Student(25,"xiaoming",false);
    }
}

结果：

I amxiaoming,my number is25
婚否：false

第三个例子：（不重要）

class Students{
    int age;
    String name;
    Students(int age,String name){
 	this.age=age;
  	this.name=name;
    }
    public void learning(){
  	System.out.println("学生的学习方法");
    }
    public void show(){
  	System.out.println("姓名："+name+"，年龄："+age);
    }
}
class Undergraduate extends Students{
    String major,degree;
    Undergraduate(int age, String name,String major,String degree) {
  	super(age, name);
        this.major=major;
 	this.degree=degree;
    }
    public void learning(){
  	System.out.println("本科生的 学习方法");
    }
    public void show(){
  	System.out.println("姓名："+name+"，年龄："+age+"，主修："+major+"，学位："+degree);
    }
}
class Graduate extends Undergraduate{
    String direction;
    Graduate(int age, String name,String major,String degree,String direction){
  	super(age,name,major,degree);
  	this.direction=direction;
    }
    public void learning(){
  	System.out.println("研究生的学习方法");
    }
    public void show(){
  	System.out.println("姓名："+name+"，年龄："+age+"，主修："+major+"，学位："+degree+"，研究方向："+direction);
    }
}
public class Test4{
    public static void main(String args[]){
   	Students A=new Students(14,"小明");
  	A.learning();
  	A.show();
  	Undergraduate B=new Undergraduate(20,"小芳","英语","本科生");
 	B.learning();
  	B.show();
  	Graduate C=new Graduate(23,"小红","数学","研究生","统计学");
  	C.learning();
  	C.show();
    }
}

结果：

学生的学习方法
姓名：小明，年龄：14
本科生的 学习方法
姓名：小芳，年龄：20，主修：英语，学位：本科生
研究生的学习方法
姓名：小红，年龄：23，主修：数学，学位：研究生，研究方向：统计学

ps:
1.关于继承中构造方法的执行：若父类的构造方法无参，首先执行父类的构造方法，再执行子类的（在创建子类的对象前，必须保证先创建父类的对象）；若父类的构造方法有参，则用super关键字代指父类来调用父类的构造方法，并且super的语句必须是子类构造方法的第一条语句！！！