推（搬）箱子，又名Sokoban，倉庫番等，是一款堪稱古玩級的電腦遊戲。提起它，筆者相信沒什麼人會感覺到陌生，更沒什麼生物會連聽都沒聽說過。它的發展歷史之久遠，甚至超越了俄羅斯方塊（1988年電腦遊戲化）。這款遊戲最初起源於日本，是個很難爭辯的事實（我知道有人反對，但筆者確實找不到什麼有力的反對證據）。他由日本人（哎……）今川巨集行在1981年創立遊戲規則，並於1982年經日本軟體公司Thinking Rabbit正式釋出。比較遺憾的是，早期的推箱子並沒有PC版，筆者在網路上搜索到的老版遊戲也大多為90年以前的Mac OS下程式。但說起真正令推箱子風靡於PC機的，卻該感謝我們的臺灣同胞李果兆先生。是他在1994年開發的倉庫世家，才真正令推箱子游戲在世界各地大受推崇；仔細說來，推箱子這款小遊戲之所以能有今時今日的聲望與地位，固然有今川巨集行的開創之功，但若說到貢獻最大，承前啟後的，則非中國臺灣的李果兆先生莫屬。推箱子游戲的規則非常簡單，就是用盡量少的推動或移動把所有箱子都推到目標點上。箱子只能推動而不能拉動；一次只能推動一個箱子。然而，儘管它的規則是很簡單的，但對於不同難度的關卡，所需要的腦力卻是截然不同的，有些關卡可能會花費您幾個小時、幾天甚至幾個月的時間，也正是這種簡單性和複雜性的結合，最終令推箱子類遊戲風靡全球！本回筆者在Blog中提供的，就是一款Java版推箱子游戲的簡單實現。筆者設定[上、下、左、右]為方向控制 ，[S]鍵為後退到上一步操作，[ESC]為重新開始當前關卡，點選鍵盤上對應關卡的數字鍵可以直接選關，需要注意的是筆者以HP限制了角色的移動次數，HP歸0則挑戰失敗。目前版本僅提供有5關，有需要者可參考同類遊戲自行擴充，遊戲原始碼在jar內。

遊戲截圖：

核心程式碼：

Sokoban.java

