JAVA基础（10）面向对象编程5——接口

最新推荐文章于 2024-08-16 23:08:28 发布
最新推荐文章于 2024-08-16 23:08:28 发布
阅读量939 收藏 13
点赞数 31
分类专栏： JAVA基础 文章标签： java 开发语言 java-ee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Theodore_1022/article/details/140513799
版权

 

目录

 一、接口(interface)

1.概念

2.格式

3.说明

4.接口的使用

（1）类实现接口（implements）

①定义

②格式

③注意

④举例

（2）接口的多实现（implements）

①定义

②格式

③注意

④举例

（3）接口的多继承(extends)

①定义

②注意

③举例

（4）接口与实现类对象构成多态引用

①定义

②举例

（5）使用接口的静态成员

①定义

②举例

（6）使用接口的非静态方法

 5.JDK8中相关冲突问题

（1）默认方法冲突问题

①类优先原则

②接口冲突（左右为难）

（2）常量冲突问题

总结

一、接口(interface)

1.概念

  • 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要...则必须能...”的思想。继承是一个"是不是"的is-a关系，而接口实现则是 "能不能"的has-a关系。
  • 接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型（数组，类，枚举，接口，注解 ）。

2.格式

[修饰符] interface 接口名{
    //接口的成员列表：
    // 公共的静态常量
    // 公共的抽象方法
    
    // 公共的默认方法（JDK1.8以上）
    // 公共的静态方法（JDK1.8以上）
    // 私有方法（JDK1.9以上）
}

package com.atguigu.interfacetype;

public interface USB3{
    //静态常量
    long MAX_SPEED = 500*1024*1024;//500MB/s

    //抽象方法
    void in();
    void out();

    //默认方法
    default void start(){
        System.out.println("开始");
    }
    default void stop(){
        System.out.println("结束");
    }

    //静态方法
    static void show(){
        System.out.println("USB 3.0可以同步全速地进行读写操作");
    }
}

3.说明

在JDK8.0 之前，接口中只允许出现：

（1）公共的静态的常量：其中public static final可以省略

（2）公共的抽象的方法：其中public abstract可以省略

理解：接口是从多个相似类中抽象出来的规范，不需要提供具体实现

在JDK8.0 时，接口中允许声明默认方法和静态方法：

（3）公共的默认的方法：其中public 可以省略，建议保留，但是default不能省略

（4）公共的静态的方法：其中public 可以省略，建议保留，但是static不能省略

在JDK9.0 时，接口又增加了：

（5）私有方法

除此之外，接口中没有构造器，没有初始化块，因为接口中没有成员变量需要动态初始化。

4.接口的使用

（1）类实现接口（implements）

①定义

        接口不能创建对象，但是可以被类实现（implements ，类似于被继承）。

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

②格式

【修饰符】 class 实现类  implements 接口{
    // 重写接口中抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
      // 重写接口中默认方法【可选】
}

【修饰符】 class 实现类 extends 父类 implements 接口{
    // 重写接口中抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
      // 重写接口中默认方法【可选】
}

③注意

  • 如果接口的实现类是非抽象类，那么必须重写接口中所有抽象方法。

  • 默认方法可以选择保留，也可以重写。

    重写时，default单词就不要再写了，它只用于在接口中表示默认方法，到类中就没有默认方法的概念了

  • 接口中的静态方法不能被继承也不能被重写

④举例
interface Appliance {
    public void turnOn();
    public void turnOff();
}

class Home {
    public static void operate(Appliance appliance) {
        appliance.turnOn();
        System.out.println("=========== 家用电器正在工作 ========");
        appliance.turnOff();
    }
}

class Light implements Appliance {
    public void turnOn() { // 重写方法
        System.out.println("灯光打开。");
    }
    public void turnOff() { // 重写方法
        System.out.println("灯光关闭。");
    }
}

class Fan implements Appliance {
    public void turnOn() { // 重写方法
        System.out.println("风扇打开。");
    }
    public void turnOff() { // 重写方法
        System.out.println("风扇关闭。");
    }
}

