Java面向对象编程三大特征详解：封装、继承与多态

封装：保护数据安全

封装是将抽象出的数据（属性）和对数据的操作（方法）结合成一个整体，并将内部细节隐藏起来。外界只能通过被授权的方法访问数据，从而保证数据的安全性与合理性。

第1步：定义私有属性

目的：限制外部直接修改类成员变量。 入口：类的定义中。 动作：使用 private 关键字修饰属性和字段。

第2步：提供公共访问器

目的：允许外部读取和修改数据，同时加入逻辑验证。 入口：类的定义中。 动作：创建公共的 getter 和 setter 方法。在 setter 中可以添加条件判断，例如限制年龄范围。

class Person {
    private String name; // 私有化属性，不可直接访问
    private int age;

    // Getter方法用于获取值
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    // Setter方法用于设置值并验证数据
    public void setAge(int age) {
        if (age < 1 || age > 150) {
            System.out.println("年龄需要在1~150之内~");
            return; 
        }
        this.age = age;
    }
}

封装的好处在于隐藏了实现的复杂性，用户只需调用方法即可操作对象，无需关心底层实现，同时也防止了非法数据的传入。

继承：提高代码复用性

当多个类存在相同的属性和方法时，可以抽取一个父类。子类通过 extends 关键字继承父类，无需重复编写相同代码，从而实现代码复用和层级化管理。

子类可以继承父类的非私有成员，也可以根据需求重写（Override）父类的方法，以改变其具体行为。

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.speak(); // 输出：喵喵~
    }
}

class Animal { // 父类
    public void speak() {
        System.out.println("动物会叫~");
    }
}

class Cat extends Animal { // 子类
    @Override
    public void speak() {
        System.out.println("喵喵~");
    }
}

子类对象实例化过程

继承不仅提高了代码的复用性，还增强了系统的可扩展性和维护性。在进行子类实例化时，JVM会自动先调用父类的构造方法完成初始化，再执行子类的构造逻辑。

多态：同一行为，多种形态

多态建立在封装和继承之上，指同一个对象在不同情境下表现出不同的状态或行为。主要体现在方法的调用上，即父类引用指向子类对象，实际执行的是子类重写后的方法。

方法多态：重载与重写

• 重载（Overload）： 方法名相同但参数列表不同，属于静态绑定，编译期确定。
• 重写（Override）： 子类覆盖父类方法，属于动态绑定，运行期确定。

class A {
    public int sum(int num1, int num2) {
        return num1 + num2;
    }
    
    // 方法重载：参数数量不同
    public int sum(int num1, int num2, int num3) {
        return num1 + num2 + num3;
    }
    
    public void say() {
        System.out.println("这是A的say()方法~");
    }
}

class B extends A {
    // 方法重写
    @Override
    public void say() {
        System.out.println("这是B的say()方法~");
    }
}

public class TestPolymorphism {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a.sum(1, 2));      // 3
        System.out.println(a.sum(1, 2, 3));   // 6
        
        A obj = new B(); // 父类引用指向子类对象
        obj.say();       // 输出：这是B的say()方法~ (体现多态)
    }
}

对象多态的核心机制

多态的核心在于“编译类型”与“运行类型”的分离。

1. 编译类型：定义对象时声明的类型（如 Animal animal），决定了该引用能调用哪些方法（仅限父类中声明的方法）。
2. 运行类型：实际创建的对象类型（如 new Dog()），决定了最终执行哪个方法实现。

Animal animal = new Dog(); // 向上转型
animal = new Cat();         // 运行类型变为Cat

虚拟方法调用规则：当调用实例方法时，Java虚拟机（JVM）会根据对象的运行类型动态绑定相应的方法；但若调用成员变量或静态方法，则取决于编译类型（哪里声明，就用哪里的）。

多态的应用场景

多态数组

数组声明为父类类型，但存储的元素可以是具体的子类对象，统一操作，各异其效。

Person[] persons = new Person[3];
persons[0] = new Student(); // 学生
persons[1] = new Teacher(); // 教师
// 遍历时可统一调用父类声明的方法，实际执行子类重写逻辑

多态参数

方法形参定义为父类类型，实参传入任意子类对象，极大提升了方法的通用性。

// 父类作为参数类型，兼容所有子类
public void pay(Employee e) {
    // 处理工资支付逻辑
}

掌握面向对象三大特征是编写健壮、可维护Java应用的关键。封装确保了安全，继承促进了复用，而多态赋予了程序灵活的变化能力。

以上就是Java面向对象编程的三大特征的详细内容，更多关于Java基础特性的资料请关注本站其它相关文章！