接口的顶级理解

已于 2023-11-23 21:16:27 修改
阅读量280 收藏 5
点赞数 11
分类专栏： javaSE 文章标签： java 开发语言
于 2023-08-06 14:43:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WHabc2002/article/details/132118290
版权

目录

1.基本介绍

1.1定义接口

1.2接口使用

 2.接口特性

3.实现多个接口

4.接口间的继承

5.接口使用实例

5.1对象比大小

5.1.1方法1：Comparable 接口法

 5.1.2构造比较器（Comparator接口法）

5.2对象数组排序

5.2.1 实现 Comparable 接口,

 5.2.2构造比较器（实现Comparator接口）

6.Clonable 接口和深拷贝

6.1Clonable 接口

6.2 浅拷贝

6.3深拷贝  

1.基本介绍

接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用 。 在 Java 中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

上述可能过于抽象，我们可以通过语法来理解。

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

1.1定义接口

public interface 接口名称 {
// 抽象方法
void method ();
}
注意：
1. 创建接口时, 接口的命名一般以大写字母 I 开头 .
2. 接口的命名一般使用 " 形容词" 词性的单词.

1.2接口使用

接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法。
public class 类名称 implements 接口名称 {
// ...
}

 2.接口特性

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

2. 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract

只能是 public abstract，其他修饰符都会报错

3. 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现，但两个方法除外，static修饰的方法和default修饰的方法.
IText 接口 
public interface IText {

    void A();
    public static void AAwork(){
        System.out.println("AAwork()");
    }
    public default void BBwork(){
        System.out.println("BBwork()");
    }
}

Dometext implements IText
class Dometext implements IText{
    @Override
    public void A() {
        System.out.println("Dometext的A()");
    }
}
Test1

public class Test1 {
    public static void main(String[] args) {
        IText.AAwork();
        Dometext dometext = new Dometext();
        dometext.BBwork();
        dometext.A();

    }
}

运行结果：

 小结：static修饰不可重写，default修饰可重写也可以不重写。

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

故为常量，不可修改。

5.接口中不能有静态代码块，实例代码块和构造方法

 6.接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class

7.如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类

3.实现多个接口

在 Java 中，类和类之间是单继承的，一个类只能有一个父类，即 Java中不支持多继承，但是一个类可以实现多个接 口。
下面通过类来表示一组动物 . 
Animal
abstract class Animal {
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

     public abstract void eat();
}
另外我们再提供一组接口 , 分别表示 " 会飞的 ", " 会跑的 ", " 会游泳的 ". 
interface IFlying 
interface IFlying {
    void fly();
}
interface IRunning
interface IRunning {
    void run();
}
interface ISwimming
interface ISwimming {
    void swim();
}
接下来我们创建几个具体的动物
猫 , 是会跑的 . 
class Cat extends Animal implements IRunning {
    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name+"吃猫粮");
    }

    @Override
    public void run() {
        System.out.println(this.name + "正在用四条腿跑");
    }

}
青蛙 , 既能跑 , 又能游 ( 两栖动物 ) 
class Frog extends Animal implements IRunning, ISwimming {
    public Frog(String name, int age) {
        super(name, age);
    }


    @Override
    public void run() {
        System.out.println(this.name + "正在往前跳");
    }
    @Override
    public void swim() {
        System.out.println(this.name + "正在蹬腿游泳");
    }
    @Override
    public void eat() {
        System.out.println(name+"吃青蛙粮");
    }
}
水陆空三栖" 鸭子 " 
class Duck extends Animal implements IRunning, ISwimming, IFlying {
    public Duck(String name, int age) {
        super(name, age);
    }

    @Override
    public void fly() {
        System.out.println(this.name + "正在用翅膀飞");
    }

    @Override
    public void run() {
        System.out.println(this.name + "正在用两条腿跑");
    }

    @Override
    public void swim() {
        System.out.println(this.name + "正在漂在水上");
    }
    @Override
    public void eat() {
        System.out.println(name+"吃鸭粮");
    }
}

Text1

public class Text1 {
    
    public static void func(Animal animal){
        animal.eat();
    }
 
    public static void main(String[] args) {
        func(new Cat("mimi",1));
        func(new Frog("vava",1));
        func(new Duck("yaya",1));

    }
}

运行结果：

Text2

