java 一個類實現兩個介面的案例

直接用英文逗號分隔就可以了，比如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
inerface IHello {
  String sayHello(String name);
  
}
interface IHi {
  String sayHi(String name);
  
}
  
class ServiceImpl implements IHello, IHi {// 實現三個四個。。。n個介面都是使用逗號分隔
public String sayHello(String name) {
  return "Hello, " + name;
  
}
public String sayHi(String name) {
  return "Hi, " + name;
  
}
}
補充知識：Java 一個類實現的多個介面，有相同簽名的default方法會怎麼辦？

看程式碼吧~

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public interface A {
  default void hello() {
    System.out.println("Hello from A");
  }
}
public interface B extends A {
  default void hello() {
    System.out.println("Hello from B");
  }
}
public class C implements B, A {
  public static void main(String... args) {
    new C().hello();
  }
}
這段程式碼，會列印什麼呢？

有三條規則

類永遠贏。類宣告的方法，或者超類宣告的方法，比default方法的優先順序高

否則，子介面贏

否則，如果整合自多個介面，必須明確選擇某介面的方法

上面程式碼的UML圖如下

所以，上面的程式碼，輸出是

Hello from B

如果這樣呢？

1
2
3
4
5
6
7
8
public class D implements A{ 
   
}
public class C extends D implements B, A {
  public static void main(String... args) {
    new C().hello();
  }
}
UML圖是這樣的

規則1說，類宣告的方法優先順序高，但是，D沒有覆蓋hello方法，它只是實現了介面A。所以，它的default方法來自介面A。規則2說，如果類和超類沒有方法，就是子介面贏。所以，程式列印的還是“Hello from B”。

所以，如果這樣修改程式碼

1
2
3
4
5
6
7
8
9
10
public class D implements A{ 
  void hello(){
    System.out.println("Hello from D");
  }
}
public class C extends D implements B, A {
  public static void main(String... args) {
    new C().hello();
  }
}
程式的輸出就是“Hello from D”。

如果D這樣寫

1
2
3
public abstract class D implements A {
  public abstract void hello();
}
C就只能實現自己的抽象方法hello了。

如果是這樣的程式碼呢

1
2
3
4
5
6
7
8
9
10
11
12
13
public interface A {
  default void hello() {
    System.out.println("Hello from A");
  }
}
public interface B {
  default void hello() {
    System.out.println("Hello from B");
  }
}
public class C implements B, A { 
   
}
UML圖如下

會生成這樣的編譯器錯誤

"Error: class C inherits unrelated defaults for hello() from types B and A."

怎麼修改程式碼呢？只能明確覆蓋某介面的方法

1
2
3
4
5
public class C implements B, A {
  void hello(){
    B.super.hello();
  }
}
如果程式碼是這樣的，又會怎樣呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public interface A{
  default void hello(){
    System.out.println("Hello from A");
  }
}
public interface B extends A { 
   
}
public interface C extends A { 
   
}
public class D implements B, C {
  public static void main(String... args) {
    new D().hello();
  }
}
UML圖是這樣的

很明顯，還是不能編譯。

以上這篇java 一個類實現兩個介面的案例就是小編分享給大家的全部內容了