首页 > 基础资料博客日记

【Java 学习】接口的意义：程序世界的规则与多态性，学会接口、驭见多态是Java初学者的必经之路

2025-01-03 22:00:06基础资料围观349次

这篇文章介绍了【Java 学习】接口的意义：程序世界的规则与多态性，学会接口、驭见多态是Java初学者的必经之路，分享给大家做个参考，收藏Java资料网收获更多编程知识

💬 欢迎讨论：如对文章内容有疑问或见解，欢迎在评论区留言，我需要您的帮助！

👍 点赞、收藏与分享：如果这篇文章对您有所帮助，请不吝点赞、收藏或分享，谢谢您的支持！

🚀 传播技术之美：期待您将这篇文章推荐给更多对需要学习Java语言、低代码开发感兴趣的朋友，让我们共同学习、成长！

1. 什么是接口？

1.1 引入接口

在生活中，接口属于一个标准，如：手机的充电口，电脑的USB盘接口。一般情况下，所做的东西都要符合这个接口（标准）。

大家设置的产品都按着这个标准来做，设计出的产品都是 " 通用 " 的。

电脑的USB口上，可以插：U盘、鼠标、键盘…所有符合USB协议的设备

在Java中也规定的有标准，为了设置的方法符合标准，就需要实现接口。

1.2 接口的定义

在Java中，接口是一个用来定义方法的集合，但这些方法没有具体实现（即只有方法的声明，没有方法体）。接口可以看作是一种契约，规定了实现这个接口的类必须提供这些方法的具体实现。

定义接口的语法：

public interface 接口名 {
    // 抽象方法（没有方法体）
    void 方法名();
}

2. 接口的语法和使用

2.1 接口的语法

接口的定义格式与定义类的格式基本相同，将class关键字换成interface关键字，就定义了一个接口。

// interface 是定义接口垫的关键字
public interface 接口名称{
	double a = 3.0;  // 默认被：final public static修饰

 	// 抽象方法
	public abstract void method1();   // public abstract 是接口中函数的默认形式，可以不写
	
	public void method2();       // 相当于省略了 abstract, 隐士存在sbatract
	abstract void method3();     // 相当于省略了 public,  隐士存在public 
	void method4();              // 省略了 public abstract,  隐士存在public abstract
 }

提示:

创建接口时, 接口的命名一般以大写字母 I 开头.
接口的命名一般使用 “形容词” 词性的单词.
阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性.

2.2 使用接口

接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法

public  class 类名称 implements 接口名称{
 // ...
 }

注意：子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系。

示例：

在同一个包中，下面代码文件的结构：

Usb接口类：
声明两个方法。

public interface Usb {
    // 连接
    void connect();

    // 断开连接
    void disconnect();
}

Mouse类：
实现接口Usb

public class Mouse implements Usb{

    public void connect() {
        System.out.println("连接鼠标");
    }

    public void disconnect(){
        System.out.println("断开鼠标");
    }

}

Keyboard类：
实现接口Usb

public class Keyboard implements Usb{
    public void connect(){
        System.out.println("连接键盘");
    }

    public void disconnect(){
        System.out.println("断开键盘");
    }
}

Service 服务类（类似于电脑工作）：
public void useService(Usb usb) 函数模拟电脑的工作流程

public class Servise {

    // 打开电脑
    private void openService(){
        System.out.println("打开电脑");
    }

    // 关闭电脑
    private void closeService(){
        System.out.println("关闭电脑");
    }

    // 工作流程
    public void useService(Usb usb){  //向上转型
        openService();

        // 检查时什么硬件插入
        if( usb instanceof Keyboard){ // 键盘插入
            // 向下转型
             Keyboard k = (Keyboard) usb; // 转换成键盘对象
             k.connect();
             System.out.println("操作。。。。。。。。。。。。。。。。");
             k.disconnect();
        } else if( usb instanceof Mouse){ // 鼠标插入
            // 向下转型
            Mouse m = (Mouse) usb; // 转换成鼠标对象
            m.connect();
            System.out.println("操作。。。。。。。。。。。。。");
            m.disconnect();
        } else { // 不支持的硬件
            System.out.println("不支持该设备");
        }

        closeService();
    }
}

Main类，运行程序

