写了大半天，终于做出来IO版的老农过河了，但是还有很多瑕疵，如：没处理IO异常，输入流没有关闭，判断输入格式神马的不严谨.......好多！求完善
下面是我的源码(感觉好繁琐，都写晕我了==！！)：

1. /*
   
2. 需求：做一个控制台版的老农过河小游戏
   
3. 规则：一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。
   
4. 当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。编程解决猫狗鱼过河问题。
   
5. 
   
6. */
   
7. import java.util.*;
   
8. import java.io.*;
   
9. class  LaoNongGuoHe
   
10. {
    
11.         ArrayList<String> left = null;//左岸
    
12.         ArrayList<String> right = null;//右岸
    
13.         int count = 1;//记录步数
    
14.         LaoNongGuoHe()
    
15.         {
    
16.                 /*
    
17.                 一初始化就有了左岸，右岸，
    
18.                 所有的动物和人开始都在左岸
    
19.                 */
    
20.                 left = new ArrayList<String>();
    
21.                 right = new ArrayList<String>();
    
22.                 left.add("person");
    
23.                 left.add("dog");
    
24.                 left.add("cat");
    
25.                 left.add("fish");
    
26.         }
    
27. 
    
28.         public static void main(String[] args) throws IOException
    
29.         {
    
30.                 System.out.println("《过河规则》：一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。"
    
31. +"当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。\n"
    
32. +"《输入格式》：person,animal---如：person,cat或person");
    
33.                 System.out.println("《初始化》左岸：[person,cat,fish,dog]\t右岸：[]");
    
34.                 new LaoNongGuoHe().keyboardInput();               
    
35.         }
    
36.         public void keyboardInput()throws IOException
    
37.         {
    
38.                 System.out.print("\n请输入过河的person和动物：");
    
39.                 BufferedReader bis = new BufferedReader(new InputStreamReader(System.in));
    
40. 
    
41.                 String line = bis.readLine();
    
42. 
    
43.                 duHe(line);
    
44.         }
    
45.         public void duHe(String str)throws IOException
    
46.         {
    
47.                 String[] s = str.split(",");//按格式输入的字符串，用”和“切割开
    
48. 
    
49.                 if (left.contains("person"))//人在左岸的情况
    
50.                 {
    
51.                         if (s.length!=2||!s[0].equals("person"))
    
52.                         {
    
53.                                 System.out.println("请按格式输入！person必须带一个动物过去");
    
54.                                 keyboardInput();
    
55.                         }
    
56.                         /*
    
57.                         移动人和动物
    
58.                         */
    
59.                         left.remove(s[0]);
    
60.                         left.remove(s[1]);
    
61. 
    
62.                         right.add(s[0]);
    
63.                         right.add(s[1]);
    
64.                         /*
    
65.                         如果打架则返回来，重新输入；否则此步渡河成功
    
66.                         */
    
67.                         if (this.daJia())
    
68.                         {
    
69.                                 right.remove(s[0]);
    
70.                                 right.remove(s[1]);
    
71.                                 left.add(s[0]);
    
72.                                 left.add(s[1]);
    
73.                                 keyboardInput();
    
74.                         }
    
75.                         else
    
76.                         {
    
77.                                 System.out.println("第"+count++ +"步：："+s[0]+" 把 "+s[1]+" 带到了右岸");
    
78.                                 System.out.println("左岸："+left+"\t右岸："+right);
    
79.                                 if (!this.chengGong())//如果渡河没完成就继续输入
    
80.                                         keyboardInput();
    
81.                                 else
    
82.                                         return;
    
83.                         }
    
84.                 }
    
85.                 else//人在右岸的情况
    
86.                 {
    
87.                         /*
    
88.                         这是只输入person的情况
    
89.                         */
    
90.                         if(s.length==1&&s[0].equals("person"))
    
91.                         {
    
92.                                 right.remove(s[0]);
    
93.                                 left.add(s[0]);
    
94.                                 if (this.daJia())
    
95.                                 {
    
96.                                         left.remove(s[0]);
    
97.                                         right.add(s[0]);
    
98.                                         keyboardInput();
    
99.                                 }
    
100.                                 else
     
101.                                 {
     
102.                                         System.out.println("第"+count++ +"步：："+s[0]+" 回到了左岸");
     
103.                                         System.out.println("左岸："+left+"\t右岸："+right);
     
104.                                         if (!this.chengGong())
     
105.                                                 keyboardInput();
     
106.                                         else
     
107.                                                 return;
     
108.                                 }
     
109.                         }
     
110.                         else if(s.length==2&&s[0].equals("person"))//这是输入person和一个动物的情况
     
111.                         {
     
112.                                 right.remove(s[0]);
     
113.                                 right.remove(s[1]);
     
114.                                 left.add(s[0]);
     
115.                                 left.add(s[1]);
     
116.                                 if (this.daJia())
     
117.                                 {
     
118.                                         left.remove(s[0]);
     
119.                                         left.remove(s[1]);
     
120.                                         right.add(s[0]);
     
121.                                         right.add(s[1]);
     
122.                                         keyboardInput();
     
123.                                 }
     
124.                                 else
     
125.                                 {
     
126.                                         System.out.println("第"+count++ +"步：："+s[0]+" 和 "+s[1]+" 回到了左岸");
     
127.                                         System.out.println("左岸："+left+"\t右岸："+right);
     
128.                                         if (!this.chengGong())
     
129.                                                 keyboardInput();
     
130.                                         else
     
131.                                                 return;
     
132.                                 }
     
133.                         }
     
134.                         else
     
135.                         {
     
136.                                 System.out.println("请按格式输入！");
     
137.                                 keyboardInput();
     
138.                         }
     
139.                 }
     
140.         }
     
141.         
     
142.         /*
     
143.         判断左岸和右岸是否发生打架，
     
144.         */
     
145.         public boolean daJia()
     
146.         {
     
147.                 //如果人不在左岸，左岸还包含dog和cat则打架，以下同理
     
148.                 if ((!left.contains("person")) && left.contains("dog") && left.contains("cat"))
     
149.                 {
     
150.                         System.out.println("左岸打架！狗咬猫！请重新输入");
     
151.                         return true;
     
152.                 }        
     
153.                 if ((!left.contains("person")) && left.contains("cat") && left.contains("fish"))
     
154.                 {
     
155.                         System.out.println("左岸打架！猫吃鱼！请重新输入");
     
156.                         return true;
     
157.                 }
     
158.                 if ((!right.contains("person")) && right.contains("dog") && right.contains("cat"))
     
159.                 {
     
160.                         System.out.println("右岸打架！狗咬猫！请重新输入");
     
161.                         return true;
     
162.                 }
     
163.                 if ((!right.contains("person")) && right.contains("cat") && right.contains("fish"))
     
164.                 {
     
165.                         System.out.println("右岸打架！猫吃鱼！请重新输入");
     
166.                         return true;
     
167.                 }
     
168. 
     
169.                 return false;
     
170.         }
     
171.         /*
     
172.         判断渡河是否成功，如果左岸空了代表成功
     
173.         */
     
174.         public boolean chengGong()
     
175.         {
     
176.                 if (left.isEmpty())
     
177.                 {
     
178.                         System.out.println("\n渡河成功！！！！");
     
179.                         return true;
     
180.                 }
     
181.                 else
     
182.                         return false;
     
183.         }
     
184. }
     

