详解 Java 基础中的继承、封装与多态

红烧白开水。

于 2025-02-09 13:42:09 发布

阅读量364

点赞数 4

文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/qq_45729306/article/details/145517510

版权

Java 作为一门面向对象的编程语言，核心概念包括 继承、封装和多态。这些概念提高了代码的复用性、可维护性和扩展性。本文将详细讲解它们的作用，并提供相应的代码示例。

1. 继承（Inheritance）

继承是面向对象编程的重要特性，它允许一个类（子类）继承另一个类（父类）的属性和方法。继承可以提高代码的复用性，使得代码更易维护。

1.1 继承的基本语法

在 Java 中，使用 extends 关键字实现继承：

// 父类
class Animal {
    String name;

    public void eat() {
        System.out.println(name + " is eating.");
    }
}

// 子类继承 Animal
class Dog extends Animal {
    public void bark() {
        System.out.println(name + " is barking.");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "Buddy";
        dog.eat(); // 继承自 Animal
        dog.bark(); // Dog 自己的方法
    }
}

1.2 继承的特点

子类继承父类的非私有属性和方法。
子类可以重写父类的方法（见多态部分）。
Java 只支持单继承，即一个类只能继承一个父类。
可以通过 super 关键字访问父类的方法和构造函数。

1.3 `super` 关键字

super 用于调用父类的方法或构造方法：

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

class Dog extends Animal {
    public void makeSound() {
        super.makeSound(); // 调用父类的方法
        System.out.println("Dog barks");
    }
}

2. 封装（Encapsulation）

封装是指将数据（属性）和行为（方法）封装在一起，对外部隐藏实现细节，只暴露必要的接口，从而提高安全性。

2.1 封装的基本实现

在 Java 中，通常使用 private 关键字 限制属性的访问，并通过 public 方法（getter 和 setter）提供访问方式。

class Person {
    private String name;
    private int age;

    // 提供公共方法访问 private 属性
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        } else {
            System.out.println("Age must be positive");
        }
    }
}

public class EncapsulationExample {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("Alice");
        person.setAge(25);
        
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
    }
}

2.2 封装的优点

隐藏实现细节，保护数据。
防止不合理的数据修改。
提高代码的可维护性。

3. 多态（Polymorphism）

多态允许同一个接口或方法在不同的类中有不同的表现形式。它主要体现在 方法重写（Override） 和 方法重载（Overload）。

3.1 方法重写（Override）

子类可以重写父类的方法，提供不同的实现。

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

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

public class PolymorphismExample {
    public static void main(String[] args) {
        Animal myAnimal = new Dog(); // 向上转型
        myAnimal.makeSound(); // 调用 Dog 的方法
    }
}

注意点：

重写的方法必须具有相同的方法签名。
子类方法的访问权限不能比父类更严格（如 public 方法不能被 protected 覆盖）。
父类方法可以是抽象方法，要求子类必须实现（见接口与抽象类）。

3.2 方法重载（Overload）

方法重载是指 同一个类中有多个方法名相同，但参数列表不同 的方法。

class MathUtils {
    public int add(int a, int b) {
        return a + b;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
}

public class OverloadingExample {
    public static void main(String[] args) {
        MathUtils math = new MathUtils();
        System.out.println(math.add(2, 3));       // 调用 int 版本
        System.out.println(math.add(2.5, 3.2));   // 调用 double 版本
    }
}