// 定義一個(gè)簡單的類
class Person {
    private String name;
    private int age;
    // 無參構(gòu)造方法
    public Person() {}
    // 有參構(gòu)造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // getter/setter 略
}
// 使用 new 關(guān)鍵字創(chuàng)建對(duì)象
public class NewDemo {
    public static void main(String[] args) {
        Person p1 = new Person(); // 調(diào)用無參構(gòu)造
        Person p2 = new Person("張三", 25); // 調(diào)用有參構(gòu)造
    }
}

public class ReflectDemo1 {
    public static void main(String[] args) {
        try {
            // 1. 獲取 Person 類的 Class 對(duì)象
            Class<Person> personClass = Person.class;
            // 2. 調(diào)用 newInstance() 創(chuàng)建對(duì)象（依賴無參構(gòu)造）
            Person p = personClass.newInstance();
            // 3. 后續(xù)操作
            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 對(duì)象
            Class<Person> personClass = Person.class;
            // 2. 獲取有參構(gòu)造方法（參數(shù)為 String 和 int）
            Constructor<Person> constructor = personClass.getConstructor(String.class, int.class);
            // 3. 調(diào)用構(gòu)造方法創(chuàng)建對(duì)象
            Person p = constructor.newInstance("王五", 30);
            System.out.println(p.getName() + "，" + p.getAge()); // 輸出：王五，30
            // 4. 訪問私有構(gòu)造方法（假設(shè) Person 有一個(gè)私有構(gòu)造）
            Constructor<Person> privateConstructor = personClass.getDeclaredConstructor(String.class);
            privateConstructor.setAccessible(true); // 暴力訪問私有方法
            Person p2 = privateConstructor.newInstance("趙六");
        } catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

// 實(shí)現(xiàn) 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(); // 克隆對(duì)象
            System.out.println(s1 == s2); // 輸出：false（不同對(duì)象）
            System.out.println(s1.getName().equals(s2.getName())); // 輸出：true（屬性值相同）
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

import java.io.*;
// 實(shí)現(xiàn) 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 {
    // 序列化：將對(duì)象寫入文件
    public static void serialize(Book book, String filePath) throws IOException {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath))) {
            oos.writeObject(book);
        }
    }
    // 反序列化：從文件讀取對(duì)象（創(chuàng)建新對(duì)象）
    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");
            // 反序列化創(chuàng)建新對(duì)象
            Book book2 = deserialize("book.ser");
            System.out.println(book1 == book2); // 輸出：false（不同對(duì)象）
            System.out.println(book2.getTitle()); // 輸出：Java編程思想
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

// 產(chǎn)品接口
interface Shape {
    void draw();
}
// 具體產(chǎn)品：圓形
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("繪制圓形");
    }
}
// 具體產(chǎn)品：矩形
class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("繪制矩形");
    }
}
// 工廠類：負(fù)責(zé)創(chuàng)建對(duì)象
class ShapeFactory {
    // 根據(jù)類型創(chuàng)建不同對(duì)象
    public static Shape getShape(String type) {
        if ("circle".equals(type)) {
            return new Circle();
        } else if ("rectangle".equals(type)) {
            return new Rectangle();
        }
        return null;
    }
}
// 使用工廠創(chuàng)建對(duì)象
public class FactoryDemo {
    public static void main(String[] args) {
        Shape circle = ShapeFactory.getShape("circle");
        circle.draw(); // 輸出：繪制圓形
        Shape rectangle = ShapeFactory.getShape("rectangle");
        rectangle.draw(); // 輸出：繪制矩形
    }
}