zz 02月 25th, 2008 — Dreamer 
从小侯兄弟的Blog上看到的这篇文章，虽然我不知道HP大中华区总裁孙振耀到底是怎样的人，不过这篇文章写的很诚恳，没有什么说教，是我见过的最好的感言之一，特意转载过来。这篇文章很长，不过值得花费一点时间和耐心看完。 

一、关于工作与生活 

我有个有趣的观察，外企公司多的是25-35岁的白领，40岁以上的员工很少，二三十岁的外企员工是意气风发的，但外企公司40岁附近的经理人是很尴尬的。我见过的40岁附近的外企经理人大多在一直跳槽，最后大多跳到民企，比方说，唐骏。外企员工的成功很大程度上是公司的成功，并非个人的成功，西门子的确比国美大，但并不代表西门子中国经理比国美的老板强，甚至可以说差得很远。而进外企的人往往并不能很早理解这一点，把自己的成功90％归功于自己的能力，实际上，外企公司随便换个中国区总经理并不会给业绩带来什么了不起的影响。好了问题来了，当这些经理人40多岁了，他们的薪资要求变得很高，而他们的才能其实又不是那么出众，作为外企公司的老板，你会怎么选择？有的是只要不高薪水的，要出位的精明强干精力冲沛的年轻人，有的是，为什么还要用你？ 

从上面这个例子，其实可以看到我们的工作轨迹，二三十岁的时候，生活的压力还比较小，身体还比较好，上面的父母身体还好，下面又没有孩子，不用还房贷，也没有孩子要上大学，当个外企小白领还是很光鲜的，挣得不多也够花了。但是人终归要结婚生子，终归会老，到了40岁，父母老了，要看病要吃药，要有人看护，自己要还房贷，要过基本体面的生活，要养小孩……那个时候需要挣多少钱才够花才重要。所以，看待工作，眼光要放远一点，一时的谁高谁低并不能说明什么。 

从这个角度上来说，我不太赞成过于关注第一份工作的薪水，更没有必要攀比第一份工作的薪水，这在刚刚出校园的学生中间是很常见的。正常人大概要工作 35年，这好比是一场马拉松比赛，和真正的马拉松比赛不同的是，这次比赛没有职业选手，每个人都只有一次机会。要知到，有很多人甚至坚持不到终点，大多数人最后是走到终点的，只有少数人是跑过终点的，因此在刚开始的时候，去抢领先的位置并没有太大的意义。刚进社会的时候如果进500强公司，大概能拿到3k -6k/月的工资，有些特别技术的人才可能可以到8k/月，可问题是，5年以后拿多少？估计5k-10k了不起了。起点虽然高，但增幅有限，而且，后面的年轻人追赶的压力越来越大。 

我前两天问我的一个销售，你会的这些东西一个新人2年就都学会了，但新人所要求的薪水却只是你的一半，到时候，你怎么办？ 
职业生涯就像一场体育比赛，有初赛、复赛、决赛。初赛的时候大家都刚刚进社会，大多数都是实力一般的人，这时候努力一点认真一点很快就能让人脱颖而出，于是有的人二十多岁做了经理，有的人迟些也终于赢得了初赛，三十多岁成了经理。然后是复赛，能参加复赛的都是赢得初赛的，每个人都有些能耐，在聪明才智上都不成问题，这个时候再想要胜出就不那么容易了，单靠一点点努力和认真还不够，要有很强的坚忍精神，要懂得靠团队的力量，要懂得收服人心，要有长远的眼光…… 

看上去赢得复赛并不容易，但，还不是那么难。因为这个世界的规律就是给人一点成功的同时让人骄傲自满，刚刚赢得初赛的人往往不知道自己赢得的仅仅是初赛，有了一点小小的成绩大多数人都会骄傲自满起来，认为自己已经懂得了全部，不需要再努力再学习了，他们会认为之所以不能再进一步已经不是自己的原因了。虽然他们仍然不好对付，但是他们没有耐性，没有容人的度量，更没有清晰长远的目光。就像一只愤怒的斗牛，虽然猛烈，最终是会败的，而赢得复赛的人则象斗牛士一样，不急不躁，跟随着自己的节拍，慢慢耗尽对手的耐心和体力。赢得了复赛以后，大约已经是一位很了不起的职业经理人了，当上了中小公司的总经理，大公司的副总经理，主管着每年几千万乃至几亿的生意。 

最终的决赛来了，说实话我自己都还没有赢得决赛，因此对于决赛的决胜因素也只能凭自己的猜测而已，这个时候的输赢或许就像武侠小说里写得那样，大家都是高手，只能等待对方犯错了，要想轻易击败对手是不可能的，除了使上浑身解数，还需要一点运气和时间。世界的规律依然发挥着作用，赢得复赛的人已经不只是骄傲自满了，他们往往刚愎自用，听不进去别人的话，有些人的脾气变得暴躁，心情变得浮躁，身体变得糟糕，他们最大的敌人就是他们自己，在决赛中要做的只是不被自己击败，等着别人被自己击败。这和体育比赛是一样的，最后高手之间的比赛，就看谁失误少谁就赢得了决赛。 

二、 根源 

你工作快乐么？你的工作好么？ 

有没有觉得干了一段时间以后工作很不开心？有没有觉得自己入错了行？有没有觉得自己没有得到应有的待遇？有没有觉得工作像一团乱麻每天上班都是一种痛苦？有没有很想换个工作？有没有觉得其实现在的公司并没有当初想象得那么好？有没有觉得这份工作是当初因为生存压力而找的，实在不适合自己？你从工作中得到你想要得到的了么？你每天开心么？ 

天涯上愤怒的人很多，你有没有想过，你为什么不快乐？你为什么愤怒？ 

其实，你不快乐的根源，是因为你不知道要什么！你不知道要什么，所以你不知道去追求什么，你不知道追求什么，所以你什么也得不到。 

我总觉得，职业生涯首先要关注的是自己，自己想要什么？大多数人大概没想过这个问题，唯一的想法只是——我想要一份工作，我想要一份不错的薪水，我知道所有人对于薪水的渴望，可是，你想每隔几年重来一次找工作的过程么？你想每年都在这种对于工作和薪水的焦急不安中度过么？不想的话，就好好想清楚。饮鸩止渴，不能因为口渴就拼命喝毒药。越是焦急，越是觉得自己需要一份工作，越饥不择食，越想不清楚，越容易失败，你的经历越来越差，下一份工作的人看着你的简历就皱眉头。于是你越喝越渴，越渴越喝，陷入恶性循环。最终只能哀叹世事不公或者生不逢时，只能到天涯上来发泄一把，在失败者的共鸣当中寻求一点心理平衡罢了。大多数人都有生存压力，我也是，有生存压力就会有很多焦虑，积极的人会从焦虑中得到动力，而消极的人则会因为焦虑而迷失方向。所有人都必须在压力下做出选择，这就是世道，你喜欢也罢不喜欢也罢。 

一般我们处理的事情分为重要的事情和紧急的事情，如果不做重要的事情就会常常去做紧急的事情。比如锻炼身体保持健康是重要的事情，而看病则是紧急的事情。如果不锻炼身体保持健康，就会常常为了病痛烦恼。又比如防火是重要的事情，而救火是紧急的事情，如果不注意防火，就要常常救火。找工作也是如此，想好自己究竟要什么是重要的事情，找工作是紧急的事情，如果不想好，就会常常要找工作。往往紧急的事情给人的压力比较大，迫使人们去赶紧做，相对来说重要的事情反而没有那么大的压力，大多数人做事情都是以压力为导向的，压力之下，总觉得非要先做紧急的事情，结果就是永远到处救火，永远没有停歇的时候。（很多人的工作也像是救火队一样忙碌痛苦，也是因为工作中没有做好重要的事情。）那些说自己活在水深火热为了生存顾不上那么多的朋友，今天找工作困难是当初你们没有做重要的事情，是结果不是原因。如果今天你们还是因为急于要找一份工作而不去思考，那么或许将来要继续承受痛苦找工作的结果。 

我始终觉得我要说的话题，沉重了点，需要很多思考，远比唐笑打武警的话题来的枯燥乏味，但是，天下没有轻松的成功，成功，要付代价。请先忘记一切的生存压力，想想这辈子你最想要的是什么？所以，最要紧的事情，先想好自己想要什么。 

三、什么是好工作 

当初微软有个唐骏，很多大学里的年轻人觉得这才是他们向往的职业生涯，我在清华bbs里发的帖子被这些学子们所不屑，那个时候学生们只想出国或者去外企，不过如今看来，我还是对的，唐骏去了盛大，陈天桥创立的盛大，一家民营公司。一个高学历的海归在500强的公司里拿高薪水，这大约是很多年轻人的梦想，问题是，每年毕业的大学生都在做这个梦，好的职位却只有500个。 

人都是要面子的，也是喜欢攀比的，即使在工作上也喜欢攀比，不管那是不是自己想要的。大家认为外企公司很好，可是好在哪里呢？好吧，他们在比较好的写字楼，这是你想要的么？他们出差住比较好的酒店，这是你想要的么？别人会羡慕一份外企公司的工作，这是你想要的么？那一切都是给别人看的，你干吗要活得那么辛苦给别人看？另一方面，他们薪水福利一般，并没有特别了不起，他们的晋升机会比较少，很难做到很高阶的主管，他们虽然厌恶常常加班，却不敢不加班，因为“你不干有得是人干”，大部分情况下会找个台湾人香港人新加坡人来管你，而这些人又往往有些莫名其妙的优越感。你想清楚了么？500强一定好么？找工作究竟是考虑你想要什么，还是考虑别人想看什么？ 

我的大学同学们大多数都到美国了，甚至毕业这么多年了，还有人最近到国外去了。出国真的有那么好么？我的大学同学们，大多数还是在博士、博士后、访问学者地挣扎着，至今只有一个正经在一个美国大学里拿到个正式的教职。国内的教授很难当么？我有几个表亲也去了国外了，他们的父母独自在国内，没有人照顾，有好几次人在家里昏倒都没人知道，出国，真的这么光彩么？就像有人说的“很多事情就像看A片，看的人觉得很爽，做的人未必。” 

人总想找到那个最好的，可是，什么是最好的？你觉得是最好的那个，是因为你的确了解，还是因为别人说他是最好的？即使他对于别人是最好的，对于你也一定是最好的么？ 

对于自己想要什么，自己要最清楚，别人的意见并不是那么重要。很多人总是常常被别人的意见所影响，亲戚的意见，朋友的意见，同事的意见……问题是，你究竟是要过谁的一生？人的一生不是父母一生的续集，也不是儿女一生的前传，更不是朋友一生的外篇，只有你自己对自己的一生负责，别人无法也负不起这个责任。自己做的决定，至少到最后，自己没什么可后悔。对于大多数正常智力的人来说，所做的决定没有大的对错，无论怎么样的选择，都是可以尝试的。比如你没有考自己上的那个学校，没有入现在这个行业，这辈子就过不下去了？就会很失败？不见得。 

我想，好工作，应该是适合你的工作，具体点说，应该是能给你带来你想要的东西的工作，你或许应该以此来衡量你的工作究竟好不好，而不是拿公司的大小，规模，外企还是国企，是不是有名，是不是上市公司来衡量。小公司，未必不是好公司，赚钱多的工作，也未必是好工作。你还是要先弄清楚你想要什么，如果你不清楚你想要什么，你就永远也不会找到好工作，因为你永远只看到你得不到的东西，你得到的，都是你不想要的。 
可能，最好的，已经在你的身边，只是，你还没有学会珍惜。人们总是盯着得不到的东西，而忽视了那些已经得到的东西。 

四、普通人 

我发现中国人的励志和国外的励志存在非常大的不同，中国的励志比较鼓励人立下大志愿，卧薪尝胆，有朝一日成富成贵。而国外的励志比较鼓励人勇敢面对现实生活，面对普通人的困境，虽然结果也是成富成贵，但起点不一样，相对来说，我觉得后者在操作上更现实，而前者则需要用999个失败者来堆砌一个成功者的故事。 

我们都是普通人，普通人的意思就是，概率这件事是很准的。因此，我们不会买彩票中500万，我们不会成为比尔盖茨或者李嘉诚，我们不会坐飞机掉下来，我们当中很少的人会创业成功，我们之中有30％的人会离婚，我们之中大部分人会活过65岁…… 

所以请你在想自己要什么的时候，要得“现实”一点，你说我想要做李嘉诚，抱歉，我帮不上你。成为比尔盖茨或者李嘉诚这种人，是靠命的，看我写的这篇文章绝对不会让你成为他们，即使你成为了他们，也绝对不是我这篇文章的功劳。“王侯将相宁有种乎”但真正当皇帝的只有一个人，王侯将相，人也不多。目标定得高些对于喜欢挑战的人来说有好处，但对于大多数普通人来说，反而比较容易灰心沮丧，很容易就放弃了。 

回过头来说，李嘉诚比你有钱大致50万倍，他比你更快乐么？或许。有没有比你快乐50万倍，一定没有。他比你最多也就快乐一两倍，甚至有可能还不如你快乐。寻找自己想要的东西不是和别人比赛，比谁要得更多更高，比谁的目标更远大。虽然成为李嘉诚这个目标很宏大，但你并不见得会从这个目标以及追求目标的过程当中获得快乐，而且基本上你也做不到。你必须听听你内心的声音，寻找真正能够使你获得快乐的东西，那才是你想要的东西。 
你想要的东西，或者我们把它称之为目标，目标其实并没有高低之分，你不需要因为自己的目标没有别人远大而不好意思，达到自己的目标其实就是成功，成功有大有小，快乐却是一样的。我们追逐成功，其实追逐的是成功带来的快乐，而非成功本身。职业生涯的道路上，我们常常会被攀比的心态蒙住眼睛，忘记了追求的究竟是什么，忘记了是什么能使我们更快乐。 

社会上一夜暴富的新闻很多，这些消息，总会在我们的心里面掀起很多涟漪，涟漪多了就变成惊涛骇浪，心里的惊涛骇浪除了打翻承载你目标的小船，并不会使得你也一夜暴富。“只见贼吃肉，不见贼挨揍。”我们这些普通人既没有当贼的勇气，又缺乏当贼的狠辣绝决，虽然羡慕吃肉，却更害怕挨揍，偶尔看到几个没挨揍的贼就按奈不住，或者心思活动，或者大感不公，真要叫去做贼，却也不敢。 

我还是过普通人的日子，要普通人的快乐，至少，晚上睡得着觉。 

五、跳槽与积累 

首先要说明，工作是一件需要理智的事情，所以不要在工作上耍个性，天涯上或许会有人觉得你很有个性而叫好，煤气公司电话公司不会因为觉得你很有个性而免了你的帐单。当你很帅地炒掉了你的老板，当你很酷地挖苦了一番招聘的HR，账单还是要照付，只是你赚钱的时间更少了，除了你自己，没人受损失。 

我并不反对跳槽，但跳槽决不是解决问题的办法，而且频繁跳槽的后果是让人觉得没有忠诚度可言，而且不能安心工作。现在很多人从网上找工作，很多找工作的网站常常给人出些馊主意，要知道他们是盈利性企业，当然要从自身盈利的角度来考虑，大家越是频繁跳槽频繁找工作他们越是生意兴隆，所以鼓动人们跳槽是他们的工作。所以他们会常常告诉你，你拿的薪水少了，你享受的福利待遇差了，又是“薪情快报”又是“赞叹自由奔放的灵魂”。至于是否会因此让你不能安心，你跳了槽是否解决问题，是否更加开心，那个，他们管不着。 

要跳槽肯定是有问题，一般来说问题发生了，躲是躲不开的，很多人跳槽是因为这样或者那样的不开心，如果这种不开心，在现在这个公司不能解决，那么在下一个公司多半也解决不掉。你必须相信，90%的情况下，你所在的公司并没有那么烂，你认为不错的公司也没有那么好。就像围城里说的，“城里的人拼命想冲出来，而城外的人拼命想冲进去。”每个公司都有每个公司的问题，没有问题的公司是不存在的。换个环境你都不知道会碰到什么问题，与其如此，不如就在当下把问题解决掉。很多问题当你真的想要去解决的时候，或许并没有那么难。有的时候你觉得问题无法解决，事实上，那只是“你觉得”。 

人生的曲线应该是曲折向上的，偶尔会遇到低谷但大趋势总归是曲折向上的，而不是象脉冲波一样每每回到起点，我见过不少面试者，30多岁了，四五份工作经历，每次多则3年，少则1年，30多岁的时候回到起点从一个初级职位开始干起，拿基本初级的薪水，和20多岁的年轻人一起竞争，不觉得有点辛苦么？这种日子好过么？ 

我非常不赞成在一个行业超过3年以后换行业，基本上，35岁以前我们的生存资本靠打拼，35岁以生存的资本靠的就是积累，这种积累包括人际关系，经验，人脉，口碑……如果常常更换行业，代表几年的积累付之东流，一切从头开始，如果换了两次行业，35岁的时候大概只有5年以下的积累，而一个没有换过行业的人至少有了10年的积累，谁会占优势？工作到2-3年的时候，很多人觉得工作不顺利，好像到了一个瓶颈，心情烦闷，就想辞职，乃至换一个行业，觉得这样所有一切烦恼都可以抛开，会好很多。其实这样做只是让你从头开始，到了时候还是会发生和原来行业一样的困难，熬过去就向上跨了一大步，要知道每个人都会经历这个过程，每个人的职业生涯中都会碰到几个瓶颈，你熬过去了而别人没有熬过去你就领先了。跑长跑的人会知道，开始的时候很轻松，但是很快会有第一次的难受，但过了这一段又能跑很长一段，接下来会碰到第二次的难受，坚持过了以后又能跑一段，如此往复，难受一次比一次厉害，直到坚持不下去了。大多数人第一次就坚持不了了，一些人能坚持到第二次，第三次虽然大家都坚持不住了，可是跑到这里的人也没几个了，这点资本足够你安稳活这一辈子了。 

一份工作到两三年的时候，大部分人都会变成熟手，这个时候往往会陷入不断的重复，有很多人会觉得厌倦，有些人会觉得自己已经搞懂了一切，从而懒得去寻求进步了。很多时候的跳槽是因为觉得失去兴趣了，觉得自己已经完成比赛了。其实这个时候比赛才刚刚开始，工作两三年的人，无论是客户关系，人脉，手下，和领导的关系，在业内的名气……还都是远远不够的，但稍有成绩的人总是会自我感觉良好的，每个人都觉得自己跟客户关系铁得要命，觉得自己在业界的口碑好得很。其实可以肯定地说，一定不是，这个时候，还是要拿出前两年的干劲来，稳扎稳打，积累才刚刚开始。 
你足够了解你的客户吗？你知道他最大的烦恼是什么吗？你足够了解你的老板么？你知道他最大的烦恼是什么吗？你足够了解你的手下么？你知道他最大的烦恼是什么吗？如果你不知道，你凭什么觉得自己已经积累够了？如果你都不了解，你怎么能让他们帮你的忙，做你想让他们做的事情？如果他们不做你想让他们做的事情，你又何来的成功？ 

六、等待 

这是个浮躁的人们最不喜欢的话题，本来不想说这个话题，因为会引起太多的争论，而我又无意和人争论这些，但是考虑到对于职业生涯的长久规划，这是一个躲避不了的话题，还是决定写一写，不爱看的请离开吧。 

并不是每次穿红灯都会被汽车撞，并不是每个罪犯都会被抓到，并不是每个错误都会被惩罚，并不是每个贪官都会被枪毙，并不是你的每一份努力都会得到回报，并不是你的每一次坚持都会有人看到，并不是你每一点付出都能得到公正的回报，并不是你的每一个善意都能被理解……这个，就是世道。好吧，世道不够好，可是，你有推翻世道的勇气么？如果没有，你有更好的解决办法么？有很多时候，人需要一点耐心，一点信心。每个人总会轮到几次不公平的事情，而通常，安心等待是最好的办法。 

有很多时候我们需要等待，需要耐得住寂寞，等待属于你的那一刻。周润发等待过，刘德华等待过，周星驰等待过，王菲等待过，张艺谋也等待过……看到了他们如今的功成名就的人，你可曾看到当初他们的等待和耐心？你可曾看到金马奖影帝在街边摆地摊？你可曾看到德云社一群人在剧场里给一位观众说相声？你可曾看到周星驰的角色甚至连一句台词都没有？每一个成功者都有一段低沉苦闷的日子，我几乎能想象得出来他们借酒浇愁的样子，我也能想象得出他们为了生存而挣扎的窘迫。在他们一生最中灿烂美好的日子里，他们渴望成功，但却两手空空，一如现在的你。没有人保证他们将来一定会成功，而他们的选择是耐住寂寞。如果当时的他们总念叨着“成功只是属于特权阶级的”，你觉得他们今天会怎样？ 

曾经我也不明白有些人为什么并不比我有能力却要坐在我的头上，年纪比我大就一定要当我的领导么？为什么有些烂人不需要努力就能赚钱？为什么刚刚改革开放的时候的人能那么容易赚钱，而轮到我们的时候，什么事情都要正规化了？有一天我突然想，我还在上学的时候他们就在社会里挣扎奋斗了，他们在社会上奋斗积累了十几二十年，我们新人来了，他们有的我都想要，我这不是在要公平，我这是在要抢劫。因为我要得太急，因为我忍不住寂寞。二十多岁的男人，没有钱，没有事业，却有蓬勃的欲望。 

人总是会遇到挫折的，人总是会有低潮的，人总是会有不被人理解的时候的，人总是有要低声下气的时候，这些时候恰恰是人生最关键的时候，因为大家都会碰到挫折，而大多数人过不了这个门槛，你能过，你就成功了。在这样的时刻，我们需要耐心等待，满怀信心地去等待，相信，生活不会放弃你，机会总会来的。至少，你还年轻，你没有坐牢，没有生治不了的病，没有欠还不起的债。比你不幸的人远远多过比你幸运的人，你还怕什么？路要一步步走，虽然到达终点的那一步很激动人心，但大部分的脚步是平凡甚至枯燥的，但没有这些脚步，或者耐不住这些平凡枯燥，你终归是无法迎来最后的那些激动人心。 

逆境，是上帝帮你淘汰竞争者的地方。要知道，你不好受，别人也不好受，你坚持不下去了，别人也一样，千万不要告诉别人你坚持不住了，那只能让别人获得坚持的信心，让竞争者看着你微笑的面孔，失去信心，退出比赛。胜利属于那些有耐心的人。 

在最绝望的时候，我会去看电影《The Pursuit of Happyness》《JerryMaguire》，让自己重新鼓起勇气，因为，无论什么时候，我们总还是有希望。当所有的人离开的时候，我不失去希望，我不放弃。每天下班坐在车里，我喜欢哼着《隐形的翅膀》看着窗外，我知道，我在静静等待，等待属于我的那一刻。 

原贴里伊吉网友的话我很喜欢，抄录在这里： 

每个人都希望，自己是独一无二的特殊者 
含着金匙出生、投胎到好家庭、工作安排到电力局拿1w月薪这样的小概率事件，当然最好轮到自己 
红军长征两万五、打成右派反革命、胼手胝足牺牲尊严去奋斗，最好留给祖辈父辈和别人 
自然，不是每个吃过苦的人都会得到回报 
但是，任何时代，每一个既得利益者身后，都有他的祖辈父辈奋斗挣扎乃至流血付出生命的身影 
羡慕别人有个好爸爸，没什么不可以 
问题是，你的下一代，会有一个好爸爸吗？ 
至于问到为什么不能有同样的赢面概率？我只能问：为什么物种竞争中，人和猴子不能有同样的赢面概率？ 
物竞天择。猴子的灵魂不一定比你卑微，但你身后有几十万年的类人猿进化积淀。 

七、入对行跟对人 

在中国，大概很少有人是一份职业做到底的，虽然如此，第一份工作还是有些需要注意的地方，有两件事情格外重要，第一件是入行，第二件事情是跟人。第一份工作对人最大的影响就是入行，现代的职业分工已经很细，我们基本上只能在一个行业里成为专家，不可能在多个行业里成为专家。很多案例也证明即使一个人在一个行业非常成功，到另外一个行业，往往完全不是那么回事情，“你想改变世界，还是想卖一辈子汽水？”是乔布斯邀请百事可乐总裁约翰·斯考利加盟苹果时所说的话，结果这位在百事非常成功的约翰，到了苹果表现平平。其实没有哪个行业特别好，也没有哪个行业特别差，或许有报道说哪个行业的平均薪资比较高，但是他们没说的是，那个行业的平均压力也比较大。看上去很美的行业一旦进入才发现很多地方其实并不那么完美，只是外人看不见。 

说实话，我自己都没有发大财，所以我的建议只是让人快乐工作的建议，不是如何发大财的建议，我们只讨论一般普通打工者的情况。我认为选择什么行业并没有太大关系，看问题不能只看眼前。比如，从前年开始，国家开始整顿医疗行业，很多医药公司开不下去，很多医药行业的销售开始转行。其实医药行业的不景气是针对所有公司的，并非针对一家公司，大家的日子都不好过，这个时候跑掉是非常不划算的，大多数正规的医药公司即使不做新生意撑个两三年总是能撑的，大多数医药销售靠工资撑个两三年也是可以撑的，国家不可能永远捏着医药行业不放的，两三年以后光景总归还会好起来的，那个时候别人都跑了而你没跑，那时的日子应该会好过很多。有的时候觉得自己这个行业不行了，问题是，再不行的行业，做得人少了也变成了好行业，当大家都觉得不好的时候，往往却是最好的时候。大家都觉得金融行业好，金融行业门槛高不说，有多少人削尖脑袋要钻进去，竞争激励，进去以后还要时时提防，一个疏忽，就被后来的人给挤掉了，压力巨大，又如何谈得上快乐？也就未必是“好”工作了。 

太阳能这个东西至今还不能进入实际应用的阶段，但是中国已经有7家和太阳能有关的公司在纽交所上市了，国美苏宁永乐其实是贸易型企业，也能上市，鲁泰纺织连续10年利润增长超过50%，卖茶的一茶一座，卖衣服的海澜之家都能上市……其实选什么行业真的不重要，关键是怎么做。事情都是人做出来的，关键是人。 

有一点是需要记住的，这个世界上，有史以来直到我们能够预见得到的未来，成功的人总是少数，有钱的人总是少数，大多数人是一般的，普通的，不太成功的。因此，大多数人的做法和看法，往往都不是距离成功最近的做法和看法。因此大多数人说好的东西不见得好，大多数人说不好的东西不见得不好。大多数人都去炒股的时候说明跌只是时间问题，大家越是热情高涨的时候，跌的日子越近。大多数人买房子的时候，房价不会涨，而房价涨的差不多的时候，大多数人才开始买房子。不会有这样一件事情让大家都变成功，发了财，历史上不曾有过，将来也不会发生。有些东西即使一时运气好得到了，还是会在别的时候别的地方失去的。 

年轻人在职业生涯的刚开始，尤其要注意的是，要做对的事情，不要让自己今后几十年的人生总是提心吊胆，更不值得为了一份工作赔上自己的青春年华。我的公司是个不行贿的公司，以前很多人不理解，甚至自己的员工也不理解，不过如今，我们是同行中最大的企业，客户乐意和我们打交道，尤其是在国家打击腐败的时候，每个人都知道我们做生意不给钱的名声，都敢于和我们做生意。而勇于给钱的公司，不是倒了，就是跑了，要不就是每天睡不好觉，人还是要看长远一点。很多时候，看起来最近的路，其实是最远的路，看起来最远的路，其实是最近的路。 

跟对人是说，入行后要跟个好领导好老师，刚进社会的人做事情往往没有经验，需要有人言传身教。对于一个人的发展来说，一个好领导是非常重要的。所谓“好”的标准，不是他让你少干活多拿钱，而是以下三个。 

首先，好领导要有宽广的心胸，如果一个领导每天都会发脾气，那几乎可以肯定他不是个心胸宽广的人，能发脾气的时候却不发脾气的领导，多半是非常厉害的领导。中国人当领导最大的毛病是容忍不了能力比自己强的人，所以常常可以看到的一个现象是，领导很有能力，手下一群庸才或者手下一群闲人。如果看到这样的环境，还是不要去的好。 

其次，领导要愿意从下属的角度来思考问题，这一点其实是从面试的时候就能发现的，如果这位领导总是从自己的角度来考虑问题，几乎不听你说什么，这就危险了。从下属的角度来考虑问题并不代表同意下属的说法，但他必须了解下属的立场，下属为什么要这么想，然后他才有办法说服你，只关心自己怎么想的领导往往难以获得下属的信服。 

第三，领导敢于承担责任，如果出了问题就把责任往下推，有了功劳就往自己身上揽，这样的领导不跟也罢。选择领导，要选择关键时刻能抗得住的领导，能够为下属的错误买单的领导，因为这是他作为领导的责任。 

有可能，你碰不到好领导，因为，中国的领导往往是屁股决定脑袋的领导，因为他坐领导的位置，所以他的话就比较有道理，这是传统观念官本位的误区，可能有大量的这种无知无能的领导，只是，这对于你其实是好事，如果将来有一天你要超过他，你希望他比较聪明还是比较笨？相对来说这样的领导其实不难搞定，只是你要把自己的身段放下来而已。多认识一些人，多和比自己强的人打交道，同样能找到好的老师，不要和一群同样郁闷的人一起控诉社会，控诉老板，这帮不上你，只会让你更消极。和那些比你强的人打交道，看他们是怎么想的，怎么做的，学习他们，然后跟更强的人打交道。 

八、选择 

我们每天做的最多的事情，其实是选择，因此在谈职业生涯的时候不得不提到这个话题。 

我始终认为，在很大的范围内，我们究竟会成为一个什么样的人，决定权在我们自己，每天我们都在做各种各样的选择，我可以不去写这篇文章，去别人的帖子拍拍砖头，也可以写下这些文字，帮助别人的同时也整理自己的思路，我可以多注意下格式让别人易于阅读，也可以写成一堆，我可以就这样发上来，也可以在发以前再看几遍，你可以选择不刮胡子就去面试，也可以选择出门前照照镜子……每天，每一刻我们都在做这样那样的决定，我们可以漫不经心，也可以多花些心思，成千上万的小选择累计起来，就决定了最终我们是个什么样的人。 

从某种意义上来说我们的未来不是别人给的，是我们自己选择的，很多人会说我命苦啊，没得选择阿，如果你认为“去微软还是去IBM”“上清华还是上北大”“当销售副总还是当厂长”这种才叫选择的话，的确你没有什么选择，大多数人都没有什么选择。但每天你都可以选择是否为客户服务更周到一些，是否对同事更耐心一些，是否把工作做得更细致一些，是否把情况了解得更清楚一些，是否把不清楚的问题再弄清楚一些……你也可以选择在是否在痛苦中继续坚持，是否抛弃掉自己的那些负面的想法，是否原谅一个人的错误，是否相信我在这里写下的这些话，是否不要再犯同样的错误……生活每天都在给你选择的机会，每天都在给你改变自己人生的机会，你可以选择赖在地上撒泼打滚，也可以选择咬牙站起来。你永远都有选择。有些选择不是立杆见影的，需要累积，比如农民可以选择自己常常去浇地，也可以选择让老天去浇地，诚然你今天浇水下去苗不见得今天马上就长出来，但常常浇水，大部分苗终究会长出来的，如果你不浇，收成一定很糟糕。 

每天生活都在给你机会，他不会给你一叠现金也不会拱手送你个好工作，但实际上，他还是在给你机会。我的家庭是一个普通的家庭，没有任何了不起的社会关系，我的父亲在大学毕业以后就被分配到了边疆，那个小县城只有一条马路，他们那一代人其实比我们更有理由抱怨，他们什么也没得到，年轻的时候文化大革命，书都没得读，支援边疆插队落户，等到老了，却要给年轻人机会了。他有足够的理由象成千上万那样的青年一样坐在那里抱怨生不逢时，怨气冲天。然而在分配到边疆的十年之后，国家恢复招研究生，他考回了原来的学校。研究生毕业，他被分配到了安徽一家小单位里，又是3年以后，国家第一届招收博士生，他又考回了原来的学校，成为中国第一代博士，那时的他比现在的我年纪还大。生活并没有放弃他，他也没有放弃生活。10年的等待，他做了他自己的选择，他没有放弃，他没有破罐子破摔，所以时机到来的时候，他改变了自己的人生。你最终会成为什么样的人，就决定在你的每个小小的选择之间。 

你选择相信什么？你选择和谁交朋友？你选择做什么？你选择怎么做？……我们面临太多的选择，而这些选择当中，意识形态层面的选择又远比客观条件的选择来得重要得多，比如选择做什么产品其实并不那么重要，而选择怎么做才重要。选择用什么人并不重要，而选择怎么带这些人才重要。大多数时候选择客观条件并不要紧，大多数关于客观条件的选择并没有对错之分，要紧的是选择怎么做。一个大学生毕业了，他要去微软也好，他要卖猪肉也好，他要创业也好，他要做游戏代练也好，只要不犯法，不害人，都没有什么关系，要紧的是，选择了以后，怎么把事情做好。 

除了这些，你还可以选择时间和环境，比如，你可以选择把这辈子最大的困难放在最有体力最有精力的时候，也可以走一步看一步，等到了40岁再说，只是到了40多岁，那正是一辈子最脆弱的时候，上有老下有小，如果在那个时候碰上了职业危机，实在是一件很苦恼的事情。与其如此不如在20多岁30多岁的时候吃点苦，好让自己脆弱的时候活得从容一些。你可以选择在温室里成长，也可以选择到野外磨砺，你可以选择在办公室吹冷气的工作，也可以选择40度的酷热下，去见你的客户，只是，这一切最终会累积起来，引导你到你应得的未来。 

