从“追求尽量不出错”，到正视“出错是必然”|
收藏闪存小组博问

如此而已~~~

园龄：3年3个月粉丝：0关注：12

26_Java的接口组成更新

Java的接口组成更新

一、接口组成更新概述

回忆接口组成：

​ 常量：public static final 默认写好

​ 抽象方法：public abstract 默认写好

在Java8之后加入了

​ 默认方法

​ 静态方法

在Java9后加入了

​ 私有方法

二、接口中的默认方法

​ 接口并非不变，当往已经存在的接口中添加一个新的抽象方法时，所有的实现类都需要进行重写此方法。但是又可能不是所有的实现类都需要这个方法，所以我们使用了一个子接口继承这个接口的同时，将需要新的抽象方法的实现类，转换实现这个子接口。但是如此也有诸多弊端，所以添加了默认方法。

​ 默认方法无需强制重写，在接口中可以有方法体。需要的实现类可以自定重写或者调用。

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

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

​ 范例：public default void show(){}

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

​ 默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写时去掉default关键字

​ 接口中的public可进行省略，默认方法默认使用public修饰符

参考代码：

package com.itheima_01;
//接口
public interface MyInterface {
    void show1();
    void show2();
 
    //为了适应需求，添加了一些新特性
    //添加一个抽象方法后，所有的实现类都需要进行重写此方法
    //void show3();
 
    //1、重写一个子接口，让需要的实现类实现这个子接口
 
    //2、使用接口中的默认方法来解决此类问题，同时这个默认的方法可以进行重写
    //同之前的重写方法，（default）修饰符不用再写了
    public default void show3(){
        System.out.println("show3");
    }
}
package com.itheima_01;
//实现类一
public class MyInterfaceImplOne implements MyInterface{
    @Override
    public void show1() {
        System.out.println("One show1");
    }
 
    @Override
    public void show2() {
        System.out.println("One show2");
    }
 
    @Override
    public void show3(){
        System.out.println("One show3");
    }
}
package com.itheima_01;
//实现类二
public class MyInterfaceImplTwo implements MyInterface{
    @Override
    public void show1() {
        System.out.println("Two show1");
    }
 
    @Override
    public void show2() {
        System.out.println("Two show2");
    }
}
package com.itheima_01;
/*
	测试类
    需求：
        1、定义一个接口MyInterface，里面有两个抽象方法：
            void show1();
            void show2();
        2、定义接口的两个实现类：
            MyInterfaceImplOne
            MyInterfaceImplTwo
        3、定义测试类
            MyInterfaceDemo
            在主方法中，按照多态的方式创建对象并使用
 */
public class MyInterfaceDemo {
    public static void main(String[] args) {
        //按照多态的方式创建对象并使用
        MyInterface my = new MyInterfaceImplOne();
        my.show1();
        my.show2();
 
        //输出实现类二的重写内容
        /*my = new MyInterfaceImplTwo();
        my.show1();
        my.show2();*/
 
        my.show3();
    }
}

三、接口中的静态方法

接口中静态方法的定义格式（与类中的定义格式相同）：

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

​ 范例：public static void show(){ }

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

​ 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用

​ public可以省略，static不能省略

参考代码：

package com.itheima_02;
/*
    接口1
 */
public interface Inter {
    void show();
 
    default void method(){
        System.out.println("Inter中的默认方法执行了");
    }
 
    public static void test(){  //其中的public也是可以省略的
        System.out.println("Inter中的静态方法执行了");
    }
}
package com.itheima_02;
/*
	接口2
*/
public interface Flyable {
    public static void test(){
        System.out.println("Flyable 中的静态方法执行了");
    }
}
package com.itheima_02;
//实现类
public class InterImpl implements Inter, Flyable{
    @Override
    public void show(){
        System.out.println("show方法执行了");
    }
}
package com.itheima_02;
/*
    需求：
        定义一个接口Inter，里面有三个方法：抽象方法、默认方法、静态方法
            void show();
            default void method(){}
            public static void test(){}
        定义一个接口的实现类：
            InterImpl
        定义一个测试类
            InterDemo
            在主方法中，按照多态的方式创建对象并使用
 */
 
