1. 为什么有接口

在这里插入图片描述

2. 接口快速入门

UsbInterface

public interface UsbInterface {
    //规定接口的相关方法
    public void start();
    public void stop();
}

Camera

public class Camera implements UsbInterface{//实现接口,就是把接口方法实现

    @Override
    public void start() {
        System.out.println("相机开始工作...");
    }

    @Override
    public void stop() {
        System.out.println("相机停止工作....");
    }
}

Phone

//Phone 类 实现 UsbInterface
//解读:即 Phone类需要实现 UsbInterface接口 规定/声明的方法
public class Phone implements UsbInterface {

    @Override
    public void start() {
        System.out.println("手机开始工作...");
    }

    @Override
    public void stop() {
        System.out.println("手机停止工作.....");
    }
}

Computer

public class Computer {
    //编写一个方法, 计算机工作
    //解读:
    //1. UsbInterface usbInterface 形参是接口类型 UsbInterface
    //2. 接收 实现了 UsbInterface接口的类的对象实例
    public void work(UsbInterface usbInterface) {
        //通过接口，来调用方法
        usbInterface.start();
        usbInterface.stop();
    }
}

测试：

public class Interface01 {
    public static void main(String[] args) {
        //创建手机，相机对象
        
        //Camera 实现了 UsbInterface
        Camera camera = new Camera();
        
        //Phone 实现了 UsbInterface
        Phone phone = new Phone();
        
        //创建计算机
        Computer computer = new Computer();
        computer.work(phone);//把手机接入到计算机
        
        System.out.println("===============");
        computer.work(camera);//把相机接入到计算机

    }
}

在这里插入图片描述

3. 基本介绍

接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，在根据具体情况把这些方法写出来。
语法:

interface接口名 {
    //属性
    //方法 (1.抽象方法 2.默认方法 3.静态方法)
class 类名 implements 接口 {
    自己属性;
    自己方法;
    必须实现的接口的抽象方法
}

小结：

接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体。【JDK7.0】
接口体现了程序设计的多态和高内聚低偶合的设计思想。
特别说明：【JDK8.0】后接口类可以有静态【static】方法，默认【default】方法，也就是说接口中可以有方法的具体实现。
在接口中，抽象方法可以省略abstract关键字，有实现的方法必须加上【default】或【static】修饰符

AInterface

public interface AInterface {
    //写属性
    public int n1 = 10;
    //写方法
    //在接口中，抽象方法，可以省略abstract关键字
    public void hi();

    //在jdk8后，可以有默认实现方法,需要使用default关键字修饰
    default public void ok() {
        System.out.println("ok ...");
    }
    //在jdk8后, 可以有静态方法
    public static void cry() {
        System.out.println("cry ....");
    }
}

4. 深入讨论

对初学者讲，理解接口的概念不算太难，难的是不知道什么时候使用接口。下面举几个应用场景：

如：现在要制造战斗机，武装直升机，专家只需把飞机需要的功能/规格定下来即可，然后让别的人具体实现就可以了。
如：现在有一个项目经理，管理三个程序员，功能开发一个软件。为了控制和管理软件，项目经理可以定义一些接口，然后由程序员具体实现。(1.项目质量2.项目进度3.项目奖)参加工作。

在这里插入图片描述

案例演示

要求3个程序员，编写三个类，分别完成对Mysql,Oracle,DB2数据库的连接connect, close...

public interface DBInterface { //项目经理

    public void connect();//连接方法
    public void close();//关闭连接
    
}

//A程序
public class MysqlDB implements DBInterface {
    @Override
    public void connect() {
        System.out.println("连接mysql");
    }

    @Override
    public void close() {
        System.out.println("关闭mysql");
    }
}

//B程序员连接Oracle
public class OracleDB implements DBInterface{

    @Override
    public void connect() {
        System.out.println("连接oracle");
    }

    @Override
    public void close() {
        System.out.println("关闭oracle");
    }
}

测试

public class Interface03 {
    public static void main(String[] args) {
    
        MysqlDB mysqlDB = new MysqlDB();
        test(mysqlDB);
        
        OracleDB oracleDB = new OracleDB();
        test(oracleDB);
        
    }

    public static void test(DBInterface db) {
        db.connect();
        db.close();
    }
}

在这里插入图片描述

5. 注意事项和细节

1) 接口不能被实例化【因为接口本身就是希望别的类来实现它，然后再去创建实现接口类的一个实例】
2) 接口中所有的方法是public方法，接口中抽象方法可以不用abstract修饰

