猫和狗类（继承、多态、抽象、接口）

目录

继承

多态

抽象

接口

---

继承

//需求：采用继承的思想实现猫和狗的案例

1.猫：
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set方法，抓老鼠

2.狗：
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set方法，看门

3.共性：
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set方法

具体代码：

猫类：

package Animal;

public class Cat extends Common{  //猫类

    public Cat() {
    }

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

    public void catchMouse(){
        System.out.println("今天抓了十个杰克！");
    }
}

狗类：

package Animal;

public class Dog extends Common {

    public Dog() {
    }

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

    public void lookDoor(){
        System.out.println("今天要想一百遍妮妮！！");
    }
}

共性类：

package Animal;

public class Common {
    private String name;   //成员变量
    private int age;

    public Common() {     //构造方法
    }

    public Common(String name, int age) {   //成员方法
        this.name = name;
        this.age = age;
        System.out.println("姓名："+name+"   年龄："+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 Animal;

public class Demo {
    public static void main(String[] args) {

        Dog d = new Dog("小虎", 5);
        d.lookDoor();

        Cat c = new Cat();
        c.setName("Tom");
        c.setAge(2);
        System.out.println(c.getName()+" "+c.getAge());
        c.catchMouse();
    }
}

运行结果：

多态

//说明：多态需以继承为前提条件，需要有重写操作，然后需要父类引用指向子类对象；

共性类：

package Animal;

public class Common {
    private String name;   //成员变量
    private int age;

    public void eat() {
        System.out.println("动物都会吃饭！！！");
    }


    public Common() {     //构造方法
    }

    public Common(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 Animal;

public class Cat extends Common{

    public Cat() {
    }

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

    public void catchMouse(){
        System.out.println("今天抓了十个杰克！");
    }

    @Override
    public void eat(){  //重写
        System.out.println("猫吃jarry");
    }
}

狗类：

package Animal;

public class Dog extends Common {

    public Dog() {
    }

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

    public void lookDoor(){
        System.out.println("今天要想一百遍妮妮！！");
    }

    @Override
    public void eat(){  //重写
        System.out.println("狗吃tom");
    }
}

测试类：

package Animal;

public class Demo {
    public static void main(String[] args) {

        //创建猫狗类并进行测试
        Common c1 = new Cat();
        c1.setName("Tom");
        c1.setAge(2);
        System.out.println(c1.getName()+","+c1.getAge());
        c1.eat();

        Cat c = (Cat) c1;   //完成猫的特有方法
        c.catchMouse();

        Common c2 = new Dog("黑嘴",3);
        System.out.println(c2.getName()+","+c2.getAge());
        c2.eat();

        Dog d = (Dog) c2;  //完成狗的特有方法
        d.lookDoor();

    }
}

测试结果：

抽象

//说明：用抽象类定义一个父类，他的子类要么也是抽象类，要么必须重写父类中的抽象方法；

共性类：

package ChouXiang;

public abstract class Animal {  //抽象类
    private int age;
    private String name;

    public abstract void eat();  //抽象方法

    public void sleep(){     //非抽象方法
        System.out.println("睡觉");
    }

    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;
    }
}

猫类：

package ChouXiang;

public class Cat extends Animal{

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

狗类：

package ChouXiang;

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

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

测试类：

package ChouXiang;

public class AnimalDemo {
    public static void main(String[] args) {

        Animal a = new Cat();
        a.setName("tommy");
        a.setAge(1);
        System.out.println(a.getName()+" "+a.getAge());
        a.eat();
        a.sleep();

        Animal b = new Dog(3,"花花");
        System.out.println(b.getName()+" "+b.getAge());
        b.eat();
        b.sleep();
    }
}

测试结果：

接口

//需求：对猫和狗进行训练，他们就可以调高了，在这里加入跳高功能。
采用抽象类和接口实现猫狗案例；

注意： 接口中不能定义构造方法也不能定义非抽象方法，接口中只能有抽象方法；

思路：

1. 定义接口： Jumpping
   成员方法：跳高

2. 定义动物抽象类：Animal
   成员变量：姓名，年龄；
   成员方法：get/set方法，吃饭；
   构造方法：无参，带参；

3. 定义具体的类：Cat，Dog；
   构造方法：无参、带参；
   成员方法：重写吃饭类，跳高类；

4. 定义测试类：AnimalDemo

接口：

package JieKouAnimal;

public interface Jumpping {

    public abstract void jump();
}

动物类：

package JieKouAnimal;

public abstract class Animal {

    private String name;
    private int age;

    //构造方法

    public Animal() {}

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

    //成员方法

    public abstract void eat();

    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 JieKouAnimal;

public class Cat extends Animal implements Jumpping {

    //重写父类方法
    @Override
    public void eat() {
        System.out.println("猫吃鱼啊");
    }

    @Override
    public void jump() {
        System.out.println("猫上窜下跳！");
    }

    //构造方法
    public Cat() {
    }

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

狗类：

package JieKouAnimal;

public class Dog extends Animal implements Jumpping{

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

    @Override
    public void jump(){
        System.out.println("狗左跳右跳！");
    }

    public Dog() {
    }

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

测试类：

package JieKouAnimal;

public class AnimalDemo {
    public static void main(String[] args) {

        //创建对象
        Animal mimi = new Cat("小咪",1);
        System.out.println(mimi.getName()+" "+mimi.getAge());
        mimi.eat();
        Jumpping j = new Cat();
        j.jump();

        System.out.println("------------------------");

        Dog d = new Dog();
        d.setAge(2);
        d.setName("小胡");
        d.eat();
        d.jump();
        System.out.println(d.getName()+" "+d.getAge());
    }
}

测试结果：