public class ApplianceDemo {
    public static void main(String args[]) {
        Home.operate(new Light());
        Home.operate(new Fan());

        Home.operate(new Appliance() {
            public void turnOn() {
                System.out.println("空调打开。");
            }
            public void turnOff() {
                System.out.println("空调关闭。");
            }
        });
    }
}

（2）接口的多实现（implements）

①定义

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

②格式

【修饰符】 class 实现类  implements 接口1，接口2，接口3。。。{
    // 重写接口中所有抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
      // 重写接口中默认方法【可选】
}

【修饰符】 class 实现类 extends 父类 implements 接口1，接口2，接口3。。。{
    // 重写接口中所有抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
      // 重写接口中默认方法【可选】
}

③注意

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

④举例
package com.myexample.devices;

public interface Screen {
    void display();
}

package com.myexample.devices;

public interface Speaker {
    void playSound();
}

package com.myexample.devices;

public class SmartDevice implements Screen, Speaker {
    @Override
    public void display() {
        System.out.println("屏幕显示内容");
    }

    @Override
    public void playSound() {
        System.out.println("通过扬声器播放声音");
    }
}

package com.myexample.devices;

public class TestDevice {
    public static void main(String[] args) {
        SmartDevice device = new SmartDevice();
        device.display();
        device.playSound();
    }
}

（3）接口的多继承(extends)

①定义

        一个接口能继承另一个或者多个接口，接口的继承也使用 extends 关键字，子接口继承父接口的方法。

②注意

        所有父接口的抽象方法都有重写。

        方法签名相同的抽象方法只需要实现一次。

③举例
package com.myexample.interfacetype;

// 父接口：定义基本连接方法
public interface Connectable {
    void connect();
    void disconnect();
    void status();
}

// 子接口：继承父接口并增加新方法
public interface Bluetooth extends Connectable {
    void pair();
}

// 无线接口：定义无线传输方法
public interface Wireless {
    void transmit();
    void receive();
}

// 实现类：实现子接口并重写所有方法
public class BluetoothSpeaker implements Bluetooth, Wireless {
    @Override
    public void pair() {
        System.out.println("设备配对成功");
    }

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

    @Override
    public void disconnect() {
        System.out.println("设备已断开连接");
    }

    @Override
    public void status() {
        System.out.println("设备状态正常");
    }

    @Override
    public void transmit() {
        System.out.println("传输数据中...");
    }

    @Override
    public void receive() {
        System.out.println("接收数据中...");
    }
}

// 测试类：测试实现类的所有方法
public class TestBluetoothSpeaker {
    public static void main(String[] args) {
        BluetoothSpeaker speaker = new BluetoothSpeaker();
        speaker.pair();         // 测试设备配对
        speaker.connect();      // 测试设备连接
        speaker.transmit();     // 测试数据传输
        speaker.receive();      // 测试数据接收
        speaker.status();       // 测试设备状态
        speaker.disconnect();   // 测试设备断开
    }
}

（4）接口与实现类对象构成多态引用

①定义

        实现类实现接口，类似于子类继承父类，因此，接口类型的变量与实现类的对象之间，也可以构成多态引用。通过接口类型的变量调用方法，最终执行的是你new的实现类对象实现的方法体。

②举例
package com.myexample.interfacetype;

// 定义USB3接口
public interface USB3 {
    void start();
    void stop();
    void in();
    void out();
}

package com.myexample.interfacetype;

// 定义Mouse实现类
public class Mouse implements USB3 {
    @Override
    public void start() {
        System.out.println("鼠标开始工作");
    }

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

    @Override
    public void in() {
        System.out.println("鼠标不接收信号");
    }

    @Override
    public void out() {
        System.out.println("鼠标发送脉冲信号");
    }
}

package com.myexample.interfacetype;

// 定义KeyBoard实现类
public class KeyBoard implements USB3 {
    @Override
    public void start() {
        System.out.println("键盘开始工作");
    }

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

    @Override
    public void in() {
        System.out.println("键盘不接收信号");
    }

    @Override
    public void out() {
        System.out.println("键盘发送按键信号");
    }
}

package com.myexample.interfacetype;

// 定义MobileHDD实现类
public class MobileHDD implements USB3 {
    @Override
    public void start() {
        System.out.println("移动硬盘开始工作");
    }

