Java 面向对象三大特征（初学者入门）

Java 面向对象三大特征（初学者入门）

在 Java 编程中，面向对象编程（OOP, Object-Oriented Programming） 是核心思想之一。它的三大基本特征是 封装（Encapsulation）、继承（Inheritance）、多态（Polymorphism），掌握这些特性可以帮助我们更好地编写高效、可维护的代码。

---

一、封装（Encapsulation）

1. 什么是封装？

封装是指将对象的属性（数据）和行为（方法）包装在一起，并通过访问控制（如 private、public、protected 等）隐藏对象的内部实现，防止外部直接访问或修改数据。

简单来说，封装的核心思想是数据私有化，提供公共方法访问。

2. 为什么要使用封装？

• 保证数据安全，防止外部随意修改对象的数据。
• 隐藏实现细节，只暴露必要的功能，提高代码的可维护性。
• 提高代码的复用性，便于模块化开发。

3. 如何实现封装？

• 使用 private 关键字将属性隐藏，防止外部直接访问。
• 提供 public 的 getter 和 setter 方法，控制数据的访问权限。

4. 代码示例

public class Person {
    private String name;  // 私有属性，外部无法直接访问
    private int 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;
        } else {
            System.out.println("年龄不能小于0！");
        }
    }
}

5. 使用封装

public class Test {
    public static void main(String[] args) {
        Person p = new Person();
        p.setName("张三");
        p.setAge(25);

        System.out.println("姓名：" + p.getName());
        System.out.println("年龄：" + p.getAge());
    }
}

输出：

姓名：张三
年龄：25

---

二、继承（Inheritance）

1. 什么是继承？

继承是指子类（Subclass）继承父类（Superclass）的属性和方法，这样子类可以直接使用父类已有的功能，而无需重复编写代码。

继承的作用：

• 代码复用，减少重复代码，提高开发效率。
• 层次结构清晰，符合现实世界的分类逻辑。

2. 继承的关键字

• extends：子类使用 extends 关键字继承父类。
• super：子类可以使用 super 关键字调用父类的方法或构造器。

3. 代码示例

// 定义一个父类 Animal
public class Animal {
    String name;

    public void eat() {
        System.out.println(name + " 在吃东西");
    }
}

// 定义一个子类 Dog 继承 Animal
public class Dog extends Animal {
    public void bark() {
        System.out.println(name + " 在汪汪叫");
    }
}

// 测试继承
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "小黑";  // 继承了父类的 name 属性
        dog.eat();          // 继承了父类的 eat() 方法
        dog.bark();         // 子类自己的方法
    }
}

输出：

小黑 在吃东西
小黑 在汪汪叫

说明： Dog 类继承了 Animal，因此它可以使用 name 和 eat() 方法，而 bark() 方法是 Dog 类自己新增的。

---

三、多态（Polymorphism）

1. 什么是多态？

多态是指同一个方法在不同对象上表现出不同的行为，即父类引用指向子类对象时，调用的方法是子类重写的方法。

多态有两种常见形式：

1. 方法重写（Override）：子类重写父类的方法，调用时执行的是子类的方法。
2. 方法重载（Overload）：同一个类中多个方法方法名相同但参数不同。

2. 方法重写（Override）

• 子类对父类的方法进行重新定义，保证调用时执行子类的版本。
• 规则：
  • 方法名和参数列表必须相同。
  • 返回值必须相同或是父类返回值的子类（Java 1.5+）。
  • 访问权限不能比父类更严格（public → protected ❌）。
  • @Override 注解可以帮助检查是否正确重写。

示例代码

// 定义一个父类
public class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}

// 定义子类 Dog
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("狗：汪汪汪！");
    }
}

// 定义子类 Cat
public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("猫：喵喵喵！");
    }
}

// 测试多态
public class Test {
    public static void main(String[] args) {
        Animal a1 = new Dog(); // 父类引用指向子类对象
        Animal a2 = new Cat();

        a1.makeSound(); // 调用的是 Dog 的方法
        a2.makeSound(); // 调用的是 Cat 的方法
    }
}

输出：

狗：汪汪汪！
猫：喵喵喵！

即使 a1 和 a2 的编译类型是 Animal，但它们运行时会调用自己所属子类的 makeSound() 方法，这就是多态的作用！

---

四、小结

特性	概念	关键点	示例
封装	隐藏数据，提供访问方法	private、getter/setter	Person 类封装 name 和 age
继承	复用父类方法	extends、super	Dog 继承 Animal
多态	同一方法不同表现	@Override	Dog 和 Cat 继承 Animal 并重写 makeSound()