子类成员变量的隐藏、方法重写以及final、super关键字

成员变量的隐藏：

子类可以隐藏继承的成员变量，只要子类中定义的成员变量和父类中的成员变量同名时，子类就隐藏了继承的成员变量；子类也可以隐藏已继承的方法，子类通过方法重写来隐藏继承的方法，一旦子类重写了父类的方法f，就隐藏了父类的f，如果想要使用被隐藏的方法必须使用super关键字。

方法重写：子类中定义一个方法，并且这个方法的名字、返回类型、参数个数和类型与从父类继承的方法完全相同。

注意方法重写和重载的区别，重载是一个类中方法有不同的参数（类型或者个数），两者都是多态的实现方式。

eg.

class Chengji{
    float f(float x,float y){
        return x*y;
    }
}
class Xiangjia extends Chengji{
    float f(float x,float y){
        return x+y;
    }
}
public class Example{
    public static void main(String args[]){
        Xiangjia sum;
        sum=new Xiangjia();
        float c=sum.f(4,6);
        System.out.println(c);
    }
}

上述输出结果是10.0，可见f已经被子类重写了。

值得注意的是，重写父类的方法时，不能降低方法的访问权限，如下代码中，子类重写父类的f，该方法在父类中是protected级别，子类重写时不允许级别低于protected级别：

class Chengji{
    protected float f(float x,float y){
        return x*y;
    }
}
class Xiangjia extends Chengji{
    float f(float x,float y){//非法，因为降低了访问级别
        return x+y;
    }
}
class Xiangjia extends Chengji{
    public float f(float x,float y){//合法，因为没有降低访问级别
        return x+y;
    }
}

final关键字:

final关键字可以修饰类成员变量和方法中的参数。

final类不能被继承，即不能有子类。

final修饰的方法不能被重写。

final修饰的成员变量就是常量，必须给初值并且不能再发生变化。

final修饰方法的参数，那么该参数的值不能被改变。

eg.

class A{
    //final double PI;//非法，因为没有给初值。
    final double PI=3.1415926;//合法，PI是常量且给定初值。
    public double getArea(final double r){
        //r=89//非法，因为不允许再改变r的值
        return PI*r*r;
    }
}

super关键字

1.使用关键字super调用父类的构造方法：

子类不继承父类的构造方法，因此子类如果想使用父类的构造方法必须在子类的构造方法中使用，并且必须使用super来表示，而且super必须是子类构造方法中的头一条语句，如:

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);
        婚否=b;
        System.out.println("婚否="+婚否);
    }
}
public class Ceshi{
    public static void main(String args[]){
        Univer_Student zhang=new Univer_Student(9901,"张三",false);
    }
}

输出结果：

！！需要注意的是如果在子类的构造方法中，没有用super调用父类的某个构造方法，那么默认有:"super();"即调用父类的不带参数的构造方法，如果类里定义了一个或多个构造方法，那么java不提供默认的不带参数的构造方法，因此当在父类中定义多个构造方法时，应当包括一个不带参数的构造方法，以防子类省略super时出现错误。如果父类没有不带参数的构造方法，则在子类的构造方法中必须明确的告诉调用父类的某个带参数的构造方法，通过super关键字，这条语句还必须出现在构造方法的第一句。

2.使用 super操作被隐藏的成员变量和方法

如果在子类中想要使用被子类隐藏了的父类的成员变量或者方法就可以使用关键字super，比如super.x、super.f()。这个很简单，就不举例子了。

父类{

f(){}

};

子类{

f(){super.f();//在子类中可以如此调用父类f()}

}