======================================================================================

这仅仅是一个很简单的医院挂号系统，虽然涉及到一些C/S架构思想，但并没有按照C/S架构去实现

还请大家见谅！！！

======================================================================================



**************************************************************************************

首先，新建一些辅助的类。
       比如：Patients类，用于存放挂号的病人；Init类，用于预先存储一些病人，这样就可以方
便的测试Doctor类；还有一个Server类，相当于一个服务器。

**************************************************************************************


Patients类


package Queue;
        /**

                定义一个Patients类,这个类从写了toString方法，可以方便的进行输出！

        */


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
         * 向一个队列中加入一些病人,对医生的客户端进行测试！！！
         *
         *      
         */
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类相当于服务器,挂号客户端增加一个病人的话,相应的存储在这里,可以供Doctor调用！！！

        */

import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;

public class Server {
   
   
    //这是病人的队列
    Queue<Patients> patQueue = new LinkedList<Patients>();
    //String 是医生的代号 ；Queue 是病人的队列
    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;

        /**

                这是一个挂号客户端,对会诊的病人进行挂号,以及方便挂号的病人容易的挂到自己想要的专家！！！

        */

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("专家挂号系统");     
        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();  
    }

}



运行结果如下图：





**************************************************************************************


最后是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("医生会诊系统");     
        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();  
    }
}


运行的结果如下图：






**************************************************************************************


让大家见笑了！

曾以为QQ很神秘

后来觉得QQ很简单，感觉无非就是一个QQ客户端发送一个消息到服务器，然后服务器将消息发送到指定QQ客户端

现在把当时想的过程画了下来

（大家别笑话我啊，当时真的就是这么想的，感觉很简单——其实，当自己去实现的时候，真的很复杂！！！）


还写了一些代码，不过还不能具体运行，仅仅是一个框架：

我把这些都放在QQ包内：

*****************************************************************
首先，定义了一个客户端接口——可能有点罗嗦，没有完全实现接口的作用

package QQ;

        /**

            这个接口的作用是用来实现客户端向服务器发送消息的接口。

        */

public interface QQClientInterface {
   
    public void SendServerMessage();
    public QQMessage ToFromQQServer();

}


****************************************************************

================================================================

****************************************************************

这是一个服务器的接口——貌似和上面的接口重复了！！！


package QQ;

        /**

                用来实现QQ服务器向QQ客户端发送消息，和接受QQ客户端发送来的消息

        */

public interface QQServerInterface {
   
    public QQMessage SendMessageToQQClient(String QQName);
    public void GetMessageFromQQClient();

}

****************************************************************

================================================================

****************************************************************

这里插入一个消息类QQMessage

package QQ;

    /**

        这个类专门用来存放QQClient和QQserver发送的消息。

     */

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;
    }

   
****************************************************************

================================================================

****************************************************************

下面可以重点~\(≧▽≦)/~啦啦啦

这是QQ客户端的代码：


package QQ;

public class QQClient implements QQClientInterface {

    private String QQName;
    private QQMessage message;
   

    public void SendServerMessage() {
       
        /**
       
                用来实现对QQ服务器发送消息(调用QQ服务器的接受消息的方法，将消息发送到服务器)
         
        */   
   
       
       
       
        }




    public QQMessage ToFromQQServer() {
       
        /**
       
                隔一段时间向服务器发送一个消息，带有自己QQName的消息，然后QQ服务器检索，是否
                有消息要传给这个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;
    }
   
   

}


****************************************************************

================================================================

****************************************************************

最后是服务器端的代码：

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要发送消息必须满足两个条件：
                
                             1. QQ客户端将自己的QQName发送给QQServer，然后根据自己的QQNameQQ服务器开始遍历qqMessage；
                             2. qqMessage的Values不是null。
                            
                     如果QQMessage不为空，则将自己的V发送给QQName,否则返回Null；
         
        */
       
        return null;
    }



    public void GetMessageFromQQClient() {

        /**
         
         QQServer接受消息,并将消息存放在qqMessage中
        
 
        */
       
    }

}


****************************************************************
****************************************************************

暂时还没写出一个简单QQ程序，大家尽心等待！我一定会写出一个让自己满意的即时通讯程序！










所谓的抽象类就是一个类前加上一个abstract修饰的类，我觉得抽象类更像一个特殊的类，虽然抽象类和类也有些不同之处。

抽象类和类的区别：

    抽象——就是一种具有共同属性的集体概括。

抽象类中可以有抽象方法，也可以其他的方法及属性；

抽象类和类的最大区别在于： 抽象类可以有抽象方法，但类中一定没有抽象方法，只要一个类有抽象方法那么这个类一定是抽象方法，抽象方法

是由abstract修饰的方法，但在抽象类中并没有去定义这个方法，这个抽象方法必须在它的子类中得到定义——这是必须的！ 从这里可以看出，

抽象类的作用是建立在继承之上的。

另外需要注意的是：抽象类中不一定有抽象方法，但有抽象方法的类一定是抽象类！

继承抽象类的子类，必须实现父类（这是抽象类）中所有的抽象方法！

其他的，抽象类和普通的类没有区别！

暂且不举例子，胃痛，今天就到这里！实在撑不住了！


   this 相当于本类，说白了就是“自己的”。
   super 指的是父类，说白了就是自己继承的类。

面向对象的三大特征是：封装，继承和多态！

封装：

    所谓的封装就是将类包装起来，可以理解为  将一个类包装成一个黑箱子，外部对内部是不可见的！

但这个箱子（封装的类）有若干个接口，这些接口可以向这个黑箱子传送一些数据，这个箱子做一些处理，然后从另外的接口（也可以从输入的接

口）接受处理完的信息。

说白了，封装就是将一个类包装起来，使类内部数据对外不可见，这样的话，这个类就更安全了！只要你从一个接口输入信心，就可以从另外的接口（也可以从输入的接口）接受你想要的处理完的数据！


继承：

    所谓的继承就是将一个父类（被继承的类）的全部（包括属性和方法）包含在子类（继承的类）中，这样做可以减少代码量，同时也可以将

具有某些相同属性的类，先写出一个父类，然后继承，在子类中，子类可以有自己的属性和方法。

举一个很经典的例子：

          父类就相当于你的父亲，子类就相当于你。（基因就相当于类中方法，属性就是你的姓名啊等等）你父亲的基因你都有，但你又从你

母亲那继承了很多基因，但在JAVA中只允许单程继承，也就是你有且只有一个父类，但子类中确包含了父类中没有的属性和方法，你可以这么理

解，就是你继承了你“母类”属性和方法——注意：JAVA中并没有“母类”。



多态：
 
    多态是什么呢？ 多态多态就是有很多状态。

    比如还拿上面那个经典的例子来说，父类中的方法你也有，但你可以将这个方法的执行过程按照自己的方式写出来！这样呢，这个方法才真

正属于你（举个小例子：就是你的父亲可以吃饭，你也可以吃饭，但你们喜欢吃什么，喜欢怎么吃，吃多少，肯定不一样！）。在子类中要从写

自己的方法，子类中方法的名字，参数以及参数属性的顺序必须相同。

另外，还有一种多态形式是表现在一个类中的构造方法，他们的方法名肯定相同且和子类的类名相同，但构造方法的参数个数，顺序和类型必须

有一样是不相同的！


按我目前的理解，仅仅能解释成这样！如果以后有新的理解，一定会更新这篇博客！






这是一个用SWT做的用户登陆程序：