public abstract void say();
等价于    
void say();

3) 一个普通类实现接口,就必须将该接口的所有方法都实现。
4) 抽象类实现接口，可以不用实现接口的方法。

public class InterfaceDetail01 {
    public static void main(String[] args) {
        //1.接口不能被实例化
        //new IA();
    }
}

//2.接口中所有的方法是 public方法,  接口中抽象方法，可以不用 abstract 修饰
interface IA {
    void say();
    void hi();
}

//3.一个普通类实现接口,就必须将该接口的所有方法都实现,可以使用alt+enter
class Cat implements IA{
    @Override
    public void say() {

    }

    @Override
    public void hi() {

    }
}

//4.抽象类去实现接口时，可以不实现接口的抽象方法
abstract class Tiger implements  IA {

}

5) 一个类同时可以实现多个接口
6) 接口中的属性，只能是final，而且是 public static final修饰符。比如：

int a = 1
等价于
public static final int a = 1 【必须初始化】

7) 接口中属性的访问形式：接口名.属性名
8) 接口不能继承其它的类,但是可以继承多个别的接口。【接口与接口之间只能是继承关系】

interface A extends B, C()

9) 接口的修饰符只能是public和默认，这点和类的修饰符是一样的。如：

interface IE {}
或
public interface IE {}

案例演示说明

public class InterfaceDetail02 {
    public static void main(String[] args) {
        //接口中的属性,是 public static final
        System.out.println(IB.n1);//可以通过 类名.属性名 调用，说明 n1 就是static
        //IB.n1 = 30; 不能修改其初始值，说明 n1 是 final
    }
}

interface IB {
    //6.接口中的属性,只能是final的，而且是 public static final 修饰符
    int n1 = 10; //等价 public static final int n1 = 10;
    void hi();
}
interface IC {
    void say();
}
//8.接口不能继承其它的类,但是可以继承多个别的接口
interface ID extends IB,IC {
}
//9.接口的修饰符 只能是 public 和默认，这点和类的修饰符是一样的
interface IE{}

//5.一个类同时可以实现多个接口
class Pig implements IB,IC {
    @Override
    public void hi() {
    }
    @Override
    public void say() {
    }
}

6. 练习

interface A {
int a = 23;//等价public static final int a = 23;
}
class B implements A {//正确
}

public static void main(String[] args) {
    B b = new B();//ok
    System.out.println(b.a); //23
    System.out.println(A.a); //23
    System.out.println(B.a); //23
}

7. 实现接口 vs 继承类

接口实现是对单继承机制的一种补充

案例演示

public class ExtendsVsInterface {
    public static void main(String[] args) {
        LittleMonkey wuKong = new LittleMonkey("悟空");
        wuKong.climbing();
        wuKong.swimming();
        wuKong.flying();
    }
}

//猴子
class Monkey {
    private String name;

    public Monkey(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    
    public void climbing() {
        System.out.println(name + " 会爬树...");
    }
}

//接口
interface Fishable {
    void swimming();
}

interface Birdable {
    void flying();
}

//继承
//小结: 当子类继承了父类，就自动的拥有父类的功能
// 如果子类需要扩展功能，可以通过实现接口的方式扩展.
// 可以理解 实现接口 是 对java 单继承机制的一种补充.
class LittleMonkey extends Monkey implements Fishable,Birdable {

    public LittleMonkey(String name) {
        super(name);
    }

    @Override
    public void swimming() {
        System.out.println(getName() + " 通过学习，可以像鱼儿一样游泳...");
    }

