10-接口

最新推荐文章于 2024-05-11 10:24:57 发布

静者，随心

最新推荐文章于 2024-05-11 10:24:57 发布

阅读量144

点赞数

分类专栏： Java基础文章标签： java 开发语言

本文链接：https://blog.csdn.net/yc_Cabbage/article/details/126174785

版权

Java基础专栏收录该内容

20 篇文章 1 订阅

订阅专栏

引言

面向对象思想的基础就是学会使用类去描述事物，类描述事物从属性和行为去描述，但是如果描述的事物完全不关注属性，全部是行为呢，这时就可以使用接口来描述。

一. 接口概念

1.1 接口是一类事物

从面向对象程序设计思想上看，Java中接口interface和类class 都是用来描述一类事物的工具。类关注事物的属性和行为两个方面，但是接口通常只关注事物的行为单方面。

1.2 接口是能力集合

从编程业务角度看，接口是一系列功能的集合，因为接口中通常只会声明方法，而这些方法，都是一个一个的功能，所以可以理解接口是能力的集合。

1.3 接口是一种规范

从代码设计角度看，接口是一种规范和准则，是一套严格的标准，系统各个模块通过接口连接，并**实现解耦，**软件设计中，接口通常作为设计体系结构的工具。

接口：把具有相同行为的事务，抽取出来，作为不同的实现。

二.接口语法

2.1 接口定义

接口中可以定义哪些如下 4个方面。不同jdk版本有区别 jdk8允许定义静态方法和默认方法。

jdk8以前的版本：只能定常量和公共方法；

[修饰词] interface 接口名{
    
    //① 定义静态常量
   
    //② 抽象方法
    
    //③ 静态方法 
    
    //④ 默认方法
    
}

2.2 接口定义示例

//定义接口
public interface Usb {

    //静态常量
    public static  final  String VERSION= "3.0";
    //抽象方法
    public abstract void transData();

    //静态方法
    public static void stop(){
        System.out.println("stop....");
    }
    //默认方法
    public default void flash(){
        System.out.println("flash。。。");
    }
}

2.3 接口与实现类

类和类上下级是继承关系，类和接口上下级是实现关系，类去实现接口。接口是比抽象类还抽象的事物，所以接口也不能实例化本身的实例，单独定义一个接口没有意义，接口必须用自己的实现类，才可以使用。

接口他就是一类事务行为的抽取（抽象），抽象类是一种事物的扩展

2.3.1 实现语法

class 实现类名 extends 父类名  implements 接口名1,接口名2,接口名N{
   // 1. 这类本身该有的东西
   // 2. 必须重写全部接口的抽象方法。 
}

实现类

// 定义一个类
public class UPan implements Usb {
    @Override
    public void transData() {
        System.out.println("U盘"+  Usb.VERSION + "协议传数据...");
    }
}

2.3.2 类和类关系

类是单继承的，一个类最多只能直接继承一个父类，但是可以多级继承。

2.3.3 类和接口的关系

类是多实现的，一个类可以实现多个接口，但是要重写全部的抽象方法。

三. 接口与抽象类的区别

3.1 相同点

都可以定义抽象方法
都不可以实例化本身实例
通常作为引用，实例化下级实例（使用多态的方式创建实例）

3.2 不同点

声明关键字不同接口 intercace class
定义内容不同（接口不可以定义实例属性构造器代码块）
抽象类中抽象方法需要显示声明。

体会：有时候接口抽象类甚至是普通类都可以完成设计，但是我们需要选择一个最好的方案。

四.接口多态

4.1 什么是接口多态

和类多态一样呀，声明接口实例化实现类对象。由于类是多实现，接口引用类型较多，通过不同的接口引用调用方法，只能调用到该接口中声明的方法。

public class TestUsb {

    public static void main(String[] args) {

        //多态
        Usb usb = new UPan();
        usb.transData();
        usb.save();//报错调用不了，Usb接口中没有这个方法

        System.out.println("------------------------");
        //多态
        Storage usb2 = new UPan();
        usb2.save();
        usb2.transData();//报错调用不了，Storage接口中没有这个方法
    }
}