----------------------可视化用户登陆系统----------------------------



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();
        //创建一个主窗口
        final Shell window = new Shell();
        //打开主窗口大小
        window.setBounds(30, 75, 300, 400);
        //设置主窗口的标题
        window.setText("登陆界面");
   
        //创建触发按钮以及按钮的显示文字和大小位置
        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);
       
        //创建输入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);
       
        //创建标签
        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){
                //创建一个adm数组
                Admin[] admin = new Admin[3];
               
                //实例化三个账号
                admin[0] = new Admin("admin", "admin");
                admin[1] = new Admin("admin1", "pastNumber");
                admin[2] = new Admin("admin2", "pastNumber");
               
               
                //新建一个布尔型和整型数据，布尔值 用于判断，整型判断是那个账号登陆
                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()){//如果主窗体没有关闭则一直循环
            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;
    }
   
   
   
}

=========================程序的运行结果如下==============================
打开时，用户的登陆界面




当输入的账号密码都正确时：




当密码或者账号不正确：





希望这个程序对大家有所帮助！



-----------------------用户登陆原----------------------------


public class Check {

    public static void main(String[] args) {

        //创建一个adm数组
        Admin[] adm = new Admin[3];
       
        //三个账号
        adm[0] = new Admin("admin", "pastNumber");
        adm[1] = new Admin("admin1", "pastNumber");
        adm[2] = new Admin("admin2", "pastNumber");
       
        //使用标准输入流函数，从键盘输入一些信息
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入你的账号：");
       
        //将输入的账号放入putName
        String putName = scan.next();
        System.out.println("请输入你的账号密码：");
       
        //将输入的密码放入普通putPassNumber中
        String putPassNumber = scan.next();
       
        //新建一个布尔型和整型数据，布尔值 用于判断，整型判断是那个账号登陆
        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;
    }

}

运行结果为：






当密码或者账号不正确的时候输出结果是：

芝加哥的同学聚会

芝加哥一个阳光明明媚的星期天，许多过去在学校曾是好朋友的同班同学聚在一起搞午餐会。前一天晚上，他们刚参加完全体高中同学的聚会。在一阵打闹嬉笑和丰盛和午餐后，他们坐下来开始了饶有兴致的交谈，希望彼此多了解一些分别后的生活经历。

安杰拉曾是班上最受欢迎的人之一，她第一个发表感慨：“生活真的是跟我们做学生时想像的完全不一样，变化太多了。”

“的确如此！”内森附和道。内森正如大家所预料的那样，毕业后就进入了他的家族企业。这家企业的经营模式经年未变，在当地人的记忆中，那可是一家历史悠久的老字号了。因此，当内森若有所思地附和着安杰拉，并发出如此感叹时，大家都感到有些吃惊。

内森好像并未注意到大家的诧异，表情忧郁地接着说：“你们是否注意到，当周围的事情已经发生变化时，我们却不想对自己有所改变。”

卡洛斯接着说道：“我们拒绝改变，是因为我们害怕改变。”

杰西卡接过他的话：“噢，卡洛斯，你可是学校的足球队长，我们心目中的英雄，我从没想过还有什么东西可以让你害怕的。”

大家都笑了起来。他们都意识到，尽管大家毕业后都在各自不同的方面发展——从在家里工作到在外经营管理公司——但好像都有着类似的感觉——害怕改变。


这些年来，每个人都试图应对发生在生活中的各种意想不到的变化。但大家都承认，他们找不到一种很好的应对办法。

这时，迈克尔发话了：“我过去也一直害怕改变，直到有一天，我们的生意出现了一个重大的变故，但我们公司所有的人都不知道该怎样去应付，由于我们没能及时做出调整，使我们几乎丢掉了全部的生意。”

“后来，”迈克尔继续讲道：“我听到了一个故事，这个故事使一切都改变了。”

“此话怎讲？”内森问道。

“喔，因为这个故事改变了我害怕改变的个性以及我对变化的看法——从害怕失去某些东西到期待获得某些东西——它教会我如何去做。从那以后，我的一切都迅速地改善了——无论工作还是生活。”

“是什么故事这么神奇？”好几个人异口同声地问道。

“一开始，我被这个故事显而易见的简单给苦恼了，它就像我们小时候听腻了的那些寓言故事一样。”

“再后来，我把这个故事告诉我们公司里的其他人，其他人又讲给其他人听。很快，公司里的业务有了明显的改进，因为我们大家都能及时地做出很好的调整以随时应对变化。与我的感受一样，许多人都说，这个故事使他们的个人生活大受裨益。”

“当然，也有人说他们从中没有得到什么，他们或者是知道这样的教训而且已经领教多次了。 或者，更普遍的是，他们觉得自己已经懂得够多，不需要再学习什么了。他们甚至假装看不到如此多的人正在从中受益。”

“我的一位有些呆板的高级主管就说，读这个故事只是浪费时间。然而大家都取笑他，把他比做故事中的一个角色——从不学习新的东西而且从不愿意改变。”
安杰拉有些迫不及待：“别卖关子了，这究竟是一个什么样的故事？”

“故事的名字叫作‘谁动了我的奶酪’。”

大家都哄笑起来。卡洛斯说：“我想仅凭这个名字，我就已经喜欢上这个故事了。你能讲给我们听听吗？或许我们也会从中有所收获。”

“当然，”迈克尔答道：“我非常愿意把这个故事讲给你们听。它并不长。”于是他开始给大家讲述这个故事。

“谁动了我的奶酪”的故事（1）

从前，在一个遥远的地方，住着四个小家伙。为了填饱肚子和享受乐趣，他们每天在不远处的一座奇妙的迷宫里跑来跑去，在那里寻找一种叫做“奶酪”的黄橙橙、香喷喷的食物。

有两个小家伙是老鼠，一个叫“嗅嗅”，另一个叫“匆匆”。另外两个家伙则是小矮人，和老鼠一般大小，但和人一个模样，而且他们的行为也和我们今天的人类差不多。他俩的名字，一个叫“哼哼”，另一个叫“唧唧”。

由于他们四个实在太小了，他们在干什么当然不太会引起旁人的注意。但如果你凑近去仔细观察，你会发现许多令人惊奇不已的事情！

两个老鼠和两个小矮人每天都在迷宫中度过，在其中寻找他们各自喜欢的奶酪。嗅嗅、匆匆的大脑和其他啮齿类动物的差不多一样简单，但他们有很好的直觉。和别的老鼠一样，他们喜欢的是那种适合啃咬的、硬一点的奶酪。

而那两个小矮人，哼哼和唧唧，则靠脑袋行事，他们的脑袋里装满了各种信念和情感。他们要找的是一种带字母“C”的奶酪。他们相信，这样的奶酪会给他们带来幸福，使他们成功。

尽管小老鼠和小矮人的目标各不相同，但他们做的事情是差不多的。每天早上，他们会各自穿上运动服和慢跑鞋，离开他们的小房子，跑进迷宫寻找他们各自钟爱的奶酪。

迷宫中有许多曲折的走廊和好像蜂窝似的房间，其中的一些房间里藏着美味的奶酪，但更多的地方则是黑暗的角落和隐蔽的死胡同，任何人走进去都很容易迷路。

同时，这座迷宫还有一种神奇的力量，对那些找到出路的人，它能使他们享受到美好的生活。

两个老鼠，嗅嗅和匆匆，总是运用简单低效的反复尝试的办法找奶酪。他们跑进一条走廊，如果走廊里的房间都是空的，他们就返回来，再去另一条走廊搜 寻。没有奶酪的走廊他们都会记住。就这样，很快地他们从一个地方找到另一个地方。嗅嗅可以用他那了不起的鼻子嗅出奶酪的大致方向，匆匆则跑在前面开路。然 而迷宫太大太复杂，如你所料，他们经常会迷路，离开正道走错了方向，有时甚至还会撞到墙上。

而两个小矮人，哼哼和唧唧，则运用他们思考的能力，从过去的经验中学习。他们靠复杂的脑筋，搞出了一套复杂的寻找奶酪的方法。

