Java-接口

Neo丶

已于 2023-03-20 19:53:23 修改

阅读量278

点赞数 1

文章标签：学习

于 2022-07-26 22:59:42 首次发布

本文链接：https://blog.csdn.net/Ego_Ekko/article/details/126001889

版权

基本介绍

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

语法:

interface 接口名{

    //属性；
    //方法；（抽象方法可以不用abstract修饰）
}

class 类名 implements 接口名 {

    //本类的属性
    //本类的方法
    //必须实现的接口抽象方法
}

注意：1）在JDK7.0前接口里的所有方法都没有方法体（都是抽象方法）；

2）在JDK8.0后接口类可以有静态方法、默认方法，接口类中可以有具体方法的实现

（接口类中抽象方法可以省略abstract修饰符，默认方法需要用default修饰，

例如：（default public void say(){ }）；

3）某一类要实现接口类时，必须要重写实现接口类中的所有抽象方法。

package com.pero.interface_;

/**
 * 接口的介绍
 */

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

    }
}

interface AInterface{

    //写属性
    public static final String name = "USB"; 
    //接口中的属性只能是final的，而且是public static final修饰符。
    //例如：（int a = 1;实际上是 public static final int a = 1）必须初始化赋值

    //写方法
    //抽象方法可以省略abstract字符
    public void hi();

    //默认方法
    default public void say(){
        System.out.println("接口类中的默认方法say()用default修饰");
    }

    //静态方法
    public static void ok(){
        System.out.println("接口类中的静态方法ok()不需要用default修饰");
    }
}

class A implements AInterface{
    @Override
    public void hi() {
        System.out.println("A类实现接口中的hi()方法");
    }
}

应用场景

package com.pero.interface_;

/**
 * Interface应用场景
 * 项目管理时统一不同程序员编写的规则
 *
 * @version 1.3
 * @author Pero
 */

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

        MysqlDB mysqlDB = new MysqlDB(); //连接Mysql
        action(mysqlDB);

        OracleDB oracleDB = new OracleDB();  //链接Oracle
        action(oracleDB);
    }

    public static void action(DBInterface dbInterface){  //执行链接的方法
        dbInterface.connect();
        dbInterface.close();
    }
}

interface DBInterface{  //项目经理
    //定义规范的链接的方法
    public void connect();
    public void close();
}

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

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

class OracleDB implements DBInterface{  //B程序员写的Oracle的链接
    @Override
    public void connect() {
        System.out.println("链接Oracle");
    }

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

注意事项和细节

1）接口不能实例化；

public class A{

    public static void main(String[] args){
    
        //new B();  错误，接口不能实例化对象
    }
}

interface B{
    
    
}

2）接口中所有的方法是public方法，接口中抽象方法可以不用abstract修饰；

interface B{

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

3）一个普通类实现接口就必须将该接口的所有抽象方法都实现；（Alt+Enter）

interface B{

    void say();
    void see();
}

class C implements B{
    
    //接口的所有抽象方法都要实现
    public void say(){

    }
    public void see(){
    
    }
}

4）抽象类实现接口可以不用实现接口的方法；

interface B{

    void say();
}

abstract class D implement B{
    //抽象类可以不用实现接口中的抽象方法
}

5）一个类可以同时实现多个接口；

package com.pero.interface_;

/**
 * 一个类可以实现多个接口
 */


interface IB{
    void say();
}

interface IC{
    void see();
}

class Person implements IB,IC{

    @Override
    public void say() {
        System.out.println("实现IB接口中的say()方法");
    }

    @Override
    public void see() {
        System.out.println("实现IC接口中的see()方法");
    }
}

6）接口中的属性只能是final的，而且是public static final修饰符，例如：

（int a = 1;实际上是 public static final int a = 1）必须初始化赋值；

package com.pero.interface_;

/**
 * 一个类可以实现多个接口
 * 接口中的属性只能是final的，而且是public static final修饰符
 */

public class Interface04 {
    public static void main(String[] args) {
        //证明接口属性是static修饰的
        System.out.println(IB.n);
        //证明接口属性是final修饰的
        //IB.n = 10;  Cannot assign a value to final variable 'n'
    }
}
interface IB{
    int n = 10;  //等价于public static final int n = 1
    void say();
}

interface IC{
    void see();
}

class Person implements IB,IC{

    @Override
    public void say() {
        System.out.println("实现IB接口中的say()方法");
    }

