接口

概述

• 接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用
  Java中的接口更多的实现是对行为的抽象
   

定义和特点

• 接口用关键字interface修饰
• • public interface 接口名{}
• 类实现接口用implements表示
• • public class 类名 implements 接口名{}
• 接口不能实例化
• • 接口如何实例化？参照多态的方式，通过实现类对象实例化，这叫接口多态
    多态的形式：具有类多态，抽象类多态，接口多态
    多态的前提：有继承或者实现关系；有方法重写；有父（类/接口）引用指向（子/实现）类对象
• 接口的子类(实现类)
• • 要么重写接口中的所有抽象方法
• • 要么是抽象类

注意：

1. 接口和类的实现关系，可以单实现也可以多实现

• public class 类名 implements 接口名1,接口名2{}

2. 实现类还可以在继承一个类的同时实现多个接口

• public class 类名 extends 父类 implements 接口名1,接口名2{}

 

练习：编写带有接口和抽象类的标准Javabean类

青蛙frog	属性：姓名，年龄	行为：吃虫子，蛙泳
狗Dog	属性：姓名，年龄	行为：吃骨头，狗刨
兔子Rabbit	属性：姓名，年龄	行为：吃胡萝卜

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 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 interface Swim {
    public abstract void swim();
}

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

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

    @Override
    public void eat() {
        System.out.println("兔子在吃胡萝卜");
    }
}

public class Frog extends Animal implements Swim {
    public Frog() {
    }

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

    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子");
    }

    @Override
    public void swim() {
        System.out.println("青蛙在蛙泳");
    }
}

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

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

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

    @Override
    public void swim() {
        System.out.println("狗刨");
    }
}

public class Test {
    public static void main(String[] args) {
        Frog f = new Frog("朵朵", 1);
        System.out.println(f.getName() + "," + f.getAge());
        f.eat();
        f.swim();
    }
}

 

接口的成员特点

• 成员变量
• • 只能是常量
• • 默认修饰符：public static final
• 构造方法
• • 没有
• 成员方法
• • 只能是抽象方法
• • 默认修饰符：public abstract
• JDK7以前：接口中只能定义抽象方法
   

抽象类和接口的关系

• 类和类的关系
• • 继承关系：只能单继承，不能多继承，但可以多层继承
• 类和接口的关系
• • 实现关系：可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
• 接口和接口的关系
• • 继承关系：可以单继承，也可以多继承

public interface Inter1 {
    public abstract void method1();
}

public interface Inter2 {
    public abstract void method2();
}

public interface Inter3 extends Inter1, Inter2 {
    void method3();
}

public class InterImpl implements Inter3 {
    @Override
    public void method3() {

    }

    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }
}

 

练习：运动员和教练

需求：

• 我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。为了出国交流，跟乒乓球相关的人员都需要学习英语。请用所学知识分析，这个案例中有哪些具体类，哪些抽象类，哪些接口，并用代码实现

public 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 interface SpeakEnglish {
    void speak();
}

public abstract class Coach extends Person {
    public Coach() {
    }

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

    public abstract void teach();
}

public abstract class Player extends Person {
    public Player() {
    }

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

    public abstract void study();
}

篮球教练：

public class BasketballCoach extends Coach {
    public BasketballCoach() {
    }

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

    @Override
    public void teach() {
        System.out.println("篮球教练教如何运球和投篮");
    }

    @Override
    public void eat() {
        System.out.println("篮球教练吃羊肉，喝羊奶");
    }
}

乒乓球教练：

public class PingPangCoach extends Coach implements SpeakEnglish {
    public PingPangCoach() {
    }

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

    @Override
    public void teach() {
        System.out.println("乒乓球教练教如何发球和接球");
    }

    @Override
    public void eat() {
        System.out.println("乒乓球教练吃小白菜，喝大米粥");
    }

    @Override
    public void speak() {
        System.out.println("乒乓球教练说英语");
    }
}

篮球运动员：

public class BasketballPlayer extends Player {
    public BasketballPlayer() {
    }

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

    @Override
    public void study() {
        System.out.println("篮球运动员学习如何运气和投篮");
    }

    @Override
    public void eat() {
        System.out.println("篮球运动员吃牛肉，喝牛奶");
    }
}

乒乓球运动员：

public class PingPangPlayer extends Player implements SpeakEnglish{
    public PingPangPlayer() {
    }

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

    @Override
    public void study() {
        System.out.println("乒乓球运动员学习如何发球和接球");
    }

    @Override
    public void eat() {
        System.out.println("乒乓球运动员吃大白菜，喝小米粥");
    }

    @Override
    public void speak() {
        System.out.println("乒乓球运动员说英语");
    }
}

测试类：

public class PersonDemo {
    public static void main(String[] args) {
        PingPangPlayer ppp = new PingPangPlayer("小李", 20);
        System.out.println(ppp.getName() + "," + ppp.getAge());
        ppp.eat();
        ppp.study();
        ppp.speak();

        BasketballCoach bbc = new BasketballCoach("姚明", 35);
        System.out.println(bbc.getName() + "," + bbc.getAge());
        bbc.eat();
        bbc.teach();
    }
}

输出结果：

小李,20
乒乓球运动员吃大白菜，喝小米粥
乒乓球运动员学习如何发球和接球
乒乓球运动员说英语
姚明,35
篮球教练吃羊肉，喝羊奶
篮球教练教如何运球和投篮