哼哼和唧唧的方法比他们的老鼠朋友要高效，因此他们走进死胡同和碰壁的情况要比小老鼠们少得多。他们也为此而时常沾沾自喜很是得意，甚至有些看不起 低智商的老鼠朋友。然而有时候，人类复杂的头脑所带来的复杂感情也会战胜他们理性思维，使他们看问题的眼光变得黯淡起来。这也使得他们在迷宫中的生活更加 复杂化，也更具有挑战性了。

但是不管怎样，这四个家伙——嗅嗅和匆匆，哼哼和唧唧，都以他们各自的方式不懈地追寻着他们想要得到的东西。最后，终于有一天，在某个走廊的尽头，在奶酪C站，他们都找到了自己想要的奶酪。

这里真是一个天堂，四个小家伙被眼前的情景惊呆了，无数各式各样的奶酪堆积如山，闪着诱人的光亮。四个小家伙呆了半晌，然后疯了般地冲进奶酪堆，开始狂欢。

从那以后，这四个家伙，小老鼠和小矮人，每天早上穿上他们的跑步装备后便毫不犹豫地直奔奶酪C站。不久，他们都建立了熟悉的路线，并形成了各自的生活习惯。

嗅嗅和匆匆仍旧每天都起得很早，然后沿着相同的路线跑进迷宫中。

当老鼠们到达目的地后，他们脱下自己的跑鞋，有条不紊地将两只鞋系在一起，挂在脖子上——以便需要的时候能够很快穿上。然后，他们才开始尽情地享用奶酪。

在刚开始的一段时间里，哼哼和唧唧也是如此行事，每天早晨赶到奶酪C站，按部就班的把鞋子挂在脖子上，享用在那里等着他们的美味佳肴。

然而，不久以后，小矮人们改变了他们的常规。

哼哼和唧唧每天起得比老鼠们晚一些，懒懒地穿好运动服，然后信步走到奶酪C站。不管怎样，反正已经找到了奶酪。

他们从没想过，奶酪是从哪里来的，是谁把它们放在那里的。他们只是理所当然地认为，奶酷总是会在那里的。

每天，哼哼和唧唧到达奶酪C站以后，就像回到了自己家一样，舒适地呆在那里。他们脱下身上的运动衣，把它们挂起来，甩掉脚上的鞋子，换上拖鞋。他们找到了奶酪，感觉实在是太惬意了。

“真是太好了！”哼哼说：“这里有这么多的奶酪，足够我们享用一辈子了。”小矮人们充满了幸福和成功的感觉，觉得从此可以无忧无虑了。

“谁动了我的奶酪”的故事（2）

不久，哼哼和唧唧更理所当然地认定，他们在奶酪C站发现的奶酪就是“他们自己的”奶酪了。这里的奶酪库存是如此的丰富，于是他们决定把家搬到更靠近奶酪C站的地方，还在周围一带开展了他们的社交活动。

为了使这里有更象家的感觉，哼哼和唧唧把墙壁装饰了一通，还在墙上写了一些格言，并且精心地画上了一些非常可口的奶酪的图案。他们看着这些图画和格言，会心地笑了。其中一幅图画的内容是：

拥有奶酪，就拥有幸福。

有时，他们会带朋友来参观他们在奶酪C站里成堆的奶酪，自豪地指着这些奶酪说：“多么美妙可口的奶酪呀，不是吗？”有时，他们还会与朋友们一起分享这些奶酪，而有时则单独享用。

“我们应该拥有这些奶酪，”哼哼说，“为了找到它们，我们可是付出了长期而艰苦的努力的，我们当然有资格拥有它们。”他一边说着一边拿起一块鲜美的奶酪放进嘴里，享用起来，脸上流露出幸福的光彩。

然后，就像往常一样，哼哼享受完奶酪便睡着了，梦中还露出满足而惬意的笑容。

每天晚上，小矮人们在美美地饱餐了奶酪后，就摇摇摆摆地走回家，第二天早上他们又会信心十足地走进奶酪C站，去享用更多奶酪。

这样的境况维持了相当长的一段时间。

逐渐地，哼哼和唧唧的自信开始膨胀起来。面对成功，他们开始变得妄自尊大。在这种安逸的生活中，他们丝毫没有察觉到正在发生的变化。

随着时间的流逝，嗅嗅和匆匆日复一日地重复着他们的生活。每天早早地赶到奶酪C站，四处闻一闻、抓一抓，看看这区域和前一天有什么不一样。等到确定没有任何异常后他们才会坐下来细细品味奶酪，好好享受一番。

一天早上，当嗅嗅和匆匆到达奶酪C站时，发现这里已经没有奶酪了。

对此，他们并不感到吃惊。因为他们早已察觉到，最近好像有一些奇异的事情正在奶酪C站里发生，因为这里的奶酪已经越来越小，并且一天比一天少了。他们对这种不可避免的情况早有心理准备，而且直觉地知道该怎么办。

他们相互对望了一眼，毫不犹豫地取下挂在脖子上的跑鞋，穿上脚并系好鞋带。

两只小老鼠对此并没有做什么全面细致的分析，事实上，也没有足够复杂的脑细胞可以支持他们进行这么复杂的思维。

对老鼠来说，问题和答案都是一样的简单。奶酪C站的情况发生了变化，所以，他们也决定随之而变化。

他们同时望向迷宫深处。嗅嗅扬起他的鼻子闻了闻，朝匆匆点点头，匆匆立刻拔腿跑向迷宫的深处，嗅嗅则紧跟其后。

他们开始迅速行动，去别的地方寻找新的奶酪，甚至连头都没有回一下。

同一天的晚些时候，哼哼和唧唧也像往常一样地来到奶酪C站，一路上哼着小曲。他们过去一直没有察觉到这里每天都在发生的细小变化，而想当然地以为他们的奶酪还在那里。

面对新的情况，他们毫无准备。

“谁动了我的奶酪”的故事（3）

“怎么！竟然没有奶酪？”哼哼大叫道，然后他开始不停地大喊大叫，“没有奶酪？怎么可能没有奶酪？”好象他叫喊地声音足够大的话，就会有谁把奶酪送回来似的。

“谁动了我的奶酪？”他声嘶力竭力地呐喊着。

最后，他把手放在屁股上，脸憋得通红，用他最大的嗓门叫道：“这不公平！”

唧唧则站在那里，一个劲地摇头，不相信这里已经发生的变化。对此，他同样没有任何心理准备，他满以为在这里照旧可以找到奶酪。他长时间地站在那里，久久不能动弹，完全被这个意外给惊呆了。

哼哼还在疯狂地叫嚷着什么，但唧唧不想听，他不想面对眼前的现实，他拼命地告诉自己，这只是一个噩梦，他只想回避这一切。

他们的行为并不可取，而且也于事无补，但我们总还是能够理解的。

要知道找到奶酪并不是一件容易的事情。更何况，对这两个小矮人来说，奶酷绝不仅仅只是一样填饱肚子的东西，它意味着他们悠闲的生活、意味着他们的荣誉、意味着他们的社交关系以及更多重要的事情。

对他们来说，找到酪是获得幸福的惟一途径。根据不同的偏爱，他们对奶酪的意义有各自的看法。

对有些人而言，奶酪代表的是一种物质上的享受；而对另一些人来说，奶酪意味着健康的生活，或者是一种安宁富足的精神世界。

对唧唧来说，奶酪意味着安定，意味着某一天能够拥有一个可爱的家庭，生活在名人社区的一座舒适的别墅里。

对哼哼来说，拥有奶酪可以使他成为大人物，可以领导很多很多的人，而且可以在卡米伯特山项上拥有一座华丽的宫殿。

