用java中的抽象类与接口实现农夫过河问题

农夫过河问题是一个经典的AI问题，可以用Java中的抽象类和接口来实现。

首先，我们可以定义一个“物品”接口，表示可以被运输的物品：

public interface Item {
    String getName();
    boolean canTransport();
}

其中，`getName()`方法用于获取物品名称，`canTransport()`方法用于判断该物品是否可以被运输。

接下来，我们可以定义一个“人”抽象类，表示可以执行运输操作的人：

public abstract class Person {
    private String name;
    private List<Item> items;
    
    public Person(String name) {
        this.name = name;
        this.items = new ArrayList<>();
    }
    
    public String getName() {
        return name;
    }
    
    public void addItem(Item item) {
        items.add(item);
    }
    
    public void removeItem(Item item) {
        items.remove(item);
    }
    
    public List<Item> getItems() {
        return items;
    }
    
    public abstract boolean canTransport();
}

其中，`name`字段表示人的名字，`items`字段表示人当前所持有的物品列表。`addItem()`和`removeItem()`方法用于添加和移除物品，`getItems()`方法用于获取当前所持有的物品列表。`canTransport()`方法是一个抽象方法，用于判断该人是否有能力进行运输操作。

接下来，我们可以定义一个“农夫”类，继承自“人”抽象类：

public class Farmer extends Person {
    public Farmer() {
        super("农夫");
    }
    
    @Override
    public boolean canTransport() {
        return true;
    }
}

其中，`canTransport()`方法返回`true`，表示农夫可以进行运输操作。

接下来，我们可以定义一个“船”类，表示运输物品的载体：

public class Boat {
    private int capacity;
    private List<Item> items;
    
    public Boat(int capacity) {
        this.capacity = capacity;
        this.items = new ArrayList<>();
    }
    
    public boolean canTransport(Item item) {
        return items.size() < capacity && item.canTransport();
    }
    
    public void addItem(Item item) {
        if (canTransport(item)) {
            items.add(item);
        }
    }
    
    public void removeItem(Item item) {
        items.remove(item);
    }
    
    public List<Item> getItems() {
        return items;
    }
    
    public void clear() {
        items.clear();
    }
}

其中，`capacity`字段表示船的运输能力，`items`字段表示船当前所装载的物品列表。`canTransport()`方法用于判断物品是否可以被运输，`addItem()`和`removeItem()`方法用于添加和移除物品，`getItems()`方法用于获取当前所装载的物品列表，`clear()`方法用于清空船上的物品。

最后，我们可以定义一个“农夫过河”类，用于实现整个过程的控制：

public class FarmerCrossRiver {
    private Farmer farmer;
    private List<Item> leftBank;
    private List<Item> rightBank;
    private Boat boat;
    
    public FarmerCrossRiver() {
        this.farmer = new Farmer();
        this.leftBank = new ArrayList<>();
        this.rightBank = new ArrayList<>();
        this.boat = new Boat(1);
        
        // 初始化左岸物品
        leftBank.add(new Item() {
            @Override
            public String getName() {
                return "狼";
            }

            @Override
            public boolean canTransport() {
                return false;
            }
        });
        leftBank.add(new Item() {
            @Override
            public String getName() {
                return "羊";
            }

            @Override
            public boolean canTransport() {
                return true;
            }
        });
        leftBank.add(new Item() {
            @Override
            public String getName() {
                return "菜";
            }

            @Override
            public boolean canTransport() {
                return true;
            }
        });
    }
    
    public void start() {
        System.out.println("开始过河");
        System.out.println("左岸: " + leftBank);
        System.out.println("船上: " + boat.getItems());
        System.out.println("右岸: " + rightBank);
        System.out.println();
        
        while (!isFinished()) {
            // 农夫运输物品
            for (Item item : farmer.getItems()) {
                if (boat.canTransport(item)) {
                    farmer.removeItem(item);
                    boat.addItem(item);
                    System.out.println(farmer.getName() + "将" + item.getName() + "运到了船上");
                }
            }
            
            // 船运输物品
            if (boat.getItems().size() > 0) {
                System.out.println("船开始运输");
                boat.getItems().forEach(item -> {
                    if (boat.getItems().contains(item)) {
                        boat.removeItem(item);
                        if (leftBank.contains(item)) {
                            leftBank.remove(item);
                            rightBank.add(item);
                            System.out.println("船将" + item.getName() + "从左岸运到了右岸");
                        } else {
                            rightBank.remove(item);
                            leftBank.add(item);
                            System.out.println("船将" + item.getName() + "从右岸运到了左岸");
                        }
                    }
                });
            }
            
            // 农夫运回船上
            for (Item item : farmer.getItems()) {
                if (boat.canTransport(item)) {
                    farmer.removeItem(item);
                    boat.addItem(item);
                    System.out.println(farmer.getName() + "将" + item.getName() + "运回了船上");
                }
            }
            
            // 船运回农夫
            if (boat.getItems().size() > 0) {
                System.out.println("船开始运回农夫");
                boat.getItems().forEach(item -> {
                    if (boat.getItems().contains(item)) {
                        boat.removeItem(item);
                        farmer.addItem(item);
                        System.out.println("船将" + item.getName() + "运回了" + farmer.getName());
                    }
                });
            }
            
            System.out.println("左岸: " + leftBank);
            System.out.println("船上: " + boat.getItems());
            System.out.println("右岸: " + rightBank);
            System.out.println();
        }
        
        System.out.println("过河完成");
    }
    
    private boolean isFinished() {
        return rightBank.containsAll(leftBank) && rightBank.size() == 3;
    }
}

其中，`isFinished()`方法用于判断是否完成过河，`start()`方法用于启动整个过程。

现在，我们可以在`main()`方法中启动过河过程：

public static void main(String[] args) {
    FarmerCrossRiver game = new FarmerCrossRiver();
    game.start();
}

运行程序，即可看到过河过程的输出结果。