Java继承与高级特性

继承使用初探

类的继承是面向对象编程的核心特性之一，允许子类继承父类的属性和方法，从而实现代码复用和层次化设计。

继承的实现
Java中通过extends关键字实现继承。子类自动获得父类的非私有成员（属性和方法）。

class Animal {
void eat() {
System.out.println("Animal is eating");
}
}

class Dog extends Animal {
void bark() {
System.out.println("Dog is barking");
}
}

Dog类继承Animal后，可直接调用eat()方法，同时拥有自己的bark()方法。

继承与重写
子类可以重写（Override）父类的方法以满足特定需求。重写需遵循以下规则：

• 方法名、参数列表必须与父类一致。
• 访问修饰符不能比父类更严格（如父类为protected，子类不能为private）。
• 返回类型可以是父类返回类型的子类（协变返回类型）。

class Animal {
void makeSound() {
System.out.println("Animal makes a sound");
}
}

class Cat extends Animal {
@Override
void makeSound() {
System.out.println("Cat meows");
}
}

继承与类型转换

• 向上转型：子类对象赋值给父类引用（隐式转换）。

  Animal myPet = new Dog(); // 向上转型
  myPet.eat(); // 调用父类方法

• 向下转型：父类引用强制转换为子类类型（需显式转换，可能存在ClassCastException风险）。

  if (myPet instanceof Dog) {
  Dog myDog = (Dog) myPet; // 向下转型
  myDog.bark();
  }

实用案例
设计一个图形类层次结构，Shape为父类，Circle和Rectangle为子类，重写计算面积的方法：

class Shape {
double area() {
return 0;
}
}

class Circle extends Shape {
double radius;
Circle(double r) { radius = r; }
@Override
double area() {
return Math.PI * radius * radius;
}
}

class Rectangle extends Shape {
double width, height;
Rectangle(double w, double h) {
width = w;
height = h;
}
@Override
double area() {
return width * height;
}
}

多态

多态性指同一操作作用于不同对象时产生不同的行为，通常通过方法重写和接口实现。

多态性的概念

• 编译时多态：通过方法重载实现（静态绑定）。
• 运行时多态：通过方法重写实现（动态绑定），依赖继承和接口。

实用案例
利用多态实现统一的动物行为调用：

class Animal {
void sound() {
System.out.println("Generic animal sound");
}
}

class Duck extends Animal {
@Override
void sound() {
System.out.println("Quack");
}
}

class Cow extends Animal {
@Override
void sound() {
System.out.println("Moo");
}
}

public class TestPolymorphism {
public static void main(String[] args) {
Animal[] animals = {new Duck(), new Cow()};
for (Animal a : animals) {
a.sound(); // 输出不同动物的声音
}
}
}

高级特性与设计原则

抽象类与接口

• 抽象类：用abstract声明，可包含抽象方法（无实现）和具体方法。子类必须实现所有抽象方法。

  abstract class Bird {
  abstract void fly();
  void breathe() {
  System.out.println("Breathing…");
  }
  }

  class Eagle extends Bird {
  @Override
  void fly() {
  System.out.println("Eagle flies high");
  }
  }

• 接口：Java 8后支持默认方法和静态方法，实现多继承。

  interface Swimmable {
  void swim();
  default void floatOnWater() {
  System.out.println("Floating");
  }
  }

  class Fish implements Swimmable {
  @Override
  public void swim() {
  System.out.println("Fish swims fast");
  }
  }

final关键字

• final修饰类：禁止继承。
• final修饰方法：禁止重写。
• final修饰变量：常量（不可修改）。

final class ImmutableClass {
final int value = 100;
final void display() {
System.out.println("Value: " + value);
}
}

设计原则应用

• 开闭原则：通过继承和多态扩展功能，而非修改原有代码。
• 里氏替换原则：子类必须能够替换父类且不影响程序正确性。

通过结合继承、多态和接口，可以构建灵活且易于维护的代码结构。例如，电商系统中的支付模块可通过接口支持多种支付方式：

interface Payment {
void pay(double amount);
}

class CreditCard implements Payment {
@Override
public void pay(double amount) {
System.out.println("Paid " + amount + " via Credit Card");
}
}

class PayPal implements Payment {
@Override
public void pay(double amount) {
System.out.println("Paid " + amount + " via PayPal");
}
}

class PaymentProcessor {
void process(Payment p, double amount) {
p.pay(amount);
}
}

总结

继承与多态是Java面向对象编程的基石，合理使用可显著提升代码复用性和扩展性。掌握重写、类型转换、抽象类和接口等特性，结合设计原则，能够构建更健壮的系统架构。