Java的继承性和方法重写

方法重写需要建立在继承之上，先讲继承性，再说方法重写：

（一）继承

（1）Java继承性的好处：

①减少了代码的冗余，提高了代码的复用性；

②便于功能的扩展；

③为之后的多态性的使用，提供了前提。

（2）继承性的格式：class A extends B { }

A：子类 subclass
B：父类 superclass

①体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的结构：属性、方法；

特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只是因为封装性的影响，使得子类不能直接调用父类的结构而已。

②子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的扩展

（3）Java中关于继承性的规定

①一个类可以被多个子类继承；

②Java中类的单继承性：一个类只有一个子类；

③子父类是相对的概念；

④子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类；

⑤子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法。

（4）

①如果没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类；

②所有的java类（除了java.lang.Object类之外）都直接或间接的继承于java.lang.Object类；

③所有的java类具有java.lang.Object类声明的功能。

（二）方法的重写（override/overwrite）

（1）定义：在子类中可以根据需要对从父类中继承来的方法进行改造。在程序执行时，子类的方法将覆盖父类的方法。(同名同参数)

（2）应用：重写以后，当创建子类对象以后，通过子类对象调用子类中的同名同参数的方法时，实际执行的是子类重写父类的方法。

（3）方法重写的一些规定：

方法的声明：  权限修饰符  返回值类型  方法名（形参列表）（throws  异常的类型）{
                                  //方法体（不同）
               }
统一称呼：子类中的叫重写的方法；父类中叫被重写的方法。

①子类重写的方法的方法名和形参列表与父类中的被重写方法的方法名和形参列表相同；

②子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符；

特殊情况：子类不能重写父类中声明为private权限的方法

③返回值类型：

1.父类被重写的方法返回值类型是void，则子类重写的方法返回值类型只能是void；
2.父类被重写的方法返回值类型是A类类型，则子类重写的方法的返回值类型可以是A类或A类的子类；
3.父类被重写的方法返回值类型是基本数据类型（比如：int），则子类重写的方法的返回值类型必须是相同的基本数据类型（必须也是int）；
4.子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型。

子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）

package com.java.oop3;
/**
 * @ClassName Person
 * @Description:    人类
 * @Author Seven
 * @Date 2021/7/28 18:59
 * @Version 1.0
 **/
public class ManKind {
    private int sex;    //性别
    private int salary; //薪资

    public ManKind(){

    }

    public ManKind(int sex, int salary) {
        this.sex = sex;
        this.salary = salary;
    }

    public int getSex() {
        return sex;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public void manOrWoman(int sex){
        if(sex == 1){
            System.out.println("man");
        }else{
            System.out.println("woman");
        }
    }

    public void employee(int salary){
        if(salary == 0){
            System.out.println("no job");
        }else{
            System.out.println("job");
        }
    }
}

Kids类继承于Person类：

package com.java.oop3;

/**
 * @ClassName Kids
 * @Description:	小孩类继承人类
 * @Author Seven
 * @Date 2021/7/28 19:43
 * @Version 1.0
 **/
public class Kids extends ManKind{
    private int yearsOld;   //年龄

    public Kids(){

    }

    public Kids(int yearsOld){
        this.yearsOld = yearsOld;
    }

    public int getYearsOld() {
        return yearsOld;
    }

    public void setYearsOld(int yearsOld) {
        this.yearsOld = yearsOld;
    }

    public void printAge(int yearsOld){
        System.out.println(this.yearsOld);
    }
    
}

Kids继承于Person类，并重写Person父类中的方法employee()：

package com.java.oop3;

/**
 * @ClassName Kids
 * @Description:	小孩类，继承人类并实现employee()方法的重写
 * @Author Seven
 * @Date 2021/7/28 19:43
 * @Version 1.0
 **/
public class Kids extends ManKind{
    private int yearsOld;   //年龄

    public Kids(){

    }

    public Kids(int yearsOld){
        this.yearsOld = yearsOld;
    }

    public int getYearsOld() {
        return yearsOld;
    }

    public void setYearsOld(int yearsOld) {
        this.yearsOld = yearsOld;
    }

    public void printAge(int yearsOld){
        System.out.println(this.yearsOld);
    }

    @Override
    public void employee(int salary) {  //方法的重写
        System.out.println("Kids should study and no job");
    }
}

package com.java.oop3;

/**
 * @ClassName KidsTest
 * @Description:	测试类
 * @Author Seven
 * @Date 2021/7/28 19:46
 * @Version 1.0
 **/
public class KidsTest {
    public static void main(String[] args) {
        Kids someKid = new Kids();
        someKid.setSex(1);
        someKid.setYearsOld(18);
        someKid.employee(0);
    }
}

继承的结果：

方法重写的结果：