Java--接口--JDK8新特性/匿名内部类--使用/教程/实例

谁借莪１个温暖的怀抱￠ 2022-08-28 03:45 10阅读 0赞

原文网址：[Java--接口--JDK8新特性/匿名内部类--使用/教程/实例\_IT利刃出鞘的博客-CSDN博客][Java--_--JDK8_--_IT_-CSDN]

# 简介 #

本文介绍Java的接口知识。包括：JDK8新特性（default、static），匿名内部类。

# jdk8的接口新特性 #

## default ##

**简介**

JDK1.8增加default方法。

接口内部包含了一些默认的方法实现（也就是接口中可以包含方法体，这打破了Java之前版本对接口的语法限制） 。之前的接口是个双刃剑，好处是面向抽象而不是面向具体编程，缺陷是，当需要修改接口时候，需要修改全部实现该接口的类。

default使得开发者可以在不破坏二进制兼容性的前提下，往现存接口中添加新的方法，即不强制那些实现了该接口的类也同时实现这个新加的方法。

二进制兼容性：指的就是在升级（也可能是 bug fix）库文件的时候，不必重新编译使用这个库的可执行文件或使用这个库的其他库文件，程序的功能不被破坏。

实际开发中应该谨慎使用：在复杂的继承体系中，默认方法可能引起歧义和编译错误。

**实例**

package com.example;
    
    interface MyInterface{
        default void sayHello(){
            System.out.println("sayHello");
        }
    }
    
    class MyInterfaceImpl implements MyInterface{
    
        public void test(){
            MyInterface myInterface = new MyInterfaceImpl();
            myInterface.sayHello();
        }
    }
    
    public class Demo {
        public static void main(String[] args) {
            MyInterfaceImpl impl = new MyInterfaceImpl();
            impl.test();
        }
    }

**运行结果**

sayHello

注意：如果两个接口都用default修饰同一方法，则会报错

package com.example;
    
    interface MyInterface1{
        default void sayHello(){
            System.out.println("sayHello(1)");
        }
    }
    
    interface MyInterface2{
        default void sayHello(){
            System.out.println("sayHello(2)");
        }
    }
    
    class MyInterfaceImpl implements MyInterface1,MyInterface2{
        public void test(){
            MyInterface1 myInterface = new MyInterfaceImpl();
            myInterface.sayHello();
        }
    }
    
    public class Demo {
        public static void main(String[] args) {
            MyInterfaceImpl impl = new MyInterfaceImpl();
            impl.test();
        }
    }

![20200602105049969.png][]

解决办法：在实现类中重写该方法。

package com.example;
    
    interface MyInterface1{
        default void sayHello(){
            System.out.println("sayHello(1)");
        }
    }
    
    interface MyInterface2{
        default void sayHello(){
            System.out.println("sayHello(2)");
        }
    }
    
    class MyInterfaceImpl implements MyInterface1,MyInterface2{
        public void test(){
            MyInterface1 myInterface = new MyInterfaceImpl();
            myInterface.sayHello();
        }
    
        @Override
        public void sayHello() {
            System.out.println("sayHello(Impl)");
        }
    }
    
    public class Demo {
        public static void main(String[] args) {
            MyInterfaceImpl impl = new MyInterfaceImpl();
            impl.test();
        }
    }

运行结果

sayHello(Impl)

## static ##

JDK1.8新增了static函数。static修饰的方法也是非抽象方法，有自己的方法体，在接口中定义一个静态方法，该方法可以直接用< 接口名.方法名() >的形式来调用。相当于调用类的静态方法一样

package com.example;
    
    interface MyInterface{
        static void sayHello(){
            System.out.println("sayHello");
        }
    }
    
    public class Demo {
        public static void main(String[] args) {
            MyInterface.sayHello();
        }
    }

运行结果

sayHello

# 接口与匿名内部类 #

package org.example.a;
    
    interface MyInterface<A, B>{
        public void test1(String str, A a);
        public void test2(B b);
    }
    
    class MyInterfaceImpl1<A, B> implements MyInterface<A, B> {
        @Override
        public void test1(String str, A a) {
            System.out.println("MyInterfaceImpl1 test1: " + str + a);
        }
    
        @Override
        public void test2(B b) {
            System.out.println("MyInterfaceImpl1 test2: " + b);
        }
    }
    
    class MyInterfaceImpl2 implements MyInterface<Integer, String> {
        @Override
        public void test1(String str, Integer a) {
            System.out.println("MyInterfaceImpl2 test1: " + str + a);
        }
    
        @Override
        public void test2(String b) {
            System.out.println("MyInterfaceImpl2 test2: " + b);
        }
    }
    
    public class Demo {
        public static void main(String[] args) {
            //匿名内部类写法
            MyInterface myInterface = new MyInterface<Integer, String>() {
                @Override
                public void test1(String str, Integer integer) {
                    System.out.println("Anonymous test1: " + str + integer);
                }
    
                @Override
                public void test2(String str) {
                    System.out.println("Anonymous test2: " + str);
                }
            };
            myInterface.test1("hello", 3);
            myInterface.test2("world");
    
            MyInterface<Integer, String> myInterface1 = new MyInterfaceImpl1<>();
            myInterface1.test1("hi", 4);
            myInterface1.test2("Tony");
    
            MyInterface myInterface2 = new MyInterfaceImpl2();
            myInterface2.test1("hhh", 5);
            myInterface2.test2("Stark");
        }
    }

运行结果

Anonymous test1: hello3
    Anonymous test2: world
    MyInterfaceImpl1 test1: hi4
    MyInterfaceImpl1 test2: Tony
    MyInterfaceImpl2 test1: hhh5
    MyInterfaceImpl2 test2: Stark

# **其他网址** #

[jdk1.8新特性之default关键字 - lcnb - 博客园][jdk1.8_default_ - lcnb -]

[Java--_--JDK8_--_IT_-CSDN]: https://knife.blog.csdn.net/article/details/120930086
[20200602105049969.png]: /images/20220828/55c04e1aa1e045d78f0f14667d7c0b75.png
[jdk1.8_default_ - lcnb -]: https://www.cnblogs.com/lc4j/p/11069172.html