面向对象编程：封装、继承与多态

面向对象编程概述

面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，将数据和操作数据的方法封装在一起，以对象为基本单元进行程序设计。

OOP 核心概念

对象：现实世界实体的抽象，包含属性和行为
类：对象的模板或蓝图，定义对象的属性和方法
实例：类的具体实现，即对象

封装

封装是将数据（属性）和操作数据的方法（行为）绑定在一起，并对外部隐藏内部实现细节的机制。

封装的优点

数据安全性：防止外部直接访问和修改对象内部数据
代码复用：封装好的类可以在不同地方重复使用
模块化：每个类负责自己的功能，降低耦合度
可维护性：修改内部实现不影响外部使用

封装示例

public class Person {
    private String name;
    private int age;
    private String gender;
    
    public Person(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        if (name != null && !name.isEmpty()) {
            this.name = name;
        }
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        if (age > 0 && age < 150) {
            this.age = age;
        }
    }
    
    public void introduce() {
        System.out.println("我是" + name + "，今年" + age + "岁，性别" + gender);
    }
}

继承

继承是一种机制，允许一个类（子类）获得另一个类（父类）的属性和方法。

继承的优点

代码复用：子类可以直接使用父类的属性和方法
层次结构：建立类之间的关系，使代码更有组织
扩展性：可以在子类中添加新的功能

继承示例

public class Animal {
    protected String name;
    protected int age;
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void eat() {
        System.out.println(name + "正在吃东西");
    }
    
    public void sleep() {
        System.out.println(name + "正在睡觉");
    }
}

public class Dog extends Animal {
    private String breed;
    
    public Dog(String name, int age, String breed) {
        super(name, age);
        this.breed = breed;
    }
    
    public void bark() {
        System.out.println(name + "汪汪汪！");
    }
    
    @Override
    public void eat() {
        System.out.println(name + "正在吃狗粮");
    }
}

public class Cat extends Animal {
    private String color;
    
    public Cat(String name, int age, String color) {
        super(name, age);
        this.color = color;
    }
    
    public void meow() {
        System.out.println(name + "喵喵喵！");
    }
    
    @Override
    public void sleep() {
        System.out.println(name + "在沙发上睡觉");
    }
}

多态

多态是指同一个方法在不同对象上有不同的行为表现。

多态的实现方式

方法重写（Override）：子类重新定义父类的方法
方法重载（Overload）：同一个类中定义多个同名方法，参数列表不同
接口：通过接口实现多态

多态示例

public interface Shape {
    double getArea();
    double getPerimeter();
}

public 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;
    }
}

public 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 ShapeCalculator {
    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);
        printShapeInfo(rectangle);
    }
}

设计模式

设计模式是解决特定问题的通用解决方案，是OOP思想的最佳实践。

常见设计模式

类别	模式名称	描述
创建型	单例模式	确保一个类只有一个实例
创建型	工厂模式	封装对象的创建过程
创建型	建造者模式	分步构建复杂对象
结构型	适配器模式	将一个接口转换为另一个接口
结构型	装饰器模式	动态添加功能
结构型	代理模式	为对象提供代理
行为型	观察者模式	一对多的依赖关系
行为型	策略模式	封装算法并使其可互换
行为型	模板方法模式	定义算法骨架

单例模式示例

public class Singleton {
    private static volatile Singleton instance;
    
    private Singleton() {
    }
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

总结

面向对象编程的三大特性——封装、继承、多态——是构建高质量软件的基础。封装保证了数据安全，继承实现了代码复用，多态提高了代码的灵活性和可扩展性。掌握设计模式则能让你的代码更加优雅和可维护。