创建型模式 ⭐⭐⭐

public class HungrySingleton {
 
    // 1. 类加载时就完成实例化（JVM 保证类加载过程是线程安全的）
    private static final HungrySingleton INSTANCE = new HungrySingleton();
 
    // 2. 私有构造函数：禁止外部 new
    private HungrySingleton() {
        // 可以在这里做初始化工作
    }
 
    // 3. 全局访问点：直接返回已经创建好的实例
    public static HungrySingleton getInstance() {
        return INSTANCE; // 无需任何同步机制，直接返回
    }
 
    // 业务方法
    public void doSomething() {
        System.out.println("HungrySingleton is working...");
    }
}

// Kotlin 的 object 声明本质上就是一个饿汉式单例
// 编译器会自动生成 private 构造函数 + static INSTANCE 字段
object HungrySingleton {
 
    // 直接在 object 中定义属性和方法
    fun doSomething() {
        println("HungrySingleton is working...")
    }
}
 
// 使用方式：无需 getInstance()，直接通过类名访问
// HungrySingleton.doSomething()

// 反编译后的简化伪代码，展示 JVM 内部的加锁逻辑
static {
    synchronized (HungrySingleton.class) {   // JVM 内部的隐式锁
        INSTANCE = new HungrySingleton();     // 只会执行一次
    }
}

public class LazyUnsafeSingleton {
 
    // 1. 初始为 null，不在类加载时创建
    private static LazyUnsafeSingleton instance = null;
 
    // 2. 私有构造函数
    private LazyUnsafeSingleton() {}
 
    // 3. 首次调用时创建实例 —— ⚠️ 线程不安全！
    public static LazyUnsafeSingleton getInstance() {
        if (instance == null) {          // 线程 A 判断为 null
            // 线程 A 还没来得及赋值，线程 B 也进来了，也判断为 null
            instance = new LazyUnsafeSingleton(); // 可能创建多个实例！
        }
        return instance;
    }
}

public class LazySafeSingleton {
 
    private static LazySafeSingleton instance = null;
 
    private LazySafeSingleton() {}
 
    // synchronized 保证同一时刻只有一个线程可以进入此方法
    public static synchronized LazySafeSingleton getInstance() {
        if (instance == null) {
            instance = new LazySafeSingleton();
        }
        return instance;
    }
}

public class DCLSingleton {
 
    // 1. volatile 关键字：禁止指令重排序，保证可见性
    //    这是 DCL 正确性的关键！
    private static volatile DCLSingleton instance = null;
 
    // 2. 私有构造函数
    private DCLSingleton() {}
 
    // 3. 双重检查锁定
    public static DCLSingleton getInstance() {
        if (instance == null) {                    // 第一次检查（无锁，快速路径）
            synchronized (DCLSingleton.class) {    // 只有 instance 为 null 时才加锁
                if (instance == null) {            // 第二次检查（持锁状态下再确认）
                    instance = new DCLSingleton(); // 创建实例
                }
            }
        }
        return instance;                           // 已创建过的实例直接返回，无需加锁
    }
}

class DCLSingleton private constructor() {
 
    companion object {
        // @Volatile 等价于 Java 的 volatile
        @Volatile
        private var instance: DCLSingleton? = null
 
        // 双重检查锁
        fun getInstance(): DCLSingleton {
            if (instance == null) {                          // 第一次检查
                synchronized(DCLSingleton::class.java) {    // 加锁
                    if (instance == null) {                  // 第二次检查
                        instance = DCLSingleton()            // 创建实例
                    }
                }
            }
            return instance!!                               // 非空断言，此时必不为 null
        }
    }
}

// instance = new DCLSingleton(); 的字节码分解
 
// Step 1: 在堆上分配对象的内存空间
memory = allocate();
 
// Step 2: 调用构造函数，初始化对象的成员变量
ctorInstance(memory);
 
// Step 3: 将 instance 引用指向分配好的内存地址
//         （此时 instance != null）
instance = memory;

// 重排序后的执行顺序（危险！）
memory  = allocate();   // Step 1: 分配内存
instance = memory;      // Step 3: instance 已经非 null 了！
                        //         但对象还没初始化！
ctorInstance(memory);   // Step 2: 初始化（还没执行到这里）

// 加了 volatile 后的内存屏障（简化示意）
memory  = allocate();       // Step 1
ctorInstance(memory);       // Step 2
// ──── StoreStore Barrier ──── (禁止上面的操作和下面的重排)
instance = memory;          // Step 3 (volatile write)
// ──── StoreLoad Barrier ──── (对其他线程立即可见)

public class HolderSingleton {
 
    // 1. 私有构造函数
    private HolderSingleton() {}
 
    // 2. 静态内部类：只有在被"主动引用"时才会被 JVM 加载
    //    这个类的加载时机 = getInstance() 第一次被调用时
    private static class Holder {
        // 类加载时创建实例（JVM 保证线程安全）
        private static final HolderSingleton INSTANCE = new HolderSingleton();
    }
 
    // 3. 全局访问点：触发 Holder 类的加载 → 创建实例
    public static HolderSingleton getInstance() {
        return Holder.INSTANCE; // 首次调用时才加载 Holder 类
    }
}

class HolderSingleton private constructor() {
 
    companion object {
        // Kotlin 的 lazy 委托默认就是 synchronized 模式
        // 其内部实现原理与静态内部类异曲同工
        val instance: HolderSingleton by lazy {
            HolderSingleton()
        }
    }
}
 
// 或者更显式地模拟 Java 的 Holder 模式
class HolderSingleton2 private constructor() {
 
    // 私有的 Holder object（编译为静态内部类）
    private object Holder {
        val INSTANCE = HolderSingleton2()
    }
 
    companion object {
        fun getInstance(): HolderSingleton2 = Holder.INSTANCE
    }
}

public enum EnumSingleton {
 
    INSTANCE;  // 唯一的枚举常量，就是单例实例本身
 
    // 可以持有成员变量
    private int counter = 0;
 
    // 可以定义业务方法
    public void doSomething() {
        counter++;
        System.out.println("EnumSingleton working, counter = " + counter);
    }
}
 
// 使用方式
// EnumSingleton.INSTANCE.doSomething();

// Kotlin 中可以直接用 enum class
enum class EnumSingleton {
    INSTANCE;  // 枚举常量
 
