Default 方法

前言：当我在用Spring boot框架开发项目中配置Webconfig类时，该类实现了WebMvcConfigurerAdapter抽象类。但是IDE提示WebMvcConfigurerAdapter类已被弃用，查看该类的定义发现已被@Deprecated注解标记，Spring-webmvc的版本为5.0.6。接着查看它实现的WebMvcConfigurer接口，发现该接口下的所有方法都变成了以default开头的方法，由于之前不了解default关键字，因此查阅官方文档，便有了下面的翻译。

原文链接：https://docs.oracle.com/javase/tutorial/java/IandI/defaultmethods.html

部分Interface描述了一个示例，该示例涉及计算机控制的汽车制造商，他们发布行业标准接口，描述可以调用哪些方法来操作他们的汽车。如果那些电脑控制的汽车制造商向他们的汽车添加新的功能，比如飞行，会怎么样呢？这些制造商需要指定新的方法，以使其他公司(如电子导航仪器制造商)能够使他们的软件适应飞行汽车。这些汽车制造商将在哪里声明这些新的飞行相关的方法？如果将它们添加到原始接口中，那么已经实现了这些接口的程序员将不得不重写他们的实现。如果将它们以静态方法的方式添加，那么程序员将视它们为实用方法，而不是本质的核心的方法。

default方法能够使你向库中添加新的功能，并确保它们和这些接口旧版本现有的代码二进制兼容。

考虑下面的interface，TimeClient，如在Answers to Questions and Exercises: Interfaces中的描述：

import java.time.*; 

public interface TimeClient {
    void setTime(int hour, int minute, int second);
    void setDate(int day, int month, int year);
    void setDateAndTime(int day, int month, int year,
                               int hour, int minute, int second);
    LocalDateTime getLocalDateTime();
}

下面SimpleTimeClient类实现了TimeClient接口：

package defaultmethods;

import java.time.*;
import java.lang.*;
import java.util.*;

public class SimpleTimeClient implements TimeClient {

    private LocalDateTime dateAndTime;

    public SimpleTimeClient() {
        dateAndTime = LocalDateTime.now();
    }

    public void setTime(int hour, int minute, int second) {
        LocalDate currentDate = LocalDate.from(dateAndTime);
        LocalTime timeToSet = LocalTime.of(hour, minute, second);
        dateAndTime = LocalDateTime.of(currentDate, timeToSet);
    }

    public void setDate(int day, int month, int year) {
        LocalDate dateToSet = LocalDate.of(day, month, year);
        LocalTime currentTime = LocalTime.from(dateAndTime);
        dateAndTime = LocalDateTime.of(dateToSet, currentTime);
    }

    public void setDateAndTime(int day, int month, int year,
                               int hour, int minute, int second) {
        LocalDate dateToSet = LocalDate.of(day, month, year);
        LocalTime timeToSet = LocalTime.of(hour, minute, second); 
        dateAndTime = LocalDateTime.of(dateToSet, timeToSet);
    }

    public LocalDateTime getLocalDateTime() {
        return dateAndTime;
    }

    public String toString() {
        return dateAndTime.toString();
    }

    public static void main(String... args) {
        TimeClient myTimeClient = new SimpleTimeClient();
        System.out.println(myTimeClient.toString());
    }
}

假如你想向TimeClient 接口添加新的功能，例如通过ZonedDateTime对象指定时区的能力（这就像一个LocalDateTime对象，只是它存储了时区信息）。

public interface TimeClient {
    void setTime(int hour, int minute, int second);
    void setDate(int day, int month, int year);
    void setDateAndTime(int day, int month, int year,
        int hour, int minute, int second);
    LocalDateTime getLocalDateTime();                           
    ZonedDateTime getZonedDateTime(String zoneString);
}

在此基础上修改了TimeClient接口，你将不得不修改SimpleTimeClient 类，并且实现getZonedDateTime方法。然而你不必保持getZonedDateTime方法为抽象方法（像之前的例子一样），取而代之可以定义一个默认的实现。（记住，抽象方法是在没有实现的情况下声明的方法）。

