一、面向对象概述

面向对象编程（OOP）是一种编程范式，具有以下核心特性：

• 封装：隐藏实现细节，提供公共接口
• 继承：实现代码复用，建立类之间的关系
• 多态：同一操作作用于不同对象，产生不同结果
• 抽象：提取共同特征，忽略具体细节

二、类与对象

1. 类的定义

// 类的定义
public class Person {
    // 成员变量（属性）
    private String name;
    private int age;
    
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 成员方法
    public void sayHello() {
        System.out.println("Hello, I'm " + name);
    }
    
    // Getter和Setter
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
}

2. 对象的创建与使用

// 创建对象
Person person = new Person("张三", 25);

// 调用方法
person.sayHello();

// 访问属性
String name = person.getName();
person.setName("李四");

三、封装

1. 访问修饰符

修饰符	类内	包内	子类	其他包
private	✓	✗	✗	✗
default	✓	✓	✗	✗
protected	✓	✓	✓	✗
public	✓	✓	✓	✓

2. 封装示例

public class BankAccount {
    private String accountNumber;
    private double balance;
    
    public BankAccount(String accountNumber) {
        this.accountNumber = accountNumber;
        this.balance = 0.0;
    }
    
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    
    public boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;
    }
    
    public double getBalance() {
        return balance;
    }
}

四、继承

1. 继承语法

// 父类
public class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void eat() {
        System.out.println(name + " is eating");
    }
}

// 子类
public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    
    public void bark() {
        System.out.println(name + " is barking");
    }
}

2. 方法重写

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

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

五、多态

1. 编译时多态（方法重载）

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
    
    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

2. 运行时多态（方法重写）

Animal animal = new Dog("Buddy");
animal.makeSound(); // 输出：Dog barks

六、抽象类

1. 抽象类定义

public abstract class Shape {
    protected String color;
    
    public Shape(String color) {
        this.color = color;
    }
    
    // 抽象方法
    public abstract double getArea();
    
    // 具体方法
    public String getColor() {
        return color;
    }
}

2. 抽象类实现

public class Circle extends Shape {
    private double radius;
    
    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }
    
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

七、接口

1. 接口定义

public interface Drawable {
    void draw();
    void resize(int width, int height);
    default void printInfo() {
        System.out.println("This is a drawable object");
    }
}

2. 接口实现

public class Rectangle implements Drawable {
    private int width;
    private int height;
    
    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
    
    @Override
    public void resize(int width, int height) {
        this.width = width;
        this.height = height;
    }
}

八、内部类

1. 成员内部类

public class Outer {
    private int outerField;
    
    public class Inner {
        public void accessOuter() {
            outerField = 10; // 可以直接访问外部类成员
        }
    }
}

2. 静态内部类

public class Outer {
    private static int staticField;
    
    public static class StaticInner {
        public void accessOuter() {
            staticField = 10; // 只能访问外部类的静态成员
        }
    }
}

九、面向对象设计原则

1. SOLID原则

• 单一职责原则：一个类只负责一个功能
• 开闭原则：对扩展开放，对修改关闭
• 里氏替换原则：子类可以替换父类
• 接口隔离原则：使用多个专门的接口
• 依赖倒置原则：依赖抽象，不依赖具体实现

2. 设计模式示例

// 单例模式
public class Singleton {
    private static Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

// 工厂模式
public interface Shape {
    void draw();
}

public class ShapeFactory {
    public Shape createShape(String type) {
        switch (type) {
            case "circle": return new Circle();
            case "rectangle": return new Rectangle();
            default: throw new IllegalArgumentException("Unknown shape type");
        }
    }
}

面向对象编程建议

1. 合理使用访问修饰符，确保封装性
2. 优先使用组合而不是继承
3. 面向接口编程，而不是具体实现
4. 遵循单一职责原则
5. 合理使用设计模式
6. 注意类的可扩展性和可维护性