    private var counter = 0
 
    fun doSomething() {
        counter++
        println("EnumSingleton working, counter = $counter")
    }
}
 
// 不过在 Kotlin 中，object 声明已经足够优雅
// 枚举单例更多用在需要防反射/序列化的 Java 项目中

// 反射攻击：绕过私有构造函数创建第二个实例
Constructor<DCLSingleton> constructor =
        DCLSingleton.class.getDeclaredConstructor();   // 获取私有构造函数
constructor.setAccessible(true);                        // 暴力破解访问权限
DCLSingleton anotherInstance = constructor.newInstance(); // 创建了第二个实例！
 
// anotherInstance != DCLSingleton.getInstance() → 单例被破坏！

// java.lang.reflect.Constructor 源码节选
public T newInstance(Object ... initargs) throws ... {
    // ...
    if ((clazz.getModifiers() & Modifier.ENUM) != 0)   // 如果是枚举类型
        throw new IllegalArgumentException(              // 直接抛出异常！
            "Cannot reflectively create enum objects");
    // ...
}

// 序列化攻击演示
DCLSingleton s1 = DCLSingleton.getInstance();
 
// 序列化：将对象写入字节流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("singleton.ser"));
oos.writeObject(s1);
oos.close();
 
// 反序列化：从字节流还原对象 —— 会调用默认构造函数创建新对象！
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("singleton.ser"));
DCLSingleton s2 = (DCLSingleton) ois.readObject();
ois.close();
 
System.out.println(s1 == s2); // false！单例被破坏！

// 在普通单例类中添加此方法以防止序列化破坏
private Object readResolve() {
    return getInstance(); // 反序列化时返回已有实例而非新建
}

// Android Framework 中 Application 的获取方式
// 系统在 ActivityThread.handleBindApplication() 中创建 Application 实例
// 整个进程生命周期只创建一次
 
// 在 Activity/Service 中获取
Application app = getApplication();          // Activity/Service 内
Context appContext = getApplicationContext(); // 任意 Context 内
 
// 自定义 Application
public class MyApp extends Application {
 
    // 注意：这里不需要自己实现单例！
    // 系统保证只创建一个 MyApp 实例
 
    @Override
    public void onCreate() {
        super.onCreate();
        // 全局初始化工作
    }
}

class MyApp : Application() {
 
    companion object {
        // 使用 lateinit 而非直接赋值，确保在 onCreate 后才可用
        lateinit var instance: MyApp
            private set  // 外部只读
    }
 
    override fun onCreate() {
        super.onCreate()
        instance = this  // Application.onCreate() 由系统保证只调用一次
    }
}

// 常见的系统 Manager（全部是单例）
val windowManager = getSystemService(Context.WINDOW_SERVICE) as WindowManager
val layoutInflater = getSystemService(Context.LAYOUT_INFLATER_SERVICE) as LayoutInflater
val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
val connectivityManager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
val audioManager = getSystemService(Context.AUDIO_SERVICE) as AudioManager
val inputMethodManager = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager

// Android Framework 源码简化 —— SystemServiceRegistry.java
// 注册系统服务的方式（静态代码块中执行）
static {
    // 每个服务注册一个 CachedServiceFetcher
    registerService(Context.WINDOW_SERVICE, WindowManager.class,
        new CachedServiceFetcher<WindowManager>() {          // 工厂 + 缓存
            @Override
            public WindowManager createService(ContextImpl ctx) {
                // 首次调用时创建，之后从缓存返回
                return new WindowManagerImpl(ctx);
            }
        });
    // ... 其他几十个服务类似注册 ...
}

// 1. 网络客户端 —— OkHttpClient 推荐全局单例
//    （内部维护连接池、线程池，多实例会浪费资源）
object NetworkClient {
    val okHttpClient: OkHttpClient by lazy {     // lazy 委托实现延迟初始化
        OkHttpClient.Builder()
            .connectTimeout(30, TimeUnit.SECONDS) // 连接超时 30s
            .readTimeout(30, TimeUnit.SECONDS)    // 读取超时 30s
            .addInterceptor(loggingInterceptor)   // 日志拦截器
            .build()                              // 构建实例
    }
 
    val retrofit: Retrofit by lazy {              // Retrofit 也应单例
        Retrofit.Builder()
            .baseUrl("https://api.example.com/")  // 基础 URL
            .client(okHttpClient)                 // 复用同一个 OkHttpClient
            .addConverterFactory(GsonConverterFactory.create()) // JSON 转换
            .build()
    }
}
 
// 2. 数据库 —— Room Database 推荐单例
//    （多实例会导致数据库锁冲突）
@Database(entities = [UserEntity::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao               // 抽象 DAO 方法
 
    companion object {
        @Volatile
        private var INSTANCE: AppDatabase? = null // volatile 修饰
 
        fun getInstance(context: Context): AppDatabase {
            return INSTANCE ?: synchronized(this) {              // DCL
                INSTANCE ?: Room.databaseBuilder(
                    context.applicationContext,                   // 使用 applicationContext 防止内存泄漏
                    AppDatabase::class.java,
                    "app_database"                               // 数据库文件名
                ).build().also { INSTANCE = it }                 // 赋值并返回
            }
        }
    }
}
 
// 3. SharedPreferences 管理器
object PrefsManager {
    private lateinit var prefs: SharedPreferences   // 延迟初始化
 
    fun init(context: Context) {                    // 在 Application.onCreate() 中调用
        prefs = context.applicationContext           // 使用 applicationContext
            .getSharedPreferences("app_prefs", Context.MODE_PRIVATE)
    }
 
    var userName: String                            // 属性委托简化读写
        get() = prefs.getString("user_name", "") ?: ""
        set(value) = prefs.edit().putString("user_name", value).apply()
}

// ❌ 错误示范：单例持有 Activity 的 Context
public class BadManager {
    private static BadManager instance;
    private Context context;   // 如果这是 Activity 的 Context → 内存泄漏！
 
    private BadManager(Context context) {
        this.context = context; // 保存了 Activity 引用
    }
 
    public static BadManager getInstance(Context context) {
        if (instance == null) {
            instance = new BadManager(context); // Activity 被永久持有！
        }
        return instance;
    }
}
 
// ✅ 正确做法：始终使用 ApplicationContext
public class GoodManager {
    private static GoodManager instance;
    private Context appContext;  // Application 级别的 Context
 
    private GoodManager(Context context) {
        this.appContext = context.getApplicationContext(); // 安全！
    }
 
    public static GoodManager getInstance(Context context) {
        if (instance == null) {
            instance = new GoodManager(context);
        }
        return instance;
    }
}

// 内存泄漏引用链示意
GC Root (Static Field)
  └── BadManager.instance (static, 永远存活)
        └── BadManager.context
              └── MainActivity (已经 onDestroy，但无法被 GC 回收！)
                    └── View Hierarchy (整个视图树全部泄漏)
                          └── Bitmap, Drawable... (大量内存无法释放)

public class Singleton {
    private static Singleton instance;
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                instance = new Singleton();
            }
        }
        return instance;
    }
}

