第十二章继承

作者: 十一_2bef | 来源:发表于2018-05-28 18:13 被阅读0次

为什么要使用继承

当类很多并且这些类有很多共同之处的时候，我们需要建一个父类将这些类的相同之处归纳到一起，以便以后再次出现相似类的时候可以调用父类中的属性或者参数，来减少子类中的代码数量。

使用继承

编写父类

class Pet { 
        //公共的属性和方法
}

编写子类

class Dog extends Pet { 
        //子类特有的属性和方法
}

class Penguin extends Pet { 
}

方便理解的例子

未使用继承以前

狗类

public class Dog extends Pet{
    String name = "旺财"; // 昵称
    int health = 100;     // 健康值0---100 private私有的
    int love = 0;        // 亲密度
    int type;//类型：1狗2企鹅
    int kind;//品种

    public String toString()
    {
        String strKind = "";
        if(kind == 1)
        {
            strKind = "拉布拉多";
        }
        else if(kind == 2)
        {
            strKind = "雪纳瑞";
        }
        String str = "宠物的自白，我的名字叫"
                +name+"健康值是"+health+"和主人的亲密度是"+love+"我是一只"+strKind;
        return str;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getHealth() {
        return health;
    }

    public void setHealth(int health) {
        this.health = health;
    }

    public int getLove() {
        return love;
    }

    public void setLove(int love) {
        this.love = love;
    }

    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }

    public int getKind() {
        return kind;
    }

    public void setKind(int kind) {
        this.kind = kind;
    }

}

企鹅类

public class Penguin extends Pet {
    String name = "旺财"; // 昵称
    int health = 100;     // 健康值0---100 private私有的
    int love = 0;        // 亲密度
    int type;//类型：1狗2企鹅
    private int sex;//性别

    public String toString()
    {
        String strSex = "";
        if(sex == 1)
        {
            strSex = "Q仔";
        }
        else if(sex == 2)
        {
            strSex = "Q妹";
        }
        String str = "宠物的自白，我的名字叫"
                +name+"健康值是"+health+"和主人的亲密度是"+love+"我是一只"+strSex;
        return str;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getHealth() {
        return health;
    }

    public void setHealth(int health) {
        this.health = health;
    }

    public int getLove() {
        return love;
    }

    public void setLove(int love) {
        this.love = love;
    }

    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }

    public int getSex() {
        return sex;
    }

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

主方法

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("欢迎来到宠物店");
        System.out.println("请输入宠物名字");

        String name = scanner.next();

        System.out.println("请输入宠物类型:1狗，2企鹅");
        int type = scanner.nextInt();
        if(type == 1)
        {
            Dog d = new Dog();
            System.out.println("请输入品种,1聪明的拉布拉多，2酷酷的雪纳瑞");
            int kind = scanner.nextInt();
            d.setKind(kind);
            d.setName(name);
            System.out.println(d);
        }
        else
        {
            //new 企鹅();
            Penguin p = new Penguin();
            System.out.println("请输入性别,1 Q仔，2 Q妹");
            int sex = scanner.nextInt();
            p.setSex(sex);
            p.setName(name);
            System.out.println(p);
        }
    }
}

使用继承后
主方法(保持不变)

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("欢迎来到宠物店");
        System.out.println("请输入宠物名字");

        String name = scanner.next();

        System.out.println("请输入宠物类型:1狗，2企鹅");
        int type = scanner.nextInt();
        if(type == 1)
        {
            Dog d = new Dog();
            System.out.println("请输入品种,1聪明的拉布拉多，2酷酷的雪纳瑞");
            int kind = scanner.nextInt();
            d.setKind(kind);
            d.setName(name);
            System.out.println(d);
        }
        else
        {
            //new 企鹅();
            Penguin p = new Penguin();
            System.out.println("请输入性别,1 Q仔，2 Q妹");
            int sex = scanner.nextInt();
            p.setSex(sex);
            p.setName(name);
            System.out.println(p);
        }
    }
}

父类

public class Pet {
    String name = "旺财"; // 昵称
    int health = 100;     // 健康值0---100 private私有的
    int love = 0;        // 亲密度
    int type;//类型：1狗2企鹅
    int kind;//品种

