java的接口

全干程序元

已于 2024-06-01 10:08:18 修改

阅读量596

点赞数 21

文章标签： java 开发语言

于 2024-06-01 10:07:00 首次发布

本文链接：https://blog.csdn.net/jiayu123321/article/details/139355150

版权

概述

我们已经学完了抽象类，抽象类中可以用抽象方法，也可以有普通方法，构造方法，成员变量等。那么什么是接口呢？接口是更加彻底的抽象，JDK7之前，包括JDK7，接口中全部是抽象方法。接口同样是不能创建对象的。

定义格式

//接口的定义格式：
interface 接口名称{
    // 抽象方法
}

// 接口的声明：interface
// 接口名称：首字母大写，满足“驼峰模式”

接口成分的特点

在JDK7，包括JDK7之前，接口中的只有包含：抽象方法和常量

抽象方法

注意：接口中的抽象方法默认会自动加上public abstract修饰程序员无需自己手写！！按照规范：以后接口中的抽象方法建议不要写上public abstract。因为没有必要啊，默认会加上。

常量

在接口中定义的成员变量默认会加上： public static final修饰。也就是说在接口中定义的成员变量实际上是一个常量。这里是使用public static final修饰后，变量值就不可被修改，并且是静态化的变量可以直接用接口名访问，所以也叫常量。常量必须要给初始值。常量命名规范建议字母全部大写，多个单词用下划线连接。

案例演示

public interface InterF {
    // 抽象方法！
    //    public abstract void run();
    void run();

    //    public abstract String getName();
    String getName();

    //    public abstract int add(int a , int b);
    int add(int a , int b);


    // 它的最终写法是：
    // public static final int AGE = 12 ;
    int AGE  = 12; //常量
    String SCHOOL_NAME = "黑马程序员";

}

基本的实现

实现接口的概述

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

实现接口的格式

/**接口的实现：
    在Java中接口是被实现的，实现接口的类称为实现类。
    实现类的格式:*/
class 类名 implements 接口1,接口2,接口3...{

}

从上面格式可以看出，接口是可以被多实现的。大家可以想一想为什么呢？

类实现接口的要求和意义

必须重写实现的全部接口中所有抽象方法。
如果一个类实现了接口，但是没有重写完全部接口的全部抽象方法，这个类也必须定义成抽象类。
意义：接口体现的是一种规范，接口对实现类是一种强制性的约束，要么全部完成接口申明的功能，要么自己也定义成抽象类。这正是一种强制性的规范

类与接口基本实现案例

假如我们定义一个运动员的接口（规范），代码如下：

/**
   接口：接口体现的是规范。
 * */
public interface SportMan {
    void run(); // 抽象方法，跑步。
    void law(); // 抽象方法，遵守法律。
    String compittion(String project);  // 抽象方法，比赛。
}

接下来定义一个乒乓球运动员类，实现接口，实现接口的实现类代码如下：

package com.itheima._03接口的实现;
/**
 * 接口的实现：
 *    在Java中接口是被实现的，实现接口的类称为实现类。
 *    实现类的格式:
 *      class 类名 implements 接口1,接口2,接口3...{
 *
 *
 *      }
 * */
public class PingPongMan  implements SportMan {
    @Override
    public void run() {
        System.out.println("乒乓球运动员稍微跑一下！！");
    }

    @Override
    public void law() {
        System.out.println("乒乓球运动员守法！");
    }

    @Override
    public String compittion(String project) {
        return "参加"+project+"得金牌！";
    }
}

测试代码：

public class TestMain {
    public static void main(String[] args) {
        // 创建实现类对象。
        PingPongMan zjk = new PingPongMan();
        zjk.run();
        zjk.law();
        System.out.println(zjk.compittion("全球乒乓球比赛"));

    }
}

类与接口的多实现案例

类与接口之间的关系是多实现的，一个类可以同时实现多个接口。

首先我们先定义两个接口，代码如下：

/** 法律规范：接口*/
public interface Law {
    void rule();
}

/** 这一个运动员的规范：接口*/
public interface SportMan {
    void run();
}

然后定义一个实现类：

/**
 * Java中接口是可以被多实现的：
 *    一个类可以实现多个接口: Law, SportMan
 *
 * */
public class JumpMan implements Law ,SportMan {
    @Override
    public void rule() {
        System.out.println("尊长守法");
    }

    @Override
    public void run() {
        System.out.println("训练跑步！");
    }
}

从上面可以看出类与接口之间是可以多实现的，我们可以理解成实现多个规范，这是合理的。

接口与接口的多继承

Java中，接口与接口之间是可以多继承的：也就是一个接口可以同时继承多个接口。大家一定要注意：

