分别使用继承、多态、抽象类和接口方式实现动物类需求

继承

实现

package jicheng;

public class Animal {
    private String name;
    private int age;

    public Animal() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package jicheng;

public class Cat extends Animal {

    public Cat() {
    }

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

    public void catchMouse() {
        System.out.println("猫抓老鼠");
    }
}

package jicheng;

public class Dog extends Animal {

    public Dog() {
    }

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

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

package com.itheima_11;

/*
    测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //创建猫类对象并进行测试
        Cat c1 = new Cat();
        c1.setName("加菲猫");
        c1.setAge(5);
        System.out.println(c1.getName() + "," + c1.getAge());
        c1.catchMouse();

        Cat c2 = new Cat("加菲猫", 5);
        System.out.println(c2.getName() + "," + c2.getAge());
        c2.catchMouse();
    }
}

解决了啥？

使用继承可以有效实现代码复用，避免重复代码的出现。例如get、set方法就是大家通用的。

多态

实现

package duotai03;

public class Animal {
    private int age;
    private String name;

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void eat(){
        System.out.println("动物吃东西");
    }
}

package duotai03;

public class Cat extends Animal{
    public Cat() {
    }

    public Cat(int age, String name) {
        super(age, name);
    }
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

package duotai03;

public class Dog extends Animal{
    public Dog() {
    }

    public Dog(int age, String name) {
        super(age, name);
    }
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

package duotai03;

public class AnimalDemo {
    public static void main(String[] args) {
        //无参构造方法
        Animal a = new Cat();
        a.setAge(10);
        a.setName("英短");
        a.eat();
        System.out.println(a.getAge()+a.getName());
        //使用带参构造方法
        a = new Cat(10,"加菲");
        a.eat();
        System.out.println(a.getAge()+a.getName());
    }
}

解决了啥？

可以增强程序的可扩展性及可维护性，使代码更加简洁。

存在的问题

父类本身可能是一个具体事务，例如动物类。所以上面的多态的实现是有问题的。下面使用抽象方式实现。

抽象

实现

package chouxiang02;

public abstract class Animal {
    private int age;
    private String name;

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //提供抽象方法
    public abstract void eat();
}

package chouxiang02;

public class Cat extends Animal {
    public Cat() {
    }

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

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

package chouxiang02;

public class Dog extends Animal{
    public Dog() {
    }

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

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

package chouxiang02;

public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.setAge(6);
        a.setName("测试猫");
        System.out.println(a.getAge()+a.getName());
        a.eat();
        System.out.println("------------");

        a = new Cat(10,"英短");
        System.out.println(a.getAge()+a.getName());
        a.eat();
    }
}

解决了啥？

父类本身可能是一个具体事务，例如动物类。抽象类的实现解决了这个 问题。

接口

实现

package interface02;

public interface Jumpping {
    public abstract void jump();
}

package interface02;

public abstract class Animal{
    private int age;
    private String name;

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public abstract void eat();
}

package interface02;

public class Cat extends Animal implements Jumpping{
    public Cat() {
    }

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

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}

package interface02;

public class AnimalDemo {
    public static void main(String[] args) {
        Jumpping j = new Cat();
        j.jump();
        System.out.println("---------");

        Animal a = new Cat();
        a.setAge(10);
        a.setName("英短");
        System.out.println(a.getAge()+a.getName());
        a.eat();
        //向下转型，把一个父类对象转为子类对象
        ((Cat)a).jump();//由于Animal中没有jump，所以要强转

        a = new Cat(10,"加菲");
        System.out.println(a.getAge()+a.getName());
        a.eat();
        System.out.println("---------");

        //一般使用这个方式
        Cat c = new Cat();
        c.setAge(10);
        c.setName("英短");
        c.jump();
        c.eat();
    }
}

解决了啥？

接口的出现可以很方便的实现程序的拓展。