面向对象(14-2)：接口的练习

面向对象(14-2)：接口的练习

一、类与类，类与接口，接口与接口之间的关系

类与类：
      继承关系,只能进行单继承，不可以进行多继承，但是可以多层继承
      		案例：
            class A{}
            class B extends A{}
            class C extends C{}

类与接口：
        实现关系,可以是单实现，也可也一次实现多个接口;
        也可以在继承一个类的同时，实现多个接口
        
        案例1：一次实现多个接口
        interface Inter1{}
		interface Inter2{}
		class C implements Inter1, Inter2{}
		
		案例2：在继承一个类的同时，实现多个接口
		interface Inter1{}
		interface Inter2{}
		class C extends A implements Inter1, Inter2{}

接口与接口之：
        继承关系，可以单继承，也可以多继承（类不可以多继承）
        案例：
        interface Inter1{}
		interface Inter2{}
		interface Inter3 extends Inter1, Inter2{}

二、接口的练习

1、猫狗案例，加入额外的跳高功能

/*
        分析：
            猫：成员变量：姓名，年龄
               成员方法：吃饭，睡觉
               
            狗：成员变量：姓名，年龄
               成员方法：吃饭，睡觉
               
        由于猫和狗存在共性，所以我们提取出来相同的内容，放到一个抽象类中
            动物：
                姓名，年龄，吃饭，睡觉
            猫：继承自动物
            狗：继承自动物

        由于跳高是一个额外的功能，不是动物特有的，所以我们利用接口的方式定义

            接口：
                跳高
            部分的猫：实现接口
            部分的狗：实现接口
 */

//抽象类：动物类
abstract class Animal{
    //成员变量
    private String name;
    private int gae;
	//构造方法
    public Animal() {
    }

    public Animal(String name, int gae) {
        this.name = name;
        this.gae = gae;
    }
	//公共的setXxx()和getXxx()方法
    public String getName() {
        return name;
    }

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

    public int getGae() {
        return gae;
    }

    public void setGae(int gae) {
        this.gae = gae;
    }
    //抽象方法
    public abstract void eat();
    public abstract void sleep();
}

//定义一个具体的猫类，继承抽象类
class Cat extends Animal{
	//构造方法
    public Cat() {
    }

    public Cat(String name, int gae) {
        super(name, gae);
    }
	//重写抽象类中的抽象方法
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    public void sleep() {
        System.out.println("猫趴着睡");
    }
}
//定义一个具体的狗类，继承抽象类
class Dog extends Animal{
	//构造方法
    public Dog() {
    }

    public Dog(String name, int gae) {
        super(name, gae);
    }
	//重写抽象类中的抽象方法
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }

    @Override
    public void sleep() {
        System.out.println("狗侧着睡");
    }
}

//定义跳高的接口
interface Jump{
    public abstract void jump();
}

//定义具体会跳高的猫类，来实现接口
class JumpCat extends Cat3 implements Jump{
	//构造方法
    public JumpCat() {
    }
	
    public JumpCat(String name, int gae) {
        super(name, gae);
    }
	//重写接口中的方法
    @Override
    public void jump() {
        System.out.println("猫跳高");
    }
}

//定义具体会跳高的狗类，来实现接口
class JumpDog extends Dog3 implements Jump{
    public JumpDog() {
    }

    public JumpDog(String name, int gae) {
        super(name, gae);
    }
	//重写接口中的方法
    @Override
    public void jump() {
        System.out.println("狗跳高");
    }
}

public class InterfaceTest1 {
    public static void main(String[] args) {
        //创建不会跳高的狗
        Animal a1 = new Dog("小白",2);
        a1.show();
        a1.eat();
        a1.sleep();
        
        System.out.println("=====抽象类多态创建对象======");
        //抽象类多态创建一个会跳高的狗对象(多态创建对象，编译看左，运行看右)
        Dog d1 = new JumpDog("大黄",3);
        d1.show();
        d1.eat();
        d1.sleep();
        ((JumpDog) d1).jump();//需要向下转型
        
        System.out.println("=====接口多态创建创建对象======");
        //接口多态创建一个会跳高的狗对象
        Jump j1 = new JumpDog("小黑",4);
        ((JumpDog) j1).show();//需要向下转型
        ((JumpDog) j1).eat();//需要向下转型
        ((JumpDog) j1).sleep();//需要向下转型
        j1.jump();

执行结果如下：

名字：小白,年龄：2岁
狗吃肉
狗侧着睡
=====抽象类多态创建对象======
名字：大黄,年龄：3岁
狗吃肉
狗侧着睡
狗跳高
=====接口多态创建创建对象======
名字：小黑,年龄：4岁
狗吃肉
狗侧着睡
狗跳高

Process finished with exit code 0

2、老师和学生案例,加入抽烟的额外功能

/*
        分析：
            老师：姓名，年龄，吃饭，睡觉
            学生：姓名，年龄，吃饭，睡觉

            由于老师和学生有着共性内容，提取出来一个抽象类

            人：
                姓名，年龄，吃饭()，睡觉(){}

            由于抽烟不是所有的学生和老师都会的，只有部分老师和学生才会

            定义一个抽烟接口

            部分老师抽烟：实现抽烟接口
            部分学生抽烟：实现抽烟接口
 */
 
//抽烟接口
interface Smoking{
    //抽烟的抽象方法
    public abstract void smoke();
}

//定义抽象类---人
abstract class Person{
    private String name;
    private int age;

    public Person() {
    }

    public Person(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;
    }

    //定义抽象的吃饭方法
    public abstract void eat();

    //定义一个具体的睡觉方法
    public void sleep(){
        System.out.println("睡觉");
    }
}

class Teacher extends Person{

    public Teacher() {
    }

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

    @Override
    public void eat() {
        System.out.println("老师喝粥");
    }
}

class Student extends Person{

    public Student() {
    }

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

    @Override
    public void eat() {
        System.out.println("学生吃山珍海味");
    }
}

//定义部分抽烟老师类
class SomkeTeacher extends Teacher implements Smoking{

    public SomkeTeacher() {
    }

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

    @Override
    public void smoke() {
        System.out.println("老师抽烟");
    }
}

//定义部分抽烟学生类
class SmokeStudent extends Student implements Smoking{
    public SmokeStudent() {
    }

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

    @Override
    public void smoke() {
        System.out.println("学生抽烟");
    }
}


public class InterfaceTest2 {
    public static void main(String[] args) {
        //创建一个不抽烟的学生对象
        Person p = new Student("潘磊",15);
        p.eat();
        p.sleep();

        //创建一个抽烟的学生对象
        Student s = new SmokeStudent("刘生发",18);
        s.eat();
        ((SmokeStudent) s).smoke();
        s.sleep();

    }
}

执行结果如下：

学生吃山珍海味
睡觉
学生吃山珍海味
学生抽烟
睡觉

Process finished with exit code 0