package defaultmethods;

import java.time.*;

public interface TimeClient {
    void setTime(int hour, int minute, int second);
    void setDate(int day, int month, int year);
    void setDateAndTime(int day, int month, int year,
                               int hour, int minute, int second);
    LocalDateTime getLocalDateTime();

    static ZoneId getZoneId (String zoneString) {
        try {
            return ZoneId.of(zoneString);
        } catch (DateTimeException e) {
            System.err.println("Invalid time zone: " + zoneString +
                "; using default time zone instead.");
            return ZoneId.systemDefault();
        }
    }

    default ZonedDateTime getZonedDateTime(String zoneString) {
        return ZonedDateTime.of(getLocalDateTime(), getZoneId(zoneString));
    }
}

你通过在方法签名前以default关键字开始的方式，在一个接口中指定了一个方法的定义。在interface中，所有的方法声明，包括default方法的可见范围都隐式的声明为public，因此你可以省略这个public修饰符。

对于这个interface，你不需要改变SimpleTimeClient类，这个类（任何实现了接口TimeClient的类）将有已经定义了的getZonedDateTime方法。下面这个例子，TestSimpleTimeClient类从SimpleTimeClient类的一个实例中调用了getZonedDateTime 方法。

package defaultmethods;

import java.time.*;
import java.lang.*;
import java.util.*;

public class TestSimpleTimeClient {
    public static void main(String... args) {
        TimeClient myTimeClient = new SimpleTimeClient();
        System.out.println("Current time: " + myTimeClient.toString());
        System.out.println("Time in California: " +
            myTimeClient.getZonedDateTime("Blah blah").toString());
    }
}

继承包含default方法的接口

当你继承一个包含default方法的接口时，你可以执行以下操作：

• 根本不用提及default方法，这让你继承的接口继承default方法。
• 重新声明default方法，使它成为抽象方法。
• 重新定义default方法，重写default方法。

假如你像下面这样继承TimeClient接口：

public interface AnotherTimeClient extends TimeClient { }

实现了AnotherTimeClient 接口的任何类，都将拥有default方法TimeClient.getZonedDateTime的实现。

假如你像下面这样继承TimeClient接口：

public interface AbstractZoneTimeClient extends TimeClient {
    public ZonedDateTime getZonedDateTime(String zoneString);
}

任何实现了AbstractZoneTimeClient 接口的类，都将不得不实现getZonedDateTime方法；这个方法是一个抽象方法，像一个接口中所有其他非default（和非静态）方法一样。

假如你像下面这样继承TimeClient接口：

public interface HandleInvalidTimeZoneClient extends TimeClient {
    default public ZonedDateTime getZonedDateTime(String zoneString) {
        try {
            return ZonedDateTime.of(getLocalDateTime(),ZoneId.of(zoneString)); 
        } catch (DateTimeException e) {
            System.err.println("Invalid zone ID: " + zoneString +
                "; using the default time zone instead.");
            return ZonedDateTime.of(getLocalDateTime(),ZoneId.systemDefault());
        }
    }
}

所有实现了HandleInvalidTimeZoneClient 接口的类，都将使用HandleInvalidTimeZoneClient 接口中实现的getZonedDateTime 方法，而不是第一个接口TimeClient中的getZonedDateTime 方法。

静态方法

除了default方法，你可以在接口中定义静态方法。（静态方法是与定义它的类相关联的方法，而不是与任何对象相关联的方法。类的每个实例都共享其静态方法。）这个使你更容易在函数库中组织辅助方法；你可以保持静态方法与同一个接口中，而不是分开的类中。下面的例子定义了一个静态方法，该方法依据地区标识符检索返回一个ZoneId对象；如果依据得到的标识符没有检索出ZoneId对象，那么将返回系统默认的地区时间。（因此，你可以简化getZonedDateTime方法）:

