面向对象(5）abstract 抽象与多态基础

object类是所有类的父类

object类中有几个方法
toString() 返回当前对象本身的有关信息，按字符串对象返回
equals()比较两个对象是否是同一个对象
比较两个对象是否是同一个对象，是则返回true
操作符==
简单数据类型，直接比较值。如1==2
引用类型，比较两者是否为同一对象

hashCode() 返回对象的哈希代码值
生成随机的哈希值

getClass()获取当前对象所属的类信息，返回Class对象

abstract关键字创建抽象类 例如 public abstract class 类名{}
abstract也可用于方法——抽象方法
抽象方法没有方法体
抽象方法必须在抽象类里
抽象方法必须在子类中被实现，除非子类是抽象类
public abstract 方法返回值 方法名()；
记住抽象方法不能有大括号也就是不能有方法体
子类可以重写父类的抽象方法。
例如定义个抽象宠物类
创建抽象方法跑 创建狗类 继承宠物类 重写抽象方法跑

首先宠物类：

public abstract class Pet {

    private String name;

    public abstract void run();


    public String getName() {
        return name;
    }

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

}

抽象方法后一定不能有方法体

狗类：

public class Dog extends Pet {

    @Override
    public void run() {
        System.out.println("狗正在跑");
    }
}

继承父类并重写方法
编写测试类：

public class TestPet {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.run();
    }
}

结果：狗正在跑

final关键字的作用在类中使用
public final class 类名{}
代表此类为最终类，不能被其他类继承
public final 方法返回值 方法名(){}
代表此方法不能被重写
final在属性变量中代表常量

多态：同一个引用类型，使用不同实例而执行不同操作
编写具有继承关系的父类和子类
子类重写父类方法
使用父类的引用指向子类的对象

例如给宠物喂食是需要一个主人类，正常的操作是
狗类一个吃的方法，企鹅类一个吃的方法，然后主人类中一个喂狗的方法 一个喂企鹅的方法
但是使用多态就可以省去主人的喂狗方法而是直接喂成宠物类，前提条件 企鹅和狗必须都属于宠物类

定义抽象宠物类：

public abstract class Pet {
    private String name;
    private int health;
    private int love;

    public  abstract void eat();
     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;
    }
}

其中sett和get方法可以忽略不计因为这里只显示多态的使用。

首先定义抽象方法吃

狗类

public class Dog extends Pet {

    private  String strain;

    public String getStrain() {
        return strain;
    }

    public void setStrain(String strain) {
        this.strain = strain;
    }

    @Override
    public void eat() {
        System.out.println("吃狗粮");
        super.setHealth(super.getHealth()+5);

    }

狗类继承父类宠物类并重写吃的方法

public class Penguin extends Pet {
    private String sex;

    public String getSex() {
        return sex;
    }

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


    @Override
    public void eat() {
        System.out.println("吃鱼");
        super.setHealth(super.getHealth()+6);
    }

企鹅继承父类宠物类并重写吃的方法

主人类

public class Master {
    public void feed(Pet pet){pet.eat();
    }

使用父类作为方法形参实现多态

方法体中引用父类的吃方法

测试类

public class TestMaster {
    public static void main(String[] args) {
        Pet dog=new Dog();
       Pet penguin=new Penguin();
        Master master=new Master();
        master.feed(dog);
        master.feed(penguin);

主人类中的喂食带参方法
参数为宠物类型的狗对象
就是狗吃的方法
为宠物类型的企鹅对象
就是企鹅吃的方法
结果：

第一种方法为使用父类作为方法形参实现多态
下面演示第二种方法
使用父类作为方法返回值实现多态

实现控制台输入领养宠物
输入编号领养

大体不变
宠物类：

public abstract class Pet {
    private String name;
    private int health;
    private int love;
    public abstract void print();

狗类

public class Dog extends Pet {

    private  String strain;

    public String getStrain() {
        return strain;
    }

    public void setStrain(String strain) {
        this.strain = strain;
    }
     @Override
    public void print() {
        System.out.println("这是一条狗");
    }

企鹅类

public class Penguin extends Pet {
    private String sex;

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
     @Override
    public void print() {
        System.out.println("这是一只企鹅");
    }

主人类：

public class Master {
 public Pet getPet(int typeid){
        Pet pet=null;
        if (typeid==1){
            pet=new Dog();
        }else if (typeid==2){
            pet=new Penguin();
        }
        return pet;
    }
}

这里直接以父类为返回值把控制台输入的编号作为参数传入方法， 然后判断如果输入为1 宠物对象为狗类型 则返回狗的print方法
输入2 宠物对象为企鹅类型返回企鹅的print方法

测试类：

public class TestMaster {
    public static void main(String[] args) {
        Pet dog=new Dog();
       Pet penguin=new Penguin();
        Master master=new Master();
         Scanner input=new Scanner(System.in);
        System.out.println("请选择宠物1.狗2.企鹅");
        int typeid=input.nextInt();
        Pet pet=master.getPet(typeid);
        pet.print();

结果：

instanceof运算符判断其左边对象是否为其右边类的实例
返回的值为boolean值
例如实现宠物玩耍 狗玩飞碟 企鹅游泳
这里也会用到强制转换
宠物类：

public abstract class Pet {
    private String name;
    private int health;
    private int love;

狗类：

ublic class Dog extends Pet {

    private  String strain;

    public String getStrain() {
        return strain;
    }

    public void setStrain(String strain) {
        this.strain = strain;
        
    }
     public void playplate(){
        System.out.println("狗狗在玩飞碟");
    }
}

企鹅类：

public class Penguin extends Pet {
    private String sex;

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
        public void swimming(){
        System.out.println("企鹅在游泳");
    }
    }
    

主人类：

public class Master {
public void play(Pet pet){
        if (pet instanceof Dog){
            Dog dog=(Dog) pet;
            dog.playplate();
        }else if (pet instanceof Penguin){
            Penguin penguin=(Penguin) pet;
            penguin.swimming();
        }
    }
}

利用instanceof运算符判断是否一致
如果不一致则要使用强制类型转换

测试类：

public class TestMaster {
    public static void main(String[] args) {
        Pet dog=new Dog();
       Pet penguin=new Penguin();
        Master master=new Master();
         master.play(dog);
        master.play(penguin);
        

结果：