Java智能体案例

wen java案例 2026-08-01 183

本文目录导读：

Java智能体案例

智能体核心架构
感知系统
决策系统
行动执行系统
环境系统
记忆系统
具体智能体实现
主程序
增强功能（可选）
运行说明
扩展建议

我将为您提供一个完整的Java智能体案例，展示如何使用Java实现一个具备感知、决策和行动能力的简单智能体系统。

智能体核心架构

// Agent.java - 智能体基类
public abstract class Agent {
    protected String name;
    protected Environment environment;
    protected Perception perception;
    protected DecisionMaker decisionMaker;
    protected ActionExecutor actionExecutor;
    protected Memory memory;
    public Agent(String name) {
        this.name = name;
        this.memory = new Memory();
    }
    public abstract void initialize();
    public abstract void run();
    protected void perceive() {
        perception = environment.getPerception();
    }
    protected void decide() {
        Decision decision = decisionMaker.makeDecision(perception, memory);
        memory.storeDecision(decision);
    }
    protected void act(Decision decision) {
        actionExecutor.execute(decision);
    }
    // Getters and setters
    public String getName() { return name; }
    public Environment getEnvironment() { return environment; }
    public void setEnvironment(Environment environment) { 
        this.environment = environment; 
        environment.registerAgent(this);
    }
}

感知系统

// Perception.java - 感知信息类
public class Perception {
    private Map<String, Object> perceptions = new HashMap<>();
    private long timestamp;
    public void addPerception(String key, Object value) {
        perceptions.put(key, value);
        timestamp = System.currentTimeMillis();
    }
    public Object getPerception(String key) {
        return perceptions.get(key);
    }
    public Map<String, Object> getAllPerceptions() {
        return Collections.unmodifiableMap(perceptions);
    }
}
// Sensor.java - 传感器接口
public interface Sensor {
    void perceive(Environment environment);
    Perception getPerception();
}
// EnvironmentSensor.java - 环境传感器实现
public class EnvironmentSensor implements Sensor {
    private Perception perception;
    @Override
    public void perceive(Environment environment) {
        perception = new Perception();
        // 感知环境状态
        perception.addPerception("temperature", environment.getTemperature());
        perception.addPerception("humidity", environment.getHumidity());
        perception.addPerception("position", environment.getAgentPosition());
        perception.addPerception("obstacles", environment.getObstacles());
        perception.addPerception("target", environment.getTarget());
    }
    @Override
    public Perception getPerception() {
        return perception;
    }
}

决策系统

// Decision.java - 决策类
public class Decision {
    private String action;
    private Map<String, Object> parameters;
    private double confidence;
    public Decision(String action, Map<String, Object> parameters, double confidence) {
        this.action = action;
        this.parameters = parameters;
        this.confidence = confidence;
    }
    // Getters
    public String getAction() { return action; }
    public Map<String, Object> getParameters() { return parameters; }
    public double getConfidence() { return confidence; }
}
// DecisionMaker.java - 决策器接口
public interface DecisionMaker {
    Decision makeDecision(Perception perception, Memory memory);
}
// RuleBasedDecisionMaker.java - 基于规则的决策器
public class RuleBasedDecisionMaker implements DecisionMaker {
    private List<Rule> rules = new ArrayList<>();
    public void addRule(Rule rule) {
        rules.add(rule);
    }
    @Override
    public Decision makeDecision(Perception perception, Memory memory) {
        for (Rule rule : rules) {
            if (rule.matches(perception)) {
                return rule.getDecision();
            }
        }
        // 默认决策
        return new Decision("idle", Collections.emptyMap(), 0.5);
    }
}
// Rule.java - 规则接口
public interface Rule {
    boolean matches(Perception perception);
    Decision getDecision();
}
// NavigationRule.java - 导航规则示例
public class NavigationRule implements Rule {
    @Override
    public boolean matches(Perception perception) {
        Integer position = (Integer) perception.getPerception("position");
        Integer target = (Integer) perception.getPerception("target");
        return position != null && target != null && position < target;
    }
    @Override
    public Decision getDecision() {
        Map<String, Object> params = new HashMap<>();
        params.put("direction", "forward");
        return new Decision("move", params, 0.9);
    }
}

行动执行系统

// ActionExecutor.java - 行动执行器
public class ActionExecutor {
    private Map<String, Action> actions = new HashMap<>();
    public void registerAction(String name, Action action) {
        actions.put(name, action);
    }
    public void execute(Decision decision) {
        String actionName = decision.getAction();
        Action action = actions.get(actionName);
        if (action != null) {
            action.execute(decision.getParameters());
        } else {
            throw new RuntimeException("Unknown action: " + actionName);
        }
    }
}
// Action.java - 行动接口
public interface Action {
    void execute(Map<String, Object> parameters);
}
// MoveAction.java - 移动行动
public class MoveAction implements Action {
    @Override
    public void execute(Map<String, Object> parameters) {
        String direction = (String) parameters.get("direction");
        System.out.println("执行移动操作，方向: " + direction);
        // 实际移动逻辑
        switch (direction) {
            case "forward":
                // 向前移动
                break;
            case "backward":
                // 向后移动
                break;
            case "left":
                // 向左移动
                break;
            case "right":
                // 向右移动
                break;
        }
    }
}

