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