引言：
JDK8中，在接口中除了定义全局静态常量和公共抽象方法之外，还可以定义静态方法和默认方法
JDK8以后，在接口中除了能定义全局常量和抽象方法之外，还可以定义静态方法和默认方法
静态方法
使用static关键字修饰。可以通过接口直接调用静态方法（并且接口中的静态方只能通过接口本身来调用），并执行其方法体。java通常在相互使用的类中使用静态方法，可以在java标准库中找到像Collection/Collections或者Path/Paths这样成对的接口和类。
默认方法
默认方法使用default关键字修饰。可以通过实现类对象来调用。我们在已有的接口中提供新方法的同时，还保留了与旧版本代码的兼容性。比如：java8 API中对Collection、List、Comparator等接口提供了丰富的默认类。
interface CompareA {
//全局常量，其中public static final可省
public static final int a = 1;
//抽象方法，其中public abstract可省
public abstract void method();
//静态方法
public static void method1() {
System.out.println("method1");
}
//静态方法，省略public
static void method2() {
System.out.println("method2");
}
//默认方法
public default void method3() {
System.out.println("method3");
}
//默认方法，省略public
default void method4() {
System.out.println("method4");
}
}- 接口中定义的静态方法，只能通过接口来调用。”接口.静态方法”，有点像工具类。
- 通过实现类的对象，可以调用接口中的默认方法。
- 如果实现类重写了接口中的默认方法，调用时，调用的是重写以后的方法。
- 类优先原则：如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。如果子类重写过，那么调用的当然是子类重写后的方法
- 接口冲突：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错。这就需要我们必须在实现类中重写此方法
class SubClassTest {
public static void main(String[] args) {
SubClass1 s1 = new SubClass1();
//s.method1();//报错
//SubClass.method1();//报错
CompareA.method1();//知识点1：接口中定义的静态方法，只能通过接口来调用。
//知识点2：通过实现类的对象，可以调用接口中的默认方法。
//如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
s1.method2();//该方法被子类重写过
s1.method3();
System.out.println("*********************");
SubClass2 s2 = new SubClass2();
s2.method2();//该方法被子类重写过
//知识点3：如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，
//那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。-->类优先原则
//知识点4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
//那么在实现类没有重写此方法的情况下，报错。-->接口冲突。
//这就需要我们必须在实现类中重写此方法
s2.method3();//这里默认调用的是父类中的方法
}
}
interface CompareA {
//静态方法。静态方法不存在重写这一说法
public static void method1() {
System.out.println("CompareA:北京");
}
//默认方法
public default void method2() {
System.out.println("CompareA:上海");
}
default void method3() {
System.out.println("CompareA:重庆");
}
}
class SuperClass {
public void method3() {
System.out.println("SuperClass:重庆");
}
}
class SubClass1 implements CompareA {
public void method2() {
System.out.println("SubClass1:上海");
}
}
class SubClass2 extends SuperClass implements CompareA {
public void method2() {
System.out.println("SubClass2:上海");
}
}如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错。–>接口冲突。这就需要我们必须在实现类中重写此方法
class SubClassTest {
public static void main(String[] args) {
SubClass s = new SubClass();
s.method2();//子类重写过
s.method3();//其实是调用的父类中继承来的该方法
}
}
interface CompareA {
public static void method1() {
System.out.println("CompareA:北京");
}
public default void method2() {
System.out.println("CompareA:上海");
}
default void method3() {
System.out.println("CompareA:重庆");
}
}
interface CompareB {
default void method3() {
System.out.println("CompareB:重庆");
}
}
class SuperClass {
public void method3() {
System.out.println("SuperClass:重庆");
}
}
class SubClass extends SuperClass implements CompareA, CompareB{
public void method2() {
System.out.println("SubClass:上海");
}
//如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
//那么在实现类没有重写此方法的情况下，报错。-->接口冲突。
//如果没有extends SuperClass，则报错。必须去重写method3()
}接口可以多继承，多继承遇到同名默认方法时必须重写，不然会报错。重写后还是一个默认方法
interface A {
public default void method() {
System.out.println("interface A method");
}
}
interface B {
public default void method() {
System.out.println("interface B method");
}
}
interface C extends A, B {
@Override
default void method() {
System.out.println("interface C method");
A.super.method();//调用接口中的被重写的默认方法
B.super.method();
}
}如何在子类(或实现类)的方法中调用父类、接口中被重写的方法
interface CompareA {
public static void method1() {
System.out.println("CompareA:北京");
}
public default void method2() {
System.out.println("CompareA:上海");
}
default void method3() {
System.out.println("CompareA:重庆");
}
}
interface CompareB {
default void method3() {
System.out.println("CompareB:重庆");
}
}
class SuperClass {
public void method3() {
System.out.println("SuperClass:重庆");
}
}
class SubClass extends SuperClass implements CompareA, CompareB{
public void method2() {
System.out.println("SubClass:上海");
}
public void method3() {
System.out.println("SubClass:重庆");
}
//子类中的普通方法
public void myMethod() {
method3();//调用自定义的重写方法
super.method3();//调用父类中声明的方法
CompareA.super.method3();//调用接口中的被重写的默认方法，当然也只能在实现类中去这样调用
CompareB.super.method3();
}
}一个有趣的例子
interface Filial {// 孝顺的
default void help() {
System.out.println("老妈，我来救你了");
}
}
interface Spoony {// 痴情的
default void help() {
System.out.println("媳妇，别怕，我来了");
}
}
class Father{
public void help(){
System.out.println("儿子，救我媳妇！");
}
}
/*在不继承Father的情况下，如果不重写接口冲突的同名默认方法，则会报错。在继承Father的情况下，如果父类中有该重名方法，则子类可以不重写，默认调用的是从父类中继承来的同名方法。*/
class Man extends Father implements Filial, Spoony {
@Override
public void help() {
System.out.println("我该就谁呢？");
super.help();
Filial.super.help();
Spoony.super.help();
}
}
