Java 中的接口定义和继承规则详解

深藏阁楼爱情的钟 2024-03-30 12:14 62阅读 0赞

**目录**

1、接口的定义

（1）接口中的默认方法

（2）接口中的静态方法

2、Java 中的继承

（1）继承对方法覆盖和隐藏

（2）final 方法和 final 类

（3）抽象类和抽象方法

--------------------

### 1、接口的定义 ###

在 Java 中，接口是一种引用类型，类似于 class，在接口中只能包含常量、方法签名（没有方法体）、默认方法（有方法体）、静态方法（有方法体）和嵌套类。方法体只存在于默认方法和静态方法中。且接口不能被实例化，它们只能由类去实现或者由其他接口去继承。按照惯例，implements 语句跟在 extends 语句后面。// 先写 extends，后写 implements

接口中的所有抽象方法、默认方法和静态方法都是隐式的 public 方法，因此可以省略 public 修饰符。此外，接口也可以包含常量声明。在接口中定义的所有常量值都是隐式的 public、static 和 final。同样，你可以省略这些修饰符。

下边是一个接口的定义示例：

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));
        }
    }

#### （1）接口中的默认方法 ####

当你扩展一个包含默认方法的接口时，你可以执行以下操作：

*  完全不提及默认方法，这将使你的扩展接口继承默认方法。
 *  重新声明默认方法，使其变为抽象方法。
 *  重新定义默认方法，并使用新的默认方法覆盖它。

1）采用完全不提及默认方法的方式，扩展接口 TimeClient，如下所示：

public interface AnotherTimeClient extends TimeClient { }

那么实现 AnotherTimeClient 接口的任何类都将具有由默认方法 TimeClient.getZonedDateTime() 指定的实现逻辑。

2）采用重新声明默认方法的方式，扩展接口 TimeClient，如下所示：

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

那么任何实现 AbstractZoneTimeClient 接口的类都必须实现 getZonedDateTime() 方法；该方法是一个抽象方法，就像接口中所有其他非默认(和非静态)方法一样。

3）采用重新定义默认方法的方式，拓展接口 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 的任何类都将使用该拓展接口指定的 getZonedDateTime() 实现，而不是原接口 TimeClient 指定的实现。

#### （2）接口中的静态方法 ####

除了默认方法外，还可以在接口中定义静态方法。静态方法与定义它的类相关联，而不与任何类的对象相关联（不必通过创建对象去使用静态方法），在该类的所有实例中，静态方法都是共享的。因此，你可以根据这个特性来定义一些工具类方法。如下所示（定义静态方法可以简化 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));
        }    
    }

注意：接口中的所有方法声明(包括静态方法)都是隐式公共的，因此可以省略 public 修饰符。

### 2、Java 中的继承 ###

#### （1）继承对方法覆盖和隐藏 ####

**1）实例方法**

方法覆盖（重写）：子类中的实例方法与父类中的实例方法具有相同的签名(相同的名称，相同的参数数量、相同的参数类型)和相同的返回类型，那么该方法将覆盖父类的方法。当重写一个父类方法时，可以使用 @Override 注释对方法进行标记，指定该方法为一个重写的方法（可用于编译前检查，减少编译错误）

**2）静态方法**

如果在子类中定义的静态方法与父类中的静态方法具有相同的签名，那么子类中的方法将隐藏父类中的方法。// 注意不是覆盖，此时父类中的静态方法仍然可以被子类调用

**隐藏静态方法和覆盖实例方法之间的区别有重要的含义：**

*  通过被覆盖的实例方法执行的是子类中的方法逻辑
 *  调用被隐藏的静态方法要取决于它是从父类进行调用还是从子类进行调用的。

为了更好的解释以上逻辑，参考下边代码示例：

// 父类
    public class Animal {
        public static void testClassMethod() {
            System.out.println("The static method in Animal");
        }
        public void testInstanceMethod() {
            System.out.println("The instance method in Animal");
        }
    }
    // 子类
    public class Cat extends Animal {
        public static void testClassMethod() {
            System.out.println("The static method in Cat");
        }
        public void testInstanceMethod() {
            System.out.println("The instance method in Cat");
        }
    
        public static void main(String[] args) {
            Cat myCat = new Cat();
            Animal myAnimal = myCat;
            Animal.testClassMethod(); // 使用父类调用静态方法
            myAnimal.testInstanceMethod();
        }
    }

以上程序的输出如下：

The static method in Animal
    The instance method in Cat

**3）默认方法**

接口中的默认方法和抽象方法都会像实例方法一样继承。但是，当类或接口的父类提供具有多个相同签名的默认方法时，Java 编译器将遵循继承规则来解决名称冲突。这些规则是由以下两个原则进行驱动的：

原则一：实例方法的继承要优先于接口的默认方法。程序示例如下：

public class Horse {
        public String identifyMyself() { // 实例方法
            return "I am a horse.";
        }
    }
    public interface Flyer {
        default public String identifyMyself() { // 默认方法
            return "I am able to fly.";
        }
    }
    public interface Mythical {
        default public String identifyMyself() { // 默认方法
            return "I am a mythical creature.";
        }
    }
    public class Pegasus extends Horse implements Flyer, Mythical {
        public static void main(String... args) {
            Pegasus myApp = new Pegasus();
            System.out.println(myApp.identifyMyself());
        }
    }

调用 Pegasus.identifyMyself 将返回字符串 I am a horse.

原则二：已经被其他父类覆盖的默认方法将被忽略。当父类拥有一个共同的祖先时，就会出现这种情况。

