【Java基础小记】0823

一、 引言

在面向对象编程中，继承和方法重写是两个重要的概念，它们使得代码更加模块化、可复用和易于维护。在 Java 中，这些特性不仅有助于简化代码结构，还能提高代码的灵活性和扩展性。在这篇博客中，我们将深入探讨 Java 继承和方法重写的基础知识和应用场景。

什么是继承？

继承是一种机制，它允许一个类（称为子类）继承另一个类（称为父类）的属性和方法。这种机制的主要目的是实现代码的复用和简化代码的设计。继承使得我们可以在一个类中定义通用的功能，然后在另一个类中扩展或修改这些功能，从而避免重复编写相似的代码。

继承的重要性和应用场景

继承的重要性体现在以下几个方面：

1. 代码复用：通过继承，子类可以复用父类中的已有代码，减少代码重复。
   结构化设计：继承提供了一种结构化设计的方式，使得代码更加模块化和层次化。
   易于扩展：通过继承，新的功能可以通过扩展现有的类来实现，而无需修改原有的代码。
   常见的应用场景包括：

2. 类层次结构：如设计一个动物类（Animal）作为基类，然后设计不同的动物类（如 Dog、Cat）作为子类。
   库和框架：许多 Java 库和框架利用继承来提供可扩展的功能。
   方法重写的概念和目的
   方法重写（Overriding）是继承中的一个重要特性，它允许子类重新定义父类中已存在的方法。重写使得子类可以提供特定于其自身的实现，而不是使用父类的实现。这种机制使得多态性成为可能，即同一个方法调用可以有不同的行为，取决于对象的实际类型。

二、 继承的基本概念与语法

2.1 继承的基本概念

在 Java 中，继承允许一个类（子类）从另一个类（父类）继承字段和方法。子类获得了父类的所有非私有成员，并且可以扩展或修改这些成员。继承是实现面向对象设计中**“is-a”**关系的关键机制，即子类是一种父类的特例。

2.2 继承的语法

在 Java 中，继承通过关键字 extends 实现。以下是继承的基本语法：

class Parent {
    // 父类的字段
    int age;
    
    // 父类的方法
    void display() {
        System.out.println("This is parent class");
    }
}

class Child extends Parent {
    // 子类的字段
    String name;
    
    // 子类的方法
    void show() {
        System.out.println("This is child class");
    }
}

在上面的代码示例中，Child 类通过 extends 关键字继承了 Parent 类。Child 类可以访问 Parent 类中的 age 字段和 display() 方法，并且可以定义自己的字段和方法（如 name 和 show()）。

2.3 继承的规则

单继承：Java 支持单继承，即一个子类只能有一个直接父类。尽管如此，Java 支持多重继承的接口（通过 implements 关键字），但一个类不能同时继承多个类。

构造函数：构造函数不会被继承。子类可以调用父类的构造函数，通过 super 关键字来初始化父类的部分。

class Parent {
    Parent() {
        System.out.println("Parent constructor");
    }
}

class Child extends Parent {
    Child() {
        super(); // 显式调用父类构造函数
        System.out.println("Child constructor");
    }
}

访问权限：子类可以访问父类的 public 和 protected 成员，但不能访问 private 成员。private 成员只能在定义它的类中访问。

方法隐藏和重写：如果子类定义了一个与父类同名的方法，这种方法隐藏了父类的方法。我们将在后续章节中详细讨论如何通过方法重写来提供子类特定的实现。

2.4 使用 super 关键字

super 关键字在子类中用于访问父类的成员（包括字段、方法和构造函数）。它可以用来：

调用父类的构造函数。
访问父类的字段。
调用父类的方法（尤其是在方法重写的情况下）。

class Parent {
    int age = 40;
    
    void display() {
        System.out.println("Parent's display method");
    }
}

class Child extends Parent {
    int age = 20;

    void show() {
        System.out.println("Child's age: " + age);
        System.out.println("Parent's age: " + super.age);
        super.display(); // 调用父类的方法
    }
}