    public String toString()
    {
        String strKind = "";
        if(kind == 1)
        {
            strKind = "拉布拉多";
        }
        else if(kind == 2)
        {
            strKind = "雪纳瑞";
        }
        String str = "宠物的自白，我的名字叫"
                +name+"健康值是"+health+"和主人的亲密度是"+love+"我是一只"+strKind;
        return str;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getHealth() {
        return health;
    }

    public void setHealth(int health) {
        this.health = health;
    }

    public int getLove() {
        return love;
    }

    public void setLove(int love) {
        this.love = love;
    }

    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }
}

狗子类

public class Dog extends Pet{

    int kind;//品种

    public String toString()
    {
        String strKind = "";
        if(kind == 1)
        {
            strKind = "拉布拉多";
        }
        else if(kind == 2)
        {
            strKind = "雪纳瑞";
        }
        String str = "宠物的自白，我的名字叫"
                +name+"健康值是"+health+"和主人的亲密度是"+love+"我是一只"+strKind;
        return str;
    }


    public int getKind() {
        return kind;
    }

    public void setKind(int kind) {
        this.kind = kind;
    }

}

企鹅子类

  private int sex;//性别

    public String toString()
    {
        String strSex = "";
        if(sex == 1)
        {
            strSex = "Q仔";
        }
        else if(sex == 2)
        {
            strSex = "Q妹";
        }
        String str = "宠物的自白，我的名字叫"
                +name+"健康值是"+health+"和主人的亲密度是"+love+"我是一只"+strSex;
        return str;
    }

    public int getSex() {
        return sex;
    }

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

求同存异

子类访问父类成员super

使用super关键字,super代表父类对象

访问父类构造方法
super(); --super调用构造方法时，只能是第一句
super(name);
访问父类属性
super.name;
访问父类方法
super.print();

不能被子类继承的父类成员

private成员
构造方法

protected

可以修饰属性和方法
本类、同包、子类可以访问

访问修饰符小结

image.png

上述表格有误，默认在子类中也适用

多重继承关系的初始化顺序

1.父类属性
2.父类构造方法
3.子类属性
4.子类构造方法

class Person {
    String name="李光";// 姓名
    public Person() {
        // super();//写不写该语句，效果一样
        System.out.println("execute Person()");
    }
    public Person(String name) {
        this.name = name;
        System.out.println("execute Person(name)");
    }
}

class Student extends Person {
    String school="蓝翔";// 学校
    public Student() {
        // super();//写不写该语句，效果一样
        System.out.println("execute Student() ");
    }
    public Student(String name, String school) {
        super(name); // 显示调用了父类有参构造方法，将不执行无参构造方法
        this.school = school;
        System.out.println("execute Student(name,school)");
    }
}

class PostGraduate extends Student {
    String guide;// 导师
    public PostGraduate() {
        // super();//写不写该语句，效果一样
        System.out.println("execute PostGraduate()");
    }
    public PostGraduate(String name, String school, String guide) {
        super(name, school);
        this.guide = guide;
        System.out.println("execute PostGraduate(name, school, guide)");
    }
}

class TestInherit {
    public static void main(String[] args) {
        PostGraduate pgdt=null;
        pgdt = new PostGraduate();
        System.out.println();
        pgdt=new PostGraduate("刘小光","北京大学","王老师");
    }
}

继承条件下构造方法的调用规则如下：

如果子类的构造方法中没有通过super显式调用父类的有参构造方法，也没有通过this显式调用自身的其他构造方法，则系统会默认先调用父类的无参构造方法。在这种情况下，写不写“super();”语句，效果是一样的。
如果子类的构造方法中通过super显式调用父类的有参构造方法，那将执行父类相应构造方法，而不执行父类无参构造方法。
如果子类的构造方法中通过this显式调用自身的其他构造方法，在相应构造方法中应用以上两条规则。
特别注意的是，如果存在多级继承关系，在创建一个子类对象时，以上规则会多次向更高一级父类应用，一直到执行顶级父类Object类的无参构造方法为止。

阅读代码，思考运行结果

