Java面向对象三大特性-封装继承多态

面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将数据和操作数据的方法绑定在一起，以对象为基本单元来组织代码。Java作为一种纯面向对象的编程语言，其核心特性包括封装、继承和多态。这三大特性是理解Java编程的基础，也是设计高质量代码的关键。

封装

概念

封装（Encapsulation）是指将对象的状态（属性）和行为（方法）绑定在一起，并对外部隐藏对象的内部实现细节。通过封装，可以控制对对象内部数据的访问，只暴露必要的接口供外部使用。

实现方式

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

1. 使用访问修饰符（private、protected、public）限制对成员变量和方法的访问
2. 提供公共的getter和setter方法来访问和修改私有成员变量
3. 将类的实现细节隐藏在内部，只暴露必要的接口

示例代码

public class Person {
    // 私有成员变量，外部无法直接访问
    private String name;
    private int age;
    
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // getter方法，用于获取name属性
    public String getName() {
        return name;
    }
    
    // setter方法，用于设置name属性
    public void setName(String name) {
        this.name = name;
    }
    
    // getter方法，用于获取age属性
    public int getAge() {
        return age;
    }
    
    // setter方法，用于设置age属性，带有数据校验
    public void setAge(int age) {
        if (age >= 0 && age <= 120) {
            this.age = age;
        } else {
            throw new IllegalArgumentException("年龄必须在0-120之间");
        }
    }
    
    // 公共方法，展示个人信息
    public void introduce() {
        System.out.println("我叫" + name + "，今年" + age + "岁");
    }
    
    public static void main(String[] args) {
        Person person = new Person("张三", 25);
        person.introduce();
        
        // 通过setter方法修改属性
        person.setAge(30);
        person.setName("李四");
        person.introduce();
        
        // 下面的代码会抛出异常，因为年龄不合法
        // person.setAge(150);
    }
    /**Output
     * 我叫张三，今年25岁
     * 我叫李四，今年30岁
     *///~
}

封装的优点

• 数据安全性：通过访问控制和数据校验，可以防止非法数据的输入
• 代码可维护性：隐藏实现细节，修改内部实现不会影响外部调用
• 代码复用性：封装好的类可以在不同的项目中重复使用

---

继承

概念

继承（Inheritance）是指一个类（子类/派生类）可以获取另一个类（父类/基类）的属性和方法。通过继承，可以实现代码复用，建立类之间的层次关系。

实现方式

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

class 子类名 extends 父类名 {
    // 子类的成员变量和方法
}

示例代码

// 父类：动物
class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void eat() {
        System.out.println(name + "正在吃东西");
    }
    
    public void sleep() {
        System.out.println(name + "正在睡觉");
    }
}

// 子类：狗，继承自动物
class Dog extends Animal {
    private String breed;
    
    public Dog(String name, String breed) {
        super(name); // 调用父类的构造方法
        this.breed = breed;
    }
    
    // 重写父类的eat方法
    @Override
    public void eat() {
        System.out.println(name + "（" + breed + "）正在啃骨头");
    }
    
    // 子类特有的方法
    public void bark() {
        System.out.println(name + "汪汪汪");
    }
}

// 子类：猫，继承自动物
class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }
    
    @Override
    public void eat() {
        System.out.println(name + "正在吃鱼");
    }
    
    public void meow() {
        System.out.println(name + "喵喵喵");
    }
}

public class InheritanceTest {
    public static void main(String[] args) {
        Dog dog = new Dog("旺财", "金毛");
        dog.eat();
        dog.sleep();
        dog.bark();
        
        Cat cat = new Cat("咪咪");
        cat.eat();
        cat.sleep();
        cat.meow();
    }
    /**Output
     * 旺财（金毛）正在啃骨头
     * 旺财正在睡觉
     * 旺财汪汪汪
     * 咪咪正在吃鱼
     * 咪咪正在睡觉
     * 咪咪喵喵喵
     *///~
}

继承的特点

• Java只支持单继承，一个子类只能有一个直接父类
• 子类可以继承父类的非私有成员（包括protected和public）
• 使用super关键字可以调用父类的构造方法和成员
• 子类可以重写（override）父类的方法

---

多态

概念

多态（Polymorphism）是指同一个方法调用可以根据对象的实际类型产生不同的行为。多态分为编译时多态（方法重载）和运行时多态（方法重写）。

编译时多态（方法重载）

方法重载是指在同一个类中，方法名相同但参数列表不同的多个方法。编译器在编译时根据参数类型和数量确定调用哪个方法。

public class Calculator {
    // 加法：两个整数
    public int add(int a, int b) {
        return a + b;
    }
    
    // 加法：三个整数（参数数量不同）
    public int add(int a, int b, int c) {
        return a + b + c;
    }
    
    // 加法：两个浮点数（参数类型不同）
    public double add(double a, double b) {
        return a + b;
    }
    
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(1, 2));        // 调用int版本
        System.out.println(calc.add(1, 2, 3));     // 调用三个参数版本
        System.out.println(calc.add(1.5, 2.5));    // 调用double版本
    }
    /**Output
     * 3
     * 6
     * 4.0
     *///~
}

运行时多态（方法重写）

方法重写是指子类重写父类的方法，当通过父类引用调用该方法时，实际执行的是子类的实现。

// 形状接口
interface Shape {
    double getArea();
    double getPerimeter();
}

// 圆形类
class Circle implements Shape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
    
    @Override
    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
}

// 矩形类
class Rectangle implements Shape {
    private double width;
    private double height;
    
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    
    @Override
    public double getArea() {
        return width * height;
    }
    
    @Override
    public double getPerimeter() {
        return 2 * (width + height);
    }
}

public class PolymorphismTest {
    // 使用多态，接收任意Shape类型的对象
    public static void printShapeInfo(Shape shape) {
        System.out.println("面积: " + shape.getArea());
        System.out.println("周长: " + shape.getPerimeter());
    }
    
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(4, 6);
        
        printShapeInfo(circle);
        System.out.println("------------");
        printShapeInfo(rectangle);
    }
    /**Output
     * 面积: 78.53981633974483
     * 周长: 31.41592653589793
     * ------------
     * 面积: 24.0
     * 周长: 20.0
     *///~
}

多态的优点

• 代码灵活性：同一个接口可以有多种实现方式
• 代码扩展性：可以方便地添加新的子类实现，不需要修改现有代码
• 代码可读性：使用接口或抽象类编程，代码更加清晰易懂

---

三大特性总结

特性	概念	实现方式	作用
封装	将数据和方法绑定，隐藏实现细节	使用访问修饰符，提供getter/setter	保护数据安全，提高代码可维护性
继承	子类获取父类的属性和方法	使用extends关键字	实现代码复用，建立类层次结构
多态	同一方法调用产生不同行为	方法重载（编译时）、方法重写（运行时）	提高代码灵活性和扩展性

这三大特性相互配合，构成了面向对象编程的核心。在实际开发中，合理运用这些特性可以大大提高代码的质量和开发效率。

---

参考资料

• Java官方文档
• Effective Java