Java接口

• 接口就是一种规则,是对行为的抽象

接口的定义和使用

• 接口用关键字interface来定义
  • public interface接口名{}
• 接口不能实例化
• 接口和类之间是实现关系,通过implements关键字表示
  • public class类名 implements 接口名{}
• 接口的子类(实现类)
  • 要么重写接口中的所有抽象方法
  • 要么是抽象类

注意1:接口和类的实现关系,可以单实现,也可以多实现。

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

注意2:实现类还可以在继承一个类的同时实现多个接口。

   public class类名 extends 父类<font style="color:#DF2A3F;"> implements </font>接口名1,接口名2{}

练习

编写带有接口和抽象类的标准javabean类

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 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 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 Test {
    public static void main(String[] args) {
        //创建对象
        Dog d = new Dog("小狗", 1);
        System.out.println(d.getName() + "," + d.getAge());

        d.eat();
        d.swim();
        System.out.println("-------------");

        Rabbit r = new Rabbit("小兔", 2);
        System.out.println(r.getName() + "," + r.getAge());
        r.eat();
        System.out.printf("--------------");

        Frog f = new Frog("小蛙", 3);
        System.out.println(f.getName() + "," + f.getAge());
        f.eat();
        f.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 interface Swim {
    public abstract void swim();
}

接口中成员的特点

• 成员变量
  • 只能是常量
  • ·默认修饰符:public static final
• 构造方法
  • 没有
• 成员方法
  • 只能是抽象方法
  • 默认修饰符:publicabstract
• JDK7以前:接口中只能定义抽象方法。
• 接口和类之间的关系
• 类和类的关系
  • 继承关系,只能单继承,不能多继承,但是可以多层继承
• 类和接口的关系
  • 实现关系,可以单实现,也可以多实现,还可以在继承一个类的同时实现多个接口（要重写里面的所有方法）
  • 
  • 重复重写的只需要重写一次
• 接口和接口的关系
  • 继承关系,可以单继承,也可以多继承
  • 如果是继承接口子类，则要全部重写
  • 
  • 

练习

编写带有接口和抽象类的标准javabean类

题目：我们现在有乒乓球运动员和篮球运动员,乒乓球教练和篮球教练。

为了出国交流,跟乒乓球相关的人员都需要学习英语。

请用所有知识分析,在这个案例中,哪些是具体类,哪些是抽象类,哪些是接口?

乒乓球运动员:姓名,年龄,学打乒乓球,说英语

篮球运动员:姓名,年龄,学打篮球

乒乓球教练:姓名,年龄,教打乒乓球,说英语

篮球教练:姓名,年龄,教打篮球

方法1：

方法2：

代码演示：

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

    public Sporter(String name, int age) {
        super(name, age);
    }
    public abstract void study();
}

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

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

    public abstract void teach();
}

public interface English {
    public abstract void speakEnglish();
}

import java.sql.SQLOutput;

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

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

    @Override
    public void teach() {
        System.out.println("教乒乓球");
    }

    @Override
    public void speakEnglish() {
        System.out.println("说英语");
    }
}

public class PingPangSporter extends Sporter implements English {
    public PingPangSporter() {
    }

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

    @Override
    public void speakEnglish() {
        System.out.println("说英语");
    }

    @Override
    public void study() {
        System.out.println("学乒乓球");
    }
}

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

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

    @Override
    public void teach() {
        System.out.println("教篮球");
    }
}

public class Test {
    public static void main(String[] args) {
        //创建运动员的对象
        PingPangCoach coach = new PingPangCoach("小王", 44);
        System.out.println(coach.getName() + "," + coach.getAge());
        coach.speakEnglish();
        coach.teach();
    }
}

JDK8以后接口中新增的方法

分为默认方法和静态方法

• 允许在接口中定义默认方法,需要使用关键字default修饰
  • 作用:解决接口升级的问题
• 接口中默认方法的定义格式:
  • 格式:public default 返回值类型 方法名 (参数列表) {}
  • 范例:public default void show(){}
• 接口中默认方法的注意事项:
  • 默认方法不是抽象方法,所以不强制被重写。但是如果被重写,重写的时候去掉default关键字

接口中静态方法的注意事项:

• 静态方法只能通过接口名调用,不能通过实现类名或者对象:名调用
• public可以省略,static不能省略
• 调用接口时，静态方法不用被调用

接口中私有方法的定义格式:

• 格式1:private返回值类型方法名(参数列表){}
• 范例1:private void show(){}
• 格式2:private static返回值类型 方法名(参数列表){}
• 范例2:private static void method(){}

接口的应用

1.接口代表规则,是行为的抽象。想要让哪个类拥有一个行为,就让这个类实现对应的接口就可以了。

2.当一个方法的参数是接口时,可以传递接口所有实现类的对象,这种方式称之为接口多态。

适配器使用方法

1.当一个接口中抽象方法过多,但是我只要使用其中一部分的时候,就可以适配器设计模式

2.书写步骤:

• 编写中间类XXXAdapter,实现对应的接口
• 对接口中的抽象方法进行空实现
• 让真正的实现类继承中间类,并重写需要用的方法
• 为了避免其他类创建适配器类的对象,中间的适配器类用abstract进行修饰