由于奶酪对他们实在太重要了，所以这两个小矮人花了很长时间试图决定该怎么办。但他们所能够想到的，只是在奶酪C站里寻找，看看奶酪是否真的不存在了。

当嗅嗅和匆匆已经在迅速行动的时候，哼哼和唧唧还在那里不停地哼哼唧唧、犹豫不决。

他们情绪激动地大声叫骂这世界的不公平，用尽一切恶毒的语言去诅咒那个搬走了他们的奶酪的黑心贼。然后唧唧开始变得消沉起来，没有了奶酪，明天会怎样？他对未来的计划可是完完全全都建立在这些奶酪的基础上面的啊！

这两个小矮人就是不能接受这一切。这一切怎么可能发生呢？没有任何人警告过他们，这是不对的，事情不应该是这个样子的，他们始终无法相信眼前的事实。

那天晚上，哼哼和唧唧饥肠辘辘、沮丧地回到家里。在离开之前，唧唧在墙上写下了一句话：

奶酪对你越重要，你就越想抓住它。

第二天，辗转难眠了一晚上的哼哼和唧唧早早地离开家又回到奶酪C站，不管怎样，他们抱着一线希望，他们不断地欺骗自己，假定昨天走错了地方，他们仍然希望找回他们的奶酪。奶酪站的位置没有变化，然而奶酪的的确确早已不复存在。两个小矮人顿时手足无措，不知道该怎么办。哼哼和唧唧只是站在那里，一动不动，就像两座毫无生气的雕像。

唧唧紧紧闭上眼睛，用手捂住自己的耳朵，他只想把一切都堵在外面。他不愿相信奶酪是逐渐变得越来越少的，他宁愿相信奶酪是突然之间被全部拿走的。

哼哼则把现在的情况分析了分析，他用他那复杂的大脑把他所有的信条都翻了个遍。“他们为什么要这样做？”他终究没能找到答案，“这里究竟发生了什么事情？”

“谁动了我的奶酪”的故事（4）

终于，唧唧睁开了眼睛，朝周围看了看说：“顺便问一下，嗅嗅和匆匆现在在哪里？你是否觉得他们知道某些我们还不知道的事情？”

“那两个弱智，他们能够知道些什么？”哼哼的语气中充满了不屑。

他继续说：“他们只是头脑简单的老鼠，他们只会对发生的事情做出简单的反应。而我们是机灵聪明的小矮人，我们比老鼠有头脑。我们应该能够推测出这里的情况。”

“我知道我们更聪明，”唧唧说，“但是，我们现在的行为好像并不怎么聪明。我们周围的情况已经发生了变化，哼哼，也许我们需要做出一些改变，去做点什么不同的事情。”

“我们为什么要改变？”哼哼问道，“我们是小矮人，我们是不一样的。这样的事情不应该发生在我们的身上。即使出现了这样的情况，我们至少也应该从中得到一些补偿。”

“为什么我们应该得到一些补偿呢？”唧唧问。

“因为我们有这样的权力。”哼哼宣称。

“有什么样的权力？”唧唧不明白。

“有拥有我们的奶酪的权力。”

“为什么？”唧唧还是不明白。

“因为这个问题不是我们引起的，”哼哼说，“是某些别有用心的人制造了这个局面，而不是我们，所以我坚持认为我们总应该从中得到些补偿。”

“也许我们应该停止这种无用的分析，”唧唧提议，“分析问题到此为止。在我们还没有被饿死之前，我们应该赶紧出发去找新的奶酪。”

“噢，不！”哼哼反对说，“我就快要找到问题的根源了，要知道，我们曾经拥有过那么多、那么好的奶酪啊！”

当哼哼和唧唧还在争执着试图决定该怎么办的时候，嗅嗅和匆匆已经在很顺利地做他们的事情了。他们进入到了迷宫的更深处，走过一条又一条走廊，在每一个他们遇到的奶酪站里仔细寻找着奶酪。

除了倾尽全力地寻找新的奶酪，他们并不考虑任何别的事情。

有好一段时间，他们找得很辛苦却一无所获。直到他们走进迷宫中一个他们从未到过的地方：奶酪N站。

他们高兴得尖叫起来，他们终于发现了他们一直在寻找的东西：大量新鲜的奶酪。

他们简直不敢相信自己的眼睛，这是他们所见过的最大的奶酪仓库。

而与此同时，哼哼和唧唧仍然呆在奶酪C站，对他们目前的处境进行揣摩。他们正在忍受着失去了奶酪的痛苦，挫折感、饥饿感和由此而来的愤怒紧紧围绕着他们，折磨着他们，他们甚至为陷入眼前的困境而相互指责。

唧唧仍然时时想起他的老鼠朋友，猜想他们现在是否已经找到了奶酪。他相信他们也许过得很困难。在迷宫中穿行，总会面临许多难以预料的事情。但他也知道，什么事情也得有不容易的一个阶段。

有时，唧唧会想象出嗅嗅和匆匆已经找到了奶酪并正在享用它们的情景。他忽然有一种冲动，想到迷宫中冒险去寻找新的奶酪。在迷宫中探险，找到新的奶酪并尽情享用，这一切该是多么的美好啊！想到这里，他觉得仿佛自己已经尝到了新鲜奶酪的美味。

正在寻找和享用新的奶酪，这样的情景在唧唧的头脑中越来越清晰。他觉得自己越来越想离开奶酪C站，出发去寻找新的奶酪。

突然，他大声宣布道：“我们走吧！”

“不！”哼哼很快做出了反应：“我喜欢这里。我只熟悉这里，这里很好很舒服。再说，“离开这里到外面去是很危险的。”

“不会的，”唧唧说：“以前我们也曾经到过这个迷宫中的许多的地方，我们还可以再去其他地方找找看。”

“我觉得自己已经有些老了，不能再做这种跑来跑去到处冒险的事了。”哼哼说：“而且，我也不想象个傻瓜似的，时常迷路。你觉得呢？”

听哼哼这么一说，失败的恐惧感又袭上了唧唧的心头，他的那点发现新奶酪的希望又逐渐消退了。

就这样，这两个小矮人继续做着以前每天所做的事。他们仍然每天都去奶酪C站，发现还是找不到奶酪，然后怀着忧虑和挫败的心情回到家里。

他们试图否认眼前发生的一切，开始失眠，力气一天比一天小，变得越来越烦躁易怒。

他们的家，也不再是美好舒适的地方。他们睡不上一个安稳觉，而且每晚的时光伴着找不到奶酪的噩梦度过。

但他们仍然每天都回到奶酪C站，仍然每天在那里等待。

哼哼说：“你知道，如果我们再努力一些，我们也许会发现事情并没有发生太大的变化。奶酪也许就在附近，它们也许只是被人藏到墙后面去了。”

“谁动了我的奶酪”的故事（5）

第二天，哼哼和唧唧带了工具回到奶酪C站。哼哼拿着凿子，唧唧则用锤子敲打。他们费了九牛二虎之力，终于在墙上打出了一个洞，朝里面窥视，却依旧没有发现奶酪的踪迹。

尽管他们感到非常失望，但他们仍然想念问题会得到解决。以后，他们起得更早，工作得更长、更努力。但是，一段时间以后，他们得到的只是一个个更大的空洞。

唧唧开始认识到行动和结果的区别。

“也许，”哼哼说：“我们只需要坐在这里，看看到底会发生什么事情。迟早他们会把奶酪再送回来。”

唧唧希望他说的是真的。这样，他每天回家休息，然后勉强陪着哼哼去奶酪C站查看情况。但是，奶酷始终没有再出现。

