猎人打猎(二)----利用继承

上一篇文章中虽然实现了猎人打猎这一行为，但是分析一下，猎人是人，枪是武器，猎物可以是很多种的动物，打猎也不可能仅仅就抓住一种猎物不放。所以在这里利用继承来实现

结构

分析

1. 在继承中，被继承类中属性修饰符不能再是private，应该改成 protected
2.  子类Tiger继承自父类Animal，Animal实现了方法 death()，以后只要是动物都可以继承父类并重写方法death()
3.  子类Hunter继承自父类People，但子类还有自己的方法shoot(Animal animal, Gun gun); 以后如果还有新的Animal子类，此方法同样可以使用

代码

Animal.java

package com.a.po;

public class Animal {
    protected String name ; //此时属性修饰符为protected，允许子类调用，当然同一包中的类可以调用(可以把猎人，武器，猎物分别放在不同包中，这样就可以保证外界不能直接访问这个属性)，声明一下不同包中子类同样可以调用
    protected String state ;

    public Animal() {} //无参构造

    /**
     * @param name
     * @param state
     * 构造方法
     */
    public Animal(String name, String state) {
        this.name = name;
        this.state = state;
    }

    public String getName() {
        return name;
    }

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

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * 动物都有的一个行为“死”，可以出现在父类中，被子类继承
     */
    public void death() {
        state = "死的";
    }
}

Tiger.java

package com.a.po;

public class Tiger extends Animal {
    public Tiger(String name, String state) {
        super(name, state);
    }

    /**
     * 猎物的一个行为
     */
    public void death() {
        state = "死的";
    }
}

Gun.java

package com.a.po;

public class Gun {
    /**
     * @param animal
     * @return animal 返回一个Animal类型的animal，即猎人打死的猎物
     */
    public Animal peng(Animal animal) {
        System.out.println("啊啊啊，打死了" + animal.getName());
        animal.death();
        return animal;
    }
}

People.java

package com.a.po;

public class People {
    protected String name;

    public People(String name) {
        super();
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

}

Hunter.java

package com.a.po;

public class Hunter extends People {
    private Animal animal;
    /**
     * @param name
     * 由于继承自父类，父类的构造方法需要重写，且第一行必须为super(...)之类的，子类如果有自己
     */
    public Hunter(String name) { 
        super(name);
    }

    public Animal getAnimal() {
        return animal;
    }

    public void setAnimal(Animal animal) {
        this.animal = animal;
    }

    public void shoot(Animal animal, Gun gun) {

        gun.peng(animal);
    }
}

Test.java

package com.a.test;

import com.a.po.Animal;
import com.a.po.Gun;
import com.a.po.Hunter;
import com.a.po.Tiger;

public class Test {

    public static void main(String[] args) {
        Hunter hunter = new Hunter("张三");
        Gun gun = new Gun();
        Tiger tiger = new Tiger("大老虎", "活的");
        System.out.println("猎人" + hunter.getName() + "开始打猎了！");
        System.out.println("猎人发现了" + tiger.getName());
        hunter.shoot(tiger, gun);
        System.out.println("老虎状态：" + tiger.getState());
    }
}

结果

猎人张三开始打猎了！
猎人发现了大老虎
啊啊啊，打死了大老虎
老虎状态：死的

总结：继承实现了程序的可重用新和可扩展性，而且代码看起类更明朗，灵活性强