java如何设计类
设计类的核心原则
面向对象编程（OOP）的核心思想包括封装、继承、多态和抽象。设计类时应遵循这些原则，确保代码的可维护性和扩展性。
封装数据与行为
将数据（属性）和操作数据的方法（行为）绑定在一个类中，通过访问修饰符控制外部访问权限。私有属性通过公有方法暴露必要操作。
public class BankAccount {
private double balance;
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
}
}
public double getBalance() {
return balance;
}
}单一职责原则
每个类应只负责一项明确的功能。避免创建"全能类"，将不同功能拆分到多个类中。
// 违反原则的示例
class UserManager {
void saveUser() { /* 数据库操作 */ }
void sendEmail() { /* 邮件逻辑 */ }
}
// 改进方案
class UserRepository {
void saveUser() { /* 仅处理存储 */ }
}
class EmailService {
void sendEmail() { /* 仅处理邮件 */ }
}使用继承建立层次结构
通过extends关键字实现类继承，子类复用父类属性和方法。抽象类定义通用行为，具体子类实现细节。
abstract class Animal {
abstract void makeSound();
}
class Dog extends Animal {
@Override
void makeSound() {
System.out.println("Bark");
}
}接口实现多态
定义接口规范行为，不同类实现相同接口可互换使用。优先使用接口而非具体实现类作为参数类型。
interface Drawable {
void draw();
}
class Circle implements Drawable {
public void draw() {
System.out.println("Drawing circle");
}
}
class Canvas {
void render(Drawable d) {
d.draw();
}
}组合优于继承
通过持有其他类实例实现功能复用，比继承更灵活。使用final类防止不必要的继承。
class Engine {
void start() { /* 引擎启动 */ }
}
class Car {
private final Engine engine;
Car(Engine engine) {
this.engine = engine;
}
void start() {
engine.start();
}
}不可变对象设计
对于值对象，设计为不可变类能提高线程安全性。所有字段设为final，不提供修改方法。
public final class Money {
private final double amount;
private final String currency;
public Money(double amount, String currency) {
this.amount = amount;
this.currency = currency;
}
// 只有getter没有setter
}静态工厂方法
替代构造器提供更清晰的实例创建方式，可隐藏实现类或缓存实例。
class Complex {
private final double real;
private final double imaginary;
private Complex(double r, double i) {
real = r;
imaginary = i;
}
public static Complex fromCartesian(double r, double i) {
return new Complex(r, i);
}
public static Complex fromPolar(double modulus, double angle) {
return new Complex(modulus*Math.cos(angle), modulus*Math.sin(angle));
}
}构建者模式
对于多参数构造，使用构建者模式提高可读性和灵活性。
class NutritionFacts {
private final int servingSize;
private final int calories;
public static class Builder {
private final int servingSize;
private int calories = 0;
public Builder(int servingSize) {
this.servingSize = servingSize;
}
public Builder calories(int val) {
calories = val;
return this;
}
public NutritionFacts build() {
return new NutritionFacts(this);
}
}
private NutritionFacts(Builder builder) {
servingSize = builder.servingSize;
calories = builder.calories;
}
}依赖注入
通过构造函数或setter方法注入依赖对象，提高可测试性和松耦合。
class UserService {
private final UserRepository repository;
public UserService(UserRepository repository) {
this.repository = repository;
}
public User getUser(int id) {
return repository.findById(id);
}
}
