编程自学指南：java程序设计开发，Java 对象创建的6种方式，从new到反射：Java 对象创建全解析，new关键字，反射机制，克隆（Clone），反序列化 ，工厂模式，建造者模式

编程自学指南：java程序设计开发，Java 对象创建的几种方式

一、课程信息

学习目标

1. 掌握 6 种主流对象创建方式的实现方法
2. 理解每种方式的适用场景与优缺点
3. 能根据需求选择最合适的创建方式
4. 避免对象创建中的常见错误（如构造器权限问题）

二、课程导入：生活中的 "创建"

🌰 场景类比

• 买现成的 → new关键字（最常用）
• 复制已有物品 → 克隆（Clone）
• 按图纸定制 → 工厂模式（复杂对象）
• 反序列化 → 从文件 / 网络恢复对象

三、主流创建方式

🔨 方式 1：new关键字（最常用）

核心语法

ClassName obj = new ClassName(参数); // 调用构造器

案例：创建学生对象

class Student {
    private String name;
    public Student(String name) { // 构造器
        this.name = name;
    }
}

// 创建对象
Student stu = new Student("张三"); // 调用构造器初始化

特点

✅ 简单直接，可读性强
❌ 无法创建私有构造器的类

🔍 方式 2：反射机制（高级用法）

核心步骤

1. 获取 Class 对象
2. 获取构造器
3. 调用newInstance()（JDK9 + 改用getDeclaredConstructor().newInstance()）

案例：动态创建对象

try {
    // 方式1：通过类名获取Class
    Class<Student> clazz = Student.class;
    
    // 方式2：通过全类名获取（适合配置文件）
    Class<?> clazz = Class.forName("com.example.Student");
    
    // 获取无参构造器
    Constructor<Student> constructor = clazz.getConstructor(String.class);
    
    // 创建对象（JDK9+需设置访问权限）
    Student stu = constructor.newInstance("李四");
} catch (Exception e) {
    e.printStackTrace();
}

适用场景

• 框架开发（如 Spring 依赖注入）
• 动态加载类（根据配置创建不同实现）

📋 方式 3：克隆（Clone）

核心步骤

1. 实现Cloneable接口
2. 重写clone()方法

案例：简历克隆（浅拷贝）

class Resume implements Cloneable {
    private String name;
    
    public Resume(String name) { this.name = name; }
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); // 浅拷贝
    }
}

// 使用
Resume original = new Resume("张三");
Resume copy = (Resume) original.clone();

深拷贝改进

class Address implements Cloneable {
    private String city;
    // 重写clone()...
}

class Resume implements Cloneable {
    private Address address;
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Resume clone = (Resume) super.clone();
        clone.address = (Address) address.clone(); // 深拷贝
        return clone;
    }
}

💾 方式 4：反序列化（从字节流恢复）

核心步骤

1. 实现Serializable接口
2. 序列化对象到文件
3. 反序列化恢复对象

案例：用户对象持久化

import java.io.*;

class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String username;
    
    public User(String username) { this.username = username; }
}

// 序列化
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.obj"))) {
    oos.writeObject(new User("admin"));
}

// 反序列化
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user.obj"))) {
    User user = (User) ois.readObject(); // 创建新对象
}

🏭 方式 5：工厂模式（解耦创建与使用）

案例：简单工厂

class CarFactory {
    public static Car createCar(String type) {
        if ("electric".equals(type)) {
            return new ElectricCar();
        } else {
            return new GasCar();
        }
    }
}

// 使用
Car car = CarFactory.createCar("electric");

🛠️ 方式 6：建造者模式（复杂对象分步创建）

案例：电脑配置

class Computer {
    private String cpu;
    private String ram;
    
    private Computer(Builder builder) {
        this.cpu = builder.cpu;
        this.ram = builder.ram;
    }
    
    public static class Builder {
        private String cpu;
        private String ram = "8G"; // 默认值
        
        public Builder cpu(String cpu) {
            this.cpu = cpu;
            return this;
        }
        
        public Computer build() {
            return new Computer(this);
        }
    }
}

// 使用
Computer highEnd = new Computer.Builder()
    .cpu("i7")
    .ram("16G")
    .build();

四、创建方式对比

方式	优点	缺点	适用场景
new	简单直接	无法创建私有构造器的类	日常开发，简单对象
反射	动态创建，突破权限	代码复杂，性能略低	框架开发，插件系统
克隆	快速复制对象	深拷贝实现复杂	批量生成相似对象
反序列化	持久化 / 网络传输	依赖序列化协议	对象持久化，分布式系统
工厂模式	解耦创建与使用	增加类数量	多类型对象统一创建
建造者模式	分步设置参数，支持默认值	类结构复杂	参数众多的复杂对象

五、初学者必避的 3 大陷阱

陷阱 1：私有构造器无法通过new创建

class Singleton {
    private Singleton() {} // 私有构造器
    public static Singleton getInstance() {
        return new Singleton(); // 只能通过静态方法创建
    }
}

// 错误：无法在外部调用new Singleton()

陷阱 2：反射忽略权限检查

Constructor<Student> constructor = clazz.getDeclaredConstructor();
constructor.setAccessible(true); // 暴力访问私有构造器
Student stu = constructor.newInstance();

陷阱 3：克隆时的浅拷贝问题

class User implements Cloneable {
    private List<String> hobbies;
    
    // 未重写clone()，hobbies是浅拷贝
}

六、课堂练习

练习 1：用三种方式创建对象

任务：为Person类实现以下创建方式

1. new关键字（带参构造器）
2. 反射（无参构造器）
3. 克隆（深拷贝）

练习 2：分析创建方式

场景：

• 从文件中读取用户数据并恢复对象 → 反序列化
• 框架根据配置文件创建不同数据库连接 → 反射
• 批量生成 100 个相似的游戏角色 → 克隆

七、课程总结

知识图谱：

对象创建方式  
   ↳ 基础：new、克隆、反序列化  
   ↳ 设计模式：工厂、建造者  
   ↳ 高级：反射  
核心原则：根据场景选择最合适的方式，兼顾可读性与灵活性  

口诀记忆：

“new 是基础最常用，反射动态破权限，
克隆复制省力气，反序列化存对象，
工厂建造解耦好，复杂对象分步造！”

八、课后作业

必做 1：综合创建练习

需求：

1. 定义Book类，包含title、author属性
2. 实现以下创建方式：
   • new带参构造器
   • 反射（无参 + 有参构造器）
   • 克隆（浅拷贝）

必做 2：单例模式创建对比

任务：

1. 用new+ 私有构造器实现饿汉式单例
2. 用反射破坏单例，思考如何防御