什么是继承？
继承（Inheritance）是面向对象编程（OOP）的四大基本特性之一，另外三大特性是封装（Encapsulation）、多态（Polymorphism）和抽象（Abstraction）。继承允许一个类从另一个类获取字段和方法的能力，从而实现代码的重用性和扩展性。继承体现了“is-a”的关系，即子类是父类的一种特殊化。
在Java中，继承通过关键字extends来实现。一个类可以继承另一个类，这样子类就可以使用父类中的字段和方法，同时可以添加新的字段和方法，或者重写父类的方法以提供特定的实现。
继承的基本概念
父类（Super Class）：也称为基类（Base Class）或超类（Parent Class），是被继承的类。子类（Sub Class）：也称为派生类（Derived Class）或子类（Child Class），是继承父类的类。方法重写（Method Overriding）：子类可以提供其父类中已存在方法的具体实现，称为方法重写。
继承的实现
基本示例
下面是一个基本的继承示例：
// 定义一个父类
class Animal {
String name;
void eat() {
System.out.println(name + " is eating.");
}
}
// 定义一个子类，继承自Animal类
class Dog extends Animal {
void bark() {
System.out.println(name + " is barking.");
}
}
// 测试继承关系
public class InheritanceTest {
public static void main(String[] args) {
Dog dog = new Dog();
dog.name = "Buddy";
dog.eat(); // 调用从父类继承的方法
dog.bark(); // 调用子类自己的方法
}
}
在这个示例中，Dog类继承了Animal类，因此Dog类可以访问Animal类中的字段name和方法eat()，并且可以定义自己的方法bark()。
方法重写
方法重写是指子类提供了与父类方法相同的名称、参数和返回类型的实现。重写的方法必须具有相同的访问权限，或者更宽松的权限。
class Animal {
void makeSound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
@Override
void makeSound() {
System.out.println("Dog barks");
}
}
public class InheritanceTest {
public static void main(String[] args) {
Dog dog = new Dog();
dog.makeSound(); // 调用Dog类的makeSound方法
}
}
在这个示例中，Dog类重写了Animal类的makeSound()方法。因此，调用Dog类的makeSound()方法时，会输出“Dog barks”。
继承的优点
代码重用性：继承使得子类可以重用父类中的字段和方法，减少了代码的重复。可扩展性：通过继承，可以在不修改现有代码的情况下扩展现有类的功能。多态性：继承是实现多态的基础，通过继承，可以使用父类类型的引用来指向子类对象，达到运行时的多态性。
继承的缺点
强耦合：继承会导致子类和父类之间的耦合度较高，子类会依赖父类的实现，如果父类发生改变，子类也可能需要相应地修改。单继承限制：Java中一个类只能继承一个直接父类，这限制了类的多重继承能力（不过可以通过接口来实现多继承的效果）。设计复杂性：过度使用继承可能会导致类层次结构过于复杂，增加理解和维护的难度。
继承与组合
除了继承，组合（Composition）也是一种常用的代码复用机制。组合是通过在一个类中包含另一个类的实例来实现功能扩展的。
class Engine {
void start() {
System.out.println("Engine starts");
}
}
class Car {
private Engine engine = new Engine();
void start() {
engine.start();
System.out.println("Car starts");
}
}
public class CompositionTest {
public static void main(String[] args) {
Car car = new Car();
car.start(); // 调用Car类的start方法
}
}
在这个示例中，Car类通过组合的方式包含了一个Engine实例，并在start()方法中调用Engine的start()方法。组合相比继承更加灵活，可以动态地替换被组合的对象，实现更高的可维护性。
接口与抽象类
在Java中，可以使用接口（Interface）和抽象类（Abstract Class）来实现更灵活的继承结构。
抽象类
抽象类是不能实例化的类，可以包含抽象方法和非抽象方法。抽象方法只有声明，没有实现，必须由子类来提供实现。
abstract class Animal {
abstract void makeSound();
void sleep() {
System.out.println("Animal is sleeping");
}
}
class Dog extends Animal {
@Override
void makeSound() {
System.out.println("Dog barks");
}
}
public class AbstractClassTest {
public static void main(String[] args) {
Dog dog = new Dog();
dog.makeSound(); // 调用Dog类的makeSound方法
dog.sleep(); // 调用父类Animal的sleep方法
}
}
在这个示例中，Animal类是一个抽象类，包含一个抽象方法makeSound()和一个非抽象方法sleep()。Dog类继承了Animal类并实现了makeSound()方法。
接口
接口是一个纯抽象类，只包含抽象方法（Java 8及以后可以包含默认方法和静态方法）。一个类可以实现多个接口，从而弥补了Java单继承的限制。
interface Animal {
void makeSound();
}
interface Pet {
void play();
}
class Dog implements Animal, Pet {
@Override
public void makeSound() {
System.out.println("Dog barks");
}
@Override
public void play() {
System.out.println("Dog plays");
}
}
public class InterfaceTest {
public static void main(String[] args) {
Dog dog = new Dog();
dog.makeSound(); // 调用Animal接口的方法
dog.play(); // 调用Pet接口的方法
}
}
在这个示例中，Dog类实现了Animal和Pet两个接口，从而具备了makeSound()和play()两个方法。
总结
继承是Java面向对象编程的重要特性，通过继承，子类可以复用父类的代码，增加代码的重用性和可扩展性。同时，继承也是实现多态的基础。然而，继承也有其局限性，例如类的强耦合和单继承限制。因此，在实际开发中，应该根据具体需求选择适当的代码复用机制，结合使用继承、组合、接口和抽象类，设计出灵活且可维护的代码结构。