Day 10 （继承、重写与super的使用）

一、继承 

        Java只支持单继承和多层继承，不支持多重继承，一个子类只能有一个父类，但一个父类可以有多个子类。

继承性的好处：

•         减少代码的冗余，提高了代码的复用性
•         便于功能的扩展
•         为以后多态性的使用做铺垫

继承的格式：

        class A extends B { }     A是子类（派生类），B是父类（超类）

练习题1 ：

     

 Mankind类：

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(){
        if (sex == 1){
            System.out.println("man");
        }else if (sex == 0){
            System.out.println("woman");
        }
    }
    public void employeed(){
        if (salary == 0){
            System.out.println("no job");
        }else if (salary != 0){
            System.out.println("job");
        }
    }
}

Kids类：

//Kids继承Mankind类
public class kids extends Mankind{
    private int yearOld;

    public kids(int yearOld) {
        this.yearOld = yearOld;
    }
    public void printAge(){
        System.out.println("I am " + yearOld + " years old");
    }
}

  KidsTest代码：

public class KidsTest {
    public static void main(String[] args) {
        kids someKid = new kids(22);
        someKid.printAge();
        someKid.setSex(1);
        someKid.setSalary(0);
        someKid.manOrWoman();
        someKid.employeed();
    }
}

练习题2 ：

        在CylinderTest类中创建Cylinder类的对象，设置圆柱的地面半径和高，并输出圆柱的体积

Circle类:

public class Circle {
    private double radius;
    public Circle(){
        radius = 1;
    }
    public void setRadius(double radius){
        this.radius = radius;
    }
    public double getRadius(){
        return this.radius;
    }
    public double findArea(){
        return Math.PI*radius*radius;
    }
}

Cylinder类：

public class Cylinder extends Circle{
    private double length;
    public Cylinder(){
        length = 1;
    }
    public void setLength(double length){
        this.length = length;
    }
    public double getLength(){
        return length;
    }
    public double findVolume(){
        //父类的方法也被继承过来 可以直接使用父类方法
        return findArea() * getLength();
    }
}

CylinderTest代码:

public class CylinderTest {
    public static void main(String[] args) {
        Cylinder cy = new Cylinder();
        cy.setRadius(2.8);
        cy.setLength(2.8);
        System.out.println("圆的面积为:" + cy.findArea());
        System.out.println("圆柱的体积为:"+cy.findVolume());
    }
}

二、覆写

        当子类定义了和父类的方法名称、返回值类型、参数类型及个数完全相同时，就称方法的覆写。

覆写要求：

        （1）子类重写的方法与父类被重写的方法的方法和形参列表完全一样

        （2）子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符

        （3） 返回值类型：

                1、父类被重写的方法返回值是void，子类也必须是void；

                2、父类被重写的方法的返回值类型是A类，则子类重写的返回值类型可以是A类或A的子类（比如父类返回值是Object，子类可以是Object也可以是String）

                3、父类被重写的方法的返回值类型是基本数据类型，则子类重写的返回值类型必须是相同的基本数据类型。

重载与覆写的区别？

        重载发生在一个类里面，覆写发生在继承关系中；

        重载方法名相同，参数类型和参数个数不同；

        覆写方法名相同，参数类型、参数个数、方法返回值相同；

        重载没有权限的限制，在覆写中，子类所覆写的方法权限不能比父类更严格；

        重载不表现为多态性，重写表现为多态性;

三、super的使用

•         super表示父类的，可以在子类的方法或构造器中采用“super.属性” “super.方法” 来显式的调用父类的属性或方法。
•         可以在子类的构造器中显式的使用super（形参列表），调用父类中声明的指定的构造器
•         super（形参列表）必须声明在子类构造器的首行
•         super（形参列表）、 this（形参列表）只能出现一个
•         当在构造器的首行，没有显式的声明 super（形参列表）、 this（形参列表），则默认调用的是父类中空参的形参列表
•         若子类有n个构造器，至少有一个是使用了super()调用了父类的构造器（因为子类中最多有n-1个使用this调用子类构造器）
•         通过子类构造器创建对象时，一定会直接或间接的调用父类的构造器，进而调用其父类的父类的构造器...直至调用Object类的空参构造器