Java8 default方法

Posted 2020-10-02 尨德一彼

为什么需要引入default方法

　　在Java7以前interface只能声明方法，而不能实现方法。

　　在Java8中这一情况有所改变，接口中引入了default方法和static方法，interface中声明的方法默认为 public abstract 修饰，default方法

就相当于只有public 修饰，并且可以有具体的实现，一样可以覆盖(参见下面的例子)；static方法在interface里和在其他地方是一样的，类名.方法名调用即可。

　　引入default主要目的是为了实现接口的升级。因为在原有的Java代码框架中，如果要对接口进行升级就会导致所有接口的实现类都要被

修改，这就很麻烦了。那么怎样才能不破坏Java现有实现架构的情况下往接口里增加新方法又不至于大动干戈呢？于是乎，引入default方法，

具有默认方法的实现，这对这些库类的升级带来许多的便利。

举个具体的例子

 　　Java8集合接口中添加了一些default方法，对集合类API进行升级，比如Collection中的Stream()就是default方法

 1 import java.util.List;
 2 import java.util.stream.Stream;
 3 
 4 /**
 5  * interface defined default method and static method
 6  * 
 7  * @author mdyb 
 8  *             date: 2017/8/11 
 9  *             file: ISuper.java
10  */
11 public interface ISuper {
12     /**
13      * default method
14      */
15     default void showClass() {
16         System.out.println("class name of calling this method: " + this.getClass().getName());
17     }
18 
19     /**
20      * static method
21      * @param iSupers
22      * @return
23      */
24     static ISuper[] filter(int p, ISuper... iSupers) {
25         ISuper[] supers = Stream.of(iSupers).filter(a -> a.getValueRandom() < p).toArray(ISuper[]::new);
26         return supers;
27 
28     }
29     static ISuper[] filter(int p, List<ISuper> iSpers) {
30         return iSpers.stream().filter(a-> a.getValueRandom() < p).toArray(ISuper[]::new);
31     }
32     
33 
34     static void swap(int[] arr, int i, int j) {
35         arr[i] += arr[j];
36         arr[j] = arr[i] - arr[j];
37         arr[i] -= arr[j];
38     }
39 
40     int getValueRandom();
41 
42     int getValue();
43 }

 

 1 import java.util.Arrays;
 2 /**
 3  * 
 4  * @author yushenglong
 5  *         date: 2017/8/11 
 6  *         file: ISuperImpl.java
 7  */
 8 public class ISuperImpl implements ISuper {
 9 
10     public static void main(String[] args) {
11         ISuper iSuper = new ISuperImpl(); 
12         iSuper.showClass(); // 无覆盖直接调用
13 
14         System.out.println("\n====================");
15         ISuper iSuper2 = new ISuperImpl2();
16         iSuper2.showClass(); // 调用覆盖的方法
17 
18         System.out.println("\n====================");
19         ISuper iSuper3 = new ISuperImpl3();
20         iSuper3.showClass(); // 调用覆盖的方法
21 
22         System.out.println("\n====================");
23 
24         ISuper iSuper31 = new ISuperImpl3();
25         ISuper iSuper21 = new ISuperImpl2();
26         ISuper iSuper11 = new ISuperImpl();
27 
28         System.out.println("iSuper value = " + iSuper.getValue());
29         
30         ISuper[] s = ISuper.filter(5000, iSuper, iSuper11, iSuper2, iSuper21, iSuper3, iSuper31);
31         ISuper[] s2 = ISuper.filter(4000, iSuper, iSuper11, iSuper2, iSuper21, iSuper3, iSuper31);
32         Arrays.stream(s).forEach((a) -> System.out.print(a.getValue() + " "));
33         System.out.println();
34         Arrays.stream(s2).forEach((a) -> System.out.print(a.getValueRandom() + " "));
35     }
36 
37     private int value = (int) (Math.random() * 2000);
38 
39     @Override
40     public int getValueRandom() {
41         return value + 3333;
42     }
43 
44     @Override
45     public int getValue() {
46         return value;
47     }
48 
49 }
50 
51 class ISuperImpl2 implements ISuper {
52     private int value = (int) (Math.random() * 777);
53     
54     // default 方法可以覆盖
55     @Override
56     public void showClass() {
57         System.out.println("before");
58         ISuper.super.showClass();
59         System.out.println("after");
60     }
61 
62     @Override
63     public int getValueRandom() {
64         return (value + 2000) * 2;
65     }
66 
67     @Override
68     public int getValue() {
69         return value;
70     }
71 }
72 
73 class ISuperImpl3 implements ISuper {
74 
75     private String status;
76 
77     private int value = (int) (3141 + Math.random() * 600);
78 
79     public ISuperImpl3() {
80         status = getClass().getName() + System.currentTimeMillis();
81     }
82 
83     @Override
84     public void showClass() {
85         System.out.println("class status of calling this method: "+status + System.currentTimeMillis() + "\n" + Math.random());
86     }
87 
88     @Override
89     public int getValueRandom() {
90         return (value + status.length() - (int) (1333 * Math.random())) / 2;
91     }
92 
93     @Override
94     public int getValue() {
95         return value;
96     }
97 }

 　　Java8相对Java7还有许多新特性，等用到的时候再去仔细研究。