类与接口是实现关系

接口与接口是继承关系

接口继承接口就是把其他接口的抽象方法与本接口进行了合并。

案例演示：

public interface Abc {
    void go();
    void test();
}

/** 法律规范：接口*/
public interface Law {
    void rule();
    void test();
}

 *
 *  总结：
 *     接口与类之间是多实现的。
 *     接口与接口之间是多继承的。
 * */
public interface SportMan extends Law , Abc {
    void run();
}

接口的细节

不需要背，只要当idea报错之后，知道如何修改即可。

关于接口的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。

1.当两个接口中存在相同抽象方法的时候，该怎么办？

只要重写一次即可。此时重写的方法，既表示重写1接口的，也表示重写2接口的。

2.实现类能不能继承A类的时候，同时实现其他接口呢？

继承的父类，就好比是亲爸爸一样实现的接口，就好比是干爹一样可以继承一个类的同时，再实现多个接口，只不过，要把接口里面所有的抽象方法，全部实现。

3.实现类能不能继承一个抽象类的时候，同时实现其他接口呢？

实现类可以继承一个抽象类的同时，再实现其他多个接口，只不过要把里面所有的抽象方法全部重写。

4.实现类Zi，实现了一个接口，还继承了一个Fu类(这里就是普通的父类不是抽象类)。假设在接口中有一个方法，父类中也有一个相同的方法。子类如何操作呢？

处理办法一：如果父类中的方法体，能满足当前业务的需求，在子类中可以不用重写。处理办法二：如果父类中的方法体，不能满足当前业务的需求，需要在子类中重写。

5.如果一个接口中，有10个抽象方法，但是我在实现类中，只需要用其中一个，该怎么办?

可以在接口跟实现类中间，新建一个中间类（适配器类）让这个适配器类去实现接口，对接口里面的所有的方法做空重写。让子类继承这个适配器类，想要用到哪个方法，就重写哪个方法。因为中间类没有什么实际的意义，所以一般会把中间类定义为抽象的，不让外界创建对象

接口中新增的三个方法

因为如果要在接口中添加新的方法的话，就需要接口所以的实现类都去添加这个方法，要是别人比较忙不能第一时间添加的话，整个程序就会报错，这样就很不合理了，所以java就在jdk8后新添加了特性。

默认方法

我们用案例来解释：

下面接口中的fangg（）方法就不是必须要重写的，因为它被default修饰了，变成了默认方法，并且default不能省略，不然java会把那个方法让认为是抽象方法

//接口
public interface Jieko {
    void fangf();
    default void fangg() {}
}

//javabean类
public class Test implements Jieko{
    @Override
    public void fangf(){
        System.out.println("fangf");
    }
}

静态方法

这个方法我们也用案例来解释

测试类中直接通过接口类调用静态方法

//测试类
    public static void main(String[] args) {
        Jieko.s();
    }

//接口
public interface Jieko {
    void fangf();
    static void s(){
        System.out.println("我是接口的一个静态方法");
    }
}
//实现类
public class Test implements Jieko{
    @Override
    public void fangf(){
        System.out.println("fangf");
    }
}

私有方法

用来对默认方法或者静态方法的公共部分进行抽取的到一个函数里面降低代码的冗余。

public interface Jieko {
    void fangf();
    default void fangg() {
        log();
    }
    default void fangh() {
        log();
    }
    private void log(){
        System.out.println("私有方法");
    }
}

接口的应用

这个图讲的是接口的多态，只要是接口的实现类就可以用接口类型来接收这些实现类。

适配器

这个概念我也不是很理解，所以我们来看案例把。

我通过案例理解就是先让一个类实现接口，在让一个类当那个实现类的子类重写实现类里面的方法就可以了。

//接口

public interface Jieko {
    void a();
    void b();
    void c();
    void d();
    void e();
    void f();
}

//适配器

public class Test implements Jieko{

    @Override
    public void a() {
        System.out.println("适配器");
    }

    @Override
    public void b() {
        System.out.println("适配器");

    }

    @Override
    public void c() {
        System.out.println("适配器");

    }

    @Override
    public void d() {
        System.out.println("适配器");

    }

    @Override
    public void e() {
        System.out.println("适配器");

    }

    @Override
    public void f() {
        System.out.println("适配器");

    }
}

//适配器的子类

public class Test1 extends Test{
    @Override
    public void a(){
        System.out.println("通过适配器");
    }
}

全干程序元

关注

21
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
java的接口

/接口的定义格式：interface 接口名称{// 抽象方法// 接口的声明：interface// 接口名称：首字母大写，满足“驼峰模式”类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用implements关键字。
复制链接

扫一扫