1. package org.loon.game.simple.sokoban.control;  
2. import java.awt.Color;  
3. import java.awt.Font;  
4. import java.awt.Graphics;  
5. import java.awt.Image;  
6. import java.awt.event.KeyEvent;  
7. import org.loon.game.simple.sokoban.GraphicsUtils;  
8. import org.loon.game.simple.sokoban.LSystem;  
9. import org.loon.game.simple.sokoban.SimpleControl;  
10. /** 
11.  * Copyright 2008 - 2009 
12.  *  
13.  * Licensed under the Apache License, Version 2.0 (the "License"); you may not 
14.  * use this file except in compliance with the License. You may obtain a copy of 
15.  * the License at 
16.  *  
17.  * http://www.apache.org/licenses/LICENSE-2.0
     
18.  *  
19.  * Unless required by applicable law or agreed to in writing, software 
20.  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 
21.  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 
22.  * License for the specific language governing permissions and limitations under 
23.  * the License. 
24.  *  
25.  * @project loonframework 
26.  * @author chenpeng 
27.  * @email <a title="" href="http://hi.baidu.com/ceponline" mce_href="http://hi.baidu.com/ceponline" target="_blank">ceponline</a>@yahoo.com.cn 
28.  * @version 0.1 
29.  */
30. publicclass Sokoban extends SimpleControl {  
31.     /** 
32.      *  
33.      */
34.     privatestaticfinallong serialVersionUID = 1L;  
35.     private Image backImage = GraphicsUtils.loadImage("image/back1.jpg");  
36.     private Image screenImage;  
37.     // 牆壁圖
38.     private Image floorImage[];  
39.     // 角色精靈
40.     private RpgSprite sprite;  
41.     // 窗體顯示圖
42.     private Graphics screen;  
43.     private String message = "按下 [Enter] 開始進行遊戲";  
44.     private String m_stageName[] = { "關卡1", "關卡2", "關卡3", "關卡4", "關卡5", "關卡6",  
45.             "關卡7" };  
46.     privateint CS = 32;  
47.     privateint maxX, maxY, comps;  
48.     privateint stageNo;  
49.     privateboolean complete[];  
50.     privateboolean boxMove[][];  
51.     privateint hp[];  
52.     privateint stageStates[][][];  
53.     privateint ons[][];  
54.     privateint role[];  
55.     privateint rolex[];  
56.     privateint roley[];  
57.     privateint mapx[];  
58.     privateint mapy[];  
59.     privateint sleep = 0;  
60.     privateboolean succeed = false;  
61.     private Stage stage;  
62.     public Sokoban(Stage stage) {  
63.         this.stage = stage;  
64.         this.floorImage = new Image[4];  
65.         this.sprite = new RpgSprite("image/role1.gif");  
66.         this.maxX = 16;  
67.         this.maxY = 13;  
68.         this.comps = 0;  
69.         this.complete = newboolean[stage.getMaxStageNo()];  
70.         this.boxMove = newboolean[stage.getMaxStageNo()][1500];  
71.         this.ons = newint[stage.getMaxStageNo()][1500];  
72.         this.hp = newint[stage.getMaxStageNo()];  
73.         this.stageStates = newint[stage.getMaxStageNo()][maxY][maxX];  
74.         this.role = newint[stage.getMaxStageNo()];  
75.         this.rolex = newint[stage.getMaxStageNo()];  
76.         this.roley = newint[stage.getMaxStageNo()];  
77.         this.mapx = newint[stage.getMaxStageNo()];  
78.         this.mapy = newint[stage.getMaxStageNo()];  
79.         for (int j = 0; j < 4; j++) {  
80.             floorImage[j] = GraphicsUtils.loadImage("image/back" + (j + 1)  
81.                     + ".gif");  
82.         }  
83.         this.screenImage = GraphicsUtils.createImage(CS * maxX + CS, CS  
84.                 * (maxY + 1) + 32, true);  
85.         this.screen = screenImage.getGraphics();  
86.         for (stageNo = 0; stageNo < stage.getMaxStageNo(); stageNo++) {  
87.             this.setupStage();  
88.         }  
89.         this.stageNo = -1;  
90.         // 開場介面
91.         this.openDraw();  
92.     }  
93.     /** 
94.      * 重新整理關卡 
95.      *  
96.      */
97.     publicsynchronizedvoid reset(int stageNo) {  
98.         this.stageNo = stageNo;  
99.         this.stage.getMode()[stageNo] = 1;  
100.         this.message = null;  
101.         // 設定關卡
102.         this.setupStage();  
103.         // 重繪背景
104.         this.background();  
105.         // 重繪遊戲螢幕
106.         this.drawScreen();  
107.     }  
108.     /** 
109.      * 繪製螢幕背景 
110.      *  
111.      */
112.     publicsynchronizedvoid background() {  
113.         screen.drawImage(backImage, 0, 0, null);  
114.         screen.setColor(Color.black);  
115.         screen.fillRect(0, LSystem.HEIGHT - 40, LSystem.WIDTH, 40);  
116.     }  
117.     /** 
118.      * 繪製螢幕影象 
119.      *  
120.      */
121.     publicsynchronizedvoid drawScreen() {  
122.         if (stageNo >= stage.getMaxStageNo()) {  
123.             stageNo = 0;  
124.         }  
125.         for (int i = 0; i < mapy[stageNo]; i++) {  
126.             for (int j = 0; j < mapx[stageNo];) {  
127.                 switch (stageStates[stageNo][i][j]) {  
128.                 case2:  
129.                 case3:  
130.                 case4:  
131.                 case5:  
132.                     screen.drawImage(floorImage[1], moveX(j), moveY(i), null);  
133.                 default:  
134.                     j++;  
135.                     break;  
136.                 }  
137.             }  
138.         }  
139.         for (int n = 0; n < mapy[stageNo]; n++) {  
140.             for (int l = 0; l < mapx[stageNo]; l++)  
141.                 switch (stageStates[stageNo][n][l]) {  
142.                 case1:  
143.                     screen.drawImage(floorImage[0], moveX(l), moveY(n), null);  
144.                     screen.setColor(new Color(32, 0, 0));  
145.                     screen.drawLine(moveX(l), moveY(n + 1), moveX(l) + CS - 1,  
146.                             moveY(n + 1));  
147.                     if (l == 0 || l > 0 && stageStates[stageNo][n][l - 1] != 1) {  
148.                         screen.setColor(new Color(160, 128, 96));  
149.                         screen.drawLine(moveX(l), moveY(n) + 1, moveX(l),  
150.                                 moveY(n) + CS - 2);  
151.                     }  
152.                     if (l == mapx[stageNo] - 1 || l < mapx[stageNo] - 1
153.                             && stageStates[stageNo][n][l + 1] != 1) {  
154.                         screen.setColor(new Color(72, 64, 64));  
155.                         screen.drawLine(moveX(l) + CS - 1, moveY(n), moveX(l)  
156.                                 + CS - 1, moveY(n) + CS - 2);  
157.                     }  
158.                     break;  
159.                 case2:  
160.                 case3:  
161.                 case4:  
162.                     switch (stageStates[stageNo][n][l]) {  
163.                     default:  
164.                         break;  
165.                     case2:  
166.                     case3:  
167.                         screen.drawImage(floorImage[3], moveX(l), moveY(n),  
168.                                 null);  
169.                         break;  
170.                     case4:  
171.                         break;  
172.                     }  
173.                     if (stageStates[stageNo][n][l] != 3)  
174.                         screen.drawImage(floorImage[2], moveX(l), moveY(n),  
175.                                 null);  
176.                     break;  
177.                 default:  
178.                     break;  
179.                 }  
180.         }  
181.         // System.out.println(role[stageNo]);
182.         screen.drawImage(sprite.getOnlyMove(role[stageNo]),  
183.                 moveX(rolex[stageNo]), moveY(roley[stageNo]), null);  
184.         if (stageStates[stageNo][roley[stageNo]][rolex[stageNo]] == 4) {  
185.             screen.drawImage(floorImage[2], moveX(rolex[stageNo]),  
186.                     moveY(roley[stageNo]), null);  
187.         }  
188.         setupDisplay();  
189.     }  
190.     /** 
191.      * 定位到實際的X座標 
192.      *  
193.      * @param i 
194.      * @return 
195.      */
196.     publicint moveX(int i) {  
197.         return (CS * ((maxX - mapx[stageNo]) + 1)) / 2 + CS * i;  
198.     }  
199.     /** 
200.      * 定位到實際的Y座標 
201.      *  
202.      * @param i 
203.      * @return 
204.      */
205.     publicint moveY(int i) {  
206.         return (CS * ((maxY - mapy[stageNo]) + 1)) / 2 + CS * i;  
207.     }  
208.     /** 
209.      * 執行操作 
210.      *  
211.      */
212.     publicsynchronizedvoid execute() {  
213.         boolean flag = true;  
214.         for (int i = 0; i < mapy[stageNo]; i++) {  
215.             for (int j = 0; j < mapx[stageNo]; j++) {  
216.                 if (stageStates[stageNo][i][j] == 4) {  
217.                     flag = false;  
218.                 }  
219.             }  
220.         }  
221.         if (flag) {  
222.             stage.getMode()[stageNo] = 3;  
223.             complete[stageNo] = true;  
224.         } elseif (hp[stageNo] == 0) {  
225.             stage.getMode()[stageNo] = 2;  
226.         }  
227.         comps = 0;  
228.         for (int n = 0; n < stage.getMaxStageNo(); n++) {  
229.             if (complete[n]) {  
230.                 comps++;  
231.             }  
232.         }  
233.     }  
234.     /** 
235.      * 鍵盤事件處理 
236.      */
237.     publicvoid keyPressed(KeyEvent e) {  
238.         if (e.getKeyCode() == 10 && stageNo == -1) {  
239.             // 開始關卡1
240.             reset(0);  
241.         } elseif (stageNo < 0) {  
242.             return;  
243.         }  
244.         // 選關（預設為最大支援7關，更多請自行設定）
245.         if (e.getKeyCode() == 97 || e.getKeyCode() == 49) {  
246.             stageNo = 0;  
247.         } elseif (e.getKeyCode() == 98 || e.getKeyCode() == 50) {  
248.             stageNo = 1;  
249.         } elseif (e.getKeyCode() == 99 || e.getKeyCode() == 51) {  
250.             stageNo = 2;  
251.         } elseif (e.getKeyCode() == 100 || e.getKeyCode() == 52) {  
252.             stageNo = 3;  
253.         } elseif (e.getKeyCode() == 101 || e.getKeyCode() == 53) {  
254.             stageNo = 4;  
255.         } elseif (e.getKeyCode() == 102 || e.getKeyCode() == 54) {  
256.             stageNo = 5;  
257.         } elseif (e.getKeyCode() == 103 || e.getKeyCode() == 55) {  
258.             stageNo = 6;  
259.             // ESC,重新開始
260.         } elseif (e.getKeyCode() == 27) {  
261.             reset(stageNo);  
262.         } elseif (stage.getMode()[stageNo] == 1) {  
263.             // 退步
264.             if (e.getKeyCode() == 83) {  
265.                 nextStep(-1);  
266.             }  
267.             // 移動角色
268.             elseif (e.getKeyCode() == 40) {  
269.                 nextStep(0);  
270.             } elseif (e.getKeyCode() == 37) {  
271.                 nextStep(1);  
272.             } elseif (e.getKeyCode() == 39) {  
273.                 nextStep(2);  
274.             } elseif (e.getKeyCode() == 38) {  
275.                 nextStep(3);  
276.             } else {  
277.                 return;  
278.             }  
279.         } else {  
280.             return;  
281.         }  
282.         // 繪製背景
283.         background();  
284.         // 繪製遊戲畫面
285.         drawScreen();  
286.     }  
287.     /** 
288.      * 切換動作 
289.      *  
290.      * @param i 
291.      */
292.     publicsynchronizedvoid nextStep(finalint i) {  
293.         boxMove[stageNo][hp[stageNo] - 1] = false;  
294.         switch (i) {  
295.         case0:  
296.             if (stageStates[stageNo][roley[stageNo] + 1][rolex[stageNo]] < 2) {  
297.                 return;  
298.             }  
299.             if (stageStates[stageNo][roley[stageNo] + 1][rolex[stageNo]] < 4) {  
300.                 if (stageStates[stageNo][roley[stageNo] + 2][rolex[stageNo]] < 4) {  
301.                     return;  
302.                 }  
303.                 stageStates[stageNo][roley[stageNo] + 1][rolex[stageNo]] += 2;  
304.                 stageStates[stageNo][roley[stageNo] + 2][rolex[stageNo]] -= 2;  
305.                 boxMove[stageNo][hp[stageNo] - 1] = true;  
306.             }  
307.             roley[stageNo]++;  
308.             break;  
309.         case1:  
310.             if (stageStates[stageNo][roley[stageNo]][rolex[stageNo] - 1] < 2) {  
311.                 return;  
312.             }  
313.             if (stageStates[stageNo][roley[stageNo]][rolex[stageNo] - 1] < 4) {  
314.                 if (stageStates[stageNo][roley[stageNo]][rolex[stageNo] - 2] < 4) {  
315.                     return;  
316.                 }  
317.                 stageStates[stageNo][roley[stageNo]][rolex[stageNo] - 1] += 2;  
318.                 stageStates[stageNo][roley[stageNo]][rolex[stageNo] - 2] -= 2;  
319.                 boxMove[stageNo][hp[stageNo] - 1] = true;  
320.             }  
321.             rolex[stageNo]--;  
322.             break;  
323.         case2:  
324.             if (stageStates[stageNo][roley[stageNo]][rolex[stageNo] + 1] < 2) {  
325.                 return;  
326.             }  
327.             if (stageStates[stageNo][roley[stageNo]][rolex[stageNo] + 1] < 4) {  
328.                 if (stageStates[stageNo][roley[stageNo]][rolex[stageNo] + 2] < 4) {  
329.                     return;  
330.                 }  
331.                 stageStates[stageNo][roley[stageNo]][rolex[stageNo] + 1] += 2;  
332.                 stageStates[stageNo][roley[stageNo]][rolex[stageNo] + 2] -= 2;  
333.                 boxMove[stageNo][hp[stageNo] - 1] = true;  
334.             }  
335.             rolex[stageNo]++;  
336.             break;  
337.         case3:  
338.             if (stageStates[stageNo][roley[stageNo] - 1][rolex[stageNo]] < 2) {  
339.                 return;  
340.             }  
341.             if (stageStates[stageNo][roley[stageNo] - 1][rolex[stageNo]] < 4) {  
342.                 if (stageStates[stageNo][roley[stageNo] - 2][rolex[stageNo]] < 4) {  
343.                     return;  
344.                 }  
345.                 stageStates[stageNo][roley[stageNo] - 1][rolex[stageNo]] += 2;  
346.                 stageStates[stageNo][roley[stageNo] - 2][rolex[stageNo]] -= 2;  
347.                 boxMove[stageNo][hp[stageNo] - 1] = true;  
348.             }  
349.             roley[stageNo]--;  
350.             break;  
351.         default:  
352.             if (hp[stageNo] == stage.getMaxHp()[stageNo]) {  
353.                 return;  
354.             }  
355.             switch (ons[stageNo][hp[stageNo]]) {  
356.             case0:  
357.                 if (boxMove[stageNo][hp[stageNo]]) {  
358.                     stageStates[stageNo][roley[stageNo] + 1][rolex[stageNo]] += 2;  
359.                     stageStates[stageNo][roley[stageNo]][rolex[stageNo]] -= 2;  
360.                 }  
361.                 roley[stageNo]--;  
362.                 break;  
363.             case1:  
364.                 if (boxMove[stageNo][hp[stageNo]]) {  
365.                     stageStates[stageNo][roley[stageNo]][rolex[stageNo] - 1] += 2;  
366.                     stageStates[stageNo][roley[stageNo]][rolex[stageNo]] -= 2;  
367.                 }  
368.                 rolex[stageNo]++;  
369.                 break;  
370.             case2:  
371.                 if (boxMove[stageNo][hp[stageNo]]) {  
372.                     stageStates[stageNo][roley[stageNo]][rolex[stageNo] + 1] += 2;  
373.                     stageStates[stageNo][roley[stageNo]][rolex[stageNo]] -= 2;  
374.                 }  
375.                 rolex[stageNo]--;  
376.                 break;  
377.             default:  
378.                 if (boxMove[stageNo][hp[stageNo]]) {  
379.                     stageStates[stageNo][roley[stageNo] - 1][rolex[stageNo]] += 2;  
380.                     stageStates[stageNo][roley[stageNo]][rolex[stageNo]] -= 2;  
381.                 }  
382.                 roley[stageNo]++;  
383.                 break;  
384.             }  
385.             break;  
386.         }  
387.         if (i != -1) {  
388.             hp[stageNo]--;  
389.             ons[stageNo][hp[stageNo]] = i;  
390.         }  
391.         role[stageNo] = ons[stageNo][hp[stageNo]];  
392.         if (i == -1) {  
393.             hp[stageNo]++;  
394.         }  
395.         execute();  
396.     }  
397.     /** 
398.      * 開場畫面 
399.      *  
400.      */
401.     publicsynchronizedvoid openDraw() {  
402.         background();  
403.         for (int i = 0; i < 5; i++) {  
404.             for (int j = 0; j < maxX + 1; j++) {  
405.                 screen.drawImage(floorImage[0], CS * j,  
406.                         (CS * i + CS / 2 * maxY) - CS * 2, null);  
407.             }  
408.         }  
409.         GraphicsUtils.setAntialias(screen, true);  
410.         String mes = "怪蜀黍傳說 - 勇者推魔王";  
411.         screen.setFont(new Font("華文新魏", 1, 35));  
412.         GraphicsUtils.drawStyleString(screen, mes, (CS * maxX - screen  
413.                 .getFontMetrics().stringWidth(mes)) / 2 + 13,  
414.                 (CS * maxY) / 2 + 25, Color.black, Color.orange);  
415.         mes = "Java版搬箱子游戲開發入門示例 - 0.1.0";  
416.         screen.setFont(new Font("華文新魏", 0, 30));  
417.         GraphicsUtils.drawStyleString(screen, mes, (CS * maxX - screen  
418.                 .getFontMetrics().stringWidth(mes)) / 2 + 13,  
419.                 (CS * (maxY + 2)) / 2 - 55, Color.black, Color.white);  
420.         GraphicsUtils.setAntialias(screen, false);  
421.         setupDisplay();  
422.     }  
423.     /** 
424.      * 繪圖介面實現 
425.      */
426.     publicsynchronizedvoid draw(Graphics g) {  
427.         g.drawImage(screenImage, 0, 0, null);  
428.         if (succeed) {  
429.             if (sleep == 100) {  
430.                 // 進入下一關
431.                 reset(++stageNo);  
432.                 succeed = false;  
433.                 sleep = 0;  
434.             }  
435.             sleep++;  
436.         }  
437.     }  
438.     /** 
439.      * 設定基本資料 
440.      *  
441.      */
442.     publicvoid setupStage() {  
443.         for (int i = 0; i < maxY; i++) {  
444.             for (int j = 0; j < maxX; j++) {  
445.                 stageStates[stageNo][i][j] = 0;  
446.             }  
447.         }  
448.         mapx[stageNo] = stage.getConf()[stageNo][0];  
449.         mapy[stageNo] = stage.getConf()[stageNo][1];  
450.         rolex[stageNo] = stage.getConf()[stageNo][2];  
451.         roley[stageNo] = stage.getConf()[stageNo][3];  
452.         for (int n = 0; n < mapy[stageNo]; n++) {  
453.             for (int l = 0; l < mapx[stageNo]; l++) {  
454.                 stageStates[stageNo][n][l] = stage.getMapData()[stageNo][n][l];  
455.             }  
456.         }  
457.         hp[stageNo] = stage.getMaxHp()[stageNo];  
458.         role[stageNo] = 0;  
459.         for (int i1 = 0; i1 < stage.getMaxHp()[stageNo]; i1++) {  
460.             ons[stageNo][i1] = 0;  
461.         }  
462.         for (int j1 = 0; j1 < stage.getMaxHp()[stageNo]; j1++) {  
463.             boxMove[stageNo][j1] = false;  
464.         }  
465.     }  
466.     /** 
467.      * 設定顯示 
468.      *  
469.      */
470.     publicvoid setupDisplay() {  
471.         if (message == 

     相關推薦

     Java版推箱子（搬箱子）遊戲開發入門示例及原始碼

                     推（搬）箱子，又名Sokoban，倉庫番等，是一款堪稱古玩級的電腦遊戲。提起它，筆者相信沒什麼人會感覺到陌生，更沒什麼生物會連聽都沒聽說過。它的發展歷史之久遠，甚至超越了俄羅斯方塊（1988年電腦遊戲化）。這款遊戲最初起源於日本，是個很難爭辯的事實（我知道有人反對，但筆者確實找

     cocos2d-x實現一個PopStar（消滅星星）遊戲的邏輯分析及原始碼

     前言 說起PopStar這個遊戲，或許很多人都不知道是啥，但是如果說起消滅星星的話，可能就會有很多人恍然大悟，原來是它。那麼，這個消滅星星長得什麼樣子呢？我們用一張圖來看看: emmm，是的，具體來說，長得就是這樣，我們通過點選圖片上某一個顏色的星星塊，如果，這個顏色塊周圍存在和他相

     【劍指offer】Java版代碼（完整版）

     從尾到頭打印鏈表 .net 字符串 刪除 ron 代碼下載 逆序 鏈表 撲克 原文地址：https://blog.csdn.net/baiye_xing/article/details/78428561 一、引言 《劍指offer》可謂是程序猿面試的神書了，在面試中幫了我很

     Java版快排（遞迴）

     public class Test { private static int Partition(int[] arr, int start, int end) { int key = arr[start]; while (start < end) {

     資料結構Java版 多項式相加（簽到題）

     題目描述 一條單鏈表可以表示一個一元多項式，每個節點包含三個域：指數、係數和後繼節點（指標或引用）。 表示多項式3X4-6X2+5X-10的單鏈表如圖所示。給定兩個多項式，實現兩個多項式相加演算法。   輸入 第一行輸入包含兩個整數m,n 後續為m行和n行資料

     遊戲開發入門（十二）遊戲開發全總結

     通過遊戲開發入門系列的學習，是不是對遊戲開發有了一個比較清晰的認識？ 在最後一篇裡面，博主試著概括性的對遊戲開發做一個總結，歡迎各位提出意見來完善這篇部落格~ 遊戲模組總結： 遊戲邏輯模組系統：各種武器，狀態，技能，揹包，戰鬥等邏輯系統 動畫模組系

     Java版AVG遊戲開發入門示例[3]——指令碼引擎的製作及應用

      根據wikipedia的解釋：指令碼語言（Script language，scripting language，scripting programming language），是為了縮短傳統的編寫-編譯-連結-執行（edit-compile-link-run）過程而建立

     1254 】推箱子 （雙bfs）

     題幹： 推箱子是一個很經典的遊戲.今天我們來玩一個簡單版本.在一個M*N的房間裡有一個箱子和一個搬運工,搬運工的工作就是把箱子推到指定的位置,注意,搬運工只能推箱子而不能拉箱子,因此如果箱子被推到一個角上(如圖2)那麼箱子就不能再被移動了,如果箱子被推到一面牆上,那麼箱子只

     hdu1254 推箱子（bfs+bfs）

     推箱子 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 6386 Accepted Submission(s): 18

     java版雲筆記（二）

     blank app mar emc mt4 雲筆記 shu cmm ndt qC50f曬06渙hx厙咆2http://www.docin.com/nwghs11486 評z謁64a癡嘶06棵自暮0http://jz.docin.com/zdng396 5crl71也

     Effective Java 第二版 中文版 筆記（8-12）避免使用終結方法

     我對此部分沒有什麼興趣，因為誰會閒的沒事覆蓋java自身的方法。 八、覆蓋equals ; 這裡最重要的就是遵守約定； 自反性（reflexive）—>x != null && x.equals(x) == true 對稱性（symmetric）

     Effective Java 第二版 中文版 筆記（十八）介面優於抽象類

     這裡主要就是介面和抽象類的區別 ： 使用一個例子直接進行說明； 理解：抽象類：抽象類是對一種事物的抽象，即對類抽象           介面：是對行為進行抽象； 從網上看了個例子感覺不錯： interface Alram { void alarm(); }

     Effective Java 第二版 中文版 筆記（二十三）請不要在新程式碼中使用原生態型別

     泛型：宣告一個或多個型別的引數的類和介面； 原生態型別如 List:不帶任何型別引數的泛型名稱； public class Primordial{ //原生態例子 public void primordialTest(){ List&l

     Java記憶體回收知識（讀書筆記）--深入理解Java虛擬機器——JVM高階特性與最佳實踐(第2版)2.2~2.3

     1.哪些地方的記憶體要回收？ Java程式運時的記憶體包括以下幾部分：程式計數器，Java虛擬機器棧，本地方法棧，Java堆，方法區（執行時常量池是方法區的一部分）。 程式計數器，Java虛擬機器棧，本地方法棧是隨執行緒而生，隨執行緒而亡，它們的分配的記憶體大小已知，因此不

     Java版運算元彙總（包括filter，collect，take，first,sample等）【Java純程式碼】

     package com.bjsxt; import java.util.List; import org.apache.spark.SparkConf; import org.apache.spark.api.java.JavaRDD; import org.apache

     java核心技術 卷一 第十版 中文版勘誤（更新ing）

     本文主要是閱讀java核心技術 卷一 第十版時發現的錯誤，整理下來。本人小白，如果整理有誤，還望指出。如果有的錯誤沒有指出，還望補充。謝謝！ 官方勘誤表可以參考這個英文官方勘誤表 第34頁最下方 警告部分 換行符的Unicode值為\u000a,把\u00A

     我在生產專案裡是如何使用Redis釋出訂閱的？（二）Java版程式碼實現（含原始碼）

     上篇文章講了在實際專案裡的哪些業務場景用到Redis釋出訂閱，這篇文章就講一下，在Java中如何實現的。   圖解程式碼結構 釋出訂閱的理論以及使用場景大家都已經有了大致瞭解了，但是怎麼用程式碼實現釋出訂閱呢？在這裡給大家分享一下實現方式。   我們以上篇文章的第三種使用場景為例

     java基本類型（數值範圍）：浮點的底層表示定義，float計算快一些

     方法 -1 att ieee754 符號位 無法 字符類 數值計算 小數 Java八種基本類型: 六種數字類型（四個整數型，兩個浮點型）， 一種字符類型， 一種布爾型。 詳細例如以下 1、整數：包含int,short,byte,long

     Java基礎部分回顧（為自己）

     .cn logs -1 繼續 分享 9.png 沒有 理解 開始 最近，學到集合框架。感覺有些蒙圈兒。知道這一塊很重要很重要，不敢疏忽。自學遇到的攔路虎，想著是不是前面的基礎知道還沒有夯實，對一些概念沒有真正的理解到位呢？！所以，停下來。開始找一些視頻，做一下回顧。 再次鞏

     JAVA 8 新特性 （值得學習）

     java 8 新特性JAVA 8 已經出現好長時間了，大的互聯網公司很多都已經使用了，甚至很多知名互聯網公司踩過很多坑，也有一些大牛分享出了他們的實戰經驗。去很多知名的互聯網公司經常會被面試官問，你了解java 8嗎？你知道它的一些新特性嗎？好像似乎成了一面面試官必問的一道題目。這篇博文，只是簡答的介紹了一下