学习目录：

  1. 抽象类
  2. 抽象方法
  3. 接口
  4. 多个接口

一. 抽象类和抽象方法

数据抽象是隐藏某些细节，仅向用户展示必要信息的过程。
抽象可以通过抽象类或接口来实现。

抽象 关键字是一个非访问修饰符，用于类和方法：

  • 抽象类：是一种受限的类，不能直接用来创建对象（要访问它，必须由其他类继承）。
  • 抽象方法：只能在抽象类中使用，并且没有方法体。方法体由子类提供（继承自抽象类）。
    抽象类可以同时包含抽象方法和常规方法。

1. 1 例子：

这段代码定义了一个抽象类 Animal，其中包含一个抽象方法 animalSound() 和一个常规方法 sleep()。

1
2
3
4
5
6
7
8
9
10
abstract class Animal {
 // 定义了一个抽象类 Animal。
  public abstract void animalSound();
   // 抽象方法：没有方法体，必须由继承此类的子类提供实现
  
  public void sleep() {
      // 常规方法：有方法体，可以被直接使用
    System.out.println("Zzz");
  }
}

从上面的示例中，无法创建 Animal 类的对象：

1
Animal myObj = new Animal(); // 将会产生错误

2. 要访问抽象类，必须从另一个类继承它

接上述示例 1：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// 抽象类
abstract class Animal {
  // 抽象方法（没有方法体）
  public abstract void animalSound();
  
  // 普通方法
  public void sleep() {
    System.out.println("Zzz");
  }
}

// 子类（继承自 Animal）
class Pig extends Animal {
  public void animalSound() {
    // 在这里提供了 animalSound() 方法的实现
    System.out.println("阿伟的叫声: 不要啦！杰哥！不要");
  }
}

class Main {
  public static void main(String[] args) {
    Pig myPig = new Pig(); // 创建一个 Pig 对象
    myPig.animalSound();   // 调用 animalSound 方法
    myPig.sleep();         // 调用 sleep 方法
  }
}

二. 接口

在 Java 中，另一种实现抽象的方式是使用接口。

接口是一种完全的“抽象类”，用于将相关的方法归类，这些方法没有方法体。

1
2
3
4
interface Animal {
  public void animalSound(); // 接口方法（没有方法体）
  public void run(); // 接口方法（没有方法体）
}

要访问接口的方法，必须通过另一个类使用关键字 **implements**（类似于继承）来“实现”该接口，而不是使用 **extends**。接口方法的具体实现由“实现”接口的类提供。

翻译：

  • **implements**：关键字，用于实现接口的方法。
  • **extends**：用于继承类，不适用于实现接口。

1. 2 例子：分 3 段翻译，有部分1.0，2.0，3.0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// 接口
// 部分1.0
interface Animal { // 运用了interface
  public void animalSound(); // 接口方法（没有方法体）
  public void sleep(); // 接口方法（没有方法体）
} // Animal 是一个接口，定义了两个方法

// 部分2.0
// 类 Pig 实现了 Animal 接口
class Pig implements Animal {
  // 实现接口方法 animalSound
  public void animalSound() {
    System.out.println("阿伟的叫声: 不要啦！杰哥！不要");
  }
  
  // 实现接口方法 sleep
  public void sleep() {
    System.out.println("Zzz");
  }
}

// 部分3.0
// 主类
class Main {
  public static void main(String[] args) {
    Pig myPig = new Pig(); // 创建一个 Pig 类的对象
    myPig.animalSound();   // 调用 animalSound 方法
    myPig.sleep();         // 调用 sleep 方法
  }
}

**部分1.0 翻译 : ** 在 Java 中，接口只声明方法，而不提供方法体。

  • interface（接口） 是一种特殊的类类型，用于定义一组方法（行为），但不提供具体的实现。
  • Animal 是一个接口，定义了两个方法：animalSound() 和 sleep()，但没有提供它们的具体实现。

部分2.0 翻译： 类 Pig 实现 Animal 接口

  • Pig 类 实现了 Animal 接口，这意味着 Pig 类必须提供接口中所有方法的具体实现。
  • animalSound() 方法的实现是打印 "阿伟的叫声: 不要啦！杰哥！不要"。
  • sleep() 方法的实现是打印 "Zzz"。

部分3.0 翻译： 主类main

  • Main 类 中定义了 main 方法，这是 Java 程序的入口点。main 方法中的代码是程序开始执行时运行的部分。
  • Pig myPig = new Pig();：创建了 Pig 类的对象 myPig。
  • myPig.animalSound();：调用 myPig 对象的 animalSound() 方法，输出 "阿伟的叫声: 不要啦！杰哥！不要"。
  • myPig.sleep();：调用 myPig 对象的 sleep() 方法，输出 "Zzz"。

2 接口小总结：

  1. 像抽象类一样，接口不能用来创建对象。
  2. 接口方法没有方法体 - 方法体由“实现”该接口的类提供。
  3. 实现接口时，必须重写所有接口的方法。
  4. 接口方法默认是 public 和 abstract 的。
  5. 接口的属性默认是 public static final 的。
  6. 接口不能包含构造方法（因为接口不能用于创建对象）。

3 多个接口

  • 实现多个接口，用逗号隔开
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
// 定义第一个接口
interface FirstInterface {
  public void myMethod(); // 接口方法
}

// 定义第二个接口
interface SecondInterface {
  public void myOtherMethod(); // 接口方法
}

// DemoClass 类实现了 FirstInterface 和 SecondInterface 接口
class DemoClass implements FirstInterface, SecondInterface {
  // 实现 myMethod() 方法
  public void myMethod() {
    System.out.println("一些文件...");
  }
  
  // 实现 myOtherMethod() 方法
  public void myOtherMethod() {
    System.out.println("其它的一些文件...");
  }
}

// 主类，包含程序入口方法
class Main {
  public static void main(String[] args) {
    // 创建 DemoClass 类型的对象
    DemoClass myObj = new DemoClass();
    
    // 调用 myMethod() 方法
    myObj.myMethod();
    
    // 调用 myOtherMethod() 方法
    myObj.myOtherMethod();
  }
}

总结：

  • **FirstInterface 和 SecondInterface**：两个接口分别声明了 myMethod() 和 myOtherMethod() 方法，但没有提供实现，具体实现需要在类中提供。
  • **DemoClass**：实现了这两个接口，并为其方法提供了具体实现。调用 myMethod() 时打印 "Some text.."，调用 myOtherMethod() 时打印 "Some other text..."。
  • Main 类：在 main 方法中创建 DemoClass 对象并调用了 myMethod() 和 myOtherMethod() 方法，演示了接口的实现与方法的调用。