Java接口的艺术：探索接口特性与面向接口编程

news2024/9/20 11:03:53

在Java的世界里，接口（Interface）是一种强大的抽象机制，它定义了一组方法规范，但不实现这些方法。接口在Java编程中扮演着至关重要的角色，特别是在实现多态和面向接口编程（Interface-Oriented Programming, IOP）方面。本文将深入探讨Java接口的特性、接口实现多态的方式，以及面向接口编程的好处。

接口的特性

  1. 完全抽象：接口中的方法默认都是抽象的，它不能包含实现（除非是默认方法或静态方法）。
  2. 多继承：Java不允许类继承多个类，但允许一个类实现多个接口，从而实现多继承的特性。
  3. 全局访问：接口中的所有方法默认都是public的，它们隐式地定义为public abstract。
  4. 类型检查：接口可以作为引用类型，用于引用对象，提供了一种类型检查的机制。
  5. 默认方法：从Java 8开始，接口可以包含默认方法，即带有实现的方法。
  6. 静态方法：接口也可以包含静态方法，这些方法可以在不实例化接口的情况下直接调用。
package cn.zy.cellphone;
/**接口是一种引用数据类型。使用interface声明接口，形式
 * 形式:public interface 接口名称{}
 * 接口不能拥有构造方法，不能用于创建对象
 *接口可以多继承。一个接口可以继承多个其他接口
 *列如：public interface Broadcast extends Network，Picture{}
 *Broadcast接口就具备了A、B接口中定义的抽象方法。
 */
public interface Broadcast {
     /**接口中可以声明属性。接口中定义的所有变量都是static final类型的。
      * public static final String version = "1.0";
         public int count = 10; // 默认是static final类型
         一般很少在接口中声明属性。
      */
package cn.zy.cellphone;
 
public interface Picture {
public void picture();//照相
}
package cn.zy.cellphone;
 
public interface Network {
public void network();//网络
}
package cn.zy.cellphone;
/**一个类只能继承一个父类，同时实现多个接口。继承在前，实现在后。
 * public class Photo2 extends Photo implements Network,Picture,Broadcast {}
 * 实现类实现接口，必须实现接口中定义的抽象方法。
 *方法即行为，表示一种功能,接口定义了一套功能，实现类必须实现这些功能 –> 实现类的能力得到拓展。
 */
//实现类（子类）
public class Photo2 extends Photo implements Network,Picture,Broadcast {
            private String name;
          
            
            public String getName() {
                return name;
            }
 
 
            public void setName(String name) {
                this.name = name;
            }
             
 
            public Photo2(String brand, String type, String name) {
                super(brand, type);
                this.setName (name);
         } 
            /**接口中定义的一些系列方法表示的是一种种的能力。接口让实现类实现这些能力，实现类的能力得到拓展和升级。
                                         实现类根据自身特性实现接口中定义的方法。
             * 特殊情况:如果一个抽象父类定义了和接口同名的抽象方法，实现类实现的是抽象父类的抽象方法。
             */
            public void broadcast() {
                System.out.println(this.getName()+"的手机可以播放");
        }
 
            public void picture() {
                System.out.println(this.getName()+super.getBrand()+super.getType()+"的手机可以照相");
                
            }
 
            
            public void network() {
                
                System.out.println(this.getName()+super.getBrand()+super.getType()+"的手机可以播放上网");    
            }
            /**实现类（子类）Photo2 手机原本只有下面几个功能，通过接口增加了上面几个功能
             * 实现类实现接口，必须实现接口中定义的抽象方法。
               *方法即行为，表示一种功能,接口定义了一套功能，实现类必须实现这些功能 –> 实现类的能力得到拓展。
             */
            
            public void sendInfo() {
                System.out.println(super.getBrand()+super.getType()+"的手机发信息");            
                
            }
 
            
            public void call() {
                System.out.println(super.getBrand()+super.getType()+"的手机可以打电话");                
                
            }
 
            
            public void info() {
                System.out.println(super.getBrand()+super.getType()+"的手机可以发短信");
                
            }
}
package cn.zy.cellphone;
//实现类（子类）
public  class Photo1 extends Photo implements Broadcast {
       private String name;
    
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
    public Photo1() {
    super();
}
 
