接口、Lambda、内部类总结

接口

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

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

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

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

Java 接口冲突解决方式

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

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

java

复制代码

public interface InfoInterface { String getMessage(); }

java

复制代码

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

java

复制代码

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方法没有实现。

java

复制代码

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

java

复制代码

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注解表明这是只有一个方法的接口

java

复制代码

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 抽象类并实现抽象方法的类。
• 静态内部类：把一个类隐藏在另外一个类的内部而不需要有外围对象的一个引用。
• 成员内部类：可以访问外部类的私有成员或属性的类。

java

复制代码

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); } }

java

复制代码

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核心技术 卷Ⅰ》