# 建造者模式

## 目录
- [建造者模式概念](#建造者模式概念)
- [建造者模式实现](#建造者模式实现)
- [建造者模式应用](#建造者模式应用)
- [建造者模式最佳实践](#建造者模式最佳实践)
- [面试常见问题](#面试常见问题)

---

## 建造者模式概念

### 定义

```java
// 建造者模式：将一个复杂对象的构建与表示分离
// 使同样的构建过程可以创建不同的表示
```

### 使用场景

```java
// 1. 需要创建复杂对象
// 2. 对象有很多可选参数
// 3. 需要保证对象创建过程的一致性
```

---

## 建造者模式实现

### 基本实现

```java
// 产品类
public class Product {
    private String partA;
    private String partB;
    private String partC;
    
    public void setPartA(String partA) {
        this.partA = partA;
    }
    
    public void setPartB(String partB) {
        this.partB = partB;
    }
    
    public void setPartC(String partC) {
        this.partC = partC;
    }
}

// 建造者接口
public interface Builder {
    void buildPartA();
    void buildPartB();
    void buildPartC();
    Product getProduct();
}

// 具体建造者
public class ConcreteBuilder implements Builder {
    private Product product = new Product();
    
    @Override
    public void buildPartA() {
        product.setPartA("PartA");
    }
    
    @Override
    public void buildPartB() {
        product.setPartB("PartB");
    }
    
    @Override
    public void buildPartC() {
        product.setPartC("PartC");
    }
    
    @Override
    public Product getProduct() {
        return product;
    }
}

// 指挥者
public class Director {
    private Builder builder;
    
    public Director(Builder builder) {
        this.builder = builder;
    }
    
    public Product construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.getProduct();
    }
}

// 使用
Builder builder = new ConcreteBuilder();
Director director = new Director(builder);
Product product = director.construct();
```

### 链式调用实现

```java
// 链式调用建造者
public class Product {
    private String partA;
    private String partB;
    private String partC;
    
    public static class Builder {
        private Product product = new Product();
        
        public Builder setPartA(String partA) {
            product.partA = partA;
            return this;
        }
        
        public Builder setPartB(String partB) {
            product.partB = partB;
            return this;
        }
        
        public Builder setPartC(String partC) {
            product.partC = partC;
            return this;
        }
        
        public Product build() {
            return product;
        }
    }
}

// 使用
Product product = new Product.Builder()
    .setPartA("PartA")
    .setPartB("PartB")
    .setPartC("PartC")
    .build();
```

---

## 建造者模式应用

### Android 中的应用

#### 1. AlertDialog.Builder

```java
// AlertDialog 使用建造者模式
AlertDialog dialog = new AlertDialog.Builder(context)
    .setTitle("Title")
    .setMessage("Message")
    .setPositiveButton("OK", null)
    .setNegativeButton("Cancel", null)
    .create();
```

#### 2. NotificationCompat.Builder

```java
// Notification 使用建造者模式
Notification notification = new NotificationCompat.Builder(context, CHANNEL_ID)
    .setContentTitle("Title")
    .setContentText("Text")
    .setSmallIcon(R.drawable.icon)
    .build();
```

#### 3. Retrofit.Builder

```java
// Retrofit 使用建造者模式
Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.example.com/")
    .addConverterFactory(GsonConverterFactory.create())
    .build();
```

---

## 建造者模式最佳实践

### 1. 使用链式调用

```java
// 链式调用更易读
Product product = new Product.Builder()
    .setPartA("A")
    .setPartB("B")
    .build();
```

### 2. 验证参数

```java
// 在 build() 方法中验证参数
public Product build() {
    if (partA == null) {
        throw new IllegalArgumentException("PartA is required");
    }
    return product;
}
```

---

## 面试常见问题

### Q1: 建造者模式的原理？

**答案：**
- 将一个复杂对象的构建与表示分离
- 使同样的构建过程可以创建不同的表示

### Q2: 建造者模式的优点？

**答案：**
1. 封装复杂对象的创建过程
2. 可以逐步构建对象
3. 代码可读性好（链式调用）
4. 易于扩展

### Q3: Android 中的建造者模式应用？

**答案：**
- AlertDialog.Builder
- NotificationCompat.Builder
- Retrofit.Builder

---

*最后更新：2024年*