public class Singleton {
    private static volatile Singleton instance;
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public class Singleton {
    private static Singleton instance;
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public class Singleton {
    private static volatile Singleton instance;
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

object ImageLoader {
    private lateinit var context: Context
    
    fun init(activity: Activity) {
        this.context = activity  // 传入 Activity
    }
    
    fun loadImage(url: String) {
        // 使用 context 加载图片...
    }
}

// ==================== 产品抽象层 ====================
 
/**
 * 通知接口 —— 所有通知类型的统一抽象
 * 调用方只面向此接口编程，不关心具体实现
 */
interface Notification {
    fun send(message: String)   // 发送通知的统一方法
}
 
// ==================== 具体产品层 ====================
 
/** 站内信通知 */
class InAppNotification : Notification {
    override fun send(message: String) {
        // 实际场景中会调用 NotificationManager 构建系统通知
        println("📱 站内信通知: $message")
    }
}
 
/** 短信通知 */
class SmsNotification : Notification {
    override fun send(message: String) {
        // 实际场景中会调用 SmsManager 发送短信
        println("💬 短信通知: $message")
    }
}
 
/** 邮件通知 */
class EmailNotification : Notification {
    override fun send(message: String) {
        // 实际场景中会调用 JavaMail API 或后端接口
        println("📧 邮件通知: $message")
    }
}

// ==================== 简单工厂 ====================
 
/**
 * 通知工厂 —— 根据类型参数创建对应的 Notification 实例
 * 这就是"简单工厂"的核心：一个工厂类包揽所有产品创建
 */
object NotificationFactory {
 
    /**
     * 枚举定义通知渠道类型，比字符串更安全
     */
    enum class Channel {
        IN_APP,   // 站内信
        SMS,      // 短信
        EMAIL     // 邮件
    }
 
    /**
     * 工厂方法 —— 根据 channel 参数返回对应的 Notification 实例
     * @param channel 通知渠道类型
     * @return Notification 的具体实现
     * @throws IllegalArgumentException 未知类型时抛出异常
     */
    fun create(channel: Channel): Notification {
        // 使用 Kotlin when 表达式进行分支匹配
        return when (channel) {
            Channel.IN_APP -> InAppNotification()   // 站内信
            Channel.SMS    -> SmsNotification()      // 短信
            Channel.EMAIL  -> EmailNotification()    // 邮件
            // 如果新增类型，必须在这里添加分支 ← 违反开闭原则的根源
        }
    }
}

// ==================== 客户端调用 ====================
fun main() {
    // 调用方完全不知道 InAppNotification / SmsNotification 的存在
    // 它只认识 Notification 接口和 NotificationFactory
    val notification = NotificationFactory.create(NotificationFactory.Channel.SMS)
    notification.send("您的验证码是 886425")  // 💬 短信通知: 您的验证码是 886425
}

// 新增微信推送 → 必须修改工厂类源码
Channel.WECHAT -> WeChatNotification()

// ==================== Java 简单工厂 ====================
public class NotificationFactory {
 
    /**
     * 根据类型字符串创建 Notification 实例
     * Java 中常用 String 或 enum 作为类型标识
     */
    public static Notification create(String channel) {
        // switch 分支判断
        switch (channel) {
            case "IN_APP":
                return new InAppNotification();   // 站内信
            case "SMS":
                return new SmsNotification();      // 短信
            case "EMAIL":
                return new EmailNotification();    // 邮件
            default:
                // 未知类型抛出异常，防止静默失败
                throw new IllegalArgumentException("Unknown channel: " + channel);
        }
    }
}

// ==================== 产品抽象层（与之前相同）====================
 
interface Notification {
    fun send(message: String)
}
 
class InAppNotification : Notification {
    override fun send(message: String) = println("📱 站内信: $message")
}
 
class SmsNotification : Notification {
    override fun send(message: String) = println("💬 短信: $message")
}
 
class EmailNotification : Notification {
    override fun send(message: String) = println("📧 邮件: $message")
}
 
// ==================== 工厂抽象层 ====================
 
/**
 * 抽象工厂接口 —— 定义"创建通知"的契约
 * 每个具体工厂子类负责创建一种具体产品
 */
interface NotificationFactory {
    fun create(): Notification   // 工厂方法：由子类决定创建哪个产品
}
 
// ==================== 具体工厂层 ====================
 
/** 站内信工厂 —— 专门生产 InAppNotification */
class InAppNotificationFactory : NotificationFactory {
    override fun create(): Notification {
        // 可以在此添加初始化逻辑、日志、缓存等
        return InAppNotification()
    }
}
 
/** 短信工厂 —— 专门生产 SmsNotification */
class SmsNotificationFactory : NotificationFactory {
    override fun create(): Notification {
        return SmsNotification()
    }
}
 
/** 邮件工厂 —— 专门生产 EmailNotification */
class EmailNotificationFactory : NotificationFactory {
    override fun create(): Notification {
        return EmailNotification()
    }
}

// ==================== 客户端调用 ====================
 
/**
 * NotificationService 依赖抽象的 NotificationFactory
 * 通过构造器注入工厂实例，实现松耦合
 */
class NotificationService(
    private val factory: NotificationFactory   // 依赖注入：注入的是哪个工厂，就生产哪种产品
) {
    fun notify(message: String) {
        val notification = factory.create()    // 调用工厂方法获取产品
        notification.send(message)             // 使用产品
    }
}
 
fun main() {
    // 运行时决定使用哪个工厂 —— 策略可从配置文件或 DI 框架注入
    val service = NotificationService(SmsNotificationFactory())
    service.notify("您的快递已签收")   // 💬 短信: 您的快递已签收
}

// ==================== 新增产品 + 新增工厂，不修改任何已有代码 ====================
 
/** 新增产品：微信推送通知 */
class WeChatNotification : Notification {
    override fun send(message: String) = println("💚 微信推送: $message")
}
 
/** 新增工厂：微信推送工厂 */
class WeChatNotificationFactory : NotificationFactory {
    override fun create(): Notification = WeChatNotification()
}

                  产品等级 →
                  Button          EditText        Card
产品族 ↓
Light主题    LightButton     LightEditText   LightCard
Dark主题     DarkButton      DarkEditText    DarkCard

// ================================================================
// 产品抽象层：定义每个产品等级的接口
// ================================================================
 
/** 按钮抽象 */
interface Button {
    fun render(): String    // 渲染按钮，返回描述文字
}
 
/** 输入框抽象 */
interface EditText {
    fun render(): String    // 渲染输入框
}
 
/** 卡片抽象 */
interface Card {
    fun render(): String    // 渲染卡片
}
 
// ================================================================
// 具体产品层：Light 主题族
// ================================================================
 
class LightButton : Button {
    override fun render() = "🔲 Light Button (白底黑字)"
}
 
class LightEditText : EditText {
    override fun render() = "📝 Light EditText (白底灰边框)"
}
 
class LightCard : Card {
    override fun render() = "🃏 Light Card (白色卡片 + 浅灰阴影)"
}
 
// ================================================================
// 具体产品层：Dark 主题族
// ================================================================
 
class DarkButton : Button {
    override fun render() = "🔳 Dark Button (深灰底白字)"
}
 
class DarkEditText : EditText {
    override fun render() = "📝 Dark EditText (深灰底亮边框)"
}
 
class DarkCard : Card {
    override fun render() = "🃏 Dark Card (深灰卡片 + 黑色阴影)"
}
 
// ================================================================
// 抽象工厂接口：定义创建一族产品的契约
// ================================================================
 
/**
 * UIComponentFactory —— 抽象工厂
 * 每个方法对应一个产品等级（Button / EditText / Card）
 * 每个具体工厂实现负责生产同一主题族的全套组件
 */
interface UIComponentFactory {
    fun createButton(): Button       // 创建按钮
    fun createEditText(): EditText   // 创建输入框
    fun createCard(): Card           // 创建卡片
}
 
// ================================================================
// 具体工厂：Light 主题工厂 —— 生产 Light 族全部产品
// ================================================================
 
class LightThemeFactory : UIComponentFactory {
    override fun createButton(): Button = LightButton()         // Light 按钮
    override fun createEditText(): EditText = LightEditText()   // Light 输入框
    override fun createCard(): Card = LightCard()               // Light 卡片
}
 
// ================================================================
// 具体工厂：Dark 主题工厂 —— 生产 Dark 族全部产品
// ================================================================
 
class DarkThemeFactory : UIComponentFactory {
    override fun createButton(): Button = DarkButton()          // Dark 按钮
    override fun createEditText(): EditText = DarkEditText()    // Dark 输入框
    override fun createCard(): Card = DarkCard()                // Dark 卡片
}

// ================================================================
// 客户端：面向抽象工厂编程，运行时切换整套主题
// ================================================================
 
/**
 * ThemeRenderer 负责使用工厂创建 UI 并渲染
 * 它完全不知道 LightButton / DarkButton 的存在
 * 只依赖 UIComponentFactory + Button / EditText / Card 这些抽象
 */
class ThemeRenderer(private val factory: UIComponentFactory) {
 
    fun renderScreen() {
        // 通过工厂获取同一族的全套产品
        val button = factory.createButton()        // 获取按钮
        val editText = factory.createEditText()    // 获取输入框
        val card = factory.createCard()            // 获取卡片
 
        // 渲染到界面
        println("=== Screen Render ===")
        println(button.render())                   // 渲染按钮
        println(editText.render())                 // 渲染输入框
        println(card.render())                     // 渲染卡片
    }
}
 
fun main() {
    // 运行时根据用户设置选择主题工厂
    val isDarkMode = true  // 假设用户开启了深色模式
 
    // 根据条件注入不同的工厂
    val factory: UIComponentFactory = if (isDarkMode) {
        DarkThemeFactory()     // 深色主题工厂
    } else {
        LightThemeFactory()    // 浅色主题工厂
    }
 
    // ThemeRenderer 不关心具体是哪个工厂，它只面向接口
    val renderer = ThemeRenderer(factory)
    renderer.renderScreen()
}

=== Screen Render ===
🔳 Dark Button (深灰底白字)
📝 Dark EditText (深灰底亮边框)
🃏 Dark Card (深灰卡片 + 黑色阴影)

// ==================== BitmapFactory 核心 API（Framework 源码简化）====================
 
public class BitmapFactory {
 
    /**
     * 从资源文件解码 Bitmap
     * @param res   Resources 对象
     * @param id    资源 ID（如 R.drawable.photo）
     * @return      解码后的 Bitmap 对象
     */
    public static Bitmap decodeResource(Resources res, int id) {
        // 内部调用 native 层解码逻辑
        // ...
        return bitmap;
    }
 
    /**
     * 从文件路径解码 Bitmap
     * @param pathName 文件绝对路径
     * @return         解码后的 Bitmap 对象
     */
    public static Bitmap decodeFile(String pathName) {
        // 打开 FileInputStream → 调用 decodeStream
        // ...
        return bitmap;
    }
 
    /**
     * 从字节数组解码 Bitmap
     * @param data   字节数据
     * @param offset 偏移量
     * @param length 长度
     * @return       解码后的 Bitmap 对象
     */
    public static Bitmap decodeByteArray(byte[] data, int offset, int length) {
        // 调用 native 解码
        // ...
        return bitmap;
    }
 
    /**
     * 从输入流解码 Bitmap —— 最底层的通用方法
     * @param is  InputStream 输入流
     * @return    解码后的 Bitmap 对象
     */
    public static Bitmap decodeStream(InputStream is) {
        // 所有方法最终都会汇聚到这里或 native 层
        // ...
        return bitmap;
    }
}

// ==================== Android 应用层使用 BitmapFactory ====================
 
// 从 drawable 资源解码
val bitmap1: Bitmap = BitmapFactory.decodeResource(
    resources,           // Context.getResources()
    R.drawable.avatar    // 资源 ID
)
 
// 从文件路径解码
val bitmap2: Bitmap? = BitmapFactory.decodeFile(
    "/sdcard/DCIM/photo.jpg"   // 文件绝对路径
)
 
// 从网络下载的字节数组解码
val bitmap3: Bitmap? = BitmapFactory.decodeByteArray(
    byteArray,   // 网络下载的字节数据
    0,           // 起始偏移
    byteArray.size   // 数据长度
)

// ==================== LayoutInflater 中的工厂接口 ====================
 
public abstract class LayoutInflater {
 
    /**
     * Factory2 接口 —— 工厂方法模式的核心抽象
     * 任何想参与 View 创建过程的类都可以实现此接口
     */
    public interface Factory2 {
        /**
         * 工厂方法：根据 XML 标签名创建对应的 View 实例
         * @param parent  父 View
         * @param name    XML 标签名（如 "TextView", "LinearLayout"）
         * @param context 上下文
         * @param attrs   XML 属性集
         * @return        创建的 View 对象，返回 null 则交给下一个工厂处理
         */
        View onCreateView(View parent, String name, Context context, AttributeSet attrs);
    }
}

// ==================== LayoutInflater.createViewFromTag() 简化逻辑 ====================
 
View createViewFromTag(View parent, String name, Context context, AttributeSet attrs) {
    View view;
 
    // 第一优先级：尝试使用 mFactory2（通常是 AppCompatDelegateImpl）
    if (mFactory2 != null) {
        view = mFactory2.onCreateView(parent, name, context, attrs);  // 工厂方法调用
        if (view != null) return view;  // 如果工厂成功创建，直接返回
    }
 
    // 第二优先级：尝试使用 mFactory（兼容旧版）
    if (mFactory != null) {
        view = mFactory.onCreateView(name, context, attrs);
        if (view != null) return view;
    }
 
    // 第三优先级：使用 mPrivateFactory（系统内部使用，如 Fragment）
    if (mPrivateFactory != null) {
        view = mPrivateFactory.onCreateView(parent, name, context, attrs);
        if (view != null) return view;
    }
 
    // 兜底：通过反射创建 View（最终的默认逻辑）
    // 如果标签名包含 "."（如 "com.example.CustomView"），说明是全限定名
    // 否则补上 "android.widget." 前缀再反射
    view = onCreateView(context, parent, name, attrs);  // 反射兜底
    return view;
}

// ==================== AppCompatDelegateImpl（简化）====================
 
/**
 * AppCompatDelegateImpl 实现 Factory2 接口
 * 它就是 "具体工厂子类"，决定创建哪种 View
 */
class AppCompatDelegateImpl : LayoutInflater.Factory2 {
 
    override fun onCreateView(
        parent: View?,
        name: String,       // XML 标签名，如 "TextView"
        context: Context,
        attrs: AttributeSet
    ): View? {
        // 根据标签名决定创建哪个 AppCompat 版本的 View
        return when (name) {
            "TextView"    -> AppCompatTextView(context, attrs)     // TextView → AppCompatTextView
            "ImageView"   -> AppCompatImageView(context, attrs)    // ImageView → AppCompatImageView
            "Button"      -> AppCompatButton(context, attrs)       // Button → AppCompatButton
            "EditText"    -> AppCompatEditText(context, attrs)     // EditText → AppCompatEditText
            "CheckBox"    -> AppCompatCheckBox(context, attrs)     // CheckBox → AppCompatCheckBox
            "RadioButton" -> AppCompatRadioButton(context, attrs)  // RadioButton → AppCompatRadioButton
            // ... 更多替换规则
            else          -> null  // 返回 null 表示本工厂不处理，交给下一级
        }
    }
}

// ==================== 全局字体替换示例 ====================
 
class FontActivity : AppCompatActivity() {
 
    override fun onCreate(savedInstanceState: Bundle?) {
        // 必须在 super.onCreate() 之前设置 Factory2
        // 因为 AppCompatDelegateImpl 也要在 super 中注册自己的 Factory2
        val delegate = delegate  // 获取 AppCompatDelegate
 
        // 用 LayoutInflaterCompat 设置自定义 Factory2
        LayoutInflaterCompat.setFactory2(layoutInflater, object : LayoutInflater.Factory2 {
            override fun onCreateView(
                parent: View?, name: String, context: Context, attrs: AttributeSet
            ): View? {
                // 先让 AppCompat 默认处理（保留 AppCompat 兼容逻辑）
                val view = delegate.createView(parent, name, context, attrs)
 
                // 如果创建出来的是 TextView 或其子类，统一设置自定义字体
                if (view is TextView) {
                    val customFont = ResourcesCompat.getFont(context, R.font.custom_font)
                    view.typeface = customFont   // 全局替换字体
                }
 
                return view  // 返回处理后的 View
            }
 
            // Factory（旧版接口）的方法，委托给上面的方法
            override fun onCreateView(name: String, context: Context, attrs: AttributeSet): View? {
                return onCreateView(null, name, context, attrs)
            }
        })
 
        super.onCreate(savedInstanceState)   // 此后的 setContentView 就会走自定义 Factory2
        setContentView(R.layout.activity_font)
    }
}

/**
 * Product（产品）—— 一个复杂的网络请求配置对象
 * 拥有多个可选字段，不适合用构造函数直接创建
 */
public class NetworkConfig {
 
    // ====== 所有字段均为 final，保证对象不可变（Immutable） ======
    private final String baseUrl;          // 基础 URL（必选）
    private final int connectTimeout;      // 连接超时时间，单位毫秒
    private final int readTimeout;         // 读取超时时间，单位毫秒
    private final int retryCount;          // 重试次数
    private final boolean enableCache;     // 是否启用缓存
    private final boolean enableLog;       // 是否启用日志
 
    /**
     * 私有构造函数 —— 外部无法直接 new，必须通过 Builder 创建
     * 这是建造者模式的核心约束之一
     */
    private NetworkConfig(Builder builder) {
        // 从 Builder 中逐一取出各字段，赋值给 Product
        this.baseUrl = builder.baseUrl;
        this.connectTimeout = builder.connectTimeout;
        this.readTimeout = builder.readTimeout;
        this.retryCount = builder.retryCount;
        this.enableCache = builder.enableCache;
        this.enableLog = builder.enableLog;
    }
 
    // ====== 只提供 getter，不提供 setter，保持不可变性 ======
    public String getBaseUrl() { return baseUrl; }
    public int getConnectTimeout() { return connectTimeout; }
    public int getReadTimeout() { return readTimeout; }
    public int getRetryCount() { return retryCount; }
    public boolean isEnableCache() { return enableCache; }
    public boolean isEnableLog() { return enableLog; }
 
    /**
     * Builder（具体建造者）—— 以静态内部类的形式存在
     * 负责分步收集参数，最终构建出 NetworkConfig 实例
     */
    public static class Builder {
 
        // ====== 必选参数：在 Builder 构造函数中强制传入 ======
        private final String baseUrl;
 
        // ====== 可选参数：提供合理默认值 ======
        private int connectTimeout = 10_000;  // 默认 10 秒
        private int readTimeout = 10_000;     // 默认 10 秒
        private int retryCount = 3;           // 默认重试 3 次
        private boolean enableCache = true;   // 默认启用缓存
        private boolean enableLog = false;    // 默认关闭日志
 
        /**
         * Builder 构造函数 —— 接收必选参数
         * @param baseUrl 必须提供的基础 URL
         */
        public Builder(String baseUrl) {
            // 对必选参数做校验
            if (baseUrl == null || baseUrl.isEmpty()) {
                throw new IllegalArgumentException("baseUrl cannot be null or empty");
            }
            this.baseUrl = baseUrl;  // 保存必选参数
        }
 
        /**
         * 设置连接超时 —— 返回 this 以支持链式调用
         */
        public Builder connectTimeout(int timeout) {
            this.connectTimeout = timeout;  // 保存用户设定的超时值
            return this;                     // 返回自身，允许继续链式调用
        }
 
        /**
         * 设置读取超时
         */
        public Builder readTimeout(int timeout) {
            this.readTimeout = timeout;
            return this;
        }
 
        /**
         * 设置重试次数
         */
        public Builder retryCount(int count) {
            this.retryCount = count;
            return this;
        }
 
        /**
         * 设置是否启用缓存
         */
        public Builder enableCache(boolean enable) {
            this.enableCache = enable;
            return this;
        }
 
        /**
         * 设置是否启用日志
         */
        public Builder enableLog(boolean enable) {
            this.enableLog = enable;
            return this;
        }
 
        /**
         * build() —— 建造者模式的终结方法
         * 在这里可以做最终的参数校验，然后创建 Product 实例
         */
        public NetworkConfig build() {
            // 可以在此处做复杂的参数合法性校验
            if (connectTimeout < 0) {
                throw new IllegalStateException("connectTimeout must be >= 0");
            }
            // 调用 Product 的私有构造函数，将自身传入
            return new NetworkConfig(this);
        }
    }
}

// 分步构建 —— 每一步只关注一个属性，语义清晰
NetworkConfig config = new NetworkConfig.Builder("https://api.example.com")  // 必选参数
        .connectTimeout(15_000)  // 可选：连接超时 15 秒
        .readTimeout(20_000)     // 可选：读取超时 20 秒
        .retryCount(5)           // 可选：重试 5 次
        .enableCache(true)       // 可选：启用缓存
        .enableLog(true)         // 可选：启用日志
        .build();                // 终结操作：构建出最终产品

// ❌ Telescoping Constructor —— 参数含义不明，容易出错
// 请问 10000, 20000, 3, true, false 分别是什么？完全看不懂！
NetworkConfig config = new NetworkConfig(
    "https://api.example.com", 10000, 20000, 3, true, false
);
 
// ✅ Builder Pattern —— 每个参数都有名字，自文档化（Self-documenting）
NetworkConfig config = new NetworkConfig.Builder("https://api.example.com")
    .connectTimeout(10_000)   // 一目了然
    .readTimeout(20_000)      // 一目了然
    .retryCount(3)            // 一目了然
    .enableCache(true)        // 一目了然
    .enableLog(false)         // 一目了然
    .build();

class DialogConfig private constructor(       // 私有构造函数，禁止外部直接 new
    val title: String,                         // 对话框标题
    val message: String,                       // 对话框消息
    val positiveText: String,                  // 确认按钮文字
    val negativeText: String,                  // 取消按钮文字
    val isCancelable: Boolean                  // 是否可取消
) {
    /**
     * Builder 类 —— Kotlin 风格的建造者
     * 注意：Kotlin 提供了命名参数和默认值，有时可以替代 Builder
     * 但对于需要对外暴露的 SDK API，Builder 仍然是更好的选择
     */
    class Builder {
        // ====== 可变属性，收集构建参数 ======
        private var title: String = ""                // 默认空标题
        private var message: String = ""              // 默认空消息
        private var positiveText: String = "OK"       // 默认确认文字
        private var negativeText: String = "Cancel"   // 默认取消文字
        private var isCancelable: Boolean = true      // 默认可取消
 
        /**
         * 每个方法都返回 Builder 自身 —— 这就是链式调用的秘密
         * apply {} 是 Kotlin 的作用域函数，在 block 内部 this 指向 Builder
         */
        fun title(title: String) = apply {     // apply 返回 this
            this.title = title                  // 设置标题
        }
 
        fun message(message: String) = apply {
            this.message = message              // 设置消息
        }
 
        fun positiveText(text: String) = apply {
            this.positiveText = text            // 设置确认按钮文字
        }
 
        fun negativeText(text: String) = apply {
            this.negativeText = text            // 设置取消按钮文字
        }
 
        fun cancelable(cancelable: Boolean) = apply {
            this.isCancelable = cancelable      // 设置是否可取消
        }
 
        /**
         * build() —— 终结方法，返回的是 Product（DialogConfig）而非 Builder
         * 链条在这里断开，产出最终产品
         */
        fun build(): DialogConfig {
            // 参数校验
            require(title.isNotEmpty()) {       // require 是 Kotlin 内置的前置条件检查
                "Title must not be empty"       // 不满足条件则抛出 IllegalArgumentException
            }
            // 构建并返回不可变的 Product
            return DialogConfig(
                title = title,                  // 从 Builder 中取出收集到的参数
                message = message,
                positiveText = positiveText,
                negativeText = negativeText,
                isCancelable = isCancelable
            )
        }
    }
}

// 以下四行代码本质上等价于一条链式调用
val builder = DialogConfig.Builder()      // 步骤 1: 创建 Builder 实例
val ref1 = builder.title("Warning")       // 步骤 2: ref1 === builder (同一个对象)
val ref2 = ref1.message("Are you sure?")  // 步骤 3: ref2 === ref1 === builder
val ref3 = ref2.cancelable(false)         // 步骤 4: ref3 === ref2 === ref1 === builder
val config = ref3.build()                 // 步骤 5: config 是新的 DialogConfig 实例

 ┌─────────────── Heap (堆内存) ───────────────────┐
 │                                                  │
 │   ┌──────────────────────────┐                   │
 │   │   Builder Instance       │◀── builder        │
 │   │   ──────────────────     │◀── ref1 (同一对象)│
 │   │   title = "Warning"      │◀── ref2 (同一对象)│
 │   │   message = "Are you.."  │◀── ref3 (同一对象)│
 │   │   cancelable = false     │                   │
 │   └──────────────────────────┘                   │
 │                     │                            │
 │                     │ .build()                   │
 │                     ▼                            │
 │   ┌──────────────────────────┐                   │
 │   │   DialogConfig (Product) │◀── config         │
 │   │   ──────────────────     │    (新对象)        │
 │   │   title = "Warning"      │                   │
 │   │   message = "Are you.."  │                   │
 │   │   cancelable = false     │                   │
 │   │   (所有字段为 val/final) │                   │
 │   └──────────────────────────┘                   │
 └──────────────────────────────────────────────────┘

// apply 的源码定义（Kotlin 标准库）
public inline fun <T> T.apply(block: T.() -> Unit): T {
    block()       // 在 T 的上下文中执行 block
    return this   // 永远返回调用者自身 —— 这就是链式调用的本质
}

// Kotlin 方式 —— 利用 data class + 命名参数 + 默认值
data class NetworkConfig(
    val baseUrl: String,                      // 必选参数（无默认值）
    val connectTimeout: Int = 10_000,         // 可选，默认 10 秒
    val readTimeout: Int = 10_000,            // 可选，默认 10 秒
    val retryCount: Int = 3,                  // 可选，默认 3 次
    val enableCache: Boolean = true,          // 可选，默认启用
    val enableLog: Boolean = false            // 可选，默认关闭
)
 
// 调用时使用命名参数 —— 同样语义清晰
val config = NetworkConfig(
    baseUrl = "https://api.example.com",      // 必须提供
    connectTimeout = 15_000,                  // 可选覆盖
    enableLog = true                          // 可选覆盖，其余使用默认值
)

// ====== Java 版本 ======
AlertDialog dialog = new AlertDialog.Builder(this)        // 传入 Context（必选）
        .setTitle("删除确认")                               // 设置标题
        .setMessage("确定要删除这条记录吗？")                 // 设置消息体
        .setIcon(R.drawable.ic_warning)                     // 设置图标
        .setCancelable(false)                               // 禁止按返回键取消
        .setPositiveButton("删除", (dialog1, which) -> {    // 确认按钮 + 回调
            deleteRecord();                                 // 执行删除操作
        })
        .setNegativeButton("取消", (dialog1, which) -> {    // 取消按钮 + 回调
            dialog1.dismiss();                              // 关闭对话框
        })
        .setNeutralButton("了解更多", (dialog1, which) -> { // 中性按钮
            showHelpPage();                                 // 跳转帮助页
        })
        .create();                                          // 构建 AlertDialog 实例（不显示）
 
dialog.show();                                              // 显示对话框

// ====== Kotlin 版本（更简洁） ======
AlertDialog.Builder(this)                      // 传入 Context
    .setTitle("删除确认")                        // 设置标题
    .setMessage("确定要删除这条记录吗？")          // 设置消息体
    .setIcon(R.drawable.ic_warning)              // 设置图标
    .setCancelable(false)                        // 不可取消
    .setPositiveButton("删除") { _, _ ->         // Kotlin lambda 简写
        deleteRecord()                           // 执行删除
    }
    .setNegativeButton("取消") { dialog, _ ->
        dialog.dismiss()                         // 关闭对话框
    }
    .show()                                      // create() + show() 的快捷方式

// AlertDialog.Builder 源码核心逻辑简化版
public class AlertDialog extends Dialog {
 
    // AlertController 是真正管理 Dialog 内部 View 的控制器
    private final AlertController mAlert;  
 
    /**
     * Builder 静态内部类
     */
    public static class Builder {
        
        // P 是一个参数包，收集所有配置项
        private final AlertController.AlertParams P;  
 
        public Builder(Context context) {
            // 创建参数包，传入 Context 和默认主题
            P = new AlertController.AlertParams(
                new ContextThemeWrapper(context, resolveDialogTheme(context, 0))
            );
        }
 
        /**
         * setTitle —— 将 title 存入参数包 P
         * 返回 this 以支持链式调用
         */
        public Builder setTitle(CharSequence title) {
            P.mTitle = title;      // 存入参数包
            return this;           // 返回 Builder 自身
        }
 
        /**
         * setMessage —— 将 message 存入参数包 P
         */
        public Builder setMessage(CharSequence message) {
            P.mMessage = message;  // 存入参数包
            return this;           // 返回 Builder 自身
        }
 
        /**
         * create() —— 终结方法，从参数包 P 构建出 AlertDialog
         */
        public AlertDialog create() {
            // 1. 创建 AlertDialog 实例
            final AlertDialog dialog = new AlertDialog(P.mContext);
 
            // 2. 将参数包 P 中的所有配置，应用到 dialog 的 AlertController 上
            //    这一步是 "参数包 → 产品" 的关键转换
            P.apply(dialog.mAlert);
 
            // 3. 设置可取消属性
            dialog.setCancelable(P.mCancelable);
 
            if (P.mCancelable) {
                // 如果可取消，设置 cancel 监听器
                dialog.setCanceledOnTouchOutside(true);
            }
 
            // 4. 设置各种监听器
            dialog.setOnCancelListener(P.mOnCancelListener);
            dialog.setOnDismissListener(P.mOnDismissListener);
 
            if (P.mOnKeyListener != null) {
                dialog.setOnKeyListener(P.mOnKeyListener);
            }
 
            // 5. 返回构建好的 AlertDialog 产品
            return dialog;
        }
    }
}

// 构建 Retrofit 实例 —— 链式调用，语义极其清晰
val retrofit = Retrofit.Builder()
    .baseUrl("https://api.github.com/")           // 设置 API 基础 URL
    .client(okHttpClient)                          // 注入 OkHttpClient 实例
    .addConverterFactory(GsonConverterFactory.create())    // 添加 JSON 转换器
    .addCallAdapterFactory(RxJava3CallAdapterFactory.create()) // 添加 RxJava 适配器
    .validateEagerly(true)                         // 启用提前校验（开发阶段推荐）
    .build()                                       // 构建 Retrofit 实例

// Retrofit.Builder.build() 源码核心逻辑简化
public Retrofit build() {
    // 1. 必选参数校验 —— baseUrl 必须提供
    if (baseUrl == null) {
        throw new IllegalStateException("Base URL required.");
    }
 
    // 2. 如果用户没有提供 OkHttpClient，使用默认的
    okhttp3.Call.Factory callFactory = this.callFactory;
    if (callFactory == null) {
        callFactory = new OkHttpClient();   // 默认创建一个 OkHttpClient
    }
 
    // 3. 平台适配 —— 根据运行平台设置回调执行器
    Executor callbackExecutor = this.callbackExecutor;
    if (callbackExecutor == null) {
        // 在 Android 平台上，默认使用 MainThreadExecutor
        // 确保回调在主线程执行（更新 UI 安全）
        callbackExecutor = platform.defaultCallbackExecutor();
    }
 
    // 4. 组装 CallAdapter 工厂列表
    List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
    // 添加平台默认的 CallAdapter（如 Android 的 DefaultCallAdapterFactory）
    callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));
 
    // 5. 组装 Converter 工厂列表
    List<Converter.Factory> converterFactories = new ArrayList<>();
    converterFactories.add(new BuiltInConverters());  // 内置转换器（始终添加）
    converterFactories.addAll(this.converterFactories); // 用户自定义转换器
    converterFactories.addAll(platform.defaultConverterFactories()); // 平台默认
 
    // 6. 构建不可变的 Retrofit 实例
    return new Retrofit(
        callFactory,
        baseUrl,
        Collections.unmodifiableList(converterFactories),     // 不可变 List
        Collections.unmodifiableList(callAdapterFactories),   // 不可变 List
        callbackExecutor,
        validateEagerly
    );
}

val client = OkHttpClient.Builder()
    // ====== 超时配置 ======
    .connectTimeout(15, TimeUnit.SECONDS)        // 连接超时 15 秒
    .readTimeout(20, TimeUnit.SECONDS)           // 读取超时 20 秒
    .writeTimeout(20, TimeUnit.SECONDS)          // 写入超时 20 秒
    .pingInterval(30, TimeUnit.SECONDS)          // WebSocket ping 间隔
 
