日常作业2019.1.21

作业（向上转型、向下转型）

宠物类　　父类

package com.job1_21;
/**
 *     宠物类
 * @author Administrator
 *
 */
public abstract class Pet {
    /**
     *     宠物属性
     */
    protected String name;
    protected String sex;
    protected int health;
    protected int love;
    
    /**
     *     构造方法
     */
    public Pet() {}
    public Pet(String name,String sex,int health,int love) {
        this.name =name;
        this.sex=sex;
        this.health=health;
        this.love=love;
    }
    
    
    /**
     *     宠物属性setter getter
     */
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    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 abstract void eat();
    /**
     *     玩
     */
    public abstract void play();
}

 

狗　　子类

package com.job1_21;
/**
 *     狗子
 * @author Administrator
 *
 */
public class Dog extends Pet {
    /**
     *     构造方法
     */
    public Dog() {}
    public Dog(String name,String sex,int health,int love) {
        super(name,sex,health,love);
    }
    
    /**
     *     吃
     */
    public void eat() {
        this.setHealth(this.getHealth()+3);
        System.out.println("健康值加3,，健康值："+this.getHealth());
    }

    /**
     *     玩
     */
    public void play() {
        System.out.println("狗子在接飞盘");

    }

}

 

企鹅　　子类

package com.job1_21;
/**
 *     企鹅
 * @author Administrator
 *
 */
public class Penguin extends Pet{
    /**
     *     构造方法
     */
    public Penguin() {}
    public Penguin(String name,String sex,int health,int love) {
        super(name,sex,health,love);
    }
    
    /**
     *     吃
     */
    public void eat() {
        this.setHealth(this.getHealth()+5);
        System.out.println("健康值加5,，健康值："+this.getHealth());
    }

    /**
     *     玩
     */
    public void play() {
        System.out.println("企鹅在南极游泳");

    }
}

 

主人类

package com.job1_21;
/**
 *     主人
 * @author Administrator
 *
 */
public class Host {
    /**
     *     主人带宠物玩
     * @param pet
     */
    public void playWith(Pet pet) {
        pet.play();
    }
    /**
     *     主人带宠物吃东西
     * @param pet
     */
    public void eatWith(Pet pet) {
        /**
         *     主人给宠物喂食 
         */
        if(pet.getHealth()<100) {
            if(pet instanceof Dog) {
                Dog dog=(Dog)pet;                    //向下转型
                dog.eat();
            }else if(pet instanceof Penguin) {        
                Penguin penguin=(Penguin)pet;        //向下转型
                penguin.eat();
            }
//            pet.eat();    父类不能使用子类独有的方法，如果创建了才可以父类点方法名
        }else {
            System.out.println("健康值大于100，不需要喂食");
        }
    }
}

 

测试类

package com.job1_21;
/**
 *     宠物测试类
 * @author Administrator
 *
 */
public class PetTest {
    public static void main(String[] args) {
        Pet dog=new Dog("嘎嘎","公的",59,60);            //创建狗子对象
        Pet penguin=new Penguin("扣扣","Q仔",92,50);    //创建企鹅对象
        Host host=new Host();                        //创建主人对象
        
        host.playWith(dog);                            //和狗玩
        host.playWith(penguin);                        //和企鹅玩
        host.eatWith(dog);                            //给狗喂食
        host.eatWith(penguin);                        //给企鹅喂食
    }
}

 

运行结果

 1、

 

2、

 笔记

多态三要素：继承、方法重写、父类引用指向子类对象

1、使用多态时：是使用父类的类型，但是对象还是子类对象。

2、如果子类不重写父类方法，那么当使用多态时，是不能调用子类独有的方法（谁的类型，调谁的方法）

3、但是当子类重写父类方法，使用多态调用的方法，看似是父类中的方法，但实际是子类中重写过父类的那个方法。

抽象类：表示这个类的对象是不存在的，因此抽象类不能被实例化对象，但是可以用它的类型来创建对象，通常是创建子类对象，也就是多态 因此不需要具体实现的方法，可以吧这个方法定义为抽想方法（抽象方法没有方法体） 抽象类中可以有非抽象方法和抽象方法，但是抽象方法只能存在于抽象类中

abstract 抽象方法 方法抽象后，类名也要抽象

1、有抽象方法的类一定是抽象类

2、抽象类不一定有抽象方法

3、抽象方法没有方法体

4、抽象类不能实例化

5、抽象类的子类可以使普通类，该普通类要实现抽象类中的抽象方法

6、抽象类的子类可以使抽象类，此时，父类中的抽象方法可以在子类中不被实现