我不敢说所有的事情你都有得选择，但是绝大部分事情你有选择，只是往往你不把这当作一种选择。认真对待每一次选择，才会有比较好的未来。 

九、选择职业 

职业的选择，总的来说，无非就是销售、市场、客服、物流、行政、人事、财务、技术、管理几个大类，有个有趣的现象就是，500强的CEO当中最多的是销售出身，第二多的人是财务出身，这两者加起来大概超过95％。现代IT行业也有技术出身成为老板的，但实际上，后来他们还是从事了很多销售和市场的工作，并且表现出色，公司才获得了成功，完全靠技术能力成为公司老板的，几乎没有。这是有原因的，因为销售就是一门跟人打交道的学问，而管理其实也是跟人打交道的学问，这两者之中有很多相通的东西，他们的共同目标就是“让别人去做某件特定的事情。”而财务则是从数字的层面了解生意的本质，从宏观上看待生意的本质，对于一个生意是否挣钱，是否可以正常运作有着最深刻的认识。 

公司小的时候是销售主导公司，而公司大的时候是财务主导公司，销售的局限性在于只看人情不看数字，财务的局限性在于只看数字不看人情。公司初期，运营成本低，有订单就活得下去，跟客户也没有什么谈判的条件，别人肯给生意做已经谢天谢地了，这个时候订单压倒一切，客户的要求压倒一切，所以当然要顾人情。公司大了以后，一切都要规范化，免得因为不规范引起一些不必要的风险，同时运营成本也变高，必须提高利润率，把有限的资金放到最有产出的地方。对于上市公司来说，股东才不管你客户是不是最近出国，最近是不是那个省又在搞严打，到了时候就要把业绩拿出来，拿不出来就抛股票，这个时候就是数字压倒一切。 

前两天听到有人说一句话觉得很有道理，开始的时候我们想“能做什么？”，等到公司做大了有规模了，我们想“不能做什么。”很多人在工作中觉得为什么领导这么保守，这也不行那也不行，错过很多机会。很多时候是因为，你还年轻，你想的是“能做什么”，而作为公司领导要考虑的方面很多，他比较关心“不能做什么”。 

我并非鼓吹大家都去做销售或者财务，究竟选择什么样的职业，和你究竟要选择什么样的人生有关系，有些人就喜欢下班按时回家，看看书听听音乐，那也挺好，但就不适合找个销售的工作了，否则会是折磨自己。有些人就喜欢出风头，喜欢成为一群人的中心，如果选择做财务工作，大概也干不久，因为一般老板不喜欢财务太积极，也不喜欢财务话太多。先想好自己要过怎样的人生，再决定要找什么样的职业。有很多的不快乐，其实是源自不满足，而不满足，很多时候是源自于心不定，而心不定则是因为不清楚究竟自己要什么，不清楚要什么的结果就是什么都想要，结果什么都没得到。 
我想，我们还是因为生活而工作，不是因为工作而生活，生活是最要紧的，工作只是生活中的一部分。我总是觉得生活的各方方面都是相互影响的，如果生活本身一团乱麻，工作也不会顺利。所以要有娱乐、要有社交、要锻炼身体，要有和睦的家庭……最要紧的，要开心，我的两个销售找我聊天，一肚子苦水，我问他们， 2年以前，你什么都没有，工资不高，没有客户关系，没有业绩，处于被开的边缘，现在的你比那时条件好了很多，为什么现在却更加不开心了？如果你做得越好越不开心，那你为什么还要工作？首先的首先，人还是要让自己高兴起来，让自己心态好起来，这种发自内心的改变会让你更有耐心，更有信心，更有气质，更能包容……否则，看看镜子里的你，你满意么？ 

有人会说，你说得容易，我每天加班，不加班老板就会把我炒掉，每天累得要死，哪有时间娱乐、社交、锻炼？那是人们把目标设定太高的缘故，如果你还在动不动就会被老板炒掉的边缘，那么你当然不能设立太高的目标，难道你还想每天去打高尔夫？你没时间去健身房锻炼身体，但是上下班的时候多走几步可以吧，有楼梯的时候走走楼梯不走电梯可以吧？办公的间隙扭扭脖子拉拉肩膀做做俯卧撑可以吧？谁规定锻炼就一定要拿出每天2个小时去健身房？你没时间社交，每月参加郊游一次可以吧，周末去参加个什么音乐班，绘画班之类的可以吧，去尝试认识一些同行，和他们找机会交流交流可以吧？开始的时候总是有些难的，但迈出这一步就会向良性循环的方向发展。而每天工作得很苦闷，剩下的时间用来咀嚼苦闷，只会陷入恶性循环，让生活更加糟糕。 

虽然离开惠普仅有十五天，但感觉上惠普已经离我很远。我的心思更多放在规划自己第二阶段的人生，这并非代表我对惠普没有任何眷恋，主要还是想以此驱动自己往前走。 

万科王石登珠穆朗玛峰的体验给我很多启发，虽然在出发时携带大量的物资，但是登顶的过程中，必须不断减轻负荷，最终只有一个氧气瓶和他登上峰顶。登山如此，漫长的人生又何尝不是。 
我宣布退休后，接到同事朋友同学的祝贺。大部分人都认为我能够在这样的职位上及年龄选择退休，是一种勇气，也是一种福气。 
还有一部分人怀疑我只是借此机会换个工作，当然还有一些人说我在HP做不下去了，趁此机会离开。 
我多年来已经习惯别人对我的说三道四，但对于好友，我还是挺关心大家是否真正理解我的想法，这也是写这篇文章的目的。 
由于受我父亲早逝的影响，我很早就下定决心，要在有生之年实现自己的愿望，我不要像我父亲一样，为家庭生活忙碌一辈子，临终前感伤，懊恼自己有很多没有实现的理想。 
一本杂志的文章提到我们在生前就应该思考自己的墓志铭，因为那代表你自己对完美人生的定义，我们应该尽可能在有生之年去实现它。 
我希望我的墓志铭上除了与家人及好友有关的内容外，是这样写着： 
1.这个人曾经服务于一家全球最大的IT公司（HP）25年，和她一起经历过数次重大的变革，看着她从以电子仪表为主要的业务变革成全球最大的IT公司。 
2.这个人曾经在全球发展最快的国家（中国）工作16年，并担任HP中国区总裁7年，见证及经历过中国改革开放的关键最新突破阶段，与中国一起成长。 
3.这个人热爱飞行，曾经是一个有执照的飞行员，累积飞行时数超过X小时，曾经在X个机场起降过。 
4.这个人曾经获得管理硕士学位，在领导管理上特别关注中国企业的组织行为及绩效，并且在这个领域上获得中国企业界的认可。 
我费时25年才总结1和2两项成果，我不知还要费时多久才能达成3和4的愿望，特别是第4个愿望需要经历学术的训练，才能将我的经验总结成知识。 
否则我的经验将无法有效影响及传授他人。因此重新进入学校学习，拿一个管理学位是有必要的，更何况这是我一个非常重要的愿望。 
另一方面，我25年的时间都花在运营(operation)的领域，兢兢业业的做好职业人士的工作，它是一份好工作，特别是在HP，这份工作也帮助我建立财务的基础，支持家庭的发展。 
但是我不想终其一生，都陷入在运营的领域，我想象企业家一样，有机会靠一些点子(ideas)赚钱，虽然风险很高，但是值得一试，即使失败，也不枉走一回，这也是第4个愿望其中的一部份。 
Carly Fiorina曾经对我说过“这个世界上有好想法的人很多，但有能力去实现的人很少”，2007年5月21日在北大演讲时，有人问起那些书对我影响较大，我想对我人生观有影响的其中一本书叫“TriggerPoint”，它的主要观点是：人生最需要的不是规划，而是在适当的时机掌握机会，采取行动。 
我这些愿望在我心中已经酝酿一段很长的时间，开始的时候，也许一年想个一两次，过了也就忘掉，但逐渐的，这个心中的声音，愈来愈大，出现的频率也愈来愈高，当它几乎每一个星期都会来与我对话时，我知道时机已经成熟。 
但和任何人一样，要丢掉自己现在所拥有的，所熟悉的环境及稳定的收入，转到一条自己未曾经历过，存在未知风险的道路，需要绝大的勇气，家人的支持和好友的鼓励。有舍才有得，真是知易行难，我很高兴自己终于跨出了第一步。 
我要感谢HP的EER提前退休优惠政策，它是其中一个关键的TriggerPoints,另一个关键因素是在去年五六月发生的事。 
当时我家老大从大学毕业，老二从高中毕业，在他们继续工作及求学前，这是一个黄金时段，让我们全家可以相聚一段较长的时间，我为此很早就计划休一个长假，带着他们到各地游玩。 
但这个计划因为工作上一件重要的事情（Mark Hurd访华）不得不取消。这个事件刺激了我必须严肃的去对待那心中的声音，我会不会继续不断的错失很多关键的机会? 
我已经年过50，我会不会走向和我父亲一样的道路？人事部老总Charles跟我说，很多人在所有对他有利的星星都排成一列时，还是错失时机。 
我知道原因，因为割舍及改变对人是多么的困难，我相信大部分的人都有自己人生的理想，但我也相信很多人最终只是把这些理想当成是幻想，然后不断的为自己寻找不能实现的藉口，南非前总统曼德拉曾经说过，“与改变世界相比，改变自己更困难”，真是一针见血。 
什么是快乐及有意义的人生？我相信每一个人的定义都不一样，对我来说，能实现我墓志铭上的内容就是我的定义。 
在中国惠普总裁的位置上固然可以吸引很多的关注及眼球，但是我太太及较亲近的好友，都知道那不是我追求的，那只是为扮演好这个角色必须尽力做好的地方。 
做一个没有名片的人士，虽然只有十多天的时间，但我发现我的脑袋里已经空出很多空间及能量，让我可以静心的为我ChapterII的新生活做细致的调研及规划。 
我预订以两年的时间来完成转轨的准备工作，并且花多点时间与家人共处。这两年的时间我希望拿到飞行执照，拿到管理有关的硕士学位，提升英文的水平，建立新的网络，多认识不同行业的人，保持与大陆的联系。希望两年后，我可以顺利回到大陆去实现我第四个愿望。 
毫不意外，在生活上，我发现很多需要调整的地方。 
二十多年来，我生活的步调及节奏，几乎完全被公司及工作所左右，不断涌出的deadline及任务驱动我每天的安排，一旦离开这样的环境，第一个需要调整的就是要依靠自己的自律及意志力来驱动每天的活动，睡觉睡到自然醒的态度绝对不正确，放松自己，不给事情设定目标及时间表，或者对错失时间目标无所谓，也不正确，没有年度，季度，月及周计划也不正确。 
担任高层经理多年，已经养成交待事情的习惯，自己的时间主要花在思考，决策及追踪项目的进展情况，更多是依靠一个庞大的团队来执行具体的事项及秘书来处理很多协调及繁琐的事情。 
到美国后，很多事情需要打800号电话联系，但这些电话很忙，常让你在waitingline上等待很长的时间，当我在等待时，我可以体会以前秘书工作辛苦的地方，但同时也提醒我自己，在这个阶段要改变态度，培养更大的耐性及自己动手做的能力。 
生活的内容也要做出很大的调整，多出时间锻炼身体，多出时间关注家人，多出时间关注朋友，多出时间体验不同的休闲活动及飞行，一步步的，希望生活逐步调整到我所期望的轨道上，期待这两年的生活既充实又充满乐趣及意义。 
第一个快乐的体验就是准备及参加大儿子的订婚礼，那种全心投入，不需担忧工作数字的感觉真好。同时我也租好了公寓，买好了家具及车子，陪家人在周末的时候到Reno及Lake Tahoe玩了一趟，LakeTahoe我去了多次，但这次的体验有所不同，我从心里欣赏到它的美丽。 
但同时我也在加紧调研的工作，为申请大学及飞行学校做准备，这段时间也和在硅谷的朋友及一些风险投资公司见面，了解不同的产业。 
我的人生观是“完美的演出来自充分的准备”，“勇于改变自己，适应不断变化的环境，机会将不断出现”，“快乐及有意义的人生来自于实现自己心中的愿望，而非外在的掌声”。 
我离开时，有两位好朋友送给我两个不同的祝语，Baron的是“多年功过化烟尘”，杨华的是“莫春者，风乎舞雩，咏而归”，它们分别代表了我离开惠普及走向未来的心情。 
我总结人生有三个阶段，一个阶段是为现实找一份工作，一个阶段是为现实，但可以选择一份自己愿意投入的工作，一个阶段是为理想去做一些事情。 
我珍惜我的福气，感激HP及同事、好朋友给我的支持，鼓励及协助，这篇文字化我心声的文章与好友分享。 

一、要解决这个问题首先要知道json格式是什么？