4.2 接口向下转型

由于多态问题，导致接口引用无法调用实现类特有方法，可以向下转型，以便调用实现类特有方法

public class TestUsb {

    public static void main(String[] args) {

        //多态1
        Usb usb = new UPan();
        usb.transData();
        // usb.save();//报错调用不了，Usb接口中没有这个方法 , 通过向下转型来解决
        UPan xx =  (UPan) usb;
        xx.save(); //这里使用 xx 就可以调用特有方法。
         
    }
}

五.接口继承

5.1 什么是接口继承

和类一样呀，子接口通过继承获得父接口中的抽象方法，但是接口的继承是是多继承，一个接口可以同时继承多个父接口。

interface 子接口名 extends 父接口1,父接口2,父接口N{

}

如果这里有一个类实现这里的子接口，那么它必须重写全部接口中的抽象方法。

5.2 接口多继承示例

interface IA{
    void a();
}
interface IB{
    void b();
}

interface IC extends IB,IA {
    void c();
}

class X implements IC { // 你看这里重写了 3个抽象方法
    @Override
    public void a() {
        
    }
    @Override
    public void b() {

    }
    @Override
    public void c() {
    }
}

六.特殊的接口

6.1 常量接口

就是一个接口中全部都是静态常量呀,没有其他东西了。思想就是用一个接口来管理常用字面量。

//品牌接口
public interface Brand {
     String BRAND_AUDI="奥迪";
     String BRAND_BYD="比亚迪";
     String BRAND_BMW="宝马";
     String BRAND_MI="小米";
     String BRAND_ALI="阿里";
}

使用

class Shop {
    public static Car tell(String brand) {
        //根据品牌返回汽车
        if (brand.equals( Brand.BRAND_MI )) { //使用接口常量
            return new MICar("小米汽车", 1.5);
        } else if (brand.equals(Brand.BRAND_ALI )) { //使用接口常量
            return new AliCar("阿里汽车", 2.0);
        }else {
            return null;
        }
    }
}

public class Demo {
    public static void main(String[] args) {
            Car car =  Shop.tell( Brand.BRAND_MI); //使用接口常量
            car.info();
    }
}

6.2 标志接口

标志接口，用来标识一类事物是否满足什么能力。

//能飞的就是一个标志接口，实现过着接口的类都是能飞的事物
public interface CanFly {

}
public class AirPlane implements CanFly {
    
}

public class Bird implements CanFly {
    
}

public class Pig {
    
}
public class Person {
    public void  qi(Object bird  ){
        if( bird instanceof CanFly ){
            System.out.println("可以骑");
        }else{
            throw new RuntimeException("这个东西不可骑");
        }
    }
    public static void main(String[] args) {
        Person person = new Person();
        person.qi( new Pig() );
    }
}

七、接口回调

接口回调指的是，把接口设计为方法的参数，方法的参数是一个接口类。它出现的场景是，当我们想封装一个通用的方法，但是发现这个方法不能完全封装，有些步骤可以封装，但是有些步骤又存在差异不可封装，这是咱们可以把可以封装的逻辑依次编写，不可封装的部分，通过参数来执行方法解决。

//回调案例
public class CallBackDemo {

    public static void main(String[] args) {
        Person person = new Person();
        person.speak( new LSLife() );
    }
}
//抽取的一个接口，讲述一个人的经历，具体不详细
interface Life{
    public void tel();
}

class ZSLife implements Life{
    @Override
    public void tel() {
        System.out.println("生于1890");
        System.out.println("年少有为");
        System.out.println("毕业蓝翔技校");
        System.out.println("于2080....");
    }
}
class LSLife implements Life{
    @Override
    public void tel() {
        System.out.println("生于1891");
        System.out.println("年少有为个屁");
        System.out.println("毕业蓝翔技校");
        System.out.println("于2081....");
    }
}

class Person{
    //我们想封装的一个通用功能 ，有些流程是固定，但是有部分是不确定的。
    public void  speak( Life obj  ){
        System.out.println("各位亲朋好友大家好");
        //不可确定的
        obj.tel();
        System.out.println("谢谢各位，开席！");
    }
}