由于焦虑和饥饿，这两个小矮人已经变得有些虚弱。唧唧已经开始厌倦等待——完全被动地等着状况自己发生好转。他开始明白，他们在奶酪C站等待的时间越长，情况只会变得越糟糕。

唧唧明白，他们正在失去自己的优势。

终于，有一天，唧唧开始自己嘲笑起自己来了：“唧唧呀唧唧，看看你自己吧！你居然等到每天重复同样的错误，还总是奇怪、怀疑为什么情况还没有得到改善，还有什么比你这种做法更可笑的呢？这如果不是荒谬，就是滑稽。”

唧唧并不想再到迷宫中去奔波。他知道他可能会迷路，而且他也不知道究竟应该到哪儿去寻找新的奶酪。但当他明白正是他的恐惧感使他如此裹足不前、坐以待毙的时候，他嘲笑起自己的愚笨。

他问哼哼：“我们的运动衣和慢跑鞋放到哪里去了？”他花了很长的时间才翻出了那些运动装备。当初，他们在奶酪C站找到奶酪以后，就把鞋啊什么的都有扔到一边去了，因为他们满以为再也不会需要这些玩意儿了。

当哼哼看到他的朋友穿上运动服时，他说，“你不是真的要到迷宫中去吧？你为什么不留下来，和我一起在这里等，等着他们把奶酪送回来？“

“因为如果这么做，我们将永远不会得到那些奶酪，”唧唧大声说：“不会有人把奶酪送回来了，现在已经到了去寻找新奶酪的时候了，不要再想那些早已不存在的奶酪了！”

哼哼争辩说：“但是如果外面也没有奶酪怎么办？或者，即使有奶酪，但你找不到，又怎么办？”

“我不知道。”唧唧不耐烦地说。同样的问题，他已经问过自己多少遍了。他又感到了那种使他停滞不前的恐惧感。奶酪的喜悦再度鼓起了他的勇气。

他最后问自己：“你希望到哪里去找奶酪——这里还是迷宫中？”

于是他的脑中出现了一幅图画，他看见自己面带微笑地在迷宫中探险。

这样的景象让他有些惊慌，他发现自己终于克服了再次进入迷宫的恐惧。他看见自己在迷宫中迷了路但仍然满怀信心地在那里寻找新奶酪，一切美好的事物都随之而来。他又重新找回了自己的勇气。

于是，他尽量发挥自己想象力，在脑海中为自己描绘了一幅他最信赖的、最具有现实感受的图画——他在寻找和品尝新的奶酪。

他仿佛看见自己坐在一大堆奶酪中央，正在尽情品尝各种奶酪，像蜂窝状的瑞士奶酪、鲜黄的英国切达干酪、美国奶酪和意大利干酪，还有美妙又柔软的法国卡米伯特奶酪，等等。

唧唧简直想入了神，直到他听到哼哼在一边嘟囔着什么，他才意识到自己仍然还在奶酪C站。

于是唧唧转身来对哼哼说：“哼哼，有时候，事情发生了改变，就再也变不回原来的样子了。我们现在遇到的情况就是这样。这就是生活！生活在变化，日子在住前走，我们也应随之改变，而不是在原地踟蹰不前。”

唧唧看着他那因饥饿和沮丧而显得有些憔悴的朋友，试图给予他分析一些道理。但是，哼哼的畏惧早已变成了气恼，他什么也听不进去。

唧唧并不想冒犯他的朋友，但是，他还是忍不住要嘲笑他们自己，因为现在看起来他们俩真的是又狼狈又愚蠢。

当唧唧准备要出发的时候，他觉得自己整个人都变得都充满了活力，他挺起了胸膛，他的精神开始振作起来：“让我们出发吧。”

唧唧大笑着宣称：“这是一个迷宫的时代！”

哼哼笑不起来，他几乎没有任何反应。

“谁动了我的奶酪”的故事（6）

唧唧拾起一块尖硬的小石头，在墙上写下一句恳切的话，留给哼哼去思考。他没有忘记自己的习惯，在这句话的周围画上奶酪的图案。唧唧希望这幅画能给哼哼带来一丝希望，会对哼哼有所启发，并促使哼哼起身去追寻新的奶酪。但是哼哼根本不想朝墙上看一眼。

墙上的话是：

如果你不改变，你就会被淘汰。

在墙上留完言后，唧唧伸出脑袋小心翼翼地朝迷宫中望了望，回想着到达奶酪C站以前所走过的路线。

他曾经想过，也许迷宫中再也没有奶酪了，或者，他可能永远也找不到奶酪。这种悲观的情绪曾经那样深地根植于他的心底，以到于差一点就毁了他。

想到这里，唧唧会心地微笑起来。他知道，哼哼现在一定还在原地懊恼：“究竟是谁动了我的奶酪？”而唧唧此刻想的却是：“我为什么没有早点行动起来，跟随着奶酪移动呢？”

当唧唧终于走出奶酪C站踏入黑暗的迷宫时，他忍不住回头看了看这个曾经伴随他和哼哼很长一段时间的地方。那一瞬间他几乎无法控制自己，又想走回那个熟悉的地方，又想躲进那个虽已没有奶酪但很完全的地方。

唧唧又有些担心起来，拿不准自己是否真的想要进入到迷宫中去。片刻以后，他又拿起石块在面前的墙上写下一句话，盯着它看了许久：

如果你无所畏惧，你会怎样做呢？

他对着这句话苦思冥想。

他知道，有时候，有所畏惧是有好处的。当你害怕不做某些事情会使事情变得越来越糟糕时，恐惧心反而会激起你采取行动。但是，如果你因为过分害怕而不敢采取任何行动时，恐惧心就会变成前进道路上最大的障碍。

他朝迷宫的右侧瞧了瞧，心中生出了恐惧，因为他从未到过那里面。

然后，他深吸了一口气，朝迷宫的右侧缓步跑去，跑向那片未知的领地。

在探路的时候，唧唧有些担心起来，一开始他还在奶酪C站犹豫了那么久，因为很长时间没有吃到奶酪了，他有些虚弱。现在，在迷宫中穿行要比以前更加吃力，花的时间更长。他打定主意，一旦再有机会，他一定要尽早走出舒适的环境去适应事情的变化。他觉得立刻采取措施会使事情更容易一些。

想到这里，唧唧无力地微笑了一下，感叹道：“迟做总比不做好。”

接下来的几天里，唧唧在周围偶而能够找到一点奶酪，但都吃不了多久。他曾经希望能够找到足够多的奶酪，带回去给哼哼，鼓励他离开原地，走进迷宫。

但是，唧唧还是感到有些信心不足。他不得不承认，身在迷宫中，他感到十分困惑。里面很多地方跟以前完全不一样了。

他这样想着朝前走去，他觉得自己已经走了好远，却又好像就要迷失在迂回曲折的走廊中了。这就好像是在走两步退一步，对他来说这真是一种挑战。不过他还是要承认，回到迷宫中寻找奶酪，其实并不像他想象的那样可怕。

随着时间的流逝，他开始有些怀疑，找到新奶酪的希望是否能变成现实。有种幻觉，有时他怀疑是否自己嘴里的奶酪太多而嚼不过来，这时，想到自己根本没有东西可嚼，他不禁哑然失笑。

每当他开始感到泄气的时候，他就提醒自己正在做什么。尽管现在很难受，但这样总比呆在没有奶酪的地方更实际。他在掌握控制权，而不是听天由命、束手无策。

他还提醒自己，如果嗅嗅和匆匆能不断前行，那么自己也能做到！

后来，唧唧回想起过去的事情，他终于明白奶酪C站的奶酪并不是像他曾经相信的那样一夜之间突然消失的。奶酪的数量是逐渐变少，直至完全消失的。而且，剩下的那一点也已经陈旧变质，美味丧失殆尽了。