public interface TimeClient {
    // ...
    static public ZoneId getZoneId (String zoneString) {
        try {
            return ZoneId.of(zoneString);
        } catch (DateTimeException e) {
            System.err.println("Invalid time zone: " + zoneString +
                "; using default time zone instead.");
            return ZoneId.systemDefault();
        }
    }

    default public ZonedDateTime getZonedDateTime(String zoneString) {
        return ZonedDateTime.of(getLocalDateTime(), getZoneId(zoneString));
    }    
}

像类中的静态方法，在一个接口中，你需要使用static关键字在方法签名前来制定它为静态方法。在一个接口中所有的方法声明，包括静态方法，隐式地声明为public，因此你能省略public标识符。

集成default方法到现有的库中

default方法能够使你向已经存在的接口中添加新的功能，并确保它们和这些接口旧版本现有的代码二进制兼容。特别的，default方法使您能够添加将lambda表达式作为参数的方法添加到现有接口中。本节演示如何使用默认和静态方法增强Comparator接口。

考虑在Classes的问题和练习中描述的Card和Deck类。这个例子重写Card和Deck类为接口。Card接口包含了两个枚举类型（Suit和Rank）和两个抽象方法（getSuit和getRank）:

package defaultmethods;

public interface Card extends Comparable<Card> {

    public enum Suit { 
        DIAMONDS (1, "Diamonds"), 
        CLUBS    (2, "Clubs"   ), 
        HEARTS   (3, "Hearts"  ), 
        SPADES   (4, "Spades"  );

        private final int value;
        private final String text;
        Suit(int value, String text) {
            this.value = value;
            this.text = text;
        }
        public int value() {return value;}
        public String text() {return text;}
    }

    public enum Rank { 
        DEUCE  (2 , "Two"  ),
        THREE  (3 , "Three"), 
        FOUR   (4 , "Four" ), 
        FIVE   (5 , "Five" ), 
        SIX    (6 , "Six"  ), 
        SEVEN  (7 , "Seven"),
        EIGHT  (8 , "Eight"), 
        NINE   (9 , "Nine" ), 
        TEN    (10, "Ten"  ), 
        JACK   (11, "Jack" ),
        QUEEN  (12, "Queen"), 
        KING   (13, "King" ),
        ACE    (14, "Ace"  );
        private final int value;
        private final String text;
        Rank(int value, String text) {
            this.value = value;
            this.text = text;
        }
        public int value() {return value;}
        public String text() {return text;}
    }

    public Card.Suit getSuit();
    public Card.Rank getRank();
}

Deck接口包含了各种各样操作Card的方法：

package defaultmethods; 

import java.util.*;
import java.util.stream.*;
import java.lang.*;

public interface Deck {

    List<Card> getCards();
    Deck deckFactory();
    int size();
    void addCard(Card card);
    void addCards(List<Card> cards);
    void addDeck(Deck deck);
    void shuffle();
    void sort();
    void sort(Comparator<Card> c);
    String deckToString();

    Map<Integer, Deck> deal(int players, int numberOfCards)
        throws IllegalArgumentException;

}

PlayingCard 类实现了Card接口，StandardDeck 类实现了Deck接口。

StandardDeck 类实现了抽象方法Deck.sort，如下：

public class StandardDeck implements Deck {

    private List<Card> entireDeck;

    // ...

    public void sort() {
        Collections.sort(entireDeck);
    }

    // ...
}

Collections.sort方法是一个List实例的排序，它的元素类型实现了Comparable接口。entireDeck成员是一个List实例，它的元素类型是Card，其继承了Comparable接口。PlayingCard类实现了Comparable.compartTo方法，如下：

public int hashCode() {
    return ((suit.value()-1)*13)+rank.value();
}

public int compareTo(Card o) {
    return this.hashCode() - o.hashCode();
}

compareTo方法使得StandardDeck.sort()中cards元素先按照suit排序，再按照rank排序。