    public Photo1(String brand, String type,String name) {
    super(brand,type);
    this.setName(name);
}
 
 
    public void broadcast() {
        System.out.println(this.getName()+"的手机可以播放");
}
    public  void sendInfo(){
        System.out.println(super.getBrand()+super.getType()+"的手机发信息");
    }
    public void call(){
        System.out.println(super.getBrand()+super.getType()+"的手机可以打电话");
        }
    public void info(){
        System.out.println(super.getBrand()+super.getType()+"的手机可以发短信");
    }
 
}
package cn.zy.cellphone;
//父类
public abstract class Photo {
     private String brand;
     private String type;
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    public Photo() {
        super();
    }
    public Photo(String brand, String type) {
        super();
        this.brand = brand;
        this.type = type;
    }
     public abstract void sendInfo();
     public abstract void call();
     public abstract void info();
}
package cn.zy.cellphone;
//执行类
public class Test {
public static void main(String[] args) {
              // 同一引用类型
    Broadcast broadcast1=new Photo1("诺基亚","a01","张三");
            broadcast1.broadcast();
        
            Photo photo=new Photo1("诺基亚","a01","张三");
            photo.sendInfo();
            photo.call();
            photo.info();
            // 同一引用类型
            Broadcast broadcast2=new Photo1("苹果X","11S","李四"); 
            broadcast2.broadcast();
            // 实例不同， 对同一方法的执行结果不同
            Picture picture1=new Photo2("苹果X","11S","李四");
            picture1.picture();
            Network network1=new Photo2("苹果X","11S","李四");
            network1.network();
           //多态
            Photo photo1=new Photo1("苹果X","11S","李四");
            photo1.sendInfo();
            photo1.call();
            photo1.info();
            /**
             * 接口实现多态: 接口类型 引用 实现类对象
                                      继 承实现多态: 父类类型 引用 子类对象
                                     接口定义的方法被实现类实现，通过接口引用实现类时，调用接口中的方法时，执行的是实现类实现的方法。
                                       实现类对象具备接口中定义的能力 是一种has a 关系
                                           子类对象是一种父类类型 是一种is a 关系                       
                
                                         现在的Photo1同Photo2既是实现类也是子类
             */
}
}

面向接口编程
接口表示一种约定 (协议), 约定 (规范) 了实现类应该具备 (has a) 的能力。

理解:

=> 实现类必须实现接口中所有的方法，所以接口规范了实现类的行为

=> 接口约定了实现类应该具备的行为。

面向接口编程

所谓面向接口编程，在程序设计时，只关心实现类具备什么能力，而不关心实现类如何实现这个能力。面向接口编程时，面向接口的约定而不考虑接口的具体实现。

也就是说，面向接口编程时，接口的定义方只关系实现类是否具备接口所定义的能力，而实现类如何被的该能力接口定义方一点都不关心

//接口实现多态 电脑类（通过接口把3种零件组成电脑，而且零件随时可以更换）（cpu接口  4Hz  5Hz  。。。。（随时更换大小不同的cpu）  ）
                                                            （硬盘接口  3000GB  4000Gb（随时更换大小不同的硬盘））

（内存接口  30GB  40Gb（随时更换大小不同的内存））
package cn.computer;
//电脑
public class Computer {
  private Cpu cpu;                       //  预留cpu接口
  private Caliche caliche;                 // 预留硬盘接口
  private InternalStroage internalStroage;   //预留内存接口
public Cpu getCpu() {
    return cpu;
}
public void setCpu(Cpu cpu) {
    this.cpu = cpu;
}
public Caliche getCaliche() {
    return caliche;
}
public void setCaliche(Caliche caliche) {
    this.caliche = caliche;
}
public InternalStroage getInternalStroage() {
    return internalStroage;
}
public void setInternalStroage(InternalStroage internalStroage) {
    this.internalStroage = internalStroage;
}
public Computer() {
    super();
}
public Computer(Cpu cpu, Caliche caliche, InternalStroage internalStroage) {
    super();
    this.cpu = cpu;                         
    this.caliche = caliche;                    
    this.internalStroage = internalStroage;       
}
  //把各个部件通过接口组装成一个完整的电脑
public void print(String name) {
    System.out.println(name+"计算机");
    System.out.println("cpu："+getCpu().Hz());
    System.out.println("硬盘容量："+getCaliche().big2());
    System.out.println("内存容量："+this.getInternalStroage().big());
}
    
}
package cn.computer;
//cpu接口
public interface Cpu {
    public String Hz();  //这是接口实现多态的形式：  public 你要返回的变量类型   方法名（）
    
        
    }

package cn.computer;
//实现类
public class Realize1 implements Cpu{
  public String Hz(){             // public 你要返回的变量类型   方法名（）
      return "3.8GHz";               //返回值
  }
}
package cn.computer;
//内存接口
public interface InternalStroage {
  public String big();
}
package cn.computer;
//实现类
public class Realize2 implements InternalStroage{
    public String big(){
        return "4GB";
 
    }
 
}
package cn.computer;
//硬盘接口
public interface Caliche {
    public String big2();
}
package cn.computer;
 
public class Test {
public static void main(String[] args) {
    Cpu cpu=new Realize1();     //把一种3.8Hz的cpu赋予给cpu接口
    Caliche caliche=new Realize3();   //把3000GB的硬盘赋予给硬盘接口
    InternalStroage internalStroage=new Realize2();     //把4GB的内存赋予给内存接口
    Computer computer=new Computer(cpu,caliche,internalStroage);    //把cpu，硬盘，内存给电脑类组合（地址）
     computer.print("华硕");                 //最后得到了完整的电脑
     }
}

抽象类和接口的异同比较

抽象类和接口都是引用数据类型，他们都不能创建对象。
他们都可以定义抽象方法，都可以实现多态。但是抽象类可以定义非抽象方法，而接口中定义的都是抽象方法。
抽象类和接口都具有传递性。抽象类是单根性（单继承），而接口是多继承。
在概念上，都可以重写抽象方法。子类重写抽象类，实现类实现接口
抽象类和子类解决的是模块内的问题（代码重用 , 重写 , 多态）而接口解决的是模块间的问题 => 高内聚，低耦合。接口可以用解耦模块。

接口实现多态

多态是面向对象编程的核心特性之一，它允许使用父类型来引用子类型的对象，并在运行时确定调用哪个子类型的方法是多态的关键。接口在实现多态中起到了桥梁的作用：