// 父类的共同父类 Animal 
    public interface Animal {
        default public String identifyMyself() {
            return "I am an animal.";
        }
    }
    // 父类 1
    public interface EggLayer extends Animal {
        default public String identifyMyself() {
            return "I am able to lay eggs.";
        }
    }
    // 父类 2
    public interface FireBreather extends Animal { }
    
    // 子类
    public class Dragon implements EggLayer, FireBreather {
        public static void main (String... args) {
            Dragon myApp = new Dragon();
            System.out.println(myApp.identifyMyself());
        }
    }

调用 Dragon.identifyMyself 将返回字符串：I am able to lay eggs 。此时，将执行 EggLayer 中重新定义的默认方法，而 FireBreather 中继承的默认方法被忽略。

如果两个或多个独立定义的默认方法冲突，或者默认方法与抽象方法冲突，那么 Java 编译器会产生编译器错误。此时，子类必须显式的重写父类的默认方法。示例程序如下，假如有以下两个接口：

// 接口一
    public interface OperateCar {
        // ...
        default public int startEngine(EncryptedKey key) {
            // Implementation
        }
    }
    // 接口二
    public interface FlyCar {
        // ...
        default public int startEngine(EncryptedKey key) {
            // Implementation
        }
    }

那么同时实现 OperateCar 和 FlyCar 的子类必须重写 startEngine() 方法。也可以使用 super 关键字调用任何一个父类的默认实现。示例程序如下：

public class FlyingCar implements OperateCar, FlyCar {
        // ...
        public int startEngine(EncryptedKey key) {
            FlyCar.super.startEngine(key);
            OperateCar.super.startEngine(key);
        }
    }

另外，从类继承的实例方法也可以覆盖抽象接口的方法。示例程序如下：

// 接口
    public interface Mammal {
        String identifyMyself();
    }
    // 类
    public class Horse {
        public String identifyMyself() {
            return "I am a horse.";
        }
    }
    // 子类：此时子类并没有实现 identifyMyself 方法的逻辑，而是被父类中的 identifyMyself 方法实现了
    public class Mustang extends Horse implements Mammal {
        public static void main(String... args) {
            Mustang myApp = new Mustang();
            System.out.println(myApp.identifyMyself());
        }
    }

调用 Mustang.identifyMyself 将返回字符串 I am a horse。Mustang 从 Horse 类继承了方法 identifyMyself()，该类重写了 Mammal 接口中的同名的抽象方法。

注意：接口中的静态方法永远不会被继承。静态方法是跟类关联在一起的，只要有访问该类的权限就可以使用该类中声明为 public 的静态方法，因为接口中的方法默认就是 public 的，所以跟继不继承没啥关系。// 类级别的访问权限只有 public 和 package-private（不做任何声明）

**4）使用权限更宽泛的修饰符**

覆盖方法的修饰符可以允许比被原覆盖方法的修饰符使用更加宽泛的权限，而且只能更宽泛不能更狭隘。例如，父类中的 protected 方法在子类中可以定义为 public，但不能定义为 private。

同时，不能将父类中的实例方法更改为子类中的静态方法，反之亦然。// 两种方法不一样

**5）对字段进行隐藏**

如果子类与父类中的字段具有相同名称，那么即使它们的类型不同，父类中的字段也会被隐藏。在子类中，如果需要访问父类中的字段，不能简单的通过其字段名称对其进行引用。相反，必须使用 super 关键字来访问该字段，一般来说，不建议去隐藏父类中的字段，因为这会做使代码变得难以阅读。

#### （2）final 方法和 final 类 ####

你可以将类和方法全部声明为 final。声明为 final 的方法表示该方法不能被子类进行覆盖。Object 类许多方法就是 final 的，他们都不能被。

如果一个方法的实现不应该被更改，且它对对象的一致状态也至关重要，那么就可以将该方法定义为 final。例如，可以将示例程序中 ChessAlgorithm 类中的 getFirstPlayer 方法设置为 final 方法：

class ChessAlgorithm {
        enum ChessPlayer { WHITE, BLACK }
        ...
        final ChessPlayer getFirstPlayer() {
            return ChessPlayer.WHITE;
        }
        ...
    }

在构造函数中调用的方法通常应该声明为 final 方法。因为如果在构造函数中调用非 final 方法，子类可能会重新去定义该方法，给程序造成不希望的结果。

你也可以将整个类声明为 final。声明为 final 的类不能被子类继承。例如，在创建 String 这样的不可变类时，将 String 声明为 final 的做法将特别有用。

#### （3）抽象类和抽象方法 ####

抽象类是声明为 abstract 的类，抽象类可以包含也可以不包含抽象方法。抽象类不能被实例化，但可以被子类继承。如果一个类包含抽象方法，那么该类必须声明为抽象类（abstract）。

当抽象类被子类继承时，子类通常会为其父类中的所有抽象方法提供具体实现。如果子类不为父类的抽象方法提供实现，那么子类也必须声明为抽象的。

接口中所有方法都是抽象的（默认方法和静态方法除外），因此 abstract 修饰符通常不会与接口中的方法一起使用。(可以使用，但没有必要)

抽象类可以有静态字段和静态方法。你可以使用类引用(例如AbstractClass.staticMethod())来使用这些静态成员，就像在普通类中使用一样。

**抽象类和接口的区别**

抽象类和接口都不能被实例化。

在抽象类中，可以包含抽象方法，也可以包含非抽象方法，还可以不包含抽象方法，同时，还可以声明非静态字段和 final 字段，并定义 public、protected 和private 修饰的具体方法。

在接口中，所有字段都是 public static final 修饰的，所有定义的方法都是 public 修饰的。此外，只能继承一个类，无论它是否是抽象类，但是可以实现任意数量的接口。// 抽象类是一个特殊的类，它不能被实例化

###  ###