JSON格式：
比如学生有学号，姓名，性别等。
用json表示则为：
{"studno":"11111","studname":"wwww","studsex":"男"}(各个字段都是字符型）

这代表一个学生的信息。

如果多个呢？

[{"studno":"122222","studname":"wwww","studsex":"男"},
{"studno":"11111","studname":"xxxx","studsex":"男"},
{"studno":"33333","studname":"ssss","studsex":"男"}]

这就是json格式。

二、那如何操作json格式的文件呢？

这个更简单了，说白了就是直接读写文件，再把读出来的文件内容格式化成json就可以了。

三、具体操作。

1.我有一个实体类，如下：

public class ElectSet {
public String xueqi;
public String xuenian;
public String startTime;
public String endTime;
public int menshu;
public String isReadDB;
//{"xueqi":,"xuenian":,"startTime":,"endTime":,"renshu":,"isReadDB":}
public String getXueqi() {
   return xueqi;
}
public void setXueqi(String xueqi) {
   this.xueqi = xueqi;
}
public String getXuenian() {
   return xuenian;
}
public void setXuenian(String xuenian) {
   this.xuenian = xuenian;
}
public String getStartTime() {
   return startTime;
}
public void setStartTime(String startTime) {
   this.startTime = startTime;
}
public String getEndTime() {
   return endTime;
}
public void setEndTime(String endTime) {
   this.endTime = endTime;
}
public int getMenshu() {
   return menshu;
}
public void setMenshu(int menshu) {
   this.menshu = menshu;
}
public String getIsReadDB() {
   return isReadDB;
}
public void setIsReadDB(String isReadDB) {
   this.isReadDB = isReadDB;
}

}

2.有一个json格式的文件，存的就是他的信息，如下

Sets.json:
{"xuenian":"2007-2008","xueqi":"1","startTime":"2009-07-19 08:30","endTime":"2009-07-22 18:00","menshu":"10","isReadDB":"Y"}

3.具体操作.
/*
* 取出文件内容，填充对象
*/
public ElectSet findElectSet(String path){
   ElectSet electset=new ElectSet();
   String sets=ReadFile(path);//获得json文件的内容
   JSONObject jo=JSONObject.fromObject(sets);//格式化成json对象
   //System.out.println("------------" jo);
   //String name = jo.getString("xuenian");
   //System.out.println(name);
   electset.setXueqi(jo.getString("xueqi"));
   electset.setXuenian(jo.getString("xuenian"));
   electset.setStartTime(jo.getString("startTime"));
   electset.setEndTime(jo.getString("endTime"));
   electset.setMenshu(jo.getInt("menshu"));
   electset.setIsReadDB(jo.getString("isReadDB"));
   return electset;
}
//设置属性，并保存
public boolean setElect(String path,String sets){
   try {
    writeFile(path,sets);
    return true;
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    return false;
   }
}
//读文件，返回字符串
public String ReadFile(String path){
    File file = new File(path);
    BufferedReader reader = null;
    String laststr = "";
    try {
     //System.out.println("以行为单位读取文件内容，一次读一整行：");
     reader = new BufferedReader(new FileReader(file));
     String tempString = null;
     int line = 1;
     //一次读入一行，直到读入null为文件结束
     while ((tempString = reader.readLine()) != null) {
      //显示行号
      System.out.println("line " line ": " tempString);
      laststr = laststr tempString;
      line ;
     }
     reader.close();
    } catch (IOException e) {
     e.printStackTrace();
    } finally {
     if (reader != null) {
      try {
       reader.close();
      } catch (IOException e1) {
      }
     }
    }
    return laststr;
}
         //把json格式的字符串写到文件
public void writeFile(String filePath, String sets) throws IOException {
    FileWriter fw = new FileWriter(filePath);
    PrintWriter out = new PrintWriter(fw);
    out.write(sets);
    out.println();
    fw.close();
    out.close();
   }

4.调用，使用（在网站的controller里调用的）

//取出json对象
public void GetElectSettings(HttpServletRequest request,
    HttpServletResponse response) throws Exception {
   ElectSet electset=new ElectSet();
   String absPath = request.getRealPath("\");
   String filePath = absPath "public\sets\electSets.json";
   electset=businessService.findElectSets(filePath);//这里是调用，大家自己改改，我调用的业务层的。
   JSONArray jsonItems = new JSONArray();
   jsonItems.add(electset);
   JSONObject jo=new JSONObject();
   jo.put("data", jsonItems);
   System.out.println(jo);
   request.setCharacterEncoding("utf-8");
   response.setContentType("application/json;charset=utf-8");
   PrintWriter out = response.getWriter();
   out.print(jo);
}

//修改json文件
public void ChangeElectSet(HttpServletRequest request,
    HttpServletResponse response) throws Exception {
   request.setCharacterEncoding("UTF-8");
   response.setContentType("text/json;charset=utf-8");
   log.info("reach ChangeElectSet");
   String json = (String) request.getParameter("json").trim();
   log.info("Change ElectSet");
   log.info(json);
   ElectSet sets = new ElectSet();
   JSONObject jsonObject = JSONObject.fromObject(json);
   sets = (ElectSet) JSONObject.toBean(jsonObject, ElectSet.class);
   if(sets.getIsReadDB()=="false"){
    sets.setIsReadDB("否");
   }
   else{
    sets.setIsReadDB("是");
   }
   String changes="{"xuenian":"";//因为json的属性要用引号，所以要用"转义一下
   changes =sets.getXuenian() "","xueqi":"" sets.getXueqi() "","startTime":"" sets.getStartTime() "","endTime":"" sets.getEndTime() "","menshu":"" sets.getMenshu() "","isReadDB":"" sets.getIsReadDB() ""}";
   System.out.println(changes);
   String absPath = request.getRealPath("\");
   String filePath = absPath "public\sets\electSets.json";

javascript遍历表格所有的值  2012-04-24 09:49:25|  分类： Javascript |  标签： |字号大中小 订阅 .


javascript代码
function getData()
{
var arrData=[];
  var objTable=document.getElementById("myTable");
  
  if(objTable)
  {
     for(var i=0;i<objTable.rows.length;i++)
     {
        for(var j=0;j<objTable.rows[1].cells.length;j++)
        {
            arrData.push(objTable.rows[i].cells[j].innerHTML);   
        }
     }
  }
  alert(arrData.join(","));
}
}

html代码
<table border="1" id="myTable">
<tr><td>liu</td><td>jin</td><td>cai</td></tr>
<tr><td>liu2</td><td>jin2</td><td>cai2</td></tr>
<tr><td>liu3</td><td>jin3</td><td>cai3</td></tr>
</table>
<form>
<input type="button" value="getData" onclick="getData();" />
</form>

摘要: 　　最近要用到的javascript也比较多，前段时间加上创恩培训的学员也正在学习javascript部分的知识，今天就我这段时间收集的javascript的一些基础知识做个归纳，并在此与大家一起分享。1.document.write("");为 输出 ...
　　最近要用到的javascript也比较多，前段时间加上创恩培训的学员也正在学习javascript部分的知识，今天就我这段时间收集的javascript的一些基础知识做个归纳，并在此与大家一起分享。


1.document.write("");为 输出语句 
 2.js中的注释为//  


3.传统的HTML文档顺序是:document->html->(head,body) 


 4.一个浏览器窗口中的DOM顺序是:window->(navigator,screen,history,location,document) 
 
5.得到表单中元素的名称和值:document.getElementById("表单中元素的ID号").name(或value)  


6.一个小写转大写的JS: document.getElementById("output").value = document.getElementById("input").value.toUpperCase(); 


 7.JS中的值类型:String,Number,Boolean,Null,Object,Function  
8.JS中的字符型转换成数值型:parseInt(),parseFloat()  


9.JS中的数字转换成字符型:(""+变量)  
10.JS中的取字符串长度是:(length)  


11.JS中的字符与字符相连接使用+号.  


12.JS中的比较操作符有:==等于,!=不等于,>,>=,<.<= 


 13.JS中声明变量使用:var来进行声明 


 14.JS中的判断语句结构:if(condition){}else{}  


15.JS中的循环结构:for([initial expression];[condition];[upadte expression]) {inside loop}  


16.循环中止的命令是:break 


17.JS中的函数定义:function functionName([parameter],...){statement[s]} 


 18.当文件中出现多个form表单时.可以用document.forms[0],document.forms[1]来代替.  


19.窗口:打开窗口window.open(), 关闭一个窗口:window.close(), 窗口本身:self 


 20.状态栏的设置:window.status="字符";  


21.弹出提示信息:window.alert("字符");  


22.弹出确认框:window.confirm();  


23.弹出输入提示框:window.prompt();  


24.指定当前显示链接的位置:window.location.href="URL"


 25.取出窗体中的所有表单的数量:document.forms.length  


26.关闭文档的输出流:document.close();  


27.字符串追加连接符:+= 


 28.创建一个文档元素:document.createElement(),document.createTextNode()  


29.得到元素的方法:document.getElementById()  


30.设置表单中所有文本型的成员的值为空:  var form = window.document.forms[0]  for (var i = 0; i 


 49.引用一个文件式的JS:  


50.指定在不支持脚本的浏览器显示的HTML:

  51.当超链和ONCLICK事件都有时,则老版本的浏览器转向a.html,否则转向b.html.例:dfsadf 


 52.JS的内建对象有:Array,Boolean,Date,Error,EvalError,Function,Math,Number,Object,RangeError,ReferenceError,RegExp,String,SyntaxError,TypeError,URIError  


53.JS中的换行:\n 


 54.窗口全屏大小:  55.JS中的all代表其下层的全部元素   


  56.JS中的焦点顺序:document.getElementByid("表单元素").tabIndex = 1  


57.innerHTML的值是表单元素的值:如 
"how are you" 


,则innerHTML的值就是:how are you  
58.innerTEXT的值和上面的一样,只不过不会把这种标记显示出来.  


59.contentEditable可设置元素是否可被修改,isContentEditable返回是否可修改的状态. 


 60.isDisabled判断是否为禁止状态.disabled设置禁止状态  


61.length取得长度,返回整型数值  


62.addBehavior()是一种JS调用的外部函数文件其扩展名为.htc  


63.window.focus()使当前的窗口在所有窗口之前.  


64.blur()指失去焦点.与FOCUS()相反. 


65.select()指元素为选中状态. 


 66.防止用户对文本框中输


67.取出该元素在页面中出现的数量:document.all.tags("div(或其它HTML标记符)").length 


 68.JS中分为两种窗体输出:模态和非模态.window.showModaldialog(),window.showModeless() 


 69.状态栏文字的设置:window.status='文字',默认的状态栏文字设置:window.defaultStatus = '文字.';  


70.添加到收藏夹:external.AddFavorite("http://www.google.com","Google"); 


 71.JS中遇到脚本错误时不做任何操作:window.onerror = doNothing; 指定错误句柄的语法为:window.onerror = handleError;  


72.JS中指定当前打开窗口的父窗口:window.opener,支持opener.opener...的多重继续.  73.JS中的self指的是当前的窗口


  74.JS中状态栏显示内容:window.status="内容"


 75.JS中的top指的是框架集中最顶层的框架 


76.JS中关闭当前的窗口:window.close();


  77.JS中提出是否确认的框:if(confirm("Are you sure?")){alert("ok");}else{alert("Not Ok");} 


 78.JS中的窗口重定向:window.navigate("http://www.google.com"); 


 79.JS中的打印:window.print()  


80.JS中的提示输入框:window.prompt("message","defaultReply");  


81.JS中的窗口滚动条:window.scroll(x,y)  


82.JS中的窗口滚动到位置:window.scrollby


  83.JS中设置时间间隔:setInterval("expr",msecDelay)或setInterval(funcRef,msecDelay)或setTimeout 


 84.JS中的模态显示在IE4+行,在NN中不行:showModalDialog("URL"[,arguments][,features]); 


 85.JS中的退出之前使用的句柄:function verifyClose(){event.returnValue="we really like you and hope you will stay longer.";}}   window.onbeforeunload=verifyClose; 


 86.当窗体第一次调用时使用的文件句柄:onload()  


87.当窗体关闭时调用的文件句柄:onunload()  


88.window.location的属性: protocol(http:),hostname(www.example.com),port(80),host(www.example.com:80),pathname("/a/a.html"),hash("#giantGizmo",指跳转到相应的锚记),href(全部的信息)  
89.window.location.reload()刷新当前页面. 


 89-1.parent.location.reload()刷新父亲对象（用于框架）  


89-2.opener.location.reload()刷新父窗口对象（用于单开窗口） 


 89-3.top.location.reload()刷新最顶端对象（用于多开窗口）  


90.window.history.back()返回上一页,window.history.forward()返回下一页,window.history.go(返回第几页,也可以使用访问过的URL) 


 91.document.write()不换行的输出,document.writeln()换行输出 


 92.document.body.noWrap=true;防止链接文字折行. 


 93.变量名.charAt(第几位),取该变量的第几位的字符. 


 94."abc".charCodeAt(第几个),返回第几个字符的ASCii码值. 


 95.字符串连接:string.concat(string2),或用+=进行连接  


96.变量.indexOf("字符",起始位置),返回第一个出现的位置(从0开始计算) 


 97.string.lastIndexOf(searchString[,startIndex])最后一次出现的位置. 


98.string.match(regExpression),判断字符是否匹配. 


 99.string.replace(regExpression,replaceString)替换现有字符串. 


 100.string.split(分隔符)返回一个数组存储值.  101.string.substr(start[,length])取从第几位到指定长度的字符串. 


 102.string.toLowerCase()使字符串全部变为小写.  


103.string.toUpperCase()使全部字符变为大写. 


 104.parseInt(string[,radix(代表进制)])强制转换成整型.  


105.parseFloat(string[,radix])强制转换成浮点型. 


 106.isNaN(变量):测试是否为数值型.  


107.定义常量的关键字:const,定义变量的关键字:var 

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>JavaScript 图片滑动切换效果</title>
<script type="text/javascript">
var $ = function (id) {
	return "string" == typeof id ? document.getElementById(id) : id;
};

var Extend = function(destination, source) {
	for (var property in source) {
		destination[property] = source[property];
	}
	return destination;
}

var CurrentStyle = function(element){
	return element.currentStyle || document.defaultView.getComputedStyle(element, null);
}

var Bind = function(object, fun) {
	var args = Array.prototype.slice.call(arguments).slice(2);
	return function() {
		return fun.apply(object, args.concat(Array.prototype.slice.call(arguments)));
	}
}

var Tween = {
	Quart: {
		easeOut: function(t,b,c,d){
			return -c * ((t=t/d-1)*t*t*t - 1) + b;
		}
	},
	Back: {
		easeOut: function(t,b,c,d,s){
			if (s == undefined) s = 1.70158;
			return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b;
		}
	},
	Bounce: {
		easeOut: function(t,b,c,d){
			if ((t/=d) < (1/2.75)) {
				return c*(7.5625*t*t) + b;
			} else if (t < (2/2.75)) {
				return c*(7.5625*(t-=(1.5/2.75))*t + .75) + b;
			} else if (t < (2.5/2.75)) {
				return c*(7.5625*(t-=(2.25/2.75))*t + .9375) + b;
			} else {
				return c*(7.5625*(t-=(2.625/2.75))*t + .984375) + b;
			}
		}
	}
}


//容器对象,滑动对象,切换数量
var SlideTrans = function(container, slider, count, options) {
	this._slider = $(slider);
	this._container = $(container);//容器对象
	this._timer = null;//定时器
	this._count = Math.abs(count);//切换数量
	this._target = 0;//目标值
	this._t = this._b = this._c = 0;//tween参数
	
	this.Index = 0;//当前索引
	
	this.SetOptions(options);
	
	this.Auto = !!this.options.Auto;
	this.Duration = Math.abs(this.options.Duration);
	this.Time = Math.abs(this.options.Time);
	this.Pause = Math.abs(this.options.Pause);
	this.Tween = this.options.Tween;
	this.onStart = this.options.onStart;
	this.onFinish = this.options.onFinish;
	
	var bVertical = !!this.options.Vertical;
	this._css = bVertical ? "top" : "left";//方向
	
	//样式设置
	var p = CurrentStyle(this._container).position;
	p == "relative" || p == "absolute" || (this._container.style.position = "relative");
	this._container.style.overflow = "hidden";
	this._slider.style.position = "absolute";
	
	this.Change = this.options.Change ? this.options.Change :
		this._slider[bVertical ? "offsetHeight" : "offsetWidth"] / this._count;
};
SlideTrans.prototype = {
  //设置默认属性
  SetOptions: function(options) {
	this.options = {//默认值
		Vertical:	true,//是否垂直方向（方向不能改）
		Auto:		true,//是否自动
		Change:		0,//改变量
		Duration:	50,//滑动持续时间
		Time:		10,//滑动延时
		Pause:		2000,//停顿时间(Auto为true时有效)
		onStart:	function(){},//开始转换时执行
		onFinish:	function(){},//完成转换时执行
		Tween:		Tween.Quart.easeOut//tween算子
	};
	Extend(this.options, options || {});
  },
  //开始切换
  Run: function(index) {
	//修正index
	index == undefined && (index = this.Index);
	index < 0 && (index = this._count - 1) || index >= this._count && (index = 0);
	//设置参数
	this._target = -Math.abs(this.Change) * (this.Index = index);
	this._t = 0;
	this._b = parseInt(CurrentStyle(this._slider)[this.options.Vertical ? "top" : "left"]);
	this._c = this._target - this._b;
	
	this.onStart();
	this.Move();
  },
  //移动
  Move: function() {
	clearTimeout(this._timer);
	//未到达目标继续移动否则进行下一次滑动
	if (this._c && this._t < this.Duration) {
		this.MoveTo(Math.round(this.Tween(this._t++, this._b, this._c, this.Duration)));
		this._timer = setTimeout(Bind(this, this.Move), this.Time);
	}else{
		this.MoveTo(this._target);
		this.Auto && (this._timer = setTimeout(Bind(this, this.Next), this.Pause));
	}
  },
  //移动到
  MoveTo: function(i) {
	this._slider.style[this._css] = i + "px";
  },
  //下一个
  Next: function() {
	this.Run(++this.Index);
  },
  //上一个
  Previous: function() {
	this.Run(--this.Index);
  },
  //停止
  Stop: function() {
	clearTimeout(this._timer); this.MoveTo(this._target);
  }
};
</script>
</head>
<body>
<style type="text/css"> 
.container, .container img{width:280px; height:200px;}
.container{border:1px solid #333;}
.container img{border:0;}
</style>
<div class="container" id="idContainer">
	<table id="idSlider" border="0" cellpadding="0" cellspacing="0">
		<tr>
			<td><a href="http://www.cnblogs.com/cloudgamer/archive/2009/01/06/Tween.html"><img src="/articleimg/2009/09/7031/r_rt_1.jpg"/></a></td>
		</tr>
		<tr>
			<td><a href="http://www.cnblogs.com/cloudgamer/archive/2008/07/21/ImgCropper.html"><img src="/articleimg/2009/09/7031/r_rt_5.jpg"/></a></td>
		</tr>
		<tr>
			<td><a href="http://www.cnblogs.com/cloudgamer/archive/2008/11/17/Drag.html"><img src="/articleimg/2009/09/7031/r_rt_3.jpg"/></a></td>
		</tr>
	</table>
</div>
<br />
<br />
<style type="text/css">
.num{ position:absolute; right:5px; bottom:5px;}
.num li{
	float: left;
	list-style:none;
	color: #fff;
	text-align: center;
	line-height: 16px;
	width: 16px;
	height: 16px;
	font-family: Arial;
	font-size: 12px;
	cursor: pointer;
	margin: 1px;
	border: 1px solid #707070;
	background-color: #060a0b;
}
.num li.on{
	line-height: 18px;
	width: 18px;
	height: 18px;
	font-size: 14px;
	border: 0;
	background-color: #ce0609;
	font-weight: bold;
}
</style>
<div class="container" id="idContainer2">
	<table id="idSlider2" border="0" cellpadding="0" cellspacing="0">
		<tr>
			<td><a href="http://www.cnblogs.com/cloudgamer/archive/2009/03/11/color.html"><img src="/articleimg/2009/09/7031/r_4.jpg"/></a></td>
			<td><a href="http://www.cnblogs.com/cloudgamer/archive/2008/12/24/Slider.html"><img src="/articleimg/2009/09/7031/r_3.jpg"/></a></td>
			<td><a href="http://www.cnblogs.com/cloudgamer/archive/2008/12/03/Resize.html"><img src="/articleimg/2009/09/7031/r_rt_2.jpg"/></a></td>
		</tr>
	</table>
	<ul class="num" id="idNum">
	</ul>
</div>
<br />
<div>
	<input id="idAuto" type="button" value="停止" />
	<input id="idPre" type="button" value="<<" />
	<input id="idNext" type="button" value=">>" />
	<select id="idTween">
		<option value="0">默认缓动</option>
		<option value="1">方式1</option>
		<option value="2">方式2</option>
	</select>
</div>
<script>

new SlideTrans("idContainer", "idSlider", 3).Run();

///////////////////////////////////////////////////////////

var forEach = function(array, callback, thisObject){
	if(array.forEach){
		array.forEach(callback, thisObject);
	}else{
		for (var i = 0, len = array.length; i < len; i++) { callback.call(thisObject, array[i], i, array); }
	}
}

var st = new SlideTrans("idContainer2", "idSlider2", 3, { Vertical: false });

var nums = [];
//插入数字
for(var i = 0, n = st._count - 1; i <= n;){
	(nums[i] = $("idNum").appendChild(document.createElement("li"))).innerHTML = ++i;
}

forEach(nums, function(o, i){
	o.onmouseover = function(){ o.className = "on"; st.Auto = false; st.Run(i); }
	o.onmouseout = function(){ o.className = ""; st.Auto = true; st.Run(); }
})

//设置按钮样式
st.onStart = function(){
	forEach(nums, function(o, i){ o.className = st.Index == i ? "on" : ""; })
}

$("idAuto").onclick = function(){
	if(st.Auto){
		st.Auto = false; st.Stop(); this.value = "自动";
	}else{
		st.Auto = true; st.Run(); this.value = "停止";
	}
}
$("idNext").onclick = function(){ st.Next(); }
$("idPre").onclick = function(){ st.Previous(); }

$("idTween").onchange = function(){
	switch (parseInt(this.value)){
		case 2 :
			st.Tween = Tween.Bounce.easeOut; break;
		case 1 :
			st.Tween = Tween.Back.easeOut; break;
		default :
			st.Tween = Tween.Quart.easeOut;
	}
}


st.Run();
</script>
</body>
</html>

J2EE学习者越来越多，J2EE本身技术不断在发展，涌现出各种概念，本文章试图从一种容易理解的角度对这些概念向初学者进行解释，以便掌握学习 J2EE学习方向。 首先我们需要知道Java和J2EE是两个不同概念，Java不只是指一种语言，已经代表与微软不同的另外一个巨大阵营，所以Java有时是指一种
J2EE学习者越来越多，J2EE本身技术不断在发展，涌现出各种概念，本文章试图从一种容易理解的角度对这些概念向初学者进行解释，以便掌握学习 J2EE学习方向。
首先我们需要知道Java和J2EE是两个不同概念，Java不只是指一种语言，已经代表与微软不同的另外一个巨大阵营，所以Java有时是指一种软件系统的流派，当然目前主要是.NET和Java两大主流体系。
J2EE可以说指Java在数据库信息系统上实现，数据库信息系统从早期的dBase、到Delphi/VB等C/S结构，发展到B /S（Browser浏览器/Server服务器）结构，而J2EE主要是指B/S结构的实现。
J2EE又是一种框架和标准，框架类似API、库的概念，但是要超出它们。如果需要详细了解框架，可先从设计模式开始学习。
J2EE是一个虚的大的概念，J2EE标准主要有三种子技术标准：WEB技术、EJB技术和JMS，谈到J2EE应该说最终要落实到这三个子概念上。
这三种技术的每个技术在应用时都涉及两个部分：容器部分和应用部分，Web容器也是指Jsp/Servlet容器，你如果要开发一个Web应用，无论是编译或运行，都必须要有Jsp/Servlet库或API支持（除了JDK/J2SE以外）。
Web技术中除了Jsp/Servlet技术外，还需要JavaBeans或Java Class实现一些功能或者包装携带数据，所以Web技术最初裸体简称为Jsp/Servlet+JavaBeans系统。
谈到JavaBeans技术，就涉及到组件构件技术（component），这是Java的核心基础部分，很多软件设计概念（设计模式）都是通过 JavaBeans实现的。
JavaBeans不属于J2EE概念范畴中，如果一个JavaBeans对象被Web技术（也就是Jsp/Servlet）调用，那么 JavaBeans就运行在J2EE的Web容器中；如果它被EJB调用，它就运行在EJB容器中。
EJB（企业JavaBeans）是普通JavaBeans的一种提升和规范，因为企业信息系统开发中需要一个可伸缩的性能和事务、安全机制，这样能保证企业系统平滑发展，而不是发展到一种规模重新更换一套软件系统。
至此，JavaBeans组件发展到EJB后，并不是说以前的那种JavaBeans形式就消失了，这就自然形成了两种JavaBeans技术：EJB 和POJO，POJO完全不同于EJB概念，指的是普通JavaBeans，而且这个JavaBeans不依附某种框架，或者干脆可以说：这个 JavaBeans是你为这个应用程序单独开发创建的。
J2EE应用系统开发工具有很多：如JBuilder、Eclipse等，这些IDE首先是Java开发工具，也就是说，它们首要基本功能是可以开发出JavaBeans或Java class，但是如果要开发出J2EE系统，就要落实到要么是Web技术或EJB技术，那么就有可能要一些专门模块功能(如eclipse需要 lomboz插件)，最重要的是，因为J2EE系统区分为容器和应用两个部分，所以，在任何开发工具中开发J2EE都需要指定J2EE容器。
J2EE容器分为WEB容器和EJB容器，Tomcat/Resin是Web容器；JBoss是EJB容器+Web容器等，其中Web容器直接使用 Tomcat实现的。所以你开发的Web应用程序可以在上面两种容器运行，而你开发的Web+EJB应用则只可以在JBoss服务器上运行，商业产品 Websphere/Weblogic等和JBoss属于同一种性质。
J2EE容器也称为J2EE服务器，大部分时它们概念是一致的。
如果你的J2EE应用系统的数据库连接是通过JNDI获得，也就是说是从容器中获得，那么你的J2EE应用系统基本与数据库无关，如果你在你的 J2EE 应用系统耦合了数据库JDBC驱动的配置，那么你的J2EE应用系统就有数据库概念色彩，作为一个成熟需要推广的J2EE应用系统，不推荐和具体数据库耦合，当然这其中如何保证J2EE应用系统运行性能又是体现你的设计水平了。
衡量J2EE应用系统设计开发水平高低的标准就是：解耦性；你的应用系统各个功能是否能够彻底脱离？是否不相互依赖，也只有这样，才能体现可维护性、可拓展性的软件设计目标。
为了达到这个目的，诞生各种框架概念，J2EE框架标准将一个系统划分为WEB和EJB主要部分，当然我们有时不是以这个具体技术区分，而是从设计上抽象为表现层、服务层和持久层，这三个层次从一个高度将J2EE分离开来，实现解耦目的。
因此，我们实际编程中，也要将自己的功能向这三个层次上靠，做到大方向清楚，泾渭分明，但是没有技术上约束限制要做到这点是很不容易的，因此我们还是必须借助J2EE具体技术来实现，这时，你可以使用EJB规范实现服务层和持久层，Web技术实现表现层；
EJB为什么能将服务层从Jsp/Servlet手中分离出来，因为它对JavaBeans编码有强制的约束，现在有一种对JavaBeans弱约束，使用Ioc模式实现的（当然EJB 3.0也采取这种方式），在Ioc模式诞生前，一般都是通过工厂模式来对JavaBeans约束，形成一个服务层，这也是是Jive这样开源论坛设计原理之一。
由此，将服务层从表现层中分离出来目前有两种可选架构选择：管理普通JavaBeans（POJO）框架(如Spring、 JdonFramework)以及管理EJB的EJB框架，因为EJB不只是框架，还是标准，而标准可以扩展发展，所以，这两种区别将来是可能模糊，被纳入同一个标准了。但是，个人认为：标准制定是为某个目的服务的，总要牺牲一些换取另外一些，所以，这两种架构会长时间并存。
这两种架构分歧也曾经诞生一个新名词：完全POJO的系统也称为轻量级系统(lightweight)，其实这个名词本身就没有一个严格定义，更多是一个吸引人的招牌，轻量是指容易学习容易使用吗？按照这个定义，其实轻量Spring等系统并不容易学习；而且EJB 3.0（依然叫EJB）以后的系统是否可称为轻量级了呢？
前面谈了服务层框架，使用服务层框架可以将JavaBeans从 Jsp/Servlet中分离出来，而使用表现层框架则可以将Jsp中剩余的JavaBeans完全分离，这部分JavaBeans主要负责显示相关，一般是通过标签库（taglib）实现，不同框架有不同自己的标签库，Struts是应用比较广泛的一种表现层框架。
这样，表现层和服务层的分离是通过两种框架达到目的，剩余的就是持久层框架了，通过持久层的框架将数据库存储从服务层中分离出来是其目的，持久层框架有两种方向：直接自己编写JDBC等SQL语句（如iBatis）；使用O/R Mapping技术实现的Hibernate和JDO技术；当然还有EJB中的实体Bean技术。
持久层框架目前呈现百花齐放，各有优缺点的现状，所以正如表现层框架一样，目前没有一个框架被指定为标准框架，当然，表现层框架现在又出来了一个 JSF，它代表的页面组件概念是一个新的发展方向，但是复杂的实现让人有些忘而却步。
在所有这些J2EE技术中，虽然SUN公司发挥了很大的作用，不过总体来说：网络上有这样一个评价：SUN的理论天下无敌；SUN的产品用起来撞墙；对于初学者，特别是那些试图通过或已经通过SUN认证的初学者，赶快摆脱SUN的阴影，立即开溜，使用开源领域的产品来实现自己的应用系统。
最后，你的J2EE应用系统如果采取上面提到的表现层、服务层和持久层的框架实现，基本你也可以在无需深刻掌握设计模式的情况下开发出一个高质量的应用系统了。
还要注意的是: 开发出一个高质量的J2EE系统还需要正确的业务需求理解，那么域建模提供了一种比较切实可行的正确理解业务需求的方法，相关详细知识可从UML角度结合理解。
当然，如果你想设计自己的行业框架，那么第一步从设计模式开始吧，因为设计模式提供你一个实现JavaBeans或类之间解耦参考实现方法，当你学会了系统基本单元JavaBean或类之间解耦时，那么系统模块之间的解耦你就可能掌握，进而你就可以实现行业框架的提炼了，这又是另外一个发展方向了。
以上理念可以总结为一句话：
J2EE开发三件宝: Domain Model（域建模）、patterns（模式）和framework（框架）。
推荐一套高质量的J2EE开源系统： JPestore

1.文本框焦点问题 
onBlur:当失去输入焦点后产生该事件 
onFocus:当输入获得焦点后，产生该文件 
Onchange:当文字值改变时，产生该事件 
Onselect:当文字加亮后，产生该文件 
<input type="text" value="郭强" onfocus="if(value=='郭强') {value=''}" onblur="if 
(value=='') {value='郭强'}">点击时文字消失，失去焦点时文字再出现 

2.网页按钮的特殊颜色 
<input type=button name="Submit1" value="郭强" size=10 class=s02 
style="background-color:rgb(235,207,22)"> 
3.鼠标移入移出时颜色变化 
<input type="submit" value="找吧" name="B1" onMouseOut=this.style.color="blue" 
onMouseOver=this.style.color="red" class="button"> 
4.平面按钮 
<input type=submit value=订阅 style="border:1px solid :#666666; height:17px; width:25pt; font-size:9pt; 
BACKGROUND-COLOR: #E8E8FF; color:#666666" name="submit"> 
5.按钮颜色变化 
<input type=text name="nick" style="border:1px solid #666666; font-size:9pt; height:17px; 
BACKGROUND-COLOR: #F4F4FF; color:#ff6600" size="15" maxlength="16"> 
6.平面输入框 
<input type="text" name="T1" size="20" style="border-style: solid; border-width: 1"> 
7.使窗口变成指定的大小 
<script> 
window.resizeTo(300,283); 
</script> 
8.使文字上下滚动 
<marquee direction=up scrollamount=1 scrolldelay=100 onmouseover='this.stop()' onmouseout='this.start()' 
height=60> 
<!-- head_scrolltext --> 
<tr> 
<td> 
共和国 
</table> <!-- end head_scrolltext --> 
</marquee> 
9.状态栏显示该页状态 
<base onmouseover="window.status='网站建设 http://www.webmake.cn/' ;return true"> 
10.可以点击文字实现radio选项的选定 
<br> 
<input type="radio" name="regtype" value="A03" id="A03"> 
<label for="A03"> 情侣 : 一次注册两个帐户</label> <br> 
11.可以在文字域的font写onclick事件 
12.打印</a>打印网页 
<a href='javascript:window.print ()'> 
13.线型输入框 
<input type="text" name="key" size="12" value="关键字" onFocus=this.select() onMouseOver=this.focus() 
class="line"> 
14.显示文档最后修改日期 
<script language=javascript> 
function hi(str) 
{ 
document.write(document.lastModified) 
alert("hi"+str+"!") 
} 
</script> 
15.可以在鼠标移到文字上时就触发事件 
<html> 
<head> 
<script language="LiveScript"> 
<!-- Hiding 
function hello() { 
alert("哈罗!"); 
} 
</script> 
</head> 
<body> 
<a href="" onMouseOver="hello()">link</a> 
</body> 
</html> 
16.可以根据网页上的选项来确定页面颜色 
<HTML> 
<HEAD> 
<TITLE>background.html</TITLE> 
</HEAD> 
<SCRIPT> 
<!-- 
function bgChange(selObj) { 
newColor = selObj.options[selObj.selectedIndex].text; 
document.bgColor = newColor; 
selObj.selectedIndex = -1; 
} 
//--> 
</SCRIPT> 
<BODY STYLE="font-family:Arial"> 
<B>Changing Background Colors</B> 
<BR> 
<FORM> 
<SELECT SIZE="8" onChange="bgChange(this);"> 
<OPTION>Red 
<OPTION>Orange 
<OPTION>Yellow 
<OPTION>Green 
<OPTION>Blue 
<OPTION>Indigo 
<OPTION>Violet 
<OPTION>White 
<OPTION>pink 
</SELECT> 
</FORM> 
</BODY> 
</HTML> 
17.将按钮的特征改变 
<style type="text/CSS"> 
<!-- 
.style1 { font-size: 12px; background: #CCCCFF; border-width: thin thin thin thin; border-color: #CCCCFF 
#CCCCCC #CCCCCC #CCCCFF} 
.style2 { font-size: 12px; font-weight: bold; background: #CCFFCC; border-width: thin medium medium thin; 
border-color: #CCFF99 #999999 #999999 #CCFF99} 
--> 
</style> 
　　本例按钮的代码如下： 
<input type="submit" name="Submit" value="提 交" onmouseover="this.className='style2'" 
onmouseout="this.className='style1'" class="style1"> 
18.改变按钮的图片. 
<style type="text/css"> 
<!-- 
.style3 { font-size: 12px; background: url(image/buttonbg1.gif); border: 0px; width: 60px; height: 22px} 
.style4 { font-size: 12px; font-weight: bold; background: url(image/buttonbg2.gif); border: 0px 0; width: 
60px; height: 22px} 
--> 
</style> 
　　本例的按钮代码如下： 
<input type="submit" name="Submit2" value="提 交" onmouseover="this.className='style4'" 
onmouseout="this.className='style3'" class="style3"> 
19.打印页面 
<div align="center"><a class=content href="javascript:doPrint();">打印本稿</a></div> 
20.可以直接写html语言 
document.write(""); 
21.改变下拉框的颜色 
<select name="classid" 
onChange="changelocation(document.myform.classid.options[document.myform.classid.selectedIndex].value)" 
size="1" style="color:#008080;font-size: 9pt"> 
22.转至目标URL 
window.location="http://guoguo" 
23.传递该object的form 
UpdateSN('guoqiang99267',this.form) 
function UpdateSN(strValue,strForm) 
{ 
strForm.SignInName.value = strValue; 
return false; 
} 
24.文字标签 
<label for="AltName4"><input name="AltName" type="RADIO" tabindex="931" id="AltName4" 
>guoqiang99859</label> 
25.layer2为组件的ID，可以控制组件是否可见 
document.all.item('Layer2').style.display = "block"; 
document.all.item('Layer2').style.display = "none";// 
26.将页面加入favorite中 
<script language=javascript> 
<!-- 
function Addme(){ 
url = "http://your.site.address"; //你自己的主页地址 
title = "Your Site Name"; //你自己的主页名称 
window.external.AddFavorite(url,title); 
--> 
</script>// 
27.过10秒自动关闭页面 
< script language="JavaScript" > 
function closeit() { 
setTimeout("self.close()"，10000) 
} 
< /script > 
28.可以比较字符的大小 
char=post.charAt(i); 
if(!('0'<=char&&char<='9')) 
29.将字符转化为数字 
month = parseInt(char) 
30.点击value非空的选项时转向指定连接 
<select onchange='if(this.value!="")window.open(this.value)' class="textinput"> 
<option selected>主办单位</option> 
<option>-----------------</option> 
<option value="http://www.bjd.com.cn/">北京日报</option> 
<option value="http://www.ben.com.cn/">北京晚报</option> 
</select> 
31.改变背景颜色 
<td width=* class=dp bgColor=#FAFBFC onmouseover="this.bgColor='#FFFFFF';" 
onmouseout="this.bgColor='#FAFBFC';"> 
32.改变文字输入框的背景颜色 
<style> 
.input2 {background-image: url('../images/inputbg.gif'); font-size: 12px; background-color: 
#D0DABB;border-top-width:1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px} 
</style> 
<input name=content type=text size="47" class="input2" maxlength="50"> 
33.改变水平线的特征 
<hr size="0" noshade color="#C0C0C0"> 
34.传递参数的方式 
<a href="vote.asp?CurPage=8&id=3488">8</a> 
35.页内跳转 
<a href="#1">1</a> 
<a href="#2">2</a> 
<a href="#3">3</a> 
<a href="#4">4</a> 
<a href="#5">5</a> 
<a href="#6">6</a> 
<a href="#7">7</a> 
<a name="1">dfdf</a> 
<a name="2">dfdf</a>// 
36.两个按键一起按下 
if(event.ctrlKey && window.event.keyCode==13)// 
37.刷新页面 
javascript:this.location.reload()// 
38.将网页的按钮使能 
<SCRIPT LANGUAGE="JavaScript"> 
function haha() 
{ 
for(var i=0;i<document.form1.elements.length;i++) 
{ 
if(document.form1.elements[i].name.indexOf("bb")!=-1) 
document.form1.elements[i].disabled=!document.form1.elements[i].disabled; 
} 
} 
</SCRIPT> 
<BODY><form name=form1> 
<INPUT TYPE="button" NAME="aa " value=cindy onclick=haha()> 
<INPUT TYPE="button" NAME="bb " value=guoguo> 
<INPUT TYPE="button" NAME="bb " value=guoguo> 
39.文字移动 
<marquee scrollamount=3 onmouseover=this.stop(); onmouseout=this.start();> 
40.双击网页自动跑 
<SCRIPT LANGUAGE="JavaScript"> 
var currentpos,timer; 
function initialize() 
{ 
timer=setInterval("scrollwindow()",1); 
} 
function sc() 
{ 
clearInterval(timer); 
} 
function scrollwindow() 
{ 
currentpos=document.body.scrollTop; 
window.scroll(0,++currentpos); 
if (currentpos != document.body.scrollTop) 
sc(); 
} 
document.onmousedown=sc 
document.ondblclick=initialize 
</SCRIPT>// 
41.后退 
<INPUT TYPE="button" onclick=window.history.back() value=back> 
42.前进 
<INPUT TYPE="button" onclick=window.history.forward() value=forward> 
43.刷新 
<INPUT TYPE="button" onclick=document.location.reload() value=reload> 
44.转向指定网页 
document.location="http://ww"或者document.location.assign("http://guoguo.com") 
45.在网页上显示实时时间 
<SCRIPT LANGUAGE="JavaScript"> 
var clock_id; 
window.onload=function() 
{ 
clock_id=setInterval("document.form1.txtclock.value=(new Date);",1000) 
} 
</SCRIPT>// 
46.可以下载文件 
document.location.href="目标文件"// 
47.连接数据库 
import java.sql.*; 
String myDBDriver="sun.jdbc.odbc.JdbcOdbcDriver"; 
Class.forName(myDBDriver); 
Connection conn=DriverManager.getConnection("jdbc:odbc:firm","username","password"); 
Statement stmt=conn.createStatement(); 
ResultSet rs=stmt.executeQuery(sql); 
rs.getString("column1");// 
48.可以直接在页面“div”内写下所需内容 
<INPUT TYPE="button" onclick="a1.innerHTML='<font color=red>*</font>'"> 
<div id=a1></div>// 
49.可以改变页面上的连接的格式，使其为双线 
<style> 
A:link {text-decoration: none; color:#0000FF; font-family: 宋体} 
A:visited {text-decoration: none; color: #0000FF; font-family: 宋体} 
A:hover {text-decoration: underline overline; color: FF0000} 
</style> 
<style> 
A:link {text-decoration: none; color:#0000FF; font-family: 宋体} 
A:visited {text-decoration: none; color: #0000FF; font-family: 宋体} 
A:hover {text-decoration: underline overline line-through; color: FF0000} 
TH{FONT-SIZE: 9pt} 
TD{FONT-SIZE: 9pt} 
body {SCROLLBAR-FACE-COLOR: #A9D46D; SCROLLBAR-HIGHLIGHT-COLOR: #e7e7e7;SCROLLBAR-SHADOW-COLOR:#e7e7e7; 
SCROLLBAR-3DLIGHT-COLOR: #000000; LINE-HEIGHT: 15pt; SCROLLBAR-ARROW-COLOR: #ffffff; 
SCROLLBAR-TRACK-COLOR: #e7e7e7;} 
INPUT{BORDER-TOP-WIDTH: 1px; PADDING-RIGHT: 1px; PADDING-LEFT: 1px; BORDER-LEFT-WIDTH: 1px; FONT-SIZE: 
9pt; BORDER-LEFT-COLOR: #cccccc; 
BORDER-BOTTOM-WIDTH: 1px; BORDER-BOTTOM-COLOR: #cccccc; PADDING-BOTTOM: 1px; BORDER-TOP-COLOR: #cccccc; 
PADDING-TOP: 1px; HEIGHT: 18px; BORDER-RIGHT-WIDTH: 1px; BORDER-RIGHT-COLOR: #cccccc} 
DIV,form ,OPTION,P,TD,BR{FONT-FAMILY: 宋体; FONT-SIZE: 9pt} 
textarea, select {border-width: 1; border-color: #000000; background-color: #efefef; font-family: 宋体; 
font-size: 9pt; font-style: bold;} 
.text { font-family: "宋体"; font-size: 9pt; color: #003300; border: #006600 solid; border-width: 1px 1px 
1px 1px} 
</style>完整的css 

50.新建frame 
<a 
href="javascript:newframe('http://www.163.net/help/a_little/index.html','http://www.163.net/help/a_little 
/a_13.html')"><img alt=帮助 border=0 src="http://bjpic.163.net/images/mail/button-help.gif"></a> 
51.向文件中写内容 
<%@ page import="java.io.*" %> 
<% 
String str = "print me"; 
//always give the path from root. This way it almost always works. 
String nameOfTextFile = "/usr/anil/imp.txt"; 
try 
{ 
PrintWriter pw = new PrintWriter(new FileOutputStream(nameOfTextFile)); 
pw.println(str); 
//clean up 
pw.close(); 
} 
catch(IOException e) 
{ 
out.println(e.getMessage()); 
} 
%> 
52.先读文件再写文件 
<%@ page language = "java" %> 
<%@ page contentType = "text/html; charSet=gb2312" %> 
<%@ page import ="java.util.*" %> 
<%@ page import ="java.lang.*" %> 
<%@ page import ="javax.servlet.*" %> 
<%@ page import ="javax.servlet.jsp.*" %> 
<%@ page import ="javax.servlet.http.*" %> 
<%@ page import="java.io.*" %> 
eryrytry 
<% 
int count=0; 
FileInputStream fi =new FileInputStream ("count.txt"); 
ObjectInputStream si= new ObjectInputStream (fi); 
count =si.readInt(); 
count++; 
out.print(count); 
si.close(); 
FileOutputStream fo =new FileOutputStream ("count.txt"); 
ObjectOutputStream so= new ObjectOutputStream (fo); 
so.writeInt(count); 
so.close(); 
%> 
53.直线型输入框 
<INPUT name=Password size=10 type=password style="border-left-width: 0; border-right-width: 0; 
border-top-width: 0; border-bottom-style: solid; border-bottom-width: 1; background-color: #9CEB9C"> 
54.可以将背景改为按钮性状，通过改变css改变属性 
<td width="65" align="center" bgcolor="#E0E0E0" onmouseover=this.className='mouseoverbt'; 
onmouseout=this.className='mouseout';><a href="tm.asp?classid=76"><font 
color="#000000">录音笔</font></a></td> 
<style> 
.mouseoverbt 
{ 
background-image: url(http://www.yongle.com.cn/img/btbgw64h20y.gif); 
background-repeat: no-repeat; 
} 
.mouseout 
{ 
background-color: #E0E0E0; 
} 
</style> 
55.同时按下CTRL和Q键 
document.onkeydown=function() 
{ 
if(event.ctrlKey&&event.keyCode==81) 
{alert(1)} 
}// 
56.以下是一个完整的显示hint的代码，其思想是当鼠标停留是将div中的内容显示在鼠标出，当鼠标移出后在将该div隐 
藏掉 
--------------------------------------------------------------------------------------------------------- 
------------ 
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"> 
<HTML> 
<style> 
#hint{ 
width:198px; 
border:1px solid #000000; 
background:#99ff33; 
position:absolute; 
z-index:9; 
padding:6px; 
line-height:17px; 
text-align:left; 
top: 1520px; 
} 
</style> 
<SCRIPT LANGUAGE="JavaScript"> 
<!-- 
function showme() 
{ 
var oSon=window.document.getElementById("hint"); 
if (oSon==null) return; 
with (oSon) 
{ 
innerText=guoguo.value; 
style.display="block"; 
style.pixelLeft=window.event.clientX+window.document.body.scrollLeft+6; 
style.pixelTop=window.event.clientY+window.document.body.scrollTop+9; 
} 
} 
function hidme() 
{ 
var oSon=window.document.getElementById("hint"); 
if (oSon==null) return; 
oSon.style.display="none"; 
} 
//--> 
</SCRIPT> 
<BODY> 
<text id=guoguo value=ga> 
<a href=# onmouseover=showme() onmouseout=hidme() onmousemove=showme() son=hint>dfdfd</a> 
<div id=hint style="display:none"></div> 
</BODY> 
</HTML> 
--------------------------------------------------------------------------------------------------------- 
------------ 
57.弹出窗口 
方法一：<body onload="openwen()"> 浏览器读页面时弹出窗口； 
方法二：<body onunload="openwen()"> 浏览器离开页面时弹出窗口； 
方法三：用一个连接调用：<a href="#" onclick="openwin()">打开一个窗口</a> 
注意：使用的"#"是虚连接。 
方法四：用一个按钮调用：<input type="button" onclick="openwin()" value="打开窗口"> 何时装载script 

58.动态改变字体的大小 
function doZoom(size) 
{ 
document.getElementById('zoom').style.fontSize=size+'px' 
} 
function aa() 
{ 
var newWin=window.open(url); 
newWin.document.form1.text1.value=value1; 
}改变弹出窗口上域的属性 
opener.document.form2.text2.value=value2;改变父窗口的域的值 
59.判断是何种浏览器 
var name = navigator.appName; 
if (name == "Microsoft Internet Explorer") 
alert("IE"); 
else if (name == "Netscape") 
alert("NS");// 
60.vbsscript确定框 
<script language="VBScript"> 
<!-- 
MsgBox "确定删除吗？", 4 
//--> 
</script>// 
61.复制内容到剪切板 
function JM_cc(bb) 
{ 
var ob=eval("document.form1."+bb); 
ob.select(); 
js=ob.createTextRange(); 
js.execCommand("Copy"); 
}// 
62.java中建立数据库连接取数据 
public void init() 
{ 
String url="jdbc:odbc:javadata"; 
try 
{ 
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); 
Connection con=DriverManager.getConnection(url,"sa","");//mssql database user SA and password 
DatabaseMetaData dma=con.getMetaData(); 
System.out.println("Connect to"+dma.getURL()); 
System.out.println(";Driver "+dma.getDriverName()); 
System.out.println(";Version "+dma.getDriverVersion()); 
System.out.println(""); 
Statement stmt=con.createStatement(); 
ResultSet rs=stmt.executeQuery("select * from company.dbo.TB_NAME where number=1");//Sql 
rs.next(); 
String dispresult=rs.getString("name"); 
System.out.println(dispresult);// Instead,you can display it in Paint() or use AWT etc. 
rs.close(); 
stmt.close(); 
con.close(); 
} 
catch(SQLException ex) 
{ 
System.out.println("!!!SQL Exception !!!"); 
while(ex!=null) 
{ 
System.out.println("SQLState:"+ex.getSQLState()); 
System.out.println("Message:"+ex.getMessage()); 
System.out.println("Vendor:"+ex.getErrorCode()); 
ex=ex.getNextException(); 
System.out.println(""); 
} 
} 
catch(java.lang.Exception ex) 
{ 
ex.printStackTrace(); 
} 
}// 

63.最小化窗口 
window.blur()// 

64.文档的路径 
document.URL// 
65.定时执行某段程序 
setTimeout("change_color()",600); 
66.设置为主页 
function makeHome(){ 
netscape.security.PrivilegeManager.enablePrivilege("UniversalPreferencesWrite"); 
navigator.preference("browser.startup.homepage", location.href); 
}// 
67.设置为收藏 
function addFav(){ 
if(ie) 
window.external.AddFavorite(location.href,'WWW.OGRISH.COM : GROTESQUE MOVIES AND PICTURES'); 
if(ns) 
alert("Thanks for the bookmark!\n\nNetscape users click OK then press CTRL-D"); 
}// 
68.判断cookie是否可用 
navigator.cookieEnabled;// 
69.显示有模式的有页面的弹出窗口 
function setbgcolor_onclick() 
{ 
var color = showModalDialog("/mailpage/compose/colorsel.html",0,"help=0"); 
if (color != null) 
{ 
document.compose.bgcolor.value = color; 
} 
}// 

70.截取小数点后两位 
var a=3454545.4454545; 
alert(a.toFixed(2));// 

71.禁止选择页面上的文字来拷贝 
<script> 
function noEffect() { 
with (event) { 
returnValue = false; 
cancelBubble = true; 
} 
return; 
} 
</script> 
<body onselectstart="noEffect()" oncontextmenu="noEffect()">// 
72.屏蔽右键菜单 
oncontextmenu="event.returnValue = false"// 
73.事件禁止起泡 
event.cancelBubble = true// 
74.禁止在输入框打开输入法 
<input style="ime-mode: disabled">// 
75.屏蔽汉字和空格 
<input name="txt"><input type="submit" onClick="alert(!/[^ -}]|\s/.test(txt.value))">// 
76.用javascript判断文件是否存在 
function Exists(filespec) 
{ 
if (filespec) 
{ 
var fso; 
fso = new ActiveXObject("Scripting.FileSystemObject"); 
alert(fso.FileExists(filespec)); 
} 
} 
选择图片 <input type=file name=f1><p> 
<input type="submit" onClick="Exists(f1.value)">// 
77.获得当前的文本框选中的文字 
<input onmouseup="alert(document.selection.createRange().text)" value=123>// 
78.跳转至目标页面，同时不可返回 
<a href="javascript:location.replace('http://www.sohu.com/')">sohu.com</a>// 

79.获得当前的行是表格的第几行 
<script> 
function getrow(obj) 
{ 
if(event.srcElement.tagName=="TD"){ 
curRow=event.srcElement.parentElement; 
alert("这是第"+(curRow.rowIndex+1)+"行"); 
} 
} 
</script> 
<table border="1" width="100%" onclick=getrow(this)> 
<tr> 
<td width="20%">　</td> 
<td width="20%">　</td> 
<td width="20%">　</td> 
<td width="20%">　</td> 
<td width="20%">　</td> 
</tr> 
<tr> 
<td width="20%">　</td> 
<td width="20%">　</td> 
<td width="20%">　</td> 
<td width="20%">　</td> 
<td width="20%">　</td> 
</tr> 
</table>// 
80.删除表格某行，xx表示某行，下标从0开始计算 
document.all.myTable.deleteRow(xx)// 
81.动态的向表格中添加行 
<table id="t1" border="1"> 
</table> 
<script language="JavaScript"> 
function add() 
{ 
t1.insertRow().insertCell().innerHTML = '<input name="test'+t1.rows.length+'">'; 
}// 

82.event.x,event.clientX,event.offsetX区别： 
x:设置或者是得到鼠标相对于目标事件的父元素的外边界在x坐标上的位置。 clientX:相对于客户区域的x坐标位置，不 
包括滚动条，就是正文区域。 offsetx：设置或者是得到鼠标相对于目标事件的父元素的内边界在x坐标上的位置。 
screenX:相对于用户屏幕。 

83.显示是鼠标按钮的哪个 
<body onMouseDown="alert(event.button)">点Mouse看看// 
84.打开C盘 
<form action="file:///c|/"><input type="submit" value="c:\ drive"></form>// 
85.当前屏幕的分辨率 
screen.width、screen.height// 
86.设置表格中的内容 
tbl.rows[0].cells[1].innerText=document.form.text1.value;// 

87.本地快捷键 
<p><a href="file:///::{208D2C60-3AEA-1069-A2D7-08002B30309D}" target="_blank">网上邻居</a></p> 
<p><a href="file:///::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\d:\web" target="_blank">我的电脑</a></p> 
<p><a href="file:///::{450D8FBA-AD25-11D0-98A8-0800361B1103}" target="_blank">我的文档</a></p> 
<p><a href="file:///::{645FF040-5081-101B-9F08-00AA002F954E}" target="_blank">回收站</a></p> 
<p><a href="file:///::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\::{21EC2020-3AEA-1069-A2DD-08002B30309D}" 
target="_blank">控制面板</a></p> 
<p><a href="file:///::{7007ACC7-3202-11D1-AAD2-00805FC1270E}">拨号网络</a>(Windows 2000)</p> 

88.IE菜单 
<button onclick="min.Click()"><font face="webdings">0</font></button>//改变按钮上的图片 
<input type=button onclick="document.execCommand('CreateLink','true','true')"> //创建新连接 
<input type=button onclick="document.execCommand('print','true','true')"> //打印 
<input type=button onclick="document.execCommand('saveas','true','网站制作.htm')">//另存为htm 
<input type=button onclick="document.execCommand('saveas','true','网站制作.txt')">//另存为txt 
document.execCommand("SaveAs")//保存为 
document.execCommand('undo')//撤销上一次操作 
89.web对话框 
<SCRIPT> 
var contents='<style>body,td{font:menu}img{cursor:hand}</style>'; 
contents+='<title>你要关闭我吗</title>'; 
contents+='<body bgcolor=menu>'; 
contents+='<table width=100% height=100% border=0>'; 
contents+='<tr><td align=center>'; 
contents+='你要关闭我吗？<br>'; 
contents+='<img src=dark.gif onclick=self.close() alt="...关闭">'; 
contents+='<img src=jet.gif onclick=self.close() alt="全是关闭">'; 
contents+='</td></tr></table>'; 
showModalDialog("about:"+contents+"","","dialogHeight:50px;dialogWidth:250px;help:no;status:no") 
document.write(contents); 
</SCRIPT>// 
90.取第x,y的值 
<button onclick="t1.rows[x].cells[y].innerText='guoguo'"></button>// 
91.向新打开的网页上写内容 
newwin=window.open('about:blank','','top=10'); 
newwin.document.write('');// 
93.返回 
javascript:history.go(-2);// 
94.将页面上选中的内容复制到剪贴板 
abcdefg 
<input type='button' 
onclick="window.clipboardData.setData('text',document.selection.createRange().text);" value='复制页面选中 
的字符'>// 
95.将页面上选中的内容复制到剪贴板 
<INPUT TYPE="text" NAME="">kjhkjhkhkj<INPUT TYPE="button" onclick="document.execCommand('Copy', 'false', 
null);">//// 
96.鼠标移到下拉框时自动全部打开 
<select onmouseover="javascript:this.size=this.length" onmouseout="javascript:this.size=1"></select>// 
97.获得本机的文件 
var fso = new ActiveXObject("Scripting.FileSystemObject"); 
var f1 = fso.GetFile("C:\\bsitcdata\\ejbhome.xml"); 
alert("File last modified: " + f1.DateLastModified); // 
98.判断客户端是否是IE浏览器 
因为 document.all 是 IE 的特有属性，所以通常用这个方法来判断客户端是否是IE浏览器 ,document.all?1:0; 
99.创建新的下拉框选项 
new Option(text,value)这样的函数// 
100.在页面上画柱状图 
<STYLE> 
td{font-size:12px} 
body{font-size:12px} 
v\:*{behavior:url(#default#VML);} //这里声明了v作为VML公用变量 
</STYLE> 
<SCRIPT LANGUAGE="JavaScript"> 
mathstr=12; 
document.write ("<v:rect fillcolor='red' 
style='width:20;color:navy;height:"+5000/(1000/mathstr)+"'><br> %"+mathstr+"<br>4人<v:Extrusion 
backdepth='15pt' on='true'/></v:rect>") 
</SCRIPT> 
<v:rect fillcolor='red' style='width:20;color:navy;height:200'><br>%12<br>4人<v:Extrusion 
backdepth='15pt' on='true'/></v:rect> 
<v:rect fillcolor='yellow' style='width:20;color:navy;height:100'><br>%12<br>4人<v:Extrusion 
backdepth='15pt' on='true'/></v:rect>// 

101.饼图 
<style> 
v\:* { behavior: url(#default#VML) } 
o\:* { behavior: url(#default#VML) } 
.shape { behavior: url(#default#VML) } 
</style> 
<script language="javascript"> 
function show(pie) 
{ 
pie.strokecolor=pie.fillcolor; 
pie.strokeweight=10; 
div1.innerHTML="<font size=2 color=red> " + pie.id +"</font> <font size=2>" + pie.title + "</font>"; 
} 
function hide(pie) 
{ 
pie.strokecolor="white"; 
pie.strokeweight=1; 
div1.innerHTML=""; 
} 
</script> 
</head> 
<body> 
<v:group style='width: 5cm; height: 5cm' coordorigin='0,0' coordsize='250,250'> 
<v:shape id='asp技术' style='width:10;height:10;top:10;left:0' title='得票数:6 比例:40.00%' 
onmouseover='javascript:show(this);' onmouseout='javascript:hide(this);' href='http://www.cnADO.com' 
CoordSize='10,10' strokecolor='white' fillcolor='#ffff33'><v:path v='m 300,200 ae 
300,200,200,150,0,9437184 xe'/></v:shape> 
<v:shape id='php' style='width:10;height:10;top:10;left:0' title='得票数:1 比例:6.67%' 
onmouseover='javascript:show(this);' onmouseout='javascript:hide(this);' href='http://www.cnADO.com' 
CoordSize='10,10' strokecolor='white' fillcolor='#ff9933'><v:path v='m 300,200 ae 
300,200,200,150,9437184,1572864 xe'/></v:shape> 
<v:shape id='jsp' style='width:10;height:10;top:10;left:0' title='得票数:2 比例:13.33%' 
onmouseover='javascript:show(this);' onmouseout='javascript:hide(this);' href='http://www.cnADO.com' 
CoordSize='10,10' strokecolor='white' fillcolor='#3399ff'><v:path v='m 300,200 ae 
300,200,200,150,11010048,3145728 xe'/></v:shape> 
<v:shape id='c#写的.netWEB程序' style='width:10;height:10;top:10;left:0' title='得票数:3 比例:20.00%' 
onmouseover='javascript:show(this);' onmouseout='javascript:hide(this);' href='http://www.cnADO.com' 
CoordSize='10,10' strokecolor='white' fillcolor='#99ff33'><v:path v='m 300,200 ae 
300,200,200,150,14155776,4718592 xe'/></v:shape> 
<v:shape id='vb.net写的.netWEB程序' style='width:10;height:10;top:10;left:0' title='得票数:2 比例:13.33%' 
onmouseover='javascript:show(this);' onmouseout='javascript:hide(this);' href='http://www.cnADO.com' 
CoordSize='10,10' strokecolor='white' fillcolor='#ff6600'><v:path v='m 300,200 ae 
300,200,200,150,18874368,3145728 xe'/></v:shape> 
<v:shape id='xml技术' style='width:10;height:10;top:10;left:0' title='得票数:1 比例:6.67%' 
onmouseover='javascript:show(this);' onmouseout='javascript:hide(this);' href='http://www.cnADO.com' 
CoordSize='10,10' strokecolor='white' fillcolor='#ff99ff'><v:path v='m 300,200 ae 
300,200,200,150,22020096,1572864 xe'/></v:shape> 
</v:group> 
<v:group style='width: 6cm; height: 6cm' coordorigin='0,0' coordsize='250,250'> 
<v:rect style='height:10;width:15;top:0;left:10' fillcolor='#ffff33'/> 
<v:rect style='height:28;width:100;top:0;left:30' stroked='false'><v:textbox 
style='fontsize:2'>asp技术</v:textbox/></v:rect> 
<v:rect style='height:10;width:15;top:30;left:10' fillcolor='#ff9933'/> 
<v:rect style='height:28;width:100;top:30;left:30' stroked='false'><v:textbox 
style='fontsize:2'>php</v:textbox/></v:rect> 
<v:rect style='height:10;width:15;top:60;left:10' fillcolor='#3399ff'/> 
<v:rect style='height:28;width:100;top:60;left:30' stroked='false'><v:textbox 
style='fontsize:2'>jsp</v:textbox/></v:rect> 
<v:rect style='height:10;width:15;top:90;left:10' fillcolor='#99ff33'/> 
<v:rect style='height:28;width:100;top:90;left:30' stroked='false'><v:textbox 
style='fontsize:2'>c#写的.netWEB程序</v:textbox/></v:rect> 
<v:rect style='height:10;width:15;top:120;left:10' fillcolor='#ff6600'/> 
<v:rect style='height:28;width:100;top:120;left:30' stroked='false'><v:textbox style='fontsize:2'>vb.net 
写的.netWEB程序</v:textbox/></v:rect> 
<v:rect style='height:10;width:15;top:150;left:10' fillcolor='#ff99ff'/> 
<v:rect style='height:28;width:100;top:150;left:30' stroked='false'><v:textbox style='fontsize:2'>xml技术 
</v:textbox/></v:rect> 
</v:group> 
<div style="position: absolute; left: 10; top: 10; width: 760; height:16"> 
<table border="1" cellpadding="2" cellspacing="2" cellpadding="0" cellspacing="0" 
style="border-collapse: collapse" bordercolor="#CCCCCC" width="100%" ID="Table1"> 
<tr> 
<td width="100%" id=div1>　</td> 
</tr> 
</table> 
</div>// 
102.是一个特殊的容器，想装个网页都行 
<button><iframe src="http://www.google.com/"></iframe></button>//button 
103.外部的html代码 
event.srcElement.outerHTML// 
104.标识当前的IE事件的触发器 
event.srcElement和event.keyCode// 
105.事件类型 
event.type// 
106.动态改变类型 
<style> 
.Overnone { border-width:0;background-color:darkblue;cursor:default;color:gold;width:115} 
.Outnone {border-width:0;background-color:white;cursor:default;width:115} 
</style> 
<input class=Outnone onmouseover=this.className='Overnone' >// 
107.页面翻转 
<html dir=rtl></html>// 
108.滚屏 
parent.scroll(x,y);// 
<body onload="s=0" onDblClick="s=setInterval('scrollBy(0, 1)',10)" onClick="clearInterval(s)">// 
109.改变状态栏 
self.status ="";// 
110.改变窗口大小 
window.resizeTo(200,300);// 
111.改变鼠标样式 
style 
BODY{CURSOR: url('mouse.ani'); 
SCROLLBAR-BASE-COLOR: #506AA8; 
SCROLLBAR-ARROW-COLOR: #14213F; 
}// 
112.背景透明 
<input type="button" value="Button" style="background-color: transparent; border: 0;">// 
113.鼠标为等待形状 
<input type=button onclick="this.style.cursor='wait'">// 
114.调用父窗口的函数 
opener.fucntion1();// 
115.body的内部html代码 
<input type="button" onclick="alert(code.document.body.innerHTML)" value="查看">// 
116.框架中调用父窗口的函数 
<INPUT TYPE='button' onclick='parent.test();' value='调用parent窗口的函数'>// 
117.交换节点 
<table width=200 height=200 border> 
<tr><td id=c1>CELL_1</td></tr> 
<tr><td id=c2>CELL_2</td></tr> 
</table> 
<br> 
<input type="button" value="swap row" onclick="c1.swapNode(c2)">// 
118.删除节点 
<table width=200 height=200 border> 
<tr id=trall><td id=c1>CELL_1</td></tr> 
<tr><td id=c2>CELL_2</td></tr> 
</table> 
<br> 
<input type="button" value="swap row" onclick="trall.removeNode(c2)">// 
119.添加节点 
addNode()// 
120.获得事件的父与子标签 
event.srcElement.children[0]和event.srcElement.parentElement // 

121.集中为按钮改变颜色 
<style> 
button{benc:expression(this.onfocus = function(){this.style.backgroundColor='#E5F0FF';})} 
</style> 
<button>New</button>// 

122.判断是左键还是右键被按下 
<body onmousedown=if(event.button==1)alert("左键");if(event.button==2)alert("右键")>// 
123.获得操作系统的名称和浏览器的名称 
document.write(navigator.userAgent)// 

124.alt/ctrl/shift键按下 
event.altKey //按下alt键 
event.ctrlKey //按下ctrl键 
event.shiftKey //按下shift键 

125.将当前位置定位为C盘。 
{window.location="c:"}// 
126.返回输入框的类型 
<script> 
alert(event.srcElement.type);// 
</script> 
127.模拟控件的单击事件 
<INPUT TYPE="hidden" name="guoguo" onclick="haha()"> 
<SCRIPT LANGUAGE="JavaScript"> 
<!-- 
function haha() 
{ 
alert(); 
} 
guoguo.click(); 
//--> 
</SCRIPT>// 

128.取出记录集的列名 
java.sql.ResultSet rset = com.bsitc.util.DBAssist.getIT().executeQuery(queryStatement, conn); 
java.sql.ResultSetMetaData metaData = rset.getMetaData(); 
int count = metaData.getColumnCount(); 
String name = metaData.getColumnName(i); 
String value = rset.getString(i);// 
129.格式化数字 
function format_number(str,digit) 
{ 
if(isNaN(str)) 
{ 
alert("您传入的值不是数字！"); 
return 0; 
} 
else if(Math.round(digit)!=digit) 
{ 
alert("您输入的小数位数不是整数！"); 
return 0; 
} 
else 
return Math.round(parseFloat(str)*Math.pow(10,digit))/Math.pow(10,digit); 
} 
130.回车按钮转化为tab按钮 
if(event.keyCode==13) event.keyCode=9; //将 

131.滚动条滚动 
<button onclick="text1.scrollTop=text1.scrollHeight">Scroll</button><br> 
<textarea id="text1" cols=50 rows=10> 
1 
1 
1 
1 
1 
1 
1 
1 
1 
1 
1 
1 
1 
1 
1 
</textarea>// 

132.判断是什么对象 
if(typeof(unknown)=="function")return true; 
if(typeof(unknown)!="object")return false;// 

133.取消文本框自动完成功能 
<input type="text" autocomplete="off"> // 
134.让下拉框自动下拉 
<select onmouseover="javascript:this.size=this.length" onmouseout="javascript:this.size=1"> 
<option value="">1</option> 
<option value="">2</option> 
<option value="">3</option> 
</select> // 

135.读取XML文件 
var childrenobj=myselect//document.all.myselect; 
var oXMLDoc = new ActiveXObject('MSXML'); 
oXMLDoc.url = "mymsg.xml"; 
var oRoot=oXMLDoc.root; 
if(oRoot.children != null) 
{ 
for(var i=0;i<oRoot.children.item(0).children.length;++i) 
{ 
oItem = oRoot.children.item(0).children.item(i); 
oOption = new Option(oItem.text,oItem.value); 
childrenobj.add(oOption); 
} 
} 
//mymsg.xml文件 
<?xml version="1.0" encoding="gb2312" ?> 
<childrenlist> 
<aa> 
<child value='3301'>杭州地区</child> 
<child value='3303'>温州地区</child> 
</aa> 
<aa> 
<child value='3310'>台州地区</child> 
<child value='3311'>丽水地区</child> 
</aa> 
</childrenlist>// 

136.点击图片，图片停止 
<a href="javascript:"><img src="http://www.51js.com/images/51js/red_forum.gif" border="0"></a>// 
137.显示本地计算机信息 
var WshNetwork = new ActiveXObject("WScript.Network"); 
alert("Domain = " + WshNetwork.UserDomain); 
alert("Computer Name = " + WshNetwork.ComputerName); 
alert("User Name = " + WshNetwork.UserName);// 

138.比较时间 
tDate = new Date(2004,01,08,14,35); //年,月，日，时，分 
dDate = new Date(); 
tDate<dDate?alert("早于"):alert("晚于");// 
139.弹出鼠标所在处的链结地址 
<body onmouseover="if (event.srcElement.tagName=='A')alert(event.srcElement.href)"><a 
href="http://51js.com/viewthread.php?tid=13589" >dddd</a><input>// 
140.注意不能通过与 undefined 做比较来测试一个变量是否存在，虽然可以检查它的类型是否为“undefined”。在以 
下的代码范例中，假设程序员想测试是否已经声明变量 x ： 
// 这种方法不起作用 
if (x == undefined) 
// 作某些操作 
// 这个方法同样不起作用- 必须检查 

// 字符串 "undefined" 
if (typeof(x) == undefined) 
// 作某些操作 
// 这个方法有效 
if (typeof(x) == "undefined") 
// 作某些操作 
141.创建具有某些属性的对象 
var myObject = new Object(); 
myObject.name = "James"; 
myObject.age = "22"; 
myObject.phone = "555 1234";// 
142.枚举（循环）对象的所有属性 
for (var a in myObject) 
{ 
// 显示 "The property 'name' is James"，等等。 
window.alert("The property '" + a + "' is " + myObject[a]); 
}// 
143.判断一个数字是否是整数 
var a=23.2; 
alert(a%1==1)// 

144.新建日期型变量 
var a = new Date(2000, 1, 1); 
alert(a.toLocaleDateString()); 

145.给类定义新的方法 
function trim_1() 
{ 
return this.replace(/(^\s*)|(\s*$)/g, ""); 
} 
String.prototype.trim=trim_1; 
alert('cindy'.trim()); 

146.定义一个将日期类型转化为字符串的方法 
function guoguo_date() 
{ 
var tmp1,tmp2; 
tmp1 =this.getMonth()+1+""; 
if(tmp1.length<2) 
tmp1="0"+tmp1; 
tmp2 =this.getDate()+""; 
if(tmp2.length<2) 
tmp2="0"+tmp2; 
return this.getYear()+"-"+tmp1+"-"+tmp2; 
} 
Date.prototype.toLiteString=guoguo_date; 
alert(new Date().toLiteString()) 

147. pasta 是有四个参数的构造器,定义对象。 
function pasta(grain, width, shape, hasEgg) 
{ 
// 是用什么粮食做的？ 
this.grain = grain; 
// 多宽？（数值） 
this.width = width; 
// 横截面形状？（字符串） 
this.shape = shape; 
// 是否加蛋黄？（boolean） 
this.hasEgg = hasEgg; 
//定义方法 
this.toString=aa; 
} 
function aa() 
{ 
} 
//定义了对象构造器后，用 new 运算符创建对象实例。 
var spaghetti = new pasta("wheat", 0.2, "circle", true); 
var linguine = new pasta("wheat", 0.3, "oval", true); 
//补充定义属性，spaghetti和linguine都将自动获得新的属性 
pasta.prototype.foodgroup = "carbohydrates"; 

148.打印出错误原因 
try 
{ 
x = y // 产生错误。 
} 
catch(e) 
{ 
document.write(e.description) //打印 "'y' is undefined". 
}// 
149.生成Excel文件并保存 
var ExcelSheet; 
ExcelApp = new ActiveXObject("Excel.Application"); 
ExcelSheet = new ActiveXObject("Excel.Sheet"); 
//本代码启动创建对象的应用程序（在这种情况下，Microsoft Excel 工作表）。一旦对象被创建，就可以用定义的对 
象变量在代码中引用它。 在下面的例子中，通过对象变量 ExcelSheet 访问新对象的属性和方法和其他 Excel 对象， 
包括 Application 对象和 ActiveSheet.Cells 集合。 
// 使 Excel 通过 Application 对象可见。 
ExcelSheet.Application.Visible = true; 
// 将一些文本放置到表格的第一格中。 
ExcelSheet.ActiveSheet.Cells(1,1).Value = "This is column A, row 1"; 
// 保存表格。 
ExcelSheet.SaveAs("C:\\TEST.XLS"); 
// 用 Application 对象用 Quit 方法关闭 Excel。 
ExcelSheet.Application.Quit();// 

JavaScript教程及实例讲解

	.JAVASCRIPT简介及特点：
JavaScript语言的前身叫作Livescript。自从Sun公司推出著名的Java语言之后，Netscape公司引进了Sun公司有关Java的程序概念，将自己原有的Livescript 重新进行设计，并改名为JavaScript。
　　JavaScript是一种基于对象和事件驱动并具有安全性能的脚本语言，有了JavaScript，可使网页变得生动。使用它的目的是与HTML超文本标识语言、Java 脚本语言一起实现在一个网页中链接多个对象，与网络客户交互作用，从而可以开发客户端的应用程序。它是通过嵌入或调入在标准的HTML语言中实现的。
JavaScript具有很多优点：
1.简单性:-JavaScript是一种脚本编写语言，它采用小程序段的方式实现编程，像其它脚本语言一样，JavaScript同样已是一种解释性语言，它提供了一个简易的开发过程。它的基本结构形式与C、C++、VB、Delphi十分类似。但它不像这些语言一样，需要先编译，而是在程序运行过程中被逐行地解释。它与HTML标识结合在一起，从而方便用户的使用操作。
2.动态性:-JavaScript是动态的，它可以直接对用户或客户输入做出响应，无须经过Web服务程序。它对用户的反映响应，是采用以事件驱动的方式进行的。所谓事件驱动，就是指在主页中执行了某种操作所产生的动作，就称为“事件”。比如按下鼠标、移动窗口、选择菜单等都可以视为事件。当事件发生后，可能会引起相应的事件响应。
3.跨平台性:-JavaScript是依赖于浏览器本身，与操作环境无关，只要能运行浏览器的计算机，并支持JavaScript的浏览器就可以正确执行。
4.节省CGI的交互时间:-随着WWW的迅速发展有许WWW服务器提供的服务要与浏览者进行交流，确浏览的身份、需服务的内等等，这项工作通常由CGI/PERL编写相应的接口程序与用户进行交互来完成。很显然，通过网络与用户的交互过程一方面增大了网络的通信量，另一方面影响了服务器的服务性能。服务器为一个用户运行一个CGI时，需要一个进程为它服务，它要占用服务器的资源(如CPU服务、内存耗费等)，如果用户填表出现错误，交互服务占用的时间就会相应增加。被访问的热点主机与用户交互越多，服务器的性能影响就越大。
JavaScript是一种基于客户端浏览器的语言，用户在浏览中填表、验证的交互过程只是通过浏览器对调入HTML文档中的JavaScript源代码进行解释执行来完成的，即使是必须调用CGI的部分，浏览器只将用户输入验证后的信息提交给远程的服务器，大大减少了服务器的开销。 

㈡.JAVASCRIPT与Java的区别
JavaScript语言和Java语言是相关的，但它们之间的联系并不像想象中的那样紧密。
二者的区别体现在：
首先，它们是两个公司开发的不同的两个产品，Java是SUN公司推出的新一代面向对象的程序设计语言，特别适合于Internet应用程序开发；而JavaScript是Netscape公司的产品，其目的是为了扩展Netscape Navigator功能,而开发的一种可以嵌入Web页面中的基于对象和事件驱动的解释性语言。
其次，JavaScript是基于对象的，而Java是面向对象的，即Java是一种真正的面向对象的语言，即使是开发简单的程序，必须设计对象。JavaScript是种脚本语言，它可以用来制作与网络无关的，与用户交互作用的复杂软件。它是一种基于对象和事件驱动的编程语言。因而它本身提供了非常丰富的内部对象供设计人员使用。
第三，两种语言在其浏览器中所执行的方式不一样。Java的源代码在传递到客户端执行之前，必须经过编译，因而客户端上必须具有相应平台上的仿真器或解释器，它可以通过编译器或解释器实现独立于某个特定的平台编译代码的束缚。JavaScript是一种解释性编程语言，其源代码在发往客户端执行之前不需经过编译，而是将文本格式的字符代码发送给客户，由浏览器解释执行。
第四，两种语言所采取的变量是不一样的。Java采用强类型变量检查，即所有变量在编译之前必须作声明。JavaScript中变量声明，采用其弱类型。即变量在使用前不需作声明，而是解释器在运行时检查其数据类型。
第五，代码格式不一样。Java是一种与HTML无关的格式，必须通过像HTML中引用外媒体那么进行装载，其代码以字节代码的形式保存在独立的文档中。JavaScript的代码是一种文本字符格式，可以直接嵌入HTML文档中，并且可动态装载。编写HTML文档就像编辑文本文件一样方便。
第六，嵌入方式不一样。在HTML文档中，两种编程语言的标识不同，JavaScript使用 <script>...</script> 来标识，而Java使用<applet> ... </applet>来标识。
第七，静态绑定和动态绑定。Java采用静态联编，即Java的对象引用必须在编译时的进行，以使编译器能够实现强类型检查。JavaScript采用动态联编，即JavaScript的对象引用在运行时进行检查，如不经编译则就无法实现对象引用的检查。

㈢.JAVASCRIPT的运行环境
在目前流行的浏览器中，Netscape公司的Navigator 2.0以上版本的浏览器具都有处理JavaScript源代码的能力。JavaScript在其中实现了它的1.0版本，并在后来的Navigator 3.0实现了它的1.1版本，在现在推出的Navigator 4.0（Communicator）中,JavaScript在其中实现了它的1.2版本。
微软公司从它的Internet Explorer 3.0版开始支持JavaScript。Microsoft把自己实现的JavaScript规范叫做JAVASCRIPTcript。这个规范与Netscape Navigator浏览器中的JavaScript规范在基本功能上和语法上是一致的，但是在个别的对象实现方面还有一定的差别，这里特别需要予以注意。

㈣.JAVASCRIPT的数据类型和变量
JavaScript 有六种数据类型。主要的类型有 number、string、object 以及 Boolean 类型,其他两种类型为 null 和 undefined。
String 字符串类型:字符串是用单引号或双引号来说明的。（使用单引号来输入包含引号的字符串。）如：“The cow jumped over the moon.” 
数值数据类型：JavaScript 支持整数和浮点数。整数可以为正数、0 或者负数；浮点数可以包含小数点、也可以包含一个 “e”（大小写均可，在科学记数法中表示“10的幂”）、或者同时包含这两项。 
Boolean 类型：可能的 Boolean 值有 true 和 false。这是两个特殊值，不能用作 1 和 0。 
Undefined 数据类型：一个为 undefined 的值就是指在变量被创建后，但未给该变量赋值以前所具有的值。 
Null 数据类型：null 值就是没有任何值，什么也不表示。 
object类型：除了上面提到的各种常用类型外，对象也是JavaScript中的重要组成部分，这部分将在后面章节详细介绍。 
在 JavaScript 中变量用来存放脚本中的值，这样在需要用这个值的地方就可以用变量来代表，一个变量可以是一个数字，文本或其它一些东西。
JavaScript是一种对数据类型变量要求不太严格的语言，所以不必声明每一个变量的类型，变量声明尽管不是必须的，但在使用变量之前先进行声明是一种好的习惯。可以使用 var 语句来进行变量声明。如：var men = true; // men 中存储的值为 Boolean 类型。 
变量命名:JavaScript 是一种区分大小写的语言，因此将一个变量命名为 computer 和将其命名为 Computer是不一样的。
另外，变量名称的长度是任意的，但必须遵循以下规则：
①.第一个字符必须是一个字母（大小写均可）、或一个下划线(_)或一个美元符 ($)。
②.后续的字符可以是字母、数字、下划线或美元符。
③.变量名称不能是保留字。 

㈤.JAVASCRIPT的语句及语法
JavaScript所提供的语句分为以下几大类：
1.变量声明，赋值语句：var。
语法如下： var 变量名称 [=初始值]
　例：var computer = 32 //定义computer是一个变量，且有初值为32。
2.函数定义语句：function，return。
　语法如下： function 函数名称 （函数所带的参数）
　　　 ｛ 
　　　  函数执行部分 
　　　  ｝
　　　  return 表达式 //return语句指明将返回的值。 
例：function square ( x ) 
　　　　 { 
　　　　 return x*x 
　　　　 } 
3.条件和分支语句：if...else，switch。
if...else语句完成了程序流程块中分支功能：如果其中的条件成立，则程序执行紧接着条件的语句或语句块；否则程序执行else中的语句或语句块。 　　　　
语法如下： if (条件)
　　　　｛ 
　　　　 执行语句1
　　　　 ｝else{ 
　　　　 执行语句2 
　　　　 ｝ 
例：if (result == true)
｛ 
response = “你答对了！” 
｝else{ 
response = “你错了！” 
｝
分支语句switch可以根据一个变量的不同取值采取不同的处理方法。
 语法如下： switch (expression)
　　　　 { 
　　　　 case label1: 语句串1；
　　　 　case label2: 语句串2； 
　　　　 case label3: 语句串3；
　　　　　　　　 ... 
　　　　 default: 语句串3；
　　　    }
如果表达式取的值同程序中提供的任何一条语句都不匹配，将执行default　中的语句。 
4. 循环语句：for， for...in，while,break,continue。
for语句的语法如下： for (初始化部分；条件部分；更新部分)
　　　　　 　　  ｛ 
　　　　　　 　　 执行部分... 
　　　　　　 　   ｝ 
只要循环的条件成立，循环体就被反复的执行。
for...in语句与for语句有一点不同，它循环的范围是一个对象所有的属性或是一个数组的所有元素。
for...in语句的语法如下： for (变量 in 对象或数组)
　　　　　　　　　　　　｛ 
　　　　　　　　　　　　 语句... 
　　　　　　　　　　　　 } 
while语句所控制的循环不断的测试条件，如果条件始终成立，则一直循环，直到条件不再成立。
语法如下： while (条件)
　　　  ｛
　　 　 执行语句... 
　　　     }
break语句结束当前的各种循环，并执行循环的下一条语句。
continue语句结束当前的循环，并马上开始下一个循环。
5.对象操作语句：with，this，new。
with语句的语法如下：
with (对象名称){
　　               执行语句 
　　　　　　  } 
作用是这样的：如果你想使用某个对象的许多属性或方法时，只要在with语句的（）中写出这个对象的名称，然后在下面的执行语句中直接写这个对象的属性名或方法名就可以了。 
ew语句是一种对象构造器，可以用new语句来定义一个新对象。
语法是这样的：新对象名称＝ new 真正的对象名 
譬如说，我们可以这样定义一个新的日期对象： var curr＝ new Date()，然后，变量curr就具有了Date对象的属性。 
　　this运算符总是指向当前的对象。 
6.注释语句：//，/*...*/。
　　  //这是单行注释
　　  /*这可以多行注释.... */ 

㈥.JAVASCRIPT的对象及其属性和方法
在JavaScript中是基于对象的编程，而不是完全的面向对象的编程。
　　那麽什麽是对象呢？如果你学过一些VB的编程，对这个名词一定不会陌生。通俗的说，对象是变量的集合体，对象提供对于数据的一致的组织手段，描述了一类事物的共同属性。 
在JavaScript中，可以使用以下几种对象：
①.由浏览器根据web页面的内容自动提供的对象。
②.JavaScript的内置对象，如Date,Math等。
③.服务器上的固有对象。
④.用户自定义的对象。 
　　JavaScript中的对象是由属性和方法两个基本的元素的构成的。对象的属性是指对象的背景色，长度，名称等。对象的方法是指对属性所进行的操作，就是一个对象自己所属的函数，如对对象取整，使对象获得焦点，使对象获得个随机数等等一系列操作。
　　举个例子来说，将汽车看成是一个对象，汽车的颜色，大小，品牌等叫做属性，而发动，刹车，拐弯等就叫做方法。 
　　可以采用这样的方法来访问对象的属性：对象名称.属性名称，例：mycomputer.year=1996，mycomputer.owner = “me”。
　　可以采用这样的方法，将对象的方法同函数联系起来：对象.方法名字=函数名字或对象.属性.方法名，例：this.display=display，document.writeln（“this is method”）。 
　　多看或多写一些程序，就会理解对象的方法和属性的含义了！各个对象的各种属性和方法，可点击参考！ 

㈦.JAVASCRIPT的事件处理
事件是浏览器响应用户交互操作的一种机制，JavaScript的事件处理机制可以改变浏览器响应用户操作的方式，这样就开发出具有交互性，并易于使用的网页。
　　浏览器为了响应某个事件而进行的处理过程，叫做事件处理。 
　　事件定义了用户与页面交互时产生的各种操作，例如单击超级连接或按钮时，就产生一个单击（click）操作事件。浏览器在程序运行的大部分时间都等待交互事件的发生，并在事件发生时，自动调用事件处理函数，完成事件处理过程。 
　　事件不仅可以在用户交互过程中产生，而且浏览器自己的一些动作也可以产生事件，例：当载入一个页面时，就会发生load事件，卸载一个页面时，就会发生unload事件等。
归纳起来，必需使用的事件有三大类：
1.引起页面之间跳转的事件，主要是超连接事件。 
2.事件浏览器自己引起的事件。
3.事件在表单内部同界面对象的交互。 
　　各种JavaScript的事件可点这里参考。

㈧.实例讲解
1. 日期星期的显示
①源代码如下：
(这段程序放在<body>与</body>之间)
<!--
todayDate = new Date();
date = todayDate.getDate();
month= todayDate.getMonth() +1;
year= todayDate.getYear();
document.write("今天是")
document.write("<br>")
if(navigator.appName == "Netscape")
{
	document.write(1900+year);
	document.write("年");
	document.write(month);
	document.write("月");
	document.write(date);
	document.write("日");
	document.write("<br>")
}
if(navigator.appVersion.indexOf("MSIE") != -1)
{
document.write(year);
document.write("年");
document.write(month);
document.write("月");
document.write(date);
document.write("日");
document.write("<br>")
}
if (todayDate.getDay() == 5) document.write("星期五")
if (todayDate.getDay() == 6) document.write("星期六")
if (todayDate.getDay() == 0) document.write("星期日")
if (todayDate.getDay() == 1) document.write("星期一")
if (todayDate.getDay() == 2) document.write("星期二")
if (todayDate.getDay() == 3) document.write("星期三")
if (todayDate.getDay() == 4) document.write("星期四")

//-->

②源程序讲解：
todayDate = new Date();	当定义一个新的对象时，通常使用“new”操作符。在这里，就是创建了日期对象。
date = todayDate.getDate();	getDate()是Date对象的一种方法，其功能是获得当前的日期。
month= todayDate.getMonth() + 1 ;
; 	getMonth()是Date对象的一种方法，其功能是获得当前的日期，由于月份是从0开始的，所以这里要“+1”。
year= todayDate.getYear()	getYear()是Date对象的一种方法，其功能是获得当前的年份。
document.write("今天是") document.write("<br>")	输出“今天是”
if(navigator.appName == "Netscape") { document.write(1900+year); document.write("年"); document.write(month); document.write("月"); document.write(date); document.write("日");
document.write("<br> ") } 	如果浏览器是Netscape，输出今天是“year”+“年”+“month”+“月”+“date”+“日”，其中年要加1900。
if(navigator.appVersion.indexOf("MSIE") != -1) { document.write(year); document.write("年"); document.write(month); document.write("月"); document.write(date); document.write("日");
document.write("<br> ") }	如果浏览器是IE，直接输出今天是“year”+“年”+“month”+“月”+“date”+“日”。
document.write("") ；	在“日期”与“星期”之间输入一个空格。
if (todayDate.getDay() == 5) document.write("星期五")；
if (todayDate.getDay() == 6) document.write("星期六")；
if (todayDate.getDay() == 0) document.write("星期日")；
if (todayDate.getDay() == 1) document.write("星期一")；
if (todayDate.getDay() == 2) document.write("星期二")；
if (todayDate.getDay() == 3) document.write("星期三")；
if (todayDate.getDay() == 4) document.write("星期四")	getDay()是Date对象的一种方法，其功能是获得当前是星期几。document.write输出今天是“星期几”。

2. 分时问候
①源代码如下：
(这段程序放在<body>与</body>之间)
<script language="JavaScript">
<!--
var mess1="";
document.write("<center><font color='#0000FF' size=4><b>")
day = new Date( )
hr = day.getHours( )
if (( hr >= 0 ) && (hr <= 4 ))
mess1="深夜了，注意身体,该休息了！"
if (( hr >= 4 ) && (hr < 7))
mess1="清晨好，这麽早就上网呀？！ "
if (( hr >= 7 ) && (hr < 12))
mess1="早上好，一天之际在于晨，又是美好的一天！"
if (( hr >= 12) && (hr <= 13))
mess1="该吃午饭啦！有什麽好吃的？"
if (( hr >= 13) && (hr <= 17))
mess1="外面的天气很热吧?！心静自然凉！ "
if (( hr >= 17) && (hr <= 18))
mess1="太阳落山了！快看看夕阳吧！"
if ((hr >= 18) && (hr <= 19))
mess1="吃过晚饭了吗？"
if ((hr >= 19) && (hr <= 23))
mess1="一天过的可真快！今天过的好吗？"
document.write(mess1)
document.write("</b></font></center>")
//--->
</script>

②源程序讲解：
var mess1="";	定义一个新变量。
document.write("<center><b> ")	设置格式，可以是字体，颜色等。
day = new Date( ) 	设置Date的一个新对象。
hr = day.getHours( )	把当前的“小时”的值赋给hr.
if (( hr >= 0 ) && (hr <= 4 ))
mess1="深夜了，注意身体,该休息了！"	在0--4点间，出现“清晨好，这麽早就上网呀？！”字样。以下，类推。
if (( hr >= 4 ) && (hr < 7)) 
mess1="清晨好，这麽早就上网呀？！"
if (( hr >= 7 ) && (hr < 12)) 
mess1="早上好，一天之际在于晨，又是美好的一天！" 
if (( hr >= 12) && (hr <= 13))
mess1="该吃午饭啦！有什麽好吃的？" 
if (( hr >= 13) && (hr <= 17))
mess1="外面的天气很热吧?！心静自然凉！ "
if (( hr >= 17) && (hr <= 18))
mess1="太阳落山了！快看看夕阳吧！"
if ((hr >= 18) && (hr <= 19))
mess1="吃过晚饭了吗？"
if ((hr >= 19) && (hr <= 23))
mess1="一天过的可真快！今天过的好吗？"	同上。
document.write(mess1)	输出mess1的值。
document.write("</b> ")	字体设置结束。

3. 停留时间显示2
①源代码如下：
(这段程序放在<body>与</body>之间)
<form name=forms>
        <p><font class=p2 color=red>　　　您在本站停留了</font> </p>
        <p> 　　　 
          <input type=text name=input size=10>
          <script language=javascript>
var second=0;
var minute=0;
var hour=0;
idt=window.setTimeout("interval();",1000);
function interval(){
second++;
if(second==60){second=0;minute+=1;}
if(minute==60){minute=0;hour+=1;}
document.forms.input.value=hour+"时"+minute+"分"+second+"秒";
idt=window.setTimeout("interval();",1000);}
</script>
        </p>
</form>

②源程序讲解：
var second=0;
var minute=0;
var hour=0;	定义三个变量。
idt=window.setTimeout("interval();",1000); 	先初始化变量，这句话不可少。
function interval(){ second++; if(second==60){second=0;minute+=1;} if(minute==60){minute=0;hour+=1;}	定义一个函数。功能是形成一个计时系统。
	
document.forms.input.value = hour+"时"+minute+"分"+second+"秒"; 	输出时间。
idt=window.setTimeout("interval();",1000);}	每1秒，调用一次interval()函数，就是一秒走一次。

4. 动态数字时钟1
①源代码如下：
(建议使用1024*768的分辨率)
(这段程序放在<body>与</body>之间)
<script language="JavaScript">
<!--

function Time(){
 if (!document.layers&&!document.all)
 return
 var Timer=new Date()
 var hours=Timer.getHours()
 var minutes=Timer.getMinutes()
 var seconds=Timer.getSeconds()
 var noon="AM" 
 if (hours>12){
 noon="PM"
 hours=hours-12
 }
 if (hours==0)
 hours=12
 if (minutes<=9)
 minutes="0"+minutes
 if (seconds<=9)
 seconds="0"+seconds
//change font size here to your desire
myclock="<font size='4' face='Arial' color=blue>"+hours+":"+minutes+":"
 +seconds+" "+noon+"</b></font>"
if (document.layers){
document.layers.position.document.write(myclock)
document.layers.position.document.close()
}
else if (document.all)
position.innerHTML=myclock
setTimeout("Time()",1000)
 }
//-->
</script>
<span id="position" style="position:absolute;left:441px;top:190px; width: 128px; height: 30px"> 
</span>

②源程序讲解：
function Time() 	定义一个函数。
{ if (!document.layers&&!document.all)
return	由于IE与Netscape对JavaScript的解释不同，造成浏览的效果不同，所以要分别写代码。这句话判断一下用户所使用的浏览器，如果两者都不是，就返回。
var timer=new Date()	定义一个新的变量，名字为timer,为一个新的Date的对象。
var hours=Timer.getHours() 
var minutes=Timer.getMinutes()
var seconds=Timer.getSeconds() 	分别定义3个变量，获得当前“小时”，“分钟”，“秒”的值。
var noon="AM" if (hours>12)
{ noon="PM" hours=hours-12 }
if (hours==0) 
hours=12	定义一个名为“noon”的变量，当“小时”数大于12时，其值为PM,同时所得值减12;当“小时”数小于12时，其值为AM。
if (minutes<=9)
minutes="0"+minutes
if (seconds<=9) 
seconds="0"+seconds 	如果“分钟”数或“秒”数小于9,则在前面加一个“0”。
myclock="<font color=blue>"+hours+":"+minutes+":" +seconds+" "+noon+"</b></font>" 	用一个新变量把“小时，分，秒”结合起来。
if (document.layers)
{ document.layers.position.
document.write(myclock)
document.layers.position.document.close() } 	如果浏览器是Netscape，就输出myclock,同时用于IE的代码就停止执行。
else if (document.all) 
position.innerHTML=myclock 	否则，浏览器是IE，就输出myclock。
setTimeout("Time()",1000)	每1000毫秒，调用一次Time函数,即一秒动一次。
onload="Time()"	页面装载时，调用Time()函数。

5. 离开时显示停留时间1
①源代码如下：
(这段程序放在<body>与</body>之间)
<script language="Javascript">
<!--
pageOpen = new Date();
function stay() {
pageClose = new Date();
minutes = (pageClose.getMinutes() - pageOpen.getMinutes());
seconds = (pageClose.getSeconds() - pageOpen.getSeconds());
time = (seconds + (minutes * 60));
time = (time + " 秒钟");
alert('您在这儿停留了' + time + '.欢迎下次再来!');
} 
//-->
</script>

(这段程序放在<body ****>正文中)
onUnload=stay()

②源程序讲解：
pageOpen = new Date();	定义一个新的日期对象，纪录开始浏览页面时间。
function stay() 	定义一个函数。
pageClose = new Date(); 	定义一个新的日期对象，纪录结束浏览页面时间。
minutes = (pageClose.getMinutes() - pageOpen.getMinutes());	“分钟”变量等于结束时间的分钟数减去开始时间的分钟数。
seconds = (pageClose.getSeconds() - pageOpen.getSeconds()); 	“秒数”变量等于结束时间的秒数数减去开始时间的秒数数。
time = (seconds + (minutes * 60));	时间变量等于“秒数”变量加上“分钟”变量乘以60，即变为以秒纪录。
time = (time + " 秒钟"); alert('您在这儿停留了' + time + '.欢迎下次再来!');	alert()是JavaScript的窗口对象方法，其功能是弹出一个具有OK对话框并显示（）中的字符串，告诉在此页面停留的时间。
onUnload=stay()	页面卸载的时候，调用stay()函数。

6. 带开关的时钟
①源代码如下：
(这段程序放在<body>与</body>之间)
<script language="JavaScript">
var enabled=0;    
function TOfunc() {       
	TO = window.setTimeout( "TOfunc()", 1000);       
	var today = new Date();   
	document.clock.disp.value = today.toLocaleString();
		  }
</script>
<form name="clock">
<input type="text" name="disp" value="" size=20 
onFocus="this.blur()" ><br>
<input type="radio" name="rad" value="off"  onClick="if( enabled==1 ) 
    {
     document.clock.disp.value='';
     clearTimeout( TO ); 
     enabled = 0;
     }
   " checked>关<font color="#FFFF99"> </font> 
<input type="radio" name="rad" value="on"  onClick="if( enabled == 0 ) 
	{
        var TO = setTimeout( 'TOfunc()', 1000 );
        enabled = 1;     }" >开<font color="#FFFF99"> </font> 
</form>

②源程序讲解：
var enabled=0;	定义一个变量,并赋初值。
function TOfunc() 
{ TO = window.setTimeout( "TOfunc()", 1000);	定义一个函数，变量TO的值为一秒，调用一次TOfunc()函数。
var today = new Date();	定义today 为Date对象的一个实例。
document.clock.disp.value = today.toLocaleString(); }	在文本框中输出当前系统的时间。
<form name="clock"> 
<input type="text" name="disp" value="" size=20 onFocus="this.blur()" ><br>	插入一个文本框。
<input type="radio" name="rad" value="on" onClick="if( enabled == 0 )
{ var TO = setTimeout( 'TOfunc()', 1000 ); 
enabled = 1; }" >开<font color="#FFFF99">
</font> 	插入一个单选按钮。如果选“开”的时候，就调用TOfunc()函数。
<input type="radio" name="rad" value="off"
onClick="if( enabled==1 ) 
{ document.clock.disp.value=''; clearTimeout( TO ); 
enabled = 0; } " checked>关
<font color="#FFFF99"> </font></form> 	插入一个单选按钮。如果选“关”的时候，就取消调用TOfunc()函数。

7. 数 字 时 钟2
①源代码如下：
(这段程序放在<head>与</head>之间)
<script language="javascript"> 
<!--
var dn
c1=new Image(); c1.src="img/c1.gif"
c2=new Image(); c2.src="img/c2.gif"
c3=new Image(); c3.src="img/c3.gif"
c4=new Image(); c4.src="img/c4.gif"
c5=new Image(); c5.src="img/c5.gif"
c6=new Image(); c6.src="img/c6.gif"
c7=new Image(); c7.src="img/c7.gif"
c8=new Image(); c8.src="img/c8.gif"
c9=new Image(); c9.src="img/c9.gif"
c0=new Image(); c0.src="img/c0.gif"
cb=new Image(); cb.src="img/cb.gif"
cam=new Image(); cam.src="img/cam.gif"
cpm=new Image(); cpm.src="img/cpm.gif"
function extract(h,m,s,type){
if (!document.images)
return
if (h<=9){
document.images.a.src=cb.src
document.images.b.src=eval("c"+h+".src")
}
else {
document.images.a.src=eval("c"+Math.floor(h/10)+".src")
document.images.b.src=eval("c"+(h%10)+".src")
}
if (m<=9){
document.images.d.src=c0.src
document.images.e.src=eval("c"+m+".src")
}
else {
document.images.d.src=eval("c"+Math.floor(m/10)+".src")
document.images.e.src=eval("c"+(m%10)+".src")
}
if (s<=9){
document.g.src=c0.src
document.images.h.src=eval("c"+s+".src")
}
else {
document.images.g.src=eval("c"+Math.floor(s/10)+".src")
document.images.h.src=eval("c"+(s%10)+".src")
}
if (dn=="AM") document.j.src=cam.src
else document.images.j.src=cpm.src
}
function show(){
if (!document.images)
return
var Digital=new Date()
var hours=Digital.getHours()
var minutes=Digital.getMinutes()
var seconds=Digital.getSeconds()
dn="AM" 
if ((hours>=12)&&(minutes>=1)||(hours>=13)){
dn="PM"
hours=hours-12
}
if (hours==0)
hours=12
extract(hours,minutes,seconds,dn)
setTimeout("show()",1000)
}
//-->
</script>

(这段程序放在<body ****>正文中)
onLoad="show()"

(这段程序放在<body>与</body>之间)
img src="cb.gif" name="a">
<img src="cb.gif" name="b">
<img src="colon.gif" name="c">
<img src="cb.gif" name="d">
<img src="cb.gif" name="e">
<img src="colon.gif" name="f">
<img src="cb.gif" name="g">
<img src="cb.gif" name="h">
<img src="cam.gif" name="j">

②源程序讲解：
var dn	定义一个新变量。
c1=new Image(); c1.src="c1.gif" 
c2=new Image(); c2.src="c2.gif" 
c3=new Image(); c3.src="c3.gif"
c4=new Image(); c4.src="c4.gif"
c5=new Image(); c5.src="c5.gif" 
c6=new Image(); c6.src="c6.gif" 
c7=new Image(); c7.src="c7.gif"
c8=new Image(); c8.src="c8.gif"
c9=new Image(); c9.src="c9.gif" 
c0=new Image(); c0.src="c0.gif" 
cb=new Image(); cb.src="cb.gif" 
cam=new Image(); cam.src="cam.gif" 
cpm=new Image(); cpm.src="cpm.gif"	定义一些新对象c1,c2...，分别是c1.gif,c2,gif....分别为数字1，2...
function extract(h,m,s,type){	定义一个函数extract,具有四个参数h,m,s,type。
if (!document.images)
return	如果当前窗口不存在images对象，就返回。
if (h<=9){ document.images.a.src
=cb.src document.images.b.src=
eval("c"+h+".src") }	当h<9时，就在小时前输出一个黑背景，再输出ch.src图。
else { document.images.a.src=
eval("c"+Math.floor(h/10)+".src")
document.images.b.src=
eval("c"+(h%10)+".src") }	Math.floor(h/10)是返回一个小于h/10的整数。如果h>9，就输出一个c1图，再加上一张对h取模后的值的图。
if (m<=9){ document.images.d.src
=c0.src document.images.e.src=
eval("c"+m+".src") }	当m<=9时，就在分钟前输出一个0，再输出cm.src图。
else { document.images.d.src=
eval("c"+Math.floor(m/10)+".src") 
document.images.e.src=
eval("c"+(m%10)+".src") }	如果m>9，先输出一张分钟的十位数上的数字，再加上一张对h取模后的值的图。
if (s<=9)
{ document.g.src=c0.src document.images.h.src=
eval("c"+s+".src") }
else { document.images.g.src=
eval("c"+Math.floor(s/10)+".src") 
document.images.h.src=
eval("c"+(s%10)+".src") }	同上的讲解。
if (dn=="AM")
document.j.src=cam.src 
else
document.images.j.src=cpm.src }	如果dn=AM，则输出am图，否则输出pm图。
function show()
{ if (!document.images) return	如果当前窗口不存在images对象，就返回。
var Digital=new Date() 	定义一个新的时间对象。
var hours=Digital.getHours()
var minutes=Digital.getMinutes()
var seconds=Digital.getSeconds()	分别声明变量hours，minutes，seconds值为当前的小时数，分钟数和秒数。
dn="AM" 
if ((hours>=12)&&(minutes>=1)
||(hours>=13))
{ dn="PM" hours=hours-12 }	给dn赋初值为am，当小时数>=12,分钟>=1时或者小时数大于等于13时，dn=pm,同时，小时数减12。
if (hours==0)
hours=12	当小时数等于0时，小时数为12。
extract(hours,minutes,seconds,dn) setTimeout("show()",1000)	1秒调用一次show函数。

8. 显示最后修改日期
①源代码如下：
(这段程序放在<body>与</body>之间)
<script language="JavaScript">
<!--hide script from old browsers
function modified(){
document.form1.textfield.value= document.lastModified}
// end hiding -->
</script>
<form name="form1" >
  上次修改日期： 
  <input type="text" name="textfield">
</form>

(这段程序放在<body ****>正文中)
onload=modified()

②源程序讲解：
hide script from old browsers 	有些低版本的浏览器不支持javascript,写上这句代码，在低版本的浏览器中，javascript可被忽略。
function modified(){ 	用function语句定义一个函数以及它的参数。
document.form1.textfield.value= document.lastModified}	lastmodified是document对象的一个属性，可以自己输出上次修改该文件的时间。
这句代码意思是把上次修改时间输出到名字为textfield的文本框中。 
form name="form1"
input type="text" name="textfield"	在页面中建立一个文本框，名字要为textfield。
onload=modified()	页面装载时，调用modified函数。

9. 有阴影的钟表
①源代码如下：
(这段程序放在<head>与</head>之间)
<style type="text/css">
<!-- 
.time{
	font-family : Comic Sans Ms;
	font-size : 18pt;
	font-weight : bold;
	color: #00008D;
}
-->
</style>
<script Language="JavaScript">
var ctimer;
function init(){
if (document.all){
tim2.style.left=tim1.style.posLeft;
tim2.style.top=tim1.style.posTop+tim1.offsetHeight-6;
settimes();
}
}
function settimes(){
var time= new Date();
hours= time.getHours();
mins= time.getMinutes();
secs= time.getSeconds();
if (hours<10)
hours="0"+hours;
if(mins<10)
mins="0"+mins;
if (secs<10)
secs="0"+secs;
tim1.innerHTML=hours+":"+mins+":"+secs
tim2.innerHTML=hours+":"+mins+":"+secs
ctimer=setTimeout('settimes()',960);
}
</script>

(这段程序放在<body>与</body>之间)
<div Id="tim1" Style="position:absolute; width:10; height:10; top:10; left:50"
class="time"></div>
<div Id="tim2" Style="position:absolute; filter:flipv() alpha(opacity=40); font-style:italic"
class="time"></div>
<div Id="instructions"
</div>

(这段程序放在<body ****>里)
onLoad="init()"

②源程序讲解：
<!-- .time
{ font-family : Comic Sans Ms; font-size : 18pt; font-weight : bold; color: #00008D; } --> 
</style>	定义一些样式，如字体，字号。
<script Language="JavaScript"> 
var ctimer; 	定义一个变量。
function init()
{ if (document.all){ tim2.style.left=tim1.style.posLeft; tim2.style.top=tim1.style.posTop+
tim1.offsetHeight-6; settimes(); } } 	定义一个函数，获得tim2的位置。
function settimes()
{ var time= new Date(); 
hours= time.getHours(); 
mins= time.getMinutes();
secs= time.getSeconds();
if (hours<10) hours="0"+hours;
if(mins<10) mins="0"+mins; 
if (secs<10) secs="0"+secs;
tim1.innerHTML=
hours+":"+mins+":"+secs 
tim2.innerHTML=
hours+":"+mins+":"+secs ctimer=setTimeout('settimes()',960); } 
</script>	定义一个函数，功能是获得当前系统的时间。
<div Id="tim1" Style="position:absolute; width:10; height:10; top:10; left:50" class="time"></div>	定义tim1层的位置。
<div Id="tim2" Style="position:absolute; filter:flipv() alpha(opacity=40); font-style:italic" class="time"></div>
</div> 	定义第二层的一些样式，如垂直翻转，透明度等。

10. 倒计时
①源代码如下：
(这段程序放在<body>与</body>之间)
<script language="JavaScript">
<!-- // 
var deadline= new Date("7/30/2000");
var  symbol="7月30日";
var now = new Date();
var leave =deadline.getTime() - now.getTime();
var day = Math.floor(leave / (1000 * 60 * 60 * 24));
if (day > 0)
   document.write("今天离"+ symbol+"还有"+day +"天")
else if (day == 0)
     document.write("只有1天啦！")
else
    document.write("唉呀！已经过了！");
// -->
</script>

②源程序讲解：
var deadline= new Date("7/30/2000");	定义“到期”变量。你可以随便设置。
var symbol="7月30日"; 	定义“日期性质”变量，可以随便设置。
var now = new Date(); 	设置“现在”的时间。
var leave =deadline.getTime() - now.getTime();	设置变量“leave”的值为到期时间减现在时间，返回的为毫秒数。
var day = Math.floor(leave / (1000 * 60 * 60 * 24));	将毫秒数化为天数，并返回一个不大于天数的整数。
if (day > 0) 
document.write("今天离"+ symbol+"还有"+day +"天")	如果日期不是今天到期，就输出“还有多少天”。
else if (day == 0)
document.write("只有1天啦！")	如果到期日就是机器今天的系统日期，则输出“只有一天了”。
Else
document.write("唉呀！已经过了！")	否则，就是过期了。

11. 标题栏显示日期
①源代码如下：
(这段程序放在<body>与</body>之间)
<script language="JavaScript">
var isMonth = new
Array("1月","2月","3月","4月","5月","6月","7月","8月","9月","10月","11月","12月");
var isDay = new
Array("星期日","星期一","星期二","星期三","星期四","星期五","星期六","星期日");
today = new Date () ;
Year=today.getYear();
Date=today.getDate();
if (document.all)
document.title="今天是: "+Year+"年"+isMonth[today.getMonth()]+Date+"日"+isDay[today.getDay()]
</script>

②源程序讲解：
var isMonth = new Array
("1月","2月","3月","4月","5月","6月",
"7月","8月","9月","10月","11月","12月"); 
var isDay = new Array("星期日","星期一",
"星期二", "星期三", "星期四","星期五",
"星期六","星期日"); 	定义两个数组及其所包含的元素。
today = new Date () ; 
Year=today.getYear(); 
Date=today.getDate(); 	获得当前的日期年份和日期。
if (document.all)
document.title="今天是: "+Year+"年"+
isMonth[today.getMonth()]+
Date+"日"+isDay[today.getDay()] 	输出今天的日期和星期。

12. 淡出淡入效果
①源代码如下：
(这段程序放在<body>与</body>之间)
<script language="JavaScript">
var b = 1;
var c = true;
function fade(){
if(document.all);
if(c == true) {
b++;
}
if(b==100) {
b--;
c = false
}
if(b==10) {
b++;
c = true;
}
if(c == false) {
b--;
}
child.filters.alpha.opacity=0 + b;
setTimeout("fade()",100);
}
</script>
      <img src="img/1.jpg" name="child" border=0
alt="Image" style="filter:alpha(opacity=0)">

②源程序讲解：
var b = 1;	定义变量b的值为1。
var c = true;	定义变量c为布尔型变量，值为true.
function fade() 	定义一个函数，名为fade.
{ if(document.all);
if(c == true)
{ b++; } 
} 	当用户的浏览器是IE时，且C的值为真时，b的值累加，即b=b+1。
if(b==100)
{ b--; c = false } 	如果b的值为100时，其值自减，即b=b-1,即透明度下降，且c的值为假。
f(b==10) { b++; c = true; }	如果b的值为10时，其值自加，即b=b+1，且c的值为真。
if(c == false) { b--; } 
child.filters.alpha.opacity=0 + b;	且C的值为假时，b的值自减。此时，这张图的alpha(透明度)等于“0+b”的值。
setTimeout("fade()",100);	图像每100毫秒，调用一次fade函数，即透明度变化一次。可以通过调整这个数字，来控制变化的快慢。
<img src=img/1.jpg name=child style="filter:alpha(opacity=0>	插入一个文件名为“1.jpg”的图片，name=child，设置其透明度为0。
注：此例效果只能在IE中出现。图片放在与文件同级的“img”文件夹中，名为1.jpg。

13. 闪烁文字
①源代码如下：
(这段程序放在<body>与</body>之间)
<script language=javascript>            
<!-- 
function initArray() {
	this.length = initArray.arguments.length;
	for (var i = 0; i < this.length; i++) {
		this[i] = initArray.arguments[i];
   	}
}
var ctext = "看看我，我会变色";
var speed = 1000;
var x = 0;
var color = new initArray(
	"red", 
	"blue", 
	"green",
	"black",
	"yellow",
	"pink");
if (navigator.appVersion.indexOf("MSIE") != -1)
{
	document.write('<div id="c"><center>'+ctext+'</center></div>');
}
function chcolor()
{ 
	 if (navigator.appVersion.indexOf("MSIE") != -1)
	 {
		document.all.c.style.color = color[x];
	 }
	(x < color.length-1) ? x++ : x = 0;
}
setInterval("chcolor()",1000);
-->
</script>

②源程序讲解：
function initArray() 	定义数组initArray。
{ this.length = initArray.arguments.length; 	把数组的个数的值赋给this.length。
for (var i = 0; i < this.length; i++) 
{ this[i] = initArray.arguments[i]; } }	当i的值小于数组的个数时，i=i+1。
var ctext = "看看我，我会变色";	声明一个字符型变量。
var speed = 1000;	声明一个变量。
var x = 0;	声明一个变量。
var color = new initArray( "red", "blue", "green", "black", "yellow", "pink");	声明变量color的值为数组initArray中的元素。
if (navigator.appVersion.indexOf("MSIE") != -1)
{ document.write('<div id="c"><center>'+ctext+'</center></div>'); } 	如果浏览器是IE，就建一个区域，输出变量ctext的值。
function chcolor()	定义一个函数chcolor。
if (navigator.appVersion.indexOf("MSIE") != -1)
{ document.all.c.style.color = color[x]; }	如果浏览器是IE，就直接按颜色输出文本。
(x < color.length-1) ? x++ : x = 0; }	如果颜色都变化完了，就重新开始。
setInterval("chcolor()",1000);	没一秒调用一次chcolor函数,即每秒换一次颜色。
注：此效果只能在IE浏览器中实现。

14. 禁止图片下载
①源代码如下：
(这段程序放在<body>与</body>之间)
<a href="javascript:void(0)" onMouseDown="alert('哈哈!这张图不能下载！')"><img src="img/nodownload.jpg"  border="0" ></a>

②源程序讲解：
<a href="javascript:void(0)" onMouseDown="alert('哈哈!这张图不能下载！')"><img src="img/nodownload.jpg" border="0" ></a>	javascript:void(0)相当于取消链接。

15. 随机产生图形
①源代码如下：
(这段程序放在<body>与</body>之间)
<script language="JavaScript">
a = 3 
var pp = Math.random();
var foot = Math.round(pp * (a-1))+1;
function create() {
        this.src = ''
        this.border = ''
	this.alt = ''	
}
b = new Array()
for(var i=1; i<=a; i++) { b[i] = new create() }
b[1].src    = "img/4.jpg"
b[1].border = "0"
b[1].alt    = ""
b[2].src    = "img/2.jpg"
b[2].border = "0"
b[2].alt    = ""
b[3].src    = "img/3.jpg"
b[3].border = "0"
b[3].alt    = ""
var pic = "";
pic += '<img src='+b[foot].src+' border="0"'+' alt='+b[foot].alt+'>';
document.write(pic)
</script>

②源程序讲解：
a = 3	设置变量a的初值为3。
var pp = Math.random();	定义一个变量pp，值为一个随机数。
var foot = Math.round(pp * (a-1))+1;	定义一个变量foot,值为一个经过四舍五入的整数，此数不大于3。
function create() 	定义一个函数。
{ this.src = ''
this.border = '' 
this.alt = '' } 	初始化图片的属性。
b = new Array() 	设置b为一个数组。
for(var i=1; i<=a; i++) 	开始一个循环，当i<a时，i=i+1。
{ b[i] = new create() } 
b[1].src = "img/4.jpg"
b[1].border = "0"
b[1].alt = ""
b[2].src = "img/2.jpg" 
b[2].border = "0"
b[2].alt = ""
b[3].src = "img/3.jpg" 
b[3].border = "0"
b[3].alt = "" 	分别定义数组b中的值。
var pic = "";
pic += '<img src='+b[foot].src+' border="0"'+' alt='+b[foot].alt+'>';>';	pic的值为随机产生一幅数组b中的图。
document.write(pic)	输出pic的值。

注:本例中所用到的三张图放在与本页面同级的"img"文件夹内,名字分别为2.jpg，3.jpg，4.jpg。

16. 文字变化效果
建议使用1024*768的分辨率。
①源代码如下：
(这段程序放在<head>与</head>之间)
<script Language="JavaScript">
var timerID = null;
var timerRunning = false;
function stopclock (){
        if(timerRunning)
                clearTimeout(timerID);
        timerRunning = false;
}
function showtime () {
        var now = new Date();
        var hours = now.getHours();
        var minutes = now.getMinutes();
        var seconds = now.getSeconds()
        var timeValue = "" + ((hours >12) ? hours -12 :hours)
        timeValue += ((minutes < 10) ? ":0" : ":") + minutes
        timeValue += ((seconds < 10) ? ":0" : ":") + seconds
        timeValue += (hours >= 12) ? " P.M." : " A.M."
        window.status = timeValue;
        timerID = setTimeout("showtime()",1000);
        timerRunning = true;
}
function startclock () {
        stopclock();
        showtime();
}
</script>

(这段程序放在<body ****>)
onLoad="glowtext()

②源程序讲解：
var thissize=20 	声明一个变量，定义字符串长度。
var textfont="隶书"	声明一个变量，定义字体。
var textcolor= new Array() 
textcolor[0]="000000"
textcolor[1]="000000"
textcolor[2]="000000" 
textcolor[3]="111111" 
textcolor[4]="222222"
textcolor[5]="333333"
textcolor[6]="444444" 
textcolor[7]="555555" 
textcolor[8]="666666" 
textcolor[9]="777777"
textcolor[10]="888888" 
textcolor[11]="999999"
textcolor[12]="aaaaaa"
textcolor[13]="bbbbbb"
textcolor[14]="cccccc" 
textcolor[15]="dddddd" 
textcolor[16]="eeeeee" 
textcolor[17]="ffffff" 
textcolor[18]="ffffff"	定义一个新数组，并列出其中的元素。
var message = new Array()
message[0]="洪恩在线 求知无限"
message[1]="十二亿人的网上大学"
i_message=0 	定义新数组，并列出其中的元素。
var i_strength=0 
var i_message=0	声明变量，并赋初值。
var timer	声明变量。
function glowtext() {	定义函数。
if(document.all) 	如果是IE浏览器，执行以下语句。
{ if (i_strength <=17) 	如果i_strength <=17，执行以下语句。
{ glowdiv.innerText=message[i_message]
document.all.glowdiv.style.filter=
"glow(color="+textcolor[i_strength]+", strength=4)"
i_strength++ 	输出i_message的值，然后i_strength递加，即亮度增加。
timer=setTimeout("glowtext()",100) } 	每100毫秒，调用一次glowtext函数。
else { clearTimeout(timer) 
setTimeout("deglowtext()",1500) } 	如果i_strength 大于17了，调用deglowtext函数，即亮度开始变暗。
} } function deglowtext() 
{ if(document.all) 
{ if (i_strength >=0)	定义deglowtext函数，并当浏览器是IE时，i_strength >=0时，执行以下语句。
{ glowdiv.innerText=message[i_message]
document.all.glowdiv.style.filter=
"glow(color="+textcolor[i_strength]+",
strength=4)"
i_strength--	输出i_message的值，然后i_strength递减，即亮度减弱。
timer=setTimeout("deglowtext()",100) }
else { clearTimeout(timer)
i_message++	每100毫秒，调用一次glowtext函数，减到最暗，接着执行下一个字符串。
if (i_message>=message.length) 
{i_message=0} i_strength=0 intermezzo() } } }	如果数组message中的字符串都执行完了，一切恢复初始设置，并执行intermezzo函数。
function intermezzo()	定义一个函数intermezzo。
{ glowdiv.innerText=""
setTimeout("glowtext()",1500) } 	1.5秒后，重新调用glowtext函数。
注：此效果只能在IE浏览器中实现。

17. 文字上下移动
①源代码如下：
(这段程序放在<body>与</body>之间)
<script language="JavaScript">
done = 0;
step = 4
function anim(yp,yk)
{
 if(document.layers) document.layers["napis"].top=yp;
 else  document.all["napis"].style.top=yp;

 if(yp>yk) step = -4
 if(yp<60) step = 4

 setTimeout('anim('+(yp+step)+','+yk+')', 35);
}
function start()
{
 if(done) return
 done = 1;

 if(navigator.appName=="Netscape") {
  document.napis.left=innerWidth/2 - 145;
  anim(60,innerHeight - 60)
 }
 else {
  napis.style.left=10;
  anim(60,document.body.offsetHeight - 60)
 }
}
</script>
      </p>
      <div id="napis" style="position: absolute;top: -50;"> 
        <p><a href="http://www.hongen.com"> 洪恩在线 求知无限</a> </p>
      </div>
<script language="JavaScript">
<!--
 setTimeout('start()',10);
//-->
</script>

②源程序讲解：
done = 0; step = 4 	定义变量,并赋初值。
function anim(yp,yk) { 	定义一个函数anim()，并带yp,yk两个参数。
if(document.layers) document.layers["napis"].top=yp; 
else document.all["napis"].style.top=yp;	分两种浏览器定义层的高度为yp的值。
if(yp>yk)
step = -4 
if(yp<60)
step = 4 	分情况讨论step的值。
setTimeout('anim('+(yp+step)+','+yk+')', 35); } 	设置定时。
function start() 
{ if(done) return done = 1; 
if(navigator.appName=="Netscape") 
{ document.napis.left=innerWidth/2 - 145;
anim(60,innerHeight - 60) }
else { napis.style.left=10; 
anim(60,document.body.offsetHeight - 60) } } </script> </p>	定义一个函数，调整层的位置。
<div id="napis" style="position: absolute;top: -50;"> <p><a href="http://www.hongen.com"> 洪恩在线 求知无限</a> </p> </div>	设置层。
<script language="JavaScript"> 
<!-- setTimeout('start()',10); //-->	每10毫秒，调用一次start()函数。

18. 随时间变化的图形
①源代码如下：
(这段程序放在<body>与</body>之间)
<script language="JavaScript"> 
var dt = new Date();
var hr = dt.getSeconds();
if (hr<=20) hr=7;
    else if (hr<=40) hr=8;
    else hr=9;
var msg="<IMG SRC=img/"+hr+".jpg>";
document.write(msg); 
</script>

②源程序讲解：
var dt = new Date(); 	定义一个新的时间对象。
var hr = dt.getSeconds();	定义一个变量,获得当前的秒数。
if (hr<=20) 
hr=7; 	当前的秒数小于20时，hr=7。
else if
(hr<=40) hr=8;	当前的秒数小于40大于20时，hr=8。
else hr=9; 	当前的秒数大于40小于60时，hr=9。
var msg="<IMG SRC=img/"+hr+".jpg>";
document.write(msg); 	设置变量msg的值为要显示图的路径，并输出这张图。
注:本例中所用到的三张图放在与本页面同级的"img"文件夹内,名字分别为7.jpg，8.jpg，9.jpg。

19. 图形随窗口移动
①源代码如下：
(这段程序放在<head>与</head>之间)
<script language=javascript>
<!-- Begin
function setVariables() {
imgwidth=50; 
imgheight=50;  
if (navigator.appName == "Netscape") {
horz=".left";
vert=".top";
docStyle="document.";
styleDoc="";
innerW="window.innerWidth";
innerH="window.innerHeight";
offsetX="window.pageXOffset";
offsetY="window.pageYOffset";
}
else {
horz=".pixelLeft";
vert=".pixelTop";
docStyle="";
styleDoc=".style";
innerW="document.body.clientWidth";
innerH="document.body.clientHeight";
offsetX="document.body.scrollLeft";
offsetY="document.body.scrollTop";
   }
}
function checkLocation() {
objectXY="branding";
var availableX=eval(innerW);
var availableY=eval(innerH);
var currentX=eval(offsetX);
var currentY=eval(offsetY);
x=availableX-(imgwidth+30)+currentX;
y=availableY-(imgheight+20)+currentY;
evalMove();
setTimeout("checkLocation()",10);
}
function evalMove() {
eval(docStyle + objectXY + styleDoc + horz + "=" + x);
eval(docStyle + objectXY + styleDoc + vert + "=" + y);
}
// End -->
</script>

(这段程序放在<body ****>正文中)
onload="setVariables(); checkLocation();"

②源程序讲解：
function setVariables()	定义一个函数。
{ imgwidth=50;
imgheight=50; 	设置两个变量的初值。
if (navigator.appName == "Netscape")
{ horz=".left"; 
vert=".top";
docStyle="document."; 
styleDoc=""; 
innerW="window.innerWidth";
innerH="window.innerHeight";
offsetX="window.pageXOffset";
offsetY="window.pageYOffset"; }	如果浏览器是Netscape，设置各变量的值。
else { horz=".pixelLeft"; 
vert=".pixelTop"; 
docStyle=""; 
styleDoc=".style"; innerW="document.body.clientWidth"; 
innerH="document.body.clientHeight";
offsetX="document.body.scrollLeft"; offsetY="document.body.scrollTop"; } 	如果浏览器是IE，设置各变量的值。
} function checkLocation() { 	定义一个函数。
objectXY="branding";
var availableX=eval(innerW); 
var availableY=eval(innerH);
var currentX=eval(offsetX);
var currentY=eval(offsetY); 	声明变量，并赋值。
x=availableX-(imgwidth+30)+currentX; 
y=availableY-(imgheight+20)+currentY; 
evalMove(); 	设置图片的位置：离屏幕的右边为30，离屏幕下端为20。
setTimeout("checkLocation()",10); } 	每10毫秒，调用一次checkLocation()函数。
function evalMove() 
{ eval(docStyle + objectXY + 
styleDoc + horz + "=" + x);｝
eval(docStyle + objectXY +
styleDoc + vert + "=" + y); }	定义evalMove函数。
onload="setVariables(); checkLocation();"	页面装载时，调用setVariables(); checkLocation()函数。

20. 文字上下移动
①源代码如下：
(这段程序放在<body>与</body>之间)
<style>
<!--.drag{position:relative;cursor:hand}
-->
</style>
<script language="JavaScript">
var dragapproved=false
var z,x,y
function move(){
if (event.button==1&&dragapproved){
z.style.pixelLeft=temp1+event.clientX-x
z.style.pixelTop=temp2+event.clientY-y
return false
}}
function drags(){
if (!document.all)
return
if (event.srcElement.className=="drag"){
dragapproved=true
z=event.srcElement
temp1=z.style.pixelLeft
temp2=z.style.pixelTop 
x=event.clientX
y=event.clientY
document.onmousemove=move
}}
document.onmousedown=drags
document.onmouseup=new Function("dragapproved=false")
</script>
        <img src="img/draw.jpg" class="drag">

②源程序讲解：
<style> 
<!--.drag{position:relative;cursor:hand} -->
</style> 	定义一个样式。
<script language="JavaScript"> 
var dragapproved=false 
var z,x,y	声明几个变量。
function move()
{ if (event.button==1&&dragapproved) 	定义一个函数move()，判断鼠标是否是按下状态。
{ z.style.pixelLeft=temp1+event.clientX-x 
z.style.pixelTop=temp2+event.clientY-y 
return false }} 	定义图片左上角的位置。
function drags()
{ if (!document.all)
return	定义一个函数drags()。如果是Netscape浏览器，就返回。所以此效果，在Netscape浏览器中看不到。
if (event.srcElement.className=="drag")
{ dragapproved=true 
z=event.srcElement 
temp1=z.style.pixelLeft
temp2=z.style.pixelTop 
x=event.clientX 
y=event.clientY 	如果鼠标左键被按下，返回z，temp1，temp2，x，y的值。
document.onmousemove=move }}
document.onmousedown=drags
document.onmouseup=new
Function("dragapproved=false")
</script> 	当鼠标移动时，执行move（）函数，当鼠标按下的时候，执行drags函数，当鼠标抬起的时候，不执行任何函数。
<img src="img/draw.jpg" class="drag">	在页面中插入一张图片。

21. 滚动显示图片
①源代码如下：
(这段程序放在<body>与</body>之间)
<script language="JavaScript1.2"> 
<!-- 
var scrollerwidth=64
var Scrollerheight=64
var scrollerbgcolor='white'
var pausebetweenimages=3000

var slideimages=new Array()
slideimages[0]='<a href="http://www.hongen.com/pc/index.htm"><img src="img/logo1.gif" border=0"></a>'
slideimages[1]='<a href="http://www.hongen.com/eng/index.htm"><img src="img/logo2.gif">'
slideimages[2]='<a href="http://www.hongen.com/shop/index.htm"><img src="img/logo3.gif">'
slideimages[3]='<a href="http://www.hongen.com/album/index.htm"><img src="img/logo4.gif">'
slideimages[4]='<a href="http://www.hongen.com/matrix/"><img src="img/logo5.gif">'

if (slideimages.length>1)
i=2
else
i=0

function move1(whichlayer){
tlayer=eval(whichlayer)
if (tlayer.top>0&&tlayer.top<=5){
tlayer.top=0
setTimeout("move1(tlayer)",pausebetweenimages)
setTimeout("move2(document.main.document.second)",pausebetweenimages)
return
}
if (tlayer.top>=tlayer.document.height*-1){
tlayer.top-=5
setTimeout("move1(tlayer)",100)
}
else{
tlayer.top=scrollerheight
tlayer.document.write(slideimages[i])
tlayer.document.close()
if (i==slideimages.length-1)
i=0
else
i++
}
}

function move2(whichlayer){
tlayer2=eval(whichlayer)
if (tlayer2.top>0&&tlayer2.top<=5){
tlayer2.top=0
setTimeout("move2(tlayer2)",pausebetweenimages)
setTimeout("move1(document.main.document.first)",pausebetweenimages)
return
}
if (tlayer2.top>=tlayer2.document.height*-1){
tlayer2.top-=5
setTimeout("move2(tlayer2)",100)
}
else{
tlayer2.top=scrollerheight
tlayer2.document.write(slideimages[i])
tlayer2.document.close()
if (i==slideimages.length-1)
i=0
else
i++
}
}

function move3(whichdiv){
tdiv=eval(whichdiv)
if (tdiv.style.pixelTop>0&&tdiv.style.pixelTop<=5){
tdiv.style.pixelTop=0
setTimeout("move3(tdiv)",pausebetweenimages)
setTimeout("move4(second2)",pausebetweenimages)
return
}
if (tdiv.style.pixelTop>=tdiv.offsetHeight*-1){
tdiv.style.pixelTop-=5
setTimeout("move3(tdiv)",100)
}
else{
tdiv.style.pixelTop=scrollerheight
tdiv.innerHTML=slideimages[i]
if (i==slideimages.length-1)
i=0
else
i++
}
}

function move4(whichdiv){
tdiv2=eval(whichdiv)
if (tdiv2.style.pixelTop>0&&tdiv2.style.pixelTop<=5){
tdiv2.style.pixelTop=0
setTimeout("move4(tdiv2)",pausebetweenimages)
setTimeout("move3(first2)",pausebetweenimages)
return
}
if (tdiv2.style.pixelTop>=tdiv2.offsetHeight*-1){
tdiv2.style.pixelTop-=5
setTimeout("move4(second2)",100)
}
else{
tdiv2.style.pixelTop=scrollerheight
tdiv2.innerHTML=slideimages[i]
if (i==slideimages.length-1)
i=0
else
i++
}
}

function startscroll(){
if (document.all){
move3(first2)
second2.style.top=scrollerheight
}
else if (document.layers){
move1(document.main.document.first)
document.main.document.second.top=scrollerheight+5
document.main.document.second.visibility='show'
}
}

window.onload=startscroll

//-->

</script>
      <ilayer id="main" width=&{scrollerwidth}; height=&{scrollerheight}; bgcolor=&{scrollerbgcolor};> 
      <layer id="first" left=0 top=1 width=&{scrollerwidth};> 
      <script language="JavaScript1.2">
if (document.layers)
document.write(slideimages[0])
</script>
      </layer>
      <layer id="second" left=0 top=0 width=&{scrollerwidth}; visibility=hide> 
      <script language="JavaScript1.2">
if (document.layers)
document.write(slideimages[1])
</script>
      </layer>
      </ilayer>
      <p> 
        <script language="JavaScript1.2">
<!-- 

if (document.all){
document.writeln('<span id="main2" style="position:relative;width:'+scrollerwidth+';height:'+scrollerheight+';overflow:hiden;background-color:'+scrollerbgcolor+'">')
document.writeln('<div style="position:absolute;width:'+scrollerwidth+';height:'+scrollerheight+';clip:rect(0 '+scrollerwidth+' '+scrollerheight+' 0);left:0;top:0">')
document.writeln('<div id="first2" style="position:absolute;width:'+scrollerwidth+';left:0;top:1;">')
document.write(slideimages[0])
document.writeln('</div>')
document.writeln('<div id="second2" style="position:absolute;width:'+scrollerwidth+';left:0;top:0">')
document.write(slideimages[1])
document.writeln('</div>')
document.writeln('</div>')
document.writeln('</span>')
}
//--> 

</script>

注:本例中所用到的五张图放在与本页面同级的"img"文件夹内,名字分别为logo1.gif,logo2.gif...。

②源程序讲解：(无解释)

22. 旋转的文字
①源代码如下：
（这段程序放在<body>与</body>之间）
<script language=javascript>
Phrase="洪恩在线 求知无限"
Balises=""
Taille=40;
Midx=100;
Decal=0.5;
Nb=Phrase.length;
for (x=0;x<Nb;x++){
  Balises=Balises + '<DIV Id=L' + x + ' STYLE="width:3;font-family: Courier New;font-weight:bold;position:absolute;top:320;left:400;z-index:0">' + Phrase.charAt(x) + '</DIV>'
}
document.write (Balises);
Time=window.setInterval("Alors()",10);
Alpha=5;
I_Alpha=0.05;

function Alors(){
	Alpha=Alpha-I_Alpha;
	for (x=0;x<Nb;x++){
		Alpha1=Alpha+Decal*x;
		Cosine=Math.cos(Alpha1);
		Ob=document.all("L"+x);
		Ob.style.posLeft=Midx+100*Math.sin(Alpha1)+400;
		Ob.style.zIndex=20*Cosine;
		Ob.style.fontSize=Taille+25*Cosine;
		Ob.style.color="rgb("+ (233+Cosine*80+50) + ","+ (127+Cosine*80+50) + ",0)";
	}
}

</script>

②源程序讲解： 
Phrase="洪恩在线 求知无限"
Balises="" 
Taille=40;
Midx=100; 
Decal=0.5; 
Nb=Phrase.length; 	声明一些变量，并赋初值。
for (x=0;x<Nb;x++)
{ Balises=Balises +
'<DIV Id=L' + x + '
STYLE= "width:3;font-family: Courier New;
fontweight:bold;position:absolute;
top:320;left:400;z-index:0">' + 
Phrase.charAt(x) + '</DIV>' } 	定义要显示的字的颜色，位置，字体。
document.write (Balises); 
Time=window.setInterval("Alors()",10);	输出文字，每10毫秒，变化一次。
Alpha=5; 
I_Alpha=0.05; 	声明一些变量，并赋初值。
function Alors()
{ Alpha=Alpha-I_Alpha; 
for (x=0;x<Nb;x++)
{ Alpha1=Alpha+Decal*x;	设置文字的透明度的变化。
Cosine=Math.cos(Alpha1); 	声明变量Cosine，值是一个余弦函数在0到360度之间的变化。
Ob=document.all("L"+x); 
Ob.style.posLeft=Midx+
100*Math.sin(Alpha1)+400; 
Ob.style.zIndex=20*Cosine; 
Ob.style.fontSize=Taille+25*Cosine; 	定义输出文字的位置，深度和字体大小。
Ob.style.color="rgb("+ (233+Cosine*80+50)
+ ","+ (127+Cosine*80+50) + ",0)"; } } 	定义输出文字的颜色。

23. 页面自动滚动
①源代码如下：
(这段程序放在<head>与</head>之间)
<SCRIPT LANGUAGE="JAVASCRIPT">
<!--
var position = 0;
var timeoutid=null; 
function scrollhtml() {
if (position < 400 ){
position++;
scroll(0,position);
clearTimeout(timeoutid);
timeoutid = setTimeout("scrollhtml()",100); }
else{
clearTimeout(timeoutid);
scroll(0,0);
}}
-->
</SCRIPT>

(这段程序放在<body>与</body>之间)
<input type="button" name="submit" value="开始滚动" onClick="scrollhtml()">

②源程序讲解：
var position = 0; 	设置变量position的值为0。
var timeoutid=null; 	设置延时变量的值为空。
function scrollhtml()	定义一个函数。
{ if (position < 400 )
{ position++;	如果当前的页面长度小于400，opsition的值累加，直至大于等于400。
scroll(0,position);	页面开始滚动，x坐标不动，y向开始滚动，直到posotion位置。
clearTimeout(timeoutid); 	取消延时变量的值。
timeoutid = setTimeout("scrollhtml()",100); }	settimeout的作用就是在100毫秒后，自动调用scrollhtml函数。
else{ clearTimeout(timeoutid); 	如果当前的页面长度不小于400，每100毫秒，自动调用scrollhtml函数，此时间可以自己设置，它决定滚动速度。
scroll(0,0);	回到初始位置。

24. 查看源代码
①源代码如下：
(这段程序放在<body>与</body>之间)
<input type="BUTTON" value="查看源代码" onClick= 'window.location = "view-source:" + window.location.href' name="BUTTON">

②源程序讲解：
window.location = "view-source:" + window.location.href	输出浏览器将要打开的输入框。

25. 窗口从天而降效果
①源代码如下：
(这段程序放在<head>与</head>之间)
<script>
function drop(n) {
	if(self.moveBy){
		self.moveBy (0,-900);
		for(i = n; i > 0; i--){
			self.moveBy(0,3);
		}
		for(j = 8; j > 0; j--){
			self.moveBy(0,j);
			self.moveBy(j,0);
			self.moveBy(0,-j);
			self.moveBy(-j,0);
		}
	}
}
</script>

(这段程序放在<body ****>正文中)
onLoad="drop(300)


②源程序讲解：
function drop(n)	定义一个函数，名为drop。
{ if(self.moveBy)
{ self.moveBy (0,-900);	如果当前的窗口存在，就移动到相对于当前窗口正上方900像素的地方,moveby函数表示相对位置。
for(i = n; i > 0; i--)
{ self.moveBy(0,3); }	此例中n=300，每次相对当前窗口向下移动3个像素。
for(j = 8; j > 0; j--){ 	这是一个循环。
self.moveBy(0,j);
self.moveBy(j,0);
self.moveBy(0,-j); 
self.moveBy(-j,0);	窗口分别向下，左，上，右移动j个像素，产生震动的效果。

26. 背景图居中
①源代码如下：
(这段程序放在<head>与</head>之间)
<STYLE TYPE="text/css">
<!--
BODY {background-image:img/bgchild.jpg;
background-position: center;
background-repeat: no-repeat;
background-attachment: fixed;}
-->
</STYLE>

②源程序讲解：
BODY {background-image: URL(picture1.jpg);
background-position: center; 
background-repeat: no-repeat; 
background-attachment: fixed;} 	定义背景图的属性，位置是居中，不重复码放，且固定。
注：要在<body>里，写上 background="URL(picture1.jpg)"。

27. 向前向后翻页
①源代码如下：
(这段程序放在<body>与</body>之间)
<a href ="" onClick="parent.history.back(); return false;" onMouseOver="self.status='后退' ;return true;"><img src="img/1.gif" border=0 ></a> 
<a href ="" onClick="parent.history.forward(); return false;" onMouseOver="self.status='前进'; return true;"><img src="img/2.gif" border=0 width="60" height="56" ></a>

②源程序讲解：
onClick="parent.history.back(); return false;" onMouseOver="self.status='后退' ;return true;	当点击图标时，从当前正在执行调用的文档中，回到上一次访问的历史纪录。当鼠标放在图标上时，状态栏上显示“后退”两字。
onClick="parent.history.forward(); return false;" onMouseOver="self.status='前进'; return true;	当点击图标时，从当前正在执行调用的文档中，装入在URL纪录上的下一个文档。当鼠标放在图标上时，状态栏上显示“前进”两字。
注：图片放在与文件同级的“img”文件夹中，名为1.gif 和2.gif。

28. 背景不动效果
①源代码如下：
(这段程序放在<body ****>正文中)
style="BACKGROUND-ATTACHMENT: fixed" background="img/bgfix.gif"

②源程序讲解：
style="BACKGROUND-ATTACHMENT: fixed" background="img/bgfix.gif" 	style表明背景的属性是固定的。
注:此效果只能在IE浏览器中实现。本例中所用到的背景图放在与本页面同级的“ing”文件夹内，名为bgfix.gif。

29. 页面装载效果

javascript 之 select下拉框

1.动态创建select

    function createSelect(){

        var mySelect = document.createElement(select); 
        mySelect.id = mySelect;  
        document.body.appendChild(mySelect);
    }

2.添加选项option

   function addOption(){

        根据id查找对象，
         var obj=document.getElementById('mySelect');

         添加一个选项
         obj.add(new    Option(文本,值));   
   }

3.删除所有选项option

   function removeAll(){
         var obj=document.getElementById('mySelect');
  
         obj.options.length=0;  

   }

4.删除一个选项option

function removeOne(){
         var obj=document.getElementById('mySelect');

         index,要删除选项的序号，这里取当前选中选项的序号

         var index=obj.selectedIndex;
         obj.options.remove(index);  
   }

5.获得选项option的值

var obj=document.getElementById('mySelect');

var index=obj.selectedIndex; 序号，取当前选中选项的序号

var val = obj.options[index].value;

6.获得选项option的文本

var obj=document.getElementById('mySelect');

var index=obj.selectedIndex; 序号，取当前选中选项的序号

var val = obj.options[index].text;

7.修改选项option

var obj=document.getElementById('mySelect');

var index=obj.selectedIndex; 序号，取当前选中选项的序号

var val = obj.options[index]=new Option(新文本,新值);

8.删除select

    function removeSelect(){
          var mySelect = document.getElementById(mySelect);
         mySelect.parentNode.removeChild(mySelect);
   }

Java排序算法
1）分类：
1）插入排序（直接插入排序、希尔排序）
2）交换排序（冒泡排序、快速排序）
3）选择排序（直接选择排序、堆排序）
4）归并排序
5）分配排序（箱排序、基数排序）
所需辅助空间最多：归并排序
所需辅助空间最少：堆排序
平均速度最快：快速排序
不稳定：快速排序，希尔排序，堆排序。
1）选择排序算法的时候
1.数据的规模 ；  2.数据的类型 ；  3.数据已有的顺序  
一般来说，当数据规模较小时，应选择直接插入排序或冒泡排序。任何排序算法在数据量小时基本体现不出来差距。 考虑数据的类型，比如如果全部是正整数，那么考虑使用桶排序为最优。  考虑数据已有顺序，快排是一种不稳定的排序（当然可以改进），对于大部分排好的数据，快排会浪费大量不必要的步骤。数据量极小，而起已经基本排好序，冒泡是最佳选择。我们说快排好，是指大量随机数据下，快排效果最理想。而不是所有情况。
3）总结：
——按平均的时间性能来分：
	1）时间复杂度为O(nlogn)的方法有：快速排序、堆排序和归并排序，其中以快速排序为最好；
	2）时间复杂度为O(n2)的有：直接插入排序、起泡排序和简单选择排序，其中以直接插入为最好，特		别是对那些对关键字近似有序的记录序列尤为如此；
	3）时间复杂度为O(n)的排序方法只有，基数排序。
当待排记录序列按关键字顺序有序时，直接插入排序和起泡排序能达到O(n)的时间复杂度;而对于快速排序而言，这是最不好的情况，此时的时间性能蜕化为O(n2)，因此是应该尽量避免的情况。简单选择排序、堆排序和归并排序的时间性能不随记录序列中关键字的分布而改变。
——按平均的空间性能来分（指的是排序过程中所需的辅助空间大小）：
	1） 所有的简单排序方法(包括：直接插入、起泡和简单选择)和堆排序的空间复杂度为O(1)；
	2） 快速排序为O(logn )，为栈所需的辅助空间;
	3） 归并排序所需辅助空间最多，其空间复杂度为O(n );
	4）链式基数排序需附设队列首尾指针，则空间复杂度为O(rd )。
——排序方法的稳定性能：
	1） 稳定的排序方法指的是，对于两个关键字相等的记录，它们在序列中的相对位置，在排序之前和	经过排序之后，没有改变。
	2） 当对多关键字的记录序列进行LSD方法排序时，必须采用稳定的排序方法。
	3） 对于不稳定的排序方法，只要能举出一个实例说明即可。
	4） 快速排序，希尔排序和堆排序是不稳定的排序方法。
4）插入排序：
包括直接插入排序，希尔插入排序。
直接插入排序： 将一个记录插入到已经排序好的有序表中。
	 1, sorted数组的第0个位置没有放数据。
	 2，从sorted第二个数据开始处理：
	  		如果该数据比它前面的数据要小，说明该数据要往前面移动。
	  		首先将该数据备份放到 sorted的第0位置当哨兵。
	  		然后将该数据前面那个数据后移。
	  		然后往前搜索，找插入位置。
	 		找到插入位置之后讲 第0位置的那个数据插入对应位置。
O(n*n), 当待排记录序列为正序时，时间复杂度提高至O(n)。
希尔排序（缩小增量排序 diminishing increment sort）：先将整个待排记录序列分割成若干个子序列分别进行直接插入排序，待整个序列中的记录基本有序时，再对全体记录进行一次直接插入排序。
面试穿什么，这里找答案！
插入排序Java代码：
public class InsertionSort {
//	插入排序：直接插入排序 ，希尔排序	 
	public void straightInsertionSort(double [] sorted){
		int sortedLen= sorted.length;
		for(int j=2;j<sortedLen;j++){
			if(sorted[j]<sorted[j-1]){
				sorted[0]= sorted[j];//先保存一下后面的那个				
				sorted[j]=sorted[j-1];// 前面的那个后移。
				int insertPos=0;
				for(int k=j-2;k>=0;k--){
					if(sorted[k]>sorted[0]){
						sorted[k+1]=sorted[k];
					}else{
						insertPos=k+1;
						break;
					}
				}				
				sorted[insertPos]=sorted[0];
			}			
		}		
	}	
	public void shellInertionSort(double [] sorted, int inc){
		int sortedLen= sorted.length;
		for(int j=inc+1;j<sortedLen;j++ ){
			if(sorted[j]<sorted[j-inc]){
				sorted[0]= sorted[j];//先保存一下后面的那个
				
				int insertPos=j;				
				for(int k=j-inc;k>=0;k-=inc){					
					if(sorted[k]>sorted[0]){
						sorted[k+inc]=sorted[k];						
						//数据结构课本上这个地方没有给出判读，出错：
						if(k-inc<=0){
							insertPos = k;
						}
					}else{
						insertPos=k+inc;
						break;
					}
				}				
				sorted[insertPos]=sorted[0];				
			}
		}
	}
	public void shellInsertionSort(double [] sorted){
		int[] incs={7,5,3,1};
		int num= incs.length;
		
		int inc=0;
		for(int j=0;j<num;j++){
			inc= incs[j];			
			shellInertionSort(sorted,inc);			
		}		
	}	
	public static void main(String[] args) {
		Random random= new Random(6);
		
		int arraysize= 21;
		double [] sorted=new double[arraysize];
		System.out.print("Before Sort:");		
		for(int j=1;j<arraysize;j++){
			sorted[j]= (int)(random.nextDouble()* 100);
			System.out.print((int)sorted[j]+" ");
		}	
		System.out.println();
				
		InsertionSort sorter=new InsertionSort();		
//		sorter.straightInsertionSort(sorted);
		sorter.shellInsertionSort(sorted);
		
		System.out.print("After Sort:");
		for(int j=1;j<sorted.length;j++){
			System.out.print((int)sorted[j]+" ");
		}	
		System.out.println();
	}
}
面试穿什么，这里找答案！
5）交换排序：
包括冒泡排序，快速排序。
冒泡排序法：该算法是专门针对已部分排序的数据进行排序的一种排序算法。如果在你的数据清单中只有一两个数据是乱序的话，用这种算法就是最快的排序算法。如果你的数据清单中的数据是随机排列的，那么这种方法就成了最慢的算法了。因此在使用这种算法之前一定要慎重。这种算法的核心思想是扫描数据清单，寻找出现乱序的两个相邻的项目。当找到这两个项目后，交换项目的位置然后继续扫描。重复上面的操作直到所有的项目都按顺序排好。
快速排序：通过一趟排序，将待排序记录分割成独立的两个部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。具体做法是：使用两个指针low,high, 初值分别设置为序列的头，和序列的尾，设置pivotkey为第一个记录，首先从high开始向前搜索第一个小于pivotkey的记录和pivotkey所在位置进行交换，然后从low开始向后搜索第一个大于pivotkey的记录和此时pivotkey所在位置进行交换，重复知道low=high了为止。
交换排序Java代码：
public class ExchangeSort {
	public void BubbleExchangeSort(double [] sorted){
		int sortedLen= sorted.length;
		for(int j=sortedLen;j>0;j--){
			int end= j;
			for(int k=1;k<end-1;k++){
				double tempB= sorted[k];
				sorted[k]= sorted[k]<sorted[k+1]?
sorted[k]:sorted[k+1];
				if(Math.abs(sorted[k]-tempB)>10e-6){
					sorted[k+1]=tempB;
				}
			}			
		}
	}	
	public void QuickExchangeSortBackTrack(double [] sorted,
int low,int high){
		if(low<high){
			int pivot= findPivot(sorted,low,high);
			QuickExchangeSortBackTrack(sorted,low,pivot-1);
			QuickExchangeSortBackTrack(sorted,pivot+1,high);
		}
	}
	public int findPivot(double [] sorted, int low, int high){		
		sorted[0]= sorted[low];		
		while(low<high){
			while(low<high && sorted[high]>= sorted[0])--high;
			sorted[low]= sorted[high];
			while(low<high && sorted[low]<=sorted[0])++low;
			sorted[high]= sorted[low];
		}
		sorted[low]=sorted[0];	
		return low;
	}
	public static void main(String[] args) {
		Random random= new Random(6);
		
		int arraysize= 21;
		double [] sorted=new double[arraysize];
		System.out.print("Before Sort:");		
		for(int j=1;j<arraysize;j++){
			sorted[j]= (int)(random.nextDouble()* 100);
			System.out.print((int)sorted[j]+" ");
		}	
		System.out.println();
				
		ExchangeSort sorter=new ExchangeSort();		
//		sorter.BubbleExchangeSort(sorted);
		sorter.QuickExchangeSortBackTrack(sorted, 1, arraysize-1);
		System.out.print("After Sort:");
		for(int j=1;j<sorted.length;j++){
			System.out.print((int)sorted[j]+" ");
		}	
		System.out.println();
	}
}
6）选择排序：
分为直接选择排序， 堆排序
直接选择排序：第i次选取 i到array.Length-1中间最小的值放在i位置。
堆排序：首先，数组里面用层次遍历的顺序放一棵完全二叉树。从最后一个非终端结点往前面调整，直到到达根结点，这个时候除根节点以外的所有非终端节点都已经满足堆得条件了，于是需要调整根节点使得整个树满足堆得条件，于是从根节点开始，沿着它的儿子们往下面走（最大堆沿着最大的儿子走，最小堆沿着最小的儿子走）。 主程序里面，首先从最后一个非终端节点开始调整到根也调整完，形成一个heap， 然后将heap的根放到后面去（即：每次的树大小会变化，但是 root都是在1的位置，以方便计算儿子们的index，所以如果需要升序排列，则要逐步大顶堆。因为根节点被一个个放在后面去了。 降序排列则要建立小顶堆）
代码中的问题： 有时候第2个和第3个顺序不对（原因还没搞明白到底代码哪里有错）
选择排序Java代码：
public class SelectionSort {
	public void straitSelectionSort(double [] sorted){
		int sortedLen= sorted.length;
		for(int j=1;j<sortedLen;j++){
			int jMin= getMinIndex(sorted,j);
			exchange(sorted,j,jMin);
		}
	}
	public void exchange(double [] sorted,int i,int j){
		int sortedLen= sorted.length;
		if(i<sortedLen && j<sortedLen && i<j && i>=0 && j>=0){
			double temp= sorted[i];
			sorted[i]=sorted[j];
			sorted[j]=temp;
		}
	}
	public int getMinIndex(double [] sorted, int i){
		int sortedLen= sorted.length;
		
		int minJ=1;
		double min= Double.MAX_VALUE;
		for(int j=i;j<sortedLen;j++){
			if(sorted[j]<min){
				min= sorted[j];
				minJ= j;
			}
		}
		return minJ;
	}
		
	public void heapAdjust(double [] sorted,int start,int end){
		if(start<end){
			double temp= sorted[start];
//			这个地方j<end与课本不同，j<=end会报错：
			for(int j=2*start;j<end;j *=2){	
				if(j+1<end && sorted[j]-sorted[j+1]>10e-6){
					++j;			
				}
				if(temp<=sorted[j]){
					break;
				}			
				sorted[start]=sorted[j];
				start=j;			
			}
			sorted[start]=temp;
		}
	}	
	public void heapSelectionSort(double [] sorted){
		int sortedLen = sorted.length;
		
		for(int i=sortedLen/2;i>0;i--){
			heapAdjust(sorted,i,sortedLen);
		}
		for(int i=sortedLen;i>1;--i){			
			exchange(sorted,1,i);			
			heapAdjust(sorted,1,i-1);			
		}		
	}
	public static void main(String [] args){
		Random random= new Random(6);
		
		int arraysize=9;
		double [] sorted=new double[arraysize];
		System.out.print("Before Sort:");		
		for(int j=1;j<arraysize;j++){
			sorted[j]= (int)(random.nextDouble()* 100);
			System.out.print((int)sorted[j]+" ");
		}	
		System.out.println();
				
		SelectionSort sorter=new SelectionSort();		
//		sorter.straitSelectionSort(sorted);
		sorter.heapSelectionSort(sorted);
		
		System.out.print("After Sort:");
		for(int j=1;j<sorted.length;j++){
			System.out.print((int)sorted[j]+" ");
		}	
		System.out.println();
	}
}
面试穿什么，这里找答案！
7）归并排序：
将两个或两个以上的有序表组合成一个新的有序表。归并排序要使用一个辅助数组，大小跟原数组相同，递归做法。每次将目标序列分解成两个序列，分别排序两个子序列之后，再将两个排序好的子序列merge到一起。
归并排序Java代码：
public class MergeSort {	
	private double[] bridge;//辅助数组
	public void sort(double[] obj){
		if (obj == null){
			throw new NullPointerException("
The param can not be null!");
		}
		bridge = new double[obj.length]; // 初始化中间数组
		mergeSort(obj, 0, obj.length - 1); // 归并排序
		bridge = null;
	}
	private void mergeSort(double[] obj, int left, int right){
		if (left < right){
			int center = (left + right) / 2;
			mergeSort(obj, left, center);
			mergeSort(obj, center + 1, right);
			merge(obj, left, center, right);
		}
	}
	private void merge(double[] obj, int left, 
int center, int right){
		int mid = center + 1;
		int third = left;
		int tmp = left;
		while (left <= center && mid <= right){ 
// 从两个数组中取出小的放入中间数组
			if (obj[left]-obj[mid]<=10e-6){
				bridge[third++] = obj[left++];
			} else{
				bridge[third++] = obj[mid++];
			}
		}

		// 剩余部分依次置入中间数组
		while (mid <= right){
			bridge[third++] = obj[mid++];
		}
		while (left <= center){
			bridge[third++] = obj[left++];
		}
		// 将中间数组的内容拷贝回原数组
		copy(obj, tmp, right);
	}
	private void copy(double[] obj, int left, int right)
	{
		while (left <= right){
			obj[left] = bridge[left];
			left++;
		}
	}
	public static void main(String[] args) {
		Random random = new Random(6);

		int arraysize = 10;
		double[] sorted = new double[arraysize];
		System.out.print("Before Sort:");
		for (int j = 0; j < arraysize; j++) {
			sorted[j] = (int) (random.nextDouble() * 100);
			System.out.print((int) sorted[j] + " ");
		}
		System.out.println();

		MergeSort sorter = new MergeSort();
		sorter.sort(sorted);
		
		System.out.print("After Sort:");
		for (int j = 0; j < sorted.length; j++) {
			System.out.print((int) sorted[j] + " ");
		}
		System.out.println();
	}
}
面试穿什么，这里找答案！

8）基数排序：
使用10个辅助队列，假设最大数的数字位数为 x， 则一共做 x次，从个位数开始往前，以第i位数字的大小为依据，将数据放进辅助队列，搞定之后回收。下次再以高一位开始的数字位为依据。
以Vector作辅助队列，基数排序的Java代码：
public class RadixSort {
	private int keyNum=-1;	
	private Vector<Vector<Double>> util;
	
	public void distribute(double [] sorted, int nth){		
		if(nth<=keyNum && nth>0){
			util=new Vector<Vector<Double>>();
			for(int j=0;j<10;j++){
				Vector <Double> temp= new Vector <Double>();
				util.add(temp);
			}			
			for(int j=0;j<sorted.length;j++){
				int index= getNthDigit(sorted[j],nth);
				util.get(index).add(sorted[j]);
			}
		}
	}	
	public int getNthDigit(double num,int nth){
		String nn= Integer.toString((int)num);
		int len= nn.length();
		if(len>=nth){
			return Character.getNumericValue(nn.charAt(len-nth));	
		}else{
			return 0;
		}			
	}
	public void collect(double [] sorted){	
		int k=0;
		for(int j=0;j<10;j++){
			int len= util.get(j).size();
			if(len>0){
				for(int i=0;i<len;i++){
					sorted[k++]= util.get(j).get(i);
				}
			}
		}
		util=null;
	}
	public int getKeyNum(double [] sorted){		
		double max= Double.MIN_VALUE;
		for(int j=0;j<sorted.length;j++){
			if(sorted[j]>max){
				max= sorted[j];
			}
		}		
		return Integer.toString((int)max).length();
	}
	public void radixSort(double [] sorted){
		if(keyNum==-1){			
			keyNum= getKeyNum(sorted);
		}
		for(int i=1;i<=keyNum;i++){
			distribute(sorted,i);
			collect(sorted);			
		}
	}
	public static void main(String[] args) {
		Random random = new Random(6);

		int arraysize = 21;
		double[] sorted = new double[arraysize];
		System.out.print("Before Sort:");
		for (int j = 0; j < arraysize; j++) {
			sorted[j] = (int) (random.nextDouble() * 100);
			System.out.print((int) sorted[j] + " ");
		}
		System.out.println();

		RadixSort sorter = new RadixSort();
		sorter.radixSort(sorted);
		
		System.out.print("After Sort:");
		for (int j = 0; j < sorted.length; j++) {
			System.out.print((int) sorted[j] + " ");
		}
		System.out.println();
	}
}
=====》总结：上述Java代码中，基本上用的都是double数组，如果想要应用其他的数组，只需要将double数组改成 Comparable接口数组，凡是实现了Comparable接口的都可以用。而在C++中，是用模板类来解决这个问题。

– 我的短期目标是进入到一个规范的、正在不断发展的企业，得到一份有挑战性，同时又能让我充分学习成长的工作。而XX企业正是我最好的选择。
–而我的长期目标是能成为一位职业经理人。从当前这份基础工作做起，不断磨练自己，与公司共同进步，最终进入管理层，成为在相应领域有能力独当一面的领导者。
.将任务分解，一个紧急的任务也必然是可分解成多个小任务的，在其中再设置优先级，优先完成其中更紧急的部分。在时间这么紧迫的情况下，完成主体部分应该可以满足要求。

一、请你自我介绍一下；
二、谈谈你的家庭情况；
三、你有什么业余爱好；
四、你最祟拜谁；
五、谈谈你的缺点：
六、谈谈你的一次失败经历；
七、你为什么选择我们公司；
八、如果录用你，你将如何开展工作；
九、与上级意见不一致时你将怎么办；
十、我们为什么要录用你；
十一、你是应届毕业生缺乏经验如何能胜任这项工作；

如“我的学习能力、适应能力很强。”“人际关系很好”等都是可提出的优点，
　4.你有哪些主要的缺点?
5.你想得到的薪水是多少?

、对你来说工作中最重要的是什么？
　　2、为什么愿意为本公司工作？
　　3、你认为公司为什么要聘用你？
　　4、如果我们聘用你，你会待多久？
　　5、在你看来，我们会为你的职业生涯规划一个怎样的环境？
　　6、你的长处是什么？
　　7、什么是你最大的弱点？友情提示：不妨借自我批评来自我表扬。
　　8、你如何评价你的前任老板？
　　9、你的业余时间喜欢做什么？
　　10、你觉得5年后你会是什么样？
　　11、你对薪水的期望是多少？
　　12、如果……的话，你怎么办？友情提示：面对这类情景模拟、角色扮演的问题，宜多提供几套解决方案，以体现思维的敏捷与多元。
　　13、你对什么职位感兴趣？
　　14、你先介绍一个自己。友情提示：宜把回答控制在5分钟以内，并能有实例说明问题。
　　15、你对我们公司有什么想法？友情提示：这可体现你对公司前景的关注，切忌回答：“都很好，没什么想法。”(
问题五、谈谈你最后悔的一件事。
问题六、谈谈你的家庭情况。
问题八、你认为什么才叫事业有成。
问题八、你认为什么才叫事业有成。
问题九、你为什么会选择我们公司。

　　分析：这是个棘手的问题。若照实的回答，你会毁了工作，雇主试图使你处于不利的境地，观察你在类似的工作困境中将作出什么反应。

　　回答对策：回答这样的问题应诚实。完满地回答应该是用简洁正面的介绍抵消反面的问题。

　　回答样板1：“工人们指责我对工作太投入。我经常提前一点上班安排好我的工作，晚上晚一点下班，使要干的事得以完成。”

　　回答样板2：“我需要学会更耐心一点。我的性子比较急，我总要我的工作赶在第一时间完成。我不能容忍工作怠慢。”

　　评语：回答的虽是自身的缺点，但却表现了正面的效果，对工作的积极抵消了反面。



–当然了，事物总是发展变化的，无论是人生目标还是职业规划都要根据当时的情况调整才可以。
1.你觉得你最大的缺点是什么？
这种问题，你就需要化缺点为优点，方能避过你的岗位缺陷。我的回答是：我这个人很容易受他人影响，别人学习，我会学着跟他学习，别人在娱乐，我会学着劳逸结合跟着娱乐，我相信我有幸加入的贵公司，通过贵公司的优秀的文化以及像老师您这样优秀的员工上能够受到更好的影响。
2.你为什么选择我们公司呢？
我的回答是：贵公司的品牌形象好，贵公司在不断地发展，另外培训发展的机会比较多，从这三个方面切入展开，会得到非常好的效果。
3.你未来三到五年你有什么职业规划？
这个问题公司都会问，就是看你的个人潜力以及你是否有目标。针对这个问题。我的回答如下：
我基于技术，但我不拘泥于技术，我会从多角度去发展业务，管理，协调方面的能力。最后在三到五年内成为一名业务管理技术型的复合型人才。这样的回答，我觉得简单而又力度。自我感觉不错。
4. “举例你生活经历中当你真正遇到挑战时你是如何应对？”，
充满机遇与挑战的社会，面对挑战，我会从容不迫，寻找挑战中的机遇，面对挑战，我学会了冷静，总结挑战带给我的乐趣。面对挑战，我选择了坚强，去寻找一条通往机遇的道路。
5.“谈谈你觉得你那些方面最“不”适合这个岗位（研发）”，
研发追求的是细心谨慎而又不骄不躁的作风。我自身活泼开朗，对细节问题深入钻研。带给我在研发岗位上追求更加完美化。这样容易拖慢研发的进度。未来抽出我性格的一部分能够更加促进我在研发岗位的快速步伐。也相信我的细心能够带给研发上的完美。
6，压力测试的一道题：假如我们公司没有录用你，你觉得自己自身存在什么不足？
如果遇到的是女生的话，建议这样回答：你不可能不录用我，面试官就会说，假如真不录用呢。你就回答，那估计我是女生。所以到的这个时候，就不会问的，应该谁也不敢性别歧视。
如果是男生的话，就应该更有自信的说，你不可能不录用过我，《把自身优势说下》，就ok了。表现自信点。
7.自我介绍不需要准备。只准备框架。这个我把我的自我介绍的框架说说，我的自我介绍是这样的：您好，我叫XXX，我是重庆邮电大学硕士应届毕业生，我所学的专业是计算机应用技术，我研究方向是数据挖掘以及网格计算，作为一名应届毕业生，我认为自己在三个方面优势：
1.第一个优势是我的专业技能。我的计算机网络实践经验，《后面就对自己的这方面的内容展开阐述一段简单而又力度的话》。
2.第二个优势是我的计算机软件编程能力，《后面就对自己的这方面的内容展开阐述一段简单而又力度的话》。
3.第三个优势，我在学习期间，培养了管理能力，沟通能力，分析解决问题能力，团队合作能力，《后面就对自己的这方面的内容展开阐述一段简单而又力度的话》。
以上总结的我的特点，这些将带领我的前进奋斗，不断地去冲破障碍，最终定下目标以至于实现，在此，我也感谢贵公司给我这次面试的机会，也体会得到了贵公司人性化的招聘标准。
8.我们为什么要聘用你呢？
这个问题就需要，你把职位的要求告诉他，我具备的这个能力，其他P话都不要说。
9.当和你的面试官沉默的时候，你要打破这个僵局，后面弄的一句话，就说：您看我这样说可以吗？简单的一句话打开的僵局，以至于你们互动了。
10.在面试过程中，不要去说，我觉得怎么样。这样让人家很反感。
11.群面的时候，注意这些技巧哈。我觉得非常的有用。
1)当面试官说开始群面的时候，你就来一句：来，我们抓紧时间，只有几分钟。这样能够让人家看到你有管理者的风范。
2）快结束的时候，你立马说句。现在还有两分钟时间，咱们是不是应该结束讨论了。
3）碰到话比较多的时候，你立马对那个人说。我觉得你提出的观点很多，咱们是不是听听他的意见。这里面的那个他是指你队里一个不说话的人。
4）适当的做些记录。
12.上面列出来的问题，都是我在实战中得到验证，效果非常的好，我现在说说，你在跟面试官对话的过程中，语气以及手势和表情情况。这个是细节，当时决定你这个人是否有自信的前提。说说语气哈，你得放慢。但不能太慢，也不能太快，你得控制好节奏。记住。另外，说说，手势，干嘛要说这个呢。就是应该这个直接导致你的自信。因为这个可以让你的人变的非常的精神。在面试官德7秒钟印象中是非常的深刻的。最后，说下表情，当你讲到问题的答案的时候，不要去笑，显得你也不正经。当面试官在对你的评价以及回答问题的时候，你必须保持笑容。完了。

//http://www.cnblogs.com/wodepp2011/archive/2011/06/29/2151302.html
对于学习static我们先来看两个例子：
//Example 1  Tst.java，no main() method
   package com.blogchina.qb2049;
   public class Tst
   {
      static { System.out.println("111111"); } 
   }
运行结果为: 111111
           Exception in thread "main" java.lang.NoSuchMethodError: main
同样的道理看第二个例子：
//Example 2  TFrame.java,no main() method
  package com.blogchina.qb2049;
  import javax.swing.JFrame;
  public class TFrame
  {
    static {
               JFrame jfr_fr= new JFrame("无main（）窗体 ");
               jfr_fr.setLocation(400,300);
               jfr_fr.setSize(200,300);
               jfr_fr.setVisible(true);
               jfr_fr.setDefaultCloseOperation(jfr_fr.EXIT_ON_CLOSE);
            } 
 }运行结果如下图： 


 
     这到底怎么回事 ，这不和我们大多数教程 介绍的无main（）方法程序似乎不能运行相矛盾吗。其实，这其中的缘由 就在于那个static的修饰。我在学习java时，static的学习让我很受启发 ，特此把它的总结如下，希望对想学习java的朋友有所帮助。同时，本文中的不足还希望大家多多的提出来，我们共同学习。 

学习本文你到底要学到什么：
1、 static在java中到底代表什么，为何要用它？
2、 static在java中怎么用？
3、 static 有那些特点和使用的“局限”？ 


1、 static在java中到底代表什么，为何要用它？
     static――静态――“指定位置“
     首先，我们来看看java的内存：java把内存分为栈内存和堆内存，栈内存用来存放一些基本类型的变量和数组及对象的引用变量，而堆内存主要是来放置对象的。
      用 static的修饰的变量和方法，实际上是指定了这些变量和方法在内存中的“固定位置”－static storage。既然要有“固定位置”那么他们的 “大小”似乎就是固定的了，有了固定位置和固定大小的特征了，在栈中或堆中开辟空间那就是非常的方便了。如果静态的变量或方法在不出其作用域的情况下，其引用句柄是不会发生改变的。
      我们常看到：static变量有点类似于C中的全局变量的概念；静态表示的是内存的共享，就是它的每一个实例都指向同一个内存地址。把static拿来，就是告诉JVM它是静态的，它的引用（含间接引用）都是指向同一个位置，在那个地方，你把它改了，它就不会变成原样，你把它清理了，它就不会回来了。我们常可看到类似以下的例子来说明这个问题：
    class Student{
                static int numberOfStudents=0;
                Student()
                 {
                   numberOfStudents++;
                 }
               } 每一次创建一个新的Student实例时,成员numberOfStudents都会不断的递增,并且所有的Student实例都访问同一个 numberOfStudents变量,实际上int numberOfStudents变量在内存中只存储在一个位置上。为了来更好的说明这个问题，我特意学习张老师（张孝祥）使用一个形象的图解：
            创建两个Student实例，stu1＝new Student(); stu2=new Student();     

               

             多个实例共享一个变量似乎不足以让我们对static那么的热情，实际上java引入static却有另外的含义： 

      (1)、引用static的方法和变量，不需要和实例捆绑在一起,这可以提高代码的编写的效率，这样的例子我们随处可见；
      (2)、 java的主类中main()方法本身就是一个static的，所以main方法的执行就是在没有产生新的实例的情况；对于静态的东西，JVM在加载类时，就在內存中开辟了这些静态的空间，所以虽没有静态的main()方法但是程序还是执行了，不过抛出来了无main()方法的异常。这也不知算不算是 java的一个漏洞；
      (3)、如果需要创建一个脱离于实例的变量或方法（只与整个类有关），那么用static作修饰是再好不过了，如我们经常看到要统计实例实现的个数（通常的例子就是计数）。
      (4)、使用一种静态的方法的编程通常叫做防御(defensive)编程,它可以在API供应商突然中断支持的情况下保护代码   


2、 static在java中怎么用？
     使用static时，要记着我阐述的static代表什么。
      static 使用非常的简单，如果要修饰一个静态块只需：staic {……..}即可（常用静态块来初始化一些变量）； 静态方法就参照main()的形式：访问标识 static returnType method(…) {};静态变量就是：static type fields；
     在使用静态的方法时，可以直接用类名来引用，不需要创建实例（当然创建实例也是可以的），例如，System.out,String.valueOf()等等。 

3、 static 有那些特点和使用的“局限”？
     从上面的分析可知，static的东西在类加载时，就分配了内存空间，即编译时就为这些成员变量的实例分配了空间。
      那么在static块内和方法体内，我们能给它放一个在内存中还没有着落的变量？显然与我们先前所说的相左。static的东西，人家是在 static storage中有“指定位置“的，如果我们茫然的在static的作用域中放置一个普通的变量，那么编译时JVM就毫不客气的给你个异常：
non-static variable a cannot be referenced from a static context或 non- static method Test() cannot be referenced from a static context（注：Test() 是我试验时的一个例子 ），除非我在static中现场开辟空间，用new来要内存。
对于static的初始化问题，我们还是值得讨论的。现看下面的例子：
//StaticInit show the static decorated initialization 
package com.blogchina.qb2049;
public class StaticInit
{
   static int i;
   int a;
   public StaticInit()
   {
      a=6;
      System.out.println("a 的初始化"+a);
   } 
   public static void main(String[] args)
  {
    new StaticInit();
  }
  static 
  {
     i=5;
     System.out.println("i 的初始化"+i);
  }
}运行结果如下：i 的初始化5
                        a 的初始化6  静态块的初始化要早于非静态的，原因就是在于这些东西是在类装载时就开始初始化了。
      说起static的“局限“，总结起来就是：在static的方法中仅能够调用其他的static方法和static变量；在static方法中不能以任何方式引用this或super；static变量在定义时必须进行初始化，并且初始化的时间早于非静态。还有一个局限我需要具体的说明一下，static 的变量的初始化仅能一次，如下例：
    //Static.java， initialize only one
    class T1
    {   
     static int t=1;
     T1(int b)
     {
       t=b;
     }
   }
   public class Static
    {
       T1 t1=new T1(2);
       T1 t2=new T1(3);
       T1 t3=new T1(4);
       public Static()
       {
         System.out.println("t1: "+t1.t);
         System.out.println("t2: "+t2.t);
         System.out.println("t3: "+t3.t);
      }
      public static void main(String args[])
      {
        new Static();
      }
   }
运行结果为: t1: 4
                        t2: 4
                        t3: 4 

该static变量只是接受了最后一次的初始化.实际这还是我们先前提到的多个实例共享一个静态的变量的问题。
总之，static就是给我们一个这样的忠告：static的东西在编译时，就已向内存要到了存取空间了。 

--------------------------------------------------------------------------------------


java中static作用详解 
2012-4-26 13:00| 发布者: benben| 查看: 2949| 评论: 0

摘要: static表示全局或者静态的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的 ...
static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。
被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。

只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。

用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。

static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。

static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：
类名.静态方法名(参数列表...)
类名.静态变量名

用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块（用处非常大，呵呵）。

1、static变量
　按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。

两者的区别是：
　对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。
　对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。

所以一般在需要实现以下两个功能时使用静态变量：
?  在对象之间共享值时
?  方便访问变量时


2、静态方法
静态方法可以直接通过类名调用，任何的实例也都可以调用，
因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。
因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！
因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。

例如为了方便方法的调用，Java API中的Math类中所有的方法都是静态的，而一般类内部的static方法也是方便其它类对该方法的调用。

静态方法是类内部的一类特殊方法，只有在需要时才将对应的方法声明成静态的，一个类内部的方法一般都是非静态的

 

 

3、static代码块

　static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。例如：

public class Test5 {
private static int a;
private int b;

static{
Test5.a=3;
System.out.println(a);
Test5 t=new Test5();
t.f();
t.b=1000;
System.out.println(t.b);
}
static{
Test5.a=4;
System.out.println(a);
}
public static void main(String[] args) {
// TODO 自动生成方法存根
}
static{
Test5.a=5;
System.out.println(a);
}
public void f(){
System.out.println("hhahhahah");
}
} 

运行结果：
3
hhahhahah
1000
4
5

　利用静态代码块可以对一些static变量进行赋值，最后再看一眼这些例子，都一个static的main方法，这样JVM在运行main方法的时候可以直接调用而不用创建实例。

4、static和final一块用表示什么
static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！
对于变量，表示一旦给值就不可修改，并且通过类名可以访问。
对于方法，表示不可覆盖，并且可以通过类名直接访问。

有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ，所以它被声明为static。

声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。声明为static的方法有以下几条限制：
•
它们仅能调用其他的static 方法。
•
它们只能访问static数据。
•
它们不能以任何方式引用this 或super（关键字super 与继承有关，在下一章中描述）。
如果你需要通过计算来初始化你的static变量，你可以声明一个static块，Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法，一些static变量，以及一个static 初始化块：
// Demonstrate static variables，methods，and blocks.

class UseStatic {
static int a = 3;
static int b;

static void meth(int x) {
System.out.println("x = " + x);
System.out.println("a = " + a);
System.out.println("b = " + b);
}

static {
System.out.println("Static block initialized.");
b = a * 4;
}

public static void main(String args[]) {
meth(42);
}
}

一旦UseStatic 类被装载，所有的static语句被运行。首先，a被设置为3，接着static 块执行(打印一条消息)，最后，b被初始化为a*4 或12。然后调用main()，main() 调用meth() ，把值42传递给x。3个println ( ) 语句引用两个static变量a和b，以及局部变量x 。

注意：在一个static 方法中引用任何实例变量都是非法的。

下面是该程序的输出：

Static block initialized.
x = 42
a = 3
b = 12
在定义它们的类的外面，static 方法和变量能独立于任何对象而被使用。这样，你只要在类的名字后面加点号运算符即可。例如，如果你希望从类外面调用一个static方法，你可以使用下面通用的格式：

classname.method( )

这里，classname 是类的名字，在该类中定义static方法。可以看到，这种格式与通过对象引用变量调用非static方法的格式类似。一个static变量可以以同样的格式来访问——类名加点号运算符。这就是Java 如何实现全局功能和全局变量的一个控制版本。

下面是一个例子。在main() 中，static方法callme() 和static 变量b在它们的类之外被访问。

class StaticDemo {
static int a = 42;
static int b = 99;
static void callme() {

System.out.println("a = " + a);
}
}

class StaticByName {

public static void main(String args[]) {
StaticDemo.callme();
System.out.println("b = " + StaticDemo.b);
}
}

下面是该程序的输出：

a = 42
b = 99

static成员是不能被其所在class创建的实例访问的。

如果不加static修饰的成员是对象成员，也就是归每个对象所有的。

加static修饰的成员是类成员，就是可以由一个类直接调用，为所有对象共有的
 

hp面试:
1.servlet是不是线程安全的，怎样保障线程安全。（synchronized 设置同步块，或者lock实现也可以。其次尽量少的使用实例变量，最好使用局部变量，防止资源访问冲突）
2.设计一个蛋挞（java装饰模式）相关的了解一下单例模式，工厂模式。
3.知道sysdate，求下一个周日的date（to_char(sysdate,‘DDD’)）
4.类的关系（依赖，关联，聚合，组合，继承）
5.struts 2是怎样封装servlet的（servlet在struts 2里面起到的作用）struts2能实现那些功能？以及说一下你对spring和hibernate的理解（相关的会问一些问题）
6.linux和unix系统的区别，联系，linux的缩写
7.jdbc链接oracle有哪几种连接方式，以及连接成功后，存储过程(precedure)拷贝怎样实现。
8.jsp的9个内置对象，servlet的生命周期，request与session的区别。
9，说一下你现在项目的框架，你担任的角色，负责的模块。
10，怎样管理控制UT,以及build项目。然后其后的部署发布。
11，怎样实现或者启动一个线程（其实我感觉他想问的是Eventqueue.invokelater()）。wait（），sleep()方法，哪个持有资源，哪个释放资源。他们分别属于哪个类。

------------------------------------------------

数据库：
游标的使用；
oracle隔离模式(isolate level)有哪几种?
物理模式和逻辑模式的区别；
三张表进行关联，写出sql语句；
static 是什么意思？，举一个使用static的例子
一段程序，在多线程下执行，怎么写？
一个整型的数组，写一段程序去掉重复的数据。
public ,private,protected的使用方法
1.Hashtable和HashMap有什么区别？
2.你怎么理解MVC模式？

5.如果SQLServer中有两个数据库，那么让你把这两个数据库对应到Oracle中，你应该怎么做？
6.有两个页面a.jsp和b.jsp，要从a.jsp传值到b.jsp有几种方法？分别是什么？
7.有三个页面，a.jsp,b.jsp和c.jsp,流程是：a.jsp->b.jsp->c.jsp,其中a.jsp中提交的数据要在c.jsp中访问，用最简单的方法怎么做？注意不能放在session里
7.jsp和servlet有什么区别？
8.映射是什么？你怎么理解映射？
9.Hibernate中：不看数据库，不看XML文件，不看查询语句，怎么样能知道表结构？
10.SQLServer支持集群吗？
11.为什么要用MVC？我从JSP页面直接访问数据库不是更简单吗,为什么非要先提交到控制器再做处理？
12.在struts中，假设有一个对数据库中一张表的增删改查的操作，你是写一个action还是写多个action？为什么？
13.struts中的actionform有什么好处？
14.用过Hibernate吗，用它有什么好处？
15.通常所说的web应用程序分3层，即MVC，如果我想分4层，应该怎么分？

1、介绍一下COOKIE、SESSION的联系和区别，多台web服务器如何共享SESSION？
2、HTTP协议中的POST和GET有什么区别？ 如何选用？
4、reqiure的include都可包含文件，二者的区别是什么？
6、写一个函数，可以遍历文件夹下的所有文件和文件夹。
------------------------------------------------

1 iterator 
2 内部类
3 深复制 浅复制
4.hashtable 的 key value
5. Oracle 左右链接 全连接 ， 日期的操作 
6 接口能继承吗？读程题
7 Exception
8 事务的隔离等级，还有一个问题，记不清楚了。
9 字符串的 反向输出，不能用reverse 百度下，有。
10，一个冒泡的时间复杂度计算
11 JMS
-------------------------------------------------
1.网络通讯中，端口有什么含义。端口的取值范围？ 
2.jsp是如何被容器调用和执行的？ 
3.编写一个servlet的步骤。 
4.为什么要为servlet配置URL映射 
5.谈谈servlet的生命周期 
6.说出3个常见协议的默认端口。 
7.socket是什么，它有什么作用？ 
8.TCP/IP通讯的基本步骤是什么？ 
9.UDP通讯的基本步骤是什么？ 
10.JDBC访问数据库的基本步骤是什么(手写)？ 
11、说说preparedStatement和Statement的区别 
12.说说事务的概念，在JDBC编程中处理事务的步骤。 
13. 数据库连接池的原理。为什么要使用连接池。 
14. servlet和jsp有什么关系？ 
15.编写一个servlet的步骤。 
--------------------------------------------------

异常----问的还是很深的，分类
接口--抽象类
线程与同步---
final ，finnaly ，finnalize
泛型 
colllections 与 cellection
在try中return值了，finnaly还会执行么
接口可否继承
序列化
怎样除去list中的重复行，
list<Person>中加入list<customer>,可以么，customer是Person的子类
设计模式---- 单利（饥汉模式，有几种实现方法---单例模式序列化后返回不到原来的对象是怎么回事），工厂（说下spring的工厂，spring有什么好处），
项目中你是怎样使用设计模式的，spring中的工厂模式
说下你的项目流程
----------------数据库-----------
执行计划
函数与存储过程的区别
还有两个问题记不得了，是关于Oracle的
数据的优化
如果有一条sql语句执行很慢，你怎样调优
说下%rowtype
---索引，怎么创建索引
---事务---spring中的事物，还让写了个具体怎么写AOP（让我现场配置一下），IOC--项目流程
------------------in english
介绍下你自己
为什么离职
介绍下你最近做过的一个项目
你的工作职责，技术
遇到了什么样的困难，怎么解决的，有什么想法
---------------------------------

js，怎么放大显示一个文本框据框
---jsp页面中颜色各行变色怎么实现
----最大素数的算法
介绍下ajax
--让你学习一个性语言，你要多久（flex）
jquery等用过么
---项目管理工具--ANT，maven等了解下（用什么方式去协调你的团队开发）
-----------------------------------
unix 基本命令，grep知道么
-
问问题先根据你的项目来问，如果问的差不多了，还会问一些其他问题，这个就比较随机了

---------------------------------------------------------------------------------

unit test
-------------------------------------------------




1.什么是事务控制？
事务应该具有4个属性：原子性、一致性、隔离性、持续性。
事务有两种操作：提交，回滚
-------------------------------
2.过滤器的作用？
过 滤器是一个对象，可以传输请求或修改响应。它可以在请求到达Servlet/JSP之前对其进行预处理，而且能够在响应离开Servlet/JSP之后对 其进行后处理。所以如果你有几个Servlet/JSP需要执行同样的数据转换或页面处理的话，你就可以写一个过滤器类，然后在部署描述文件 （web.xml）中把该过滤器与对应的Servlet/JSP联系起来。

3.为什么要引入连接池？
首先在Web开发中，如果使用 JDBC连接数据库，那么每次访问请求都必须建立连接——打开数据库——存取数据库——关闭连接等一系列步骤。但是我们知道数据库的连接打开不仅费时，而 且消耗比较多的系统资源。如果进行数据库操作的次数比较少，那么还不至于有多大的影响，但是假如频繁的进行数据库操作，那么系统的性能将会受到很大影响。
其 次，是造成数据库连接泄漏。数据库连接泄漏这个词是第一次听说，指的是如果在某次使用或者某段程序中没有正确地关闭Connection、 Statement和ResultSet资源，那么每次执行都会留下一些没有关闭的连接，这些连接失去了引用而不能得到重新使用，因此就造成了数据库连接 的泄漏。数据库连接的资源是宝贵而且是有限的，如果在某段使用频率很高的代码中出现这种泄漏，那么数据库连接资源将被耗尽，影响系统的正常运转。
--------------------------------
4.JSP中动态INCLUDE与静态INCLUDE的区别？
动态INCLUDE用jsp:include动作实现 它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数。
静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面
<%@include file=”"%> 编译期 导入 合并成1个Servlet 效率较高 (用include伪码实现，适用于包含静态页面)
<jsp:include file=”"> 动态连接 效率低于<%@include file=”"%> (但它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数)
主要就是1个编译期就合成1个Servlet了 一个是2个Servlet 动态连接
（JSP 最终就是被容器编译成个 Servlet ）
--------------------------------
5. jsp中，session对象存在哪个地方，如何进行存取，存在服务器哪个地方，如何存的？
1、session在何时被创建
一 个常见的误解是以为session在有客户端访问时就被创建，然而事实是直到某server端程序调用 HttpServletRequest.getSession(true)这样的语句时才被创建，注意如果JSP没有显示的使用 <% @page session=”false”%> 关闭session，则JSP文件在编译成Servlet时将会自动加上这样一条语句 HttpSession session = HttpServletRequest.getSession(true);这也是JSP中隐含的 session对象的来历。
由于session会消耗内存资源，因此，如果不打算使用session，应该在所有的JSP中关闭它。
2、session何时被删除
综合前面的讨论，session在下列情况下被删除a.程序调用HttpSession.invalidate();或b.距离上一次收到客户端发送的session id时间间隔超过了session的超时设置;或c.服务器进程被停止（非持久session）
3、如何做到在浏览器关闭时删除session
严格的讲，做不到这一点。可以做一点努力的办法是在所有的客户端页面里使用javascript代码window.oncolose来监视浏览器的关闭动作，然后向服务器发送一个请求来删除session。但是对于浏览器崩溃或者强行杀死进程这些非常规手段仍然无能为力。
--------------------------------
9、为什么在Weblogic Server中改变session的值后要重新调用一次session.setValue
做这个动作主要是为了在集群环境中提示Weblogic Server session中的值发生了改变，需要向其他服务器进程复制新的session值。

-------------------------------
7.什么是WEBSERVICE?及它的常用开发框架？
Web Service就是为了使原来各孤立的站点之间的信息能够相互通信、共享而提出的一种接口。
Web Service所使用的是Internet上统一、开放的标准，如HTTP、XML、SOAP（简单对象访问协议）、WSDL等，所以Web Service可以在任何支持这些标准的环境（Windows,Linux）中使用。
优势：(1).跨平台。
(2).SOAP协议是基于XML和HTTP这些业界的标准的，得到了所有的重要公司的支持。
(3).由于使用了SOAP，数据是以ASCII文本的方式而非二进制传输，调试很方便；并且由于这样，它的数据容易通过防火墙，不需要防火墙为了程序而单独开一个“漏洞”。
(4).此外，WebService实现的技术难度要比CORBA和DCOM小得多。
(5).要实现B2B集成，EDI比较完善与比较复杂；而用WebService则可以低成本的实现，小公司也可以用上
(6).在C/S的程序中，WebService可以实现网页无整体刷新的与服务器打交道并取数。
缺点：
(1).WebService使用了XML对数据封装，会造成大量的数据要在网络中传输。
(2).WebService规范没有规定任何与实现相关的细节，包括对象模型、编程语言，这一点，它不如CORBA
webservice的几种常用框架及开发过程：
--------------------------------
18.几种常用的数据结构及内部实现原理？
6.DAO 模式通过对底层数据的封装，为业务曾提供一个面向对象的接口，使得业务逻辑开发员可以面向业务中的实体进行编码。
DAO模式,在项目开发中主要用在数据层，封装数据的访问操作，为业务层提供数据服务。
15. Ajax是如何工作的？
---------------------------------
XMLHttpRequest 用于在后台与服务器交换数据。这意味着可以在不重新加载整个网页的情况下，对网页的某部分进行更新。
---------------------------------
3. XML文档定义有几种形式？它们之间有何本质区别？解析XML文档有哪几种方式？ 

解答xml两种形式 dtd schema，他们的本质区别:schema本身是xml的，可以被XML解析器解析(这也是从DTD上发展schema的根本目的)，c:有DOM,SAX,STAX等
DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问
SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问
STAX:Streaming API for XML (StAX)
---------------------------------
POJO是一个简单的普通的Java对象，它包含业务逻辑或持久逻辑等，但不是JavaBean、EntityBean等，
不具有任何特殊角色和不继承或不实现任何其它Java框架的类或接口。

---------------------------------
1：EJB:

答:   Enterprise Java Bean 相当于DCOM，即分布式组件。它是基于Java的远程方法调用（RMI）技术的，所以EJB可以被远程访问 （跨进程、跨计算机） 。但EJB必须被布署在诸如Webspere、WebLogic这样的容器中，EJB客户从不直接访问真正的EJB组件，而是通过其容器访问。EJB容器是EJB组件的代理，EJB组件由容器所创建和管理。客户通过容器来访问真正的EJB组件。

答：Enterprise java bean 容器。更具有行业领域特色。他提供给运行在其中的组件EJB各种管理功能。只要满足J2EE规范的EJB放入该容器，马上就会被容器进行高效率的管理。并且可以通过现成的接口来获得系统级别的服务。例如邮件服务、事务管理。

----------------------------------
下面来看一下：getCurrentSession 与 openSession() 的区别

1.getCurrentSession创建的session会和绑定到当前线程,而openSession不会。

2 getCurrentSession创建的线程会在事务回滚或事物提交后自动关闭,而openSession必须手动关闭

3. getCurrentSession () 使用当前的session，openSession() 重新建立一个新的session

这里getCurrentSession本地事务(本地事务:jdbc)时 要在配置文件里进行如下设置

 * 如果使用的是本地事务（jdbc事务）
 <property name="hibernate.current_session_context_class">thread</property>
 * 如果使用的是全局事务（jta事务）
 <property name="hibernate.current_session_context_class">jta</property> 

openSession() 与 getCurrentSession() 有何不同和关联呢？

在 SessionFactory 启动的时候，Hibernate 会根据配置创建相应的 CurrentSessionContext，在 getCurrentSession() 被调用的时候，实际被执行的方法是 CurrentSessionContext.currentSession() 。在 currentSession() 执行时，如果当前 Session 为空，currentSession 会调用 SessionFactory 的 openSession。所以 getCurrentSession() 对于 Java EE 来说是更好的获取 Session 的方法。

---------------------------------
Hibernate中java对象的三种状态：


1、临时状态（transient）：刚刚用new语句创建，还没有被持久化，不处于Session的缓存中。处于临时状态的Java对象被称为临时对象。 

2、持久化状态（persistent）：已经被持久化，加入到Session的缓存中。处于持久化状态的Java对象被称为持久化对象。 

3、游离状态（detached）：已经被持久化，但不再处于Session的缓存中。处于游离状态的Java对象被称为游离对象。 

----------------------------------
Session的二级缓存 


Hibernate提供了两级缓存，第一级缓存是Session的缓存。由于Session对象的生命周期通常对应一个数据库事务或者一个应用事务，因此它的缓存是事务范围的缓存。第一级缓存是必须的，不允许而且事实上也无法被卸除。在第一级缓存中，持久化类的每个实例都具有惟一的OID。 第二级缓存是一个可插拔的缓存插件，它由SessionFactory负责管理。由于SessionFactory对象的生命周期和应用程序的整个进程对应，因此第二级缓存是进程范围的缓存。这个缓存中存放的是对象的散装数据。第二级缓存是可选的，可以在每个类或每个集合的粒度上配置第二级缓存。
----------------------------------
Hibernate检索机制中主要分为三种，他们各自有各自的好处和缺点，他主要分为以下三种：

1.立即检索策略 

2.延迟检索策略 

3.左外连接检索策略 

立即检索缺点：

          select语句的数目太多，需要频繁的访问数据库，会影响检索性能。如果需要查询n个Customer对象，那么必须执行n+1次select查询语句。这种检索策略没有利用SQL的连接查询功能

01.select * from CUSTOMERS left outer join ORDERS   
02.on CUSTOMERS.ID=ORDERS.CUSTOMER_ID   
select * from CUSTOMERS left outer join ORDERS 
on CUSTOMERS.ID=ORDERS.CUSTOMER_ID 


      以上select语句使用了SQL的左外连接查询功能，能够在一条select语句中查询出CUSTOMERS表的所有记录，以及匹配的ORDERS表的记录。 在应用逻辑只需要访问Customer对象，而不需要访问Order对象的场合，加载Order对象完全是多余的操作，这些多余的Order对象白白浪费了许多内存空间。 

http soap关系
http:是一个客户端和服务器端请求和应答的标准（TCP）。http协议其目的是为了提供一种发布和接收htttp页面的方法

一http协议的客户端与服务器的交互：由HTTP客户端发起一个请求，建立一个到服务器指定端口（默认是80端口）的TCP连接。HTTP服务器则在那个端口监听客户端发送过来的请求。一旦收到请求，服务器（向客户端）发回一个状态行，比如"HTTP/1.1 200 OK"，和（响应的）消息，消息的消息体可能是请求的文件、错误消息、或者其它一些信息。

 

soap 协议：它描述了一种在分散或分布式的环境中如何交换信息的轻量级协议。soap在http协议的基础上，一个基于XML的协议。

不同：都是底层的通信协议，请求包的格式不同而已，soap包是XML格式,http纯文本格式。

 

关系：SOAP是个通信协议， SOAP在HTTP协议的基础上，把编写成XML的REQUEST参数, 放在HTTP BODY上提交个WEB SERVICE服务器(SERVLET，ASP什么的) 处理完成后，结果也写成XML作为RESPONSE送回用户端， 为了使用户端和WEB SERVICE可以相互对应，可以使用WSDL作为这种通信方式的描述文件，利用WSDL工具可以自动生成WS和用户端的框架文件，SOAP具备把复杂对象序列化捆绑到XML里去的能力。

import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import org.apache.commons.collections.map.HashedMap;
public class TestMap {	
public static void main(String[] args) {		
            Map<String, String> map = new HashedMap();		
              map.put("1", "x");		
             map.put("2", "2x");		
             map.put("3", "3x");//要是只要哪一条那么直接map.get("1");即可		Set<String> key = map.keySet();		
       for (Iterator<String> it = key.iterator(); 
           it.hasNext();) {			
           String s = it.next();			
              System.out.println(s+":"+map.get(s));//这里的s就是map中的key，map.get(s)就是key对应的value。		}	}}

请问添加到什么容器中的类才必须的同时重写equals方法和hashCode方法？
我看有人说实现List接口的类比如ArrayList LinkedList 都不需要实现这两个方法，HashMap  HashSet就必须的实现这两个方法
我编了如下程序，发现添加到TreeSet中的似乎不需要重写equals方法 和 hashCode 方法？
感觉好乱啊！
请问诸位高手，到底添加到什么容器中的类才必须的同时重写equals方法和hashCode方法啊？ 
----------------------------------------------
1. HashSet是通过HashMap实现的,TreeSet是通过TreeMap实现的,只不过Set用的只是Map的key
2. Map的key和Set都有一个共同的特性就是集合的唯一性.TreeMap更是多了一个排序的功能.
3. hashCode和equal()是HashMap用的, 因为无需排序所以只需要关注定位和唯一性即可.
   a. hashCode是用来计算hash值的,hash值是用来确定hash表索引的.
   b. hash表中的一个索引处存放的是一张链表, 所以还要通过equal方法循环比较链上的每一个对象
       才可以真正定位到键值对应的Entry.
   c. put时,如果hash表中没定位到,就在链表前加一个Entry,如果定位到了,则更换Entry中的value,并返回旧value
4. 由于TreeMap需要排序,所以需要一个Comparator为键值进行大小比较.当然也是用Comparator定位的.
   a. Comparator可以在创建TreeMap时指定
    b. 如果创建时没有确定,那么就会使用key.compareTo()方法,这就要求key必须实现Comparable接口.
   c. TreeMap是使用Tree数据结构实现的,所以使用compare接口就可以完成定位了

public String Login() {

		UserVo user = (UserVo) userService.loadUser(userVo);
		if (user == null) {
			message = CommonTools.createFriendlyErrMsg(
					"error.username.notexiste",
					new Object[] { userVo.getUserId() });
		}
		if (message == null || message.isEmpty()) {
			sessionMap.put(SystemConstants.USER_KEY, user);
			return "success";

		} else {
			return "failure";
		}
	}
	
	public String Logon() throws Exception {
		return "success";
	}
--------------------------------------------------------
error.username.notexiste = User [{0}] does not exist.

<action name="login" class="com.web.action.UserAction" method="Login">
            <result  name = "success" type="redirect">/unspecial.action</result>
            <result type="redirectAction" name="failure">
			    <param name="actionName">/user/logon.action</param>
			    <param name="message">${message}</param>
			</result>
--------------------------------------------------------
public class CommonTools {

	public static String createFriendlyErrMsg(String key,Object[] values){
		
		ResourceBundle resourceBundle = ResourceBundle.getBundle("message");
		
		String msg = resourceBundle.getString(key);
		
		if(values !=null && values.length>0){
			msg = MessageFormat.format(msg, values);
		}
		return msg;
	}
}
--------------------------------------------------------

带时分秒 转换成日期类型to_date('20120801 00:00:00','yyyymmdd HH24:Mi:SS') 
六种日期函数：
1. add_months(日期，number) 指定日期推迟number个月
2. last_day(日期) 指定日期当月的最后一天
3. new_time(日期，时区简写) 调整时区
4. next_day(日期，number) number表示周几，星期日是1，指定number的日期（一周内或一周后）
5. months_between(日期1，日期2) 日期1和日期2之间有几个月
6. sysdate 系统当期那日期和时间
-----------------------------------------------------------
文章来源: http://sxdjnn.blogchina.com/5566266.html

oracle plsql 对日期的处理函数和sql例子
                                       

oracle plsql 对日期的处理函数和sql例子



102.取时间点的年份的写法:
select to_char(sysdate,'yyyy') from dual;


103.取时间点的月份的写法:
select to_char(sysdate,'mm') from dual;


104.取时间点的日的写法:
select to_char(sysdate,'dd') from dual;


105.取时间点的时的写法:
select to_char(sysdate,'hh24') from dual;


106.取时间点的分的写法:
select to_char(sysdate,'mi') from dual;


107.取时间点的秒的写法:
select to_char(sysdate,'ss') from dual;


108.取时间点的日期的写法:
select trunc(sysdate) from dual;


109.取时间点的时间的写法:
select to_char(sysdate,'hh24:mi:ss') from dual;


110.日期,时间形态变为字符形态
select to_char(sysdate) from dual;


111.将字符串转换成日期或时间形态:
select to_date('2003/08/01') from dual;


112.返回参数的星期几的写法:
select to_char(sysdate,'d') from dual;



113.返回参数一年中的第几天的写法:
select to_char(sysdate,'ddd') from dual;


114.返回午夜和参数中指定的时间值之间的秒数的写法:
select to_char(sysdate,'sssss') from dual;



115.返回参数中一年的第几周的写法:
select to_char(sysdate,'ww') from dual;

多Web服务器之间共享Session的解决方案  2011-12-15 09:11:40|  分类： 默认分类 |  标签： |字号大中小 订阅 .


参考资料：

一、提出问题：

为了满足足够大的应用，满足更多的客户，于是我们架设了N台Web服务器（N>=2），在多台Web服务器的情况下，我们会涉及到一个问题：用户登陆一台服务器以后，如果在跨越到另一台服务器的时候能够继续使用客户的Session？

二、解决方案：

1. 写客户端Cookie的方式
       当用户登陆成功以后，把网站域名、用户名、密码、token、 session有效时间全部采用cookie的形式写入到客户端的cookie里面，如果用户从一台Web服务器跨越到另一台服务器的时候，我们的程序主动去检测客户端的cookie信息，进行判断，然后提供对应的服务，当然，如果cookie过期，或者无效，自然就不让用户继续服务了。当然，这种方法的弊端就不言而喻了，比如客户端禁用了cookie或者cookie被黑客窃取了呢？这些都可以解决，目前淘宝session框架就是基于client cookie做开发，不见得他们就出了很大的问题？也许是最可行的方式，可以配合memcached来实现。

2. 服务器之间Session数据同步的方式
       假设Web服务器A是所有用户登陆的服务器，那么当用户验证登陆一下，session数据就会写到A服务器里，那么就可以自己写脚本或者守护进程来自动把session数据同步到其他Web服务器，那么当用户跳转到其他服务器的时候，那么session数据是一致的，自然就能够直接进行服务无须再次登陆了。缺点是，可能会速度慢，不稳定，如果是单向同步的话，登陆服务器出现问题，那么其他服务器也无法服务，当然也可以考虑双向同步的问题。这个方案都可以解决，目前zookeeper可以实现。

3. 利用NFS共享Session数据的方式
       其实这个方案和下面的Mysql方案类似，只是存储方式不一 样。大致就是有一台公共的NFS服务器（Network File Server）做共享服务器，所有的Web服务器登陆的时候把session数据写到这台服务器上，那么所有的session数据其实都是保存在这台 NFS服务器上的，不论用户访问哪台Web服务器，都要来这台服务器获取session数据，那么就能够实现共享session数据了。缺点是依赖性太强，如果NFS服务器down掉了，那么大家都无法工作了，当然，可以考虑多台NFS服务器同步的形式。这个方案都可以解决，目前zookeeper可以实现，当然memcached也可以实现session共享。

4. 利用Mysql数据库共享Session数据的方式
       这个方式与NFS的方式类似，也是采用一台Mysql服务器做共享服务器，把所有的session的数据保存到Mysql服务器上，所有Web服务器都来这台Mysql服务器来获取Session 数据。缺点也是依赖性太强，Mysql无法工作了影响所有的Web服务器，当然，可以考虑多太Mysql数据库来共享session，使用同步Mysql 数据的方式。这种方式跟方式3类似，同样可以采用memcached来做，nosql也可以实现，这些都不是问题。

5. 使用硬件设备
       这个算是比较成熟的解决方案了，使用类似BIG-IP的负载设备来实现资源共享，那么就能够又稳定又合理的的共享Session了。目前很多门户网站采用这种方式。缺点很明显了，就是要收费了，硬件设备肯定需要购买成本的，不过对于专业或者大型应用来讲，是比较合理并且值得的，这种方式可以放到最后面考虑。

转载，但是不知原出处。input中name和id的区别。做网站很久了，但到现在还没有搞明白input中name和id的区别，最近学习jquery，又遇到这个问题，就在网上搜集资料。看到这篇，就整理出来，以备后用。

可以说几乎每个做过Web开发的人都问过，到底元素的ID和Name有什么区别阿？为什么有了ID还要有Name呢?! 而同样我们也可以得到最classical的答案：ID就像是一个人的身份证号码，而Name就像是他的名字，ID显然是唯一的，而Name是可以重复的。 

上周我也遇到了ID和Name的问题，在页面里输入了一个input type="hidden"，只写了一个ID='SliceInfo'，赋值后submit，在后台用Request.Params["SliceInfo"]却怎么也去不到值。后来恍然大悟因该用Name来标示，于是在input里加了个Name='SliceInfo'，就一切ok了。 

第一段里对于ID和Name的解答说的太笼统了，当然那个解释对于ID来说是完全对的，它就是Client端HTML元素的Identity。而Name其实要复杂的多，因为Name有很多种的用途，所以它并不能完全由ID来代替，从而将其取消掉。具体用途有： 

用途1: 作为可与服务器交互数据的HTML元素的服务器端的标示，比如input、select、textarea、和button等。我们可以在服务器端根据其Name通过Request.Params取得元素提交的值。 
用途2: HTML元素Input type='radio'分组，我们知道radio button控件在同一个分组类，check操作是mutex的，同一时间只能选中一个radio，这个分组就是根据相同的Name属性来实现的。 
用途3: 建立页面中的锚点，我们知道<a href="URL">link</a>是获得一个页面超级链接，如果不用href属性，而改用Name，如：<a name="PageBottom"></a>，我们就获得了一个页面锚点。 
用途4: 作为对象的Identity，如Applet、Object、Embed等元素。比如在Applet对象实例中，我们将使用其Name来引用该对象。 
用途5: 在IMG元素和MAP元素之间关联的时候，如果要定义IMG的热点区域，需要使用其属性usemap，使usemap="#name"(被关联的MAP元素的Name)。 
用途6: 某些特定元素的属性，如attribute，meta和param。例如为Object定义参数<PARAM NAME = "appletParameter" VALUE = "value">或Meta中<META NAME = "Author" CONTENT = "Dave Raggett">。 

显然这些用途都不是能简单的使用ID来代替掉的，所以HTML元素的ID和Name的却别并不是身份证号码和姓名这样的区别，它们更本就是不同作用的东西。 

当然HTML元素的Name属性在页面中也可以起那么一点ID的作用，因为在DHTML对象树中，我们可以使用document.getElementsByName来获取一个包含页面中所有指定Name元素的对象数组。Name属性还有一个问题，当我们动态创建可包含Name属性的元素时，不能简单的使用赋值element.name = "..."来添加其Name，而必须在创建Element时，使用document.createElement('<element name = "myName"></element>')为元素添加Name属性。这是什么意思啊？看下面的例子就明白了。 

<script language="JavaScript"> 
var input = document.createElement('INPUT'); 
input.id = 'myId'; 
input.name = 'myName'; 
alert(input.outerHTML); 
</script> 
消息框里显示的结果是：<INPUT id=myId>。 

<script language="JavaScript"> 
var input = document.createElement('<INPUT name="myName">'); 
input.id = 'myId'; 
alert(input.outerHTML); 
</script> 
消息框里显示的结果是：<INPUT id=myId name=myName>。 
初始化Name属性的这个设计不是IE的缺陷，因为MSDN里说了要这么做的，可是这样设计的原理什么呢？我暂时没有想太明白。 

这里再顺便说一下，要是页面中有n(n>1)个HTML元素的ID都相同了怎么办？在DHTML对象中怎么引用他们呢？如果我们使用ASPX页面，这样的情况是不容易发生的，因为aspnet进程在处理aspx页面时根本就不允许有ID非唯一，这是页面会被抛出异常而不能被正常的render。要是不是动态页面，我们硬要让ID重复那IE怎么搞呢？这个时候我们还是可以继续使用document.getElementById获取对象，只不过我们只能获取ID重复的那些对象中在HTML Render时第一个出现的对象。而这时重复的ID会在引用时自动变成一个数组，ID重复的元素按Render的顺序依次存在于数组中。

 

表单元素(form input textarea select)与框架元素(iframe frame)用 name 
这些元素都与表单(框架元素作用于form的target)提交有关, 在表单的接收页面只 
接收有name的元素, 赋ID的元素通过表单是接收不到值的, 你自己可以验证一下. 
有一个例外: A 可以赋 name 作为锚点, 也可以赋ID 

当然上述元素也可以赋ID值, 赋ID值的时候引用这些元素的方法就要变一下了. 
赋 name: document.formName.inputName document.frames("frameName") 
赋 ID : document.getElementById("inputID") document.all.frameID 

只能赋ID不能赋name的元素:(除去与表单相关的元素都只能赋ID) 
body li table tr td th p div span pre dl dt dd font b 等等

Struts2 ActionContext与ServletActionContext之谈(转)  我们知道struts2接受客户端请求，在Action中进行处理后，将视图结果返回。struts2容器自身不依赖于web容器，不用和servlet对象中的请求（request）、响应（response）进行关联，对于请求的参数，通过paramerInterceptor将参数封装在Action中，然后通过调用get、set方法将参数值设置进Action之中。如果仅仅获取参数，可能有时候满足不了开发的需求，有时我们要获取request或者response中的信息，要对其进行设置、处理。

一、ActionConext（Action执行的上下文，通过它可以获取参数、会话、local信息、servletContext等）
它是保存在ThreadLocal中，线程是安全的，每次执行Action之前就会创建唯一的ActionContext实例，由于Action是运行在多线程中，那么就可以在任意Action中调用它。

获取session： Map session=ActionContext.getContext().getSession();

request获取页面参数：  Map map=ActionContext.getContext().getParameters();//获取客户端参数并封装成MAP
String username=map.get("username");//这里就获得了客户端参数；

提示：这里的session信息以及客户端参数都被封装成了Map类型，struts2考虑不与底层servlet Api打交道，那么对很多web的相关对象进行封装，这样可以达到Action与web层解耦。                         
  
二、ServletActionContext(ActionContext的子类，提供直接与servlet中Session、response、request、config、pageContext对象访问，当然也有父类的一些特性在可以访问Action中的信息、以及值栈中的信息)
获取HttpRequest对象：HttpServletRequest request = ServletActionContext. getRequest();
获取HttpSession对象：HttpSession session = ServletActionContext. getRequest().getSession();
总结：不难看出，两者之间还是存在很多共同功能，那么我们还是根据自己的需求进行选择，能用ActionContext对象满足就尽量使用ActionContext，避免让我们直接去访问Servlet对象。另外，不要在Action还没实例化的时候去通过ActionContext调用方法，因为Action实例在ActionContext实例之前创建，ActionContext中一些值还没有设置，会返回null。

转载地址：http://ajava.org/thread-65-1-1.html

oraclesqlinsertqueryselect 
INSERT INTO 表A SELECT 值, 值, 值, ……  FROM DUAL WHERE NOT EXISTS 
(SELECT 1 FROM 表A WHERE 字段A = 值) 

这条sql语句适用于oracle和mysql。 

MSSQL:去掉 "FROM DUAL"; 

public class Test {   
  
  /**  
   * @param args  
   */  
     
  public static void main(String[] args) {   
    // TODO Auto-generated method stub   
     new Test().doExecute(new CallBack(){   
  
      public void execute() {   
       System.out.println("正在执行....");   
           
      }   
          
     });   
  }   
  
  private void doExecute(CallBack callBack) {   
  
    System.out.println("回调前.....");   
    callBack.execute();   
    System.out.println("回调后.....");   
  }   
  
}  

-----------------------------------------------------------

1，比如著名的ioc的事务处理就是这样的，每个方法的事务处理都是一样的，都是些开始一个事务，用try包住，等等，所以就可以不管他们，变的只是要执行方法的不同，比如存储，删除，查询什么的。

 

2，可以减少写类，一个接口，可以有很多的实现类，在回调里面，就成了匿名的了。著名的jive里面DatabaseObjectFactory 就是这个用法。

-----------------------------------------------------------




Java代码 
interface DatabaseObjectFactory {       
      
    /**     
     * Returns the object associated with id or null if the     
     * object could not be loaded.     
     *     
     * @param id the id of the object to load.     
     * @return the object specified by id or null if it could not     
     *      be loaded.     
     */      
    public Object loadObject(long id);       
}     

interface DatabaseObjectFactory {    
   
    /**   
     * Returns the object associated with id or null if the   
     * object could not be loaded.   
     *   
     * @param id the id of the object to load.   
     * @return the object specified by id or null if it could not   
     *      be loaded.   
     */   
    public Object loadObject(long id);    
}   
 

   外面调用的根据id不同产生任何你想要的对象。

 

在看看javascript里面的：

Js代码 
function Test()   
{   
    var self=this;   
    this.func1=function()   
  {   
    self.test2(function (){ alert('正在执行');})   
  }   
}   
  
Test.prototype.test2=function(func)   
{   
    alert("回调前做些东西");   
    if(func)   
     func();   
     alert("回调后做些东西");   
}  

function Test()
{
 var self=this;
 this.func1=function()
  {
 self.test2(function (){ alert('正在执行');})
  }
}

Test.prototype.test2=function(func)
{
 alert("回调前做些东西");
 if(func)
  func();
  alert("回调后做些东西");
}
 然后，在html里面：

Html代码 
<html>  
    <head>  
        <script type=text/javascript src="1.js">  
        </script>  
        <script>  
            new Test().func1();   
        </script>  
    </head>  
    <body>  
    </body>  
</html>  

<html>
    <head>
        <script type=text/javascript src="1.js">
        </script>
        <script>
            new Test().func1();
        </script>
    </head>
    <body>
    </body>
</html>
 java和javascript的回调都差不多。

声明：JavaEye文章版权属于作者，受法律保护。没有作者书面许可不得转载。

需求确认——概要设计——详细设计——编码——单元测试——集成测试——系统测试——维护 需求确认：需求规格说明书 概要设计：系统用例图，用例场景 详细设计：系统设计报告，数据库设计报告 测试：测试用例报告
------------------------------------------------------------------------------
软件开发一般分为五个阶段：
1.问题的定义及规划此阶段是软件开发与需求放共同讨论，主要确定软件的开发目标及其可行性。

2.需求分析在确定软件开发可行性的情况下，对软件需要实现的各个功能进行详细需求分析。需求分析阶段是一个很重要的阶段，这一阶段做的好，将为整个软件项目的开发打下良好的基础。“唯一不变的是变化本身”，同样软件需求也是在软件爱你开发过程中不断变化和深入的，因此，我们必须定制需求变更计划来应付这种变化，以保护整个项目的正常进行。

3.软件设计此阶段中偶要根据需求分析的结果，对整个软件系统进行设计，如系统框架设计、数据库设计等。软件设计一般分为总体设计和详细设计。还的软件设计将为软件程序编写打下良好的基础。

4.程序编码此阶段是将软件设计的结果转化为计算机可运行的程序代码。在程序编码中必定要制定统一、符合标准的编写规范。以保证程序的可读性、易维护性。提高程序的运行效率。

5.软件测试在软件设计完成之后要进行严密的测试，一发现软件在整个软件设计过程中存在的问题并加以纠正。整个测试阶段分为单元测试、组装测试、系统测试三个阶段进行。测试方法主要有白盒测试和黑盒测试。以上就是软件开发过程的五个阶段，但是有的时候在软件爱你开发过程中并不是必须按照这个过程进行的。

package thread;

class Q {
	   int n;
	   boolean flag = false;
	   synchronized int get() {
	      if(!flag){
	         try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	      }
	      System.out.println("Got: " + n);
	      flag = false;
	      notify();
	      return n;
	   }

	   synchronized void put(int n) {
	      if(flag){
	         try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	      }
	      this.n = n;
	      flag = true;
	      System.out.println("Put: " + n);
	      notify();
	   }
	}

	class Producer implements Runnable {
	   Q q;
	   Producer(Q q) {
	      this.q = q;
	      new Thread(this, "Producer").start();
	   }

	   public void run() {
	      int i = 0;
	      while(true) {
	         q.put(i++);
	      }
	   }
	}

	class Consumer implements Runnable {
	    Q q;
	    Consumer(Q q) {
	       this.q = q;
	       new Thread(this, "Consumer").start();
	    }
	    public void run() {
	       while(true) {
	       q.get();
	    }
	  }
	}
	class PCFixed {
	   public static void main(String args[]) {
	      Q q = new Q();
	      new Producer(q);
	      new Consumer(q);
	      System.out.println("Press Control-C to stop.");
	   }
	}
	 

CDATA部件
在CDATA内部的所有内容都会被解析器忽略。

如果文本包含了很多的"<"字符和"&"字符——就象程序代码一样，那么最好把他们都放到CDATA部件中。

一个 CDATA 部件以"<![CDATA[" 标记开始，以"]]>"标记结束:

<script>
<![CDATA[
function matchwo(a,b)
{
if (a < b && a < 0) then
{
return 1
}
else
{
return 0
}
}
]]>
</script> 

在前面的例子中，所有在CDATA部件之间的文本都会被解析器忽略。

CDATA注意事项:
CDATA部件之间不能再包含CDATA部件（不能嵌套）。如果CDATA部件包含了字符"]]>" 或者"<![CDATA[" ，将很有可能出错哦。

同样要注意在字符串"]]>"之间没有空格或者换行符。

<a title="nihao,shijie" href ="www.baidu.com"/>ssss

这么写是 相当于替换页面#锚点

大致等同于
<a href="#“> 或<a href="javascript:；">

区别是空锚点会引起页面返回顶部，而javascript; javascript:void(0),不会引起页面返回顶部  

JSTL中c:set标签的要点和技巧 
c:set标签有两种不同的设置：var和target。

var“版本”用于设置作用域属性，target“版本”用于设置bean属性或Map值。

这两个版本都有两种形式：有体和没有体。有体的只是放入值的另一种途径。

★ var“版本”

<c:set var="userLevel" scope="session" value="Cowboy"/>   
   
<c:set var="fido" value="${person.dog}"/>   
   
<c:set var="user" scope="session">   
   Sheriff, Bartender, Cowgirl    
</c:set>   
如果“value”为null，“var”指定的属性将被删除！

如果“var”指定的属性不存在，则会创建一个属性，但仅当“value”不为null时才会创建新属性。

★ target“版本”

<c:set target="${petMap}" property="dogName" value="Clover" scope="session"/>   
   
<c:set target="${person}" property="name">   
   ${foo.name}    
</c:set>   
如果“target”是一个Map，“property”指定的是该Map的一个键；如果“target”是一个bean，“property”指定的是该bean的一个成员字段。

如果“target”表达式为null，容器会抛出一个异常。

如果“target”表达式不是一个Map或bean，容器会抛出一个异常。

如果“target”表达式是一个bean，但是这个bean没有与“property”匹配的成员字段，容器会抛出一个异常。

★ 使用c:set标签的要点

不能同时有“var”和“target”属性。

“scope” 是可选的，如果没有使用这个属性，则默认为页面作用域。具体的，当没有使用这个属性时，容器会依次在页面作用域、请求作用域、会话作用域、应用作用域查 找，如果找不到“var”指定名字的作用域属性，容器就会在页面作用域新建一个属性；如果找不到“target”指定的对象，容器会抛出一个异常。

<HTML>
<HEAD>
<TITLE>Demo</TITLE>
<STYLE type=text/css>
<!--
*{
   margin:0;
   padding:0;
}
html,body{
   height:100%;
}
#shadow{
   visibility:hidden;
   position:absolute; 
   z-index:10;
   left:0;
   top:0;
   width:100%;
   height:100%;
   background-color:#E0E0E0;
   filter:alpha(opacity:30);
   opacity: 0.30;
}
#box{
   visibility:hidden;
   position:absolute;
   z-index:999;
   left:40%;
   top:50%;
   width:500px;
   height:300px;
   margin:-90px 0 0 -200px;
   border:5px solid #84A0C4;
   background-color:#E0E0E0;
   text-align:center;
}
-->
</STYLE>

<SCRIPT language=javascript type=text/javascript>
<!--
function createDiv()
{
    var btnShow = document.getElementById("btnShow");
    btnShow.disabled=true;

    var box=document.getElementById("box");
    var shadow=document.getElementById("shadow");
    var btnShow=document.getElementById("btnShow");
    
    shadow.style.visibility="visible";
    box.style.visibility="visible";

    btnShow.disabled=true;
}
function hideDiv()
{
    var textUser=document.getElementById("textUser");
    var user=document.getElementById("user");
    user.value=textUser.value;

    var box=document.getElementById("box");
    var shadow=document.getElementById("shadow");
    var btnShow=document.getElementById("btnShow");
    
    shadow.style.visibility="hidden";
    box.style.visibility="hidden";

    btnShow.disabled=false;
}
-->
</SCRIPT>
</HEAD>
<div id="shadow"></div>
<div id="box">
<span>User:</span>
<input type="text" id="textUser">
<input type="button" id="button1" value="confirm" onclick="hideDiv()">
</div>
<BODY><!--StartFragment-->
<DIV style="TEXT-ALIGN: center"><INPUT id="user" type="text"> 
<INPUT id="btnShow" onclick="createDiv()" type="button" value="Display"> </DIV><!--EndFragment--></BODY>
</HTML>