接口相关基础内容及注意事项

实现关系。可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口（在实现类当中，如果实现多个接口的话，那么要把所有的抽象方法全部重写才可以）（多个接口有重名的方法时，我们只需要重写一次就可以了，既表示重写了Inter1中的method1方法，又表示重写了Inter2里面的method1方法）

3、接口和接口之间的关系

继承关系。既可以单继承也可以多继承（如果实现类实现了下面的子接口的时候，就需要重写这个体系中所有的抽象方法）

三、JDK8开始接口中新增的方法

JDK7以前：接口只能定义抽象方法

JDK8的新特性：接口中可以定义有方法体的方法（分为默认方法和用static静态修饰的静态方法）

JDK9的新特性：接口中可以定义private修饰的私有方法

1、JDK8以后新增的默认方法

允许在接口中定义默认方法，需要使用关键字default修饰

作用：解决接口升级问题

接口中默认方法的定义格式：

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

eg.

public default void show(){......}

接口中默认方法的注意事项

1、默认方法不是抽象方法，所以不强制被重写，重写的时候去掉default关键字

2、public可以省略，default不能省略（省略的话，Java会默认为抽象方法）

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

2、JDK8以后接口当中新增的静态方法

允许在接口中定义静态方法，需要用static修饰

接口中静态方法的定义格式：

格式：public static 返回值类型方法名（参数列表）{......}

eg.

public static void show(){......}

接口中静态方法的注意事项

1、静态方法接口可以通过接口名调用，不能通过实现类名或者对象名调用

2、public可以省略，static不能省略（理由同上）

3、JDK9新增的私有方法

接口中私有方法的定义格式：

格式1：private 返回值类型方法名（参数列表）{.......}

eg.

private void show(){......}
//给默认方法（abstract）服务的

格式2：private static 返回值类型方法名（参数列表）{......}

eg.

private static void method(){......}
//为静态方法服务的

四、接口的应用

1、把多个类都有可能用到的规则去定义为接口。对于实现类来讲，如果想要实现类拥有什么功能，那就实现对应的接口

2、在一个方法中，参数写成了接口

eg.

public interface 运输{
    ......
}
public void 搬家(运输的接口 c){
    ......
}

那么我们在调用这个接口的时候就传递这个接口所有的实现类对象。这个就叫接口的多态。当传递过来后就实现了：

接口类型 j = new 实现类对象()；

在运行的时候也会执行编译看左边，运行看右边的原则

五、适配器设计模式

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

简单理解：设计模式就是各种套路

适配器设计模式：解决接口对接口实现类之间的矛盾问题

1、当接口抽象对象过多，但只需要其中的一部分的时候，就可以用适配器设计模式

2、书写步骤：

编写中间类：接口名Adapter，表示中间适配器，用它实现对应的接口，对接口中抽象方法进行空实现（即方法体空着不写）让真正的实现类继承中间类，并重写需要的方法。为了避免其他类创建适配器类的对象，中间的适配器类用abstract进行修饰

课后习题及答案

题目：编写标准的JavaBean类

我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。为了出国交流，跟乒乓球相关的人员都需要学习英语请用所有知识分析，在这个案例中，哪些是具体类，哪些是抽象类，哪些是接口?
乒乓球运动员:姓名，年龄，学打乒乓球，说英语
篮球运动员:姓名，年龄，学打篮球
乒乓球教练:姓名，年龄，教打乒乓球，说英语
篮球教练:姓名，年龄，教打篮球

代码如下：先创建父类Person

//因为现在我不想让外界去直接创建人的对象
//因为直接创建顶层父类“人”的对象此时是没有意义的
//所以就把它写为抽象类
public abstract class Person {
    private String name;
    private int age;
    public Person() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

再创建Person的两个字类Spoter（运动员）和Coach（教练）

运动员的代码如下：

public abstract class Sporter extends Person{
    public Sporter() {
    }

    public Sporter(String name, int age) {
        super(name, age);
    }

    //写成抽象的是因为下面的运动员学的内容不一样，需要重写
    public abstract void study();
}

教练代码如下：

public abstract class Coach extends Person{
    public Coach() {
    }

    public Coach(String name, int age) {
        super(name, age);
    }

    public abstract void teach();
}

跟乒乓其相关的会说英语，我们写一个接口，接口名叫做English，让乒乓球教练和运动员去实现它。代码如下：

public abstract class Coach extends Person{
    public Coach() {
    }

    public Coach(String name, int age) {
        super(name, age);
    }

    public abstract void teach();
}

运动员的子类有乒乓球运动员和篮球运动员

我们分别写这两个字类，代码如下：

乒乓球运动员：

public class PingpangSporter extends Sporter implements English{
    public PingpangSporter() {
    }

    public PingpangSporter(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员在学习如何打乒乓球");
    }

    @Override
    public void speakEnglish() {
        System.out.println("乒乓球运动员在说英语");
    }
}

篮球运动员代码如下：

public class Basketballer extends Sporter{
    public Basketballer() {
    }

    public Basketballer(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("篮球运动员在学习如何打篮球");
    }
}

教练的子类分别是乒乓球教练和篮球教练，代码如下：

乒乓球教练：

public class TeachPingpang extends Coach implements English{
    public TeachPingpang() {
    }

    public TeachPingpang(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("乒乓球教练在教乒乓球运动员打乒乓球");
    }

    @Override
    public void speakEnglish() {
        System.out.println("乒乓球教练在说英语");
    }
}

篮球教练代码如下：

public class TeachBasketball extends Coach{
    public TeachBasketball() {
    }

    public TeachBasketball(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("篮球教练在教蓝球运动员打篮球");
    }
}

接下来我们写一个测试类来运行一下

public class Test {
    public static void main(String[] args) {
        //创建运动员和教练的对象
        PingpangSporter pps = new PingpangSporter("刘诗雯", 23);
        System.out.println("乒乓球运动员： " + pps.getName() + "," + pps.getAge());
        pps.study();
        pps.speakEnglish();

        Basketballer be = new Basketballer("张三" , 23);
        System.out.println("篮球运动员： " + be.getName() + "," + be.getAge());
        be.study();

        TeachPingpang tpp = new TeachPingpang("lisi", 40);
        System.out.println("乒乓球教练： " + tpp.getName() + "," + tpp.getAge());
        tpp.teach();
        tpp.speakEnglish();

        TeachBasketball tbb = new TeachBasketball("王五",35);
        System.out.println("篮球教练： " + tbb.getName() + "," + tbb.getAge());
        tbb.teach();
    }
}

运行结果如下：

以上就是咱们这次作业的步骤啦。接口的入门内容暂时就是这些。下期见

下雨摸鱼休息

关注

32
点赞
踩
19

收藏

觉得还不错? 一键收藏
3
评论
接口相关基础内容及注意事项

可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口（在实现类当中，如果实现多个接口的话，那么要把所有的抽象方法全部重写才可以）（多个接口有重名的方法时，我们只需要重写一次就可以了，既表示重写了Inter1中的method1方法，又表示重写了Inter2里面的method1方法）编写中间类：接口名Adapter，表示中间适配器，用它实现对应的接口，对接口中抽象方法进行空实现（即方法体空着不写）让真正的实现类继承中间类，并重写需要的方法。static：为了方便调用，用接口名.常量的名称就可以了。
复制链接

扫一扫