Java 创建对象的几种常见方式

// 定义一个简单的类
class Person {
    private String name;
    private int age;
    // 无参构造方法
    public Person() {}
    // 有参构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // getter/setter 略
}
// 使用 new 关键字创建对象
public class NewDemo {
    public static void main(String[] args) {
        Person p1 = new Person(); // 调用无参构造
        Person p2 = new Person("张三", 25); // 调用有参构造
    }
}

public class ReflectDemo1 {
    public static void main(String[] args) {
        try {
            // 1. 获取 Person 类的 Class 对象
            Class<Person> personClass = Person.class;
            // 2. 调用 newInstance() 创建对象（依赖无参构造）
            Person p = personClass.newInstance();
            // 3. 后续操作
            p.setName("李四");
            System.out.println(p.getName()); // 输出：李四
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class ReflectDemo2 {
    public static void main(String[] args) {
        try {
            // 1. 获取 Class 对象
            Class<Person> personClass = Person.class;
            // 2. 获取有参构造方法（参数为 String 和 int）
            Constructor<Person> constructor = personClass.getConstructor(String.class, int.class);
            // 3. 调用构造方法创建对象
            Person p = constructor.newInstance("王五", 30);
            System.out.println(p.getName() + "，" + p.getAge()); // 输出：王五，30
            // 4. 访问私有构造方法（假设 Person 有一个私有构造）
            Constructor<Person> privateConstructor = personClass.getDeclaredConstructor(String.class);
            privateConstructor.setAccessible(true); // 暴力访问私有方法
            Person p2 = privateConstructor.newInstance("赵六");
        } catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

// 实现 Cloneable 接口
class Student implements Cloneable {
    private String name;
    private int grade;
    public Student(String name, int grade) {
        this.name = name;
        this.grade = grade;
    }
    // 重写 clone() 方法
    @Override
    public Student clone() throws CloneNotSupportedException {
        return (Student) super.clone();
    }
    // getter/setter 略
}
public class CloneDemo {
    public static void main(String[] args) {
        try {
            Student s1 = new Student("小明", 3);
            Student s2 = s1.clone(); // 克隆对象
            System.out.println(s1 == s2); // 输出：false（不同对象）
            System.out.println(s1.getName().equals(s2.getName())); // 输出：true（属性值相同）
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

import java.io.*;
// 实现 Serializable 接口
class Book implements Serializable {
    private String title;
    private double price;
    public Book(String title, double price) {
        this.title = title;
        this.price = price;
    }
    // getter/setter 略
}
public class SerializeDemo {
    // 序列化：将对象写入文件
    public static void serialize(Book book, String filePath) throws IOException {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath))) {
            oos.writeObject(book);
        }
    }
    // 反序列化：从文件读取对象（创建新对象）
    public static Book deserialize(String filePath) throws IOException, ClassNotFoundException {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath))) {
            return (Book) ois.readObject();
        }
    }
    public static void main(String[] args) {
        try {
            Book book1 = new Book("Java编程思想", 108.0);
            // 序列化
            serialize(book1, "book.ser");
            // 反序列化创建新对象
            Book book2 = deserialize("book.ser");
            System.out.println(book1 == book2); // 输出：false（不同对象）
            System.out.println(book2.getTitle()); // 输出：Java编程思想
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

// 产品接口
interface Shape {
    void draw();
}
// 具体产品：圆形
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}
// 具体产品：矩形
class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}
// 工厂类：负责创建对象
class ShapeFactory {
    // 根据类型创建不同对象
    public static Shape getShape(String type) {
        if ("circle".equals(type)) {
            return new Circle();
        } else if ("rectangle".equals(type)) {
            return new Rectangle();
        }
        return null;
    }
}
// 使用工厂创建对象
public class FactoryDemo {
    public static void main(String[] args) {
        Shape circle = ShapeFactory.getShape("circle");
        circle.draw(); // 输出：绘制圆形
        Shape rectangle = ShapeFactory.getShape("rectangle");
        rectangle.draw(); // 输出：绘制矩形
    }
}