【Java8实战】默认方法

缺乏、安全感 2023-07-01 13:55 3阅读 0赞

#### 引言 ####

传统上，Java程序的接口是将相关方法按照约定组合到一起的方式。实现接口的类必须为接口中定义的每个方法提供一个实现，或者从父类中继承它的实现。

但是，一旦类库的设计者需要更新接口，向其中加入新的方法，这种方式就会出现问题。

本篇博客的内容将要总结Java8是如何解决上述问题的。

#### 解决方案 ####

Java 8为了解决上述问题引入了一种新的机制。

Java 8中的接口现在支持在声明方法的同时提供实现。

通过两种方式可以完成这种操作。其一， Java 8允许在接口内声明静态方法。其二，Java 8引入了一个新功能，叫默认方法，通过默认方法我们可以指定接口方法的默认实现。

换句话说，接口能提供方法的具体实现。因此，实现接口的类如果不显式地提供该方法的具体实现，就会自动继承默认的实现。这种机制可以使你平滑地进行接口的优化和演进。

#### 默认方法 ####

实际上，到现在，我们已经接触到了默认方法，典型的例子就是的List接口中的sort，以及Collection接口中的stream。

List接口中的sort方法是java8中全新的方法，定义如下：

default void sort(Comparator<? super E> c){     Collections.sort(this, c); }

可以看到，返回类型之前加了default修饰符。通过它，我们能够知道一个方法是否为默认方法。

再比如，Collection中的sort方法，定义如下：

default Stream<E> stream() {     return StreamSupport.stream(spliterator(), false); }

我们之前使用了该方法来处理集合，这里stream方法中调用了 SteamSupport.stream方法来返回一个流。

#### 主要目标 ####

默认方法的主要目标用户是类库的设计者，默认方法的引入就是为了以兼容的方式解决像 Java API这样的类库的演进问题的，如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwMzQyMjM_size_16_color_FFFFFF_t_70]  
简而言之，向接口添加方法是诸多问题的罪恶之源；一旦接口发生变化，实现这些接口的类往往也需要更新，提供新添方法的实现才能适配接口的变化。

#### 使用场景 ####

了解了默认方法的好处，那么下一个问题就是什么时候我们可以使用默认方法呢？下面介绍两种场景：

**(1) 可选方法**

我们可能会碰到一种场景，类实现了接口，不过却刻意地需要将一些方法的实现留白。比如说Iterator接口，Iterator接口定义了hasNext、next，还定义了remove方法。

Java 8 之前，由于用户通常不会使用该方法，remove方法常被忽略。因此，实现Interator接口的类通常会为remove方法放置一个空的实现，这些都是些毫无用处的模板代码。

采用默认方法之后，你可以为这种类型的方法提供一个默认的实现，这样实体类就无需在自己的实现中显式地提供一个空方法。比如，在Java 8中，Iterator接口就为remove方法提供了一个默认实现，如下所示：

interface Iterator<T> {     
    	boolean hasNext();     
    	T next();     
    	default void remove() {         
    		throw new UnsupportedOperationException();     
    	} 
    }

通过这种方式，我们可以减少无效的模板代码。实现Iterator接口的每一个类都不需要再声明一个空的remove方法了，因为它现在已经有一个默认的实现。

**(2) 行为的多继承**

比如，我们设计一款游戏，需要定义多个具有不同特质的性质。有的形状需要调整大小，但是不需要有旋转的功能；有的需要能旋转和移动，但是不需要调整大小。我们可以如何设计呢？这里就可以用到默认方法了。

定义一个可旋转接口，并提供旋转的默认方法：

public interface Rotatable {     
    	void setRotationAngle(int angleInDegrees);     
    	int getRotationAngle();     
    	default void rotateBy(int angleInDegrees){           
    		setRotationAngle((getRotationAngle () + angle) % 360);     
    	} 
    }

定义一个可移动接口，并提供移动的默认方法：

public interface Moveable {     
    	int getX();     
    	int getY();     
    	void setX(int x);     
    	void setY(int y); 
        default void moveHorizontally(int distance){        
        	 setX(getX() + distance);    
        } 
     
