2019.01.21多态

package pet;
//宠物类---父类
public abstract class Pet {
    private int heath;
    private String name;
    
    public Pet(int heath, String name) {
        super();
        this.heath = heath;
        this.name = name;
    }
    public int getHeath() {
        return heath;
    }
    public void setHeath(int heath) {
        if(heath<0) {
            System.out.println("健康值不能为负，默认为60");
            heath = 60;
        }
        this.heath = heath;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    //自白方法
    public void show() {
        System.out.println("宠物的姓名为："+this.getName()+",健康值为："+this.getHeath());
    }
    //抽象玩的方法
    public abstract void play();
    //抽象吃的方法
    public abstract void eat();
}

package pet;
//狗类---子类
public class Dog extends Pet{
    public Dog(int heath, String name) {
        super(heath,name);
    }
    //重写父类玩的方法
    public void play() {
        if(this.getHeath()>0) {
            System.out.println("狗狗叼飞碟");
            this.setHeath(this.getHeath()-10);
            System.out.println("叼玩飞碟后，"+this.getName()+"的健康值为："+this.getHeath());
        }else if(this.getHeath()<0) {
            System.out.println("体力耗光了，不能再玩了");
        }
    }
    //重写父类吃的方法
    public void eat() {
        if(this.getHeath()<100) {
            System.out.println("给狗狗吃根骨头");
            this.setHeath(this.getHeath()+3);
            System.out.println(this.getName()+"的健康值为："+this.getHeath());
        }else {
            System.out.println("狗狗吃饱了");
        }
    }
}

package pet;
//企鹅类---子类
public class Penguin extends Pet {
    public Penguin(int heath, String name) {
        super(heath, name);
    }
    //重写父类玩的方法
    public void play() {
        if(this.getHeath()>0) {
            System.out.println("让企鹅游泳");
            this.setHeath(this.getHeath()-15);
            System.out.println(this.getName()+"的健康值为"+this.getHeath());
        }else if(this.getHeath()<0) {
            System.out.println("体力耗光了，不能再玩了");
        }
    }
    //重写父类吃的方法
    public void eat() {
        if(this.getHeath()<100) {
            System.out.println("给企鹅吃条鱼");
            this.setHeath(this.getHeath()+5);
            System.out.println(this.getName()+"的健康值为："+this.getHeath());
        }else {
            System.out.println("企鹅吃饱了");
        }
    }
}

package pet;
//主人类
public class Master {
    public void play(Pet pet) {
        //判断给的宠物是否为狗类
        if(pet instanceof Dog) {
        //向下转型，将pet由原来的宠物类强转为狗类
            Dog d = (Dog)pet;
            d.eat();
            d.play();
        }else{
            Penguin p = (Penguin)pet;
            p.eat();
            p.play();
        }
    }
}

package pet;
//测试类
public class Test {
    public static void main(String[] args) {
        //父类类型引用子类对象
        Pet d = new Dog(70, "布拉多犬");
        d.show();
        Master ms1 = new Master();
        System.out.println("狗狗的健康值为："+d.getHeath());
        ms1.play(d);
        System.out.println("***********************************");
        Pet p = new Penguin(85,"Q妹");
        p.show();
        Master ms2 = new Master();
        System.out.println("企鹅的健康值为:"+p.getHeath());
        ms2.play(p);
    }        
}

 

1.重写和重载的区别？

2.八大基本数据类型
整型；byte short int long
浮点型: float double
字符char
布尔型 boolean
3.==和equals的区别？
== 通常做数值的相等关系比较
equals通常做引用型数据类型的相等比较、
.== 比较的是变量的地址
equals比较的是变量指向的值是否是相同的

4、什么是多态
同一个引用类型，使用不同的实例，得到不同的结果
5、实现多态的三个要素是什么
继承、方法重写、父类引用指向子类对象

1、使用多态时：是使用父类的类型，但是对象还是子类对象
2、如果子类不重写父类方法，那么当使用多态时，是不能调用子类独有的方法
(谁的类型，调谁的方法)
3、但是当子类重写父类方法，使用多态调用的方法，看似是父类中的方法，
但实际是子类中重写过父类的哪个方法

当：父类引用指向子类对象/父类类型创建子类对象时
这个对象不能够使用子类独有的方法

当使用多态时：创建对象必须是————父类类型 对象名 = new 子类构造方法

抽象类：表示这个类的对象是不存在的，因此抽象类不能够被实例化对象
但是可以用它的类型来创建对象，通常是创建子类对象，也就是多态

因此不需要具体实现的方法，可以把这个方法定义为抽象方法
（抽象方法没有方法体）

抽象类中可以有非抽象方法和抽象方法，但是抽象方法只能存在于抽象类中

实现多态的两种方式：使用父类作为方法参数、使用父类作为方法返回值