从文件数据动态创建Java对象：策略与实践

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class DataParser {

    public static List<String[]> parseFile(String filePath) {
        List<String[]> parsedLines = new ArrayList<>();
        // 使用 try-with-resources 确保资源自动关闭
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = reader.readLine()) != null) {
                // 忽略空行或只包含空白字符的行
                if (line.trim().isEmpty()) {
                    continue;
                }
                // 使用逗号作为分隔符拆分字符串
                String[] parts = line.split(",");
                // 确保至少有足够的字段
                if (parts.length >= 3) {
                    parsedLines.add(parts);
                } else {
                    System.err.println("警告: 跳过格式不正确的行 -> " + line);
                }
            }
        } catch (IOException e) {
            System.err.println("读取文件时发生错误: " + e.getMessage());
            e.printStackTrace();
        }
        return parsedLines;
    }

    public static void main(String[] args) {
        // 假设 data.txt 存在于项目根目录
        List<String[]> data = parseFile("data.txt");
        for (String[] parts : data) {
            System.out.println("类型: " + parts[0] + ", 名称: " + parts[1] + ", 描述: " + parts[2]);
        }
    }
}

// Room.java
public class Room {
    private String name;
    private String description;

    public Room(String name, String description) {
        this.name = name;
        this.description = description;
    }

    public String getName() {
        return name;
    }

    public String getDescription() {
        return description;
    }

    @Override
    public String toString() {
        return "Room [name=" + name + ", description=" + description + "]";
    }
}

// Staircase.java (示例，如果需要其他类型的对象)
public class Staircase {
    private String direction;
    private String description;

    public Staircase(String direction, String description) {
        this.direction = direction;
        this.description = description;
    }

    public String getDirection() {
        return direction;
    }

    public String getDescription() {
        return description;
    }

    @Override
    public String toString() {
        return "Staircase [direction=" + direction + ", description=" + description + "]";
    }
}

import java.util.HashMap;
import java.util.Map;

public class ObjectCreator {

    // 使用一个 Map 来存储创建的对象，键可以是对象的名称
    private Map<String, Object> gameObjects = new HashMap<>();

    public void createObjectFromParts(String[] parts) {
        String type = parts[0];     // 例如 "Room"
        String name = parts[1];     // 例如 "home"
        String description = parts[2]; // 例如 "You are in your home"

        switch (type) {
            case "Room":
                Room room = new Room(name, description);
                gameObjects.put(name, room); // 将对象存储到Map中，以便后续访问
                System.out.println("创建了 Room 对象: " + room);
                break;
            case "Staircase":
                Staircase staircase = new Staircase(name, description); // 这里 name 对应 Staircase 的 direction
                gameObjects.put(name, staircase);
                System.out.println("创建了 Staircase 对象: " + staircase);
                break;
            // 可以添加更多 case 来处理其他类型的对象
            default:
                System.err.println("未知对象类型: " + type);
                break;
        }
    }

    public Map<String, Object> getGameObjects() {
        return gameObjects;
    }

    public static void main(String[] args) {
        // 假设 DataParser 已经解析了文件
        List<String[]> parsedData = DataParser.parseFile("data.txt"); // 重新调用解析方法

        ObjectCreator creator = new ObjectCreator();
        for (String[] parts : parsedData) {
            creator.createObjectFromParts(parts);
        }

        System.out.println("\n所有创建的对象:");
        creator.getGameObjects().forEach((key, value) ->
            System.out.println("键: " + key + ", 值: " + value)
        );
    }
}

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ReflectiveObjectCreator {

    private Map<String, Object> gameObjects = new HashMap<>();

    public void createObjectFromParts(String[] parts) {
        String className = parts[0]; // 例如 "Room"
        String name = parts[1];
        String description = parts[2];

        try {
            // 1. 根据类名字符串获取 Class 对象
            // 注意：这里假设类名与文件中的类型字符串一致，且类在当前classpath下
            // 例如 "Room" 对应 Room.class
            Class<?> clazz = Class.forName(className);

            // 2. 获取构造器：这里假设所有类都有一个 (String, String) 签名的构造器
            Constructor<?> constructor = clazz.getConstructor(String.class, String.class);

            // 3. 创建实例
            Object instance = constructor.newInstance(name, description);

            // 4. 存储实例
            gameObjects.put(name, instance);
            System.out.println("反射创建了 " + className + " 对象: " + instance);

        } catch (ClassNotFoundException e) {
            System.err.println("错误: 未找到类 -> " + className);
        } catch (NoSuchMethodException e) {
            System.err.println("错误: 未找到匹配的构造器 for " + className + " -> " + e.getMessage());
        } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
            System.err.println("错误: 创建实例失败 for " + className + " -> " + e.getMessage());
            e.printStackTrace();
        }
    }

    public Map<String, Object> getGameObjects() {
        return gameObjects;
    }

    public static void main(String[] args) {
        List<String[]> parsedData = DataParser.parseFile("data.txt");

        ReflectiveObjectCreator creator = new ReflectiveObjectCreator();
        for (String[] parts : parsedData) {
            creator.createObjectFromParts(parts);
        }

        System.out.println("\n所有反射创建的对象:");
        creator.getGameObjects().forEach((key, value) ->
            System.out.println("键: " + key + ", 值: " + value)
        );
    }
}