一文总结使用Java创建对象的八种方式

// 就像我们平时说话："来一辆新车"
Car car = new Car();

// 或者带参数的："来一辆红色的宝马"
Car bmw = new Car("宝马", "红色");

// 传统方式：我知道要创建Car
Car car = new Car();

// 反射方式：运行时才知道要创建什么
try {
    Class carClass = Class.forName("com.example.Car");
    Constructor constructor = carClass.getConstructor();
    Car car = (Car) constructor.newInstance();
} catch (Exception e) {
    e.printStackTrace();
}

// Spring内部大致是这样做的
Class beanClass = loadClass("com.example.UserService");
Object bean = beanClass.getDeclaredConstructor().newInstance();

class UserSettings implements Cloneable {
    private String theme = "dark";
    private int fontSize = 14;
    
    @Override
    public UserSettings clone() {
        try {
            return (UserSettings) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

// 使用clone
UserSettings original = new UserSettings();
UserSettings cloned = original.clone(); // 得到一个完全相同的副本

// 对象需要实现Serializable接口
class GameSave implements Serializable {
    private static final long serialVersionUID = 1L;
    private int level;
    private int score;
}

// 保存对象到文件
try (ObjectOutputStream oos = new ObjectOutputStream(
        new FileOutputStream("save.dat"))) {
    oos.writeObject(gameSave);
}

// 从文件读取对象
try (ObjectInputStream ois = new ObjectInputStream(
        new FileInputStream("save.dat"))) {
    GameSave loadedSave = (GameSave) ois.readObject();
    // loadedSave就是原来那个gameSave的副本
}

class Color {
    private int red, green, blue;
    
    private Color(int r, int g, int b) {
        this.red = r;
        this.green = g;
        this.blue = b;
    }
    
    // 静态工厂方法：语义更明确
    public static Color fromRGB(int r, int g, int b) {
        return new Color(r, g, b);
    }
    
    public static Color fromHex(String hex) {
        // 解析十六进制颜色码
        return new Color(/* 解析逻辑 */);
    }
    
    public static Color red() {
        return new Color(255, 0, 0);
    }
}

// 使用：这样读起来更自然
Color red = Color.red();
Color custom = Color.fromRGB(255, 128, 0);

class Computer {
    private final String cpu;          // 必须
    private final String ram;          // 必须  
    private final String storage;      // 必须
    private final String graphicsCard; // 可选
    private final String monitor;      // 可选
    
    // 私有构造方法，只能通过Builder创建
    private Computer(Builder builder) {
        this.cpu = builder.cpu;
        this.ram = builder.ram;
        this.storage = builder.storage;
        this.graphicsCard = builder.graphicsCard;
        this.monitor = builder.monitor;
    }
    
    public static class Builder {
        // 必须参数
        private final String cpu;
        private final String ram;
        private final String storage;
        
        // 可选参数
        private String graphicsCard = "集成显卡";
        private String monitor = "23寸显示器";
        
        // Builder构造方法包含必须参数
        public Builder(String cpu, String ram, String storage) {
            this.cpu = cpu;
            this.ram = ram;
            this.storage = storage;
        }
        
        // 设置可选参数的方法
        public Builder graphicsCard(String graphicsCard) {
            this.graphicsCard = graphicsCard;
            return this;
        }
        
        public Builder monitor(String monitor) {
            this.monitor = monitor;
            return this;
        }
        
        public Computer build() {
            return new Computer(this);
        }
    }
}

// 使用Builder模式：链式调用，非常清晰
Computer gamingPC = new Computer.Builder("i7", "16GB", "1TB SSD")
    .graphicsCard("RTX 3080")
    .monitor("27寸4K显示器")
    .build();

// 创建线程的传统方式
class MyTask implements Runnable {
    @Override
    public void run() {
        System.out.println("执行任务");
    }
}

Runnable task1 = new MyTask();

// 使用匿名内部类：更简洁
Runnable task2 = new Runnable() {
    @Override
    public void run() {
        System.out.println("执行任务");
    }
};

// Java 8以后，可以用lambda表达式进一步简化
Runnable task3 = () -> System.out.println("执行任务");

class Person {
    private String name;
    
    public Person() {
        this.name = "匿名";
    }
    
    public Person(String name) {
        this.name = name;
    }
}

// 方法引用创建对象
Supplier defaultPerson = Person::new;
Function namedPerson = Person::new;

// 使用
Person p1 = defaultPerson.get();      // 调用无参构造
Person p2 = namedPerson.apply("张三"); // 调用有参构造