继承中构造方法的调用与方法重写

继承中构造方法的调用

 

---

 

在构造方法里面进行初始化的时候，有时如果我们一个一个去初始化，会显得比较麻烦，特别是当在某一个方法里对一些变量初始化，然后以另外一种方式写这个方法的时候，又需要重新对同样的变量初始化时，会毫无意义地增加代码行数，因此，我们可以把子类里面的变量的初始化写在一个方法里，这样一来，以后如果再需要初始化，直接调用这个方法即可。下面来看代码：

package com.hw.static0127;
class People{
    private String name;
    private int age;
    public People(String name,int age){
        this.name = name;
        this.age = age;
    }
    public String getName(){
        return name;
    }
    public void eat(){
        System.out.println(getName()+"在吃饭");
    }
}

class Student extends People{
    private double score;
    private int rankNum;
    
    public Student(String name,int age,double score,int rankNum){
        super(name,age);
        init(score,rankNum);
    }
    private void init(double score,int rankNum){
        this.score = score;
        this.rankNum = rankNum;
    }
    public void setscore(double score){
        this.score = score;
    }
    public double getscore(){
        return score;
    }
    public int getRankNum(){
        return rankNum;
    }
    public void show(){
        System.out.println("学生的名字是:"+getName()+"，排名是:"+getRankNum());
    }
}

class Teacher extends People{
    private double salary;
    private int level;
    public Teacher(String name,int age,double salary,int level){
        super(name,age);
        init(salary,level);  //初始化时直接调用这个方法
    }
    private void init(double salary,int level){ //把初始化写在一个专门的方法里
        this.salary = salary;
        this.level = level;
    }
    public void setSalary(double salary){
        this.salary = salary;
    }
    public double getSalary(){
        return salary;
    }
    public void setLevel(int level){
        this.level = level;
    }
    public int getLevel(){
        return level;
    }
    public void show(){
        System.out.println("老师的名字是:"+getName()+"，等级是:"+getLevel());
    }
}

public class Explanation {
    public static void main(String[] args){
        Student stu = new Student("敕勒川",20,100,1);
        stu.show();
        stu.eat();
        System.out.println(stu.getName()+"的分数是:"+stu.getscore());
        stu.setscore(98);
        System.out.println(stu.getName()+"现在的分数是:"+stu.getscore());
        Teacher tch = new Teacher("阴山下",25,5000,7);
        tch.show();
        tch.eat();
        System.out.println(tch.getName()+"的薪水是:"+tch.getSalary());
        tch.setSalary(6000);
        System.out.println(tch.getName()+"现在的薪水是:"+tch.getSalary());
    }
}

来看下运行效果：

 

 

 完全正常！

---

 

方法重写：

我们在People类里面定义了一个eat方法，但是，实际生活中由于某些需要，我们在具体到是学生类还是老师类的时候，这个行为肯定是有区别的。因此，我们需要在子类中重写方法。一般地，当子类中的方法名、参数和返回值与父类相同的时候，就是方法重写（也叫方法覆盖）。其意义是：子类和父类拥有同样的功能，但子类有自己的特定内容和特定实现方式，可以定义一个不同的名字方法，但为了见名知意，保持父类名字，自己重新实现方法体。还是上面那个程序，我们来看看重写方法eat方法后的代码：

package com.hw.static0127;
class People{
    private String name;
    private int age;
    public People(String name,int age){
        this.name = name;
        this.age = age;
    }
    public String getName(){
        return name;
    }
    public void eat(){
        System.out.println(getName()+"在吃饭");
    }
}

class Student extends People{
    private double score;
    private int rankNum;
    
    public Student(String name,int age,double score,int rankNum){
        super(name,age);
        init(score,rankNum);
    }
    private void init(double score,int rankNum){
        this.score = score;
        this.rankNum = rankNum;
    }
    public void setscore(double score){
        this.score = score;
    }
    public double getscore(){
        return score;
    }
    public int getRankNum(){
        return rankNum;
    }
    public void show(){
        System.out.println("学生的名字是:"+getName()+"，排名是:"+getRankNum());
    }
    public void eat(){   //方法的重写
        System.out.println("先刷校园卡");
        System.out.println(getName()+"在吃饭");
    }
}

class Teacher extends People{
    private double salary;
    private int level;
    public Teacher(String name,int age,double salary,int level){
        super(name,age);
        init(salary,level);  //初始化时直接调用这个方法
    }
    private void init(double salary,int level){ //把初始化写在一个专门的方法里
        this.salary = salary;
        this.level = level;
    }
    public void setSalary(double salary){
        this.salary = salary;
    }
    public double getSalary(){
        return salary;
    }
    public void setLevel(int level){
        this.level = level;
    }
    public int getLevel(){
        return level;
    }
    public void show(){
        System.out.println("老师的名字是:"+getName()+"，等级是:"+getLevel());
    }
    public void eat(){   //方法的重写
        System.out.println("先出示教师证");
        System.out.println(getName()+"在吃饭");
    }
}

public class Explanation {
    public static void main(String[] args){
        Student stu = new Student("敕勒川",20,100,1);
        stu.show();
        stu.eat();
        System.out.println(stu.getName()+"的分数是:"+stu.getscore());
        stu.setscore(98);
        System.out.println(stu.getName()+"现在的分数是:"+stu.getscore());
        Teacher tch = new Teacher("阴山下",25,5000,7);
        tch.show();
        tch.eat();
        System.out.println(tch.getName()+"的薪水是:"+tch.getSalary());
        tch.setSalary(6000);
        System.out.println(tch.getName()+"现在的薪水是:"+tch.getSalary());
    }
}

 

运行效果：

 

 

要注意一点：重写的时候，访问权限不能更低！可以把一个private的方法重写成public的方法，但不能把一个public的方法重写成private的方法！

另外需注意：

 

最后，来看看final关键字：

 

 意思是：放到上面的代码中，如果我们写成final class People,那么这个People是不能被继承的！其次，如果上面的代码中，父类中的eat方法我们写成public final void eat()，那么在子类中是不允许被重写的。但是！如果父类中的这个eat方法是private的，那么是允许的。最后，如果放在一个变量前面，那么这个变量就变成了一个常量，在第一次被初始化之后，就不能再次初始化了。