接口、Lambda、内部类总结

接口

Java接口是一个抽象的模板，定义了一组方法，但没有实现。它们用于表示类所支持的操作，并允许不同的类实现这些操作以不同的方式。使用关键字“interface”来定义接口。类可以通过实现接口来实现多态性。

在接口中所有方法都会自动添加public abstract前缀

接口中常量自动添加public final static 前缀 java 8 版本之后，接口提供了默认方法带有default关键字的方法以及静态方法，不过静态方法违背java接口的设计初衷

Java 接口的设计初衷是为了实现代码复用和解耦，将接口定义与具体实现分开，使得不同模块之间可以相互调用，降低了代码的耦合度，提高了系统的可扩展性、灵活性和可维护性。而静态方法可能使接口与实现耦合，从而导致接口变成一种与某种实现的具体工具类

Java 接口冲突解决方式

1. 超类优先
2. 接口冲突必须覆盖方法来解决

Email类实现了InfoInterface和MessageInterface接口，并且都定义了getMessage()方法

public interface InfoInterface {

    String getMessage();
}

public interface MessageInterface {
    default String getMessage() {
        return "defaultMessageInterface";
    }

//     static String getMessage() {
//         return "staticMessageInterface";
//    }
}

public class Email implements InfoInterface, MessageInterface {

    public static void main(String[] args) {
        Email email = new Email();
        System.out.println(email.getMessage());
    }
}

在MessageInterface接口虽然是默认方法，但是还是存在接口冲突，所以还是覆盖方法来解决的冲突，有意思的是，如果MessageInterface接口中方法是静态方法，那么在IDEA中不会提示错误，而是运行main 方法提示没有覆盖getMessage方法，InfoInterface中的getMessasge方法没有实现。

public abstract class AbstractBaseEmail{
    public String getMessage() {
        return "AbstractBaseEmail";
    }
}

public class Email extends AbstractBaseEmail implements InfoInterface, MessageInterface {


    public static void main(String[] args) {
        Email email = new Email();
        System.out.println(email.getMessage());
    }
}

由于Email类继承了AbstractBaseEmail，就算MessageInterface是静态方法，根据超类优先规则，所以这里无视InfoInterface中的getMessasge方法。

Lambda

lambda表达式是一个可传递的代码块，可以在以后执行一次或多次

• 一个代码块
• 参数
• 自由的变量的值，指非参数而且不在代码定义的变量

函数式接口：只有一个抽象方法的接口 ，可以使用@FunctionalInterface注解表明这是只有一个方法的接口

public class Email extends AbstractBaseEmail implements InfoInterface, MessageInterface {

    public static void main(String[] args) {
        Email email = new Email();
        System.out.println(email.getMessage());
        InfoInterface infoInterface1 = new InfoInterface() {
            @Override
            public String getMessage() {
                return "origin way";
            }
        };
        InfoInterface infoInterface = () -> "Lambda way";
    }
}

可以看出lambda可以简化代码，提升开发效率

内部类

内部类是定义在另一个类中的类，可以访问包含它们的外部类的所有成员和方法。它可以被用于实现一些特定的设计模式,如JUC相关的ReentrantLock类等使用内部类的设计

内部类可以分为4种：

• 局部内部类：在类中的方法中实现一个接口或者继承一个类并为其命名的类。
• 匿名内部类：在类中的方法中实现一个接口或者new 抽象类并实现抽象方法的类。
• 静态内部类：把一个类隐藏在另外一个类的内部而不需要有外围对象的一个引用。
• 成员内部类：可以访问外部类的私有成员或属性的类。

public class OuterClass {
    private String name;
    private Integer age;

    public OuterClass(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public static OuterClass of(String name, Integer age) {
        return new OuterClass(name, age);
    }

    /**
     * 公开的成员内部类可以这种方式来暴露给其他类使用
     *
     * @return 返回成员内部类
     */
    public InnerClass innerClass() {
        return new InnerClass("innerClass");
    }

    public void start() {
        System.out.println("outer:" + name);
        System.out.println("outer:" + age);
        InnerClass innerClass = new InnerClass("innerClass");
        System.out.println("outer:" + innerClass.innerName);
        innerClass.innerMethod();
    }

    /**
     * 测试局部类
     */
    public void local() {
        class PlusFunctionImpl implements IPlusFunction {
            @Override
            public int plus(int x, int y) {
                return x + y + age;
            }
        }
        IPlusFunction plusFunction = new PlusFunctionImpl();
        System.out.println("local: " + plusFunction.plus(12, 43));
        class AbstractOuterSubClass extends AbstractOuterClass {
            public AbstractOuterSubClass(String abstractName) {
                super(abstractName);
            }

            @Override
            protected void implPrint(String str) {
                System.out.println("实现implPrint方法：" + str + (age * 2));
            }
        }
        AbstractOuterClass outerSubClass = new AbstractOuterSubClass("localInnerClass");
        outerSubClass.implPrint("local");
    }

    /**
     * 测试内部类
     */
    public void anonymous() {
        // 实现接口
        IPlusFunction plusFunction = Integer::sum;
        System.out.println("anonymous："+plusFunction.plus(age, 14));
        // 抽象类
        AbstractOuterClass abstractOuterClass = new AbstractOuterClass("name") {

            @Override
            protected void implPrint(String str) {
                System.out.println("anonymous实现implPrint方法：" + str + getAbstractName());
            }

        };
        abstractOuterClass.implPrint(name);
    }
    
    public class InnerClass {
        private final String innerName;

        public InnerClass innerClass() {
            return this;
        }

        public InnerClass(String innerClass) {
            this.innerName = innerClass;
        }

        public void innerMethod() {
            System.out.println("inner:" + innerName);
            System.out.println("inner:" + name);
            System.out.println("inner:" + age);
        }

    }

    /**
     * 静态内部类
     */
    public static class StaticInnerClass {
        private String staticString;

        public static StaticInnerClass of(String param) {
            StaticInnerClass staticInnerClass = new StaticInnerClass();
            staticInnerClass.staticString = param;
            return staticInnerClass;
        }

        public void print() {
            System.out.println("staticClass: " + staticString);
        }
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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


    public abstract static class AbstractOuterClass {
        private String abstractName;

        public AbstractOuterClass(String abstractName) {
            this.abstractName = abstractName;
        }

        public String getAbstractName() {
            return abstractName;
        }

        public void setAbstractName(String abstractName) {
            this.abstractName = abstractName;
        }

        protected abstract void implPrint(String string);
    }

    @FunctionalInterface
    public interface IPlusFunction {
        int plus(int x, int y);
    }
}

public class Main {
    public static void main(String[] args) {
        OuterClass outerClass = OuterClass.of("xxx", 23);

        outerClass.start();
        outerClass.local();
        outerClass.anonymous();
        OuterClass.StaticInnerClass staticInnerClass = OuterClass.StaticInnerClass.of("param");
        staticInnerClass.print();
        // 如果需要对象需要设置为static
//        OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
        // 或者使用outerClass 公共方法暴露InnerClass类
        OuterClass.InnerClass innerClass = outerClass.innerClass();
        innerClass.innerMethod();
    }
}

参考文档

《Java核心技术 卷Ⅰ》