Java-面向对象三大特性详解

前言

Java 作为一种面向对象的编程语言，其三大核心特性是封装（Encapsulation）、继承（Inheritance）和多态（Polymorphism）。下面我将详细讲解这三大特性，包括定义、作用、实现方式以及代码示例。

封装（Encapsulation）

定义

封装是指将对象的属性（数据）和方法（行为）绑定在一起，并通过访问控制来隐藏对象的内部实现细节，只对外暴露必要的接口。简单来说，就是“把该藏的藏起来，该露的露出来”。

作用

保护数据安全：防止外部直接访问和修改对象的内部数据。
提高代码可维护性：通过接口操作，降低模块间的耦合性。
隐藏实现细节：外部只需关心功能，不需了解内部如何实现。

实现方式

使用访问修饰符（如 private、protected、public）控制属性和方法的可见性。
提供 getter 和 setter 方法来间接访问和修改私有属性。
将相关方法组织在类中，实现高内聚。

代码示例

public class Person {
    private String name; // 私有属性
    private int age;

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

    // getter 和 setter 方法
    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;
        }
    }
}

class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice", 25);
        System.out.println(person.getName()); // 输出: Alice
        person.setAge(30);
        System.out.println(person.getAge()); // 输出: 30
    }
}

继承（Inheritance）

定义

继承是指一个类（子类）可以继承另一个类（父类）的属性和方法，从而实现代码复用和层次结构。Java 中通过关键字 extends 实现继承，且 Java 只支持单继承（一个类只能直接继承一个父类）。

作用

代码复用：子类无需重复定义父类的属性和方法。
扩展性：子类可以在继承的基础上添加新功能或重写父类方法。
建立类之间的关系：体现“is-a”关系（如“猫是动物”）。
多态基础：继承是多态的前提。

实现方式

使用 extends 关键字。
子类可以通过 super 关键字调用父类的构造方法或方法。
子类可以重写（@Override）父类的方法。

注意事项

父类的 private 成员不能被子类直接访问，但可以通过 getter/setter 间接访问。
Java 中所有类都默认继承自 Object 类。

代码示例

class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

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

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

    // 重写父类方法
    @Override
    public void eat() {
        System.out.println(name + " is eating bones.");
    }

    // 子类特有方法
    public void bark() {
        System.out.println(name + " is barking.");
    }
}

class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        dog.eat();  // 输出: Buddy is eating bones.
        dog.bark(); // 输出: Buddy is barking.
    }
}

多态（Polymorphism）

定义

多态是指同一个方法在不同的对象上表现出不同的行为。多态分为编译时多态（重载）和运行时多态（重写）。在 Java 中，多态通常通过父类引用指向子类对象来实现。

作用

灵活性：同一接口可以有多种实现方式。
可扩展性：新增子类无需修改已有代码。
统一性：通过父类类型调用方法，屏蔽子类差异。

实现方式

方法重载（Overloading）：同一个类中，方法名相同但参数列表不同。
方法重写（Overriding）：子类重写父类的方法。
父类引用指向子类对象：运行时根据实际对象类型调用对应方法。

代码示例

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

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

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

class Main {
    public static void main(String[] args) {
        Animal myAnimal;

        myAnimal = new Cat(); // 父类引用指向子类对象
        myAnimal.makeSound(); // 输出: Meow

        myAnimal = new Dog();
        myAnimal.makeSound(); // 输出: Woof

        // 方法重载示例
        printInfo("Test", 123);
        printInfo("Test");
    }

    // 方法重载
    public static void printInfo(String str) {
        System.out.println("String: " + str);
    }

    public static void printInfo(String str, int num) {
        System.out.println("String: " + str + ", Number: " + num);
    }
}

后记

特性	核心目标	关键实现手段
封装	隐藏细节，保护数据	`private` + `getter/setter`
继承	代码复用，层次化设计	`extends` + 方法重写
多态	灵活扩展，统一接口调用	父类引用 + 方法重写/接口实现