• 初始Java 8-2 接口和抽象类

    目录

    抽象类和接口

    完全解耦

    组合多个接口

    通过继承扩展接口

    适配接口

    接口中的字段

    嵌套接口

    接口和工厂

    新特性：接口的private方法

    新特性：密封类和密封接口

    本笔记参考自： 《On Java 中文版》

     

    抽象类和接口

            在Java 8添加了默认方法后，如何选择抽象类和接口也成了一个问题。下列表格会将两者进行区分：

    特性接口抽象类
    组合可以在新类中组合多个接口只能继承一个抽象类
    状态不能包含字段（除静态字段，但静态字段无法表示对象状态）可以包含字段，非抽象类可以使用这些字段
    默认方法和抽象方法默认方法不需要在子类型中实现抽象方法必须在子类型中实现
    构造器不能有构造器可以有构造器
    访问权限控制

    方法默认被public static abstract修饰

    常量默认被public static final修饰

    		可以设置，默认是包访问权限

        经验法则告诉我们：在合理的范围内尽可能抽象。当然，除非必要，否则抽象类和接口都还是不用为好，因为常规类已经足够解决问题。

    完全解耦

            一个方法若只存在于常规的类中，那么这个方法只能被这个类及其子类调用。一旦想要让这个方法脱离这一继承层次结构，就会发现这是难以做到的。接口就放宽了这种限制，使得代码可以更加容易被复用。

    1. import java.util.Arrays;
    2.  
    3. class Processor {
    4.     public String name() {
    5.         return getClass().getSimpleName();
    6.     }
    7.  
    8.     public Object process(Object input) {
    9.         return input;
    10.     }
    11. }
    12.  
    13. class Upcase extends Processor {
    14.     @Override
    15.     public String process(Object input) { // 返回类型是协变的
    16.         return ((String) input).toUpperCase();
    17.     }
    18. }
    19.  
    20. class Downcase extends Processor {
    21.     @Override
    22.     public String process(Object input) {
    23.         return ((String) input).toLowerCase();
    24.     }
    25. }
    26.  
    27. class Splitter extends Processor {
    28.     @Override
    29.     public String process(Object input) {
    30.         // split()方法可以分割字符串
    31.         return Arrays.toString(((String) input).split(" "));
    32.     }
    33. }
    34.  
    35. public class Applicator {
    36.     public static void apply(Processor p, Object s) {
    37.         System.out.println("使用方法：" + p.name());
    38.         System.out.println(p.process(s));
    39.         System.out.println();
    40.     }
    41.  
    42.     public static void main(String[] args) {
    43.         String s = "We are Programmer";
    44.         apply(new Upcase(), s);
    45.         apply(new Downcase(), s);
    46.         apply(new Splitter(), s);
    47.     }
    48. }

            程序执行的结果是：

            上述的Applicator.apply()方法可以任何类型的Processor，将接收的类型转型为Object类型，并输出最终结果。像这样，创建一个方法，这个方法可以根据传递的参数对象表现出不同的行为，这就是策略设计模式。

        方法包含了算法的固定部分，而策略包含了算法变化的部分。

            现在，假设有一组更好用的类：

            从上图可以发现，Filter和Processor有相同的接口元素process，但因为Filter没有继承Processor，所有无法将Filter类型的对象传递到Applicator.apply()中进行使用。这种情况下，认为Applicator.apply()与Processor之间的耦合超过了所需的程度。

        在这组新的类中，process()方法的输入和输出参数都是Waveform。

            若Processor是一个接口，因为约束足够宽松，就可以复用参数为Processor接口类型的Applicator.apply()方法了。下面是Processor和Applicator的修改：

    1. package interfaceprocessor;
    2.  
    3. public interface Processor {
    4.     default String name() {
    5.         return getClass().getSimpleName();
    6.     }
    7.  
    8.     Object process(Object input);
    9. }
    1. package interfaceprocessor;
    2.  
    3. public class Applicator {
    4.     public static void apply(Processor p, Object s) {
    5.         System.out.println("使用方法：" + p.name());
    6.         System.out.println(p.process(s));
    7.     }
    8. }

            一种复用代码的方式是，调用者可以编写符合这个接口的类：

    1. package interfaceprocessor;
    2.  
    3. import java.util.Arrays;
    4.  
    5. interface StringProcessor extends Processor {
    6.     // @Override不是必要的，但它可以指出返回类型发生了从Object到String的协变
    7.     @Override
    8.     String process(Object input);
    9.  
    10.     String s = "You are an Programmer"; // 在接口内定义的字段是static和final的
    11.  
    12.     public static void main(String[] args) { // main()方法的定义也是被允许的
    13.         Applicator.apply(new Upcase(), s);
    14.         Applicator.apply(new Downcase(), s);
    15.         Applicator.apply(new Splitter(), s);
    16.     }
    17. }
    18.  
    19. class Upcase implements StringProcessor {
    20.     @Override
    21.     public String process(Object input) { // 返回类型是协变的
    22.         return ((String) input).toUpperCase();
    23.     }
    24. }
    25.  
    26. class Downcase implements StringProcessor {
    27.     @Override
    28.     public String process(Object input) {
    29.         return ((String) input).toLowerCase();
    30.     }
    31. }
    32.  
    33. class Splitter implements StringProcessor {
    34.     @Override
    35.     public String process(Object input) {
    36.         return Arrays.toString(((String) input).split(" "));
    37.     }
    38. }

            程序执行的结果如下：

            但也有上述这种处理方式应付不了的情况。因为库一般是被发现而不是被创建的，在这种情况下，就会需要使用到适配器设计模式：

    1. package interfaceprocessor;
    2.  
    3. import filters.*;
    4.  
    5. class FilterAdapter implements Processor {
    6.     Filter filter;
    7.  
    8.     FilterAdapter(Filter filter) {
    9.         this.filter = filter;
    10.     }
    11.  
    12.     @Override
    13.     public String name() { // 使用了委托
    14.         return filter.name();
    15.     }
    16.  
    17.     public Waveform process(Object input) { // 返回类型是协变的，这允许我们产生一个Waveform
    18.         return filter.process((Waveform) input);
    19.     }
    20. }
    21.  
    22. public class FilterProcessor {
    23.     public static void main(String[] args) {
    24.         Waveform w = new Waveform();
    25.         Applicator.apply(new FilterAdapter(new LowPass(1.0)), w);
    26.         Applicator.apply(new FilterAdapter(new HighPass(2.0)), w);
    27.         Applicator.apply(new FilterAdapter(new BandPass(3.0, 4.0)), w);
    28.     }
    29. }

        接口与实现的解耦允许我们将一个接口应用于多个不同的实现。

    组合多个接口

            接口没有实现，也就是说，没有与接口有关联的储存储。这为多个接口组合在一起提供了合理性。

            Java没有强制要求一个子类的基类是抽象的或是具体的。一个子类只能继承一个非接口，但同时，这个子类也可以继承复数的接口（这些接口名都应该被放置在implement关键字之后，并用逗号隔开）。例如：

    1. // 一组接口
    2. interface CanFight {
    3.     void fight();
    4. }
    5.  
    6. interface CanSwim {
    7.     void swim();
    8. }
    9.  
    10. interface CanFly {
    11.     void fly();
    12. }
    13.  
    14. // 一个基类
    15. class ActionCharacter {
    16.     public void fight() {
    17.     };
    18. }
    19.  
    20. class Hero extends ActionCharacter
    21.         implements CanFight, CanSwim, CanFly {
    22.     // 此处没有为fight提供定义
    23.     @Override
    24.     public void swim() {
    25.     }
    26.  
    27.     @Override
    28.     public void fly() {
    29.     }
    30. }
    31.  
    32. public class Adventure {
    33.     public static void t(CanFight x) {
    34.         x.fight();
    35.     }
    36.  
    37.     public static void u(CanSwim x) {
    38.         x.swim();
    39.     }
    40.  
    41.     public static void v(CanFly x) {
    42.         x.fly();
    43.     }
    44.  
    45.     public static void w(ActionCharacter x) {
    46.         x.fight();
    47.     }
    48.  
    49.     public static void main(String[] args) {
    50.         Hero h = new Hero();
    51.         t(h); // 当作一个Canfight类型
    52.         u(h); // 把Hero当作一个CanSwim类型
    53.         v(h); // 同样进行了转型
    54.         w(h); // 当作一个ActionCharacter类型
    55.     }
    56. }

            注意：当通过上述这种方式结合具体的类和接口时，具体的类必须在前面，然后才是接口。

            上述程序中，CanFight和ActionCharacter包含了同样签名的方法fight()，并且Hero中并没有为fight()提供具体的定义。但是在创建一个对象时，所有的定义都必须是已经存在的。此处之所以没有触发报错，是因为ActionCharacter提供了fight()的定义。

            使用接口的两个原因：

    1. 向上转型为多个基类型，并且利用这样做带来的灵活性。
    2. 防止客户程序员创建此类的对象，并且明确表示这只是一个接口。

        若可以在没有任何方法定义或成员变量的情况下创建基类，就应该使用接口而不是抽象类。

    通过继承扩展接口

            可以使用继承向接口中添加新的方法声明，也可以通过继承组合多个接口。这两种方式最终都会得到一个新的接口：

    1. interface Monster {
    2.     void menace();
    3. }
    4.  
    5. interface DangerousMonster extends Monster {
    6.     void destroy();
    7. }
    8.  
    9. interface Lethal {
    10.     void kill();
    11. }
    12.  
    13. class DragonZilla implements DangerousMonster {
    14.     @Override
    15.     public void menace() {
    16.     }
    17.  
    18.     @Override
    19.     public void destroy() {
    20.     }
    21. }
    22.  
    23. interface Vampire extends DangerousMonster, Lethal {
    24.     void drinkBlood();
    25. }
    26.  
    27. class VeryBadVampire implements Vampire {
    28.     @Override
    29.     public void menace() {
    30.     }
    31.  
    32.     @Override
    33.     public void destroy() {
    34.     }
    35.  
    36.     @Override
    37.     public void kill() {
    38.     }
    39.  
    40.     @Override
    41.     public void drinkBlood() {
    42.     }
    43. }
    44.  
    45. public class HorroShow {
    46.     static void u(Monster b) {
    47.         b.menace();
    48.     }
    49.  
    50.     static void v(DangerousMonster d) {
    51.         d.menace();
    52.         d.destroy();
    53.     }
    54.  
    55.     static void w(Lethal l) {
    56.         l.kill();
    57.     }
    58.  
    59.     public static void main(String[] args) {
    60.         DangerousMonster barney = new DragonZilla();
    61.         u(barney);
    62.         v(barney);
    63.  
    64.         Vampire vlad = new VeryBadVampire();
    65.         u(vlad);
    66.         v(vlad);
    67.         w(vlad);
    68.     }
    69. }

            在进行新接口的创建时，extends关键字可以用来关联多个父接口。注意接口名称要用逗号分隔。

    组合接口时的名称冲突

            在之前CanFight和ActionCharacter的例子中，接口和类具有void fight()方法。因为ActionCharacter提供了定义，因此没有任何问题。但如果方法的签名或返回类型不同，情况就会发生改变。

    1. // 3个接口
    2. interface I1 {
    3.     void f();
    4. }
    5.  
    6. interface I2 {
    7.     int f(int i);
    8. }
    9.  
    10. interface I3 {
    11.     int f();
    12. }
    13.  
    14. // 提供了一个声明
    15. class C {
    16.     public int f() {
    17.         return 1;
    18.     }
    19. }
    20.  
    21. // 对不同的接口进行组合
    22. class C2 implements I1, I2 {
    23.     @Override
    24.     public void f() {
    25.     }
    26.  
    27.     @Override
    28.     public int f(int i) { // 发生重载
    29.         return 2;
    30.     }
    31. }
    32.  
    33. class C3 extends C implements I2 {
    34.     @Override
    35.     public int f(int i) { // 发生重载
    36.         return 3;
    37.     }
    38. }
    39.  
    40. class C4 extends C implements I3 { // 两者的f()方法定义完全相同，可以直接使用
    41. }
    42.  
    43. // 下面是无法组合的情况：方法只有返回类型不同
    44. // class C5 extends C implements I1 {
    45. // }
    46.  
    47. // interface I4 extends I1, I3 {
    48. // }

            上述程序中，最后的两种组合将重写、实现和重载混在了一起，若取消注释并尝试编译，会引发报错：

        因此，在接口中应该尽量避免使用相同的方法名称。

    适配接口

            引入接口的又一个原因是，接口可以允许同一个接口有多个实现。这可以体现为一个接收接口的方法，调用者实现该接口，并将接口作为对象传递给方法。这就回到了之前说的策略设计模式，这种方法灵活、通用并且有更高的可复用性。

            例如，java.util包提供了一个Scanner类，这个类的构造器会接收一个Readable接口作为参数。Readable是一个专门为Scanner创建的接口，这样Scanner的参数就不会受到类型的约束。若想要让一个类能够和Scanner一起被使用，只需要让这个新类实现Readable接口即可：

    1. import java.nio.CharBuffer;
    2. import java.util.Random;
    3. import java.util.Scanner;
    4.  
    5. public class RandomStrings implements Readable {
    6.     private static Random rand = new Random(47);
    7.     private static final char[] CAPITALS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
    8.     private static final char[] LOWERS = "abcdefghijklmnopqrstuvwxyz".toCharArray();
    9.     private static final char[] VOWELS = "aeiou".toCharArray();
    10.  
    11.     private int count;
    12.  
    13.     public RandomStrings(int count) {
    14.         this.count = count;
    15.     }
    16.  
    17.     @Override
    18.     public int read(CharBuffer cb) {
    19.         if (count-- == 0) // 若输入已经结束
    20.             return -1;
    21.         cb.append(CAPITALS[rand.nextInt(CAPITALS.length)]);
    22.         for (int i = 0; i < 4; i++) {
    23.             cb.append(VOWELS[rand.nextInt(VOWELS.length)]);
    24.             cb.append(LOWERS[rand.nextInt(LOWERS.length)]);
    25.         }
    26.  
    27.         cb.append(" ");
    28.         return 10;
    29.     }
    30.  
    31.     public static void main(String[] args) {
    32.         Scanner s = new Scanner(new RandomStrings(10));
    33.         while (s.hasNext())
    34.             System.out.println(s.next());
    35.     }
    36. }

            程序执行的结果是：

            通过java.lang提供的Readable接口可以实现一个read()方法。read()方法的参数列表是一个CharBuffer类型的参数，可以在文档中找到关于这个类型的描述：

            可以向这个参数中通过各种方法添加数据，或者当没有输入（此时返回-1）。

            但若一个类型没有实现Readable，要让其能够与Scanner一起工作，就会需要使用到多重继承。现在，假设有一个没有实现Readable的接口RandomDoubles：

    1. import java.util.Random;
    2.  
    3. public interface RandomDoubles {
    4.     Random RAND = new Random(47);
    5.  
    6.     default double next() {
    7.         return RAND.nextDouble();
    8.     }
    9.  
    10.     public static void main(String[] args) {
    11.         RandomDoubles rd = new RandomDoubles() {
    12.         };
    13.  
    14.         for (int i = 0; i < 7; i++) {
    15.             System.out.println(rd.next() + " ");
    16.         }
    17.     }
    18. }

            此时，就可以使用适配器模式，组合两个不同的接口来创建一个适配的类。现在，使用interface关键字，生成一个新的类，这个新的类会实现RandomDouble和Readable：

    1. import java.nio.CharBuffer;
    2. import java.util.Scanner;
    3.  
    4. public class AdaptedRandomDoubles
    5.         implements RandomDoubles, Readable {
    6.     private int count;
    7.  
    8.     public AdaptedRandomDoubles(int count) {
    9.         this.count = count;
    10.     }
    11.  
    12.     @Override
    13.     public int read(CharBuffer cb) {
    14.         if (count-- == 0)
    15.             return -1;
    16.  
    17.         String result = Double.toString(next()) + " ";
    18.         cb.append(result);
    19.         return result.length();
    20.     }
    21.  
    22.     public static void main(String[] args) {
    23.         Scanner s = new Scanner(new AdaptedRandomDoubles(7)); // 使用Scanner
    24.         while (s.hasNextDouble())
    25.             System.out.println(s.nextDouble() + " ");
    26.     }
    27. }

            程序执行的结果是：

            任何现有类都可以通过这种适配器的方式进行接口的添加，这意味着把接口作为参数的方法可以让任何类适应它。

    接口中的字段

            因为接口中的任何字段都是static和final的，所有接口也是创建一组常量值的便捷工具：

    1. public class Months {
    2.     int JABUARY = 1,
    3.     FABRUARY = 2;
    4.     // ...
    5. }

            注意：Java中具有常量初始值的static final字段的命名全部使用大写字符（并且使用下划线分隔单词）。

        在Java 5之前，Java经常通过这种方式实现枚举。

    初始化接口中的字段

            接口中的定义字段不能是“空白的final”，但可以通过非常量表达式进行初始化：

    1. import java.util.Random;
    2.  
    3. public interface RandVals {
    4.     Random RAND = new Random();
    5.     int RANDOM_INT = RAND.nextInt(10);
    6.     long RANDOM_LONG = RAND.nextLong() * 10;
    7.     float RANDOM_FLOAT = RAND.nextFloat() * 10;
    8.     double RANDOM_DOUBLE = RAND.nextDouble() * 10;
    9. }

            这些字段都是静态的，它们会在接口第一次被加载时初始化。简单地看看：

    1. public class TestRandVals {
    2.     public static void main(String[] args) {
    3.         System.out.println(RandVals.RANDOM_DOUBLE);
    4.         System.out.println(RandVals.RANDOM_DOUBLE);
    5.     }
    6. }

            程序执行的结果是：

        接口中定义的字段不是接口的一部分。这些字段的值会储存在接口的静态存储区中。

    嵌套接口

            接口可以嵌套在类和其他接口中：

    1. package nesting;
    2.  
    3. class A {
    4.     interface B {
    5.         void f();
    6.     }
    7.  
    8.     public class BImp implements B {
    9.         @Override
    10.         public void f() {
    11.         }
    12.     }
    13.  
    14.     private class BImp2 implements B {
    15.         @Override
    16.         public void f() {
    17.         }
    18.     }
    19.  
    20.     private interface C {
    21.         void f();
    22.     }
    23.  
    24.     private class CImp implements C {
    25.         @Override
    26.         public void f() {
    27.         }
    28.     }
    29.  
    30.     public class CImp2 implements C {
    31.         @Override
    32.         public void f() {
    33.         }
    34.     }
    35.  
    36.     public C getC() {
    37.         return new CImp2();
    38.     }
    39.  
    40.     private C cRef;
    41.  
    42.     public void receiveC(C c) {
    43.         cRef = c;
    44.         cRef.f();
    45.     }
    46. }
    47.  
    48. interface D {
    49.     interface E {
    50.         void f();
    51.     }
    52.  
    53.     public interface F { // 此处可以省略public
    54.         void f();
    55.     }
    56.  
    57.     void g();
    58.  
    59.     // 不能在接口中使用private
    60.     // private interface H {
    61.     // }
    62. }
    63.  
    64. public class NestingInterfaces {
    65.     public class BImp implements A.B {
    66.         @Override
    67.         public void f() {
    68.         }
    69.     }
    70.  
    71.     // private的接口只能在定义的类中实现
    72.     // class DImp implements A.D {
    73.     // public void f() {
    74.     // };
    75.     // }
    76.  
    77.     class DImp implements D {
    78.         @Override
    79.         public void g() {
    80.         };
    81.  
    82.         class DE implements D.E {
    83.             @Override
    84.             public void f() {
    85.             }
    86.         }
    87.     }
    88.  
    89.     public static void main(String[] args) {
    90.         A a = new A();
    91.  
    92.         // A.C无法访问：
    93.         // A.C ac = a.getC();
    94.  
    95.         // 只能返回A.C：
    96.         // A.CImp2 ci2 = a.getC(); // 无法接收返回值
    97.  
    98.         // 无法访问接口C中的方法
    99.         // a.getC().f();
    100.  
    101.         // 需要使用到第二个A对象，才能处理getC()
    102.         A a2 = new A();
    103.         a2.receiveC(a.getC());
    104.     }
    105. }

            在类中进行接口嵌套的语句与正常使用几乎没有区别。它们都可以具有public或是包访问权限。

            值得一提的是，接口也可以是private的，就像A.C一样。这种接口会被用于：① 实现像CImp一样的私有内部类；② 像CImp2一样的public类，这种类只有自己的类型，在外界看来其与接口C无关，这种做法限制了接口C中的方法定义，也就是说，private的接口不允许任何的向上转型。

            上述程序中a.getC()的使用无疑是特殊的：这个方法的返回值必须传递给一个有权使用它的对象，也就是另一个A。

        所有的接口元素都必须是public的，所以嵌套在其他接口中的接口默认也是public的（也只能是）。

    接口和工厂

            通过接口，可以进行多种的实现。若想要生成适合某个接口的对象，就可以采取工厂方法设计模式：不直接调用构造器，而是在工厂对象上调用创建方法，这种创建方法可以产生接口实现。

    1. interface Service {
    2.     void method1();
    3.  
    4.     void method2();
    5. }
    6.  
    7. interface ServiceFactory {
    8.     Service getService();
    9. }
    10.  
    11. // 1号服务
    12. class Service1 implements Service {
    13.     Service1() { // 将构造器限定为包访问，不允许外部使用
    14.     }
    15.  
    16.     @Override
    17.     public void method1() {
    18.         System.out.println("1号服务：方法1");
    19.     }
    20.  
    21.     @Override
    22.     public void method2() {
    23.         System.out.println("1号服务：方法2");
    24.     }
    25. }
    26.  
    27. class Service1Factory implements ServiceFactory {
    28.     @Override
    29.     public Service getService() {
    30.         return new Service1();
    31.     }
    32. }
    33.  
    34. // 2号服务
    35. class Service2 implements Service {
    36.     Service2() { // 具有包访问权限的构造器
    37.     }
    38.  
    39.     @Override
    40.     public void method1() {
    41.         System.out.println("2号服务：方法1");
    42.     }
    43.  
    44.     @Override
    45.     public void method2() {
    46.         System.out.println("2号服务：方法2");
    47.     }
    48. }
    49.  
    50. class Service2Factory implements ServiceFactory {
    51.     @Override
    52.     public Service getService() {
    53.         return new Service2();
    54.     }
    55. }
    56.  
    57. public class Factories {
    58.     public static void serviceConsumer(ServiceFactory fact) {
    59.         Service s = fact.getService();
    60.         s.method1();
    61.         s.method2();
    62.     }
    63.  
    64.     public static void main(String[] args) {
    65.         // 通过“工厂”，调用不同的服务
    66.         serviceConsumer(new Service1Factory());
    67.         System.out.println();
    68.         serviceConsumer(new Service2Factory());
    69.     }
    70. }

            程序执行的结果是：

            通过工厂方法进行额外层的添加，这种做法可以用来创建框架。假设所需实现的方法更加复杂，框架的存在就会更加方便对代码的复用。

    新特性：接口的private方法

            JDK 9最终确定，可以将接口中的方法转换为private方法：

    1. interface JDK9 {
    2.     private void fd() { // private方法默认是default的
    3.         System.out.println("JDK9::fd()");
    4.     }
    5.  
    6.     private static void fs() {
    7.         System.out.println("JDK::fs()");
    8.     }
    9.  
    10.     default void f() {
    11.         fd();
    12.     }
    13.  
    14.     static void g() {
    15.         fs();
    16.     }
    17. }
    18.  
    19. class ImplJDK9 implements JDK9 {
    20. }
    21.  
    22. public class PrivateInterfaceMethods {
    23.     public static void main(String[] args) {
    24.         new ImplJDK9().f();
    25.         JDK9.g();
    26.     }
    27. }

            程序运行的结果如下：

    新特性：密封类和密封接口

            JDK 17最终确定引入密封类（sealed）和密封接口，这样基类或接口就可以限制自己能派生的类：

    1. sealed class Base permits D1, D2 {}
    2.  
    3. final class D1 extends Base {}
    4.  
    5. final class D2 extends Base {}
    6.  
    7. // 这是非法的：
    8. //final class D3 extends Base {}

             若继承了未在permits子句中列出的子类，就会发生报错（如：D3）。通过这种方式，我们可以确保自己的任何代码只需要考虑D1和D2。

            也可以对接口和抽象类进行密封：

    1. // 密封接口
    2. sealed interface Ifc permits Imp1, Imp2 {}
    3.  
    4. final class Imp1 implements Ifc {}
    5.  
    6. final class Imp2 implements Ifc {}
    7.  
    8. // 密封抽象类
    9. sealed abstract class AC permits X {}
    10.  
    11. final class X extends AC {}

            若需要继承基类的子类都在同一个文件夹中，就不需要permit子句：

    1. sealed class Shape {}
    2.  
    3. final class Circle extends Shape {}
    4.  
    5. final class Triangle extends Shape {}

            而permits子句允许我们在单独的文件夹中定义子类：

            sealed类的子类只允许使用下列的某个修饰符进行定义：

    • final：不允许有进一步的子类。
    • sealed：允许有一个密封子类。
    • no-sealed：一个新关键字，允许未知的子类继承它。

            注意：一个sealed类有至少一个子类。而sealed的子类会保持对层次结构的严格控制。

     record

            JDK 16的record也可以实现接口的密封。record是隐式的final，因此它不需要与final并用：

    1. package interfaces;
    2.  
    3. sealed interface Employee permits CLevel, Programer { }
    4.  
    5. record CLevel(String type)
    6.         implements Employee { }
    7.  
    8. record Programer(String experience)
    9.         implements Employee{}

            编译器会阻止我们从密封层次结构中向下转型为非法类型：

    1. sealed interface II permits JJ {}
    2.  
    3. final class JJ implements II {}
    4.  
    5. class Something {}
    6.  
    7. public class CheckedDowncast {
    8.     public void f() {
    9.         II i = new JJ(); // 向上转型
    10.         JJ j = (JJ) i; //强制类型转换
    11.  
    12.         // Something s = (Something) i; // 不可转换
    13.     }
    14. }

        最后：接口在程序设计中，往往是处于用来进行优化的角色。若在程序一开始就使用接口，最终可能会使程序变得太过复杂。接口应该是在必要时用来重构的工具。因此，可以这么说：应该优先使用类而不是接口。

  • 相关阅读:
    springcloud: stream整合rocketmq
    “极致成本向左，本质安全向右”-谈谈锂电池储能系统的发展趋势
    c++屏蔽qq或者wechat的好友对局域网环境下的指定关键字
    攻防世界题目练习——Web引导模式（一）
    flowable-ui部署
    ENVI操作：GF2影像全色与多光谱融合
    HanLP — HMM隐马尔可夫模型 -- 维特比(Viterbi)算法 --示例代码 - Java
    Tomcat配置敏感信息屏蔽
    命令历史应用
    CAD二次开发--CAD2007（.Net3.5环境）等低版本CAD二次开发在VS中无法捕获断点调试解决办法（CAD二次开发无法断点调试解决办法）
  • 原文地址：https://blog.csdn.net/w_pab/article/details/132840696