Java8为什么会有默认方法

这篇文章将为大家详细讲解有关Java8为什么会有默认方法，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。

前言

在Java 8之前，默认情况下，接口中的所有方法都是公共的和抽象的。但是这一限制在Java 8中被打破了，Java 8允许开发人员在接口中添加新方法，而无需在实现这些接口的类中进行任何更改。

为什么会有默认方法？

主要是为了方便扩展已有接口；如果没有默认方法，假如给Java中的某个接口添加一个新的抽象方法，那么所有实现了该接口的类都得修改，影响将非常大。

举个例子，Sortable <T>接口以及实现该接口的类SortableNumberCollection和SortableStringCollection。该接口有两种方法：void sort(); 和T peek()。

public interface Sortable<T> {
 void sort();
 T peek();
}

sort()方法用于对象排序，T peek()用于获取指定元素，另外需要一个比较器类ObjectComparator来对对象进行排序。

public class ObjectComparator implements Comparator<Comparable> {
 @Override
 public int compare(Comparable o1, Comparable o2) {
  return o1.compareTo(o2);
 }
}

SortableStringCollection是一个自定义集合类可以进行排序，并查看字符串指定元素，代码如下：

public class SortableStringCollection implements Sortable<String> {

 private List<String> items = new ArrayList<>();

 public void add(String item) {
  items.add(item);
 }

 @Override
 public void sort() {
  items.sort(new ObjectComparator());
 }

 @Override
 public String peek() {
  return items.get(0);
 }
}

同样，SortableNumberCollection是一个自定义集合类，其中包含可以使用接口方法进行排序和查看的数字列表指定元素，代码如下：

public class SortableNumberCollection implements Sortable<Integer> {

 private List<Integer> items = new ArrayList<>();

 public void add(Integer item) {
  items.add(item);
 }

 @Override
 public void sort() {
  items.sort(new ObjectComparator());
 }

 @Override
 public Integer peek() {
  return items.get(0);
 }
}

在Java8之前如果对接口Sortable<T>添加新方法：T sortAndPeek()，那么SortableStringCollection和

SortableNumberCollection都必须实现T sortAndPeek()方法。

Java8之后提供了一种新的实现方式，默认方法 default method，我们可以对Sortable<T>进行如下改造：

public interface Sortable<T> {
 void sort();
 T peek();

 default T sortAndPeek(){ // New 'default method' added in the interface
  sort();
  return peek();
 }

}

同时SortableStringCollection和SortableNumberCollection类不需要任何更改。这样可以减少我们对原有代码的改动。同时如果需要，还可以在实现此接口的任何类中重写该方法T sortAndPeek()的默认实现。

在下图中我们看到default Method不通的标识：

在多继承中使用默认方法问题

如果两个或多个接口具有相同的默认方法签名，并且一个类实现了这两个接口，则将引发编译时错误。例如：

public interface Interface1 {
 void methodOne(String str);
 default void newMethod(){
  System.out.println("Interface1: Newly added method");
 }
}



public interface Interface2 {
 void methodTwo(String str);
 default void newMethod(){
  System.out.println("Interface2: Newly added method");
 }
}



public class InterfaceImplementation implements Interface1, Interface2{
 @Override
 public void methodOne(String str) {
  System.out.println("Overridden methodOne: " + str);
 }

 @Override
 public void methodTwo(String str) {
  System.out.println("Overridden methodTwo: " + str );
 }
}

此时代码会提示如下异常：

InterfaceImplementation inherits unrelated defaults for newMethod() from types Interface1 and Interface2

要解决此问题，我们将必须重写类InterfaceImplementation中的方法：

public class InterfaceImplementation implements Interface1, Interface2{
 @Override
 public void methodOne(String str) {
  System.out.println("Overridden methodOne: " + str);
 }

 // newMethod implemented to resolve the conflict.
 @Override
 public void newMethod() {
  System.out.println("InterfaceImplementation: Newly added method");
 }

 @Override
 public void methodTwo(String str) {
  System.out.println("Overridden methodTwo: " + str );
 }
}

我们总结一下：

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

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

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

在Java 8中添加静态方法

接口定义的静态方法独立于任何对象调用。所以，在调用静态方法时，不需要实现接口，也不需要接口的实例，

就像“默认方法”一样，“静态方法”也可以添加到接口中。例如，我们可以添加一个静态方法Direction getDefaultDirection（），该方法将返回默认Direction，例如：

public interface Sortable<T> {

 Direction defaultDirection = Direction.DESC;

 enum Direction {
  ASC,
  DESC
 };

 void sort();
 T peek();

 static Direction getDefaultDirection(){ // 'static method' added to the interface.
  return defaultDirection;
 }
}

在上面的示例中，可以使用类引用来调用静态Direction getDefaultDirection（）方法：

Sortable.getDefaultDirection()

对默认方法和静态方法的一点思考

接口是设计模式中一种开闭原则的体验，而java8赋予了接口新的特性，使得接口使用起来更加的得心应手了，这也有助于我们更加内聚自己的代码结构了。Java源码中也有很多场景使用到了默认方法，例如：Iterator接口，我们在开发中可以多使用一些新的特性从而提高开发效率及增加代码的健壮性。

public interface Iterable<T> {

 Iterator<T> iterator();
 
 default void forEach(Consumer<? super T> action) {
  Objects.requireNonNull(action);
  for (T t : this) {
   action.accept(t);
  }
 }
 
 default Spliterator<T> spliterator() {
  return Spliterators.spliteratorUnknownSize(iterator(), 0);
 }
 
}

关于“Java8为什么会有默认方法”这篇文章就分享到这里了，希望以上内容可以对大家有一定的帮助，使各位可以学到更多知识，如果觉得文章不错，请把它分享出去让更多的人看到。