如何存储类的类型以供以后在Java中使用？

我有以下类型：

public class Vehicle { ... }

车辆由用户操作实例化。将其视为一款发明游戏，用户可以创建他/她想要的任何类型的车辆。对于车辆的每个对象，我需要定期记录对象的状态。因此，我有以下课程：

public abstract class Log { ... }
public class LogTyre extends Log { ... }
public class LogHandle extends Log { ... }
public class LogBrake extends Log { ... }
public class LogEngine extends Log { ... }
...etc...

更复杂的是，每辆车都有一套不同的记录要求。例如，自行车类型的车辆不需要LogEngine对象

因此，在实例化车辆的过程中，我需要存储车辆所需日志类型的类类型。因此，当需要执行日志时，记录器将能够为特定车辆实例化必要的日志类。如何在Java中实现这一点？或者可能只是在OOP中

---

非常感谢您的帮助。

假设您需要访问的方法是由日志定义的，您是否可以在日志类中添加“日志类型”枚举，以便您可以查找每个日志？比如：

private void logStuff(LogType logType, Map<LogType, Log> vehicleLogs){
    Log log = vehicleLogs.get(logType);

    if(log != null){
        log.doLogStuff();
    }
}

private void日志文件（日志类型日志类型，地图车辆日志）{
Log Log=vehicleLogs.get（日志类型）；
if（log！=null）{
log.doLogStuff（）；
}
}

---

其中LogType具有诸如Handle、Engine等值。

我不确定是否正确理解了您的问题。但是，在装满鳗鱼的气垫船的提示下，编写了以下代码。您可以添加其他类型的日志。希望这有帮助

import java.io.PrintStream;
import java.util.ArrayList;

public class Logger {
    public static void main(String[] args) {
        // creating vehicles
        Vehicle[] vs = { new Vehicle("Bike"), new Vehicle("Car") };

        // adding logs of different type
        vs[0].addLog(new LogTyre("Slim"));
        vs[1].addLog(new LogTyre("Wide"));
        vs[1].addLog(new LogEngine("Lean burn"));

        // maintaining logs
        Logger logger = new Logger();
        for (Vehicle v: vs)
            v.writeLog(logger);

        // printing logs
        for (Vehicle v: vs)
            v.printLogs();
    }
    public void write(Log log) {
        System.out.printf(".. writing to %s.%n", log.name());
        // You may write different logs depending on the log types using common methods
    }
}

class Vehicle {
    String type;            // vehicle type
    ArrayList<Log> logs;    // logs to be maintained
    public Vehicle(String type) {
        this.type = type;
        logs = new ArrayList<Log>();
    }
    public void addLog(Log log) {
        logs.add(log);
    }
    public void writeLog(Logger w)  {
        for (Log log: logs)
            log.accept(w);
    }
    public void printLogs() {
        for (Log log: logs) {
            log.print(System.out);
        }
    }
}

abstract class Log {
    protected String name;  // common fields
    // accepting the visitor
    public void accept(Logger logger) {
        logger.write(this);
    }
    // common methods for maintaining logs
    public abstract String name();
    public void print(PrintStream ps) {
        ps.printf("[Log: %s]%n", name());
    }
}

class LogTyre extends Log {
    public LogTyre(String name) {
        super.name = name;
    }
    public String name() {
        return name+" Tyre Log";
    }
}

class LogEngine extends Log {
    public LogEngine(String name) {
        super.name = name;
    }
    public String name() {
        return name+" Engine Log";
    }
}

导入java.io.PrintStream；
导入java.util.ArrayList；
公共类记录器{
公共静态void main（字符串[]args）{
//创造交通工具
车辆[]vs={新车（“自行车”）、新车（“汽车”）}；
//添加不同类型的日志
vs[0]。添加日志（新的LogTyre（“Slim”）；
vs[1].addLog（新LogTyre（“宽”））；
vs[1]。添加日志（新日志引擎（“稀燃”）；
//维护日志
记录器=新记录器（）；
用于（车辆v:vs）
v、 写日志（记录器）；
//打印日志
用于（车辆v:vs）
v、 打印日志（）；
}
公共无效写入（日志）{
System.out.printf（“…写入%s.%n”，log.name（））；
//根据日志类型，您可以使用常用方法编写不同的日志
}
}
等级车辆{
字符串类型；//车辆类型
ArrayList日志；//要维护的日志
公共车辆（串式）{
this.type=type；
logs=newarraylist（）；
}
公共无效添加日志（日志日志）{
日志。添加（日志）；
}
公共无效写入日志（记录器w）{
用于（日志：日志）
log.accept（w）；
}
公共作废打印日志（）{
用于（日志：日志）{
日志打印（系统输出）；
}
}
}
抽象类日志{
受保护的字符串名称；//公共字段
//接待来访者
公共无效接受（记录器）{
写（这个）；
}
//维护日志的常用方法
公共抽象字符串名称（）；
公共作废打印（打印流ps）{
ps.printf（“[Log:%s]%n”，name（））；
}
}
类LOGTIRE扩展日志{
公共LogTyre（字符串名称）{
super.name=名称；
}
公共字符串名称（）{
返回名称+“轮胎日志”；
}
}
类LogEngine扩展了日志{
公共日志引擎（字符串名称）{
super.name=名称；
}
公共字符串名称（）{
返回name+“引擎日志”；
}
}

---

上述代码的此键用于使用accept方法将记录器传递到日志。然后，此accept方法将调用各种类型日志的适当写入方法。

我不确定是否完全理解此问题，但我认为您应该将特定的

日志

s存储为特定

车辆

s的成员，如下所示：公共类自行车扩展车辆{private LogHandle LogHandle；private LogBrake LogBrake；}考虑一下访问者设计模式，因为我觉得它有助于满足你的需求。我不能把自行车定义为一种类型，因为我不知道这是否是用户想要的交通工具。我可以提供一组要求，用户会在运行时选择那些要求是为了记录。因此我不能做“自行车延伸车”。因为它还不存在…myVehicle.getClass（）？