MVC
MVC含義
一種軟件構(gòu)架，簡單的說就是在做軟件的時候，可以將軟件分為不同的模塊，不同的模塊實(shí)現(xiàn)了不同功能。
MVC 組成部分
Model 模型
View 視圖
Controller 控制器
MVC就是三種組成部分的縮寫。
MVC 不同模塊的功能
Model（模型層） 程序員編寫程序應(yīng)用的功能，數(shù)據(jù)庫設(shè)計(jì)等。屬于后臺操作。
View （視圖層） 前臺界面，也就是用戶可以看到的圖形見面，一般在web中是一些*.jsp或*.html。
Controller（控制器） 處理前臺和后臺請求。
MVC 優(yōu)點(diǎn)
采用MVC的優(yōu)點(diǎn)太多了，說再多不如你在真正的項(xiàng)目中自己體會，在這里不做太多解釋。
MVC 包結(jié)構(gòu)
雖然，這并不能說明所有MVC框架所有的包模式，不過我覺得新手對于這個包結(jié)構(gòu)還是比較容易接受的。
DAO 模式
在DAO層，最主要的作用是：完成數(shù)據(jù)的操作。在這層，你可以完成對任何表的數(shù)據(jù)操作，不過個人認(rèn)為DAO層最大的作用是簡單了編程人員的編程邏輯，簡單的說就是將一個大的問題，分成了幾個比較小的問題，這樣不管在測試還是在維護(hù)都起著很大的方便。
Factory 工廠
Factory 工廠在這里也可以說成是DAO的工廠，這里Factory僅僅產(chǎn)生了DAO。那么Factory工廠模式有什么好處呢？
在MVC中的Factory 層，你完全可以把它想象成現(xiàn)實(shí)中的工廠，生產(chǎn)某些東西，如果在程序中使用工廠模式，你可以簡化編程代碼，相當(dāng)與現(xiàn)實(shí)中你需要某個產(chǎn)品不需要自己去生產(chǎn)，完全可以去工廠“拿”一個，這樣程序的編程更加符合現(xiàn)實(shí)中的邏輯。
MVC 總結(jié)
本節(jié)，我僅僅是將MVC的編輯思想簡單的介紹了一下，我沒有加入一些詳細(xì)的例子，因?yàn)槲矣X得你在接觸MVC的時候，最好先了解MVC的編程思想，如果你要了解MVC的編程思想之后，你再接觸MVC的編程時，你就會覺得特別簡單。
最后，希望我這篇文章可以讓大家簡單的了解MVC的編程模式。
posted @
2011-01-25 09:30 tovep 閱讀(2197) |
評論 (9) |
編輯 收藏
摘要: ForEach小結(jié)
<c:forEach>標(biāo)簽具有以下一些屬性：
var：迭代參數(shù)的名稱。在迭代體中可以使用...
閱讀全文
posted @
2011-01-24 08:37 tovep 閱讀(2370) |
評論 (0) |
編輯 收藏通過以下Servlet程序和web.xml來說明web.xml的配置以及過程
創(chuàng)建一個Login的HTML文件
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>login.html</title>
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="this is my page">
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body>
<form action="
test1" method="
post">
<table border="0" width="379" height="79">
<tr>
<td>帳號:</td>
<td><input type="text" name="username"></td>
</tr>
<tr>
<td>密碼:</td>
<td><input type="password" name="password"></td>
</tr>
<tr>
<td colspan="5" align="center"><input type="submit" value="登錄"></td>
</tr>
</table>
</form>
</body>
</html>
以上HTML標(biāo)簽中要說明的是：
<form>標(biāo)簽中的
action="test_Web_xml" 和 method="post" 分別定義了Html將登陸的信息發(fā)送給了誰，以及發(fā)送信息的方法！
創(chuàng)建一個Servlet程序
public class LoginServlet extends HttpServlet{
public void
doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String username = null;
username = request.getParameter("username");
String password = null;
password = request.getParameter("password");
if(username.equals("username")&&password.equals("password")){
request.getRequestDispatcher("成功登陸！！！").forward(request,response);
}else{
request.getRequestDispatcher("登陸失敗！！！").forward(request,response);
}
}
}
web.xml配置
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<servlet>
<servlet-name>
Login
</servlet-name>
<servlet-class>
com.rise.LoginServlet
</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>
Login
</servlet-name>
<url-pattern>
/test1
</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
我理解web.xml的作用就是將頁面和后臺程序正確連接！！！
通過一張圖片說明我理解的web.xml的作用
以上的內(nèi)容是我自己對web.xml的理解，我覺得很簡單，但真正寫程序的時候部署程序是非常復(fù)雜的！
posted @
2010-12-11 20:43 tovep 閱讀(6313) |
評論 (2) |
編輯 收藏什么是JDBC
JDBC是由一組Java語言編寫的類和接口組成，用來處理關(guān)系數(shù)據(jù)庫！利用JDBC的API，可用Java語法去訪問各種各樣的SQL數(shù)據(jù)庫。
個人認(rèn)為：
把JDBC當(dāng)做是一門連接Java程序連接數(shù)據(jù)庫的技術(shù)不如把JDBC當(dāng)做連接程序和數(shù)據(jù)庫的橋梁。
以下我要寫的例子是用純Java的Driver來連接數(shù)據(jù)庫的方式。連接的數(shù)據(jù)庫是mysql。
JDBC編程步驟
1.加載數(shù)據(jù)庫驅(qū)動(jar文件)
//需要下載一個數(shù)據(jù)庫的jar包，并導(dǎo)入相應(yīng)的JDBC項(xiàng)目中，創(chuàng)建路徑！
Class.forName("com.mysql.jdbc.Driver");
2.獲得數(shù)據(jù)庫連接
DriverManager.getConnection("jdbc:mysql://Database_IP:3306/DATABASE","DATAROOT","PASSWORD");//返回Connection————獲得數(shù)據(jù)庫連接
3.創(chuàng)建語句
String sql = "SQL_TORUNNING";
向DATABASE發(fā)送一個執(zhí)行語句
Statement stmt = conn.createStatement();//創(chuàng)建一個 Statement 對象來將 SQL 語句發(fā)送到數(shù)據(jù)庫.
Statement—————SQL_RUNNING!!!
4.執(zhí)行查詢
ResultSet rs = Statement.executeQuery(SQL_RUNNING);//執(zhí)行SQL_RUNNING命令，返回ResultSet
//如果執(zhí)行的數(shù)據(jù)庫語句不是對數(shù)據(jù)庫中的內(nèi)容進(jìn)行修改的話，則用 Statement.executeQuery()
//如果執(zhí)行的數(shù)據(jù)庫語句是修改數(shù)據(jù)庫中的內(nèi)容進(jìn)行修改的話，則用 Statement.executeUpdate()
//當(dāng)然他們返回值的類型也不同！
//根據(jù)命令的不同Statement的方法也不同
創(chuàng)建一個表
Statement.execute(create a table)
增刪改查Insert、update、delete...
Statement.executeUpdate()
查詢語句Select
Statement.executeQuery(Select);
5.遍歷結(jié)果集
while(ResultSet.next()){
ResultSet.getInt(int);
ResultSet.getString(int);
......
}
6.關(guān)閉數(shù)據(jù)庫連接
Connection.close();
步驟分析
(圖一)
1.加載數(shù)據(jù)庫驅(qū)動
我們來看圖一，工廠和幾個農(nóng)村之間有一條河，不能夠直接進(jìn)行溝通，工廠就相當(dāng)于一個Java程序，而幾個農(nóng)村就相當(dāng)于不同的數(shù)據(jù)庫；
工廠為B村生產(chǎn)一些材料，但是生產(chǎn)出來之后并不能直接交給B村，然后工廠的廠長就想在工廠和B村之間架設(shè)一座橋梁來運(yùn)送生產(chǎn)出來的材料——我們大可把數(shù)據(jù)庫驅(qū)動加載當(dāng)做這個架設(shè)橋梁的想法。
在程序中我們要怎么做呢？
在加載數(shù)據(jù)庫驅(qū)動的時候，必須要將相應(yīng)的mysql-connector-java-5.0.4-bin.jar包，然后將jar包導(dǎo)入相應(yīng)的項(xiàng)目中如下圖
在mysql-connector-java-5.0.4-bin.jar右擊建立路徑，就相當(dāng)于import的過程——我不確定這么說對不對，但我是這么理解的。
建立路徑后，你的項(xiàng)目將出現(xiàn)一個新的文件，如下圖
這樣的話，你就可以順利加載數(shù)據(jù)庫驅(qū)動，否則當(dāng)你在運(yùn)行的時候會出現(xiàn)找不到Driver.class的異常，也就是無法加載數(shù)據(jù)庫驅(qū)動。
Class.forName("com.mysql.jdbc.Driver");
2.獲得數(shù)據(jù)庫連接
既然廠長有想法和B村之間架設(shè)一座橋梁，那就要和B村商量一下啊！然后，廠長就要去河的對岸，那條河呢？就是在工廠和B村之間的那條河(這條河就相當(dāng)于Database_IP),然后去找B村的村長(在這里要明白是B村的村長不是A村的，所以不能找錯了！！！)，找到B村村長，“我要在工廠和B村之間建設(shè)一座橋，來運(yùn)輸我們的東西”，下一步談的當(dāng)然是條件了，工廠老板說“我要B村出資90%，剩下的由工廠出！！”村長當(dāng)然不干了，這橋當(dāng)然也就沒法建設(shè)了！！！所以只有當(dāng)兩者都滿意的情況下才可以建設(shè)橋梁(比如，各處50%)其實(shí)談條件的過程就相當(dāng)于驗(yàn)證數(shù)據(jù)庫的"DATAROOT"和"PASSWORD"！！！只有兩者都正確的情況下才可以進(jìn)行下一步的計(jì)劃——也就是建設(shè)橋梁！！！
在程序中的過程如下:
Connection conn = null;
conn = DriverManager.getConnection("jdbc:mysql://Database_IP:3306/DATABASE","DATAROOT","PASSWORD");
//返回Connection————獲得數(shù)據(jù)庫連接
3.創(chuàng)建語句
橋已經(jīng)建好了，然后工廠要準(zhǔn)備一些卡車來運(yùn)輸生產(chǎn)的貨物，然后農(nóng)村需要根據(jù)不同的貨物來處理這些貨物，有些貨物直接卸在B村就可以了，但有些貨物卸在B村之后，B村要做一些處理然后運(yùn)回工廠！！！
這個過程在程序是怎么體現(xiàn)的呢？
String sql = "SQL_TORUNNING";
向DATABASE發(fā)送一個執(zhí)行語句
Statement stmt = conn.createStatement();//創(chuàng)建一個 Statement 對象來將 SQL 語句發(fā)送到數(shù)據(jù)庫.
Statement—————SQL_RUNNING!!!
4.處理數(shù)據(jù)庫發(fā)送來的消息
如果工廠運(yùn)輸?shù)紹村的貨物，只要B村的村長給工廠開一張條就行了；但也會有一些貨物需要運(yùn)回工廠！！
在程序中：
ResultSet rs = Statement.executeQuery(SQL_RUNNING);//執(zhí)行SQL_RUNNING命令，返回ResultSet
//如果執(zhí)行的數(shù)據(jù)庫語句不是對數(shù)據(jù)庫中的內(nèi)容進(jìn)行修改的話，則用 Statement.executeQuery()——需要返回一些貨物
//如果執(zhí)行的數(shù)據(jù)庫語句是修改數(shù)據(jù)庫中的內(nèi)容進(jìn)行修改的話，則用 Statement.executeUpdate()——開張條就行了
//當(dāng)然他們返回值的類型也不同！
//根據(jù)命令的不同Statement的方法也不同
創(chuàng)建一個表
Statement.execute(create a table)
增刪改查Insert、update、delete...
Statement.executeUpdate()
查詢語句Select
Statement.executeQuery(Select);
5.處理數(shù)據(jù)庫傳回的內(nèi)容
這個過程由工廠完成，如果是返回的一些貨物的話，工廠要做一些處理。
處理的過程：
while(ResultSet.next()){
ResultSet.getInt(int);
ResultSet.getString(int);
......
}
6.關(guān)閉數(shù)據(jù)庫
這樣的話，工廠和B村的交易就完成，在現(xiàn)實(shí)世界中工廠和B村之間的橋梁不會被拆除，因?yàn)榻ㄒ蛔鶚虻拇鷥r(jià)很大，但在程序和數(shù)據(jù)庫之間架設(shè)一座橋梁簡直太簡單了，所以在這里我們要把這座橋梁拆除。
Connection.close();
簡單的舉了一個例子來說明數(shù)據(jù)庫和程序之間是怎么連接的，望對大家有所幫助。
posted @
2010-12-09 18:37 tovep 閱讀(1675) |
評論 (1) |
編輯 收藏
SQL語言是操作數(shù)據(jù)庫的基礎(chǔ)語言，對于不同的數(shù)據(jù)庫語言產(chǎn)品，SQL語言大多是通用的，本篇博客旨在介紹一些最常用的SQL語句。希望對大家能有所幫助。
注：
本文中的紅色字體黃色背景的內(nèi)容為SQL語句！！
笨人也是菜鳥，如果我寫的有錯誤，大家一定要指出來啊！！！好了，廢話不說了，切入正題：
首先，使用
status查看MySQL當(dāng)前的信息
1.使用
show databases;語句查看當(dāng)前數(shù)據(jù)庫：
2.使用
create database DATABASE_NAME;語句來創(chuàng)建DATABASE_NAME數(shù)據(jù)庫
這樣，我們創(chuàng)建好了一個名字為database_name的數(shù)據(jù)庫。
注：數(shù)據(jù)庫語句對字母大小寫不敏感！
3.使用
use DATABASE_NAME;切換到使用DATABASE_NAME數(shù)據(jù)庫模式。
4.在database_name數(shù)據(jù)庫創(chuàng)建一個表：
create table if not exists table_name -- 如果表table_name不存在則創(chuàng)建
(id int primary key auto_increment, -- 創(chuàng)建int類型為主鍵，且自動增長
name varchar(200) not null, -- 創(chuàng)建字符類型的列，最大長度是200字節(jié)
age int(3), -- 創(chuàng)建int類型，長度為3個字節(jié)
sex varchar(2), -- 創(chuàng)建字符類型，長度是2個字節(jié)
salary float(11,2), -- 創(chuàng)建float類型的列，長度為2個字節(jié)
address varchar(50), -- 創(chuàng)建字符類型，長度為50個字節(jié)
birthday date -- 創(chuàng)建日期類型
);
這樣就創(chuàng)建好了一張表，可以用 describe 或則 desc來查看表的結(jié)構(gòu)
describe table_name;
desc table_name;
這樣數(shù)據(jù)就創(chuàng)建好了一張表，我們可以用
show tables; 來查看數(shù)據(jù)庫中所有表
然后，我們就可以看見我們創(chuàng)建的表
====================================================================================
數(shù)據(jù)庫最具核心的用法——對數(shù)據(jù)庫表的數(shù)據(jù)的
增刪改查。
向表中增加數(shù)據(jù)(要了加入表的結(jié)構(gòu)，看哪項(xiàng)可以為空)
insert table_name (name,age,sex) values ('tovep',22,'男');
向表中加入數(shù)據(jù)的時候，并不是要把所有的信息都要寫近期，只要表中結(jié)構(gòu)設(shè)置為可以為空的都
可以不寫！！
id不用寫，因?yàn)樗亲詣釉鲩L的！
要想查看表中的內(nèi)容，可以用select語句———為了說明下面的情況，我加入了多條信息
select * from table_name; -- 將table_name表中的所有數(shù)據(jù)都打印出來
select name from table_name; --查看所有人的名字
select * from table_name where id<5; --將表中id小于100的都打印出來
在使用select 語句查詢的時，常常用到別名
select t.name,t.id,t.age from table_name as t;
select 語句中的where表示查詢的條件
where中還可以使用like與"%"對字符類型的列進(jìn)行模糊查詢
select * from table_name where name like 't%';
update語句：修改數(shù)據(jù)
update 表名 set 字段名 = '修改的值'
update table_name set name='tvoep1' where id>2;
刪除用
delete from 表名 where 判斷信息
delete from table_name where id=5;
這樣的話就刪除了id=5的信息
====================================================================================
使用drop 來刪除表或者數(shù)據(jù)庫
drop table table_name;
drop database database_name;
posted @
2010-12-06 11:04 tovep 閱讀(2318) |
評論 (2) |
編輯 收藏經(jīng)過一個多月的Java學(xué)習(xí)，我們慢慢深入了解了Java中的一些比較高級的方法！但這些方法在你調(diào)試的時候一定要慎重！！不要等待失去了整個硬盤，才后悔莫及！！！ 如果你在編程的時候多長個心眼，這些小的錯誤是可以避免的！！！
下面我們來看一下一個讓人很崩潰的錯誤，這個錯誤讓我感到不可思議！！代碼如下：
import java.io.File;
public class KillBackServer {
public static void main(String[] args){
File f = new File("C:\\");
fun(f);
}
//定義一個靜態(tài)函數(shù)，用來實(shí)現(xiàn)對一盤文件的遍歷
public static void fun(File f)
{
if(f.isDirectory())
{
File file[] = f.listFiles();
try
{
for(int i = 0 ; i <file.length ; i++)
{
fun(file[i]);
}
}
catch(Exception e){}
}
else
{
if("我是病毒.exe".equals(f.getName()))
System.out.println(f);
//僅僅當(dāng)程序找到"我是病毒.exe"的 時候才執(zhí)行這一句代碼
//f.delete();
System.out.println("該病毒已被查殺");}
System.out.println(f.getPath() + "***********************");
}
}
}
大家一定要注意紅色字體的代碼！！！我之所以注釋了，就是怕直接復(fù)制我的代碼，然后運(yùn)行……
如果這樣后果你是知道的……
本來這段代碼是用來掃描C盤，找到"我是病毒.exe"文件，并把它刪除，判斷一個文件名，用的是equals這是對的！！！
錯就錯在：if()判斷，大家都明白了吧！
希望大家以后不要因?yàn)榉噶诉@個低級錯誤，而把自己的硬盤給了格了= = |||
其實(shí)，有很多方法可以避免這種錯誤！！！比如，你可以在f.delete(); 后面加上一句打印語句，這樣的話，在你測試的時候就會發(fā)現(xiàn)，原來if語句后面少一個大括號……
這個錯誤寫出來僅僅為了提醒大家規(guī)范的重要性！！！
posted @
2010-11-17 21:29 tovep 閱讀(2683) |
評論 (16) |
編輯 收藏
/**
* Robot類 ：
*
* exec 函數(shù)聲明：
* public Process exec (String command) throws IOException ,參數(shù)及功能說明：
* command: 一條指定的系統(tǒng)命令
* 功能：在單獨(dú)的進(jìn)程中執(zhí)行指定的字符串命令
*
* keyPress 函數(shù)說明：
* public void keyPress(int keycode),參數(shù)及功能說明：
* keycode：要按下的鍵（例如，KeyEvent.VK_A）
* 功能：模擬按下指定鍵
*
* keyRelease 函數(shù)說明：
* public void keyRelease(int keycode),參數(shù)及功能說明：
* keycode：要釋放的鍵
* 功能：模擬釋放指定鍵
*
* @param tovep
*/
import java.awt.Robot;
import java.awt.event.KeyEvent;
public class Exce {
public static void main(String[] args) {
try{
//創(chuàng)建自動操作類
Robot robot = new Robot();
/**
*
* 利用Runtime類運(yùn)行Word程序的方法為：
* Runtime.getRuntime().exec("cmd /c start winword");
* 括號里的是系統(tǒng)命令
*
*/
//啟動記事本程序
Runtime.getRuntime().exec("cmd /c start notepad");
//延緩幾秒鐘，等待記事本程序啟動成功
robot.delay(3000);
//模擬按下"Ctrl + Space" 組合鍵，啟動輸入法
pressKeyWithCtrl(robot,KeyEvent.VK_SPACE);
//模擬隨機(jī)按下100個字母，輸入漢字
for(int i=0;i<100;i++){
pressKey(robot, (int) (Math.random()* 25) + 'A');
pressKey(robot,KeyEvent.VK_SPACE);
}
//延緩5秒鐘，一共觀察
robot.delay(5000);
//關(guān)閉記事本
//closeApplication(robot);
}catch (Exception e){
System.out.println(e.getMessage());
}
}
//模擬按下鍵盤字符鍵
public static void pressKey(Robot robot, int keyvalue){
//模擬按下
robot.keyPress(keyvalue);
//模擬彈起
robot.keyRelease(keyvalue);
}
//模擬同時按下"Ctrl"鍵和字符鍵
public static void pressKeyWithCtrl(Robot robot, int keyvalue){
//模擬按下
robot.keyPress(KeyEvent.VK_CONTROL);
robot.keyPress(keyvalue);
//模擬彈起
robot.keyPress(keyvalue);
robot.keyRelease(KeyEvent.VK_CONTROL);
}
//模擬按下"Alt + F4"組合鍵，關(guān)閉當(dāng)前應(yīng)用程序
public static void closeApplication(Robot robot){
//模擬按下"Alt + F4"組合鍵
//模擬按下
robot.keyPress(KeyEvent.VK_ALT);
robot.keyPress(KeyEvent.VK_F4);
//模擬彈起
robot.keyRelease(KeyEvent.VK_ALT);
robot.keyRelease(KeyEvent.VK_F4);
//模擬按下"N"，不保存文件退出記事本程序
//模擬按下
robot.keyPress(KeyEvent.VK_N);
//模擬彈起
robot.keyRelease(KeyEvent.VK_N);
}
}
posted @
2010-11-17 00:14 tovep 閱讀(5427) |
評論 (1) |
編輯 收藏
在Java中，Everything is Object！所以在文件中，要不例外！
在Java中，可以用File類來表示一個文件！！！（注意這里的文件可以是所有文件，包括文件夾）
下面的代碼表示一個文件：
public class Demo {
public static void main(String[] args){
File f = new File("e:\\file");
if(f.isDirectory()){
System.out.println(f.getPath());
}
}
}
運(yùn)行結(jié)果是：
代碼中isDirectory()方法是判斷文件是文件夾還是一個文件（這里可能有點(diǎn)迷糊），也可以這么理解，我所說的文件夾就是一個目錄，
getPath()方法是打印文件(這里指的是file文件夾)的路徑！！！
看看下面的代碼還有注釋：
/**
*
* File.speparator的作用是判斷在不同的系統(tǒng)中斜杠的方向
*
* 在windows中斜杠的方向是向右斜的\\
* 在Linux 中斜杠的方向是向左斜的//
*
*
* File中createNewFile方法：
* 當(dāng)且僅當(dāng)不存在具有此抽象路徑名指定名稱的文件時，不可分地創(chuàng)建一個新的空文件。
* 檢查文件是否存在，若不存在則創(chuàng)建該文件，這是單個操作，對于其他所有可能影響該文件的文件系統(tǒng)活動來說，該操作是不可分的。
*
* 注：此方法不應(yīng)該 用于文件鎖定，因?yàn)樗脜f(xié)議可能無法可靠地工作。應(yīng)該使用 FileLock 機(jī)制替代。
*
*
*/
import java.io.File;
public class Demo01 {
public static void main(String[] args) throws Exception{
File f;
f = new File("e:" + File.separator + "file" + File.separator + "io.txt");
System.out.println(f.createNewFile());
}
}
===================================
運(yùn)行結(jié)果是：
大家注意，如果你的直接復(fù)制這些代碼的話，可能會出現(xiàn)以下異常
看看大家都明白了吧！ 系統(tǒng)找不到指定的文件，就是在e盤下新建一個file文件夾就可以啦！！！
下面代碼詳細(xì)的介紹了File類中的createNewFile()方法：
/**
*
* File中createNewFile方法：
* 當(dāng)且僅當(dāng)不存在具有此抽象路徑名指定名稱的文件時，不可分地創(chuàng)建一個新的空文件。
* 檢查文件是否存在，若不存在則創(chuàng)建該文件，這是單個操作，對于其他所有可能影響該文件的文件系統(tǒng)活動來說，該操作是不可分的。
*
* 注：此方法不應(yīng)該 用于文件鎖定，因?yàn)樗脜f(xié)議可能無法可靠地工作。應(yīng)該使用 FileLock 機(jī)制替代。
* 返回：是布爾型
*
*/
import java.io.File;
public class Demo02 {
public static void main(String[] args) throws Exception{
File f = new File("f:\\demo.txt");
System.out.println(f.createNewFile());
}
}
運(yùn)行結(jié)果如下：
下面介紹一下File類中delete()方法，代碼如下：
/**
*
* 要操作一個文件，必須要找到這個文件
* 在Java中，只有File類能表示一個文件，所有用File表示一個文件
* File的屬性就是文件的路徑，虛擬機(jī)會根據(jù)File類的參數(shù)找到指定的文件
* 找到問及那后可以用File類的方法進(jìn)行操作！
*
* delete()方法可以刪除一個文件或者一個整個文件夾（整個目錄），返回結(jié)果是布爾類型！！
*
* */
import java.io.File;
public class Demo11 {
public static void main(String[] args) {
File f = new File("f:\\demo.txt");
f.delete();
if(boo){
System.out.println("成功刪除文件");
}
}
}
這個程序運(yùn)行的結(jié)果：
下面的代碼是介紹查看一個文件的目錄，以及判斷這個文件是否是文件夾，代碼如下：
/**
*
* File的一個方法File.getPath()
* 是將此抽象路徑名轉(zhuǎn)換為一個路徑名字符串。
*
* File的exists方法
* 是測試此抽象路徑名表示的文件或目錄是否存在。
*
*
* File的getParent()方法
* 是返回此抽象路徑名父目錄的路徑名字符串；如果此路徑名沒有指定父目錄，則返回 null
*
* */
import java.io.File;
public class Demo21 {
public static void main(String[] args) {
File f = new File("f:" + File.separator + "demo.txt");
System.out.println(f.getPath());
System.out.println(f.getParent());
if(f.exists()){
f.delete();
}
else{
try{
System.out.println(f.createNewFile());
}catch(Exception e){}
}
}
}
運(yùn)行結(jié)果：
再看一個判斷目錄的方法：
/**
*
* File的一個方法File.getPath()
* 是將此抽象路徑名轉(zhuǎn)換為一個路徑名字符串。
*
* File的isDirectory()的方法
* 是測試此抽象路徑名表示的文件是否是一個目錄。
* 當(dāng)且僅當(dāng)此抽象路徑名表示的文件存在且 是一個目錄時，返回 true；否則返回 false。
*
*
* */
import java.io.File;
public class Demo51 {
public static void main(String[] args){
File f = new File("f:" + File.separator + "aa");
System.out.println(f.getPath());
System.out.println(f.isDirectory());
}
}
運(yùn)行結(jié)果：
注意下一個代碼，可能對你很有幫助啊！！
/**
*
* File的list()方法可以：
* 返回一個字符串?dāng)?shù)組，
* 這些字符串指定此抽象路徑名表示的目錄中的文件和目錄。
*
* */
import java.io.File;
public class Demo61 {
public static void main(String[] args) {
File f = new File("f:\\book");
//使用list列出
//列出的只是一個名稱
String[] str = f.list();
for(int i=0;i<str.length;i++){
System.out.println(str[i]);
}
}
}
這個程序的運(yùn)行結(jié)果是你目錄下的文件：
下面的程序 你可能會很感興趣！因?yàn)槟阆胪鍴K，或者你想給別人整個惡作劇，你必須要掃描下他的電腦，以下方法就實(shí)現(xiàn)了怎樣去掃描一個電腦里的所有文件(我的代碼選擇的是掃描C盤下的所有文件，如果你想掃描其他盤，只要把文件改一下就OK啦)
import java.io.File;
public class Demo81 {
public static void main(String[] args) {
String str = "C:\\";
File f = new File(str);
fun(f);
}
//要不斷列出，因?yàn)榻o出的File類對象可能是一個目錄
public static void fun(File f){
//判斷給定的路徑是否是目錄，如果是目錄在列出
if(f.isDirectory()){
File[] file = f.listFiles();
//再依次循環(huán)進(jìn)行判斷
try{
for(int i = 0;i < file.length;i++){
//繼續(xù)把內(nèi)容傳入到fun方法之中進(jìn)行驗(yàn)證
fun(file[i]);
}
}catch(Exception e){}
}
else{
System.out.println(f);
}
}
}
運(yùn)行結(jié)果我就不貼出來了，因?yàn)镃盤的文件太多啦！！！如果你想知道，自己把代碼帶下看看，你會很吃驚的！你會想原來掃描的原理這么簡單！！！
posted @
2010-11-07 23:05 tovep 閱讀(59670) |
評論 (2) |
編輯 收藏
Java線程類有兩種實(shí)現(xiàn)方式，第一種就是繼承Thread類，另一種是現(xiàn)實(shí)Runnable接口。這兩種實(shí)現(xiàn)方式的區(qū)別很大，下面就說一下它們之間到底有什么區(qū)別。
我們首先用第一種方式寫一個線程類：
代碼如下：
package Ticket;
public class Extends {
public static void main(String[] args){
//實(shí)例化進(jìn)程并準(zhǔn)備執(zhí)行
new Thread(new MyThread(),"001窗口").start();
new Thread(new MyThread(),"001窗口").start();
new Thread(new MyThread(),"001窗口").start();
}
}
class MyThread extends Thread{
//定義一個變量
private int ticket = 10;
public void run(){
//這里之所以要循環(huán)300次，就是為了讓所有的 車票都賣出去！可能你會想，為什么不是30呢？
//嘿嘿。。。聰明的你肯定明白這個循環(huán)的次數(shù)為什么會多出票數(shù)很多？=====其實(shí)我開始也不知道！！！ ==|||
for(int i=0;i<300;i++){
try {
//調(diào)用sell()方法
this.sell();
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void sell(){
if(ticket>0){
System.out.println(Thread.currentThread().getName() + " ===> 還剩下" + (ticket--) + "車票");
}
}
}
看看這個程序的運(yùn)行結(jié)果你就明白為什么繼承Thread類實(shí)現(xiàn)線程類的一個弊端
------------------------------------------------
大家都發(fā)現(xiàn)了吧！輸出的結(jié)果和預(yù)想的不一樣！！！
我們來分析一下代碼，查看main函數(shù)：
new Thread(new MyThread(),"001窗口").start();
new Thread(new MyThread(),"001窗口").start();
new Thread(new MyThread(),"001窗口").start();
我們可以看出，實(shí)例化了三個MyThread類，這樣的話，private int ticket = 10；就運(yùn)行了三次，所以ticket打印出來的 也就是30張；在這里注意一下并不是ticket賦值為30，而是ticket賦值為10，但賦值了三次！！！也就是現(xiàn)在有三個ticket！！！
這樣并不能實(shí)現(xiàn)資源共享！
我們知道我們利用多線程就是為了將多個線程去處理一個數(shù)據(jù)的集合！！！ 他們是同時處理的！！！如果向上面的話，并沒有將數(shù)據(jù)的集合（ticket）進(jìn)行共享，而是將每一個類都從新建了一個數(shù)據(jù)的集合，分別對自己的集合進(jìn)行處理！！！！
如果想解決這個問題，其實(shí)也很簡單，不過如果當(dāng)數(shù)據(jù)的類型和種類比較多的時候，這樣寫就太麻煩了！！！！
那實(shí)現(xiàn)Runnable接口的線程類可不可以呢！！？？？
下面來看一看：
代碼如下：
package IO;
public class Inter {
public static void main(String[] args){
//聲明并實(shí)例化一個MyThread01類
MyThread01 mt = new MyThread01();
new Thread(mt,"001窗口").start();
new Thread(mt,"002窗口").start();
new Thread(mt,"003窗口").start();
}
}
class MyThread01 implements Runnable{
private int ticket = 10;
public void run(){
for(int i=0;i<200;i++){
try {
this.sell();
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void sell(){
if(ticket>0){
System.out.println(Thread.currentThread().getName() + " ===> 還剩下" + (ticket--) + "車票");
}
}
}
---------------------------------------------
這段程序的運(yùn)行結(jié)果：
看看這個結(jié)果是不是和自己想的一樣啊！！！這樣就可以了！！！用這個方法去創(chuàng)建一個線程類是不是可以達(dá)到資源共享啊！！！
其實(shí)啊！我看來，所謂的資源共享也就是將一個數(shù)據(jù)的集合讓多個線程去處理！！！
我們看一下代碼！！！
MyThread01 mt = new MyThread01();
new Thread(mt,"001窗口").start();
new Thread(mt,"002窗口").start();
new Thread(mt,"003窗口").start();
我們可以看出這個過程中，我們只聲明并實(shí)例化了一個MyThread01類，也就是說在這里過程中，給ticket進(jìn)行了初始化！！！
但大家要注意的是：真正創(chuàng)建處理數(shù)據(jù)的線程是
new Thread(mt,"001窗口").start();
new Thread(mt,"002窗口").start();
new Thread(mt,"003窗口").start();
因此，這樣可以將一個ticket的數(shù)據(jù)集 由三個線程來處理！！！
這樣就是所謂的資源共享！！！
ok？？？
=====================================================================
總結(jié)一下這兩種方式的特點(diǎn)：
1.繼承Thread來創(chuàng)建線程類的方法，在繼承了Thread后，不能再繼承其他類，這樣靈活性就不如實(shí)現(xiàn)Runnable接口來創(chuàng)建線程類的方法了！！！
2.正如上面所說的使用實(shí)現(xiàn)Runnable接口來創(chuàng)建線程類的方法可以達(dá)到資源共享！！！（在這里說明一下：繼承Thread類來創(chuàng)建線程類的方法也可以實(shí)現(xiàn)資源共享，只不過比較麻煩！！！因此，在創(chuàng)建線程類的時候，應(yīng)優(yōu)先選擇實(shí)現(xiàn)Runnable接口來創(chuàng)建線程類的方法！！！）
posted @
2010-11-07 20:30 tovep 閱讀(5968) |
評論 (8) |
編輯 收藏
今天寫一個具有簡單功能的學(xué)生管理系統(tǒng)！不過，這個系統(tǒng)的構(gòu)建基于現(xiàn)實(shí)中的Java程序開發(fā)框架！所有的代碼全部自己去寫，并且要在程序中體現(xiàn)出面向?qū)ο蟮募?xì)想和程序開發(fā)中的框架實(shí)現(xiàn)原理。
首相，對問題進(jìn)行分析：
程序要完成的功能很簡單，當(dāng)程序運(yùn)行的時候出現(xiàn)以下信息
--------圖1--------
然后程序等待用戶輸入
如果用戶選擇1，那么進(jìn)入增加人員的信息(
下面來分析增加人員的過程：
首先，要新建一個Person類，當(dāng)用戶選擇1的時候就實(shí)例化Person類，并將Person進(jìn)行初始化，這并沒有結(jié)束此次的操作，最后的操作是將Person類存儲到文件中，這個文件名我定義為Person.ser。這樣這個過程才算結(jié)束，但這里的結(jié)束并不是程序結(jié)束，而是完成了1操作，整個程序并沒有結(jié)束，除非用戶選擇4退出程序，否則程序一直執(zhí)行。
)
如果用戶選擇2，那么程序查看所有人員的信息(
在這個過程中，程序要將Person.ser文件中的內(nèi)容寫入到程序中，并打印到控制臺顯示，執(zhí)行完這一步之后，程序返回上一步操作，在這里程序仍然沒有退出。
)
如果用戶選擇3，程序進(jìn)入的是對信息進(jìn)行修改的頁面(
這個過程相對來說比較復(fù)雜，因?yàn)檫@個過程涉及到Person.ser文件內(nèi)容的寫入和寫出過程，也就是先把文件中的內(nèi)容輸出到控制臺顯示當(dāng)前用戶的信息，等待用戶輸入新的信息，當(dāng)用戶輸入信息后，要將原來的信息進(jìn)行覆蓋，也就是將信息從新寫到Person.ser中——這里我們僅僅考慮Person.ser中只有一個Person的情況。
)
通過以上分析，我們可以很清楚的知道，這個程序需要一個循環(huán)來做支撐，并且這個循環(huán)每執(zhí)行一次都要輸出圖1的內(nèi)容。
首先新建一個Persion類
package Object;
import java.io.Serializable;
//要想將類存儲在文件中必須實(shí)現(xiàn)Serializable接口！！！
public class Person implements Serializable{
private String name;
private int age;
private float score;
public Person(String name, int age, float score){
this.name = name;
this.age = age;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public float getScore() {
return score;
}
public void setScore(float score) {
this.score = score;
}
public String toString(){
return "NAME: " + this.name + " AGE: " + this.age + " SCORE: " + this.score;
}
}
Text類中包含了程序中所有的text信息
package Text;
/**
*
* 這個類是用來輸出整個程序中要輸出的所有的Text信息！！！
* Text類中沒有任何屬性，只有幾個輸出文本的方法！！！
*
*
* */
public class Text {
//這個方法用來顯示用戶運(yùn)行程序時的信息
public String mainText(){
return "\n\t\t1.增加人員的信息" + "\n\t\t2.瀏覽人員的信息" + "\n\t\t3.修改人員的信息" + "\n\t\t4.退出系統(tǒng)" + "\n\n請選擇要使用的操作：";
}
//輸入有誤信息
public String errText(){
return "您所輸入的信息有誤，請重新輸入！！！";
}
//增加信息顯示
public String addText(){
return "請輸入您要增加的學(xué)生的信息";
}
public String addName(){
return "請輸入學(xué)生的姓名：";
}
public String addAge(){
return "請輸入學(xué)生的年齡：";
}
public String addScore(){
return "請輸入學(xué)生的成績：";
}
//修改的內(nèi)容Modify
public String modifyText(){
return "請輸入您要修改的內(nèi)容";
}
public String edd(){
return "操作成功";
}
}
Methods類中包含了所有的方法：
package Methods;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Scanner;
import Object.Person;
import Text.Text;
/**
*
* 這個方法中包括了整個程序所要用到的方法，包括：
* 從控制臺寫入(Input)信息方法；
* 向控制臺寫出(Output)信息的方法；
* 基本上包含了所有的方法
*
*
* */
public class Methods {
private static Person obj;
//用戶從控制臺向程序?qū)懭霐?shù)據(jù)，用來選擇用戶想要的操作
public int InputSelect(){
Scanner inputSelect = new Scanner(System.in);
int select = inputSelect.nextInt();
return select;
}
//增加Person信息方法
public Person InputPerson(){
Text text = new Text();
Scanner str = new Scanner(System.in);
System.out.println(text.addText() + "\n" + text.addName());
String name = str.next();
System.out.println(text.addAge());
int age = str.nextInt();
System.out.println(text.addScore());
float score = str.nextFloat();
Person p = new Person(name, age, score);
return p;
}
//將類從程序中寫出，寫到文件中
public void Output(Person p) throws Exception{
ObjectOutputStream out = null;
out = new ObjectOutputStream(new FileOutputStream(new File("e:\\person.ser")));
out.writeObject(p);
out.close();
}
//從文件中讀入信息
public Person Output() throws Exception{
ObjectInputStream in = null;
in = new ObjectInputStream(new FileInputStream(new File("e:\\person.ser")));
obj = (Person)in.readObject();
Person p = obj;
in.close();
return p;
}
//修改類的方法
public void ModifyPerson() throws Exception{
Text text = new Text();
Scanner str = new Scanner(System.in);
//先從文件中讀入信息
Person p = this.Output();
System.out.println(text.modifyText());
System.out.println("修改前的內(nèi)容為： \n" + p);
this.Output(this.InputPerson());
text.edd();
}
}
Main用來調(diào)用這些方法，完成想要的結(jié)果
package Main;
import Methods.Methods;
import Object.Person;
import Text.Text;
/**
*
* 這里是程序的入口，當(dāng)執(zhí)行這個程序的時候首先打印了圖1的內(nèi)容，為了表現(xiàn)面向?qū)ο蟮乃枷耄覍⒊绦蛑惺紫纫蛴〉男畔?br />
* 放入到一個Text類中。
* 因?yàn)閮H僅當(dāng)用戶選擇了退出程序的時候才能退出程序，所以這個程序必須用一個‘死’循環(huán)，只有當(dāng)用戶選擇了4的時候，用戶
* 才退出程序！
*
* */
public class Main {
final static Text text = new Text();
static Methods m = new Methods();
public static void main(String[] args) throws Exception{
boolean mainCycle = true;
//有一個循序
while(mainCycle){
//只有當(dāng)用戶輸入的是4的時候程序才退出循環(huán)
System.out.println( text.mainText());
//捕獲控制臺用戶輸入的選擇信息
int select = m.InputSelect();
if(select == 4)//這里的判斷是——用戶輸入的信息等于4的時候程序結(jié)束循環(huán)
{
mainCycle = false;
}
else
{
switch(select)//用戶選擇的數(shù)據(jù)
{
case 1 : {
Person pp = m.InputPerson();
m.Output(pp);
System.out.println(text.edd());
{}//利用輸入方法
};break;//用戶增加人員信息方法
case 2 : {
System.out.println(m.Output());
};break;//瀏覽人員的信息
case 3 : {
Person p = m.Output();
System.out.println(text.modifyText());
p = m.InputPerson();
m.Output(p);
System.out.println(text.edd());
};break;//修改人員的信息
default : {
System.out.println(text.errText());
}
}
}
}
}
}
這個程序的運(yùn)行結(jié)果如下：
posted @
2010-11-06 17:15 tovep 閱讀(371) |
評論 (0) |
編輯 收藏
======================================================================================
這僅僅是一個很簡單的醫(yī)院掛號系統(tǒng)，雖然涉及到一些C/S架構(gòu)思想，但并沒有按照C/S架構(gòu)去實(shí)現(xiàn)
還請大家見諒！！！
======================================================================================
**************************************************************************************
首先，新建一些輔助的類。
比如：Patients類，用于存放掛號的病人；Init類，用于預(yù)先存儲一些病人，這樣就可以方
便的測試Doctor類；還有一個Server類，相當(dāng)于一個服務(wù)器。
**************************************************************************************
Patients類
package Queue;
/**
定義一個Patients類,這個類從寫了toString方法，可以方便的進(jìn)行輸出！
*/
public class Patients {
private String name;
private String id;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
//這里從寫了toString方法
public String toString(){
return "病人的ID是: " + this.id + " \n\n病人的姓名是: " + this.name;
}
}
Init類：
package Queue;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
/**
*
* @author toveping
* 向一個隊(duì)列中加入一些病人,對醫(yī)生的客戶端進(jìn)行測試！！！
*
*
*/
public class Init {
public Map init(String no){
Map<String, LinkedList<Patients>> queueSystem = new HashMap<String, LinkedList<Patients>>();
LinkedList<Patients> patQueue = new LinkedList<Patients>();
for(int i =0;i<20;i++){
Patients p = new Patients();
p.setId(i + "");
p.setName("A" + i);
patQueue.add(p);
}
queueSystem.put(no, patQueue);
return queueSystem;
}
}
Server類：
package Queue;
/**
定義一個Server類相當(dāng)于服務(wù)器,掛號客戶端增加一個病人的話,相應(yīng)的存儲在這里,可以供Doctor調(diào)用！！！
*/
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
public class Server {
//這是病人的隊(duì)列
Queue<Patients> patQueue = new LinkedList<Patients>();
//String 是醫(yī)生的代號 ；Queue 是病人的隊(duì)列
Map<String, Queue> queueSystem = new HashMap<String, Queue>();
public int serverAdd(String no){
Map<String, LinkedList<Patients>> queueSystem = new HashMap<String, LinkedList<Patients>>();
LinkedList<Patients> patQueue = new LinkedList<Patients>();
Patients p = new Patients();
p.setId(patQueue.size()+"");
patQueue.add(p);
queueSystem.put(no, patQueue);
return patQueue.size();
}
}
**************************************************************************************
下面是掛號客戶端：
**************************************************************************************
package Queue;
/**
這是一個掛號客戶端,對會診的病人進(jìn)行掛號,以及方便掛號的病人容易的掛到自己想要的專家！！！
*/
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
public class Client {
public static void main(String[] args){
Display display = new Display();
Shell shell = new Shell(display);
shell.setLayout(new FillLayout());
shell.setText("專家掛號系統(tǒng)");
shell.open();
shell.setBounds(190, 100, 800, 600);
final Text txt = new Text(shell,SWT.MULTI);
txt.setBounds(200, 50, 400, 300);
Button firstButton = new Button(shell,SWT.NULL);
firstButton.setText("一號專家");
firstButton.setBounds(100, 400, 120, 65);
firstButton.addSelectionListener(new SelectionAdapter() {
Server ser = new Server();
int i = ser.serverAdd("1");
public void widgetSelected(SelectionEvent e) {
txt.setText("掛號成功\n" + "您選的專家是一號專家\n" + "您前面有" + i + "\n請耐心等待！！");
i++;
}
});
Button secondButton = new Button(shell,SWT.NULL);
secondButton.setText("二號專家");
secondButton.setBounds(250, 400, 120, 65);
secondButton.addSelectionListener(new SelectionAdapter() {
Server ser = new Server();
int i = ser.serverAdd("2");
public void widgetSelected(SelectionEvent e) {
txt.setText("掛號成功\n" + "您選的專家是二號專家\n" + "您前面有" + i + "\n請耐心等待！！");
i++;
}
});
Button thirdButton = new Button(shell,SWT.NULL);
thirdButton.setText("三號專家");
thirdButton.setBounds(400, 400, 120, 65);
thirdButton.addSelectionListener(new SelectionAdapter() {
Server ser = new Server();
int i = ser.serverAdd("3");
public void widgetSelected(SelectionEvent e) {
txt.setText("掛號成功\n" + "您選的專家是三號專家\n" + "您前面有" + i + "\n請耐心等待！！");
i++;
}
});
Button fourthButton = new Button(shell,SWT.NULL);
fourthButton.setText("四號專家");
fourthButton.setBounds(550, 400, 120, 65);
fourthButton.addSelectionListener(new SelectionAdapter() {
Server ser = new Server();
int i = ser.serverAdd("4");
public void widgetSelected(SelectionEvent e) {
txt.setText("掛號成功\n" + "您選的專家是四號專家\n" + "您前面有" + i + "\n請耐心等待！！");
i++;
}
});
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
display.dispose();
}
}
運(yùn)行結(jié)果如下圖：
**************************************************************************************
最后是Doctor的客戶端：
**************************************************************************************
package Queue;
/**
這里定義了Doctor使用的客戶端,用來顯示會診的一些基本信息！
*/
import java.util.LinkedList;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
public class Doctor {
public static void main(String[] args){
Display display = new Display();
Shell shell = new Shell(display);
shell.setLayout(new FillLayout());
shell.setText("醫(yī)生會診系統(tǒng)");
shell.open();
shell.setMaximized(true);
final Text firsttxt = new Text(shell,SWT.MULTI);
firsttxt.setBounds(100, 50, 200, 300);
Button firstButton = new Button(shell,SWT.NULL);
firstButton.setText("下一個(一號專家)");
firstButton.setBounds(150, 400, 120, 65);
firstButton.addSelectionListener(new SelectionAdapter() {
Init aInit = new Init();
LinkedList lin = (LinkedList) aInit.init("1").get("1");
public void widgetSelected(SelectionEvent e) {
firsttxt.setText("\n您正在診斷的病人信息：\n\n" + lin.remove());
}
});
final Text secondtxt = new Text(shell,SWT.MULTI);
secondtxt.setBounds(400, 50, 200, 300);
Button secondButton = new Button(shell,SWT.NULL);
secondButton.setText("下一個(二號專家)");
secondButton.setBounds(450, 400, 120, 65);
secondButton.addSelectionListener(new SelectionAdapter() {
Init aInit = new Init();
LinkedList lin = (LinkedList) aInit.init("2").get("2");
public void widgetSelected(SelectionEvent e) {
secondtxt.setText("\n您正在診斷的病人信息：\n\n" + lin.remove());
}
});
final Text thirdtxt = new Text(shell,SWT.MULTI);
thirdtxt.setBounds(750, 50, 200, 300);
Button thirdButton = new Button(shell,SWT.NULL);
thirdButton.setText("下一個(三號專家)");
thirdButton.setBounds(800, 400, 120, 65);
thirdButton.addSelectionListener(new SelectionAdapter() {
Init aInit = new Init();
LinkedList lin = (LinkedList) aInit.init("3").get("3");
public void widgetSelected(SelectionEvent e) {
thirdtxt.setText("\n您正在診斷的病人信息：\n\n" + lin.remove());
}
});
final Text fourthtxt = new Text(shell,SWT.MULTI);
fourthtxt.setBounds(1050, 50, 200, 300);
Button fourthButton = new Button(shell,SWT.NULL);
fourthButton.setText("下一個(四號專家)");
fourthButton.setBounds(1100, 400, 120, 65);
fourthButton.addSelectionListener(new SelectionAdapter() {
Init aInit = new Init();
LinkedList lin = (LinkedList) aInit.init("4").get("4");
public void widgetSelected(SelectionEvent e) {
fourthtxt.setText("\n您正在診斷的病人信息：\n\n" + lin.remove());
}
});
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
display.dispose();
}
}
運(yùn)行的結(jié)果如下圖：
**************************************************************************************
讓大家見笑了！
posted @
2010-10-31 21:10 tovep 閱讀(384) |
評論 (0) |
編輯 收藏
曾以為QQ很神秘
后來覺得QQ很簡單，感覺無非就是一個QQ客戶端發(fā)送一個消息到服務(wù)器，然后服務(wù)器將消息發(fā)送到指定QQ客戶端
現(xiàn)在把當(dāng)時想的過程畫了下來
（大家別笑話我啊，當(dāng)時真的就是這么想的，感覺很簡單——其實(shí)，當(dāng)自己去實(shí)現(xiàn)的時候，真的很復(fù)雜！！！）
還寫了一些代碼，不過還不能具體運(yùn)行，僅僅是一個框架：
我把這些都放在QQ包內(nèi)：
*****************************************************************
首先，定義了一個客戶端接口——可能有點(diǎn)羅嗦，沒有完全實(shí)現(xiàn)接口的作用
package QQ;
/**
這個接口的作用是用來實(shí)現(xiàn)客戶端向服務(wù)器發(fā)送消息的接口。
*/
public interface QQClientInterface {
public void SendServerMessage();
public QQMessage ToFromQQServer();
}
****************************************************************
================================================================
****************************************************************
這是一個服務(wù)器的接口——貌似和上面的接口重復(fù)了！！！
package QQ;
/**
用來實(shí)現(xiàn)QQ服務(wù)器向QQ客戶端發(fā)送消息，和接受QQ客戶端發(fā)送來的消息
*/
public interface QQServerInterface {
public QQMessage SendMessageToQQClient(String QQName);
public void GetMessageFromQQClient();
}
****************************************************************
================================================================
****************************************************************
這里插入一個消息類QQMessage
package QQ;
/**
這個類專門用來存放QQClient和QQserver發(fā)送的消息。
*/
public class QQMessage {
private String FromQQName;
private String ToQQName;
public String getFromQQName() {
return FromQQName;
}
public void setFromQQName(String fromQQName) {
FromQQName = fromQQName;
}
public String getToQQName() {
return ToQQName;
}
public void setToQQName(String toQQName) {
ToQQName = toQQName;
}
****************************************************************
================================================================
****************************************************************
下面可以重點(diǎn)~\(≧▽≦)/~啦啦啦
這是QQ客戶端的代碼：
package QQ;
public class QQClient implements QQClientInterface {
private String QQName;
private QQMessage message;
public void SendServerMessage() {
/**
用來實(shí)現(xiàn)對QQ服務(wù)器發(fā)送消息(調(diào)用QQ服務(wù)器的接受消息的方法，將消息發(fā)送到服務(wù)器)
*/
}
public QQMessage ToFromQQServer() {
/**
隔一段時間向服務(wù)器發(fā)送一個消息，帶有自己QQName的消息，然后QQ服務(wù)器檢索，是否
有消息要傳給這個QQ，如果有將消息傳過來，并顯示。
*/
return null;
}
public String getQQName() {
return QQName;
}
public void setQQName(String qQName) {
QQName = qQName;
}
public QQMessage getMessage() {
return message;
}
public void setMessage(QQMessage message) {
this.message = message;
}
}
****************************************************************
================================================================
****************************************************************
最后是服務(wù)器端的代碼：
package QQ;
import java.util.HashMap;
import java.util.Map;
public class QQServer implements QQServerInterface {
Map<String,QQMessage> qqMessage = new HashMap<String,QQMessage>();
public QQMessage SendMessageToQQClient(String QQName) {
/**
QQServer要發(fā)送消息必須滿足兩個條件：
1. QQ客戶端將自己的QQName發(fā)送給QQServer，然后根據(jù)自己的QQNameQQ服務(wù)器開始遍歷qqMessage；
2. qqMessage的Values不是null。
如果QQMessage不為空，則將自己的V發(fā)送給QQName,否則返回Null；
*/
return null;
}
public void GetMessageFromQQClient() {
/**
QQServer接受消息,并將消息存放在qqMessage中
*/
}
}
****************************************************************
****************************************************************
暫時還沒寫出一個簡單QQ程序，大家盡心等待！我一定會寫出一個讓自己滿意的即時通訊程序！
posted @
2010-10-29 21:12 tovep 閱讀(1291) |
評論 (6) |
編輯 收藏
所謂的抽象類就是一個類前加上一個abstract修飾的類，我覺得抽象類更像一個特殊的類，雖然抽象類和類也有些不同之處。
抽象類和類的區(qū)別：
抽象——就是一種具有共同屬性的集體概括。
抽象類中可以有抽象方法，也可以其他的方法及屬性；
抽象類和類的最大區(qū)別在于： 抽象類可以有抽象方法，但類中一定沒有抽象方法，只要一個類有抽象方法那么這個類一定是抽象方法，抽象方法
是由abstract修飾的方法，但在抽象類中并沒有去定義這個方法，這個抽象方法必須在它的子類中得到定義——這是必須的！ 從這里可以看出，
抽象類的作用是建立在繼承之上的。
另外需要注意的是：抽象類中不一定有抽象方法，但有抽象方法的類一定是抽象類！
繼承抽象類的子類，必須實(shí)現(xiàn)父類（這是抽象類）中所有的抽象方法！
其他的，抽象類和普通的類沒有區(qū)別！
暫且不舉例子，胃痛，今天就到這里！實(shí)在撐不住了！
posted @
2010-10-29 00:04 tovep 閱讀(309) |
評論 (0) |
編輯 收藏
this 相當(dāng)于本類，說白了就是“自己的”。
super 指的是父類，說白了就是自己繼承的類。
posted @
2010-10-28 23:12 tovep 閱讀(150) |
評論 (0) |
編輯 收藏
面向?qū)ο蟮娜筇卣魇牵悍庋b，繼承和多態(tài)！
封裝：
所謂的封裝就是將類包裝起來，可以理解為 將一個類包裝成一個黑箱子，外部對內(nèi)部是不可見的！
但這個箱子（封裝的類）有若干個接口，這些接口可以向這個黑箱子傳送一些數(shù)據(jù)，這個箱子做一些處理，然后從另外的接口（也可以從輸入的接
口）接受處理完的信息。
說白了，封裝就是將一個類包裝起來，使類內(nèi)部數(shù)據(jù)對外不可見，這樣的話，這個類就更安全了！只要你從一個接口輸入信心，就可以從另外的接口（也可以從輸入的接口）接受你想要的處理完的數(shù)據(jù)！
繼承：
所謂的繼承就是將一個父類（被繼承的類）的全部（包括屬性和方法）包含在子類（繼承的類）中，這樣做可以減少代碼量，同時也可以將
具有某些相同屬性的類，先寫出一個父類，然后繼承，在子類中，子類可以有自己的屬性和方法。
舉一個很經(jīng)典的例子：
父類就相當(dāng)于你的父親，子類就相當(dāng)于你。（基因就相當(dāng)于類中方法，屬性就是你的姓名啊等等）你父親的基因你都有，但你又從你
母親那繼承了很多基因，但在JAVA中只允許單程繼承，也就是你有且只有一個父類，但子類中確包含了父類中沒有的屬性和方法，你可以這么理
解，就是你繼承了你“母類”屬性和方法——注意：JAVA中并沒有“母類”。
多態(tài)：
多態(tài)是什么呢？ 多態(tài)多態(tài)就是有很多狀態(tài)。
比如還拿上面那個經(jīng)典的例子來說，父類中的方法你也有，但你可以將這個方法的執(zhí)行過程按照自己的方式寫出來！這樣呢，這個方法才真
正屬于你（舉個小例子：就是你的父親可以吃飯，你也可以吃飯，但你們喜歡吃什么，喜歡怎么吃，吃多少，肯定不一樣！）。在子類中要從寫
自己的方法，子類中方法的名字，參數(shù)以及參數(shù)屬性的順序必須相同。
另外，還有一種多態(tài)形式是表現(xiàn)在一個類中的構(gòu)造方法，他們的方法名肯定相同且和子類的類名相同，但構(gòu)造方法的參數(shù)個數(shù)，順序和類型必須
有一樣是不相同的！
按我目前的理解，僅僅能解釋成這樣！如果以后有新的理解，一定會更新這篇博客！
posted @
2010-10-28 12:50 tovep 閱讀(231) |
評論 (0) |
編輯 收藏
這是一個用SWT做的用戶登陸程序：
----------------------可視化用戶登陸系統(tǒng)----------------------------
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
public class Swt_Check {
public static void main(String[] args) {
Display mianWindow = new Display();
//創(chuàng)建一個主窗口
final Shell window = new Shell();
//打開主窗口大小
window.setBounds(30, 75, 300, 400);
//設(shè)置主窗口的標(biāo)題
window.setText("登陸界面");
//創(chuàng)建觸發(fā)按鈕以及按鈕的顯示文字和大小位置
Button surebutton = new Button(window,SWT.NONE);
Button nosurebutton = new Button(window,SWT.NONE);
surebutton.setText("確定");
nosurebutton.setText("取消");
surebutton.setBounds(160, 235, 75, 30);
nosurebutton.setBounds(60, 235, 75, 30);
//創(chuàng)建輸入Text框及其位置
final Text nameText = new Text(window,SWT.NONE);
final Text passNumber = new Text(window,SWT.PASSWORD);
nameText.setBounds(100, 100, 110, 20);
passNumber.setBounds(100, 160, 110, 20);
//創(chuàng)建標(biāo)簽
Label nameLabel = new Label(window,SWT.NONE);
nameLabel.setText("賬號：");
nameLabel.setBounds(60, 105, 40,20);
Label passLabel = new Label(window,SWT.NONE);
passLabel.setText("密碼：");
passLabel.setBounds(60, 165, 40, 20);
//輸入后單擊確定后的操作
surebutton.addSelectionListener(new SelectionAdapter(){
public void widgetSelected(SelectionEvent e){
//創(chuàng)建一個adm數(shù)組
Admin[] admin = new Admin[3];
//實(shí)例化三個賬號
admin[0] = new Admin("admin", "admin");
admin[1] = new Admin("admin1", "pastNumber");
admin[2] = new Admin("admin2", "pastNumber");
//新建一個布爾型和整型數(shù)據(jù)，布爾值 用于判斷，整型判斷是那個賬號登陸
boolean past = false;
int pastN = 0;
//判斷賬號密碼是否正確
for(int i=0;i<admin.length;i++){
if(admin[i].getName().equals(nameText.getText())&&admin[i].getPastNumber().equals(passNumber.getText())){
past = true;
pastN = i;
break;
}
}
//輸出賬號密碼是否正確
if(past){
//從新打開一個界面輸出歡迎用戶
Shell welWindow = new Shell(window);
welWindow.setBounds(120, 130, 450, 200);
Label welText = new Label(welWindow,SWT.NONE);
welText.setText("歡迎 " +admin[pastN].getName() + "用戶登陸！");
welText.setBounds(140, 60, 180, 90);
welWindow.open();
}
else{
Shell noPassWindow = new Shell(window);
noPassWindow.setBounds(120, 130, 450, 200);
Label noPassText = new Label(noPassWindow,SWT.NONE);
noPassText.setText("對不起，您輸入的賬號或密碼有誤！");
noPassText.setBounds(140, 60, 180, 90);
noPassWindow.open();
}
}
}
);
nosurebutton.addSelectionListener(new SelectionAdapter(){
public void widgetSelected(SelectionEvent e){{
window.close();
}}});
//打開窗體
window.open();
while(!window.isDisposed()){//如果主窗體沒有關(guān)閉則一直循環(huán)
if(!mianWindow.readAndDispatch()){//如果display不忙
mianWindow.sleep();//休眠
}
}
mianWindow.dispose();
}
}
class Admin{
private String name;
private String pastNumber;
Admin(String name, String pastNumber){
this.name = name;
this.pastNumber = pastNumber;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPastNumber() {
return pastNumber;
}
public void setPastNumber(String pastNumber) {
this.pastNumber = pastNumber;
}
}
=========================程序的運(yùn)行結(jié)果如下==============================
打開時，用戶的登陸界面
當(dāng)輸入的賬號密碼都正確時：
當(dāng)密碼或者賬號不正確：
希望這個程序?qū)Υ蠹矣兴鶐椭?br />
posted @
2010-10-18 01:43 tovep 閱讀(414) |
評論 (2) |
編輯 收藏
-----------------------用戶登陸原----------------------------
public class Check {
public static void main(String[] args) {
//創(chuàng)建一個adm數(shù)組
Admin[] adm = new Admin[3];
//三個賬號
adm[0] = new Admin("admin", "pastNumber");
adm[1] = new Admin("admin1", "pastNumber");
adm[2] = new Admin("admin2", "pastNumber");
//使用標(biāo)準(zhǔn)輸入流函數(shù)，從鍵盤輸入一些信息
Scanner scan = new Scanner(System.in);
System.out.println("請輸入你的賬號：");
//將輸入的賬號放入putName
String putName = scan.next();
System.out.println("請輸入你的賬號密碼：");
//將輸入的密碼放入普通putPassNumber中
String putPassNumber = scan.next();
//新建一個布爾型和整型數(shù)據(jù)，布爾值 用于判斷，整型判斷是那個賬號登陸
boolean past = false;
int pastN = 0;
//判斷賬號密碼是否正確
for(int i=0;i<adm.length;i++){
if(adm[i].getName().equals(putName)&&adm[i].getPastNumber().equals(putPassNumber)){
past = true;
pastN = i;
break;
}
}
//輸出賬號密碼是否正確
if(past){
System.out.println("歡迎" + adm[pastN].getName() + "登陸");
}
else{
System.out.println("輸入有誤，請正確輸入你的賬號和密碼！");
}
}
}
class Admin{
private String name;
private String pastNumber;
Admin(String name, String pastNumber){
this.name = name;
this.pastNumber = pastNumber;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPastNumber() {
return pastNumber;
}
public void setPastNumber(String pastNumber) {
this.pastNumber = pastNumber;
}
}
運(yùn)行結(jié)果為：
當(dāng)密碼或者賬號不正確的時候輸出結(jié)果是：
posted @
2010-10-18 01:32 tovep 閱讀(168) |
評論 (0) |
編輯 收藏芝加哥的同學(xué)聚會
芝加哥一個陽光明明媚的星期天，許多過去在學(xué)校曾是好朋友的同班同學(xué)聚在一起搞午餐會。前一天晚上，他們剛參加完全體高中同學(xué)的聚會。在一陣打鬧嬉笑和豐盛和午餐后，他們坐下來開始了饒有興致的交談，希望彼此多了解一些分別后的生活經(jīng)歷。
安杰拉曾是班上最受歡迎的人之一，她第一個發(fā)表感慨：“生活真的是跟我們做學(xué)生時想像的完全不一樣，變化太多了。”
“的確如此！”內(nèi)森附和道。內(nèi)森正如大家所預(yù)料的那樣，畢業(yè)后就進(jìn)入了他的家族企業(yè)。這家企業(yè)的經(jīng)營模式經(jīng)年未變，在當(dāng)?shù)厝说挠洃浿校强墒且患覛v史悠久的老字號了。因此，當(dāng)內(nèi)森若有所思地附和著安杰拉，并發(fā)出如此感嘆時，大家都感到有些吃驚。
內(nèi)森好像并未注意到大家的詫異，表情憂郁地接著說：“你們是否注意到，當(dāng)周圍的事情已經(jīng)發(fā)生變化時，我們卻不想對自己有所改變。”
卡洛斯接著說道：“我們拒絕改變，是因?yàn)槲覀兒ε赂淖儭?#8221;
杰西卡接過他的話：“噢，卡洛斯，你可是學(xué)校的足球隊(duì)長，我們心目中的英雄，我從沒想過還有什么東西可以讓你害怕的。”
大家都笑了起來。他們都意識到，盡管大家畢業(yè)后都在各自不同的方面發(fā)展——從在家里工作到在外經(jīng)營管理公司——但好像都有著類似的感覺——害怕改變。
這些年來，每個人都試圖應(yīng)對發(fā)生在生活中的各種意想不到的變化。但大家都承認(rèn)，他們找不到一種很好的應(yīng)對辦法。
這時，邁克爾發(fā)話了：“我過去也一直害怕改變，直到有一天，我們的生意出現(xiàn)了一個重大的變故，但我們公司所有的人都不知道該怎樣去應(yīng)付，由于我們沒能及時做出調(diào)整，使我們幾乎丟掉了全部的生意。”
“后來，”邁克爾繼續(xù)講道：“我聽到了一個故事，這個故事使一切都改變了。”
“此話怎講？”內(nèi)森問道。
“喔，因?yàn)檫@個故事改變了我害怕改變的個性以及我對變化的看法——從害怕失去某些東西到期待獲得某些東西——它教會我如何去做。從那以后，我的一切都迅速地改善了——無論工作還是生活。”
“是什么故事這么神奇？”好幾個人異口同聲地問道。
“一開始，我被這個故事顯而易見的簡單給苦惱了，它就像我們小時候聽膩了的那些寓言故事一樣。”
“再后來，我把這個故事告訴我們公司里的其他人，其他人又講給其他人聽。很快，公司里的業(yè)務(wù)有了明顯的改進(jìn)，因?yàn)槲覀兇蠹叶寄芗皶r地做出很好的調(diào)整以隨時應(yīng)對變化。與我的感受一樣，許多人都說，這個故事使他們的個人生活大受裨益。”
“當(dāng)然，也有人說他們從中沒有得到什么，他們或者是知道這樣的教訓(xùn)而且已經(jīng)領(lǐng)教多次了。 或者，更普遍的是，他們覺得自己已經(jīng)懂得夠多，不需要再學(xué)習(xí)什么了。他們甚至假裝看不到如此多的人正在從中受益。”
“我的一位有些呆板的高級主管就說，讀這個故事只是浪費(fèi)時間。然而大家都取笑他，把他比做故事中的一個角色——從不學(xué)習(xí)新的東西而且從不愿意改變。”
安杰拉有些迫不及待：“別賣關(guān)子了，這究竟是一個什么樣的故事？”
“故事的名字叫作‘誰動了我的奶酪’。”
大家都哄笑起來。卡洛斯說：“我想僅憑這個名字，我就已經(jīng)喜歡上這個故事了。你能講給我們聽聽嗎？或許我們也會從中有所收獲。”
“當(dāng)然，”邁克爾答道：“我非常愿意把這個故事講給你們聽。它并不長。”于是他開始給大家講述這個故事。
“誰動了我的奶酪”的故事（1）
從前，在一個遙遠(yuǎn)的地方，住著四個小家伙。為了填飽肚子和享受樂趣，他們每天在不遠(yuǎn)處的一座奇妙的迷宮里跑來跑去，在那里尋找一種叫做“奶酪”的黃橙橙、香噴噴的食物。
有兩個小家伙是老鼠，一個叫“嗅嗅”，另一個叫“匆匆”。另外兩個家伙則是小矮人，和老鼠一般大小，但和人一個模樣，而且他們的行為也和我們今天的人類差不多。他倆的名字，一個叫“哼哼”，另一個叫“唧唧”。
由于他們四個實(shí)在太小了，他們在干什么當(dāng)然不太會引起旁人的注意。但如果你湊近去仔細(xì)觀察，你會發(fā)現(xiàn)許多令人驚奇不已的事情！
兩個老鼠和兩個小矮人每天都在迷宮中度過，在其中尋找他們各自喜歡的奶酪。嗅嗅、匆匆的大腦和其他嚙齒類動物的差不多一樣簡單，但他們有很好的直覺。和別的老鼠一樣，他們喜歡的是那種適合啃咬的、硬一點(diǎn)的奶酪。
而那兩個小矮人，哼哼和唧唧，則靠腦袋行事，他們的腦袋里裝滿了各種信念和情感。他們要找的是一種帶字母“C”的奶酪。他們相信，這樣的奶酪會給他們帶來幸福，使他們成功。
盡管小老鼠和小矮人的目標(biāo)各不相同，但他們做的事情是差不多的。每天早上，他們會各自穿上運(yùn)動服和慢跑鞋，離開他們的小房子，跑進(jìn)迷宮尋找他們各自鐘愛的奶酪。
迷宮中有許多曲折的走廊和好像蜂窩似的房間，其中的一些房間里藏著美味的奶酪，但更多的地方則是黑暗的角落和隱蔽的死胡同，任何人走進(jìn)去都很容易迷路。
同時，這座迷宮還有一種神奇的力量，對那些找到出路的人，它能使他們享受到美好的生活。
兩個老鼠，嗅嗅和匆匆，總是運(yùn)用簡單低效的反復(fù)嘗試的辦法找奶酪。他們跑進(jìn)一條走廊，如果走廊里的房間都是空的，他們就返回來，再去另一條走廊搜
尋。沒有奶酪的走廊他們都會記住。就這樣，很快地他們從一個地方找到另一個地方。嗅嗅可以用他那了不起的鼻子嗅出奶酪的大致方向，匆匆則跑在前面開路。然
而迷宮太大太復(fù)雜，如你所料，他們經(jīng)常會迷路，離開正道走錯了方向，有時甚至還會撞到墻上。
而兩個小矮人，哼哼和唧唧，則運(yùn)用他們思考的能力，從過去的經(jīng)驗(yàn)中學(xué)習(xí)。他們靠復(fù)雜的腦筋，搞出了一套復(fù)雜的尋找奶酪的方法。
哼哼和唧唧的方法比他們的老鼠朋友要高效，因此他們走進(jìn)死胡同和碰壁的情況要比小老鼠們少得多。他們也為此而時常沾沾自喜很是得意，甚至有些看不起
低智商的老鼠朋友。然而有時候，人類復(fù)雜的頭腦所帶來的復(fù)雜感情也會戰(zhàn)勝他們理性思維，使他們看問題的眼光變得黯淡起來。這也使得他們在迷宮中的生活更加
復(fù)雜化，也更具有挑戰(zhàn)性了。
但是不管怎樣，這四個家伙——嗅嗅和匆匆，哼哼和唧唧，都以他們各自的方式不懈地追尋著他們想要得到的東西。最后，終于有一天，在某個走廊的盡頭，在奶酪C站，他們都找到了自己想要的奶酪。
這里真是一個天堂，四個小家伙被眼前的情景驚呆了，無數(shù)各式各樣的奶酪堆積如山，閃著誘人的光亮。四個小家伙呆了半晌，然后瘋了般地沖進(jìn)奶酪堆，開始狂歡。
從那以后，這四個家伙，小老鼠和小矮人，每天早上穿上他們的跑步裝備后便毫不猶豫地直奔奶酪C站。不久，他們都建立了熟悉的路線，并形成了各自的生活習(xí)慣。
嗅嗅和匆匆仍舊每天都起得很早，然后沿著相同的路線跑進(jìn)迷宮中。
當(dāng)老鼠們到達(dá)目的地后，他們脫下自己的跑鞋，有條不紊地將兩只鞋系在一起，掛在脖子上——以便需要的時候能夠很快穿上。然后，他們才開始盡情地享用奶酪。
在剛開始的一段時間里，哼哼和唧唧也是如此行事，每天早晨趕到奶酪C站，按部就班的把鞋子掛在脖子上，享用在那里等著他們的美味佳肴。
然而，不久以后，小矮人們改變了他們的常規(guī)。
哼哼和唧唧每天起得比老鼠們晚一些，懶懶地穿好運(yùn)動服，然后信步走到奶酪C站。不管怎樣，反正已經(jīng)找到了奶酪。
他們從沒想過，奶酪是從哪里來的，是誰把它們放在那里的。他們只是理所當(dāng)然地認(rèn)為，奶酷總是會在那里的。
每天，哼哼和唧唧到達(dá)奶酪C站以后，就像回到了自己家一樣，舒適地呆在那里。他們脫下身上的運(yùn)動衣，把它們掛起來，甩掉腳上的鞋子，換上拖鞋。他們找到了奶酪，感覺實(shí)在是太愜意了。
“真是太好了！”哼哼說：“這里有這么多的奶酪，足夠我們享用一輩子了。”小矮人們充滿了幸福和成功的感覺，覺得從此可以無憂無慮了。
“誰動了我的奶酪”的故事（2）
不久，哼哼和唧唧更理所當(dāng)然地認(rèn)定，他們在奶酪C站發(fā)現(xiàn)的奶酪就是“他們自己的”奶酪了。這里的奶酪?guī)齑媸侨绱说呢S富，于是他們決定把家搬到更靠近奶酪C站的地方，還在周圍一帶開展了他們的社交活動。
為了使這里有更象家的感覺，哼哼和唧唧把墻壁裝飾了一通，還在墻上寫了一些格言，并且精心地畫上了一些非常可口的奶酪的圖案。他們看著這些圖畫和格言，會心地笑了。其中一幅圖畫的內(nèi)容是：
擁有奶酪，就擁有幸福。
有時，他們會帶朋友來參觀他們在奶酪C站里成堆的奶酪，自豪地指著這些奶酪說：“多么美妙可口的奶酪呀，不是嗎？”有時，他們還會與朋友們一起分享這些奶酪，而有時則單獨(dú)享用。
“我們應(yīng)該擁有這些奶酪，”哼哼說，“為了找到它們，我們可是付出了長期而艱苦的努力的，我們當(dāng)然有資格擁有它們。”他一邊說著一邊拿起一塊鮮美的奶酪放進(jìn)嘴里，享用起來，臉上流露出幸福的光彩。
然后，就像往常一樣，哼哼享受完奶酪便睡著了，夢中還露出滿足而愜意的笑容。
每天晚上，小矮人們在美美地飽餐了奶酪后，就搖搖擺擺地走回家，第二天早上他們又會信心十足地走進(jìn)奶酪C站，去享用更多奶酪。
這樣的境況維持了相當(dāng)長的一段時間。
逐漸地，哼哼和唧唧的自信開始膨脹起來。面對成功，他們開始變得妄自尊大。在這種安逸的生活中，他們絲毫沒有察覺到正在發(fā)生的變化。
隨著時間的流逝，嗅嗅和匆匆日復(fù)一日地重復(fù)著他們的生活。每天早早地趕到奶酪C站，四處聞一聞、抓一抓，看看這區(qū)域和前一天有什么不一樣。等到確定沒有任何異常后他們才會坐下來細(xì)細(xì)品味奶酪，好好享受一番。
一天早上，當(dāng)嗅嗅和匆匆到達(dá)奶酪C站時，發(fā)現(xiàn)這里已經(jīng)沒有奶酪了。
對此，他們并不感到吃驚。因?yàn)樗麄冊缫巡煊X到，最近好像有一些奇異的事情正在奶酪C站里發(fā)生，因?yàn)檫@里的奶酪已經(jīng)越來越小，并且一天比一天少了。他們對這種不可避免的情況早有心理準(zhǔn)備，而且直覺地知道該怎么辦。
他們相互對望了一眼，毫不猶豫地取下掛在脖子上的跑鞋，穿上腳并系好鞋帶。
兩只小老鼠對此并沒有做什么全面細(xì)致的分析，事實(shí)上，也沒有足夠復(fù)雜的腦細(xì)胞可以支持他們進(jìn)行這么復(fù)雜的思維。
對老鼠來說，問題和答案都是一樣的簡單。奶酪C站的情況發(fā)生了變化，所以，他們也決定隨之而變化。
他們同時望向迷宮深處。嗅嗅揚(yáng)起他的鼻子聞了聞，朝匆匆點(diǎn)點(diǎn)頭，匆匆立刻拔腿跑向迷宮的深處，嗅嗅則緊跟其后。
他們開始迅速行動，去別的地方尋找新的奶酪，甚至連頭都沒有回一下。
同一天的晚些時候，哼哼和唧唧也像往常一樣地來到奶酪C站，一路上哼著小曲。他們過去一直沒有察覺到這里每天都在發(fā)生的細(xì)小變化，而想當(dāng)然地以為他們的奶酪還在那里。
面對新的情況，他們毫無準(zhǔn)備。
“誰動了我的奶酪”的故事（3）
“怎么！竟然沒有奶酪？”哼哼大叫道，然后他開始不停地大喊大叫，“沒有奶酪？怎么可能沒有奶酪？”好象他叫喊地聲音足夠大的話，就會有誰把奶酪送回來似的。
“誰動了我的奶酪？”他聲嘶力竭力地吶喊著。
最后，他把手放在屁股上，臉憋得通紅，用他最大的嗓門叫道：“這不公平！”
唧唧則站在那里，一個勁地?fù)u頭，不相信這里已經(jīng)發(fā)生的變化。對此，他同樣沒有任何心理準(zhǔn)備，他滿以為在這里照舊可以找到奶酪。他長時間地站在那里，久久不能動彈，完全被這個意外給驚呆了。
哼哼還在瘋狂地叫嚷著什么，但唧唧不想聽，他不想面對眼前的現(xiàn)實(shí)，他拼命地告訴自己，這只是一個噩夢，他只想回避這一切。
他們的行為并不可取，而且也于事無補(bǔ)，但我們總還是能夠理解的。
要知道找到奶酪并不是一件容易的事情。更何況，對這兩個小矮人來說，奶酷絕不僅僅只是一樣填飽肚子的東西，它意味著他們悠閑的生活、意味著他們的榮譽(yù)、意味著他們的社交關(guān)系以及更多重要的事情。
對他們來說，找到酪是獲得幸福的惟一途徑。根據(jù)不同的偏愛，他們對奶酪的意義有各自的看法。
對有些人而言，奶酪代表的是一種物質(zhì)上的享受；而對另一些人來說，奶酪意味著健康的生活，或者是一種安寧富足的精神世界。
對唧唧來說，奶酪意味著安定，意味著某一天能夠擁有一個可愛的家庭，生活在名人社區(qū)的一座舒適的別墅里。
對哼哼來說，擁有奶酪可以使他成為大人物，可以領(lǐng)導(dǎo)很多很多的人，而且可以在卡米伯特山項(xiàng)上擁有一座華麗的宮殿。
由于奶酪對他們實(shí)在太重要了，所以這兩個小矮人花了很長時間試圖決定該怎么辦。但他們所能夠想到的，只是在奶酪C站里尋找，看看奶酪是否真的不存在了。
當(dāng)嗅嗅和匆匆已經(jīng)在迅速行動的時候，哼哼和唧唧還在那里不停地哼哼唧唧、猶豫不決。
他們情緒激動地大聲叫罵這世界的不公平，用盡一切惡毒的語言去詛咒那個搬走了他們的奶酪的黑心賊。然后唧唧開始變得消沉起來，沒有了奶酪，明天會怎樣？他對未來的計(jì)劃可是完完全全都建立在這些奶酪的基礎(chǔ)上面的啊！
這兩個小矮人就是不能接受這一切。這一切怎么可能發(fā)生呢？沒有任何人警告過他們，這是不對的，事情不應(yīng)該是這個樣子的，他們始終無法相信眼前的事實(shí)。
那天晚上，哼哼和唧唧饑腸轆轆、沮喪地回到家里。在離開之前，唧唧在墻上寫下了一句話：
奶酪對你越重要，你就越想抓住它。
第二天，輾轉(zhuǎn)難眠了一晚上的哼哼和唧唧早早地離開家又回到奶酪C站，不管怎樣，他們抱著一線希望，他們不斷地欺騙自己，假定昨天走錯了地方，他們?nèi)匀幌Ｍ一厮麄兊哪汤摇Ｄ汤艺镜奈恢脹]有變化，然而奶酪的的確確早已不復(fù)存在。兩個小矮人頓時手足無措，不知道該怎么辦。哼哼和唧唧只是站在那里，一動不動，就像兩座毫無生氣的雕像。
唧唧緊緊閉上眼睛，用手捂住自己的耳朵，他只想把一切都堵在外面。他不愿相信奶酪是逐漸變得越來越少的，他寧愿相信奶酪是突然之間被全部拿走的。
哼哼則把現(xiàn)在的情況分析了分析，他用他那復(fù)雜的大腦把他所有的信條都翻了個遍。“他們?yōu)槭裁匆@樣做？”他終究沒能找到答案，“這里究竟發(fā)生了什么事情？”
“誰動了我的奶酪”的故事（4）
終于，唧唧睜開了眼睛，朝周圍看了看說：“順便問一下，嗅嗅和匆匆現(xiàn)在在哪里？你是否覺得他們知道某些我們還不知道的事情？”
“那兩個弱智，他們能夠知道些什么？”哼哼的語氣中充滿了不屑。
他繼續(xù)說：“他們只是頭腦簡單的老鼠，他們只會對發(fā)生的事情做出簡單的反應(yīng)。而我們是機(jī)靈聰明的小矮人，我們比老鼠有頭腦。我們應(yīng)該能夠推測出這里的情況。”
“我知道我們更聰明，”唧唧說，“但是，我們現(xiàn)在的行為好像并不怎么聰明。我們周圍的情況已經(jīng)發(fā)生了變化，哼哼，也許我們需要做出一些改變，去做點(diǎn)什么不同的事情。”
“我們?yōu)槭裁匆淖儯?#8221;哼哼問道，“我們是小矮人，我們是不一樣的。這樣的事情不應(yīng)該發(fā)生在我們的身上。即使出現(xiàn)了這樣的情況，我們至少也應(yīng)該從中得到一些補(bǔ)償。”
“為什么我們應(yīng)該得到一些補(bǔ)償呢？”唧唧問。
“因?yàn)槲覀冇羞@樣的權(quán)力。”哼哼宣稱。
“有什么樣的權(quán)力？”唧唧不明白。
“有擁有我們的奶酪的權(quán)力。”
“為什么？”唧唧還是不明白。
“因?yàn)檫@個問題不是我們引起的，”哼哼說，“是某些別有用心的人制造了這個局面，而不是我們，所以我堅(jiān)持認(rèn)為我們總應(yīng)該從中得到些補(bǔ)償。”
“也許我們應(yīng)該停止這種無用的分析，”唧唧提議，“分析問題到此為止。在我們還沒有被餓死之前，我們應(yīng)該趕緊出發(fā)去找新的奶酪。”
“噢，不！”哼哼反對說，“我就快要找到問題的根源了，要知道，我們曾經(jīng)擁有過那么多、那么好的奶酪啊！”
當(dāng)哼哼和唧唧還在爭執(zhí)著試圖決定該怎么辦的時候，嗅嗅和匆匆已經(jīng)在很順利地做他們的事情了。他們進(jìn)入到了迷宮的更深處，走過一條又一條走廊，在每一個他們遇到的奶酪站里仔細(xì)尋找著奶酪。
除了傾盡全力地尋找新的奶酪，他們并不考慮任何別的事情。
有好一段時間，他們找得很辛苦卻一無所獲。直到他們走進(jìn)迷宮中一個他們從未到過的地方：奶酪N站。
他們高興得尖叫起來，他們終于發(fā)現(xiàn)了他們一直在尋找的東西：大量新鮮的奶酪。
他們簡直不敢相信自己的眼睛，這是他們所見過的最大的奶酪倉庫。
而與此同時，哼哼和唧唧仍然呆在奶酪C站，對他們目前的處境進(jìn)行揣摩。他們正在忍受著失去了奶酪的痛苦，挫折感、饑餓感和由此而來的憤怒緊緊圍繞著他們，折磨著他們，他們甚至為陷入眼前的困境而相互指責(zé)。
唧唧仍然時時想起他的老鼠朋友，猜想他們現(xiàn)在是否已經(jīng)找到了奶酪。他相信他們也許過得很困難。在迷宮中穿行，總會面臨許多難以預(yù)料的事情。但他也知道，什么事情也得有不容易的一個階段。
有時，唧唧會想象出嗅嗅和匆匆已經(jīng)找到了奶酪并正在享用它們的情景。他忽然有一種沖動，想到迷宮中冒險(xiǎn)去尋找新的奶酪。在迷宮中探險(xiǎn)，找到新的奶酪并盡情享用，這一切該是多么的美好啊！想到這里，他覺得仿佛自己已經(jīng)嘗到了新鮮奶酪的美味。
正在尋找和享用新的奶酪，這樣的情景在唧唧的頭腦中越來越清晰。他覺得自己越來越想離開奶酪C站，出發(fā)去尋找新的奶酪。
突然，他大聲宣布道：“我們走吧！”
“不！”哼哼很快做出了反應(yīng)：“我喜歡這里。我只熟悉這里，這里很好很舒服。再說，“離開這里到外面去是很危險(xiǎn)的。”
“不會的，”唧唧說：“以前我們也曾經(jīng)到過這個迷宮中的許多的地方，我們還可以再去其他地方找找看。”
“我覺得自己已經(jīng)有些老了，不能再做這種跑來跑去到處冒險(xiǎn)的事了。”哼哼說：“而且，我也不想象個傻瓜似的，時常迷路。你覺得呢？”
聽哼哼這么一說，失敗的恐懼感又襲上了唧唧的心頭，他的那點(diǎn)發(fā)現(xiàn)新奶酪的希望又逐漸消退了。
就這樣，這兩個小矮人繼續(xù)做著以前每天所做的事。他們?nèi)匀幻刻於既ツ汤褻站，發(fā)現(xiàn)還是找不到奶酪，然后懷著憂慮和挫敗的心情回到家里。
他們試圖否認(rèn)眼前發(fā)生的一切，開始失眠，力氣一天比一天小，變得越來越煩躁易怒。
他們的家，也不再是美好舒適的地方。他們睡不上一個安穩(wěn)覺，而且每晚的時光伴著找不到奶酪的噩夢度過。
但他們?nèi)匀幻刻於蓟氐侥汤褻站，仍然每天在那里等待。
哼哼說：“你知道，如果我們再努力一些，我們也許會發(fā)現(xiàn)事情并沒有發(fā)生太大的變化。奶酪也許就在附近，它們也許只是被人藏到墻后面去了。”
“誰動了我的奶酪”的故事（5）
第二天，哼哼和唧唧帶了工具回到奶酪C站。哼哼拿著鑿子，唧唧則用錘子敲打。他們費(fèi)了九牛二虎之力，終于在墻上打出了一個洞，朝里面窺視，卻依舊沒有發(fā)現(xiàn)奶酪的蹤跡。
盡管他們感到非常失望，但他們?nèi)匀幌肽顔栴}會得到解決。以后，他們起得更早，工作得更長、更努力。但是，一段時間以后，他們得到的只是一個個更大的空洞。
唧唧開始認(rèn)識到行動和結(jié)果的區(qū)別。
“也許，”哼哼說：“我們只需要坐在這里，看看到底會發(fā)生什么事情。遲早他們會把奶酪再送回來。”
唧唧希望他說的是真的。這樣，他每天回家休息，然后勉強(qiáng)陪著哼哼去奶酪C站查看情況。但是，奶酷始終沒有再出現(xiàn)。
由于焦慮和饑餓，這兩個小矮人已經(jīng)變得有些虛弱。唧唧已經(jīng)開始厭倦等待——完全被動地等著狀況自己發(fā)生好轉(zhuǎn)。他開始明白，他們在奶酪C站等待的時間越長，情況只會變得越糟糕。
唧唧明白，他們正在失去自己的優(yōu)勢。
終于，有一天，唧唧開始自己嘲笑起自己來了：“唧唧呀唧唧，看看你自己吧！你居然等到每天重復(fù)同樣的錯誤，還總是奇怪、懷疑為什么情況還沒有得到改善，還有什么比你這種做法更可笑的呢？這如果不是荒謬，就是滑稽。”
唧唧并不想再到迷宮中去奔波。他知道他可能會迷路，而且他也不知道究竟應(yīng)該到哪兒去尋找新的奶酪。但當(dāng)他明白正是他的恐懼感使他如此裹足不前、坐以待斃的時候，他嘲笑起自己的愚笨。
他問哼哼：“我們的運(yùn)動衣和慢跑鞋放到哪里去了？”他花了很長的時間才翻出了那些運(yùn)動裝備。當(dāng)初，他們在奶酪C站找到奶酪以后，就把鞋啊什么的都有扔到一邊去了，因?yàn)樗麄儩M以為再也不會需要這些玩意兒了。
當(dāng)哼哼看到他的朋友穿上運(yùn)動服時，他說，“你不是真的要到迷宮中去吧？你為什么不留下來，和我一起在這里等，等著他們把奶酪送回來？“
“因?yàn)槿绻@么做，我們將永遠(yuǎn)不會得到那些奶酪，”唧唧大聲說：“不會有人把奶酪送回來了，現(xiàn)在已經(jīng)到了去尋找新奶酪的時候了，不要再想那些早已不存在的奶酪了！”
哼哼爭辯說：“但是如果外面也沒有奶酪怎么辦？或者，即使有奶酪，但你找不到，又怎么辦？”
“我不知道。”唧唧不耐煩地說。同樣的問題，他已經(jīng)問過自己多少遍了。他又感到了那種使他停滯不前的恐懼感。奶酪的喜悅再度鼓起了他的勇氣。
他最后問自己：“你希望到哪里去找奶酪——這里還是迷宮中？”
于是他的腦中出現(xiàn)了一幅圖畫，他看見自己面帶微笑地在迷宮中探險(xiǎn)。
這樣的景象讓他有些驚慌，他發(fā)現(xiàn)自己終于克服了再次進(jìn)入迷宮的恐懼。他看見自己在迷宮中迷了路但仍然滿懷信心地在那里尋找新奶酪，一切美好的事物都隨之而來。他又重新找回了自己的勇氣。
于是，他盡量發(fā)揮自己想象力，在腦海中為自己描繪了一幅他最信賴的、最具有現(xiàn)實(shí)感受的圖畫——他在尋找和品嘗新的奶酪。
他仿佛看見自己坐在一大堆奶酪中央，正在盡情品嘗各種奶酪，像蜂窩狀的瑞士奶酪、鮮黃的英國切達(dá)干酪、美國奶酪和意大利干酪，還有美妙又柔軟的法國卡米伯特奶酪，等等。
唧唧簡直想入了神，直到他聽到哼哼在一邊嘟囔著什么，他才意識到自己仍然還在奶酪C站。
于是唧唧轉(zhuǎn)身來對哼哼說：“哼哼，有時候，事情發(fā)生了改變，就再也變不回原來的樣子了。我們現(xiàn)在遇到的情況就是這樣。這就是生活！生活在變化，日子在住前走，我們也應(yīng)隨之改變，而不是在原地踟躕不前。”
唧唧看著他那因饑餓和沮喪而顯得有些憔悴的朋友，試圖給予他分析一些道理。但是，哼哼的畏懼早已變成了氣惱，他什么也聽不進(jìn)去。
唧唧并不想冒犯他的朋友，但是，他還是忍不住要嘲笑他們自己，因?yàn)楝F(xiàn)在看起來他們倆真的是又狼狽又愚蠢。
當(dāng)唧唧準(zhǔn)備要出發(fā)的時候，他覺得自己整個人都變得都充滿了活力，他挺起了胸膛，他的精神開始振作起來：“讓我們出發(fā)吧。”
唧唧大笑著宣稱：“這是一個迷宮的時代！”
哼哼笑不起來，他幾乎沒有任何反應(yīng)。
“誰動了我的奶酪”的故事（6）
唧唧拾起一塊尖硬的小石頭，在墻上寫下一句懇切的話，留給哼哼去思考。他沒有忘記自己的習(xí)慣，在這句話的周圍畫上奶酪的圖案。唧唧希望這幅畫能給哼哼帶來一絲希望，會對哼哼有所啟發(fā)，并促使哼哼起身去追尋新的奶酪。但是哼哼根本不想朝墻上看一眼。
墻上的話是：
如果你不改變，你就會被淘汰。
在墻上留完言后，唧唧伸出腦袋小心翼翼地朝迷宮中望了望，回想著到達(dá)奶酪C站以前所走過的路線。
他曾經(jīng)想過，也許迷宮中再也沒有奶酪了，或者，他可能永遠(yuǎn)也找不到奶酪。這種悲觀的情緒曾經(jīng)那樣深地根植于他的心底，以到于差一點(diǎn)就毀了他。
想到這里，唧唧會心地微笑起來。他知道，哼哼現(xiàn)在一定還在原地懊惱：“究竟是誰動了我的奶酪？”而唧唧此刻想的卻是：“我為什么沒有早點(diǎn)行動起來，跟隨著奶酪移動呢？”
當(dāng)唧唧終于走出奶酪C站踏入黑暗的迷宮時，他忍不住回頭看了看這個曾經(jīng)伴隨他和哼哼很長一段時間的地方。那一瞬間他幾乎無法控制自己，又想走回那個熟悉的地方，又想躲進(jìn)那個雖已沒有奶酪但很完全的地方。
唧唧又有些擔(dān)心起來，拿不準(zhǔn)自己是否真的想要進(jìn)入到迷宮中去。片刻以后，他又拿起石塊在面前的墻上寫下一句話，盯著它看了許久：
如果你無所畏懼，你會怎樣做呢？
他對著這句話苦思冥想。
他知道，有時候，有所畏懼是有好處的。當(dāng)你害怕不做某些事情會使事情變得越來越糟糕時，恐懼心反而會激起你采取行動。但是，如果你因?yàn)檫^分害怕而不敢采取任何行動時，恐懼心就會變成前進(jìn)道路上最大的障礙。
他朝迷宮的右側(cè)瞧了瞧，心中生出了恐懼，因?yàn)樗麖奈吹竭^那里面。
然后，他深吸了一口氣，朝迷宮的右側(cè)緩步跑去，跑向那片未知的領(lǐng)地。
在探路的時候，唧唧有些擔(dān)心起來，一開始他還在奶酪C站猶豫了那么久，因?yàn)楹荛L時間沒有吃到奶酪了，他有些虛弱。現(xiàn)在，在迷宮中穿行要比以前更加吃力，花的時間更長。他打定主意，一旦再有機(jī)會，他一定要盡早走出舒適的環(huán)境去適應(yīng)事情的變化。他覺得立刻采取措施會使事情更容易一些。
想到這里，唧唧無力地微笑了一下，感嘆道：“遲做總比不做好。”
接下來的幾天里，唧唧在周圍偶而能夠找到一點(diǎn)奶酪，但都吃不了多久。他曾經(jīng)希望能夠找到足夠多的奶酪，帶回去給哼哼，鼓勵他離開原地，走進(jìn)迷宮。
但是，唧唧還是感到有些信心不足。他不得不承認(rèn)，身在迷宮中，他感到十分困惑。里面很多地方跟以前完全不一樣了。
他這樣想著朝前走去，他覺得自己已經(jīng)走了好遠(yuǎn)，卻又好像就要迷失在迂回曲折的走廊中了。這就好像是在走兩步退一步，對他來說這真是一種挑戰(zhàn)。不過他還是要承認(rèn)，回到迷宮中尋找奶酪，其實(shí)并不像他想象的那樣可怕。
隨著時間的流逝，他開始有些懷疑，找到新奶酪的希望是否能變成現(xiàn)實(shí)。有種幻覺，有時他懷疑是否自己嘴里的奶酪太多而嚼不過來，這時，想到自己根本沒有東西可嚼，他不禁啞然失笑。
每當(dāng)他開始感到泄氣的時候，他就提醒自己正在做什么。盡管現(xiàn)在很難受，但這樣總比呆在沒有奶酪的地方更實(shí)際。他在掌握控制權(quán)，而不是聽天由命、束手無策。
他還提醒自己，如果嗅嗅和匆匆能不斷前行，那么自己也能做到！
后來，唧唧回想起過去的事情，他終于明白奶酪C站的奶酪并不是像他曾經(jīng)相信的那樣一夜之間突然消失的。奶酪的數(shù)量是逐漸變少，直至完全消失的。而且，剩下的那一點(diǎn)也已經(jīng)陳舊變質(zhì)，美味喪失殆盡了。
那些陳舊的奶酪上面或許已經(jīng)生出了霉菌，只是他沒有注意到罷了。他還得承認(rèn)，只要他愿意，應(yīng)該能夠注意得到。可惜他當(dāng)初沒有留意這些變化。
唧唧還認(rèn)識到，如果他一直能夠察覺到這些變化而且能夠預(yù)見到這些變化，那么，這些變化就不會讓他感到吃驚。也許，嗅嗅和匆匆一直就是這樣做的。
他打定主意，從現(xiàn)在起，他要時刻保持警覺。他要期待著發(fā)生變化，而且還要去追尋變化。他應(yīng)該相信自己的直覺，能夠意識到何時發(fā)生變化，并且能夠做好準(zhǔn)備去適應(yīng)這些變化。
他停下來休息了一會兒，并在迷宮的墻上寫道：
經(jīng)常聞一聞你的奶酪，
你就會知道，
它什么時候開始變質(zhì)。
一段日子以后，好像已經(jīng)很久沒有找到奶酪了。這天，唧唧遇到了一個很大的奶酪站，看起來里面似乎裝滿了奶酪。他走進(jìn)去以后，卻發(fā)現(xiàn)里面空空如也，他失望至極。
“這種空空的感覺，對我來說太平常了。”他嘆息道，他覺得自己就快要放棄了。
“誰動了我的奶酪”的故事（7）
唧唧的體力正在慢慢地喪失。他知道自己迷路了，此刻他有些擔(dān)心自己能不能活下去。他想轉(zhuǎn)身回到奶酪C站去。回去后，至少哼哼還在那里，唧唧就不會孤單一人了。這時，他又問了自己一個同樣的問題：“如果我無所畏懼，我又會怎樣做呢？”
唧唧覺得他正在克服和超越自己的恐懼，但他又越來越經(jīng)常地感到害怕，害怕得甚至無法對自己承認(rèn)。他常常難以確定自己到底害怕什么，但是在目前這樣虛弱的狀況下，他知道，他只是害怕一個人獨(dú)自前行。唧唧其實(shí)并不清楚這一點(diǎn)，他只是在跟著這種感覺走，因?yàn)樗恢痹诒贿@些恐懼的念頭壓迫著。
唧唧想知道哼哼是否已經(jīng)離開了C站開始出發(fā)去尋找新的奶酪，或者是否仍然被自己的恐懼所嚇倒，仍舊裹足不前。這時，唧唧想起他在迷宮中度過的時光，那些他曾經(jīng)覺得是最美好的時光，其實(shí)正是他一個人穿行在迷宮中找尋奶酪的時候。
他又在墻上寫下了一句話，以便提醒自己。同時，這句話也是一個標(biāo)記，留給他的朋友哼哼，希望哼哼會跟上來。
朝新的方向前進(jìn)，
你會發(fā)現(xiàn)新的奶酪。
唧唧朝著黑暗深遂的通道中望去，又有一陣恐懼襲來。前面有些什么？是不是什么都沒有？或者更糟，里面潛藏著危險(xiǎn)？他開始想象各種可能降臨到他頭上的可怕的事情。他越想越怕，快把自己嚇?biāo)懒恕?/p>
忽然，他又覺得自己真是可笑。他意識到，他的畏懼只會使事情變得更糟糕。于是，他采取了當(dāng)他無所畏懼的時候會采取的行動。他朝一個新的方向跑去。
當(dāng)他跑向這條黑暗的走廊時，他笑了起來。唧唧還沒有認(rèn)識到這一點(diǎn)，但他覺得他的靈魂得到了豐富。他正在放開自己，對前景充滿了信心，盡管他并不能確切地知道前面究竟有些什么。
出乎意料，他開始對自己感到越來越滿意。“為什么我感覺這么好？”他不明白：“我并沒有找到奶酪，而且也不知道要到哪里去。”
不久，他就明白了他為什么會感覺這么好。
他停下腳步，在墻上寫道：
當(dāng)你超越了自己的恐懼時，
你就會感到輕松自在。
他認(rèn)識到，他原來是被自己的恐懼感給控制住了。如今朝一個新的方向邁進(jìn)，使他獲得了自由。
這時，從迷宮中吹來習(xí)習(xí)的涼風(fēng)，使人感到神清氣爽。他深吸了一口氣，不覺振作起來。一旦克服了自己的恐懼感，他覺得一切比原來自己想像的要好得多。
唧唧已經(jīng)很久沒有這種感覺了。他幾乎就快要忘記了這種感覺是多么的愜意。
為了使事情更順利地進(jìn)行，他又開始在頭腦中描繪一種景象。想像中，他在一種很棒的現(xiàn)實(shí)環(huán)境，坐在各種他喜歡的奶酪中間——有切達(dá)奶酪還有布里奶酪！他看見自己在吃許多他喜歡吃的奶酪。這樣的景象使他獲得一種享受，他想像著這些奶酪的滋味該是多么美啊！
這種享受新奶酪的情景，他看得越清楚，就越相信這會變成現(xiàn)實(shí)。現(xiàn)在，他有一種感覺，他就快要找到奶酪了。
他又在墻上寫道：
在我發(fā)現(xiàn)奶酪之前，
想像我正在享受奶酪，
這會幫我找到新的奶酪。
唧唧一直在想的是他將會得到什么，而不是考慮他會失去什么。
他不明白，為什么自己過去總是覺得變化會使事情變得更糟。而現(xiàn)在他認(rèn)識到，變化將會使事情變得更好。
“為什么以前我不明白這一點(diǎn)？”他反問自己。
“誰動了我的奶酪”的故事（8）
于是，他以更大的勇氣和力量快速靈敏地穿行在迷宮中。不久他就發(fā)現(xiàn)了一個奶酪站。當(dāng)他在迷宮的入口處發(fā)現(xiàn)一些新奶酪的碎屑時，他變得興奮起來。
這是一些他從未見過的奶酪，但看起來挺不錯。他嘗了嘗，真是美味啊！他吃掉了大部分能找到的小塊奶酪，把剩下的放進(jìn)口袋，以后也許可以和哼哼分享。他的體力也開始得到恢復(fù)。
他懷著興奮的心情走進(jìn)去。但是，讓他感到驚愕的是，里面竟然是空的。有人已經(jīng)來過這里，只留下了一些零星的小塊奶酪。
他認(rèn)識到，如果能早一點(diǎn)行動，他就很有可能早已在這里發(fā)現(xiàn)大量的新奶酪了。
唧唧決定回去，看看哼哼是否愿意和他一起行動。
在返回的路上，他停下來，在墻上寫道：
越早放棄舊的奶酪，
你就會越早發(fā)現(xiàn)新的奶酪。
不久，唧唧就回到了奶酪C站，找到了哼哼。他給哼哼一些新的小塊奶酪，但被拒絕了。
哼哼很感激朋友的心意，但是他說：“我不喜歡新奶酪，這不是我習(xí)慣吃的那一種。我只要我自己的奶酪回來。除非可以得到我想要的東西，否則我是不會改變主意的。”
唧唧失望地?fù)u了搖頭，不情愿地一個人踏上了自己的旅程。當(dāng)走到他到達(dá)過的迷宮最深處時，他懷念起他的朋友來，但他明白，他喜歡的還是他的探險(xiǎn)過程。雖然以前他想自己希望的是得到充足的新奶酪，但現(xiàn)在他清楚使自己快樂的并不僅僅是奶酪而已。
他高興的是，他不再受自己的恐懼感的驅(qū)使。他喜歡自己正在做的事情。
明白了這一點(diǎn)，唧唧不再像在奶酪C站時，在沒有奶酪的日子里感到那樣虛弱了。他知道，他不會再讓恐懼感阻礙自己。他選擇了一個新的方向，他的身心得到了滋養(yǎng)，體力得到加強(qiáng)。
現(xiàn)在，他覺得，找到自己想要的東西只是一個時間問題。事實(shí)上，他感到他已經(jīng)找到了他一直在尋找的東西。
當(dāng)他認(rèn)識到這一點(diǎn)的時候，他不禁微笑起來，并在墻上寫道：
在迷宮中搜尋
比停留在
沒有奶酪的地方更安全。
唧唧還認(rèn)識到，就像他曾經(jīng)體會過的那樣，你所害怕的東西根本沒有你想像的那樣糟糕，在你心里形成的恐懼比你的實(shí)際處境要更壞。他曾經(jīng)是如此害怕找不到新的奶酪，以致于他根本不想開始去尋找。然而一旦開始尋找的旅程，他就發(fā)現(xiàn)迷宮的走廊中有足夠的奶酪使他繼續(xù)找下去。現(xiàn)在，他期待著找到更多的奶酪。只要朝前看，他就會因?yàn)橛兴诖d奮起來。
他過去的思想被恐懼和憂慮蒙蔽了。過去考慮的總是沒有奶酪，或者沒有可以維持足夠長時間的奶酪。以前總是覺得會把事情做錯，而不是考慮把事情做好。
在離開奶酪C站以后的日子里，一切都改變了。
過去他習(xí)慣于認(rèn)為，奶酪絕不會被拿走，改變總是不對的。
現(xiàn)在，他知道，變化會不斷地發(fā)生，這是很自然的事情，不管你是否希望如此。只有當(dāng)你不希望變化，也不想追尋變化的時候，變化才會讓你感到吃驚。
當(dāng)唧唧認(rèn)識到自己的信念發(fā)生了改變時，他停下來，在墻上寫道：
陳舊的信念
不會幫助你
找到新的奶酪。
唧唧還沒有找到奶酪，但在迷宮中穿行的時候，唧唧在想自己從中學(xué)到了什么。
他意識到，他的新的信念鼓舞著他采取新的行動。他的行為再不同于以往，再也不是總要回到同一個沒有奶酪的地方。
他知道，當(dāng)你改變了自己的信念，你也就改變了自己的行為。
你可以相信，變化對你有害，你可以拒絕它；或者，你會相信尋找新奶酪對你有好處，你會擁抱這種變化。
這些都取決于你選擇相信什么。
他在墻上寫道：
當(dāng)你發(fā)現(xiàn)
你會找到新的奶酪
并且能夠享用它時，
你就會改變你的路線。
“誰動了我的奶酪”的故事（9）
唧唧知道，如果他能夠早一些離開奶酪C站，早一點(diǎn)應(yīng)對這些變化，他現(xiàn)在的狀況就會更好一些。他的身體會更強(qiáng)壯，精神也會更堅(jiān)強(qiáng)，會更好地去迎接挑戰(zhàn)——尋找新奶酪的挑戰(zhàn)。事實(shí)上，如果他不是浪費(fèi)時間，否認(rèn)已經(jīng)發(fā)生了的變化，如果他能夠期待改變，也許他已經(jīng)找到奶酪了。
他再一次運(yùn)用自己的想像力，看見自己正在發(fā)現(xiàn)和品嘗新奶酪。他決定到更多的地方去，去迷宮中那些他還沒有到過的地方。在這些地方，他偶爾找到一些小塊的奶酪。唧唧又開始恢復(fù)了體力和信心。
當(dāng)他回顧自己是怎么走過來的時候，他很高興他在很多經(jīng)過的地放的墻上都留下了字跡。他相信如果哼哼決定離開奶酪C站的話，這就是留給哼哼的路標(biāo)，能幫助哼哼穿過迷宮。
唧唧只是希望自己在朝著正確的方向前進(jìn)。他還想到了這種可能性——哼哼將會讀到墻上的字跡，并且循著它找到出路。
于是他又把這段時間以來他一直在思索著的心得寫在了墻上：
盡早注意細(xì)小的變化，
這將有助于你
適應(yīng)即將來臨的更大的變化。
此時此刻，唧唧早已把過去拋在腦后，正在適應(yīng)現(xiàn)在。
他繼續(xù)以更充沛的體力和更快的速度穿越迷宮。不久，期待已久的事情終于發(fā)生了。
當(dāng)他感覺一直在迷宮中前行，而且好像永遠(yuǎn)都會在迷宮中前行的時候，他的旅程——至少是現(xiàn)階段的旅程——即將愉快地結(jié)束了。
唧唧正沿著一條走廊前進(jìn)，這是一條他從未到過的走廊，拐過一個彎，在他的面前出現(xiàn)了奶酪N站，這里堆滿了新鮮的奶酪！
當(dāng)他走進(jìn)奶酪N站的時候 ，他被眼前的景象驚呆了。到處都是堆積如山的奶酪，他從未見過如此巨大的豐盛的貯藏。他并不完全認(rèn)識這些奶酪，有些品種是全新的。
眼前的景象太壯觀了，他猶豫了一會兒，不能肯定這是否是真的，或許這只是他的幻覺。直到他看見了他的老朋友——嗅嗅和匆匆，他才相信這一切是真的。
嗅嗅沖唧唧點(diǎn)了點(diǎn)頭，表示歡迎，匆匆則朝他揮了揮爪子。他們胖胖的小肚子表明，他們在這里已經(jīng)有一段時間了。
唧唧很快向他們打了招呼，然后趕緊把他喜歡的各種奶酪都咬了一口。他脫掉鞋子，把兩只鞋子系在一起，然后掛在脖子上，以便需要的時候能夠迅速找到它們。嗅嗅和匆匆會心地笑了，并且贊許地點(diǎn)了點(diǎn)頭。而唧唧已經(jīng)一頭扎進(jìn)了奶酪堆中。一頓飽餐之后，唧唧高興地舉起一塊新鮮的奶酪歡呼：“呼啦，變化萬歲！”
唧唧享受新奶酪的同時，也在反思自己學(xué)到了什么。
他認(rèn)識到，當(dāng)他害怕變化的時候，他一直受困于對那已不存在的舊奶酪的幻想而無法自撥。
那又是什么使他發(fā)生了改變呢？難道是害怕餓死的恐懼？想到這里，唧唧笑了，他心里明白，這種恐懼當(dāng)然起過很大的作用。
唧唧忽然發(fā)現(xiàn)，他已經(jīng)學(xué)會自嘲了，而當(dāng)人們學(xué)會自嘲，能夠嘲笑自己的愚蠢和所做的錯事時，他就在開始改變了。他甚至覺得，改變自己的最快方式，就是坦然嘲笑自己的愚笨——這樣，你就能對過往云煙輕松釋然，迅速行動起來，直面變化。
唧唧相信他從他的老鼠朋友嗅嗅和匆匆那里，學(xué)到了一些有用的東西——不畏懼改變，勇往直前。老鼠朋友們簡單地對待生活，他們不會反復(fù)分析，也不會把事情搞得很復(fù)雜。當(dāng)形勢發(fā)生改變，奶酪被移走了的時候，他們會迅速隨之改變，循著奶酪移動的方向而移動。唧唧告訴自己，要牢記這些體會。
唧唧相信擁有了這些體會，憑借自己聰慧的頭腦，再遇到任何變化時他一定能做得比老鼠朋友更好。
他的頭腦里出現(xiàn)了清晰的圖畫，他的生活將會變得更美好，而且他還會在迷宮中發(fā)現(xiàn)一些更好的東西。
唧唧不斷地反思自己過去犯下的錯誤，他要汲取這些經(jīng)驗(yàn)教訓(xùn)，去構(gòu)劃自己的未來。他知道，自己完全可以通過總結(jié)和學(xué)習(xí)，掌握如何應(yīng)對變化：
首先要更清醒地認(rèn)識到，有時需要簡單地看待問題，以及靈敏快速地行動。
你不必把事情過分復(fù)雜化，或者一味地讓那些驚恐的念頭使自己慌亂。
其次必須要善于發(fā)現(xiàn)一開始發(fā)生的那些細(xì)微的變化，以便你為即將來臨的更大的變化做好準(zhǔn)備。
他知道，他需要做出更快的調(diào)整。因?yàn)椋绻荒芗皶r調(diào)整自己，就可能永遠(yuǎn)找不到屬于自己的奶酪。
還有一點(diǎn)必須承認(rèn)，那就是阻止你發(fā)生改變的最大的制約因素就是你自己。只有自己發(fā)生了改變，事情才會開始好轉(zhuǎn)。
“誰動了我的奶酪”的故事（10）
最重要的是，新奶酪始終總是存在于某個地方，不管你是否已經(jīng)意識到了它的存在。只有當(dāng)你克服了自己的恐懼念頭，并且勇于走出久已習(xí)慣的生活，去享受冒險(xiǎn)帶來的喜悅的時候，你才會得到新奶酪?guī)Ыo你的報(bào)償和獎賞。
唧唧還認(rèn)識到，有些畏懼是需要加以認(rèn)真對待的，它會幫助你避開真正的危險(xiǎn)。但絕大部分的恐懼都是不明智的，它們只會在你需要改變的時候，使你回避這種改變。
唧唧曾經(jīng)那樣地懼怕改變，他真的希望生活能夠永遠(yuǎn)按照原有的樣子繼續(xù)，但現(xiàn)在他意識到，生活并不會遵從某個人的愿望發(fā)展。改變隨時有可能降臨，但積極地面對改變卻會讓你發(fā)現(xiàn)更好的奶酪，真的是塞翁失馬，焉知非福。
唧唧已經(jīng)看到了變化更好的一面。
當(dāng)他回想起這些自己所學(xué)到的東西時，他不由得想起了他的朋友哼哼。他不知道哼哼是否讀到了那些他在奶酪C站和迷宮各個角落墻上的留言，不知道哼哼是否已經(jīng)走出了迷宮。
哼哼是否已經(jīng)決定放開已經(jīng)失去的過去并開始行動？他是否已經(jīng)重新回到迷宮中，并且發(fā)現(xiàn)了能使他的生活變得更好的東西？
或者，他因?yàn)椴豢细淖儯€在那里遲疑不前？
唧唧在考慮回到奶酪C站去，看是否能找到哼哼——但首先得肯定自己能找到回來的路。如果找到了哼哼，他會把自己學(xué)到的東西告訴他，幫助他擺脫困境。但唧唧又想起已經(jīng)試圖改變過他的失敗經(jīng)歷。
哼哼必須自己發(fā)現(xiàn)適合自己的道路，擺脫安逸，超越恐懼。沒有人可以代替他做到這一點(diǎn)，或者告訴他應(yīng)該怎樣去做。他必須邁出第一步，否則他永遠(yuǎn)不會看到改變自己所帶來的好處。
唧唧知道自己已經(jīng)給哼哼留下了足夠的標(biāo)記，只要他能夠邁出第一步，讀到墻上的字跡，他就會找到出路。
于是唧唧打消了回C站的念頭，他站起來走到奶酪N站最大的一面墻前，把他一路上得到的心得體會的要點(diǎn)寫了下來。他拿起一塊很大的奶酪，這是他見過的奶酪中最大的一塊。唧唧品嘗著新鮮的奶酪，望著自己寫下的體會，臉上綻出了微笑：
奶酪墻上的話
變化總是在發(fā)生
他們總是不斷地拿走你地奶酪。
預(yù)見變化
隨時做好奶酪被拿走的準(zhǔn)備
追蹤變化
經(jīng)常聞一聞你的奶酪，
以便知道它們呢什么時候開始變質(zhì)。
唧唧相信擁有了這些體會，憑借自己聰慧的頭腦，再遇到任何變化時他一定能做得比老鼠朋友更好。
他的頭腦里出現(xiàn)了清晰的圖畫，他的生活將會變得更美好，而且他還會在迷宮中發(fā)現(xiàn)一些更好的東西。
唧唧不斷地反思自己過去犯下的錯誤，他要汲取這些經(jīng)驗(yàn)教訓(xùn)，去構(gòu)劃自己的未來。他知道，自己完全可以通過總結(jié)和學(xué)習(xí)，掌握如何應(yīng)對變化：
首先要更清醒地認(rèn)識到，有時需要簡單地看待問題，以及靈敏快速地行動。
你不必把事情過分復(fù)雜化，或者一味地讓那些驚恐的念頭使自己慌亂。
其次必須要善于發(fā)現(xiàn)一開始發(fā)生的那些細(xì)微的變化，以便你為即將來臨的更大的變化做好準(zhǔn)備。
他知道，他需要做出更快的調(diào)整。因?yàn)椋绻荒芗皶r調(diào)整自己，就可能永遠(yuǎn)找不到屬于自己的奶酪。
還有一點(diǎn)必須承認(rèn)，那就是阻止你發(fā)生改變的最大的制約因素就是你自己。只有自己發(fā)生了改變，事情才會開始好轉(zhuǎn)。
最重要的是，新奶酪始終總是存在于某個地方，不管你是否已經(jīng)意識到了它的存在。只有當(dāng)你克服了自己的恐懼念頭，并且勇于走出久已習(xí)慣的生活，去享受冒險(xiǎn)帶來的喜悅的時候，你才會得到新奶酪?guī)Ыo你的報(bào)償和獎賞。
唧唧還認(rèn)識到，有些畏懼是需要加以認(rèn)真對待的，它會幫助你避開真正的危險(xiǎn)。但絕大部分的恐懼都是不明智的，它們只會在你需要改變的時候，使你回避這種改變。
“誰動了我的奶酪”的故事（11）
唧唧曾經(jīng)那樣地懼怕改變，他真的希望生活能夠永遠(yuǎn)按照原有的樣子繼續(xù)，但現(xiàn)在他意識到，生活并不會遵從某個人的愿望發(fā)展。改變隨時有可能降臨，但積極地面對改變卻會讓你發(fā)現(xiàn)更好的奶酪，真的是塞翁失馬，焉知非福。
唧唧已經(jīng)看到了變化更好的一面。
當(dāng)他回想起這些自己所學(xué)到的東西時，他不由得想起了他的朋友哼哼。他不知道哼哼是否讀到了那些他在奶酪C站和迷宮各個角落墻上的留言，不知道哼哼是否已經(jīng)走出了迷宮。
哼哼是否已經(jīng)決定放開已經(jīng)失去的過去并開始行動？他是否已經(jīng)重新回到迷宮中，并且發(fā)現(xiàn)了能使他的生活變得更好的東西？
或者，他因?yàn)椴豢细淖儯€在那里遲疑不前？
唧唧在考慮回到奶酪C站去，看是否能找到哼哼——但首先得肯定自己能找到回來的路。如果找到了哼哼，他會把自己學(xué)到的東西告訴他，幫助他擺脫困境。但唧唧又想起已經(jīng)試圖改變過他的失敗經(jīng)歷。
哼哼必須自己發(fā)現(xiàn)適合自己的道路，擺脫安逸，超越恐懼。沒有人可以代替他做到這一點(diǎn)，或者告訴他應(yīng)該怎樣去做。他必須邁出第一步，否則他永遠(yuǎn)不會看到改變自己所帶來的好處。
唧唧知道自己已經(jīng)給哼哼留下了足夠的標(biāo)記，只要他能夠邁出第一步，讀到墻上的字跡，他就會找到出路。
于是唧唧打消了回C站的念頭，他站起來走到奶酪N站最大的一面墻前，把他一路上得到的心得體會的要點(diǎn)寫了下來。他拿起一塊很大的奶酪，這是他見過的奶酪中最大的一塊。唧唧品嘗著新鮮的奶酪，望著自己寫下的體會，臉上綻出了微笑：
奶酪墻上的話
變化總是在發(fā)生
他們總是不斷地拿走你地奶酪。
預(yù)見變化
隨時做好奶酪被拿走的準(zhǔn)備
追蹤變化
經(jīng)常聞一聞你的奶酪，
以便知道它們呢什么時候開始變質(zhì)。
盡快適應(yīng)變化
越早放棄舊的奶酪，
你就會越早享用到新的奶酪。
改變
隨著奶酪的變化而變化。
享受變化！
嘗試去冒險(xiǎn)，去享受新奶酪的美味！
做好迅速變化的準(zhǔn)備
不斷地去享受變化
記住：他們?nèi)詴粩嗟啬米吣愕哪汤摇?/p>
唧唧在想，自從他在奶酪C站和哼哼分道揚(yáng)鑣以來已經(jīng)有多久了。他知道自己前進(jìn)了一大步，但他也很清楚，如果他過分沉溺于N區(qū)的安逸生活之中，他就會很快滑落到原來的困境。所以，他每天都仔細(xì)檢查奶酪N站的情況。他在做一切力所能及的事情，以盡量避免被意料之外的變化打個措手不及。
當(dāng)他還有大量的奶酪貯備時，他就開始經(jīng)常到外面的迷宮中去，探索新的領(lǐng)地，以便使自己與周圍發(fā)生的變化隨時保持聯(lián)系。現(xiàn)在的他非常明白，了解各種實(shí)際的選擇，要比呆在舒適的環(huán)境里把自己孤立起來安全得多。
“窸窸窣窣”，他聽到了什么，唧唧豎起耳朵聽了聽，他覺得是從迷宮里傳來的走動的聲音。這聲音漸漸大起來，他知道有人正向著這邊跑來。
會是哼哼到了嗎？他會循著那個彎轉(zhuǎn)過來嗎？
唧唧念了幾句祈禱語，他真的希望——像他以前曾多次希望的那樣——也許，他的朋友終于能夠……
隨著奶酪的變化而變化，
并享受變化！
結(jié)局……
或者是新的開始？
posted @
2010-10-17 19:14 tovep 閱讀(191) |
評論 (3) |
編輯 收藏
完全用例子告訴你！不過首先你要清楚問題問的是什么？
首先，因該明白String是引用類型，是一個類，是一個不可變的類，并且有著特殊的作用。
String 只能復(fù)制一次！復(fù)制后不可改變！
String s = new String（“abc”）；
s = new String（“cba”）；
以上的代碼并不是對s進(jìn)行賦值，而是將“abc”的引用地址，從新賦給了s；
這個過程的內(nèi)存是怎么分配的呢？
有幾個問題要給大家說明一下：
1.String s = new String("abc");
//在運(yùn)行時涉及幾個String實(shí)例？
答案：兩個，一個是字符串字面量"xyz"所對應(yīng)的、駐留（intern）在一個全局共享的字符串常量池中的實(shí)例，另一個是通過new
String(String)創(chuàng)建并初始化的、內(nèi)容與"xyz"相同的實(shí)例。
2.String s = new String("abc");//
涉及用戶聲明的幾個String類型的變量?
答案：一個，就一個String s 。
3.String s = null;
Java里變量就是變量，引用類型的變量只是對某個對象實(shí)例或者null的引用，不是實(shí)例本身。聲明變量的個數(shù)跟創(chuàng)建實(shí)例的個數(shù)沒有必然關(guān)系。
4.String s = new String("abc");
//創(chuàng)建了幾個String Object？
答案：兩個，一個是“abc”——這是一個匿名對象；一個是指向“abc”的引用對象s——這個是將匿名對象的地址賦給了s。
下面我們來看一段代碼：
public class text{
public static void main(String[] args){
//定義一個str
String str = new String("abc");
//定義一個str1
String str1 = "abc";
//定義一個str2
String str2 = "abc";
System.out.println(str1 == str);
System.out.println(str2 == str1);
}
}
運(yùn)行結(jié)果是什么呢？
為什么第一個運(yùn)行結(jié)果是false呢？ 在這里"==" 其實(shí)比較的是他們在堆內(nèi)存中的地址，因?yàn)閟tr 和 str1 在堆內(nèi)存中的地址不同的所以運(yùn)行結(jié)果是false；
為什么第二個運(yùn)行結(jié)果是true呢？ 在這要說明一下，Sting是一個共享式輸出類型，在內(nèi)存中有一個String pool 用于存放String類型中相同的值。所以在給str2賦值的時候，JVM會在String pool中查找是否有與其所賦的值相等，如果相等就將相等的值的地址賦給str2，如果沒有則在String pool中新開辟一塊控件存放str2的內(nèi)容。
這是我現(xiàn)在對String的一些理解，如果有錯誤，希望大家指出來，在這里謝謝大家了！
posted @
2010-10-16 23:51 tovep 閱讀(379) |
評論 (4) |
編輯 收藏