    // ====== 拦截器（Interceptor）配置 ======
    .addInterceptor(HttpLoggingInterceptor().apply {  // 应用层拦截器：日志
        level = HttpLoggingInterceptor.Level.BODY     // 记录完整的请求/响应体
    })
    .addInterceptor(AuthInterceptor(tokenProvider))   // 应用层拦截器：鉴权
    .addNetworkInterceptor(CacheInterceptor())        // 网络层拦截器：缓存
 
    // ====== 连接池与缓存 ======
    .connectionPool(ConnectionPool(                   // 自定义连接池
        maxIdleConnections = 10,                       // 最大空闲连接数
        keepAliveDuration = 5,                         // 连接保活时间
        timeUnit = TimeUnit.MINUTES                    // 时间单位
    ))
    .cache(Cache(                                      // HTTP 缓存
        directory = cacheDir,                          // 缓存目录
        maxSize = 50L * 1024L * 1024L                  // 缓存大小 50MB
    ))
 
    // ====== SSL/TLS 配置 ======
    .hostnameVerifier(myHostnameVerifier)              // 自定义主机名验证
    .certificatePinner(certificatePinner)              // 证书钉扎（Certificate Pinning）
 
    // ====== 其他配置 ======
    .followRedirects(true)                             // 允许 HTTP 重定向
    .followSslRedirects(true)                          // 允许 HTTPS → HTTP 重定向
    .retryOnConnectionFailure(true)                    // 连接失败时自动重试
 