        default void moveVertically(int distance){         
        	setY(getY() + distance);     
        } 
     }

定义一个可改变大小接口，并提供改变大小的默认方法：

public interface Resizable {     
    	int getWidth();     
    	int getHeight();     
    	void setWidth(int width);     
    	void setHeight(int height);     
    	void setAbsoluteSize(int width, int height); 
        default void setRelativeSize(int wFactor, int hFactor){         
        	setAbsoluteSize(getWidth() / wFactor, getHeight() / hFactor);     
        }
    }

现在，可以为游戏创建不同的实体类，比如Monster可以移动、 旋转和缩放。

public class Monster implements Rotatable, Moveable, Resizable { 
    	//... 只需要给出所有抽象方法的实现，不需要重复实现默认方法
     }

Monster继承了rotateBy、moveHorizontally、moveVertically和setRelativeSize的实现。我们也可以直接调用不同的方法：

Monster m = new Monster(); 
    //调用由Rotatable中继承而来的rotateBy 
    m.rotateBy(180);  
    //调用由Moveable中继承而来的moveVertically 
    m.moveVertically(10);

假设你现在需要声明另一个类，它要能移动和旋转，但是不能缩放，比如说Sun。这时也无需复制粘贴代码，你可以像下面这样复用Moveable和Rotatable接口的默认实现。

public class Sun implements Moveable, Rotatable { …  }

#### 解决冲突的规则 ####

Java语言中一个类只能继承一个父类，但是一个类可以实现多个接口。

随着默认方法在Java 8中引入，有可能出现一个类继承了多个方法而它们使用的却是同样的函数签名。这种情况下，类会选择使用哪一个函数？

在实际情况中，像这样的冲突可能极少发生，但是一旦发生这样的状况，必须要有一套规则来确定按照什么样的约定处理这些冲突。

(1) 类中的方法优先级最高。类或父类中声明的方法的优先级高于任何声明为默认方法的优先级。

(2) 如果无法依据第一条进行判断，那么子接口的优先级更高：函数签名相同时，优先选择拥有最具体实现的默认方法的接口，即如果B继承了A，那么B就比A更加具体。

(3) 最后，如果还是无法判断，继承了多个接口的类必须通过显式覆盖和调用期望的方法，显式地选择使用哪一个默认方法的实现。

#### 选择默认方法实例 ####

(1) 如下图所示，C类同时实现了B接口和A接口，而这两个接口恰巧又都定义了名为hello的默认方法。另外，B继承自A。那么，会选择哪个类的hello方法输出呢？  
![在这里插入图片描述][20200122171733592.png]  
按照规则(2)，应该选择的是提供了最具体实现的默认方法的接口。由于B比A更具体，所以应该选择B的hello方法。所以，程序会打印输出“Hello from B”。

(2)

public class D implements A{ } 
    
    public class C extends D implements B, A {     
    	public static void main(String... args) {         
    		new C().hello();     
    	} 
    }

如下图，  
![在这里插入图片描述][20200122171959159.png]  
输出的结果会是什么呢？

依据规则(1)，类中声明的方法具有更高的优先级。D并未覆盖hello方法，可是它实现了接口A。所以它就拥有了接口A的默认方法。

规则(2)说如果类或者父类没有对应的方法，那么就应该选择提供了最具体实现的接口中的方法。因此，编译器会在接口A和接口B的hello方法之间做选择。由于B更加具体，所以程序会再次打印输出“Hello from B”。

#### 总结 ####

通过本篇博客，认识了Java8新引入的默认方法，也通过实例看到了这种默认方法带来的灵活性。所以此后若在项目中，需要对接口进行改动，也可以想想是否可以使用默认方法了。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwMzQyMjM_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200122162253295.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwMzQyMjM=,size_16,color_FFFFFF,t_70
[20200122171733592.png]: https://img-blog.csdnimg.cn/20200122171733592.png
[20200122171959159.png]: https://img-blog.csdnimg.cn/20200122171959159.png