  1. 通过接口引用不同类型的实现：可以创建一个接口类型的引用，指向实现了该接口的不同类的对象。
  2. 方法覆盖：当接口的实现类覆盖接口中的方法时，就可以在运行时根据对象的实际类型调用相应的方法。
  3. 动态绑定：Java虚拟机（JVM）在运行时根据对象的实际类型来动态绑定方法，这就是多态的实现机制。

面向接口编程的好处

面向接口编程是一种设计原则，它强调使用接口而不是具体的类来编程。这种方式带来了许多好处：

  1. 解耦合：面向接口编程有助于降低系统各部分之间的耦合度，提高模块化。
  2. 灵活性：通过接口，可以轻松替换实现，而不影响使用接口的代码。
  3. 扩展性：新增实现类不会影响现有的代码，提高了系统的可扩展性。
  4. 代码重用：接口定义了规范，不同的实现可以共享同一接口，从而实现代码重用。
  5. 易于测试：面向接口编程使得编写单元测试更加容易，可以通过mock接口来测试代码。

实践面向接口编程

  1. 定义清晰的接口：根据业务需求定义接口，而不是根据实现细节。
  2. 优先使用接口：在编写代码时，优先考虑使用接口作为参数类型、返回类型和字段类型。
  3. 实现类遵循接口：实现类应该严格遵循接口定义，不添加额外的方法。
  4. 利用接口实现多态：通过接口来实现多态，使得代码更加灵活和可扩展。

结语

Java接口是实现多态和面向接口编程的强大工具。通过理解和运用接口的特性，Java程序员可以编写出更加灵活、可扩展和可维护的代码。面向接口编程不仅是一种技术实践，更是一种编程哲学，它引导我们关注抽象和规范，而不是具体的实现细节。掌握这些概念和技术，将使你的Java编程之路更加宽广。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2139960.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Linux进程状态进程优先级

Linux进程状态进程优先级

目录 一、操作系统的进程状态 1.1运行状态 1.2阻塞状态 1.3挂起 二、Linux下具体的状态 三、进程的优先级 3.1基本概念 3.2查看进程优先级的命令 3.3修改进程优先级的命令 3.4其他概念 3.5并发 一、操作系统的进程状态 1.1运行状态 当一个进程准备就绪&#xff0c…
阅读更多...
MouseArea元素

MouseArea元素

常用信号 onClicked，鼠标点击onPressed，鼠标按下onReleased，鼠标释放 import QtQuickWindow {width: 640height: 480visible: truetitle: qsTr("Hello World")Rectangle{id:rectwidth: 100height: 100color:"red"MouseA…
阅读更多...
redis基本数据结构-sorted set

redis基本数据结构-sorted set

1. sorted set的简单介绍 参考链接：https://mp.weixin.qq.com/s/srkd73bS2n3mjIADLVg72A Redis的Sorted Set（有序集合）是一种数据结构，它是一个不重复的字符串集合，每个元素都有一个对应的分数（score&…
阅读更多...
模板方法模式：设计模式中的骨架法则

模板方法模式：设计模式中的骨架法则

模板方法模式（Template Method Pattern）是一种行为设计模式，它定义了一个操作中的算法骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 一，模板方法模式的…
阅读更多...
C# HttpListener 实现的HTTP Sever浏览器文件下载

C# HttpListener 实现的HTTP Sever浏览器文件下载

1. 前端页面请求 编写简单的test.html 文件&#xff0c;body体值配置a标签&#xff0c;其href 属性设置为文件下载请求的http接口要求的参数序列。 <!DOCTYPE html><html> <head><meta name"viewport" content"widthdevice-width" …
阅读更多...
行业分析---自动驾驶行业的发展

行业分析---自动驾驶行业的发展

1 背景 进入21世纪以来&#xff0c;自动驾驶行业有着飞速的发展&#xff0c;L2级别的自动驾驶技术也逐渐落地量产到寻常百姓家。不管是起步比较早的特斯拉&#xff0c;还是2015年以后国内的公司&#xff0c;都在逐渐发展自动驾驶技术&#xff0c;并量产给用户使用。 自动驾驶最…
阅读更多...
COMDEL电源维修CLX2500康戴尔射频电源维修

COMDEL电源维修CLX2500康戴尔射频电源维修

美国COMDEL射频电源维修常见型号包括&#xff1a;CLX2750&#xff1b;CLX2500&#xff1b;CLX-600H&#xff1b;CX600AS&#xff1b;CX-5000S&#xff1b;CX-3500S&#xff1b;CX-2500S&#xff1b;CV500&#xff1b;CDX2000等。 Comdel成立于1966年&#xff0c;总部设在马萨诸…
阅读更多...
Linux环境基础开发工具使用（gcc/g++与makefile）

Linux环境基础开发工具使用（gcc/g++与makefile）

1.Linux编译器-gcc/g使用 1. 背景知识 接下来的操作&#xff0c;我以gcc为例&#xff0c;因为两者选项都是通用的&#xff0c;所以也就相当于间接学习了 1.预处理&#xff08;进行宏替换) 2.编译&#xff08;生成汇编) 3.汇编&#xff08;生成机器可识别代码&#xff09;…
阅读更多...
革新骨科金属螺丝：TPMS结构助力骨再生研究新突破AbMole

革新骨科金属螺丝：TPMS结构助力骨再生研究新突破AbMole

在骨科植入物领域&#xff0c;金属螺丝因其出色的机械强度和生物相容性&#xff0c;一直是骨折固定不可或缺的工具。然而&#xff0c;传统实心设计的金属螺丝常常面临应力遮挡和术后松动的问题&#xff0c;严重影响其长期固定效果。近期&#xff0c;一项由吉林大学第二医院骨科…
阅读更多...
第T1周：Tensorflow实现mnist手写数字识别

第T1周：Tensorflow实现mnist手写数字识别

&#x1f368; 本文为&#x1f517;365天深度学习训练营 中的学习记录博客&#x1f356; 原作者&#xff1a;K同学啊 目标&#xff1a; 具体实现&#xff1a; &#xff08;一&#xff09;环境&#xff1a; 语言环境&#xff1a;Python 3.10 编 译 器: PyCharm 框架&#xff1a…
阅读更多...
Mixtral 8x7B：开源稀疏混合专家模型的新里程碑

Mixtral 8x7B：开源稀疏混合专家模型的新里程碑

人工智能咨询培训老师叶梓 转载标明出处 随着大模型规模的增大&#xff0c;计算成本和资源消耗也相应增加&#xff0c;这限制了它们的应用范围和效率。本论文介绍了一种新的稀疏混合专家模型&#xff08;SMoE&#xff09;——Mixtral 8x7B&#xff0c;它在保持较小计算成本的同…
阅读更多...
【C++】c++ 11

【C++】c++ 11

目录 前言 列表初始化 std::initializer_list 右值引用和移动拷贝 左值和右值 左值引用和右值引用的区别 万能引用&#xff08;引用折叠&#xff09; 完美转发 默认成员函数控制 列表初始化 在C98中&#xff0c;标准允许使用花括号{}对数组或者结构体元素进行统一的列…
阅读更多...
Gartner 成熟度曲线报告解读（一）| 2024中国IT基础设施使用趋势、影响中国IT使用的4大因素

Gartner 成熟度曲线报告解读（一）| 2024中国IT基础设施使用趋势、影响中国IT使用的4大因素

近些年&#xff0c;面对数字化转型、信息化发展、政策监管与地缘政治等外部因素&#xff0c;以及降本增效的内部需求&#xff0c;不少中国企业在制定 IT 基础设施发展策略时遇到多重挑战。为帮助国内企业用户优化基础设施战略&#xff0c;Gartner 近日发布《中国 IT 基础设施技…
阅读更多...
【HCIA-Datacom】华为VRP系统

【HCIA-Datacom】华为VRP系统

| &#x1f449;个人主页&#xff1a;Reuuse 希望各位多多支持&#xff01;❀ | &#x1f449;往期博客&#xff1a;网络参考模型 | 最后如果对你们有帮助的话希望有一个大大的赞&#xff01; | ⭐你们的支持是我最大的动力&#xff01;⭐ | 目录 1. 华为VRP系统概述VRP概念设备…
阅读更多...
Docker-compose：管理多个容器

Docker-compose：管理多个容器

Docker-Compose 是 Docker 公司推出的一个开源工具软件&#xff0c;可以管理多个 Docker 容器组成一个应用。用户需要定义一个 YAML 格式的配置文件 docker-compose.yml&#xff0c;写好多个容器之间的调用关系。然后&#xff0c;只要一个命令&#xff0c;就能同时启动/关闭这些…
阅读更多...
七、垃圾收集器ParNewCMS与底层三色标记算法详解

七、垃圾收集器ParNewCMS与底层三色标记算法详解

文章目录 垃圾收集算法分代收集理论标记-复制算法标记-清除算法标记-整理算法 垃圾收集器1.1 Serial收集器(-XX:UseSerialGC -XX:UseSerialOldGC)1.2 Parallel Scavenge收集器(-XX:UseParallelGC(年轻代),-XX:UseParallelOldGC(老年代))1.3 ParNew收集器(-XX:UseParNewGC)1.4 C…
阅读更多...
POSIX信号量以及利用POSIX信号量实现基于循环队列的高效生产者消费者模型

POSIX信号量以及利用POSIX信号量实现基于循环队列的高效生产者消费者模型

&#x1f351;个人主页&#xff1a;Jupiter. &#x1f680; 所属专栏&#xff1a;Linux从入门到进阶 欢迎大家点赞收藏评论&#x1f60a; 目录 &#x1f341;POSIX信号量 &#x1f341;信号量的相关接口介绍*初始化信号量**销毁信号量**等待信号量**发布信号量* &#x1f341;&…
阅读更多...
YOLOv9 简介

YOLOv9 简介

YOLO v9 是目前表现最佳的目标检测器之一&#xff0c;被视为现有 YOLO 变体&#xff08;如 YOLO v5、YOLOX 和 YOLO v8&#xff09;的改进版本。 YOLOv9 在实时目标检测领域取得了重大进展&#xff0c;引入了诸如可编程梯度信息&#xff08;PGI&#xff09;和通用高效层聚合网…
阅读更多...
后端开发刷题 | 打家劫舍

后端开发刷题 | 打家劫舍

描述 你是一个经验丰富的小偷&#xff0c;准备偷沿街的一排房间&#xff0c;每个房间都存有一定的现金&#xff0c;为了防止被发现&#xff0c;你不能偷相邻的两家&#xff0c;即&#xff0c;如果偷了第一家&#xff0c;就不能再偷第二家&#xff1b;如果偷了第二家&#xff0…
阅读更多...
Dina靶机详解

Dina靶机详解

靶机下载 https://www.vulnhub.com/entry/dina-101,200/ 靶机配置 默认是桥接模式&#xff0c;切换为NAT模式后重启靶机 主机发现 arp-scan -l 端口扫描 nmap -sV -A -T4 192.168.229.157 发现80端口开启&#xff0c;访问 访问网站 目录扫描 python dirsearch.py -u http…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023