class Car { 
    private int site = 4;  //座位数
    Car(){
        System.out.println ("载客量是"+site+"人);
    }
    public void setSite(int site){
        this.site = site;
    }
    void print(){
        System.out.print("载客量是"+site+"人");
    }
}

class Bus extends Car { 
    Bus(int site){
        setSite(site);
    }
}
public static void main(String[] args) { 
    Bus bus = new Bus(20);
    bus.print();
}

运行结果中会出现：载客量是4人和载客量是20人

方法重写

使用继承之后

image.png

调用父类的print()方法，不能显示Dog的strain信息和Peguin的sex信息

image.png
以上效果如何实现
**子类重写父类方法 ** @Override

方法重写需注意的问题

1.构造方法因为不能被继承，所以不能被重写；
方法重写的规则

方法名相同
参数列表相同
返回值类型相同或者是其子类；
访问权限不能严于父类

实质就是补充父类方法中缺少的子类中特有的信息

抽象类

Pet pet = new Pet ("贝贝",20,40);
pet.print();
实例化Pet没有意义

public abstract class Pet {     
}

以下代码的问题：

public abstract class Pet { 
       public void print() {
               //…
       }
}

每个子类的实现不同，抽象类中无法给出合理的print方法的实现
abstract也可用于方法——抽象方法

抽象方法没有方法体
抽象方法必须在抽象类里
抽象方法必须在子类中被实现，除非子类是抽象类

public abstract class Pet { 
       public abstract   void print() {
               //…
       }
}

修改Pet类为抽象类
修改Pet类的print()方法为抽象方法
输出Dog信息

image.png

final用法

Penguin类不希望再被其他类继承？
使用final类

public final class Penguin extends Pet { 
      //…
}

方法不希望被重写？
使用final方法

public final void print () { 
      //…
}

属性值不希望被修改？
使用常量

public class Penguin {
       final String  home ="南极";// 居住地
       public void setHome(String name){
       this.home=home; //错误，不可再赋值
    }
}

练习

汽车租赁公司出租多种车辆，车型和租金情况如下表所示。编写程序实现租赁价格的计算。

image.png

image.png
具体要求：车辆分为轿车和客车两大类，它们都继承自抽象类MotoVehicle，并实现其抽象方法calRent()。请根据下面给出的类图分别创建三个类，并在测试类TestRent中实现车辆的租赁。租赁过程如图所示。

image.png

MotoVehicle类

public abstract class MotoVehicle {
    private String no;//车牌号
    private String brand;//品牌

    abstract int calRent(int days);//计算租金

    public MotoVehicle()
    {

    }
    public MotoVehicle(String no, String brand)
    {
        this.no = no;
        this.brand = brand;
    }

    public String getNo() {
        return no;
    }

    public void setNo(String no) {
        this.no = no;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }
}

car

public class Car extends MotoVehicle{


    public Car(String no, String brand)
    {
        super(no,brand);

    }
    @Override
    int calRent(int days) {
        if(getBrand().equals("宝马"))
        {
            return 500 * days;
        }
        else
        {
            return 600 * days;
        }

    }
}

bus

public class Bus extends MotoVehicle {

    private int seatCount;

    public int getSeatCount() {
        return seatCount;
    }

    public void setSeatCount(int seatCount) {
        this.seatCount = seatCount;
    }

    public Bus(String no, String brand, int seatCount)
    {
        super(no,brand);
        this.seatCount = seatCount;
    }

    @Override
    int calRent(int days) {
        return 0;
    }
}

测试类

public class TestRent {

    public static void main(String[] args) {
        System.out.println("欢迎");
        System.out.println("请输入天数");
        Scanner scanner =  new Scanner(System.in);
        int days = scanner.nextInt();
        System.out.println("请输入汽车类型1.轿车，2.客车");
        int type = scanner.nextInt();
        if(type == 1)
        {
            System.out.println("输入品牌");
            String brand = scanner.next();

            Car car = new Car("辽N12345",brand);
            int money = car.calRent(days);
            System.out.println("租金为"+money);
        }
        else
        {
//            Bus bus = new Bus();
        }
    }
}

第十二章继承

为什么要使用继承

使用继承

方便理解的例子

子类访问父类成员super

不能被子类继承的父类成员

protected

访问修饰符小结

多重继承关系的初始化顺序

继承条件下构造方法的调用规则如下：

阅读代码，思考运行结果

方法重写

方法重写需注意的问题

抽象类

final用法

练习

MotoVehicle类

car

bus

测试类

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读