public class InterDemo {
    public static void main(String[] args) {
        //按照多态的方式创建对象并使用
        Inter i = new InterImpl();
        i.show();
        i.method();
 
        /*
            接口是可以实现多继承的，如果使用接口对象或者其实现类名可以对接口中的静态方法进行调用
            那么就会出现作用域的二义性，如当此实现类实现两个接口且其中含同名静态方法是就会无法分辨
            而使用接口名来调用静态方法：不仅符合静态方法的共享性，而且指明了作用域（即是此接口下的此静态方法）
        */
//        i.test(); //由于静态方法的共享性，只能被接口类调用，而不是其通过多态而实例化的对象
//        InterImpl.test();   //同时也不能够使用接口中的实现类来调用
        Inter.test();
 
        Flyable.test();
    }
}

四、接口中私有方法

​ Java9新增了带方法体的私有方法，在Java8中其实就已经埋下了伏笔：Java8允许在接口中定义带方法体的默认方法和静态方法，这样可能就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时（即可以将其提取出来写一个方法），程序必然会考虑将这段代码抽取成一个共性的方法，二这个共性的方法是不需要让别人来使用的，因此用私有给隐藏起来，这就是Java9增加私有方法的必然性。

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

​ 格式1： private 返回值类型 方法名(参数列表){ }

​ 范例1： private void show() { }

为了提供给静态方法进行使用：

​ 格式2： private static 返回值类型 方法名(参数列表){} 与类中的私有静态方法的定义一样

​ 范例2： private static void method() { }

接口中私有方法的注意事项：

​ 默认方法可以调用私有方法中的静态方法和非静态方法

​ 静态方法只能调用私有的静态方法

参考代码：

package com.itheima_03;
/*
    接口
 */
public interface Inter {
    default void show1(){
        System.out.println("show1开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
 
//        this.show();
        Inter.method();
        System.out.println("show1结束执行");
    }
 
    default void show2(){
        System.out.println("show2开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
 
//        this.show();
        Inter.method();
        System.out.println("show2结束执行");
    }
 
    //定义一个私有方法来实现重复代码的操作
    private void show(){
        System.out.println("初级工程师");
        System.out.println("中级工程师");
        System.out.println("高级工程师");
    }
 
    static void method1(){
        System.out.println("method1开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
        Inter.method();
        System.out.println("method1结束执行");
    }
 
    static void method2(){
        System.out.println("method2开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
        Inter.method();
        System.out.println("method2结束执行");
    }
 
    //定义一个私有的静态方法实现静态方法中的重复语句
    private static void method(){
        System.out.println("初级工程师");
        System.out.println("中级工程师");
        System.out.println("高级工程师");
    }
}
package com.itheima_03;
/*
    没有抽象方法需要重写，只是用来创建对象
 */
public class InterImpl implements Inter{
}
package com.itheima_03;
/*
    需求：
        定义一个接口Inter，里面有四个方法：两个默认方法，两个静态方法
            default void show1(){}
            default void show2(){}
            static void method1(){}
            static void method2(){}
         定义一个接口的实现类：
            InterImpl
         定义测试类
            InterDemo
            在主方法中，按照多态的方式创建对象并使用
 
 */
public class InterDemo {
    public static void main(String[] args) {
        Inter i = new InterImpl();
        i.show1();
        System.out.println("----------------");
        i.show2();
 
        System.out.println("----------------");
 
        Inter.method1();
        System.out.println("----------------");
        Inter.method2();
    }
}

本文作者：如此而已~~~

本文链接：https://www.cnblogs.com/fragmentary/p/16989044.html

版权声明：本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。

posted @   如此而已~~~  阅读(25)  评论(0)  编辑  收藏  举报
    //雪花飘落效果
    点击右上角即可分享
    微信分享提示
    AI IDE Trae
    评论
    收藏
    关注
    推荐
    深色
    回顶
    收起
    ✽
    ✽
    ✽