当前位置：首页 > article >正文

封装，继承，多态（续）

article 2026/1/23 12:26:40

在Java中，最基础的三原则无疑是封装，继承，多态

对于这三类，最基本同样最重要，我们是会经常遇到的，在编程中，会使用，但在考试中还有一定的不理解。

对于这点，我在这里进行汇总

一.封装的三个步骤

在 Java 中，封装的三个步骤也类似，但 Java 的语法和机制与 Python 有所不同。以下是 Java 中封装的三个步骤：

1. 定义类

封装的第一步是定义一个类，类是封装的载体，它将数据（属性）和行为（方法）组织在一起。

例如，定义一个“学生”类：

public class Student {private String name;  // 属性private int age;      // 属性// 构造方法public Student(String name, int age) {this.name = name;this.age = age;}// 方法public void study() {System.out.println(name + " is studying.");}
}

在这个例子中，Student 类定义了学生的基本属性（name 和 age）和行为（study 方法）。

2. 将数据隐藏在类的内部

封装的第二步是将类的内部数据（属性）隐藏起来，通常通过将属性设置为私有属性（使用 private 关键字）。这样，外部代码无法直接访问这些属性，只能通过类提供的方法来操作它们。例如：

public class Student {private String name;  // 私有属性private int age;      // 私有属性// 构造方法public Student(String name, int age) {this.name = name;this.age = age;}// 获取 name 属性的值public String getName() {return name;}// 设置 name 属性的值public void setName(String name) {this.name = name;}// 获取 age 属性的值public int getAge() {return age;}// 设置 age 属性的值public void setAge(int age) {if (age > 0) {this.age = age;} else {System.out.println("Invalid age.");}}// 方法public void study() {System.out.println(name + " is studying.");}
}

在这个例子中，name 和 age 是私有属性，外部代码无法直接访问它们，只能通过 getName、setName、getAge 和 setAge 这些方法来获取和设置它们的值。这样可以防止外部代码直接修改属性值，从而保证数据的安全性和一致性。

3. 提供公共接口

封装的第三步是为类提供公共接口（即公共方法），这些方法允许外部代码通过这些接口与类的内部数据进行交互，但隐藏了具体的实现细节。例如：

public class Student {private String name;  // 私有属性private int age;      // 私有属性// 构造方法public Student(String name, int age) {this.name = name;this.age = age;}// 获取 name 属性的值public String getName() {return name;}// 设置 name 属性的值public void setName(String name) {this.name = name;}// 获取 age 属性的值public int getAge() {return age;}// 设置 age 属性的值public void setAge(int age) {if (age > 0) {this.age = age;} else {System.out.println("Invalid age.");}}// 方法public void study() {System.out.println(name + " is studying.");}
}

在这个例子中，getName、setName、getAge 和 setAge 是公共方法，它们允许外部代码通过这些方法访问和修改私有属性的值，但隐藏了属性的直接访问。study 方法也是一个公共方法，它定义了学生的行为。

使用封装的类

在其他类中，可以通过创建 Student 类的对象来使用封装的方法：