环境系统

// Environment.java - 环境类
public class Environment {
    private int temperature;
    private int humidity;
    private int agentPosition;
    private int target;
    private List<Integer> obstacles;
    private List<Agent> agents;
    public Environment() {
        this.temperature = 25;
        this.humidity = 60;
        this.agentPosition = 0;
        this.target = 10;
        this.obstacles = Arrays.asList(3, 5, 7);
        this.agents = new ArrayList<>();
    }
    public void updateState() {
        // 环境状态更新逻辑
        temperature = 25 + (int)(Math.random() * 10);
        humidity = 55 + (int)(Math.random() * 20);
    }
    public Perception getPerception() {
        Perception perception = new Perception();
        perception.addPerception("temperature", temperature);
        perception.addPerception("humidity", humidity);
        perception.addPerception("position", agentPosition);
        perception.addPerception("obstacles", obstacles);
        perception.addPerception("target", target);
        return perception;
    }
    public void registerAgent(Agent agent) {
        agents.add(agent);
    }
    public void updateAgentPosition(int newPosition) {
        // 检查障碍物
        if (obstacles.contains(newPosition)) {
            System.out.println("遇到障碍物，无法移动");
            return;
        }
        agentPosition = newPosition;
        // 检查是否到达目标
        if (agentPosition == target) {
            System.out.println("到达目标点！");
        }
    }
    // Getters
    public int getTemperature() { return temperature; }
    public int getHumidity() { return humidity; }
    public int getAgentPosition() { return agentPosition; }
    public int getTarget() { return target; }
    public List<Integer> getObstacles() { return obstacles; }
}

记忆系统

// Memory.java - 记忆类
public class Memory {
    private List<Experience> experiences;
    private Map<String, Object> knowledge;
    private int memorySize;
    public Memory() {
        this.experiences = new ArrayList<>();
        this.knowledge = new HashMap<>();
        this.memorySize = 100;
    }
    public void storeDecision(Decision decision) {
        if (experiences.size() >= memorySize) {
            experiences.remove(0); // 移除最旧的记忆
        }
        experiences.add(new Experience(decision));
    }
    public void storeKnowledge(String key, Object value) {
        knowledge.put(key, value);
    }
    public Object getKnowledge(String key) {
        return knowledge.get(key);
    }
    public List<Experience> getExperiences() {
        return Collections.unmodifiableList(experiences);
    }
    public void clear() {
        experiences.clear();
        knowledge.clear();
    }
}
// Experience.java - 经验类
public class Experience {
    private Decision decision;
    private long timestamp;
    public Experience(Decision decision) {
        this.decision = decision;
        this.timestamp = System.currentTimeMillis();
    }
    public Decision getDecision() { return decision; }
    public long getTimestamp() { return timestamp; }
}

具体智能体实现

// NavigationAgent.java - 导航智能体
public class NavigationAgent extends Agent {
    public NavigationAgent(String name) {
        super(name);
    }
    @Override
    public void initialize() {
        // 初始化传感器
        EnvironmentSensor sensor = new EnvironmentSensor();
        this.perception = sensor.getPerception();
        // 初始化决策器
        RuleBasedDecisionMaker decisionMaker = new RuleBasedDecisionMaker();
        // 添加决策规则
        decisionMaker.addRule(new NavigationRule());
        decisionMaker.addRule(new ObstacleAvoidanceRule());
        decisionMaker.addRule(new ArrivalRule());
        this.decisionMaker = decisionMaker;
        // 注册行动
        ActionExecutor executor = new ActionExecutor();
        executor.registerAction("move", new MoveAction());
        executor.registerAction("avoid", new AvoidAction());
        executor.registerAction("stop", new StopAction());
        this.actionExecutor = executor;
        System.out.println("智能体 " + name + " 初始化完成");
    }
    @Override
    public void run() {
        int maxIterations = 100;
        int currentIteration = 0;
        while (currentIteration < maxIterations) {
            // 感知环境
            perceive();
            // 做出决策
            decide();
            // 获取最近决策并执行
            List<Experience> experiences = memory.getExperiences();
            if (!experiences.isEmpty()) {
                Decision lastDecision = experiences.get(experiences.size() - 1).getDecision();
                act(lastDecision);
            }
            // 更新环境
            environment.updateState();
            // 检查是否完成任务
            Perception currentPerception = environment.getPerception();
            Integer position = (Integer) currentPerception.getPerception("position");
            Integer target = (Integer) currentPerception.getPerception("target");
            if (position != null && target != null && position.equals(target)) {
                System.out.println("智能体 " + name + " 成功到达目标！");
                break;
            }
            currentIteration++;
            // 模拟时间延迟
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }
    }
}
// ObstacleAvoidanceRule.java - 障碍物规避规则
public class ObstacleAvoidanceRule implements Rule {
    @Override
    public boolean matches(Perception perception) {
        Integer position = (Integer) perception.getPerception("position");
        List<Integer> obstacles = (List<Integer>) perception.getPerception("obstacles");
        return obstacles != null && position != null && obstacles.contains(position + 1);
    }
    @Override
    public Decision getDecision() {
        Map<String, Object> params = new HashMap<>();
        params.put("direction", "left");
        return new Decision("avoid", params, 0.8);
    }
}
// ArrivalRule.java - 到达规则
public class ArrivalRule implements Rule {
    @Override
    public boolean matches(Perception perception) {
        Integer position = (Integer) perception.getPerception("position");
        Integer target = (Integer) perception.getPerception("target");
        return position != null && target != null && position.equals(target);
    }
    @Override
    public Decision getDecision() {
        return new Decision("stop", Collections.emptyMap(), 1.0);
    }
}
// AvoidAction.java - 规避行动
public class AvoidAction implements Action {
    @Override
    public void execute(Map<String, Object> parameters) {
        System.out.println("执行规避行动");
        // 实际规避逻辑
    }
}
// StopAction.java - 停止行动
public class StopAction implements Action {
    @Override
    public void execute(Map<String, Object> parameters) {
        System.out.println("执行停止行动");
        // 停止逻辑
    }
}