public class Text2 {


    public static void func(Animal animal){
        animal.eat();
    }
    public static void fFly(IFlying flying){
        flying.fly();
    }
    public static void fRun(IRunning running){
        running.run();
    }
    public static void fSwim(ISwimming swimming){
        swimming.swim();
    }

    public static void main(String[] args) {
        fSwim(new Frog("vava",1));
        fRun(new Frog("vava",1));
    }

}

运行结果： 

 图解：

                                                                图解3-1

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

再如Text3

甚至参数可以不是 " 动物 ", 只要会跑 ! 
public class Text2 {

    public static void main(String[] args) {
        fRun(new Robot("1hao"));
    }
 
  
    public static void fRun(IRunning running){
        running.run();
    }
}

运行结果：

4.接口间的继承

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

  

接口与接口之间可以多继承,即：用接口可以达到 多继承的目的。
接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字.

 图解：

 

                                                               图解4-1

举例： 

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

5.接口使用实例

5.1对象比大小

不难发现 , 和普通的整数不一样 , 两个整数是可以直接比较的 , 大小关系明确 . 而两个学生对象的大小关系 怎么确定? 需要我们额外指定 .
学生类 
class Student {
    String name;
    int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
Student wang = new Student("wang", 20);
Student li = new Student("li", 19)；

如：我们现在想要比较两个学生的年龄。

5.1.1方法1：Comparable 接口法

让我们的 Student 类实现 Comparable 接口, 并实现其中的 compareTo 方法

代码（5-1-1）  

class Student implements Comparable<Student>{
    String name;
    int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Student o) {
        if(this.age>o.age){
            return 1;
        } else if (this.age < o.age) {
            return -1;
        }else {
            return 0;
        }
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
如果当前对象应排在参数对象之前 , 返回-1 的数字 ;
如果当前对象应排在参数对象之后 , 返回1   的数字 ;
如果当前对象和参数对象不分先后 , 返回 0;

运行结果：1

 5.1.2构造比较器（Comparator接口法）

实现Comparator接口, 并实现其中的 compare 方法

代码（5-1-2） 

class AgecompareTo implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age-o2.age;
    }
}

返回年龄差

 运行结果：11

5.2对象数组排序

在 sort 方法中会自动调用 compareTo 方法 . compareTo 的参数是 Object , 其实传入的就是 Student 类型的对象 . 然后比较当前对象和参数对象的大小关系( 按分数来算 ).
注意事项 : 对于 sort 方法来说 , 需要传入的数组的每个对象都是 " 可比较 " 的 , 需要具备 compareTo 这样的能力 . 通 过重写 compareTo 方法的方式 , 就可以定义比较规则 .

 

如：我们现在想要排序学生的年龄。 

5.2.1 实现 Comparable 接口,

实现 Comparable 接口, 并重写其中的 compareTo 方法

让我们的 Student 类实现 Comparable 接口, 并实现其中的 compareTo 方法为代码（5-1-1） 

Text代码：

public class Text {
    public static void main(String[] args) {
        Student wang = new Student("wang", 200);
        Student li = new Student("li", 19);
        Student hu = new Student("hu", 11);
        Student[] students ={wang,li,hu};
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));

    }
}

  运行结果：

 5.2.2构造比较器（实现Comparator接口）

实现Comparator接口, 并实现其中的 compare 方法

构造比较器实现Comparator接口, 并实现其中的 compare 方法的代码为代码（5-1-2） 

 Text代码：

public class Text {

    public static void main(String[] args) {
       Student wang = new Student("wang", 200);
        Student li = new Student("li", 19);
        Student hu = new Student("hu", 11);
        Student[] students ={wang,li,hu};
        AgecompareTo agecompareTo = new AgecompareTo();
        Arrays.sort(students,agecompareTo);
        System.out.println(Arrays.toString(students));

  
    }
}

运行结果：

为了进一步加深对接口的理解, 我们可以尝试自己实现一个 sort 方法来完成刚才的排序过程(使用冒泡排序) 
  public static void bsort(Comparable[] comparables){
        for (int i = 0; i < comparables.length - 1; i++) {
            for (int j = 0; j < comparables.length - 1 - i; j++) {
                if(comparables[j].compareTo(comparables[j+1])>0){
                    Comparable tmp=comparables[j];
                    comparables[j]=comparables[j+1];
                    comparables[j+1]=tmp;
                }
            }
        }
    }

