二、继承

2.1 继承的实现

将复制代码抽取到父类（基类）中，使用继承优化设计

//父类：提取共性的代码
public class Pet {
    private String name = "无名氏"; //昵称
    private int health = 100; //健康值，默认100，0~100之间，小于60为不健康
    private int love = 0; //亲密度
    private String strain = "聪明的拉布拉多犬"; //品种

    public void setHealth(int health){
        if(health<0 || health>100){
            System.out.println("宠物的健康值只能在0~100之间！");
            this.health = 60;
            return;
        }
        this.health = health;
    }

    public int getHealth(){
        return this.health;
    }


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

    public String getName(){
        return this.name;
    }

    public void setLove(int love){
        if(love<0 || love>100){
            System.out.println("宠物的亲密度只能在0~100之间！");
            this.love = 60;
            return;
        }
        this.love = love;
    }

    public int getLove(){
        return this.love;
    }



    /*
     * 输出宠物信息
     */
    public void print(){
        System.out.println("宠物的自白：\n我的名字叫" + this.name +
                "，健康值是" + this.health + "，和主人的亲密度是"
                + this.love);
    }
}

/*
* 宠物狗类
*/

public class Dog extends Pet{
    //1. 隐藏属性
    private String strain = "聪明的拉布拉多犬"; //品种

    //添加属性的setter/getter方法,并加入属性控制语句
    public void setStrain(String strain){
        this.strain = strain;
    }

    public String getStrain(){
        return this.strain;
    }
}

/*
* 宠物企鹅类
*/
public class Penguin extends Pet{
    private String sex = "Q仔";

    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getSex() {
        return this.sex;
    }

}

import java.util.Scanner;

public class TestPet {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("欢迎您来到宠物店！");
        System.out.print("请输入要领养宠物的名字：");
        String name = input.next();
        System.out.print("请输入要领养宠物的类型：1、狗狗；2、企鹅 ");
        int typeNo = input.nextInt();
        switch (typeNo){
            case 1:
                //创建狗狗对象
                Dog dog = new Dog();
                dog.setName(name);
                //狗狗其他属性
                dog.setHealth(-1000);
                System.out.println(dog.getHealth());

                dog.setLove(-9);

                dog.setStrain("吉娃娃");
                dog.print();
                break;
            case 2:
                //接受用户键盘录入信息
                System.out.print("请输入企鹅的性别：1、Q妹；2、Q仔  ");
                int SexId = input.nextInt();
                String sex = (SexId==1) ? "Q妹" : "Q仔";
                System.out.print("请输入企鹅的健康值：");
                int health = input.nextInt();
                System.out.print("请输入企鹅的亲密度：");
                int love = input.nextInt();

                //创建企鹅对象
                Penguin p = new Penguin();
                p.setName(name);
                p.setSex(sex);
                p.setHealth(health);
                p.setLove(love);
                p.print();
                break;

            default:
                System.out.println("暂时没有这个类型的宠物！");
                break;
        }
    }
}

2.1 修饰符对继承的影响

cn.com.oop1

Person.java:

package cn.com.oop1;

public class Person {
    //属性，成员变量，全局变量
    private int age;
    protected String name;
    char sex;
    public String address;
    String email;

}

Student.java：

package cn.com.oop1;

//类可以通过pubic来修饰
public class Student extends Person{
    public void m1(){
        //子类可以继承父类的protected修饰的成员，不管父子类是否在同一个包
        System.out.println(name);
        //子类无法继承父类的private成员
        //System.out.println(age);
        //子类可以继承父类的protected修饰的成员，不管父子类是否在同一个包
        System.out.println(address);
        //同包的子类可以继承父类的默认修饰符修饰的成员，不同包的子类无法继承父类的默认修饰符修饰的成员
        System.out.println(sex);
    }
}

cn.com.oop2

Teacher.java

package cn.com.oop2;
import cn.com.oop1.Person;


public class Teacher extends Person{
    public void m1(){
        //子类可以继承父类的protected修饰的成员，不管父子类是否在同一个包
        System.out.println(name);
        //子类无法继承父类的private成员
        //System.out.println(age);
        //子类可以继承父类的protected修饰的成员，不管父子类是否在同一个包
        System.out.println(address);
        //同包的子类可以继承父类的默认修饰符修饰的成员，不同包的子类无法继承父类的默认修饰符修饰的成员
        //System.out.println(sex);
    }
}