复制代码

中文我打小就看不懂，更别说编程了。

1. package exam;
   
2. //一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。编程解决猫狗鱼过河问题。
   
3. import java.util.ArrayList;  
   
4. import java.util.List;  
   
5. //先带猫过去，然后回来把狗带过，把猫带回来  
   
6. //再把鱼带过去，再回来带猫  
   
7. public class Test10
   
8. {  
   
9.     ArrayList<String> here = new ArrayList<String>();  
   
10.     ArrayList<String> there = new ArrayList<String>();  
    
11.     public boolean isSafty(List list)
    
12.     {  
    
13.         if (list.contains("dog") && list.contains("cat")  
    
14.                || list.contains("cat") && list.contains("fish"))
    
15.                    {  
    
16.            return false;         
    
17.            }  
    
18.         return true;  
    
19.    }  
    
20.   
    
21.     public Test10()
    
22.     {  
    
23.         here.add("Dog");  
    
24.         here.add("cat");  
    
25.        here.add("fish");  
    
26.     }  
    
27.     public void toTake()
    
28.     {  
    
29.        String str = here.get(0);  
    
30.       here.remove(str);  
    
31.       if (isSafty(here))
    
32.       {  
    
33.            System.out.println("1农夫带着" + str + "去往对岸，这边还剩下" + here + ",对岸有"  + there);  
    
34.                            toThere(str);      
    
35.       }
    
36.       else
    
37.       {  
    
38.            here.add(str);  
    
39.           toTake();  
    
40.       }  
    
41.     }   
    
42.     public void toThere(String s)
    
43.     {  
    
44.             if (isSafty(there))
    
45.             {  
    
46.                     there.add(s);  
    
47.             if(here.isEmpty())
    
48.             {  
    
49.                System.out.println("农夫，"+there+"都被你带过来了");  
    
50.                 return;  
    
51.             }  
    
52.            if(isSafty(there))
    
53.            {  
    
54.                 System.out.println("2农夫回到原点,对岸有" + there);  
    
55.                toTake();  
    
56.            }
    
57.                                 else
    
58.                                 {  
    
59.                 String temp=there.get(0);  
    
60.                there.remove(temp);  
    
61.                System.out.println("3农夫带着"+temp+"回到原点，这边有" + here + ",对岸有" + there);  
    
62.                 here.add(temp);  
    
63.                 toTake();  
    
64.                                 }  
    
65.         }
    
66.                                 else
    
67.                                 {  
    
68.                                 there.remove(s);  
    
69.                                 toTake();  
    
70.                         }  
    
71.     }  
    
72.     public static void main(String[] args)
    
73.     {  
    
74.        new Test10().toTake();  
    
75.     }  
    
76. }  

复制代码

厉害啊，我还没看到这里呢