    @Override
    public void stop() {
        System.out.println("移动硬盘停止工作");
    }

    @Override
    public void in() {
        System.out.println("移动硬盘接收数据");
    }

    @Override
    public void out() {
        System.out.println("移动硬盘输出数据");
    }
}

package com.myexample.interfacetype;

// 定义Computer类
public class Computer {
    private USB3 usb;

    public void setUsb(USB3 usb) {
        this.usb = usb;
    }
}

package com.myexample.interfacetype;

// 测试类
public class TestComputer {
    public static void main(String[] args) {
        Computer computer = new Computer();
        
        // 使用Mouse对象
        USB3 usb = new Mouse();
        computer.setUsb(usb);
        usb.start();
        usb.out();
        usb.in();
        usb.stop();
        System.out.println("--------------------------");

        // 使用KeyBoard对象
        usb = new KeyBoard();
        computer.setUsb(usb);
        usb.start();
        usb.out();
        usb.in();
        usb.stop();
        System.out.println("--------------------------");

        // 使用MobileHDD对象
        usb = new MobileHDD();
        computer.setUsb(usb);
        usb.start();
        usb.out();
        usb.in();
        usb.stop();
    }
}

（5）使用接口的静态成员

①定义

        接口不能直接创建对象，但是可以通过接口名直接调用接口的静态方法和静态常量。

②举例
package com.myexample.interfacetype;

public class TestUSB3 {
    public static void main(String[] args) {
        // 通过“接口名.”调用接口的静态方法 (JDK8.0才能开始使用)
        USB3.show();
        // 通过“接口名.”直接使用接口的静态常量
        System.out.println(USB3.MAX_SPEED);
    }
}

（6）使用接口的非静态方法

  • 对于接口的静态方法，直接使用“接口名.”进行调用即可

    • 也只能使用“接口名."进行调用，不能通过实现类的对象进行调用

  • 对于接口的抽象方法、默认方法，只能通过实现类对象才可以调用

    • 接口不能直接创建对象，只能创建实现类的对象

package com.myexample.interfacetype;

public class TestMobileHDD {
    public static void main(String[] args) {
        // 创建实现类对象
        MobileHDD b = new MobileHDD();

        // 通过实现类对象调用重写的抽象方法
        b.start();
        b.in();
        b.out();
        b.stop();

        // 通过接口名调用接口的静态方法
        USB3.show();
    }
}

 5.JDK8中相关冲突问题

（1）默认方法冲突问题

①类优先原则

        当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的抽象方法重名，子类就近选择执行父类的成员方法。代码如下：

定义接口：

​public interface Friend {
    default void date(){//约会
        System.out.println("吃喝玩乐");
    }
}

定义父类：

public class Father {
    public void date(){//约会
        System.out.println("爸爸约吃饭");
    }
}

定义子类：

public class Son extends Father implements Friend {
    @Override
    public void date() {
        //(1)不重写默认保留父类的
        //(2)调用父类被重写的
//        super.date();
        //(3)保留父接口的
//        Friend.super.date();
        //(4)完全重写
        System.out.println("跟Theodore_1022Blog学Java");
    }
}

定义测试类：

public class TestSon {
    public static void main(String[] args) {
        Son s = new Son();
        s.date();
    }
}
②接口冲突（左右为难）

  • 当一个类同时实现了多个父接口，而多个父接口中包含方法签名相同的默认方法时，怎么办呢？

无论你多难抉择，最终都是要做出选择的。

声明接口：

public interface BoyFriend {
    default void date(){//约会
        System.out.println("神秘约会");
    }
}

选择保留其中一个，通过“接口名.super.方法名"的方法选择保留哪个接口的默认方法。

public class Girl implements Friend,BoyFriend{
​
    @Override
    public void date() {
        //(1)保留其中一个父接口的
//        Friend.super.date();
//        BoyFriend.super.date();
        //(2)完全重写
        System.out.println("跟Theodore_1022Blog学Java");
    }
​
}

测试类

public class TestGirl {
    public static void main(String[] args) {
        Girl girl = new Girl();
        girl.date();
    }
}

  • 当一个子接口同时继承了多个接口，而多个父接口中包含方法签名相同的默认方法时，怎么办呢？