    @Override
    public void flying() {
        System.out.println(getName() + " 通过学习，可以像鸟儿一样飞翔...");
    }
}

在这里插入图片描述

接口和继承解决的问题不同

继承的价值主要在于：解决代码的复用性和可维护性。
接口的价值主要在于：设计，设计好各种规范(方法)，让其它类去实现这些方法。即更加的灵活

接口比继承更加灵活

接口比继承更加灵活，继承是满足 is - a 的关系，而接口只需满足 like - a 的关系。
接口在一定程度上实现代码解耦【即:接口规范性+动态绑定机制】

8. 接口的多态特性

8.1 多态参数

在前面的Usb接口案例，Usblnterface usb，既可以接收手机对象，又可以接收相机对象，就体现了接口多态(接口引用可以指向实现了接口的类的对象)
案例演示：

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

        //接口的多态提现
        //接口类型的变量 if01 可以指向 实现了IF接口的类对象实例
        IF if01 = new Monster();
        if01 = new Car();

        //继承实现的多态
        //父类类型的变量 可以 指向 子类对象实例
        AAA a = new BBB();
        a = new CCC();
    }
}

interface  IF {}

class Monster implements IF{}

class Car implements IF {}

class AAA {}

class BBB extends AAA {}

class CCC extends BBB {}

8.2 多态数组

演示一个案例：给Usb数组中，存放 Phone 和 Camera 对象，Phone类还有一个特有的方法call()，请遍历Usb数组，如果是Phone对象，除了调用Usb接口定义的方法外，还需要调用Phone特有方法call();

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

        //多态数组 --> 接口类型数组
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone_();
        usbs[1] = new Camera_();
        for (int i = 0; i < usbs.length; i++) {
            usbs[i].work();//动态绑定
            //和前面一样，仍然需要进行类型的向下转型
            if (usbs[i] instanceof Phone_) {//判断它的运行类型是 Phone_
                ((Phone_) usbs[i]).call();
            }

        }
    }
}

interface Usb {
    void work();
}

class Phone_ implements Usb {
    public void call() {
        System.out.println("手机可以打电话");
    }

    @Override
    public void work() {
        System.out.println("手机工作中");
    }
}

class Camera_ implements Usb {
    @Override
    public void work() {
        System.out.println("相机工作中");
    }
}

在这里插入图片描述

8.3 接口存在多态传递现象

案例说明

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

        //接口类型的变量 可以指向 指向实现了该接口类的对象的实例
        IG ig = new Teacher();
        //如果IG了IH接口，而Teacher类实现了 IG 接口
        //实际上就相当于 Teacher 类也实现了 IH 接口
        //这就是所谓的 接口多态传递 现象
        IH ih = new Teacher();

    }
}

interface IH {
    void hi();
}

interface IG extends IH {}

class Teacher implements IG {
    @Override
    public void hi() {

    }
}

9. 练习

看看下列代码有哪些错误

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

    }
}

interface A {
    int x = 0; //等价 public static final int x = 0;
}  

class B {
    int x = 1;
} //普通属性

class C extends B implements A {
    public void pX() {
        //System.out.println(x); //错误，原因不明确x
        //可以明确的指定x
        //访问接口的 x 就使用 A.x
        //访问父类的 x 就使用 super.x
        System.out.println(A.x + " " + super.x);
    }

    public static void main(String[] args) {
        new C().pX();
    }
}

10. 类定义的进一步完善

在这里插入图片描述

【JavaSE】接口基本使用

1. 为什么有接口

2. 接口快速入门

3. 基本介绍

4. 深入讨论

5. 注意事项和细节

6. 练习

7. 实现接口 vs 继承类

8. 接口的多态特性

8.1 多态参数

8.2 多态数组

8.3 接口存在多态传递现象

9. 练习

10. 类定义的进一步完善

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【JavaSE】接口基本使用

1. 为什么有接口

2. 接口快速入门

3. 基本介绍

4. 深入讨论

5. 注意事项和细节

6. 练习

7. 实现接口 vs 继承类

8. 接口的多态特性

8.1 多态参数

8.2 多态数组

8.3 接口存在多态传递现象

9. 练习

10. 类定义的进一步完善

热门文章

最新文章

相关课程

相关电子书

相关实验场景