主程序

// Main.java - 主程序
public class Main {
    public static void main(String[] args) {
        // 创建环境
        Environment environment = new Environment();
        // 创建智能体
        NavigationAgent agent = new NavigationAgent("NavigationAgent-1");
        // 关联环境和智能体
        agent.setEnvironment(environment);
        // 初始化智能体
        agent.initialize();
        // 启动智能体
        System.out.println("启动智能体系统...");
        agent.run();
        System.out.println("智能体系统运行结束");
    }
}

增强功能（可选）

// LearningAgent.java - 学习型智能体
public class LearningAgent extends Agent {
    private ReinforcementLearning learning;
    public LearningAgent(String name) {
        super(name);
        this.learning = new ReinforcementLearning();
    }
    @Override
    public void initialize() {
        // 初始化和学习配置
        learning.setLearningRate(0.01);
        learning.setDiscountFactor(0.9);
        learning.setExplorationRate(0.1);
    }
    @Override
    public void run() {
        // 学习和决策循环
        while (true) {
            perceive();
            decide();
            act(lastDecision);
            // 获取奖励
            double reward = getTaskReward();
            // 更新学习模型
            learning.update(reward);
            // 探索或利用
            if (Math.random() < learning.getExplorationRate()) {
                // 随机探索
                exploreAction();
            } else {
                // 利用已有知识
                exploitKnowledge();
            }
        }
    }
    private double getTaskReward() {
        // 计算任务奖励
        return 0.0;
    }
    private void exploreAction() {
        // 随机行动
    }
    private void exploitKnowledge() {
        // 从经验中学习行动
    }
}
// ReinforcementLearning.java - 强化学习类
public class ReinforcementLearning {
    private Map<String, Double> stateValues;
    private double learningRate;
    private double discountFactor;
    private double explorationRate;
    public void update(double reward) {
        // Q-Learning或SARSA算法更新
    }
    public Map<String, Double> getStateValues() {
        return stateValues;
    }
    // Getters and setters
    public double getLearningRate() { return learningRate; }
    public void setLearningRate(double learningRate) { this.learningRate = learningRate; }
    public double getDiscountFactor() { return discountFactor; }
    public void setDiscountFactor(double discountFactor) { this.discountFactor = discountFactor; }
    public double getExplorationRate() { return explorationRate; }
    public void setExplorationRate(double explorationRate) { this.explorationRate = explorationRate; }
}

运行说明

创建项目结构：
- 将所有类放入合适的包名（如 com.agentdemo）
- 确保所有Java文件正确编译

运行程序：

javac com/agentdemo/*.java
java com.agentdemo.Main

预期输出：

初始化智能体系统...
智能体 NavigationAgent-1 初始化完成
启动智能体系统...
遇到障碍物，无法移动
执行规避行动
到达目标点！
智能体 NavigationAgent-1 成功到达目标！
智能体系统运行结束

扩展建议

多智能体系统：扩展Agent类支持多智能体协作
深度学习集成：添加神经网络支持
实时通信：添加Agent间通信机制
并发处理：使用线程池并行处理多个Agent
可视化界面：添加JavaFX或Swing界面

这个案例提供了一个完整的智能体框架,您可以根据实际需求进行扩展和修改。

本文地址： https://bmjup.com/post/35452.html