    .build()                                           // 构建不可变的 OkHttpClient

// 基于已有的 client 创建新的 Builder —— 继承所有配置
// 这是建造者模式的进阶用法：Copy-on-Write Builder
val newClient = existingClient.newBuilder()      // 从现有实例反向创建 Builder
    .readTimeout(30, TimeUnit.SECONDS)           // 只修改需要变更的部分
    .addInterceptor(newInterceptor)              // 添加新的拦截器
    .build()                                     // 其余配置保持不变

// OkHttpClient 源码
public Builder newBuilder() {
    // 将当前 OkHttpClient 的所有配置，复制到新的 Builder 中
    return new Builder(this);  // 传入自身，Builder 会从中拷贝所有字段
}
 
// Builder 接受 OkHttpClient 参数的构造函数
Builder(OkHttpClient okHttpClient) {
    this.dispatcher = okHttpClient.dispatcher;                   // 复制调度器
    this.connectionPool = okHttpClient.connectionPool;           // 复制连接池
    this.interceptors.addAll(okHttpClient.interceptors);         // 复制拦截器列表
    this.networkInterceptors.addAll(okHttpClient.networkInterceptors);
    this.connectTimeout = okHttpClient.connectTimeout;           // 复制超时配置
    this.readTimeout = okHttpClient.readTimeout;
    this.writeTimeout = okHttpClient.writeTimeout;
    // ... 复制其余所有配置项
}

class Config private constructor(val a: Int, val b: Int) {
    class Builder {
        private var a = 0
        private var b = 0
        fun setA(a: Int) = apply { this.a = a }
        fun setB(b: Int) = apply { this.b = b }
        fun build() = Config(a, b)
    }
}
 
fun main() {
    val builder = Config.Builder()
    val b1 = builder.setA(1)
    val b2 = builder.setB(2)
    val config = b1.build()
    println("a=${config.a}, b=${config.b}")
}