public class Main {
    public static void main(String[] args){
        
        // 创建鼠标对象
        Mouse m = new Mouse();
        
        // 创建键盘对象
        Keyboard k = new Keyboard();

        // 创建电脑对象
        Servise s = new Servise();
        
        //  电脑接入键盘
        s.useService(m);
        System.out.println("========================");
        // 电脑接入鼠标
        s.useService(k);
    }
}

3. 接口的特性

3.1 特性

接口是一种引用数据类型：

接口是使用interface方法来修饰的
接口当中不能有被实现的方法，意味着只能有抽象方方，但是两个方法除外:一个是static修饰的方法一个是被 default 修饰的方法
接口当中的抽象方法默认都是public abstract 修饰的
接口当中的成员变量默认都是 public static final修饰
接口不能进行实例化
类和接口之间的关系，可以使用implements来进行关联
接口也是有对应的字节码文件的

3.2 举例

接口类型是一种引用类型，但是不能直接new接口的对象

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

        Usb usb = new Usb; // 会报错，因为接口不能被实例化
    }    
}

接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是
public abstract，其他修饰符都会报错)
```
public interface Usb {
    //  报错 此处不允许使用修饰符private
    private void openDevice();
    void closeDevice();
 }
```

接口中的方法是不能在接口中实现的，只能由实现接口的类来实现

public interface USB {
    void connect();
    
    // 编译失败：因为接口中的方式默认为抽象方法
    //  接口抽象方法不能带有主体
    void disconnect(){
        System.out.println("断开USB设备");
    }
 }

重写接口中方法时，不能使用默认的访问权限

public interface Usb {
    void connect();    // 默认是public abstract的
    void disconnect();   // 默认是public abstract的
}
public class Mouse implements Usb {

	// 默认的位default 
    void connect() {
        System.out.println("连接鼠标");
    }
    
    // ...
 }
 
// 编译报错，重写Usb中connect方法时，不能使用默认修饰符
// Mouse正在尝试分配更低的访问权限， 接口的为public

接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量

 public interface Usb {
    double brand = 3.0;  // 默认被：final public static修饰
    void connect();    // 默认是public abstract的
    void disconnect();   // 默认是public abstract的
 }
 
public class TestUsb {
    public static void main(String[] args) {
        System.out.println(USB.brand);   // 可以直接通过接口名访问，说明是静态的
        
        // 编译报错；无法为最终变量brand分配值
        USB.brand = 2.0;       // 说明brand具有final属性
    }
 }

接口中不能有静态代码块和构造方法

 public interface USB {
    // 编译失败
    public USB(){
 
    }
 
    {}    // 编译失败
    
    void connect();    // 默认是public abstract的
    void disconnect();   // 默认是public abstract的
 }

接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类

// 抽象方法
public abstract class MaxUsb implements Usb{
	// 不实现方法
    public abstract void connect();

    public abstract void disconnect();

}

接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
jdk8中：接口中还可以包含default方法。

4. 实现多个接口

背景：要求实现三个类：猫（名字，会跑）、鱼（名字，会游泳）、青蛙（名字，会跑、游泳）鸭子（名字，会跑，会游泳，会飞）。

思考：
先设计一个Animal抽象类，每个动物的方法是不同的，怎么设计呢？

Animal设置所有的方法，这是不行的，因为猫只能跑，不会游泳

Animal中只设置跑的方法，把动物特有的方法写在自己的类中，这样是不好的，因为没有了 “通用” 的功能。

每个功能可以单独写在一个抽象类中，但是，一个类继承一个Aniaml类后就不能再继承了。

在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。

只有接口能满足这个要求了

下面通过类来表示一组动物：

 class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
 }

另外我们再提供一组接口, 分别表示 “会飞的”, “会跑的”, “会游泳的”.

interface IFlying {
    void fly();
 }
 
interface IRunning {
    void run();
 }
 
interface ISwimming {
    void swim();
 }

接下来我们创建几个具体的动物：

猫，会跑

 class Cat extends Animal implements IRunning {
    public Cat(String name) {
        super(name);
    }
 
    public void run() {
        System.out.println(this.name + "正在用四条腿跑");
    }
 }

鱼，会游泳

class Fish extends Animal implements ISwimming {
    public Fish(String name) {
        super(name);
    }
 

