Java 面向对象编程（OOP）核心概念

Java 的面向对象编程基于 「四大支柱」：封装、继承、多态和抽象。下面通过代码示例详细说明：

1. 「封装 (Encapsulation)」

将数据和方法捆绑，隐藏内部实现细节，通过公共接口访问。

arduino 复制代码

public class BankAccount {
    private String owner; // 私有属性
    private double balance;

    // 公共构造方法
    public BankAccount(String owner, double initialBalance) {
        this.owner = owner;
        this.balance = initialBalance;
    }

    // 公共访问方法 (getter/setter)
    public double getBalance() {
        return balance;
    }

    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        }
    }
}

2. 「继承 (Inheritance)」

子类继承父类的属性和方法，实现代码复用。

csharp 复制代码

// 父类
class Animal {
    void eat() {
        System.out.println("Eating...");
    }
}

// 子类
class Dog extends Animal {
    void bark() {
        System.out.println("Barking...");
    }
}

// 使用
Dog dog = new Dog();
dog.eat();  // 继承自Animal
dog.bark(); // 自身方法

3. 「多态 (Polymorphism)」

同一操作作用于不同对象时产生不同行为。

typescript 复制代码

// 父类
class Shape {
    void draw() {
        System.out.println("Drawing a shape");
    }
}

// 子类
class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a circle");
    }
}

class Square extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a square");
    }
}

// 多态示例
public class Main {
    public static void main(String[] args) {
        Shape s1 = new Circle(); // 向上转型
        Shape s2 = new Square();
        
        s1.draw(); // 输出: Drawing a circle
        s2.draw(); // 输出: Drawing a square
    }
}

4. 「抽象 (Abstraction)」

隐藏复杂实现，只暴露必要接口（通过抽象类或接口）。

csharp 复制代码

// 抽象类
abstract class Vehicle {
    abstract void start(); // 抽象方法（无实现）
    
    void stop() {
        System.out.println("Vehicle stopped");
    }
}

class Car extends Vehicle {
    @Override
    void start() {
        System.out.println("Car started with key");
    }
}

// 接口 (Java 8+)
interface Electric {
    void charge();
}

class Tesla extends Vehicle implements Electric {
    @Override
    void start() {
        System.out.println("Car started via app");
    }
    
    @Override
    public void charge() {
        System.out.println("Charging battery");
    }
}

关键特性总结

概念	实现方式	核心作用
「封装」	`private` 属性 + `public` 方法	数据保护，控制访问逻辑
「继承」	`extends` 关键字	代码复用，层次化结构
「多态」	方法重写 + 向上转型	接口统一，扩展性强
「抽象」	`abstract` 类 + `interface`	定义规范，隐藏实现细节

高级特性

「接口默认方法 (Java 8+)」

csharp 复制代码

 interface Flyable {
     default void fly() {
         System.out.println("Default flying");
     }
 }

「静态方法与私有方法 (接口)」

csharp 复制代码

 interface MathUtils {
     static int square(int x) { return x * x; }
     private void log() { /* 内部使用 */ }
 }

「final 关键字」
- final class：禁止继承
- final method：禁止重写
- final variable：常量

设计原则

「单一职责原则」：一个类只做一件事
「开闭原则」：对扩展开放，对修改关闭
「里氏替换」：子类必须能替换父类
「依赖倒置」：依赖抽象而非具体实现

❝

「最佳实践」 ：优先使用组合而非继承 (has-a 优于 is-a)

❞

通过掌握这些核心概念，可以构建出模块化、可扩展且易于维护的 Java 应用程序。