那些陈旧的奶酪上面或许已经生出了霉菌，只是他没有注意到罢了。他还得承认，只要他愿意，应该能够注意得到。可惜他当初没有留意这些变化。

唧唧还认识到，如果他一直能够察觉到这些变化而且能够预见到这些变化，那么，这些变化就不会让他感到吃惊。也许，嗅嗅和匆匆一直就是这样做的。

他打定主意，从现在起，他要时刻保持警觉。他要期待着发生变化，而且还要去追寻变化。他应该相信自己的直觉，能够意识到何时发生变化，并且能够做好准备去适应这些变化。

他停下来休息了一会儿，并在迷宫的墙上写道：

经常闻一闻你的奶酪，

你就会知道，

它什么时候开始变质。

一段日子以后，好像已经很久没有找到奶酪了。这天，唧唧遇到了一个很大的奶酪站，看起来里面似乎装满了奶酪。他走进去以后，却发现里面空空如也，他失望至极。

“这种空空的感觉，对我来说太平常了。”他叹息道，他觉得自己就快要放弃了。

“谁动了我的奶酪”的故事（7）

唧唧的体力正在慢慢地丧失。他知道自己迷路了，此刻他有些担心自己能不能活下去。他想转身回到奶酪C站去。回去后，至少哼哼还在那里，唧唧就不会孤单一人了。这时，他又问了自己一个同样的问题：“如果我无所畏惧，我又会怎样做呢？”

唧唧觉得他正在克服和超越自己的恐惧，但他又越来越经常地感到害怕，害怕得甚至无法对自己承认。他常常难以确定自己到底害怕什么，但是在目前这样虚弱的状况下，他知道，他只是害怕一个人独自前行。唧唧其实并不清楚这一点，他只是在跟着这种感觉走，因为他一直在被这些恐惧的念头压迫着。

唧唧想知道哼哼是否已经离开了C站开始出发去寻找新的奶酪，或者是否仍然被自己的恐惧所吓倒，仍旧裹足不前。这时，唧唧想起他在迷宫中度过的时光，那些他曾经觉得是最美好的时光，其实正是他一个人穿行在迷宫中找寻奶酪的时候。

他又在墙上写下了一句话，以便提醒自己。同时，这句话也是一个标记，留给他的朋友哼哼，希望哼哼会跟上来。

朝新的方向前进，

你会发现新的奶酪。

唧唧朝着黑暗深遂的通道中望去，又有一阵恐惧袭来。前面有些什么？是不是什么都没有？或者更糟，里面潜藏着危险？他开始想象各种可能降临到他头上的可怕的事情。他越想越怕，快把自己吓死了。

忽然，他又觉得自己真是可笑。他意识到，他的畏惧只会使事情变得更糟糕。于是，他采取了当他无所畏惧的时候会采取的行动。他朝一个新的方向跑去。

当他跑向这条黑暗的走廊时，他笑了起来。唧唧还没有认识到这一点，但他觉得他的灵魂得到了丰富。他正在放开自己，对前景充满了信心，尽管他并不能确切地知道前面究竟有些什么。

出乎意料，他开始对自己感到越来越满意。“为什么我感觉这么好？”他不明白：“我并没有找到奶酪，而且也不知道要到哪里去。”

不久，他就明白了他为什么会感觉这么好。

他停下脚步，在墙上写道：

当你超越了自己的恐惧时，

你就会感到轻松自在。

他认识到，他原来是被自己的恐惧感给控制住了。如今朝一个新的方向迈进，使他获得了自由。

这时，从迷宫中吹来习习的凉风，使人感到神清气爽。他深吸了一口气，不觉振作起来。一旦克服了自己的恐惧感，他觉得一切比原来自己想像的要好得多。

唧唧已经很久没有这种感觉了。他几乎就快要忘记了这种感觉是多么的惬意。

为了使事情更顺利地进行，他又开始在头脑中描绘一种景象。想像中，他在一种很棒的现实环境，坐在各种他喜欢的奶酪中间——有切达奶酪还有布里奶酪！他看见自己在吃许多他喜欢吃的奶酪。这样的景象使他获得一种享受，他想像着这些奶酪的滋味该是多么美啊！

这种享受新奶酪的情景，他看得越清楚，就越相信这会变成现实。现在，他有一种感觉，他就快要找到奶酪了。

他又在墙上写道：

在我发现奶酪之前，

想像我正在享受奶酪，

这会帮我找到新的奶酪。

唧唧一直在想的是他将会得到什么，而不是考虑他会失去什么。

他不明白，为什么自己过去总是觉得变化会使事情变得更糟。而现在他认识到，变化将会使事情变得更好。

“为什么以前我不明白这一点？”他反问自己。

“谁动了我的奶酪”的故事（8）

于是，他以更大的勇气和力量快速灵敏地穿行在迷宫中。不久他就发现了一个奶酪站。当他在迷宫的入口处发现一些新奶酪的碎屑时，他变得兴奋起来。

这是一些他从未见过的奶酪，但看起来挺不错。他尝了尝，真是美味啊！他吃掉了大部分能找到的小块奶酪，把剩下的放进口袋，以后也许可以和哼哼分享。他的体力也开始得到恢复。

他怀着兴奋的心情走进去。但是，让他感到惊愕的是，里面竟然是空的。有人已经来过这里，只留下了一些零星的小块奶酪。

他认识到，如果能早一点行动，他就很有可能早已在这里发现大量的新奶酪了。

唧唧决定回去，看看哼哼是否愿意和他一起行动。

在返回的路上，他停下来，在墙上写道：

越早放弃旧的奶酪，

你就会越早发现新的奶酪。

不久，唧唧就回到了奶酪C站，找到了哼哼。他给哼哼一些新的小块奶酪，但被拒绝了。

哼哼很感激朋友的心意，但是他说：“我不喜欢新奶酪，这不是我习惯吃的那一种。我只要我自己的奶酪回来。除非可以得到我想要的东西，否则我是不会改变主意的。”

唧唧失望地摇了摇头，不情愿地一个人踏上了自己的旅程。当走到他到达过的迷宫最深处时，他怀念起他的朋友来，但他明白，他喜欢的还是他的探险过程。虽然以前他想自己希望的是得到充足的新奶酪，但现在他清楚使自己快乐的并不仅仅是奶酪而已。

他高兴的是，他不再受自己的恐惧感的驱使。他喜欢自己正在做的事情。

明白了这一点，唧唧不再像在奶酪C站时，在没有奶酪的日子里感到那样虚弱了。他知道，他不会再让恐惧感阻碍自己。他选择了一个新的方向，他的身心得到了滋养，体力得到加强。

现在，他觉得，找到自己想要的东西只是一个时间问题。事实上，他感到他已经找到了他一直在寻找的东西。

当他认识到这一点的时候，他不禁微笑起来，并在墙上写道：

在迷宫中搜寻

比停留在

没有奶酪的地方更安全。

唧唧还认识到，就像他曾经体会过的那样，你所害怕的东西根本没有你想像的那样糟糕，在你心里形成的恐惧比你的实际处境要更坏。他曾经是如此害怕找不到新的奶酪，以致于他根本不想开始去寻找。然而一旦开始寻找的旅程，他就发现迷宫的走廊中有足够的奶酪使他继续找下去。现在，他期待着找到更多的奶酪。只要朝前看，他就会因为有所期待而兴奋起来。

他过去的思想被恐惧和忧虑蒙蔽了。过去考虑的总是没有奶酪，或者没有可以维持足够长时间的奶酪。以前总是觉得会把事情做错，而不是考虑把事情做好。

在离开奶酪C站以后的日子里，一切都改变了。