如果你想要deck的排序先按照rank排序，再按照suit排序怎么办？你需要实现Comparator接口来指定新的排序规则，并且使用sort(List list, Comparator

public void sort(Comparator<Card> c) {
    Collections.sort(entireDeck, c);
} 

使用这种方法，你可以指定Collections.sort方法中Card类实例的排序。一种方式是实现Comparator接口来指定你想要的cards排序。下面的例子SortByRankThenSuit 就是这样做的。

package defaultmethods;

import java.util.*;
import java.util.stream.*;
import java.lang.*;

public class SortByRankThenSuit implements Comparator<Card> {
    public int compare(Card firstCard, Card secondCard) {
        int compVal =
            firstCard.getRank().value() - secondCard.getRank().value();
        if (compVal != 0)
            return compVal;
        else
            return firstCard.getSuit().value() - secondCard.getSuit().value(); 
    }
}

下面先按照rank排序，再按照suit排序的方式调用deck的sort方法：

StandardDeck myDeck = new StandardDeck();
myDeck.shuffle();
myDeck.sort(new SortByRankThenSuit());

然而，这种方式太繁琐了。如果你能指定想要的排序，而不是排序的方式，那就更好了。假设你是编写Comparator接口的开发人员，向Comparator接口添加怎样的default方法或静态方法，才能使其他开发人员更容易地指定排序规则呢？

首先，假设你对于deck的排序想以rank比较来排序，与suit无关。你可以像下面的这种方式来调用StandardDeck.sort方法：

StandardDeck myDeck = new StandardDeck();
myDeck.shuffle();
myDeck.sort(
    (firstCard, secondCard) ->
        firstCard.getRank().value() - secondCard.getRank().value()
); 

因为Comparator 接口是一个函数式接口，因此你可以使用lambda表达式来作为sort函数的参数。在这个例子中，lambda表达式比较了两个整数值。

如果开发着能够仅仅通过Card.getRank方法来创建一个Comparator实例，那对于他们来说将会是简单的。特别的，如果开发者能够通过一个方法得到一个数值，例如getValue 或者hashCode方法，从而能够创建一个Comparator实例来比较任何对象，那将是有用的。Comparator接口已经通过使用静态方法比较增强了这个能力：

myDeck.sort(Comparator.comparing((card) -> card.getRank()));  

在这个例子中，你可以使用方法引用来代替：

myDeck.sort(Comparator.comparing(Card::getRank)); 

这个方法更好的演示了要什么排序，而不是怎样排序。

Comparator接口也增加了其他版本的比较方法，例如： comparingDouble 和comparingLong，这样能够通过比较其他数据类型来创建Comparator实例。

假设开发者想要超过一种规则比较对象来创建Comparator实例。例如deck的排序先比较rank，然后再比较suit，怎么办？像前面那样，你可以通过Lambda表达式来指定排序规则：

StandardDeck myDeck = new StandardDeck();
myDeck.shuffle();
myDeck.sort(
    (firstCard, secondCard) -> {
        int compare =
            firstCard.getRank().value() - secondCard.getRank().value();
        if (compare != 0)
            return compare;
        else
            return firstCard.getSuit().value() - secondCard.getSuit().value();
    }      
); 

如果能够通过一系列的Comparator实例构建一个Comparator实例，那将会对开发者来说更简单。Comparator接口已经通过default方法thenComparing增强了这个能力：

myDeck.sort(
    Comparator
        .comparing(Card::getRank)
        .thenComparing(Comparator.comparing(Card::getSuit)));

Comparator接口已经增加了其他版本的thenComparing(例如 thenComparingDouble 和 thenComparingLong) default方法，使你能够通过比较其他数据类型来创建Comparator实例。

假设开发者希望创建一个Comparator实例，使它们能够以相反的顺序对对象集合进行排序。例如，你想要对deck中的cards按rank的降序排序，从Ace 到 Two（而不是从Two to Ace）？像之前一样，你可以指定另一个Lambda表达式。然而，如果开发者能够通过调用一个方法从而反转已经存在的Comparator，那将会更简单。Comparator接口已经通过default方法reversed实现了该功能：

myDeck.sort(
    Comparator.comparing(Card::getRank)
        .reversed()
        .thenComparing(Comparator.comparing(Card::getSuit)));

这个例子展示了Comparator接口如何通过default方法、静态方法、Lambda表达式和方法引用来创建一个更具表现力的库函数，开发者们能够很快的通过调用方式来推断出它们的功能。使用这些设计来增强库中的接口。

在JAVA8之前java中的接口类型旨在定义类型的接口规约，并不能拥有自己的方法实现，具体实现完全交由实现类自己完成。
在java8以后，接口中可以添加使用default或者static修饰的方法

default方法

default修饰方法只能在接口中使用，在接口种被default标记的方法为普通方法，可以直接写方法体。

1.实现类会继承接口中的default方法

如果接口中有default方法：

public interface demo {
	public default void demoFun(){
		System.out.println("我是接口");
	}
}

Test类实现接口：

public class Test implements demo {
	
}

那么Test类将会继承接口demo 中的demoFun方法：

public class Test2 {
	public static void main(String[] args) {
		Test t = new Test();
		t.default();
	}
}

2.如果一个类同时实现接口A和B，接口A和B中有相同的default方法，这时，该类必须重写接口中的default方法

(因为，类在继承接口中的default方法时，不知道应该继承哪一个接口中的default方法。)接口A：

public interface A {
	public default void c(){
		System.out.println("方法A");
	}
}

接口B：

public interface B {
	public default void c(){
		System.out.println("方法B");
	}
}

Test类：

public class Test implements A,B {
	@overried
	public default void c(){
		System.out.println("方法A,B");
	}
}

3.如果子类继承父类，父类中有b方法，该子类同时实现的接口中也有b方法（被default修饰），那么继承(extends)时覆盖了实现接口(implements)时的b()方法

接口A：

public interface A {
	public default void b(){
		System.out.println("A方法");
	}
}

类C：

public class C {
	public void b(){
		System.out.println("C方法");
	}
}

子类：

public class Test extends C implements A{

}

实例化:

Test test=new Test();
test.b()

输出值为:C方法

static方法

用法和普通的static方法一样。

代码示例
public interface InterfaceA {

    /**
     * 静态方法
     */
    static void showStatic() {
        System.out.println("static方法");
    }

}

测试

public class Test {
    public static void main(String[] args) {
        InterfaceA.show();
    }
}

结果

static方法

接口与插件：

      初见接口，你可能会奇怪为什么叫接口不叫插件，因为java接口的功能太像一个插件了，插上每个插件，就具有某种功能。

那么我举个例子你就明白了，比如说一个U盘就相当于一个插件，而要读取U盘的内容就得需要一个USB接口了，倘若缺少二者中的任何一个，都无法实现你想要达到的功能。

往抽象了说，电脑的外设都可以称为插件，而USB接口在电脑上可以有很多个，把电脑的PC主机抽象为一个类，那么你可以选择实现3个USB接口那么你就可以供3个插件使用并起作用（打印机，光驱），当然你也可以选择不实现，这都取决于你，至于这个插件本身的不同，USB接口并不关心，只取决于实现接口的类。这个就是现实意义中的“多态”。

接口的优缺点：

1.      达到了了C++的多继承的目的。一个类可以实现多个接口，在Java中类与类是单一继承，一个类只能由一个父类，打破了继承的局限性。
2.     降低了程序的耦合性，使程序能更好的被维护。
3.     缺点：由于每个继承接口的类都必须实现接口内部的功能，造成代码量的迅速膨胀。

接口的default方法：

   正如我们所熟知的， 接口里正常的方法是不能有函数体只能有一个类似于c++里的方法的声明而没有实现：

即使是空的方法体eclipse也会报错。

   每个“继承”接口的类如果没有声明为abstract 就必须将接口里的方法全部实现，一个都不能少。

    那么问题来了，倘若你想在这个类中添加一个新的方法，比如这个：

在这个接口里新加了一个test() 方法，但是为了能让程序编译能够通过我们不得不在每个继承Device接口的类中实现这个方法。这就给代码后期的维护与更新带来了很大的不便，缘于此，Java在jdk1.8版本为接口添加了一个default声明。

这个怎么使用呢？

我们看到了test方法的声明与在普通类中没有什么不同，当然除了那个public前的default。通过这个default声明我们可以在接口里实现一个类似于普通的class中的Static功能。

并且实现与否是由你自己决定的，你可以选择在继承接口的类中覆写这个方法，也可以选择不去管它。反正我们都是可以通过多态，将子类对象的引用赋给一个接口对象的引用。

我们在驱动类中创建一个接口类型的容器：

 然后我们在这个容器中添加“东西”：

 （注：Tv、Stopwacth、LightBulb是三个继承接口的类，其中Tv覆写了test方法）

 然后我们遍历这个容器：

看下结果：

是不是感觉有种覆写基类方法的感觉......

总结：

   a.有了default 我们可以在接口中实现普通类中的方法，有访问权限、函数体、返回类型。

   b.我们可以通过default 可以很容易的在接口中添加新的方法，而不是必须在每个继承该接口的类中覆写该方法。减少了java的代码量。

代码附录：

public interface Device {
	 
	void turnOn();
	
	void turnOff();
	
	default public void test() {
	System.out.println("I am a default method from interface from Device");
  }
	
}

public class Stopwacth implements Device{
	private int state;
	private long startTime;
	private String name;

	/**
	 * @param state
	 * @param startTime
	 * @param name
	 */
	public Stopwacth(int state, long startTime, String name) {
		super();
		this.state = state;
		this.startTime = startTime;
		this.name = name;
	}

	@Override
	public void turnOn() {
		System.out.println(" The stopwatch has been turned on.");
		
	}

	@Override
	public void turnOff() {
		System.out.println(" The stopwatch has been turned on.");
		
	}
	public String toString() {
		return "stopwatch: "+" state: "+this.state+" startTime: "+this.startTime+
				" name: "+this.name;
	}
	

}

public class Tv implements Device {
	
	private String name;
	
	public Tv(String initialname)
	{
		this.name = initialname;
	}

	@Override
	public void turnOn() {
		
		System.out.println(" The Tv has been turned on.");
		
	}

	@Override
	public void turnOff() {
		
		System.out.println(" The Tv has been turned off.");
		
	}
	
	public String toString() {
		return "name: "+this.name;
	}
	public void test() {
		System.out.println("����TV class��");
	}

}

public class LightBulb implements Device{
	private String name;
	

	/**
	 * @param name
	 */
	public LightBulb(String name) {
		super();
		this.name = name;
	}

	@Override
	public void turnOn() {
		System.out.println(" The LightBulb has been turned on.");
		
	}

	@Override
	public void turnOff() {
		System.out.println(" The LightBulb has been turned on.");
		
	}
	public String toString() {
		return "LightBulb:\n"+"name: "+this.name;
	}

}

import java.util.ArrayList;

public class Main {
	
    private ArrayList<Device> device = new ArrayList<Device>();

	public static void main(String[] args) {
		  
             Main m = new Main();
             m.addDevice();
             m.display();
             
	}
	private void display() {
		for(Device de:device) {
			de.turnOn();
			de.turnOff();
			de.test();
		}
		
	}
    private void addDevice() {
		device.add(new Tv("ximenzi"));
		device.add(new Tv("songxia"));
		device.add(new Tv("changhong"));
		device.add(new Stopwacth(1,13333,"kaxiou"));
		device.add(new Stopwacth(2,2444,"kaxiou"));
		device.add(new Stopwacth(3,4555,"kaxiou"));
		device.add(new LightBulb("xiaoming"));
		device.add(new LightBulb("xiaofang"));
		device.add(new LightBulb("xiaohong"));
    }
    
	

}