JAVA【封装、继承、多态】——详解

原创已于 2025-08-05 21:39:02 修改 · 929 阅读 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

爱敲代码的小白fll

关注

标签

#java #开发语言

分类编程语言理论

代码可运行

于 2025-08-05 21:31:33 首次发布

Java中的封装(Encapsulation)

封装是面向对象编程(OOP)的四大基本原则之一(其他三个是继承、多态和抽象)，在Java中封装主要有以下几个用途：

封装的主要目的

数据隐藏：将对象的内部状态(属性)隐藏起来，不允许外部直接访问
数据保护：防止外部代码随意修改对象内部数据，确保数据的完整性和安全性
简化使用：对外提供统一的访问接口，隐藏实现细节
提高可维护性：内部实现可以自由修改而不影响外部代码

如何实现封装

在Java中，主要通过以下方式实现封装：

使用private访问修饰符修饰类的成员变量
提供公共的getter和setter方法来访问和修改这些变量

public class Person {
    // 私有属性 - 封装的核心
    private String name;
    private int age;
    
    // 公共的getter方法 - 提供对属性的受控访问
    public String getName() {
        return name;
    }
    
    // 公共的setter方法 - 提供对属性的受控修改
    public void setName(String name) {
        if(name != null && !name.isEmpty()) {
            this.name = name;
        }
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        if(age > 0 && age < 120) {  // 添加验证逻辑
            this.age = age;
        }
    }
}

封装的好处

灵活性：可以在setter方法中添加验证逻辑，确保数据的有效性
可维护性：修改内部实现不会影响使用该类的代码
安全性：防止外部代码直接访问敏感数据
易于扩展：可以在getter/setter中添加额外功能(如日志记录)而不改变接口

封装是Java中实现信息隐藏和模块化的关键机制，是构建健壮、可维护应用程序的基础。

Java中的继承(Inheritance)

继承是面向对象编程(OOP)的四大基本原则之一，在Java中继承主要有以下用途：

继承的主要目的

代码复用：允许子类继承父类的属性和方法，避免重复编写相同代码
建立类层次结构：创建更专业的类(子类)基于更一般的类(父类)
实现多态：为方法重写和方法动态绑定提供基础
扩展功能：子类可以在继承的基础上添加新的属性和方法

如何实现继承

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

class ParentClass {
    // 父类成员
}

class ChildClass extends ParentClass {
    // 子类成员
}

示例

// 父类(基类)
class Animal {
    String name;
    
    public void eat() {
        System.out.println(name + " is eating.");
    }
}

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

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.name = "Buddy";  // 继承自Animal类
        myDog.breed = "Golden Retriever";
        myDog.eat();  // 继承的方法
        myDog.bark(); // 子类特有的方法
    }
}

继承的特点

单继承：Java只支持单继承(一个子类只能有一个直接父类)
多层继承：可以有多级继承关系(A→B→C)
继承访问权限：
- 子类继承父类所有非private成员
- 子类不能继承父类的构造方法
方法重写：子类可以重写(override)父类的方法

继承的好处

提高代码复用性：公共属性和方法只需在父类中定义一次
提高可维护性：公共修改只需在父类中进行
实现多态：为面向接口编程打下基础
逻辑层次清晰：反映现实世界的分类关系

注意事项

不要过度使用继承，可能导致类层次过于复杂
考虑使用组合(composition)代替继承，特别是当"is-a"关系不明确时
父类的修改会影响所有子类，设计时需要谨慎

继承是Java中实现代码重用和建立类关系的重要机制，合理使用可以大大提高代码的可维护性和扩展性。

Java中的多态(Polymorphism)

多态是面向对象编程(OOP)的四大基本原则之一，在Java中多态主要有以下用途：

多态的主要目的

接口统一：允许使用统一的接口操作不同类型的对象
动态绑定：在运行时确定调用的具体方法，提高代码灵活性
代码扩展性：在不修改现有代码的情况下扩展程序功能
降低耦合：减少类之间的依赖关系

多态的类型

Java中主要实现两种多态：

编译时多态(静态多态)：通过方法重载实现
运行时多态(动态多态)：通过方法重写和继承实现

多态的实现方式

1. 方法重载(Overloading) - 编译时多态

class Calculator {
    // 方法重载
    int add(int a, int b) {
        return a + b;
    }
    
    double add(double a, double b) {
        return a + b;
    }
}

2. 方法重写(Overriding) + 向上转型 - 运行时多态

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

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

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

public class Main {
    public static void main(String[] args) {
        Animal myAnimal;  // 父类引用
        
        myAnimal = new Dog();  // 向上转型
        myAnimal.makeSound();  // 输出"Dog barks"
        
        myAnimal = new Cat();  // 向上转型
        myAnimal.makeSound();  // 输出"Cat meows"
    }
}