继承练习2：猫和狗案例

思路

分别分析猫、狗的成员；
看能否抽取出共性；
能，则抽取出共性，定义到一个独立的类（动物类），即父类；
再重新定义猫、狗类。

code1

/*
    猫狗案例。
    方案一：setXxx()/getXxx()初始化对象
    分析：
    猫：
        成员变量：姓名，年龄，颜色
        构造方法：无参
        成员方法：
                setXxx()/getXxx()
                eat()
                playGame()

    狗：
        成员变量：姓名，年龄，颜色
        构造方法：无参
        成员方法：
                setXxx()/getXxx()
                eat()
                lookDoor()

    抽象出共性 ————> 类：动物
            动物：
                成员变量：姓名，年龄，颜色
                构造方法：无参
                成员方法：
                        setXxx()/getXxx()
                        eat()
            猫：
                构造方法：无参
                成员方法：
                        playGame()

            狗：
                构造方法：无参
                成员方法：
                        lookDoor()
*/
//动物类
class Animal{
    private String name;
    private int age;
    private String color;

    public Animal(){}

    public void setName(String name){
        this.name= name;
    }
    public void setAge(int age){
        this.age= age;
    }
    public void setColor(String color){
        this.color= color;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
    public String getColor(){
        return color;
    }

    public void eat(){
        System.out.println("吃饭");
    }
}
//猫类
class Cat extends Animal{
    public Cat(){}

    public void playGame(){
        System.out.println("猫玩游戏");
    }
}

//狗类
class Dog extends Animal{
    public Dog(){}
    public void lookDoor(){
        System.out.println("狗看门");
    }
}

//测试类
class CatDogTest{
    public static void main(String[] args){
        Cat c= new Cat();
        c.setName("叮当");
        c.setAge(1);
        c.setColor("White");
        System.out.println(c.getName()+"今年"+c.getAge()+",它是一只"+c.getColor()+"颜色的小猫。");
        c.eat();
        c.playGame();

        Dog d= new Dog();
        d.setName("酷酷");
        d.setAge(2);
        d.setColor("brown");
        System.out.println(d.getName()+"今年"+d.getAge()+",它是一只"+d.getColor()+"颜色的小狗。");
        d.eat();
        d.lookDoor();
    }
}

code2

/*
    猫狗案例。
    方案二：带参构造初始化对象+show()

    猫：
        成员变量：姓名，年龄，颜色
        构造方法：无参，3个参数
        成员方法：
                show()
                eat()
                playGame()

    狗：
        成员变量：姓名，年龄，颜色
        构造方法：无参，3个参数
        成员方法：
                show()
                eat()
                lookDoor()

    发现可以抽象出共性 ————> 类：动物
    动物：
        成员变量：姓名，年龄，颜色
        构造方法：无参，3个参数
        成员方法：
                show()
                eat()
    猫：
        构造方法：无参，3个参数
        成员方法：
                playGame()

    狗：
        构造方法：无参，3个参数
        成员方法：
                lookDoor()
*/
//动物类
class Animal{
    private String name;
    private int age;
    private String color;

    public Animal(){}
    public Animal(String name, int age, String color){
        this.name= name;
        this.age= age;
        this.color= color;
    }

    public void show(){
        System.out.println(name+"今年"+age+",它是一只"+color+"颜色的。");
    }

    public void eat(){
        System.out.println("吃饭");
    }
}
//猫类
class Cat extends Animal{

    //构造方法不能继承父类的
    public Cat(){}
    public Cat(String name, int age, String color){
        super(name, age, color);   //-----------------------NOTE
                   //用super(…)带参方法去显示的调用父类的带参构造方法。
                   // 子类中一定要有一个去访问了父类的构造方法，否则，父类的数据就没有初始化。
    }

    public void playGame(){
        System.out.println("猫玩游戏");
    }
}

//狗类
class Dog extends Animal{

    public Dog(){}
    public Dog(String name, int age, String color){
        super(name, age, color);
    }

    public void lookDoor(){
        System.out.println("狗看门");
    }
}

//测试类
class CatDogTest2{
    public static void main(String[] args){
        //创建猫对象测试
        Cat c= new Cat("叮当",1,"white");
        c.show();
        c.eat();
        c.playGame();

        //创建狗对象测试
        Dog d= new Dog("酷酷",2,"brown");
        d.show();
        d.eat();
        d.lookDoor();   
    }
}