过去他习惯于认为，奶酪绝不会被拿走，改变总是不对的。

现在，他知道，变化会不断地发生，这是很自然的事情，不管你是否希望如此。只有当你不希望变化，也不想追寻变化的时候，变化才会让你感到吃惊。

当唧唧认识到自己的信念发生了改变时，他停下来，在墙上写道：

陈旧的信念

不会帮助你

找到新的奶酪。

唧唧还没有找到奶酪，但在迷宫中穿行的时候，唧唧在想自己从中学到了什么。

他意识到，他的新的信念鼓舞着他采取新的行动。他的行为再不同于以往，再也不是总要回到同一个没有奶酪的地方。

他知道，当你改变了自己的信念，你也就改变了自己的行为。

你可以相信，变化对你有害，你可以拒绝它；或者，你会相信寻找新奶酪对你有好处，你会拥抱这种变化。

这些都取决于你选择相信什么。

他在墙上写道：

当你发现

你会找到新的奶酪

并且能够享用它时，

你就会改变你的路线。

“谁动了我的奶酪”的故事（9）

唧唧知道，如果他能够早一些离开奶酪C站，早一点应对这些变化，他现在的状况就会更好一些。他的身体会更强壮，精神也会更坚强，会更好地去迎接挑战——寻找新奶酪的挑战。事实上，如果他不是浪费时间，否认已经发生了的变化，如果他能够期待改变，也许他已经找到奶酪了。

他再一次运用自己的想像力，看见自己正在发现和品尝新奶酪。他决定到更多的地方去，去迷宫中那些他还没有到过的地方。在这些地方，他偶尔找到一些小块的奶酪。唧唧又开始恢复了体力和信心。

当他回顾自己是怎么走过来的时候，他很高兴他在很多经过的地放的墙上都留下了字迹。他相信如果哼哼决定离开奶酪C站的话，这就是留给哼哼的路标，能帮助哼哼穿过迷宫。

唧唧只是希望自己在朝着正确的方向前进。他还想到了这种可能性——哼哼将会读到墙上的字迹，并且循着它找到出路。

于是他又把这段时间以来他一直在思索着的心得写在了墙上：

尽早注意细小的变化，

这将有助于你

适应即将来临的更大的变化。

此时此刻，唧唧早已把过去抛在脑后，正在适应现在。

他继续以更充沛的体力和更快的速度穿越迷宫。不久，期待已久的事情终于发生了。

当他感觉一直在迷宫中前行，而且好像永远都会在迷宫中前行的时候，他的旅程——至少是现阶段的旅程——即将愉快地结束了。

唧唧正沿着一条走廊前进，这是一条他从未到过的走廊，拐过一个弯，在他的面前出现了奶酪N站，这里堆满了新鲜的奶酪！

当他走进奶酪N站的时候 ，他被眼前的景象惊呆了。到处都是堆积如山的奶酪，他从未见过如此巨大的丰盛的贮藏。他并不完全认识这些奶酪，有些品种是全新的。

眼前的景象太壮观了，他犹豫了一会儿，不能肯定这是否是真的，或许这只是他的幻觉。直到他看见了他的老朋友——嗅嗅和匆匆，他才相信这一切是真的。

嗅嗅冲唧唧点了点头，表示欢迎，匆匆则朝他挥了挥爪子。他们胖胖的小肚子表明，他们在这里已经有一段时间了。

唧唧很快向他们打了招呼，然后赶紧把他喜欢的各种奶酪都咬了一口。他脱掉鞋子，把两只鞋子系在一起，然后挂在脖子上，以便需要的时候能够迅速找到它们。嗅嗅和匆匆会心地笑了，并且赞许地点了点头。而唧唧已经一头扎进了奶酪堆中。一顿饱餐之后，唧唧高兴地举起一块新鲜的奶酪欢呼：“呼啦，变化万岁！”

唧唧享受新奶酪的同时，也在反思自己学到了什么。

他认识到，当他害怕变化的时候，他一直受困于对那已不存在的旧奶酪的幻想而无法自拨。

那又是什么使他发生了改变呢？难道是害怕饿死的恐惧？想到这里，唧唧笑了，他心里明白，这种恐惧当然起过很大的作用。

唧唧忽然发现，他已经学会自嘲了，而当人们学会自嘲，能够嘲笑自己的愚蠢和所做的错事时，他就在开始改变了。他甚至觉得，改变自己的最快方式，就是坦然嘲笑自己的愚笨——这样，你就能对过往云烟轻松释然，迅速行动起来，直面变化。

唧唧相信他从他的老鼠朋友嗅嗅和匆匆那里，学到了一些有用的东西——不畏惧改变，勇往直前。老鼠朋友们简单地对待生活，他们不会反复分析，也不会把事情搞得很复杂。当形势发生改变，奶酪被移走了的时候，他们会迅速随之改变，循着奶酪移动的方向而移动。唧唧告诉自己，要牢记这些体会。

唧唧相信拥有了这些体会，凭借自己聪慧的头脑，再遇到任何变化时他一定能做得比老鼠朋友更好。

他的头脑里出现了清晰的图画，他的生活将会变得更美好，而且他还会在迷宫中发现一些更好的东西。

唧唧不断地反思自己过去犯下的错误，他要汲取这些经验教训，去构划自己的未来。他知道，自己完全可以通过总结和学习，掌握如何应对变化：

首先要更清醒地认识到，有时需要简单地看待问题，以及灵敏快速地行动。

你不必把事情过分复杂化，或者一味地让那些惊恐的念头使自己慌乱。

其次必须要善于发现一开始发生的那些细微的变化，以便你为即将来临的更大的变化做好准备。

他知道，他需要做出更快的调整。因为，如果不能及时调整自己，就可能永远找不到属于自己的奶酪。

还有一点必须承认，那就是阻止你发生改变的最大的制约因素就是你自己。只有自己发生了改变，事情才会开始好转。

“谁动了我的奶酪”的故事（10）

最重要的是，新奶酪始终总是存在于某个地方，不管你是否已经意识到了它的存在。只有当你克服了自己的恐惧念头，并且勇于走出久已习惯的生活，去享受冒险带来的喜悦的时候，你才会得到新奶酪带给你的报偿和奖赏。

唧唧还认识到，有些畏惧是需要加以认真对待的，它会帮助你避开真正的危险。但绝大部分的恐惧都是不明智的，它们只会在你需要改变的时候，使你回避这种改变。

唧唧曾经那样地惧怕改变，他真的希望生活能够永远按照原有的样子继续，但现在他意识到，生活并不会遵从某个人的愿望发展。改变随时有可能降临，但积极地面对改变却会让你发现更好的奶酪，真的是塞翁失马，焉知非福。

唧唧已经看到了变化更好的一面。

当他回想起这些自己所学到的东西时，他不由得想起了他的朋友哼哼。他不知道哼哼是否读到了那些他在奶酪C站和迷宫各个角落墙上的留言，不知道哼哼是否已经走出了迷宫。

哼哼是否已经决定放开已经失去的过去并开始行动？他是否已经重新回到迷宫中，并且发现了能使他的生活变得更好的东西？

或者，他因为不肯改变，还在那里迟疑不前？

唧唧在考虑回到奶酪C站去，看是否能找到哼哼——但首先得肯定自己能找到回来的路。如果找到了哼哼，他会把自己学到的东西告诉他，帮助他摆脱困境。但唧唧又想起已经试图改变过他的失败经历。

哼哼必须自己发现适合自己的道路，摆脱安逸，超越恐惧。没有人可以代替他做到这一点，或者告诉他应该怎样去做。他必须迈出第一步，否则他永远不会看到改变自己所带来的好处。

唧唧知道自己已经给哼哼留下了足够的标记，只要他能够迈出第一步，读到墙上的字迹，他就会找到出路。