在上述代码中，super.age 访问的是父类中的 age 字段，而 super.display() 调用的是父类中的 display() 方法。

2.5 继承的实践示例

为了更好地理解继承，我们来看一个简单的例子：

class Animal {
    void eat() {
        System.out.println("This animal eats food.");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("The dog barks.");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // 继承自 Animal 类
        dog.bark(); // Dog 类特有的方法
    }
}

在这个例子中，Dog 类继承了 Animal 类，拥有了 Animal 类的 eat() 方法，同时也定义了自己的方法 bark()。当创建 Dog 对象时，它可以调用 eat() 和 bark() 两种方法。

三、Java方法重写

方法重写（Method Overriding）是 Java 中面向对象编程的一个核心特性，它允许子类提供父类方法的特定实现。通过方法重写，子类可以对父类的已有方法进行修改，以满足特定的需求。

1. 方法重写的基本概念
   方法重写是指在子类中重新定义父类中已存在的方法，以改变或扩展其行为。重写的方法与父类方法具有相同的方法名称、返回类型和参数列表，但可以有不同的实现。

2. 方法重写的规则
   方法签名相同：子类重写的方法必须与父类中的方法具有相同的方法名称、返回类型和参数列表。这意味着重写的方法签名必须完全匹配父类方法的签名。

访问权限：子类重写的方法的访问权限不能低于父类方法的访问权限。例如，如果父类方法是 public，那么子类重写的方法也必须是 public，不能是 protected 或 private。如果父类方法是 protected，子类可以选择将其访问权限改为 public。

不能重写 final、static 和 private 方法：

final 方法不能被重写。
static 方法属于类而非实例，因此不能被重写。
private 方法只能在其定义的类中访问，子类不能访问或重写它。
抛出异常：子类重写的方法可以抛出比父类方法更多或不同类型的异常，但不能抛出比父类方法更多的受检异常（checked exceptions）。

3. 方法重写的语法
   要重写一个父类的方法，需要在子类中重新定义该方法，并使用 @Override 注解。这种注解是可选的，但推荐使用，因为它可以帮助编译器检查方法是否正确地重写了父类的方法。

class Parent {
    // 父类的方法
    void display() {
        System.out.println("This is parent class method");
    }
}

class Child extends Parent {
    // 重写父类的方法
    @Override
    void display() {
        System.out.println("This is child class method");
    }
}

在这个示例中，Child 类重写了 Parent 类中的 display() 方法。Child 中的 display() 方法将替代 Parent 中的 display() 方法的实现。

4. 使用方法重写
   方法重写通常用于实现多态性。当我们使用父类类型的引用指向子类对象时，通过重写的方法可以实现不同子类对象的特定行为。这种机制使得代码更加灵活和可扩展。

class Animal {
    void makeSound() {
        System.out.println("Some generic animal sound");
    }
}

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

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

public class Test {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();
        
        myDog.makeSound(); // 输出 "Woof"
        myCat.makeSound(); // 输出 "Meow"
    }
}

在这个示例中，myDog 和 myCat 都是 Animal 类型的引用，但它们分别指向 Dog 和 Cat 对象。调用 makeSound() 方法时，会执行相应子类的实现，体现了多态性。

5. 方法重写与重载的区别
   重写（Overriding）：在子类中重新定义父类的已有方法，使其具有新的实现。要求方法名称、返回类型、参数列表相同。

重载（Overloading）：在同一类中定义多个方法，这些方法具有相同的名称但不同的参数列表（参数数量或类型）。重载方法的返回类型可以不同，但参数列表必须不同。

class Example {
    void display() {
        System.out.println("Display with no parameters");
    }
    
    void display(String message) {
        System.out.println("Display with message: " + message);
    }
    
    void display(int number) {
        System.out.println("Display with number: " + number);
    }
}

在这个例子中，display() 方法被重载了三次，每次使用不同的参数列表。