继承使用初探

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

继承的实现
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面向对象编程的基石，合理使用可显著提升代码复用性和扩展性。掌握重写、类型转换、抽象类和接口等特性，结合设计原则，能够构建更健壮的系统架构。