MVC
MVC含义
一种软件构架，简单的说就是在做软件的时候，可以将软件分为不同的模块，不同的模块实现了不同功能。
MVC 组成部分
Model 模型
View 视图
Controller 控制器
MVC就是三种组成部分的缩写。
MVC 不同模块的功能
Model（模型层） 程序员编写程序应用的功能，数据库设计等。属于后台操作。
View （视图层） 前台界面，也就是用户可以看到的图形见面，一般在web中是一些*.jsp或*.html。
Controller（控制器） 处理前台和后台请求。
MVC 优点
采用MVC的优点太多了，说再多不如你在真正的项目中自己体会，在这里不做太多解释。
MVC 包结构
虽然，这并不能说明所有MVC框架所有的包模式，不过我觉得新手对于这个包结构还是比较容易接受的。
DAO 模式
在DAO层，最主要的作用是：完成数据的操作。在这层，你可以完成对任何表的数据操作，不过个人认为DAO层最大的作用是简单了编程人员的编程逻辑，简单的说就是将一个大的问题，分成了几个比较小的问题，这样不管在测试还是在维护都起着很大的方便。
Factory 工厂
Factory 工厂在这里也可以说成是DAO的工厂，这里Factory仅仅产生了DAO。那么Factory工厂模式有什么好处呢？
在MVC中的Factory 层，你完全可以把它想象成现实中的工厂，生产某些东西，如果在程序中使用工厂模式，你可以简化编程代码，相当与现实中你需要某个产品不需要自己去生产，完全可以去工厂“拿”一个，这样程序的编程更加符合现实中的逻辑。
MVC 总结
本节，我仅仅是将MVC的编辑思想简单的介绍了一下，我没有加入一些详细的例子，因为我觉得你在接触MVC的时候，最好先了解MVC的编程思想，如果你要了解MVC的编程思想之后，你再接触MVC的编程时，你就会觉得特别简单。
最后，希望我这篇文章可以让大家简单的了解MVC的编程模式。
posted @
2011-01-25 09:30 tovep 阅读(2120) |
评论 (9) |
编辑 收藏
摘要: ForEach小结
<c:forEach>标签具有以下一些属性：
var：迭代参数的名称。在迭代体中可以使用...
阅读全文
posted @
2011-01-24 08:37 tovep 阅读(2347) |
评论 (0) |
编辑 收藏通过以下Servlet程序和web.xml来说明web.xml的配置以及过程
创建一个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标签中要说明的是：
<form>标签中的
action="test_Web_xml" 和 method="post" 分别定义了Html将登陆的信息发送给了谁，以及发送信息的方法！
创建一个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的作用
以上的内容是我自己对web.xml的理解，我觉得很简单，但真正写程序的时候部署程序是非常复杂的！
posted @
2010-12-11 20:43 tovep 阅读(6289) |
评论 (2) |
编辑 收藏什么是JDBC
JDBC是由一组Java语言编写的类和接口组成，用来处理关系数据库！利用JDBC的API，可用Java语法去访问各种各样的SQL数据库。
个人认为：
把JDBC当做是一门连接Java程序连接数据库的技术不如把JDBC当做连接程序和数据库的桥梁。
以下我要写的例子是用纯Java的Driver来连接数据库的方式。连接的数据库是mysql。
JDBC编程步骤
1.加载数据库驱动(jar文件)
//需要下载一个数据库的jar包，并导入相应的JDBC项目中，创建路径！
Class.forName("com.mysql.jdbc.Driver");
2.获得数据库连接
DriverManager.getConnection("jdbc:mysql://Database_IP:3306/DATABASE","DATAROOT","PASSWORD");//返回Connection————获得数据库连接
3.创建语句
String sql = "SQL_TORUNNING";
向DATABASE发送一个执行语句
Statement stmt = conn.createStatement();//创建一个 Statement 对象来将 SQL 语句发送到数据库.
Statement—————SQL_RUNNING!!!
4.执行查询
ResultSet rs = Statement.executeQuery(SQL_RUNNING);//执行SQL_RUNNING命令，返回ResultSet
//如果执行的数据库语句不是对数据库中的内容进行修改的话，则用 Statement.executeQuery()
//如果执行的数据库语句是修改数据库中的内容进行修改的话，则用 Statement.executeUpdate()
//当然他们返回值的类型也不同！
//根据命令的不同Statement的方法也不同
创建一个表
Statement.execute(create a table)
增删改查Insert、update、delete...
Statement.executeUpdate()
查询语句Select
Statement.executeQuery(Select);
5.遍历结果集
while(ResultSet.next()){
ResultSet.getInt(int);
ResultSet.getString(int);
......
}
6.关闭数据库连接
Connection.close();
步骤分析
(图一)
1.加载数据库驱动
我们来看图一，工厂和几个农村之间有一条河，不能够直接进行沟通，工厂就相当于一个Java程序，而几个农村就相当于不同的数据库；
工厂为B村生产一些材料，但是生产出来之后并不能直接交给B村，然后工厂的厂长就想在工厂和B村之间架设一座桥梁来运送生产出来的材料——我们大可把数据库驱动加载当做这个架设桥梁的想法。
在程序中我们要怎么做呢？
在加载数据库驱动的时候，必须要将相应的mysql-connector-java-5.0.4-bin.jar包，然后将jar包导入相应的项目中如下图
在mysql-connector-java-5.0.4-bin.jar右击建立路径，就相当于import的过程——我不确定这么说对不对，但我是这么理解的。
建立路径后，你的项目将出现一个新的文件，如下图
这样的话，你就可以顺利加载数据库驱动，否则当你在运行的时候会出现找不到Driver.class的异常，也就是无法加载数据库驱动。
Class.forName("com.mysql.jdbc.Driver");
2.获得数据库连接
既然厂长有想法和B村之间架设一座桥梁，那就要和B村商量一下啊！然后，厂长就要去河的对岸，那条河呢？就是在工厂和B村之间的那条河(这条河就相当于Database_IP),然后去找B村的村长(在这里要明白是B村的村长不是A村的，所以不能找错了！！！)，找到B村村长，“我要在工厂和B村之间建设一座桥，来运输我们的东西”，下一步谈的当然是条件了，工厂老板说“我要B村出资90%，剩下的由工厂出！！”村长当然不干了，这桥当然也就没法建设了！！！所以只有当两者都满意的情况下才可以建设桥梁(比如，各处50%)其实谈条件的过程就相当于验证数据库的"DATAROOT"和"PASSWORD"！！！只有两者都正确的情况下才可以进行下一步的计划——也就是建设桥梁！！！
在程序中的过程如下:
Connection conn = null;
conn = DriverManager.getConnection("jdbc:mysql://Database_IP:3306/DATABASE","DATAROOT","PASSWORD");
//返回Connection————获得数据库连接
3.创建语句
桥已经建好了，然后工厂要准备一些卡车来运输生产的货物，然后农村需要根据不同的货物来处理这些货物，有些货物直接卸在B村就可以了，但有些货物卸在B村之后，B村要做一些处理然后运回工厂！！！
这个过程在程序是怎么体现的呢？
String sql = "SQL_TORUNNING";
向DATABASE发送一个执行语句
Statement stmt = conn.createStatement();//创建一个 Statement 对象来将 SQL 语句发送到数据库.
Statement—————SQL_RUNNING!!!
4.处理数据库发送来的消息
如果工厂运输到B村的货物，只要B村的村长给工厂开一张条就行了；但也会有一些货物需要运回工厂！！
在程序中：
ResultSet rs = Statement.executeQuery(SQL_RUNNING);//执行SQL_RUNNING命令，返回ResultSet
//如果执行的数据库语句不是对数据库中的内容进行修改的话，则用 Statement.executeQuery()——需要返回一些货物
//如果执行的数据库语句是修改数据库中的内容进行修改的话，则用 Statement.executeUpdate()——开张条就行了
//当然他们返回值的类型也不同！
//根据命令的不同Statement的方法也不同
创建一个表
Statement.execute(create a table)
增删改查Insert、update、delete...
Statement.executeUpdate()
查询语句Select
Statement.executeQuery(Select);
5.处理数据库传回的内容
这个过程由工厂完成，如果是返回的一些货物的话，工厂要做一些处理。
处理的过程：
while(ResultSet.next()){
ResultSet.getInt(int);
ResultSet.getString(int);
......
}
6.关闭数据库
这样的话，工厂和B村的交易就完成，在现实世界中工厂和B村之间的桥梁不会被拆除，因为建一座桥的代价很大，但在程序和数据库之间架设一座桥梁简直太简单了，所以在这里我们要把这座桥梁拆除。
Connection.close();
简单的举了一个例子来说明数据库和程序之间是怎么连接的，望对大家有所帮助。
posted @
2010-12-09 18:37 tovep 阅读(1618) |
评论 (1) |
编辑 收藏
SQL语言是操作数据库的基础语言，对于不同的数据库语言产品，SQL语言大多是通用的，本篇博客旨在介绍一些最常用的SQL语句。希望对大家能有所帮助。
注：
本文中的红色字体黄色背景的内容为SQL语句！！
笨人也是菜鸟，如果我写的有错误，大家一定要指出来啊！！！好了，废话不说了，切入正题：
首先，使用
status查看MySQL当前的信息
1.使用
show databases;语句查看当前数据库：
2.使用
create database DATABASE_NAME;语句来创建DATABASE_NAME数据库
这样，我们创建好了一个名字为database_name的数据库。
注：数据库语句对字母大小写不敏感！
3.使用
use DATABASE_NAME;切换到使用DATABASE_NAME数据库模式。
4.在database_name数据库创建一个表：
create table if not exists table_name -- 如果表table_name不存在则创建
(id int primary key auto_increment, -- 创建int类型为主键，且自动增长
name varchar(200) not null, -- 创建字符类型的列，最大长度是200字节
age int(3), -- 创建int类型，长度为3个字节
sex varchar(2), -- 创建字符类型，长度是2个字节
salary float(11,2), -- 创建float类型的列，长度为2个字节
address varchar(50), -- 创建字符类型，长度为50个字节
birthday date -- 创建日期类型
);
这样就创建好了一张表，可以用 describe 或则 desc来查看表的结构
describe table_name;
desc table_name;
这样数据就创建好了一张表，我们可以用
show tables; 来查看数据库中所有表
然后，我们就可以看见我们创建的表
====================================================================================
数据库最具核心的用法——对数据库表的数据的
增删改查。
向表中增加数据(要了加入表的结构，看哪项可以为空)
insert table_name (name,age,sex) values ('tovep',22,'男');
向表中加入数据的时候，并不是要把所有的信息都要写近期，只要表中结构设置为可以为空的都
可以不写！！
id不用写，因为它是自动增长的！
要想查看表中的内容，可以用select语句———为了说明下面的情况，我加入了多条信息
select * from table_name; -- 将table_name表中的所有数据都打印出来
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与"%"对字符类型的列进行模糊查询
select * from table_name where name like 't%';
update语句：修改数据
update 表名 set 字段名 = '修改的值'
update table_name set name='tvoep1' where id>2;
删除用
delete from 表名 where 判断信息
delete from table_name where id=5;
这样的话就删除了id=5的信息
====================================================================================
使用drop 来删除表或者数据库
drop table table_name;
drop database database_name;
posted @
2010-12-06 11:04 tovep 阅读(2295) |
评论 (2) |
编辑 收藏经过一个多月的Java学习，我们慢慢深入了解了Java中的一些比较高级的方法！但这些方法在你调试的时候一定要慎重！！不要等待失去了整个硬盘，才后悔莫及！！！ 如果你在编程的时候多长个心眼，这些小的错误是可以避免的！！！
下面我们来看一下一个让人很崩溃的错误，这个错误让我感到不可思议！！代码如下：
import java.io.File;
public class KillBackServer {
public static void main(String[] args){
File f = new File("C:\\");
fun(f);
}
//定义一个静态函数，用来实现对一盘文件的遍历
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);
//仅仅当程序找到"我是病毒.exe"的 时候才执行这一句代码
//f.delete();
System.out.println("该病毒已被查杀");}
System.out.println(f.getPath() + "***********************");
}
}
}
大家一定要注意红色字体的代码！！！我之所以注释了，就是怕直接复制我的代码，然后运行……
如果这样后果你是知道的……
本来这段代码是用来扫描C盘，找到"我是病毒.exe"文件，并把它删除，判断一个文件名，用的是equals这是对的！！！
错就错在：if()判断，大家都明白了吧！
希望大家以后不要因为犯了这个低级错误，而把自己的硬盘给了格了= = |||
其实，有很多方法可以避免这种错误！！！比如，你可以在f.delete(); 后面加上一句打印语句，这样的话，在你测试的时候就会发现，原来if语句后面少一个大括号……
这个错误写出来仅仅为了提醒大家规范的重要性！！！
posted @
2010-11-17 21:29 tovep 阅读(2658) |
评论 (16) |
编辑 收藏
/**
* Robot类 ：
*
* exec 函数声明：
* public Process exec (String command) throws IOException ,参数及功能说明：
* command: 一条指定的系统命令
* 功能：在单独的进程中执行指定的字符串命令
*
* keyPress 函数说明：
* public void keyPress(int keycode),参数及功能说明：
* keycode：要按下的键（例如，KeyEvent.VK_A）
* 功能：模拟按下指定键
*
* keyRelease 函数说明：
* public void keyRelease(int keycode),参数及功能说明：
* keycode：要释放的键
* 功能：模拟释放指定键
*
* @param tovep
*/
import java.awt.Robot;
import java.awt.event.KeyEvent;
public class Exce {
public static void main(String[] args) {
try{
//创建自动操作类
Robot robot = new Robot();
/**
*
* 利用Runtime类运行Word程序的方法为：
* Runtime.getRuntime().exec("cmd /c start winword");
* 括号里的是系统命令
*
*/
//启动记事本程序
Runtime.getRuntime().exec("cmd /c start notepad");
//延缓几秒钟，等待记事本程序启动成功
robot.delay(3000);
//模拟按下"Ctrl + Space" 组合键，启动输入法
pressKeyWithCtrl(robot,KeyEvent.VK_SPACE);
//模拟随机按下100个字母，输入汉字
for(int i=0;i<100;i++){
pressKey(robot, (int) (Math.random()* 25) + 'A');
pressKey(robot,KeyEvent.VK_SPACE);
}
//延缓5秒钟，一共观察
robot.delay(5000);
//关闭记事本
//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"组合键，关闭当前应用程序
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 阅读(5406) |
评论 (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());
}
}
}
运行结果是：
代码中isDirectory()方法是判断文件是文件夹还是一个文件（这里可能有点迷糊），也可以这么理解，我所说的文件夹就是一个目录，
getPath()方法是打印文件(这里指的是file文件夹)的路径！！！
看看下面的代码还有注释：
/**
*
* File.speparator的作用是判断在不同的系统中斜杠的方向
*
* 在windows中斜杠的方向是向右斜的\\
* 在Linux 中斜杠的方向是向左斜的//
*
*
* File中createNewFile方法：
* 当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
* 检查文件是否存在，若不存在则创建该文件，这是单个操作，对于其他所有可能影响该文件的文件系统活动来说，该操作是不可分的。
*
* 注：此方法不应该 用于文件锁定，因为所得协议可能无法可靠地工作。应该使用 FileLock 机制替代。
*
*
*/
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());
}
}
===================================
运行结果是：
大家注意，如果你的直接复制这些代码的话，可能会出现以下异常
看看大家都明白了吧！ 系统找不到指定的文件，就是在e盘下新建一个file文件夹就可以啦！！！
下面代码详细的介绍了File类中的createNewFile()方法：
/**
*
* File中createNewFile方法：
* 当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
* 检查文件是否存在，若不存在则创建该文件，这是单个操作，对于其他所有可能影响该文件的文件系统活动来说，该操作是不可分的。
*
* 注：此方法不应该 用于文件锁定，因为所得协议可能无法可靠地工作。应该使用 FileLock 机制替代。
* 返回：是布尔型
*
*/
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());
}
}
运行结果如下：
下面介绍一下File类中delete()方法，代码如下：
/**
*
* 要操作一个文件，必须要找到这个文件
* 在Java中，只有File类能表示一个文件，所有用File表示一个文件
* File的属性就是文件的路径，虚拟机会根据File类的参数找到指定的文件
* 找到问及那后可以用File类的方法进行操作！
*
* delete()方法可以删除一个文件或者一个整个文件夹（整个目录），返回结果是布尔类型！！
*
* */
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("成功删除文件");
}
}
}
这个程序运行的结果：
下面的代码是介绍查看一个文件的目录，以及判断这个文件是否是文件夹，代码如下：
/**
*
* File的一个方法File.getPath()
* 是将此抽象路径名转换为一个路径名字符串。
*
* 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){}
}
}
}
运行结果：
再看一个判断目录的方法：
/**
*
* File的一个方法File.getPath()
* 是将此抽象路径名转换为一个路径名字符串。
*
* File的isDirectory()的方法
* 是测试此抽象路径名表示的文件是否是一个目录。
* 当且仅当此抽象路径名表示的文件存在且 是一个目录时，返回 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());
}
}
运行结果：
注意下一个代码，可能对你很有帮助啊！！
/**
*
* File的list()方法可以：
* 返回一个字符串数组，
* 这些字符串指定此抽象路径名表示的目录中的文件和目录。
*
* */
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]);
}
}
}
这个程序的运行结果是你目录下的文件：
下面的程序 你可能会很感兴趣！因为你想玩HK，或者你想给别人整个恶作剧，你必须要扫描下他的电脑，以下方法就实现了怎样去扫描一个电脑里的所有文件(我的代码选择的是扫描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);
}
//要不断列出，因为给出的File类对象可能是一个目录
public static void fun(File f){
//判断给定的路径是否是目录，如果是目录在列出
if(f.isDirectory()){
File[] file = f.listFiles();
//再依次循环进行判断
try{
for(int i = 0;i < file.length;i++){
//继续把内容传入到fun方法之中进行验证
fun(file[i]);
}
}catch(Exception e){}
}
else{
System.out.println(f);
}
}
}
运行结果我就不贴出来了，因为C盘的文件太多啦！！！如果你想知道，自己把代码带下看看，你会很吃惊的！你会想原来扫描的原理这么简单！！！
posted @
2010-11-07 23:05 tovep 阅读(59624) |
评论 (2) |
编辑 收藏
Java线程类有两种实现方式，第一种就是继承Thread类，另一种是现实Runnable接口。这两种实现方式的区别很大，下面就说一下它们之间到底有什么区别。
我们首先用第一种方式写一个线程类：
代码如下：
package Ticket;
public class Extends {
public static void main(String[] args){
//实例化进程并准备执行
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(){
//这里之所以要循环300次，就是为了让所有的 车票都卖出去！可能你会想，为什么不是30呢？
//嘿嘿。。。聪明的你肯定明白这个循环的次数为什么会多出票数很多？=====其实我开始也不知道！！！ ==|||
for(int i=0;i<300;i++){
try {
//调用sell()方法
this.sell();
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void sell(){
if(ticket>0){
System.out.println(Thread.currentThread().getName() + " ===> 还剩下" + (ticket--) + "车票");
}
}
}
看看这个程序的运行结果你就明白为什么继承Thread类实现线程类的一个弊端
------------------------------------------------
大家都发现了吧！输出的结果和预想的不一样！！！
我们来分析一下代码，查看main函数：
new Thread(new MyThread(),"001窗口").start();
new Thread(new MyThread(),"001窗口").start();
new Thread(new MyThread(),"001窗口").start();
我们可以看出，实例化了三个MyThread类，这样的话，private int ticket = 10；就运行了三次，所以ticket打印出来的 也就是30张；在这里注意一下并不是ticket赋值为30，而是ticket赋值为10，但赋值了三次！！！也就是现在有三个ticket！！！
这样并不能实现资源共享！
我们知道我们利用多线程就是为了将多个线程去处理一个数据的集合！！！ 他们是同时处理的！！！如果向上面的话，并没有将数据的集合（ticket）进行共享，而是将每一个类都从新建了一个数据的集合，分别对自己的集合进行处理！！！！
如果想解决这个问题，其实也很简单，不过如果当数据的类型和种类比较多的时候，这样写就太麻烦了！！！！
那实现Runnable接口的线程类可不可以呢！！？？？
下面来看一看：
代码如下：
package IO;
public class Inter {
public static void main(String[] args){
//声明并实例化一个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--) + "车票");
}
}
}
---------------------------------------------
这段程序的运行结果：
看看这个结果是不是和自己想的一样啊！！！这样就可以了！！！用这个方法去创建一个线程类是不是可以达到资源共享啊！！！
其实啊！我看来，所谓的资源共享也就是将一个数据的集合让多个线程去处理！！！
我们看一下代码！！！
MyThread01 mt = new MyThread01();
new Thread(mt,"001窗口").start();
new Thread(mt,"002窗口").start();
new Thread(mt,"003窗口").start();
我们可以看出这个过程中，我们只声明并实例化了一个MyThread01类，也就是说在这里过程中，给ticket进行了初始化！！！
但大家要注意的是：真正创建处理数据的线程是
new Thread(mt,"001窗口").start();
new Thread(mt,"002窗口").start();
new Thread(mt,"003窗口").start();
因此，这样可以将一个ticket的数据集 由三个线程来处理！！！
这样就是所谓的资源共享！！！
ok？？？
=====================================================================
总结一下这两种方式的特点：
1.继承Thread来创建线程类的方法，在继承了Thread后，不能再继承其他类，这样灵活性就不如实现Runnable接口来创建线程类的方法了！！！
2.正如上面所说的使用实现Runnable接口来创建线程类的方法可以达到资源共享！！！（在这里说明一下：继承Thread类来创建线程类的方法也可以实现资源共享，只不过比较麻烦！！！因此，在创建线程类的时候，应优先选择实现Runnable接口来创建线程类的方法！！！）
posted @
2010-11-07 20:30 tovep 阅读(5940) |
评论 (8) |
编辑 收藏
今天写一个具有简单功能的学生管理系统！不过，这个系统的构建基于现实中的Java程序开发框架！所有的代码全部自己去写，并且要在程序中体现出面向对象的细想和程序开发中的框架实现原理。
首相，对问题进行分析：
程序要完成的功能很简单，当程序运行的时候出现以下信息
--------图1--------
然后程序等待用户输入
如果用户选择1，那么进入增加人员的信息(
下面来分析增加人员的过程：
首先，要新建一个Person类，当用户选择1的时候就实例化Person类，并将Person进行初始化，这并没有结束此次的操作，最后的操作是将Person类存储到文件中，这个文件名我定义为Person.ser。这样这个过程才算结束，但这里的结束并不是程序结束，而是完成了1操作，整个程序并没有结束，除非用户选择4退出程序，否则程序一直执行。
)
如果用户选择2，那么程序查看所有人员的信息(
在这个过程中，程序要将Person.ser文件中的内容写入到程序中，并打印到控制台显示，执行完这一步之后，程序返回上一步操作，在这里程序仍然没有退出。
)
如果用户选择3，程序进入的是对信息进行修改的页面(
这个过程相对来说比较复杂，因为这个过程涉及到Person.ser文件内容的写入和写出过程，也就是先把文件中的内容输出到控制台显示当前用户的信息，等待用户输入新的信息，当用户输入信息后，要将原来的信息进行覆盖，也就是将信息从新写到Person.ser中——这里我们仅仅考虑Person.ser中只有一个Person的情况。
)
通过以上分析，我们可以很清楚的知道，这个程序需要一个循环来做支撑，并且这个循环每执行一次都要输出图1的内容。
首先新建一个Persion类
package Object;
import java.io.Serializable;
//要想将类存储在文件中必须实现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 {
//这个方法用来显示用户运行程序时的信息
public String mainText(){
return "\n\t\t1.增加人员的信息" + "\n\t\t2.浏览人员的信息" + "\n\t\t3.修改人员的信息" + "\n\t\t4.退出系统" + "\n\n请选择要使用的操作：";
}
//输入有误信息
public String errText(){
return "您所输入的信息有误，请重新输入！！！";
}
//增加信息显示
public String addText(){
return "请输入您要增加的学生的信息";
}
public String addName(){
return "请输入学生的姓名：";
}
public String addAge(){
return "请输入学生的年龄：";
}
public String addScore(){
return "请输入学生的成绩：";
}
//修改的内容Modify
public String modifyText(){
return "请输入您要修改的内容";
}
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;
//用户从控制台向程序写入数据，用来选择用户想要的操作
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" + p);
this.Output(this.InputPerson());
text.edd();
}
}
Main用来调用这些方法，完成想要的结果
package Main;
import Methods.Methods;
import Object.Person;
import Text.Text;
/**
*
* 这里是程序的入口，当执行这个程序的时候首先打印了图1的内容，为了表现面向对象的思想，我将程序中首先要打印的信息
* 放入到一个Text类中。
* 因为仅仅当用户选择了退出程序的时候才能退出程序，所以这个程序必须用一个‘死’循环，只有当用户选择了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){
//只有当用户输入的是4的时候程序才退出循环
System.out.println( text.mainText());
//捕获控制台用户输入的选择信息
int select = m.InputSelect();
if(select == 4)//这里的判断是——用户输入的信息等于4的时候程序结束循环
{
mainCycle = false;
}
else
{
switch(select)//用户选择的数据
{
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());
}
}
}
}
}
}
这个程序的运行结果如下：
posted @
2010-11-06 17:15 tovep 阅读(350) |
评论 (0) |
编辑 收藏
======================================================================================
这仅仅是一个很简单的医院挂号系统，虽然涉及到一些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();
}
}
运行的结果如下图：
**************************************************************************************
让大家见笑了！
posted @
2010-10-31 21:10 tovep 阅读(376) |
评论 (0) |
编辑 收藏
曾以为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程序，大家尽心等待！我一定会写出一个让自己满意的即时通讯程序！
posted @
2010-10-29 21:12 tovep 阅读(1279) |
评论 (6) |
编辑 收藏
所谓的抽象类就是一个类前加上一个abstract修饰的类，我觉得抽象类更像一个特殊的类，虽然抽象类和类也有些不同之处。
抽象类和类的区别：
抽象——就是一种具有共同属性的集体概括。
抽象类中可以有抽象方法，也可以其他的方法及属性；
抽象类和类的最大区别在于： 抽象类可以有抽象方法，但类中一定没有抽象方法，只要一个类有抽象方法那么这个类一定是抽象方法，抽象方法
是由abstract修饰的方法，但在抽象类中并没有去定义这个方法，这个抽象方法必须在它的子类中得到定义——这是必须的！ 从这里可以看出，
抽象类的作用是建立在继承之上的。
另外需要注意的是：抽象类中不一定有抽象方法，但有抽象方法的类一定是抽象类！
继承抽象类的子类，必须实现父类（这是抽象类）中所有的抽象方法！
其他的，抽象类和普通的类没有区别！
暂且不举例子，胃痛，今天就到这里！实在撑不住了！
posted @
2010-10-29 00:04 tovep 阅读(299) |
评论 (0) |
编辑 收藏
this 相当于本类，说白了就是“自己的”。
super 指的是父类，说白了就是自己继承的类。
posted @
2010-10-28 23:12 tovep 阅读(143) |
评论 (0) |
编辑 收藏
面向对象的三大特征是：封装，继承和多态！
封装：
所谓的封装就是将类包装起来，可以理解为 将一个类包装成一个黑箱子，外部对内部是不可见的！
但这个箱子（封装的类）有若干个接口，这些接口可以向这个黑箱子传送一些数据，这个箱子做一些处理，然后从另外的接口（也可以从输入的接
口）接受处理完的信息。
说白了，封装就是将一个类包装起来，使类内部数据对外不可见，这样的话，这个类就更安全了！只要你从一个接口输入信心，就可以从另外的接口（也可以从输入的接口）接受你想要的处理完的数据！
继承：
所谓的继承就是将一个父类（被继承的类）的全部（包括属性和方法）包含在子类（继承的类）中，这样做可以减少代码量，同时也可以将
具有某些相同属性的类，先写出一个父类，然后继承，在子类中，子类可以有自己的属性和方法。
举一个很经典的例子：
父类就相当于你的父亲，子类就相当于你。（基因就相当于类中方法，属性就是你的姓名啊等等）你父亲的基因你都有，但你又从你
母亲那继承了很多基因，但在JAVA中只允许单程继承，也就是你有且只有一个父类，但子类中确包含了父类中没有的属性和方法，你可以这么理
解，就是你继承了你“母类”属性和方法——注意：JAVA中并没有“母类”。
多态：
多态是什么呢？ 多态多态就是有很多状态。
比如还拿上面那个经典的例子来说，父类中的方法你也有，但你可以将这个方法的执行过程按照自己的方式写出来！这样呢，这个方法才真
正属于你（举个小例子：就是你的父亲可以吃饭，你也可以吃饭，但你们喜欢吃什么，喜欢怎么吃，吃多少，肯定不一样！）。在子类中要从写
自己的方法，子类中方法的名字，参数以及参数属性的顺序必须相同。
另外，还有一种多态形式是表现在一个类中的构造方法，他们的方法名肯定相同且和子类的类名相同，但构造方法的参数个数，顺序和类型必须
有一样是不相同的！
按我目前的理解，仅仅能解释成这样！如果以后有新的理解，一定会更新这篇博客！
posted @
2010-10-28 12:50 tovep 阅读(225) |
评论 (0) |
编辑 收藏
这是一个用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;
}
}
=========================程序的运行结果如下==============================
打开时，用户的登陆界面
当输入的账号密码都正确时：
当密码或者账号不正确：
希望这个程序对大家有所帮助！
posted @
2010-10-18 01:43 tovep 阅读(407) |
评论 (2) |
编辑 收藏
-----------------------用户登陆原----------------------------
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;
}
}
运行结果为：
当密码或者账号不正确的时候输出结果是：
posted @
2010-10-18 01:32 tovep 阅读(160) |
评论 (0) |
编辑 收藏芝加哥的同学聚会
芝加哥一个阳光明明媚的星期天，许多过去在学校曾是好朋友的同班同学聚在一起搞午餐会。前一天晚上，他们刚参加完全体高中同学的聚会。在一阵打闹嬉笑和丰盛和午餐后，他们坐下来开始了饶有兴致的交谈，希望彼此多了解一些分别后的生活经历。
安杰拉曾是班上最受欢迎的人之一，她第一个发表感慨：“生活真的是跟我们做学生时想像的完全不一样，变化太多了。”
“的确如此！”内森附和道。内森正如大家所预料的那样，毕业后就进入了他的家族企业。这家企业的经营模式经年未变，在当地人的记忆中，那可是一家历史悠久的老字号了。因此，当内森若有所思地附和着安杰拉，并发出如此感叹时，大家都感到有些吃惊。
内森好像并未注意到大家的诧异，表情忧郁地接着说：“你们是否注意到，当周围的事情已经发生变化时，我们却不想对自己有所改变。”
卡洛斯接着说道：“我们拒绝改变，是因为我们害怕改变。”
杰西卡接过他的话：“噢，卡洛斯，你可是学校的足球队长，我们心目中的英雄，我从没想过还有什么东西可以让你害怕的。”
大家都笑了起来。他们都意识到，尽管大家毕业后都在各自不同的方面发展——从在家里工作到在外经营管理公司——但好像都有着类似的感觉——害怕改变。
这些年来，每个人都试图应对发生在生活中的各种意想不到的变化。但大家都承认，他们找不到一种很好的应对办法。
这时，迈克尔发话了：“我过去也一直害怕改变，直到有一天，我们的生意出现了一个重大的变故，但我们公司所有的人都不知道该怎样去应付，由于我们没能及时做出调整，使我们几乎丢掉了全部的生意。”
“后来，”迈克尔继续讲道：“我听到了一个故事，这个故事使一切都改变了。”
“此话怎讲？”内森问道。
“喔，因为这个故事改变了我害怕改变的个性以及我对变化的看法——从害怕失去某些东西到期待获得某些东西——它教会我如何去做。从那以后，我的一切都迅速地改善了——无论工作还是生活。”
“是什么故事这么神奇？”好几个人异口同声地问道。
“一开始，我被这个故事显而易见的简单给苦恼了，它就像我们小时候听腻了的那些寓言故事一样。”
“再后来，我把这个故事告诉我们公司里的其他人，其他人又讲给其他人听。很快，公司里的业务有了明显的改进，因为我们大家都能及时地做出很好的调整以随时应对变化。与我的感受一样，许多人都说，这个故事使他们的个人生活大受裨益。”
“当然，也有人说他们从中没有得到什么，他们或者是知道这样的教训而且已经领教多次了。 或者，更普遍的是，他们觉得自己已经懂得够多，不需要再学习什么了。他们甚至假装看不到如此多的人正在从中受益。”
“我的一位有些呆板的高级主管就说，读这个故事只是浪费时间。然而大家都取笑他，把他比做故事中的一个角色——从不学习新的东西而且从不愿意改变。”
安杰拉有些迫不及待：“别卖关子了，这究竟是一个什么样的故事？”
“故事的名字叫作‘谁动了我的奶酪’。”
大家都哄笑起来。卡洛斯说：“我想仅凭这个名字，我就已经喜欢上这个故事了。你能讲给我们听听吗？或许我们也会从中有所收获。”
“当然，”迈克尔答道：“我非常愿意把这个故事讲给你们听。它并不长。”于是他开始给大家讲述这个故事。
“谁动了我的奶酪”的故事（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站的情况。他在做一切力所能及的事情，以尽量避免被意料之外的变化打个措手不及。
当他还有大量的奶酪贮备时，他就开始经常到外面的迷宫中去，探索新的领地，以便使自己与周围发生的变化随时保持联系。现在的他非常明白，了解各种实际的选择，要比呆在舒适的环境里把自己孤立起来安全得多。
“窸窸窣窣”，他听到了什么，唧唧竖起耳朵听了听，他觉得是从迷宫里传来的走动的声音。这声音渐渐大起来，他知道有人正向着这边跑来。
会是哼哼到了吗？他会循着那个弯转过来吗？
唧唧念了几句祈祷语，他真的希望——像他以前曾多次希望的那样——也许，他的朋友终于能够……
随着奶酪的变化而变化，
并享受变化！
结局……
或者是新的开始？
posted @
2010-10-17 19:14 tovep 阅读(183) |
评论 (3) |
编辑 收藏
完全用例子告诉你！不过首先你要清楚问题问的是什么？
首先，因该明白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的一些理解，如果有错误，希望大家指出来，在这里谢谢大家了！
posted @
2010-10-16 23:51 tovep 阅读(370) |
评论 (4) |
编辑 收藏
在我的人生字典里没有放弃这两个字！
我宁愿坚守错误的选择也不愿意随便改变自己的想法！
有人说，不懂变通的人是蠢货，也有人说有时候放弃才是更好的选择！
也许你也这么说！
但，对我来说，我宁愿错下去！
也许这条路的尽头是悬崖，那我也会毫不犹豫的跳下去！
这不是一错再错，而是对自己曾经的选择负责！
这个，我懂得！
posted @
2010-10-15 01:41 tovep 阅读(151) |
评论 (1) |
编辑 收藏