Day11_接口

一、接口

---

1.1接口引入

现实生活中的接口

生活中的接口是指某些企业和组织等制定的一种约定或标准。

接口就是一个合同，一个约定。实现接口，就是宣誓尊守这个约定。

接口的目的：便于类间的交流，合作。

例如

GB220v三相插头标准就是接口

川菜标准就是接口

驾照

"MP3"就是因为没有标准接口，所以五花八门

还可以把接口想象成"干爹"

java中的接口

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法（JDK 9）。

接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。

引用数据类型：数组，类，接口。

接口的使用，它不能创建对象，但是可以被实现（implements ，类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了。

可以继承一个类，但是可以声明实现了多个接口，接口是多重继承的替代品。

接口的特点

1、接口不能被实例化

2、接口用来被类实现

3、接口中可以定义属性和方法：

接口中的所有属性 默认的修饰符是 public static final，所以定义时必须赋值。

接口中的所有方法 默认的修饰符是 public abstract

4、接口没有构造方法

---

1.2接口的定义及使用

格式

public interface  接口名称 {
    //属性
    // 抽象方法
    // 默认方法
    // 静态方法
    // 私有方法
}

含有抽象方法

抽象方法：使用abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。

代码如下：

public interface InterFaceName {
    public abstract void method();
}

含有默认方法和静态方法

默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。

静态方法：使用 static 修饰，供接口直接调用。

代码如下：

public interface InterFaceName {
    public default void method() {
        // 执行语句
    }
    public static void method2() {
        // 执行语句    
    }
}

含有私有方法和私有静态方法

私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用。

代码如下：

public interface InterFaceName {
    private void method() {
        // 执行语句
    }
}

---

1.3接口实现

实现的概述

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements关键字。

非抽象子类实现接口：

必须重写接口中所有抽象方法。

实现格式：

class 类名 implements 接口名 {
    // 重写接口中抽象方法【必须】
    // 重写接口中默认方法【可选】
} 

接口中抽象方法的使用

必须全部实现，代码如下：

定义接口：

public interface LiveAble {
    // 定义抽象方法
    public abstract void eat();
    public abstract void sleep();
}

定义实现类：

public class Animal implements LiveAble {
    @Override
    public void eat() {
        System.out.println("吃东西");
    }
​
    @Override
    public void sleep() {
        System.out.println("晚上睡");
    }
}

定义测试类：

public class InterfaceDemo {
    public static void main(String[] args) {
        // 创建子类对象  
        Animal a = new Animal();
        // 调用实现后的方法
        a.eat();
        a.sleep();
    }
}
输出结果：
吃东西
晚上睡

---

2.1 接口的多实现

之前学过，在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。

实现格式：

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
    // 重写接口中抽象方法【必须】
} 

[ ]： 表示可选操作。

接口中抽象方法

接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。代码如下：

定义多个接口：

interface A {
    public abstract void showA();
    public abstract void show();
}
​
interface B {
    public abstract void showB();
    public abstract void show();
}

定义实现类：

public class C implements A,B{
    @Override
    public void showA() {
        System.out.println("showA");
    }
​
    @Override
    public void showB() {
        System.out.println("showB");
    }
​
    @Override
    public void show() {
        System.out.println("show");
    }
}

2.2 接口的多继承【了解】

一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用 extends 关键字，子接口继承父接口的方法。代码如下：

定义父接口：

interface A extends B{
    public void method();
}
​
interface B {
    public  void method1();
}

定义子接口：

class D implements A{
    @Override
    public void method() {
        System.out.println("DDDDDDDDDDDDDD");
    }
  
   @Override
    public void method1() {
        System.out.println("EEEEEEEEEEEEEEE");
    }
}

2.3接口练习

1、假设一个学校接待方面的程序，招待不同身份的人的食宿问题，其对应规则如下：

身份	食	宿
学生	食堂	宿舍
教师	教师食堂	学校公寓
学生家长	招待所	招待所

理论上，当然可以对每个不同身份的人各定义一个对应的类，并实现各自的方法，但是观察这些类，可以归纳出其有一个共同的模板，即“人”的“食、宿”问题。这时候，就可以发挥接口的功能了。

示例代码

interface Person{
    public void eat();
    public void sleep();    
}
​
class Student implements Person{
​
    public void eat() {
        System.out.println("在食堂吃饭");
    }
    public void sleep() {
        System.out.println("在宿舍睡觉");
    }
}
​
class Teacher implements Person{
    public void eat() {
        System.out.println("在教室食堂吃饭");
    }
    public void sleep() {
        System.out.println("在学校公寓睡觉");
    }
}
​
class Parent implements Person{
    public void eat() {
        System.out.println("在招待所吃饭");
    }
    public void sleep() {
        System.out.println("在招待所睡觉");
    }
}

2、需求说明：

电视、风扇、冰箱等各种电器要想工作必须提供电源，使用接口模拟电器获得电源后进行工作。

分析：

定义电源插座的接口(SocketInterface)，具有供电的能力。getElectric()

定义类：电视类(TV)、风扇类(Fan)、冰箱类(Icebox)，分别实现电源插座接口。

定义测试类，包含电器开始工作的方法，参数为电器对象（接口的引用指向实现类的对象，实现多态）。

示例代码

public class Demo02_接口练习2_电器工作 {
    public static void main(String[] args) {
        TV tv = new TV();
        work(tv);
        
        Icebox ib = new Icebox();
        work(ib);
        
        Fan fan = new Fan();
        work(fan);
    }
​
    public static void work(SocketInterface skt){
        skt.getElectric();
    }
}
​
interface SocketInterface{
    void getElectric();  // 通电方法
}
​
class TV implements SocketInterface{
    public void work(){
        System.out.println("播放节目");
    }
    public void getElectric() {
        System.out.println("电视通电后开始工作");
        work();
    }
}
​
class Icebox implements SocketInterface{
    public void work(){
        System.out.println("冻东西");
    }
    
    public void getElectric() {
        System.out.println("冰箱通电后开始工作");
        work();
    }
}
class Fan implements SocketInterface{
​
    public void work(){
        System.out.println("吹。。。。。");
    }
    
    public void getElectric() {
        System.out.println("风扇通电后开始工作");
        work();
    }
}

3、需求说明

某人是软件工程师，又是音乐家。如何在Java程序中实现？

定义人类作为抽象父类，包含人的基本属性和行为

定义编程接口，拥有编程能力

定义作曲接口，拥有作曲能力等

定义一个子类，继承人类，同时实现编程接口和作曲接口

示例代码

public class Demo03_实现多个接口 {
    public static void main(String[] args) {
        Musician m = new User();
        m.compose();
    }
}
​
abstract class People{
    public abstract void eat();
    public abstract void sleep();
}
​
interface Programmer{
    void programming();
}
​
interface Musician{  // 音乐家
    void compose();  // 作曲
}
class User extends People implements Programmer,Musician{
​
    @Override
    public void compose() {
        System.out.println("作曲....");
    }
​
    @Override
    public void programming() {
        System.out.println("编程....");
    }
​
    @Override
    public void eat() {
        System.out.println("吃饭....");
    }
​
    @Override
    public void sleep() {
        System.out.println("睡觉....");
    }
}

---

2.4总结

• 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的。

• 接口中的方法根据jdk版本的不同可以写不同的方法(参考第一节内容)，而抽象类可以有静态代码块和静态方法。

• 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

• 抽象类有构造方法，接口没有构造方法。

使用场景

抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。比如，男人，女人，这两个类（如果是类的话……），他们的抽象类是人。说明，他们都是人。人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它.

当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。