6.Clonable 接口和深拷贝

6.1Clonable 接口

Java 中内置了一些很有用的接口 , Clonable 就是其中之一 .
Object 类中存在一个 clone 方法 , 调用这个方法可以创建一个对象的 " 拷贝 ". 但是要想合法调用 clone 方法 , 必须要 先实现 Clonable 接口 , 否则就会抛出 CloneNotSupportedException 异常 . 
class Student
class Student implements Cloneable{
    String name;
    int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;

    }


    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';


    }


    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

Text1
public class Text1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student wang = new Student("wang", 21);
        Student student= (Student) wang.clone();
        System.out.println(student);
    }
    
}

 空接口、标记接口

作用：表示当前类可以被克隆。

6.2 浅拷贝

Cloneable 拷贝出的对象是一份 "浅拷贝"
回答  运行结果： 
Money
class Money {
    public double m = 99.99;
}
改造class Student 
class Student implements Cloneable{
    String name;
    int age;
    Money money=new Money();
    public Student(String name, int age) {
        this.name = name;
        this.age = age;

    }


    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", money=" + money.m +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

改造Text1

public class Text1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student wang = new Student("wang", 21);
        Student student= (Student) wang.clone();
        System.out.println(wang);
        System.out.println(student);
        System.out.println("=======================");
        wang.money.m=100;
        System.out.println(wang);
        System.out.println(student);


    }

}

  运行结果：

如上代码，我们可以看到，通过 clone，我们只是拷贝了Student 对象。但是Student 对象中的Money 对象，并 没有拷贝。通过wang 这个引用修改了 m 的值后，student 这个引用访问 m 的时候，值也发生了改变。这里 就是发生了浅拷贝。

 这是为啥？

6.3深拷贝  

 改造2class Student

class Student implements Cloneable{
    String name;
    int age;
    Money money=new Money();
    public Student(String name, int age) {
        this.name = name;
        this.age = age;

    }


    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", money=" + money.m +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Student tmp=(Student)super.clone();
            tmp.money=(Money) tmp.money.clone();
            return tmp;
    }
}

    改造 Money     

class Money implements Cloneable{
    public double m = 99.99;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

改造2Text1     

public class Text1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student wang = new Student("wang", 21);
        Student student= (Student) wang.clone();
        System.out.println(wang);
        System.out.println(student);
        System.out.println("=======================");
        wang.money.m=100;
        System.out.println(wang);
        System.out.println(student);


    }

}

  运行结果：

       

以上为我个人的小分享，如有问题，欢迎讨论！！！ 

都看到这了，不如关注一下，给个免费的赞 