    public void swim() {
        System.out.println(this.name + "正在用尾巴游泳");
    }
 }

青蛙，能跑、能游泳

class Frog extends Animal implements IRunning, ISwimming {
    public Frog(String name) {
        super(name);
    }
 

    public void run() {
        System.out.println(this.name + "正在往前跳");
    }
 

    public void swim() {
        System.out.println(this.name + "正在蹬腿游泳");
    }
 }

注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。

提示：IDEA 中使用 ctrl + i 快速实现接口

还有一种神奇的动物, 水陆空三栖, 叫做 “鸭子”

class Duck extends Animal implements IRunning, ISwimming, IFlying {
    public Duck(String name) {
        super(name);
    }
 

    public void fly() {
        System.out.println(this.name + "正在用翅膀飞");
 
    }
 
    public void run() {
        System.out.println(this.name + "正在用两条腿跑");

    public void swim() {
        System.out.println(this.name + "正在漂在水上");
    }
 }

上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口。

继承表达的含义是 is - a 语义, 而接口表达的含义是具有 xxx 特性。

猫是一种动物, 具有会跑的特性.
青蛙也是一种动物, 既能跑, 也能游泳
鸭子也是一种动物, 既能跑, 也能游, 还能飞

这样设计有什么好处呢? 时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型,而只关注某个类是否具备某种能力.

例如, 现在实现一个方法, 叫 “散步”

 public static void walk(IRunning running) {
    System.out.println("我带着伙伴去散步");
    running.run();
 }

在这个 walk 方法内部, 我们并不关注到底是哪种动物, 只要参数是会跑的, 就行

public class Main {

    public static void walk(IRunning running) {
        System.out.println("我带着伙伴去散步");
        running.run();
    }

    public static void seeSwim(ISwimming swimming) {
        System.out.println("我看着伙伴去游泳");
        swmming.swimming();
    }

    public static void main(String[] args){
            Cat cat = new Cat("小猫");
            walk(cat);

//            // 如果我们这样写
//            seeSwim(cat);
//            // seeSwim()括号中的引用会有红线，表示ISwimming没有被Cat实现



            Frog frog = new Frog("小青蛙");
            walk(frog);

    }
}

// 执行结果
我带着伙伴去散步
小猫正在用四条腿跑
我带着伙伴去散步
小青蛙正在往前跳

5. 接口间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。

接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字

可以让IAmphibious继承IRunning和ISwimming，这样，IAmphibious表示两栖动物，而且还可以使用public static void walk(IRunning running)函数。

interface IRunning {
    void run();
 }
 
interface ISwimming {
    void swim();
 }
 
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
 
}
 
class Frog implements IAmphibious {
    ...
 }

通过接口继承创建一个新的接口 IAmphibious 表示 “两栖的”. 此时实现接口创建的 Frog 类, 就继续要实现 run 方法, 也需要实现 swim 方法.

还可以使用public static void walk(IRunning running)函数，保证代码的 “通用性”。

接口间的继承相当于把多个接口合并在一起.

文章来源:https://blog.csdn.net/2302_79527141/article/details/144722714
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系邮箱：jacktools123@163.com进行投诉反馈，一经查实，立即删除！

标签：

上一篇：Redis 爆高危漏洞，请速度修复。。
下一篇：JDK各版本下载地址

首页 > 基础资料博客日记

【Java 学习】接口的意义：程序世界的规则与多态性，学会接口、驭见多态是Java初学者的必经之路

1. 什么是接口？

1.1 引入接口

1.2 接口的定义

2. 接口的语法和使用

2.1 接口的语法

2.2 使用接口

3. 接口的特性

3.1 特性

3.2 举例

4. 实现多个接口

5. 接口间的继承

相关文章

最新发布

点击排行

本站推荐

标签云

首页 > 基础资料 博客日记

【Java 学习】接口的意义：程序世界的规则与多态性，学会接口、驭见多态是Java初学者的必经之路

1. 什么是接口？

1.1 引入接口

1.2 接口的定义

2. 接口的语法和使用

2.1 接口的语法

2.2 使用接口

3. 接口的特性

3.1 特性

3.2 举例

4. 实现多个接口

5. 接口间的继承

相关文章

最新发布

点击排行

本站推荐

标签云

首页 > 基础资料博客日记