### Java面向对象编程的核心概念与实践技巧

#### 一、面向对象基础概念

封装

封装是面向对象编程的基础原则之一。通过将数据与操作数据的方法绑定在一起，形成类，实现对内部状态的保护。在Java中，使用private、protected、public等访问修饰符控制对类成员的访问权限。

```java

public class BankAccount {

private double balance;

public void deposit(double amount) {

if (amount > 0) {

balance += amount;

}

}

public double getBalance() {

return balance;

}

}

```

继承

继承允许创建分等级层次的类，子类继承父类的特征和行为，实现代码重用。

```java

class Animal {

protected String name;

public void eat() {

System.out.println(name + is eating);

}

}

class Dog extends Animal {

public void bark() {

System.out.println(name + is barking);

}

}

```

多态

多态允许不同类的对象对同一消息作出响应，提高代码的灵活性和可扩展性。

```java

interface Shape {

double calculateArea();

}

class Circle implements Shape {

private double radius;

@Override

public double calculateArea() {

return Math.PI radius radius;

}

}

class Rectangle implements Shape {

private double width, height;

@Override

public double calculateArea() {

return width height;

}

}

```

#### 二、面向对象高级特性

抽象类与接口

抽象类定义通用行为，接口定义契约规范。

```java

// 抽象类

abstract class Vehicle {

protected int speed;

public abstract void accelerate();

public void displaySpeed() {

System.out.println(Current speed: + speed);

}

}

// 接口

interface ElectricVehicle {

void chargeBattery();

int getBatteryLevel();

}

```

组合优于继承

通过对象组合实现代码复用，提供更好的灵活性和封装性。

```java

class Engine {

public void start() {

System.out.println(Engine started);

}

}

class Car {

private Engine engine;

public Car() {

this.engine = new Engine();

}

public void startCar() {

engine.start();

}

}

```

#### 三、设计原则与最佳实践

单一职责原则

每个类应该只有一个引起变化的原因。

```java

// 违反原则的写法

class UserManager {

public void createUser() { / ... / }

public void sendEmail() { / ... / }

public void generateReport() { / ... / }

}

// 遵循原则的写法

class UserService {

public void createUser() { / ... / }

}

class EmailService {

public void sendEmail() { / ... / }

}

class ReportService {

public void generateReport() { / ... / }

}

```

开闭原则

对扩展开放，对修改关闭。

```java

interface DiscountStrategy {

double applyDiscount(double price);

}

class RegularDiscount implements DiscountStrategy {

@Override

public double applyDiscount(double price) {

return price 0.9;

}

}

class VIPDiscount implements DiscountStrategy {

@Override

public double applyDiscount(double price) {

return price 0.7;

}

}

```

依赖倒置原则

依赖于抽象而不是具体实现。

```java

interface Database {

void connect();

void disconnect();

}

class MySQLDatabase implements Database {

@Override

public void connect() { / ... / }

@Override

public void disconnect() { / ... / }

}

class Application {

private Database database;

public Application(Database database) {

this.database = database;

}

}

```

#### 四、实践技巧与模式应用

工厂模式

封装对象创建过程。

```java

interface Logger {

void log(String message);

}

class FileLogger implements Logger {

@Override

public void log(String message) {

// 写入文件

}

}

class LoggerFactory {

public static Logger getLogger(String type) {

switch (type) {

case file:

return new FileLogger();

default:

throw new IllegalArgumentException(Unknown logger type);

}

}

}

```

观察者模式

实现对象间的一对多依赖关系。

```java

interface Observer {

void update(String message);

}

class Subject {

private List observers = new ArrayList<>();

public void addObserver(Observer observer) {

observers.add(observer);

}

public void notifyObservers(String message) {

for (Observer observer : observers) {

observer.update(message);

}

}

}

```

#### 五、性能优化与内存管理

对象池模式

减少对象创建和销毁的开销。

```java

class ConnectionPool {

private static final int MAX_POOL_SIZE = 10;

private List availableConnections = new ArrayList<>();

public Connection getConnection() {

if (availableConnections.isEmpty()) {

return createNewConnection();

}

return availableConnections.remove(0);

}

public void releaseConnection(Connection connection) {

if (availableConnections.size() < MAX_POOL_SIZE) {

availableConnections.add(connection);

}

}

}

```

不可变对象

提高线程安全性和性能。

```java

public final class ImmutablePerson {

private final String name;

private final int age;

public ImmutablePerson(String name, int age) {

this.name = name;

this.age = age;

}

public String getName() { return name; }

public int getAge() { return age; }

}

```

#### 六、现代Java特性应用

记录类（Record）

简化不可变数据类的定义。

```java

public record Person(String name, int age) {

// 自动生成构造函数、getter、equals、hashCode、toString

}

```

密封类（Sealed Class）

限制类的继承层次。

```java

public sealed class Shape

permits Circle, Rectangle, Triangle {

// 基类定义

}

public final class Circle extends Shape {

// 具体实现

}

```

通过深入理解和应用这些面向对象编程的核心概念与实践技巧，开发者能够构建出更加健壮、可维护和可扩展的Java应用程序。关键在于根据具体场景选择合适的设计模式和实践方法，平衡代码的复杂度与灵活性。