WH牛
关注
专栏目录
对接口的理解和说明
m0_62055442的博客
05-19 229
Java中的接口是一种特殊的抽象类，它只包含常量和抽象方法的定义，没有任何具体实现,简单而言，接口是多个类的公共规范，是一种引用数据类型。
【Java】集合与顶级接口Collection
weixin_46437504的博客
08-27 564
Java集合类存放于 java.util 包中，是一个用来存放对象的容器。
接口测试——深入理解HTTPS
测试界的彭于晏的博客
09-09 1068
前言 随着网络安全问题越来越被重视，HTTPS协议的使用已经逐渐主流化。目前的主流站点均已使用了HTTPS协议；比如：百度、淘宝、京东等一二线主站都已经迁移到HTTPS服务之上。而作为测试人员来讲，也要需时俱进对HTTPS协议要有一定的了解，这样就可以更好的帮助我们在工作完成任务和排查问题。 HTTP与TCP 首先，在理解HTTPS之前需要了解HTTP。HTTP（Hyper Text Transfer Protocol）是超文本传输协议，是在互联网上广泛使用的一种信息传输方式，通常浏览器与服务器进行通信使用
抽象与接口的区别（个人理解）
Aatroy的博客
11-27 6722
什么是抽象？ 抽象这个概念， 什么是接口？ 两者有什么异同？
一起学JAVA 接口 面向接口开发
程序媛泡泡的博客
05-13 3万+
接口 1 接口的概念 接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。 接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。 除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。 接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口
SATA、mSATA、M.2、M.2（NVMe）、PCIE固态硬盘接口详解
热门推荐
shuai0845的博客
08-03 48万+
固态硬盘 概念 固态驱动器（Solid State Drive），俗称固态硬盘，固态硬盘是用固态电子存储芯片阵列而制成的硬盘，因为台湾英语里把固体电容称之为Solid而得名。SSD由控制单元和存储单元（FLASH芯片、DRAM芯片）组成。固态硬盘在接口的规范和定义、功能及使用方法上与普通硬盘的完全相同，在产品外形和尺寸上也完全与普通硬盘一致。被广泛应用于军事、车载、工控、视频监控、网络监控、网...
Java 抽象类和接口，看这一篇就够了
沉默王二
12-21 7214
尽管接口使得抽象更进一步，但任何抽象性都应该根据真正的需求而产生，因此恰当的原则是优先选择类而不是接口，只有在真正需要接口的时候再重构代码。
instanceof java 接口_【Java】instanceof在类实现接口中的使用
weixin_29144945的博客
02-13 894
最近刚开始学习java里的多态，老师提到了instanceof，后来讲到在接口的实现时，有些地方就不太理解了，先mark下，等以后学的深了在回顾下。instanceof是在使用多态时避免出现classcastException异常的一种手段，使用方式为1 boolean result = obj instanceof Class；其中，obj指的是对象，class为类或者接口，该表达式的含义为：...
java8四大核心函数式接口讲解&源码实战，通俗易懂
wwwwwww31311的博客
01-27 1805
一、消费者接口 经典案例代码，怎么样，懵逼不？ @Test public void test1 () { consumerTest(500, (x) -> System.out.println(x)); } public void consumerTest (double money, Consumer<Double> c) { c.accept(money); } 那么，看一下小编自己的消费者接口模拟实现，为了使大家能够深入理解，我们都会将一个函数式接口
抽象类和接口
xpy2428507302的博客
04-07 1924
接口就是一种规则，是对行为的抽象①接口用interface关键字定义② 接口和类是实现关系，通过implemens关键字表示③接口不能实例化④接口的子类（实现类），要么重写接口中所有的抽象方法，要么是抽象类⑤接口和类实现关系，可以是单实现，也可以是多实现⑥实现类可以在继承一个类的同时实现多个接口。
API枚举顶级窗口.rar
04-04
在IT领域，API（应用程序编程接口）是操作系统或软件服务提供给开发者用于构建应用程序的一组预定义函数、过程和协议。API枚举顶级窗口是一种常见的系统API调用，它允许程序获取并处理操作系统中所有顶级窗口的信息...
java中的key接口解析
09-04
这个接口是所有密钥类型的顶级接口，包括对称密钥、非对称密钥（公钥和私钥）等。在进行加密、解密、数字签名和其他安全操作时，`Key`接口扮演着至关重要的角色。 `Key`接口提供了以下几个关键功能： 1. **算法**...
易语言枚举顶级进程
07-16
1. **枚举顶级进程**：这是通过系统调用或API接口遍历并获取所有顶级进程的过程。在易语言中，这通常涉及到调用Windows API函数，如`EnumProcesses`，来获取进程ID列表，然后通过这些ID获取进程的详细信息。 2. **...
易语言API枚举顶级窗口源码
06-06
总的来说，易语言API枚举顶级窗口涉及了操作系统级别的编程技巧，包括窗口管理和API调用，对于希望深入理解和控制Windows系统的易语言开发者来说是一项重要的技能。通过学习和实践这个主题，开发者可以提高自己的...
子接口及其实现类PPT实用.pptx
11-02
在Java编程语言中，集合框架是处理对象组的重要工具，其中`Collection`接口是所有集合类的顶级接口。本节将深入探讨`Collection`接口及其常用的子接口与实现类。 首先，`Collection`接口概述：它是Java集合框架的根...
工厂模式的介绍及实现
户伟伟的博客
09-25 114
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Spring Boot 学习和使用
cesske的博客
09-24 1080
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 403
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 897
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
Java接口深入理解：继承、实现与应用
3. 一个接口文件中可以声明多个接口，但只有一个公开的顶级接口。 4. 继承接口的子接口仍然是抽象类，必须由具体的类来实现其所有方法。 5. 类可以实现多个接口，但只能继承一个父类。 整个Java课程体系覆盖了从...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值