于是唧唧打消了回C站的念头，他站起来走到奶酪N站最大的一面墙前，把他一路上得到的心得体会的要点写了下来。他拿起一块很大的奶酪，这是他见过的奶酪中最大的一块。唧唧品尝着新鲜的奶酪，望着自己写下的体会，脸上绽出了微笑：

奶酪墙上的话

变化总是在发生

他们总是不断地拿走你地奶酪。

预见变化

随时做好奶酪被拿走的准备

追踪变化

经常闻一闻你的奶酪，

以便知道它们呢什么时候开始变质。

唧唧相信拥有了这些体会，凭借自己聪慧的头脑，再遇到任何变化时他一定能做得比老鼠朋友更好。

他的头脑里出现了清晰的图画，他的生活将会变得更美好，而且他还会在迷宫中发现一些更好的东西。

唧唧不断地反思自己过去犯下的错误，他要汲取这些经验教训，去构划自己的未来。他知道，自己完全可以通过总结和学习，掌握如何应对变化：

首先要更清醒地认识到，有时需要简单地看待问题，以及灵敏快速地行动。

你不必把事情过分复杂化，或者一味地让那些惊恐的念头使自己慌乱。

其次必须要善于发现一开始发生的那些细微的变化，以便你为即将来临的更大的变化做好准备。

他知道，他需要做出更快的调整。因为，如果不能及时调整自己，就可能永远找不到属于自己的奶酪。

还有一点必须承认，那就是阻止你发生改变的最大的制约因素就是你自己。只有自己发生了改变，事情才会开始好转。

最重要的是，新奶酪始终总是存在于某个地方，不管你是否已经意识到了它的存在。只有当你克服了自己的恐惧念头，并且勇于走出久已习惯的生活，去享受冒险带来的喜悦的时候，你才会得到新奶酪带给你的报偿和奖赏。

唧唧还认识到，有些畏惧是需要加以认真对待的，它会帮助你避开真正的危险。但绝大部分的恐惧都是不明智的，它们只会在你需要改变的时候，使你回避这种改变。

“谁动了我的奶酪”的故事（11）

唧唧曾经那样地惧怕改变，他真的希望生活能够永远按照原有的样子继续，但现在他意识到，生活并不会遵从某个人的愿望发展。改变随时有可能降临，但积极地面对改变却会让你发现更好的奶酪，真的是塞翁失马，焉知非福。

唧唧已经看到了变化更好的一面。

当他回想起这些自己所学到的东西时，他不由得想起了他的朋友哼哼。他不知道哼哼是否读到了那些他在奶酪C站和迷宫各个角落墙上的留言，不知道哼哼是否已经走出了迷宫。

哼哼是否已经决定放开已经失去的过去并开始行动？他是否已经重新回到迷宫中，并且发现了能使他的生活变得更好的东西？

或者，他因为不肯改变，还在那里迟疑不前？

唧唧在考虑回到奶酪C站去，看是否能找到哼哼——但首先得肯定自己能找到回来的路。如果找到了哼哼，他会把自己学到的东西告诉他，帮助他摆脱困境。但唧唧又想起已经试图改变过他的失败经历。

哼哼必须自己发现适合自己的道路，摆脱安逸，超越恐惧。没有人可以代替他做到这一点，或者告诉他应该怎样去做。他必须迈出第一步，否则他永远不会看到改变自己所带来的好处。

唧唧知道自己已经给哼哼留下了足够的标记，只要他能够迈出第一步，读到墙上的字迹，他就会找到出路。

于是唧唧打消了回C站的念头，他站起来走到奶酪N站最大的一面墙前，把他一路上得到的心得体会的要点写了下来。他拿起一块很大的奶酪，这是他见过的奶酪中最大的一块。唧唧品尝着新鲜的奶酪，望着自己写下的体会，脸上绽出了微笑：

奶酪墙上的话

变化总是在发生

他们总是不断地拿走你地奶酪。

预见变化

随时做好奶酪被拿走的准备

追踪变化

经常闻一闻你的奶酪，

以便知道它们呢什么时候开始变质。

尽快适应变化

越早放弃旧的奶酪，

你就会越早享用到新的奶酪。

改变

随着奶酪的变化而变化。

享受变化！

尝试去冒险，去享受新奶酪的美味！

做好迅速变化的准备

不断地去享受变化

记住：他们仍会不断地拿走你的奶酪。

唧唧在想，自从他在奶酪C站和哼哼分道扬镳以来已经有多久了。他知道自己前进了一大步，但他也很清楚，如果他过分沉溺于N区的安逸生活之中，他就会很快滑落到原来的困境。所以，他每天都仔细检查奶酪N站的情况。他在做一切力所能及的事情，以尽量避免被意料之外的变化打个措手不及。

当他还有大量的奶酪贮备时，他就开始经常到外面的迷宫中去，探索新的领地，以便使自己与周围发生的变化随时保持联系。现在的他非常明白，了解各种实际的选择，要比呆在舒适的环境里把自己孤立起来安全得多。

“窸窸窣窣”，他听到了什么，唧唧竖起耳朵听了听，他觉得是从迷宫里传来的走动的声音。这声音渐渐大起来，他知道有人正向着这边跑来。

会是哼哼到了吗？他会循着那个弯转过来吗？

唧唧念了几句祈祷语，他真的希望——像他以前曾多次希望的那样——也许，他的朋友终于能够……

随着奶酪的变化而变化，

并享受变化！

结局……

或者是新的开始？

完全用例子告诉你！不过首先你要清楚问题问的是什么？

首先，因该明白String是引用类型，是一个类，是一个不可变的类，并且有着特殊的作用。
String 只能复制一次！复制后不可改变！

String s = new String（“abc”）；
s = new String（“cba”）；
 
以上的代码并不是对s进行赋值，而是将“abc”的引用地址，从新赋给了s；
这个过程的内存是怎么分配的呢？



有几个问题要给大家说明一下：


1.String s = new String("abc");//在运行时涉及几个String实例？
  
    答案：两个，一个是字符串字面量"xyz"所对应的、驻留（intern）在一个全局共享的字符串常量池中的实例，另一个是通过new String(String)创建并初始化的、内容与"xyz"相同的实例。


2.String s = new String("abc");//涉及用户声明的几个String类型的变量?

    答案：一个，就一个String s 。


3.String s = null;
  
    Java里变量就是变量，引用类型的变量只是对某个对象实例或者null的引用，不是实例本身。声明变量的个数跟创建实例的个数没有必然关系。


4.String s = new String("abc");//创建了几个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);


}
 
}

运行结果是什么呢？




为什么第一个运行结果是false呢？  在这里"==" 其实比较的是他们在堆内存中的地址，因为str 和 str1 在堆内存中的地址不同的所以运行结果是false；
为什么第二个运行结果是true呢？   在这要说明一下，Sting是一个共享式输出类型，在内存中有一个String pool 用于存放String类型中相同的值。所以在给str2赋值的时候，JVM会在String pool中查找是否有与其所赋的值相等，如果相等就将相等的值的地址赋给str2，如果没有则在String pool中新开辟一块控件存放str2的内容。


这是我现在对String的一些理解，如果有错误，希望大家指出来，在这里谢谢大家了！
























在我的人生字典里没有放弃这两个字！

我宁愿坚守错误的选择也不愿意随便改变自己的想法！

有人说，不懂变通的人是蠢货，也有人说有时候放弃才是更好的选择！

也许你也这么说！

但，对我来说，我宁愿错下去！

也许这条路的尽头是悬崖，那我也会毫不犹豫的跳下去！

这不是一错再错，而是对自己曾经的选择负责！

这个，我懂得！