接口和抽象类是实现抽象和多态性的基本组件。
Java中的接口是一种引用类型，类似于类，只能包含抽象方法、静态方法、默认方法和静态最终变量（常量）。 Java 中接口用于实现抽象和多重继承。接口不能直接实例化。
?在 Java 8 之前，接口只能有 抽象方法。
这些方法的实现必须在单独的类中提供。因此，如果要在接口中添加新方法，则必须在实现相同接口的类中提供其实现代码。
？为了解决这个问题，Java 8引入了默认方法的概念，它允许接口拥有带有实现的方法，而不影响实现该接口的类.
如果需要，可以通过实现类来覆盖默认方法。
Java中的抽象类是不能自行实例化的类，可以包含抽象方法（没有主体的方法）和具体方法（有主体的方法）。抽象类用于为子类提供公共基础，允许代码重用和共享行为的定义。
Java只支持单继承，即每个类只能继承一个类的字段和方法。如果您需要从多个源继承属性，Java 提供了接口的概念，它是多重继承的一种形式。
?接口与类类似。但是，它们仅定义方法的签名，而不定义其实现。接口中声明的方法在类中实现。 多重继承当一个类实现多个接口时就会发生。
在Java中，多重继承是通过接口而不是类来实现的。这允许一个类实现多个接口，并从每个接口继承方法签名。下面是一个使用接口演示多重继承的示例。
让我们定义两个接口，Flyable 和 Swimmable，以及一个实现这两个接口的 Duck 类。
public interface Flyable {
void fly();
}
public interface Swimmable {
void swim();
}
public class Duck implements Flyable, Swimmable {
@Override
public void fly() {
System.out.println("Duck is flying");
}
@Override
public void swim() {
System.out.println("Duck is swimming");
}
public static void main(String[] args) {
Duck duck = new Duck();
duck.fly();
duck.swim();
}
}
接口：
班级:
主要方法:
Duck is flying Duck is swimming
这里用一个简单的图来说明这种关系：
+----------------+
| Flyable |<--------------->Interface
|----------------|
| + fly() |
+----------------+
^
|
| Implements
|
+----------------+
| Duck |<--------------->Class
|----------------|
| + fly() |
| + swim() |
+----------------+
^
|
| Implements
|
+----------------+
| Swimmable |<--------------->Interface
|----------------|
| + swim() |
+----------------+
在此示例中，Duck 类通过实现 Flyable 和 Swimmable 接口来演示多重继承。这允许 Duck 类继承并提供两个接口中定义的方法的实现，展示了 Java 如何通过接口实现多重继承。
Java 中的抽象类用于为一系列相关类提供公共基础。它们可以包含抽象方法（没有主体的方法）和具体方法（有主体的方法）。下面是一个演示抽象类使用的示例。
让我们定义一个抽象类 Animal 和两个扩展 Animal 类的子类 Dog 和 Cat。
public abstract class Animal {
// Abstract method (does not have a body)
public abstract void makeSound();
// Concrete method (has a body)
public void sleep() {
System.out.println("The animal is sleeping");
}
}
public class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("Dog says: Woof!");
}
public static void main(String[] args) {
Dog dog = new Dog();
dog.makeSound();
dog.sleep();
}
}
public class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("Cat says: Meow!");
}
public static void main(String[] args) {
Cat cat = new Cat();
cat.makeSound();
cat.sleep();
}
}
抽象类：动物
子类：狗
子类：猫
对于狗类：
public interface Flyable {
void fly();
}
对于猫类：
public interface Swimmable {
void swim();
}
这里用一个简单的图来说明这种关系：
public class Duck implements Flyable, Swimmable {
@Override
public void fly() {
System.out.println("Duck is flying");
}
@Override
public void swim() {
System.out.println("Duck is swimming");
}
public static void main(String[] args) {
Duck duck = new Duck();
duck.fly();
duck.swim();
}
}
在此示例中，Animal 抽象类为 Dog 和 Cat 子类提供了公共基础。 Animal 类定义了一个必须由任何子类实现的抽象方法 makeSound() 和一个提供默认实现的具体方法 sleep()。 Dog 和 Cat 类扩展了 Animal 类并提供了它们自己的 makeSound() 方法的实现。
Duck is flying Duck is swimming
接口通常用于定义 API、框架和库。例如，java.util.List接口提供了列表实现的契约，例如ArrayList和LinkedList。
+----------------+
| Flyable |<--------------->Interface
|----------------|
| + fly() |
+----------------+
^
|
| Implements
|
+----------------+
| Duck |<--------------->Class
|----------------|
| + fly() |
| + swim() |
+----------------+
^
|
| Implements
|
+----------------+
| Swimmable |<--------------->Interface
|----------------|
| + swim() |
+----------------+
抽象类通常用于为一系列相关类提供基类。例如，java.util.AbstractList类提供了List接口的骨架实现，减少了子类需要实现的代码量。
public interface Flyable {
void fly();
}
| SNo | Interface | Abstract Class |
|---|---|---|
| 1 | Interfaces cannot be instantiated | Abstract classes cannot be instantiated |
| 2 | It can have both abstract and non-abstract methods | It can have both abstract and non-abstract methods |
| 3 | In interfaces, all fields are automatically public, static, and final, and all methods that you declare or define (as default methods) are public | In abstract classes, you can declare fields that are not static and final, and define public, protected, and private concrete methods |
| 4 | Interface supports multiple inheritance. Multiple interfaces can be implemented | Abstract class or class can extend only one class |
| 5 | It is used if you expect that unrelated classes would implement your interface. Eg, the interfaces Comparable and Cloneable are implemented by many unrelated classes | It is used if you want to share code among several closely related classes |
| 6 | It is used if you want to specify the behavior of a particular data type, but not concerned about who implements its behavior. | It is used if you expect that classes that extend your abstract class have many common methods or fields, or require access modifiers other than public (such as protected and private) |
参考：https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html
当抽象类被子类化时，子类通常为其父类中的所有抽象方法提供实现。但是，如果没有，则子类也必须声明为抽象的。
根据《Effective Java》的作者 Joshua Bloch 的说法，在定义类型时，接口比抽象类更受青睐，因为它们更灵活并且支持多重继承。然而，抽象类对于提供共享功能和减少代码重复很有用。
“接口非常适合定义 mixins。相比之下，类非常适合定义具有内在属性的对象。”
- 约书亚·布洛赫
在您自己的 Java 项目中探索接口和抽象类的强大功能。尝试使用接口定义合约并使用抽象类提供共享功能。与 Java 社区分享您的见解和经验，为集体知识和成长做出贡献。
欢迎对本文进行任何更正或补充。
public interface Flyable {
void fly();
}
以上是Java 中的接口和抽象类的详细内容。更多信息请关注PHP中文网其他相关文章！
