Java的封装、继承、多态

Java的封装、继承、多态介绍

封装（Encapsulation）、继承（Inheritance）、多态（Polymorphism）是面向对象编程（OOP）中的三个重要概念，它们是实现代码重用、提高代码可维护性和扩展性的关键。

1、封装（Encapsulation）：

● 封装是将对象的状态（属性）和行为（方法）封装在一起，以实现数据隐藏和保护对象的内部状态。
● 封装可以通过访问修饰符（如 public、private、protected）来限制对对象内部状态的访问，从而确保数据的安全性和完整性。
● 通过提供公共的方法（getter 和 setter）来访问和修改对象的状态，封装隐藏了内部实现细节，使得对象的使用更加简单和安全。

2、继承（Inheritance）：

● 继承是一种通过在已有类的基础上创建新类的机制，新类可以继承已有类的属性和方法，从而实现代码重用和扩展。
● 在 Java 中，使用关键字 extends 来实现类的继承关系，子类可以继承父类的非私有成员变量和方法。
● 继承可以建立类之间的层次结构，通过在子类中添加新的方法或重写父类的方法，实现对父类行为的扩展和改进。

3、多态（Polymorphism）：

● 多态是指同一类型的对象在不同情况下会表现出不同的行为，实现同一方法在不同对象上具有不同的表现形式。
● 多态有两种实现方式：编译时多态（静态多态）和运行时多态（动态多态）。
------ 编译时多态通过方法的重载（Overloading）实现，即同一个类中有多个方法具有相同的名称但不同的参数列表。
------ 运行时多态通过方法的重写（Overriding）实现，即子类可以重写父类的方法，实现对方法的不同实现。
● Java 中的多态性是基于继承和重写的机制实现的，通过父类引用指向子类对象，在运行时动态绑定方法调用，实现不同子类对象的多态行为。

总的来说，封装、继承和多态是面向对象编程的基本特性，它们能够帮助我们构建更加灵活、可复用和可维护的代码结构，提高代码的可读性和可扩展性。

下面是一个简单的 Java 代码示例，演示了封装、继承和多态的基本用法：

// 封装：定义一个简单的人类，封装了姓名和年龄属性，并提供了访问和设置方法
class Person {
    private String name;
    private int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 访问姓名和年龄的方法
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    // 设置姓名和年龄的方法
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // 显示个人信息的方法
    public void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

// 继承：定义一个学生类，继承了人类的属性和方法，并添加了学号属性和学校属性
class Student extends Person {
    private String studentId;
    private String school;

    // 构造方法
    public Student(String name, int age, String studentId, String school) {
        super(name, age); // 调用父类的构造方法
        this.studentId = studentId;
        this.school = school;
    }

    // 访问学号和学校的方法
    public String getStudentId() {
        return studentId;
    }

    public String getSchool() {
        return school;
    }

    // 设置学号和学校的方法
    public void setStudentId(String studentId) {
        this.studentId = studentId;
    }

    public void setSchool(String school) {
        this.school = school;
    }

    // 重写父类的方法，显示学生信息的方法
    @Override
    public void displayInfo() {
        super.displayInfo(); // 调用父类的方法
        System.out.println("Student ID: " + studentId);
        System.out.println("School: " + school);
    }
}

// 多态：定义一个测试类，演示多态性
public class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice", 25);
        Student student = new Student("Bob", 20, "20210001", "ABC University");

        // 多态性：父类引用指向子类对象
        Person p = new Student("Charlie", 22, "20210002", "XYZ College");

        // 调用父类和子类的方法
        person.displayInfo();
        System.out.println();
        student.displayInfo();
        System.out.println();
        p.displayInfo(); // 虽然是 Person 类型的引用，但调用的是 Student 类的 displayInfo 方法
    }
}

这个示例中，Person 类封装了姓名和年龄属性，并提供了访问和设置方法；Student 类继承了 Person 类的属性和方法，并添加了学号和学校属性，并重写了父类的 displayInfo 方法；Main 类演示了多态性，通过父类引用指向子类对象，并调用了父类和子类的方法，展示了不同对象的多态行为。