图片问题晚些时候修复

Ⅰ.接口的使用

接口可以将其理解为是作为一种定义类的规则

一.使用场景

例如:兔子,青蛙,狗。

  • 姓名,年龄,吃。是全部类都适用的,可以直接写在父类,做抽象类
  • 但其中青蛙和狗是会游泳的,而兔子不会。这个时候就不能写在父类了,要做成游泳接口。

  • 所以子类都能用,只是具体的不同,用抽象类。写在父类。(动物)
  • 部分子类能用,用接口。另起一个Interface。(游泳)

二.接口(父类)

1.接口定义格式

idea创建文件时的注意下

不要选class,要选Interface。(也可以直接在文件内将class改成Interface)

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

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

2.接口的要求

  • 接口用关键字Interface来定义

    public Interface 接口名 {}

  • 接口不能实例化

    不能用以创建对象

3.例子

假如我们定义一个运动员的接口(规范),代码如下:

抽象方法前面默认是有public abstract的,即使不添加也会自动添加
/**
   接口:接口体现的是规范。
 * */
public interface SportMan {
   void run(); // 抽象方法,跑步。(public abstract可省)
   public abstract void law(); // 抽象方法,遵守法律。
   public abstract String compittion(String project);  // 抽象方法,比赛。
}

三.实现接口(子类)

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

1.实现接口的格式

  • 接口是可以被多实现的
  • 实现类调用接口方法,接口方法必须在实现类重写。
/**接口的实现:
    在Java中接口是被实现的,实现接口的类称为实现类。
    实现类的格式:*/
class 类名 implements 接口1,接口2,接口3...{

}

2.类实现接口的要求和意义

  1. 必须重写实现的全部接口中所有抽象方法。
  2. 如果一个类实现了接口,但是没有重写完全部接口的全部抽象方法,这个类也必须定义成抽象类。
  3. 接口和类的实现关系,可以单实现,也可以多实现。
    public class 类名 implements 接口名1, 接口名2 {}

    4.实现类还可以继承一个类的同时实现多个接口
    public class 类名 extends 父类 implements 接口名1, 接口名2 {}

  4. 意义:接口体现的是一种规范,接口对实现类是一种强制性的约束,要么全部完成接口申明的功能,要么自己也定义成抽象类。这正是一种强制性的规范。

3.例子

接上面,定义一个乒乓球运动员类,实现接口,实现接口的实现类代码如下:

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 static final

final修饰:接口是规则,里面的数据都是常量,用final修饰使变量变常量,使其不能改变。

static修饰:为了方便调用

public修饰:使哪里有可以调用

二.构造方法

  • 没有,都是常量,用不着get和set.

三.成员方法

  • 只能是抽象方法
  • 默认修饰符:public abstract(见上图)
  • JDK7以前:接口中只能定义抽象方法

Ⅲ.接口和类之间的关系

一.类和类的关系

继承关系,只能单继承,不能多继承,但是可以多层继承

二.类和接口的关系

tip:如果接口有多个重名变量,我们只需重写一次,这代表着重写了所有重名方法。

实现关系,可以单实现,也可以多实现,可以在继承一个类的同时实现多个接口(接口内的方法都要重写)

1.类与接口的多实现案例

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

首先我们先定义两个接口,代码如下:

/** 法律规范:接口*/
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("训练跑步!");
    }
}

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

三.接口和接口的关系

tip:如果实现类实现了最下面的接口,那么就需要重写所有的抽象方法

继承关系,可以单继承,也可以多继承


Ⅳ.接口中的默认方法(JDK8)

为了接口升级

一.定义格式:

public default 返回值类型 方法名(参数列表) {}

二.注意事项

  • 默认方法不是抽象方法(由default修饰),内由方法体,不强制重写即可调用,重写的时候需要去掉default关键字

    public default void show(){
        System.out.println("hello");
    }
  • public可以省略,default不能省略

    省略会被当成抽象类

  • 如果实现了多个接口,多个接口中存在相同名字的默认方法,子类就必须对该方法进行重写。

    如果不重写,对象调用时就不知道是哪个了。

Ⅴ.接口中的静态方法(JDK8)

为了接口升级

一.定义格式

public static 返回值类型 方法名(参数列表){}

例子:

interface Inter {
    public static void show(){
        sout("hello")
    }
}

二.调用

Inter.show();//hello

三.注意事项

  • 静态方法只能通过接口名调用,不能通过实现类名或者对象名进行调用
  • 接口中的静态方法不需要也不能重写(都不进虚方法表,自然没有重写覆盖一说),直接用就好。
  • public可以省略,static不能省略

Ⅵ.接口中的私有方法(JDK9)

为了解决上面的方法抽取共同体限制外界访问的问题的

一.定义格式:

普通私有为默认服务:

private 返回值类型 方法名(参数列表){ }

范例:private void show(){}

静态私有为静态服务:

private static 返回值类型 方法名(参数列表){ }

范例:private static void show(){}

Ⅶ.接口的应用

规定Javabean的行为规范,是行为的抽象。想要让哪个类拥有一个行为,就让这个类实现对应的接口就可以了。

一.接口的多态

遵循编译看左边运行看右边的原则

用接口作为方法的形参数据类型时,就会形成接口的多态,可以传递接口的所有实现类的对象。。

Ⅷ.适配器设计模式

设计模式是一套被反复使用、多数人知晓的,经过分类编目的、代码设计经验的总结。使用 设计模式是为了可重用代码,让代码更容易被人理解、保证代码可靠性、程序的重用性。(设计模式就是各种套路)

应用场景:当一个接口中的抽象方法过多,但是只需要用到其中的一部分时,就可以用适配的设计模式了

书写步骤:

为了避免其它类创建适配器的对象(无意义),中间适配器类用abstract进行修饰。
  • 编写中间类xxxAdapter,实现对应接口
  • 对接口中的抽象方法进行空实现(空着不写)
  • 让真正的实现类继承中间类(适配器),并重写需要用到的方法

例子:

接口:

public interface Inter {
    public abstract void method1();
    public abstract void method2();
    public abstract void method3();
    public abstract void method4();
    public abstract void method5();
    public abstract void method6();
    public abstract void method7();
    public abstract void method8();
    public abstract void method9();
    public abstract void method10();
}

中间类:

用中间类对接口内的所有抽象类进行空实现(并为中间类赋予abstract避免外部创建对象)

public abstract class InterAdapter implements Inter{

    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }

    @Override
    public void method3() {

    }

    @Override
    public void method4() {

    }

    @Override
    public void method5() {

    }
}

真正的实现类:

如果子类需要继承父类,可以将父类放到中间类去继承,这样就能形成间接继承,从而满足需求了。

只需要重写需要的类即可啦

public class InterImpl extends InterAdapter{
  //我需要用到那个方法,就重写哪个方法就可以了

    @Override
    public void method5() {
        System.out.println("只要用第五个方法");
    }
}
最后修改:2023 年 11 月 28 日
如果觉得我的文章对你有用,请随意赞赏