另一个父接口：

public interface USB2 {
    //静态常量
    long MAX_SPEED = 60*1024*1024;//60MB/s
​
    //抽象方法
    void in();
    void out();
​
    //默认方法
    public default void start(){
        System.out.println("开始");
    }
    public default void stop(){
        System.out.println("结束");
    }
​
    //静态方法
    public static void show(){
        System.out.println("USB 2.0可以高速地进行读写操作");
    }
}

子接口：

public interface USB extends USB2,USB3 {
    @Override
    default void start() {
        System.out.println("Usb.start");
    }
​
    @Override
    default void stop() {
        System.out.println("Usb.stop");
    }
}

​

小贴士：

子接口重写默认方法时，default关键字可以保留。

子类重写默认方法时，default关键字不可以保留。

（2）常量冲突问题

  • 当子类继承父类又实现父接口，而父类中存在与父接口常量同名的成员变量，并且该成员变量名在子类中仍然可见。

  • 当子类同时实现多个接口，而多个接口存在相同同名常量。

此时在子类中想要引用父类或父接口的同名的常量或成员变量时，就会有冲突问题。

父类和父接口：

public class SuperClass {
    int x = 1;
}
package com.atguigu.interfacetype;
​
public interface SuperInterface {
    int x = 2;
    int y = 2;
}
package com.atguigu.interfacetype;
​
public interface MotherInterface {
    int x = 3;
}
子类：

package com.atguigu.interfacetype;
​
public class SubClass extends SuperClass implements SuperInterface,MotherInterface {
    public void method(){
//        System.out.println("x = " + x);//模糊不清
        System.out.println("super.x = " + super.x);
        System.out.println("SuperInterface.x = " + SuperInterface.x);
        System.out.println("MotherInterface.x = " + MotherInterface.x);
        System.out.println("y = " + y);//没有重名问题，可以直接访问
    }
}

总结

        本篇对JAVA基础中面向对象编程思想中的接口进行了详细描述，便于学习与应用。部分内容源自网络，如有侵权请联系作者删除，谢谢！ 