    @Override
    public void see() {
        System.out.println("实现IC接口中的see()方法");
    }
}

7）接口中属性的访问形式：接口名.属性名；

8）一个接口不能继承其他类，但是可以继承多个其他的接口；

interface ID extends IB,IC{
    //接口可以继承多个接口，但是不能继承其他的类，也不能实现其他的接口
    //interface ID implements IB,IC{} 错误，接口不能实现其他的接口
}

9）接口的修饰符只能是 public 和默认，这一点和类的public和默认修饰符访问范围是一样的。

/*public或者是默认的访问修饰符*/interface IE { 
    
}

接口和继承的比较（接口实现机制是对Java单继承机制的一种补充）

继承：一个子类只能继承一个父类，先天具有父类的属性和方法，可以重写父类的方法；

接口：一个类可以实现多个接口，类可以直接或者通过生成对象的方式调用接口属性，但是类一定要实现接口的抽象方法。子类如果需要扩展功能，可以通过实现接口的方式。

package com.pero.interface_;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

/**
 * 继承和接口之间的对比
 *
 * @version 1.1
 * @author Pero
 */

public class ExtendsVsInterface {
    public static void main(String[] args) {
        LittleMonkey smith = new LittleMonkey("smith");

        //接口实现结果，需要主动学习才能实现
        smith.flying();
        smith.swimming();

        //继承实现的结果，天生就会就能实现
        smith.climbing();
    }
}
class Monkey{
    private String name;

    public Monkey(String name){
        super();  //父类为Object 类
        this.name = name;
    }

    public void climbing(){
        System.out.println("猴子会爬树");
    }
}

interface FishAble{ //鱼的本领是游泳
    void swimming();
}

interface BirdAble{  //鸟的本领是飞翔
    void flying();
}

//LittleMonkey类继承了Monkey类，
// 并且实现了接口FishAble和BirdAble中的抽象方法，
// 加强了子类的功能。
class LittleMonkey extends Monkey implements FishAble,BirdAble{
    public LittleMonkey(String name) {
        super(name);
    }

    @Override
    public void swimming() {
        System.out.println("小猴子学会游泳了");
    }

    @Override
    public void flying() {
        System.out.println("小猴子学会飞行了");
    }
}

小结：

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

继承是解决代码的复用性和可维护性；接口是设计方法规范，让其它类实现这些方法（更灵活）

★接口比继承更加灵活

继承是满足is - a的关系，而接口是满足like - a的关系

★接口在一定程度上实现代码的解耦【接口规范性+动态绑定机制】

接口的多态特性

1）多态参数（接口的引用可以指向实现了接口的类的对象）；

public class Interface01 {
    public static void main(String[] args) {
        //创建手机和相机对象
        Phone phone = new Phone();
        Camera camera = new Camera();

        //创建电脑对象
        Computer computer = new Computer();
        //电脑开始工作
        computer.work(phone);//手机接入电脑
        computer.work(camera);//相机接入电脑
    }
}

class Computer {

    //编写一个方法，计算机工作
    public void work(UsbInterface usbInterface){  //接口的多态参数特性，接口形参

        usbInterface.start();
        usbInterface.stop();
    }
}

interface UsbInterface {  //接口
    //规定接口的相关方法
    public void start(); //接口中规定的方法不能有方法体

    public void stop();
}

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

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

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

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

2）多态数组；

package com.pero.interface_;

/**
 * 接口的特性-多态数组
 *
 * @version 1.3
 * @author Pero
 */

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

        //接口类型的数组体现多态，可以将实现接口的类的对象实例存放到接口数组中
        Usb[] usb = new Usb[3];
        usb[0] = new MyPhone();
        usb[1] = new MyCamera();
        usb[2] = new MyPhone();

        for (int i = 0; i < usb.length; i++) {
            usb[i].work();  //动态绑定

            if(usb[i] instanceof MyPhone){  //判断运行类类型，并向下转型
                MyPhone myPhone = (MyPhone) usb[i];
                myPhone.call();
            }
        }
    }
}
interface Usb{
    void work();
}
class MyPhone implements Usb{

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

    public void call(){
        System.out.println("手机可以打电话");
    }
}
class MyCamera implements Usb{
    @Override
    public void work() {
        System.out.println("相机在工作中");
    }
}

3）接口存在多态传递现象。

package com.pero.interface_;

/**
 * 接口存在多态传递现象
 *
 * @version 1.4
 * @author Pero
 */

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

        //IG接口类型的变量（引用）可以指向实现接口的类的对象
        IG ig = new Teacher();
        //因为IG接口继承了IH接口，Teacher类实现了IG接口，那么实际上就相当于Teacher类也实现了IH接口
        //所以IH接口类型的变量（引用）也可以指向实现接口的类的对象
        //这就是所谓接口的多态传递现象
        IH ih = new Teacher();

    }
}

interface IH{
    void say();
}
interface IG extends IH{
    void see();
}
class Teacher implements IG{

    @Override
    public void say() {
        //由于IG接口继承了IH接口，Teacher类在实现IG接口抽象方法的同时，也要实现IH的抽象方法
    }

    @Override
    public void see() {
        //Teacher类实现IG接口，所以要实现IG的抽象方法
    }
}