public class Main {public static void main(String[] args) {Student student = new Student("Alice", 20);student.study();  // 调用方法System.out.println("Name: " + student.getName());  // 获取属性值student.setName("Bob");  // 设置属性值System.out.println("New Name: " + student.getName());}
}

通过这种方式，Java 的封装机制既保证了数据的安全性，又提供了灵活的操作接口。

二.继承

1. 继承的基本语法

在 Java 中，使用 extends 关键字来实现继承。子类继承父类后，可以访问父类的非私有属性和方法。

示例：

// 父类
class Animal {String name;public Animal(String name) {this.name = name;}public void speak() {System.out.println(name + " makes a sound.");}
}// 子类
class Dog extends Animal {public Dog(String name) {super(name); // 调用父类的构造方法}@Overridepublic void speak() {System.out.println(name + " barks.");}
}public class Main {public static void main(String[] args) {Animal myAnimal = new Animal("Generic Animal");myAnimal.speak(); // 输出：Generic Animal makes a sound.Dog myDog = new Dog("Buddy");myDog.speak(); // 输出：Buddy barks.}
}

2. 继承的特点

代码复用：子类继承父类后，可以直接使用父类的非私有属性和方法，减少代码重复。
扩展性：子类可以在继承父类的基础上，添加新的属性和方法，或者重写父类的方法以实现特定的行为。
层次结构：继承可以形成类的层次结构，子类可以继承父类的属性和方法，父类可以作为多个子类的共同基类。

3. 构造方法和继承

父类构造方法的调用：子类的构造方法中必须显式或隐式地调用父类的构造方法。如果父类有无参构造方法，则子类构造方法中可以省略 super() 调用；否则必须显式调用父类的构造方法。
super 关键字：用于访问父类的属性和方法，也可以在子类的构造方法中调用父类的构造方法。

示例：

class Animal {String name;public Animal(String name) {this.name = name;}
}class Dog extends Animal {public Dog(String name) {super(name); // 调用父类的构造方法}
}

4. 方法重写（Override）

子类可以重写父类的方法，以实现特定的行为。重写的方法必须与父类的方法具有相同的方法名、参数列表和返回值类型。

示例：

class Animal {public void speak() {System.out.println("Animal speaks.");}
}class Dog extends Animal {@Overridepublic void speak() {System.out.println("Dog barks.");}
}

5. 方法重载（Overload）

子类可以重载父类的方法，即在子类中定义多个同名方法，但参数列表不同。

示例：

class Animal {public void speak() {System.out.println("Animal speaks.");}
}class Dog extends Animal {@Overridepublic void speak() {System.out.println("Dog barks.");}public void speak(String language) {System.out.println("Dog barks in " + language);}
}

6. 访问修饰符和继承

public：父类中被声明为 public 的属性和方法可以在子类中访问。
protected：父类中被声明为 protected 的属性和方法可以在子类中访问，也可以在同一个包中的其他类中访问。
private：父类中被声明为 private 的属性和方法不能被子类直接访问，但可以通过父类提供的公共方法间接访问。
默认访问权限（无修饰符）：父类中没有访问修饰符的属性和方法只能在同一个包中的类中访问。

7. 继承的限制

Java 不支持多继承：一个类只能继承一个父类，但可以通过接口实现类似多继承的效果。
构造方法不能被继承：子类不能继承父类的构造方法，但可以通过 super() 调用父类的构造方法。
final 类和方法不能被继承或重写：如果一个类被声明为 final，则不能被继承；如果一个方法被声明为 final，则不能被子类重写。

8. 继承的使用场景

通用行为的抽象：父类可以定义通用的行为，子类可以继承并扩展这些行为。
代码复用：子类可以复用父类的代码，减少重复代码。
多态的实现：通过继承，可以实现运行时多态，即通过父类引用调用子类的方法。

9. 继承的优缺点

优点：
- 代码复用：减少重复代码。
- 扩展性：子类可以扩展父类的功能。
- 层次结构清晰：形成类的层次结构，便于理解和维护。
缺点：
- 耦合性高：子类与父类之间存在较强的依赖关系，父类的修改可能影响子类。
- 过度继承可能导致复杂性增加：过多的继承层次可能导致代码难以理解和维护。

总结

继承是面向对象编程中的一个重要特性，它允许子类继承父类的属性和方法，从而实现代码复用和功能扩展。通过合理使用继承，可以提高代码的可维护性和可扩展性。然而，过度使用继承可能导致代码耦合度过高，因此需要谨慎设计类的层次结构。

三.多态

多态在之前的博客中也描述过了

现在简要描写的是多态中重写与重载的使用，我相信不少人会把这两点给搞混，现在我来进行描述，帮助大家区分一下

多态（Polymorphism）是面向对象编程中的一个重要概念，它允许使用一个统一的接口来处理不同类型的对象，从而实现代码的通用性和灵活性。多态的核心在于“一个接口，多种实现”，即同一个接口可以被不同的子类实现，而调用代码不需要关心具体的实现细节。

在 Java 中，多态主要通过继承和接口来实现，具体包括编译时多态和运行时多态。

1. 编译时多态（静态多态）

编译时多态主要通过**方法重载（Overloading）**实现。方法重载允许在同一个类中定义多个同名方法，但这些方法的参数列表必须不同（参数类型、参数个数或二者都不同）。编译器根据方法的参数列表来决定调用哪个方法。

示例：

class Calculator {public int add(int a, int b) {System.out.println("Adding two integers");return a + b;}public double add(double a, double b) {System.out.println("Adding two doubles");return a + b;}public int add(int a, int b, int c) {System.out.println("Adding three integers");return a + b + c;}
}public class Main {public static void main(String[] args) {Calculator calc = new Calculator();calc.add(1, 2);          // 调用第一个 add 方法calc.add(1.5, 2.5);      // 调用第二个 add 方法calc.add(1, 2, 3);       // 调用第三个 add 方法}
}

在编译时，Java 编译器会根据方法的参数列表来确定调用哪个 add 方法。这种多态是静态的，因为方法的绑定是在编译时完成的。

2. 运行时多态（动态多态）

运行时多态主要通过方法重写（Overriding）和接口实现来实现。运行时多态的核心是父类引用指向子类对象，调用方法时，实际执行的是子类的实现。这种多态是动态的，因为方法的绑定是在运行时完成的。

方法重写实现运行时多态

当子类重写了父类的方法时，通过父类引用调用该方法时，实际执行的是子类的实现。

示例：

class Animal {public void speak() {System.out.println("Animal speaks");}
}class Dog extends Animal {@Overridepublic void speak() {System.out.println("Dog barks");}
}class Cat extends Animal {@Overridepublic void speak() {System.out.println("Cat meows");}
}public class Main {public static void main(String[] args) {Animal myDog = new Dog();myDog.speak();  // 输出：Dog barksAnimal myCat = new Cat();myCat.speak();  // 输出：Cat meows}
}

在这个例子中：

Animal 是父类，Dog 和 Cat 是子类。
Dog 和 Cat 都重写了 speak 方法。
在 main 方法中，myDog 和 myCat 是 Animal 类型的引用，但它们分别指向了 Dog 和 Cat 的对象。
调用 speak 方法时，实际执行的是子类的实现，而不是父类的实现。这种行为称为动态绑定或运行时多态。

接口实现实现运行时多态

接口是 Java 中实现多态的另一种方式。通过接口，不同的类可以实现同一个接口，并提供不同的实现。

示例：

interface Animal {void speak();
}class Dog implements Animal {@Overridepublic void speak() {System.out.println("Dog barks");}
}class Cat implements Animal {@Overridepublic void speak() {System.out.println("Cat meows");}
}public class Main {public static void main(String[] args) {Animal myDog = new Dog();myDog.speak();  // 输出：Dog barksAnimal myCat = new Cat();myCat.speak();  // 输出：Cat meows}
}