Theodore_1022
关注
  • 31
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础——面向对象编程
05-06
Java基础——面向对象编程 面向对象编程（Object-Oriented Programming，OOP）是一种编程方法，它将现实世界中的对象抽象出来，并使用计算机模型来描述。面向对象编程的核心概念是类（class）和实例（instance）。...
java基础之面向对象编程
02-20
Java是一种广泛使用的面向对象编程语言，其面向对象的特性使得代码更加模块化、易于...以上只是Java面向对象编程的基础知识概览，实际上，每个主题都包含了更深入的概念和实践技巧，需要通过不断的学习和实践来掌握。
【Java】面向对象之——接口的理解
DerrickWestbrook的博客
11-21 2079
【Java】面向对象之——接口的理解语法规则实现多个接口接口使用实例接口间的继承Cloneable 接口和深拷贝总结 接口是抽象类的更进一步. 抽象类中还可以包含非抽象方法, 和字段. 而接口中包含的方法都是抽象方法, 字段只能包含静态常量. 有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。 接口(interface)是抽象方法和常量值的定义的集合。 从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义
JAVA基础——接口（全网最详细教程）
热门推荐
扬俊的小屋
05-10 37万+
Java基础——接口 接口概念 官方解释：Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。 我的解释：接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组...
Java面向对象编程——什么是面向对象
WXS153322的博客
04-07 2734
面向对象的简称OO(Object Oriented) ,也称之为面向对象思想 Java 是面向对象的编程语言，对象就是面向对象程序设计的核心。所谓对象就是真实世界中的实体，对象与实体是一一对应的，也就是说现实世界中每一个实体都是一个对象，它是一种具体的概念。 它是一种编程思维，也是一种思考问题的方式 其中基本思想是使用面向对象中的三大特征继承,封装，多态进行程序设计 那么如何建立面向对象的思维？ 1.先整体，在局部 先想好一个大概，然后在局部的实现 2.先抽象，再具体 ...
【JAVA学习】2、面向对象编程的核心——对象和类
陈艺荣
09-18 1547
【JAVA学习】面向对象编程的核心——对象和类前言面向过程VS面向对象基础概念优缺点比较面向对象三大基础特性封装继承多态面向对象编程的五大基本原则单一职责原则SRP(Single Responsibility Principle)开放封闭原则OCP(Open－Close Principle)里式替换原则LSP(the Liskov Substitution Principle LS)依赖倒置原则DIP(the Dependency Inversion Principle DIP)接口分离原则ISP(the
Java学习——面向对象编程思想
weixin_53919192的博客
05-25 1780
本文向大家介绍了面对对象的基本概念、面向对象与面向过程的区别、面向对象程序设计的类与对象、面向对象的四大特征：抽象、继承、封装、多态、实现多态性的三种方式：重载、重写、接口、 面向对象思想优点、面向对象思想总结、三大特征、五种关系、七大原则，希望对你有用~~
java的面向对象编程（oop）——认识接口
快乐学习，daydayup!
01-30 590
java的面向对象编程（oop）——认识接口
Java面向对象之——封装
LEE180501的博客
11-23 2580
本期主要探讨了面向对象三大特性之一的封装，重点介绍了Java包的概念、引入了静态属性static、详细介绍了Java中的三种代码块、最后拓展了一下IDEA中的小技巧，欢迎阅读！
Java 基础入门篇（五）：面向对象编程
秀岩的博客
04-30 2653
一、面向对象的思想 二、类的定义与对象的创建 三、对象内存分配情况 3.1 两个对象的内存图 3.2 两个变量指向同一个对象内存图 四、构造器 4.1 构造器的格式与分类 4.2 构造器的调用 五、 this 关键字 六、封装 七、标准JavaBean 补充：局部变量和成员变量的区别
JAVA基础——面向对象程序设计的四大特性
weixin_42486795的博客
06-16 6297
1.封装性 面向对象的第一个原则是把数据和对该数据的操作都封装到一个类中，类的概念和现实世界的“事务种类”是一致的。 如电视机就是一个类，每台电视机都有尺寸、品牌，这些性能被封装成类的属性，每台电视机都可以开关电视、播放电视节目，这些行为动作被封装成类的方法。 对象是类的一个实例化结果，对象具有类所描述的所有属性及方法，是具体的。 每个对象都属于某个类，面向对象程序设计就是设计好相关的类，类中有属...
编程思想——面向接口编程（Java语言）
weixin_62259133的博客
04-20 2344
简介 最近学习Java基础的时候被面向接口编程的思想迷住了，自己研究了好一会才搞明白，面向接口太伟大了，我将用我写的第一篇文章记录下这个思想的过程。接下来将通过一个通俗的例子阐述面向接口编程的便利性，虽然实际开发中不太了解，但起码思想是一样的。在阅读本文时大家应有接口实现的基础了，我就不加赘述。 第一阶段 假设有帅哥小明，有一天她苦苦追求的女生说会踢足球和打篮球的男生会好加分。于是小明花重金请来了一个会打篮球和踢足球的金牌教练，代码如下。 篮球类： public class Basket..
面向对象编程基础_python面向对象_python教程_
09-29
下面我们将深入探讨Python中的面向对象编程基础。 一、类与对象 1. **类（Class）**：类是面向对象编程的基础，它是创建对象的模板。在Python中，我们通过定义class关键字来创建一个类。例如： ```python class...
JAVA面向对象编程思想
11-13
### JAVA面向对象编程思想 #### 一、面向对象的基本概念 面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它通过模拟现实世界中的对象及其交互方式来构建软件系统。Java作为一种典型的面向...
java——基础商城小项目 包含面向对象 多态 接口
03-17
这个基础商城小项目为初学者提供了实践Java面向对象编程、多态和接口的绝佳机会。通过分析和运行"shoppingmall.jar"，可以深入理解这些概念在实际开发中的应用，同时提升编程技巧和问题解决能力。
JAVA进阶补充
2301_80150315的博客
08-15 755
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
进程间通信 ---共享内存
BUG制造机的博客
08-14 1027
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
手撕快排——三种实现方法（附动图及源码）
最新发布
jsjs1346的博客
08-16 544
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 328
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值