1 编程经验实践，积累，总结，分享
2
3
4 博客地址：http://www.cnblogs.com/liaowanzhong/
5
6
7
8
9
10
11
12
13
14
15 1. 大量群发邮件：购买Edm服务，大的互联网企业是和邮箱服务商签订协议（百度，腾讯，京东，阿里，csdn）
16 站内信
17 内网发短信：短信猫
18
19 2. Servlet Filter 生命周期
20 *Servlet:看配置文件中web.xml配置其启动的优先级别，即当load-on-startup的值为大于等于0时,控制器
21 随服务器的启动初始化，随服务器的终止销毁，否则用户请求Servlet(控制器)时初始化Servlet,
22 随服务器的终止而销毁。
23 *Filter:服务器启动即初始化Filter(过滤器)，终止时销毁。
24
25 3. javaSE
26
27 *多线程
28 >实现方式：
29 1. 继承扩展Thread类
30 >代码：
31 //实体：自定义线程，继承Thread类，其实Thread也是实现了Runnable接口
32 class TestThread extends Thread{
33
34 //覆写run方法
35 @Override
36 public void run(){
37 //打印3个线程的名字
38 for(int i=0;i<3;i++){
39
40 //打印线程系统默认的名字
41 System.out.println(Thread.getCurrentThread().getName());
42 }
43 }
44 }
45
46 //测试，主方法
47 public class Test{
48
49 public static void main(String[] args){
50 //新建自定义线程
51 TestThread testThread=new TestThread();
52 //线程就绪，调用run方法
53 new Thread(testThread).start();
54 new Thread(testTread).start();
55 }
56 }
57
58 2. 实现Runnable接口：同上，只是实现类接口，而不是扩展类。
59 *线程池 ：生产者与消费者的数据共享域仓储即是个线城池。
60 *生产值与消费者模式：见下文
61
62 4. 生命周期
63 4.1 代码块：用大括号(表示开始和结束)扩起来的代码即是代码块，再用static关键字描述额就是静态代码块，
64 类加载时即初始化。代码块的变量生命周期即在代码块中。
65 4.2 不同变量生命周期：
66 *循环变量：在循环体中。
67 *子程序：在子程序中，即方法体中。
68 *类变量：全局变量，即静态变量，属于类所有。
69 *private：在当前类中有效。
70 *protected: 在当前类和子类中都有效。
71 *public：作用域最大，所有类都可以访问。
72
73 5. io流：
74 *字节流: InputStream(输入字节流) OutputStream(输出字节流)
75 *字符流：reader writer
76 *文件流：FileInputStream FileOutputStream:文件输入输出流，其中保存的是文件的内容流。
77
78 6. 集合
79 *List
80 >ArrayList: 实现方式为数组结构，访问效率高，使用的比较多。
81 >LinkedList: 双向链表结构，插入和删除多的时候用该链表。
82 *Set
83 >HashSet：集合里的值具有唯一性，不能有重复值，无序，在表映射文件中必要排序的时候可以配置为
84 order-by="列值"
85 *Map
86 >HashMap：访问效率高，用的比较多，键值可以为null,对象值也可以为null，线程不安全。
87 >HashTable：相比HashMap是同步的，当然效率要低，线程安全，键值对象值不可以为空，用的比较少。
88
89 7. SQL
90 *左连接：以主表为准，从表没有对应的数据设置值为null.
91 *内连接: 主从表都有的数据，取出重复的笛卡尔积。
92 *右外连接: 以从表为准, 主表没有对应的数据设置值为null.
93 *子查询: 从子查询语句过滤出的集合中再次过滤出你想要的数据集合。
94 *多表查询：一般过滤条件要加上从表的外键等于主表的主键，再加上必须的过滤条件，在查询你想要的数据。
95
96 8. 简历简明扼要 穿着落落大方
97
98 10. javaEE 框架
99 *ssh(Struts2+Spring+Hibernate)
100 *ejb:？？？Spring的前身，也是对象工厂
101 *jpa：是对象持久化规范，Hibernate是产品
102 *SpringMVC：框架，和Struts的作用一样
103
104 11. 常用设计模式和算法 ：
105 *简单工厂模式：工厂和产品组成。
106 *工厂模式：增加了抽象产品和抽象工厂，增加了可扩展性。
107 *抽象工厂模式：抽象产品是否可以有多个实例化的对象，这个是和工厂模式的区别。
108 *策略模式：由环境角色类，策略接口类，具体策略类构成。具体策略类实现策略接口类，自定义自己的的方
109 法(算法)环境角色类依赖具体策略类，并实例化具体策略类，就是在构造函数中往依赖对象中塞值，
110 实例化具体策略类，并提供外部调用的接口，就是具体策略类调用自己定义扩展的方法(算法)。
111 *适配器模式：目标接口 适配器 被适配者。
112
113 12. 常用Linux命令：记住常用的
114
115 12. 根据公司业务简述简历上写得框架的功能，使用场景
116 把公司业务讲清楚，把项目架构讲清楚，框架是如何用的，工作的职责，自己擅长的技术。
117
118 13. 项目经验问得很细
119 项目流程：
120 项目数据：每天处理多大的数据量，处理一次Job要多少时间
121 项目团队：多少人，怎么分工，自己的位置
122 项目问题：
123
124 14. 层叠样式表的特殊属性：
125 *left: -1px：左位移;
126 *bottom: -1px： 相邻元素向上位移;
127 *z-index: 0：层叠权限级别，就近原则，权限越大的叠在上面;
128
129
130 2015/8/18
131
132
133 1. java传值
134
135
136
137 2015/8/19
138
139
140
141 1. 两张表的插入，要添加事务
142 2. 表中的时间戳，数据库自动添加，建表时要设置时间的字段为默认当前时间戳，例如：date timpstamp default CURRENT_STAMP。
143 3. 订单的下单时间：String.format("%tF %tT",new Date());??不理解格式
144 4. request.getParamterMap():表单提交的参数;request.getParameter()：get请求提交的参数;
145 5. 要考虑空指针异常，增强代码健壮性。
146 6. 下拉列表的回显，jstl,el
147 *第一种方式：
148 <select id="" name="">
149 <c:forEach items="" var="">
150 <option value="" <c:if test="">selected:selected</c:if></option>
151 </c:forEach>
152 </select>
153 *第二种方式：麻烦点
154 <select name="">
155 <c:forEach items="" var="">
156 <c:choose>
157 <c:when test="">
158 <option value="" selcted="selected"></option>
159 </c:when>
160 <c:otherwise>
161 <option value=""></option>
162 </c:oterwise>
163 </c:choose>
164 </c:forEach>
165 </select>
166 6：易宝支付：???
167 7：异步请求，
168 *$.ajax(),七个属性：async:true/false,cache:false,url:"",data:{,},type:"POST",dataType:"json",
169 success:function(result);
170 *$.load()
171 *$.get()
172 *$.post(url,data)
173 8：下拉列表，$("#id").empty();//删除元素的子元素<option>,元素本身并不删除
174 9；返回是浏览器倒退，不会访问服务器
175 10：全站请求编码过滤器：
176 *自定义的:
177 >代码：
178 public class EncodingFilter implements Filter{
179 private String charset="utf-8";
180 public void destroy(){
181 }
182 public void doFilter(ServletRequest req,ServletResponse resp，
183 FilterChain chain){
184 HttpServletRequest request=(HttpServletRequest)req;
185 if(request.getMethod().equalsIgnoreCase("GET")){
186 if(!request instanceof GetRequest){
187 //处理get请求编码
188 request=new GetRequest( requset,charset);
189 }
190 }else{
191 //设置POST请求编码为默认编码utf-8
192 request.setCharacterEncoding();
193 }
194 chain.doFilter(request,resp);
195 }
196 public void init(FilterConfig fConfig) throws Exception{
197 String charsetfConfig.getInitParameter("charset");
198 if(charset!=null && !charset.isEmpty()){
199 this.charset=charset;
200 }
201 }
202 }n
203 *Spring框架提供的的CharacterEncodingFilter
204 >配置：
205 <filter>
206 <filter-name>characterEncodingFilter</filter-name>
207 <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
208 <init-param>
209 <param-name>encoding</param-name>
210 <param-value>utf-8</param-value>
211 </init-param>
212 </filter>
213 <filter-mapping>
214 <filter-name>characterEncodingFilter</filter-name>
215 <url-pattern>/*</url-pattren>
216 </filter-mapping>
217 11.
218 *MySQL数据类型：tinyint(小整型)，UNIQUE KEY `loginname` (`loginname`):字段值唯一，没有重复值
219 *MySQL数据库引擎：
220 >InnoDB: 提供事务，行级锁，适用于表更新，插入频繁。
221 >MyISAM：查询效率高，没有事务。
222 12. 实体设计：
223 *
224 >主键
225 >一般属性
226
227 >特殊属性（可获得的属性：时间，当前用户 。需计算维护的属性：count）
228 >关联关系（双向关联，单向关联：多对一较多，看表中的字段，页面的数据关联的情况）
229 *
230 >实体的类型尽量用包装类型，防止nll赋值出现异常,基本类型一般用在运算中，效率高。
231 13. 有用的工具：自定义通用工具，用在不用框架的web开发
232 *CommonUtils:
233 public class CommonUtils{
234
235 //返回32位通用唯一标识符，是去掉其中的4个"_"的
236 public static String uuid(){
237 return UUID.randomUUID().toString().replace("_","");
238 }
239
240 //把map转换为clazz型的bean
241 public static <T> T toBean(Map map,Class<T> clazz){
242
243 try{
244 //通过clazz穿件实例化bean
245 T bean=clazz.newInstance();
246 //字符串到日期的转换
247 ConvertUtils.register(new DateConverter(),java.util.Date.class);
248 //构成bean,把map中的数据封装到bean中
249 BeanUtils.populate(bean,map);
250 return bean;
251 }catch(Exception e){
252 throw new RuntimeException();
253 }
254
255 }
256
257 }
258 public class DateConverter implements Converter{
259 @Override
260 public Object convert(Class type,Object value){
261 //如果要转换的值为空指针，那么直接返回Null
262 if(value==null){
263 return null;
264 }
265 //如果要转换的值不为字符串，那么久不转换了，直接返回对象value
266 if(!(value instanceof String)){
267 return value;
268 }
269 SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
270 try{
271 return sdf.parse(value);
272 }catch(ParseException e){
273 throw new RuntimeException();
274 }
275
276 }
277 }
278
279
280
281
282 2015/8/20
283
284
285
286 1. HttpServlet:doGet(),doPost(),service();
287 2. 父类转子类:父类转子类是向下转型，需要强转，原则：父类型的引用指向的是哪个子类的实例，就能转向哪个子类的引用。
288 3. 通用工具类：实用
289 //用来作为其他Servlet的父类，Struts的Action很像
290 public class BaseServlet extends HttpServlet throws ServletException,IOException{
291
292 //覆写service方法，调用用户想要调用的方法
293 @Override
294 public void service(HttpServletRequest request,HttpServletResponse response){
295 //设置响应编码
296 response.setContentType("text/html;charset=utf-8");
297
298 //获取method参数，它是用户想调用的方法
299 String methodName=request.getMethod("method");
300 //方法对象
301 Method method=null;
302
303 //通过方法名获取方法对象
304 try{
305 method=this.getClass.getMethod(methodName,HttpServletRequest.class
306 ,HttpServletResponse.class);
307
308 }catch(Exception e){
309 //编译时异常转化为运行时异常，不要一味的抛异常，会增加复杂度
310 throw new RuntimeException(e);
311 }
312
313 try{
314 //调用用户的方法之后的返回值，这里是字符串:("f:/goods/UserServlet")
315 String result=method.invoke(this,request,response);
316
317 //根据返回结果，决定是否转发还是重定向，默认为转发
318 if(result!=null && !result.isEmpty()){
319 //
320 int index=result.indexOf(":");
321 //如果没有返回值，就默认转发
322 if(index=-1){
323 request.getRequestDispather(result).forward(request,response);
324 }else{
325 //拆分字符串,分割出前缀
326 String start=result.356lo9095/(0,index);
327 //要转发或重定向的路径
328 String path=result.substring(index+1);
329
330 if("f".equals(start)){
331 //前缀为"f",表示转发
332 request.getReqeustDispather(path).forward(request,response);
333 }else if("r".equals(start)){
334 //前缀为"r"，表示重定向
335 respose.sendRedirect(this.getServletContext+path);
336 }
337 }
338
339 }
340 }catch(Exception e){
341 throw new RuntimeException(e);
342 }
343
344 }
345 }
346 4. 自定义JdbcUtils
347 5. JQuery插件：
348 *JQuery_validate
349 *JQuery_complete
350 *JQuery_treeview
351 *fckeditor:富文本编辑器
352 6. 结构化数据(数据库) 半结构化数据(xml,html)
353 7. 验证码：防止恶意攻击，机器人注册，暴力破解。
354 *Java:一处编译，到处运行。
355 ×自定义；用AWT(Abstract Window Toolkits,依赖本地的类库，平台依赖性)实现，有点费劲
356 >用例：VerifyCode
357 //验证码:实体类
358 public class VerifyCode(){
359 //验证码矩形宽高
360 private int width=70;
361 private int hight=35;
362 //随机数,下面有用
363 private Random random=new Random();
364 //验证码中的字体类型
365 private String[] fontNames={};
366 //矩形框背景色,默认为白色
367 private Color bgColor=new Color(255,255,255);
368 private String codes="";
369
370 //验证码文本，此处为字符串
371 private String text;
372
373 //画3条线，随机长度(范围自定义),颜色为蓝色
374 public void drawLine(BufferedImage image){
375
376 //画线条数据
377 int num=3;
378
379 //得到2维制图工具
380 Graphics2D g2=image.getGraphics();
381
382 //循环画3条线
383 for(int i=0;i<num;i++){
384
385 //分别得到画线两个点的坐标
386 int x1=random.nextInt(width);
387 int y1=random.nextInt(height);
388 int x2=random.nextInt(width);
389 int y2=random.nextInt(height);
390
391 //设置画笔为1.5px框
392 g2.setStroke(new BasicStroke(1.5F));
393 //设置线条夜色为蓝色
394 g2.setColor(Color.blue);
395 //划线
396 g2.drawLine(x1,y2,x2,y2);
397 }
398 }
399
400 //创建缓冲区图片
401 public BufferedImage createImage(){
402
403 //创建缓冲区图片
404 BufferedImage image=new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);
405 //得到2维制图工具
406 Graphics2D g2=(Graphics2D)image.getGraphics();
407
408 //划线
409 g2.fillRect(0,0,width,height);
410 return image;
411 }
412
413 //获取图片接口,其中绘制4个字符串,设置字体，颜色。
414 public BufferedImage getImage(){
415
416 //创建缓冲区图片
417 BufferedImage image=createImage();
418 //得到制图工具
419 Graphics2D g2=image.getGraphics();
420 //设置字符串建立者(效率高)
421 StringBuilder sb=new StringBuilder();
422
423 //画4个字符串
424 for(int i=0;i<4;i++){
425 //设置要绘制的字符
426 String str=getRandomChar();
427 //追加字符
428 sb.append(str);
429 //设置线条字体
430 g2.setFont(getRandomFont());
431 //设置线条颜色
432 g2.setColor(getRandomColor());
433 //基线点横坐标
434 int x=i*1.0F*width/4;
435 //基线点纵坐标
436 int y=height-5;
437 //画4个字符
438 g2.drawString(str,x,y);
439 }
440 //text的setter
441 this.text=sb.toString();
442 drawLine(image);
443
444
445 }
446
447 //供外部访问的接口，得到text
448 public String getText(){
449 return text;
450 }
451
452 //得到随机字体
453 public Font getRandomFont(){
454
455 //
456 int index=random.nextInt(fontNames.length);
457 //字体名字
458 String fontName=fontNames[index];
459 //字体样式
460 int style=random.nextInt(4);
461 //字体大小
462 int size=random.nextInt(5)+24;
463
464 return new Font(fontName,style,size);
465 }
466
467 //获得随机字符串
468 public char getRandomChar(){
469 int index=random.nextInt();
470 return codes.charat(index);
471 }
472
473 //获得随机组合色
474 public Color randomColor(){
475
476 int red=random.nextInt(150);
477 int green=random.nextInt(150);
478 int blue=random.nextInt(150);
479
480 //
481 return new Color(red,green,blue);
482 }
483 }
484 //工具类
485 >Swing:awt的升级版，用java实现，效率较awt低，但是封装之后效果更好
486
487
488
489 2015/8/22
490
491
492
493 1. request.getParameterMap()：获取表单参数
494 2. $("#").css("display",""); :显示区块
495
496 2015/8/23
497
498 1. 邮箱的用户名:
499 2. 邮箱的格式校验：if(!/^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+((\.[a-zA-Z0-9_-]{2,3}){1,2})$/.test(value)){}
500 3. 显示元素:ele.css("display", "");
501 4. js的非空校验，空串校验
502 5. web.xml配置:
503 *contextConfigLocation: 配置ContextLoaderListener的Spring配置文件
504 *encoding：请求响应编码配置参数
505 Spring配置：
506 *configLocation: SessionFactory的配置参数，一般为classpath下的hiberbate.cfg.xml文件
507
508
509
510 2015/8/25
511
512
513
514 1. 路径问题:
515 *服务端路径，推荐使用绝对路径(/控制器...，例如：/UserServlet?...。"/"服务端会解析为服务器+项目名称)
516 *客户端路径(js,css,html,jsp)，使用绝对路径，用相对路径会出现问题，例如文件出现移动之后。
517 "/"客户端只会解析为服务器名，所以项目部署到服务器的根路径下回出现问题。
518 2. 统一编码问题：
519 *开发环境编码(编译环境:utf-8) 服务器编码(iso8859-1，自己不能配置) 数据库编码（自定义为utf-8）
520 3.
521 /*
522 * 1. 得到所有的错误信息，循环遍历之。调用一个方法来确定是否显示错误信息！
523 */
524 $(".error").each(function() {
525 showError($(this));//遍历每个元素，使用每个元素来调用showError方法
526 });
527 *JQuery中用到很多的回调函数，方法中传的对象是函数指针。
528 4. 回调函数：其实就是函数指针，调用者调用回调函数之后再返回来调用调用者。
529 5. 递归函数：函数本身自己调用自己，方法体中加上处理数据的代码，一般最后调用自己，例如树状列表，可以用递归
530 实现。
531 6. 事件和委托：事件是封装多的委托的实例，委托和事件都是函数指针？？
532 7. CORBA：(Common Object Reqeust Broker Architecture)，通用对象请求代理架构，用在电信，移动，数字电视系统
533 领域
534 8. uri和url，继承关系，url是加上了服务器的请求路径，uri纯粹是工程名的请求路径
535 9. 注意拼写错误
536 10. JQuery选择器的作用：得到元素对象，让后才可以作为调用者或者是函数参数,js也是面向对象编程，没有编译器错误
537 信息提示，所以很容易出错。
538 11. 邮件发送？？
539 12. war包
540 13. ant
541 14. webLogic
542
543
544 2015/8/26
545
546
547
548 1. pom.xml文件：Project Object Model,项目对象模型
549 2. maven生命周期：清理 编译 测试 报告(文档) 打包 部署
550 3. log4j和slf4j-log4j：
551 *slf4j和commons-logging只是一个日志门面，实际还是要依赖真正的日志库log4j，虽然slf4j和commons-loggin
552 都自带了日志库，但是毕竟log4j才是最强大的。
553 *slf4j和log4j的组合方式：
554 >slf4j-api-1.5.11.jar
555 >slf4j-log4j12-1.5.11.jar
556 >log4j-1.2.15.jar
557 >log4j.properties
558 *log4j和commons-logging的组合方式
559 >commons-logging-1.1.jar
560 >log4j-1.2.15.jar
561 >log4j.properties
562
563 4. 适配器模式，目标接口 适配器 被适配者(被依赖)
564 5. null，""," ",三者区别
565 *String str=null;是指字符串变量为空引用，还没有分配地址。还没有被实例化。
566 *String str="";是指字符串变量为空串，有地址，已经被实例化。
567 *String str=" ";是指字符串为空白格，有地址，已经被实例化。
568 6. 字符串
569 6.1 处理方法：
570 *trim()：去除字符串的首尾空白格
571 *append()：StringBulider或StringBuffer的追加方法，一个线程不安全，另一个线程安全，但效率低。
572 *substring()：子串，
573 有两个重载的方法,
574 substring(beginIndex,endIndex)：返回截取并返回开始索引到结束索引减1的字符串。
575 substring(beginIndex)：返回截取开始索引到字符串的结尾的字符串。
576 *replace()：字符串的替换
577 *indexOf()：从左向右第一个出现该字符的索引位置
578 *lastIndexOf()：从右向左第一次出现该字符串的索引位置
579 6.2 比较方法：
580 *==：比较的是字符串的地址。
581 *equals():比较的是字符串的内容。
582 7. 读取外部配置的属性文件：properties
583 *代码：
584 //参数为classpath（类路径）下的资源文件的路径地址
585 InputStream input=this.getClass().getClassLoader().getResourceAsStream("");
586 //新建一个属性集合，Properties继承与HashTable,线程安全
587 Properties prop=new Properties();
588 //有关数据流的读取一般都要有处理异常
589 try{
590 //加载数据流
591 prop.load(input);
592 }catch(IOException e){
593 throw new RuntimeException();
594 }
595
596 //读取资源文件中的键相对应的对象值
597 prop.get("key");
598 8. 变量作用域：循环变量，子程序， 类变量，类私有变量，类保护变量，类公共变量，从小到大递增。
599 9. 不要基于一种语言编程，而是要深入一种语言去编程。
600 10. 在最初的编码阶段少犯错误，在调试阶段快速地找到错误。
601 11. 循环就是用来操作数组的。
602 12. 你用的语言将很大程度上影响到你的解决方案。
603 13. 堆(heap)和栈(stack)的区别
604 *1. 申请方式和回收方式：
605 >stack:申请和释放由编译器控制，由编译器自动管理，无需程序员手工操作。
606 >heap:申请和释放由程序员控制，并制定分配内存的大小。
607 *2. 申请后系统的响应上：
608 >stack: 只要栈的剩余空间大于申请空间，系统将为程序提供内存，否则提示栈溢出。
609 >heap: 动态制定分配内存的大小。首先应该知道操作系统有一个记录内存地址的链表，当系统收到程序的
610 申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆节点，然后将该节点从空闲节点链表
611 中删除，并将该节点的空间分配给程序。对于大多数系统，会在这块内存空间的首地址处记录本次
612 分配的大小。这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆节点大
613 小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。
614 *3. 申请大小的限制：
615 >stack:在WINDOWS上,栈是向低地址扩展的数据结构，栈的大小是2M。
616 >heap:堆是向高地址扩展的数据结构，是不连续的链表结构，一般在32操作系统下，堆内存可以达到
617 4G的空间。
618 *4. 分配空间的效率上：
619 >stack:效率高。
620 >heap:一般比较慢，而且还会产生内存碎片。
621 *5. 存储内容：
622 >stack: 一般是函数指针，和函数的参数列表，以及局部变量。注意：静态变量是不入栈的。
623 >heap:：一般对的头部用一个字节存放堆的大小，由程序员决定分配存储的内容。
624 *6. 效率
625 >stack:运行效率高。
626 >heap:效率比stack 低。
627
628 14. 你用递归能做的，同样也可以用栈和循环来做。
629
630
631
632 2015/8/27
633
634
635
636 1. 程序编码是为了在机器能运行的基础上，使人能够看懂，即增加可读性，可维护性，可扩展性。
637 2. 除非万不得以，否则千万不要使用goto.
638 3. 多个return可以增加子程序的可读性和可维护性，同时可以避免产生很深的嵌套逻辑，但在使用它的时候要多加小心。
639 4. 递归能够很优雅的解决一部分小问题，但在使用的时候要多加小心。简单的问题可以用递归。复杂的问题可以用循环加
640 栈(即迭代)来解决。
641 5.
642 *不常见的代码控制结构有：子程序的多处返回(return) ，递归， goto。
643 *常见的代码控制结构有：顺序结构，判断结构，循环结构。
644 6. maven clean??
645 7. hibernate 的二级缓存配置：
646 *配置文件
647 <!--开启二级缓存，缺省是真-->
648 <property name="hibernate.cache.use_second_level_cache">true</property>
649 <!--二级缓存提供商-->
650 <property name="hibernate.cache.provider_class"></property>
651
652 <!--hibernate自己管理二级缓存-->
653 <class-cache usage="" class="" />
654 8. 硬编码和软编码：是否可以自定义配置信息，是否有更好的扩展性。
655 9. 抽象类和接口的区别：
656 *是否有成员变量。
657 *接口知识方法的声明，没有实现，抽象类可以有方法的实现，也可以有供子类覆写的抽象方法。
658 *抽象类是有abstract关键字。
659 *java中接口可以有多继承。而抽象类只能是单继承。
660 *接口解耦，抽象类的耦合度更高，因为是继承。
661
662 10. java
663 目标：高内聚，低耦合。
664 口号：一处编译，到处运行。
665 11. 编程
666 目标：可扩展性，可维护性，可读性，可行性。
667 实现方式：接口和继承事项可扩展性，良好的编码习惯(变量命名，函数命名，代码结构)可增加可读性，可维护性，
668 充分的需求分析，项目设计增加项目的可行性。
669 12. 表的映射：主从表关系，一般从表里有参照主表的外键，这里有三种关系，一对多关系，多对多关系，一对一关系
670 其中一对多关系用的最多。
671 13. MVC设计模式：模型-视图-控制器
672 *模型是：DAO,Service,JavaBean,从而生成数据。
673 *视图是：Jsp，asp等显示数据的页面，数据载体显示方式一般为表格或者是列表。
674 *控制器是：Action(动作)，是控制中心，准备数据，请求响应的分发器。
675 14. Map/HashMap/HashTable List/vector/ArrayList/LinkedList Set/HashSet Stack
676 *HashMap和HashTable的区别：与vector和List的区别一样，就是线程安全问题(是否同步)，以及访问效率的问题。
677 >HashTable是线程安全的，访问效率比HashMap 低。
678 >键值对是否为null,HashMap可以为null。
679 *ArrayList和LinkedList的区别：
680 >ArrayList使用数组实现，因此访问的效率要高。
681 >双向链表使用的是用链表的数据结构，因此插入和删除的效率要高。
682 *HashSet:元素没有顺序，没有重复的元素值。但是，必要的时候特别是在XXX.hbm.xml文件中可以配置为有序的。
683 *Stack:在Java中栈是用Vector实现的，继承于Vector。
684 15. 重构的重要性：使代码结构清晰，可读性提高。
685
686
687
688 2015/8/28
689
690
691
692 1. Cookie(可以设置保存时间):用户把浏览器信息存于用户客户端。例如：用户保存用户注册信息(用户名)于客户端
693
694 2. Session:是用户会话(也可以设置Session失效时间),用于把用户信息存于服务端。
695
696 3. JQuery日历插件:datepicker ?? JQuery UI的知识，有时间要学的。
697
698 4. 功能界面的布局：使用技术是DIV+CSS，使用区块一个一个拼凑起来的，如果你标签元素里还有子元素，则用DIV，
699 否则用内嵌文本元素span.
700
701 5. HTML标签元素：
702 *常用块级元素有：DIV P H1 H2(用的比较多) ol li table
703 *常用行内元素有：
704 >能控制宽高的，就是内嵌区块元素(inline-block,不自定义长宽时有默认的长度和宽度):
705 img input textarea select
706 >不能控制宽高的(可以设置左右内边距，外边距)：a span
707
708 6. 图书商城的用户模块的用户登录功能，可以用到Cookie和Session技术，优先级为先看Sesison是否有值，否则用保存于
709 Cookie中的信息。
710
711 7. 使用框架的一般步骤：导包>配置>使用
712
713 8. 表单客户端校验：
714 *有三个事件
715 >输入框获得焦点事件：$().focus();
716 >输入框失去焦点事件：$().blur();
717 >表单提交事件：$().submit();
718 *输入框的校验有三个步骤：
719 >1.非空校验：输入值是否为空
720 >2.格式校验：如：输入值的长度限制
721 >3.异步请求校验(服务端校验，这是真正的表单数据校验)：和服务器端的数据进行对比校验
722
723 9. 可以从tomcat的server.xml配置文件中，配置服务端口号为80(和http请求服务端口号是一样的？？)，这样URL就可以省略写服务端
724 口号，直接请求协议+服务器名称就可以访问目标网站。
725
726 10. 虚拟路径：Struts2中Action配置为：namespace属性;Struts1中配置为name属性。
727
728 11. 虚拟主机：可以配置映射为localhost IP为127.0.0.1。
729
730 12. 焦点图？？
731
732 13. 选项卡的实现。
733 *实现思路：
734 是用输入框按钮和区块来实现，得到按钮元素数组，对每个按钮体检单击事件，设置所有的按钮的样式为
735 空，并隐藏区块，然后给当前按钮添加样式，显示当前索引的区块元素。
736
737 14. MVC中显示层表示数据的方式为：以表格为载体，或者是列表。
738
739 15. 编程的目标：简化，简化，再简化。=》结构清晰，增加可读性。
740
741 16. 私服？？
742
743 17. 单点登录？？
744
745 18. response:
746 response.getWriter():得到字符输出流。
747 response.getOutputStream(): 得到字节输出流。
748
749 19. 一般html元素没有子元素的时候可以不用命名，可以直接用标签元素名用于层叠样式表的渲染或者js文件加特效。
750
751 20. 不择手段，非豪杰，不改初衷，真英雄。
752
753 21. 嘴要甜，手脚要勤快，功夫还要练，遇到什么难处都不要怕。
754
755 22. js脚本编程中的事件响应对象是浏览器，就像图形界面编程中的事件响应对象是操作系统一样，web编程中get，post
756 的响应对象是服务器，js脚本编程中的常用事件为：focus(聚焦),blur(失焦)，submit(表单提交)，click(单击事件)
757 mourseout(鼠标移入事件),mourseover(鼠标移出事件)。
758
759 23. 无论遇到什么，都要坚强，朋友很重要，说白了就是好朋友很重要。
760
761 24. 学习JQurey,选择器很重要，有类别选择器，属性选择器，元素选择器 编号选择器，操作对象是对DOM元素，操作方
762 是对层叠样式表渲染页面的add和remove,以及对元素属性的设置值和移出值，从而添加对事件响应之后的特效，
763 例如：鼠标移入移出区块的背景色的调节，或者是对元素按钮背景图片的更换，输入框聚焦和失去焦点事件响应之后
764 的标签元素的显示和取消，数据校验，表单提交事件的前端校验等等。
765
766 25. 前端是面向浏览器编程，目的是如何显示数据， 服务端是面向服务器编程，目的是如何处理数据，数据库端是面向数据
767 库编程，目的是如何持久化数据。
768
769
770
771 2015/8/29
772
773
774
775 1. 单例模式
776 *懒汉式：(多线程高并发访问时要考虑同步问题)
777 >代码，以用户实体为例(User)
778 publiuc class User{
779
780 /*1. 用户实体,静态全局依赖,类加载时即初始化为空指针，没有内存地址，但还
781 *是可以引用
782 */
783 private static User instance=null;
784
785 //2. 私有的构造函数，外部不能有以new关键字在堆内存中新创建的对象
786 private User(){}
787
788 //懒汉式，懒加载实例化的对象
789 public static synchronized User getInstace(){
790
791 //如果实例化对象为空指针
792 if(instancre==null){
793 //实例化当前对象
794 instance=new User();
795 return instance;
796 }else{
797 //否则返回当前实例化的对象
798 return instance;
799 }
800 }
801 }
802 *饿汉式：
803 >代码,以用户实体为例(User)：
804 public class User{
805
806 //类加载即初始化user对象，饿汉式，饥饿加载
807 private static User instance=new User();
808
809 //供外部访问接口,得到供外部访问的实例化对象
810 public static User getInstance(){
811 return instance;
812 }
813
814 //私有构造函数，模拟数据库
815 private User(){
816 }
817 }
818 注：单例模式，只应许有一个类的实例，所以构造函数是私有的。
819 *懒汉是不是在类加载时初始化类的实例化对象，不能保证对象的唯一性，所以在多线程的情况下尽管有
820 实例对象空值的判断，也会产生线程安全的问题，因为多线程是按照时间片来运行线程的，破坏类代码
821 的垂直执行的顺序，因此加上同步关键字synchronized,是代码块同步，线程安全。
822 *饿汉式因为是在类加载的时候实例化静态类对象，因此无论何时都只有一个静态的全局依赖类对象，
823 不会有线程的安全问题。
824
825 2. java与模式：
826
827 *简单工厂模式：由工厂和产品类组成，工厂提供实例化之后的对象访问接口，即实例化对象是工厂完成的。
828 *工厂模式：由工厂和产品类组成，只是增加了抽象工厂(父类)，具体工厂(子类)以及抽象类(父类)和具体类(子类)。提高了可扩展性
829 和上面一样，对象是由具体工厂实例化之后生成的。
830 *抽象工厂模式：有工厂和产品类组成，区别是抽象工厂模式可以有多个抽象产品类，以及多个
831 抽象工厂实例化的产品对象，其他和工厂模式一样。
832 *适配器模式：
833 >目标接口:定义要适配的规范方法。
834 >适配器：实现目标接口
835 >被适配者：适配器要依赖的对象，也就是适配器要操作的对象。
836 *生产者与消费者模式：准确说应该是生产者(setter)-消费者(getter)-仓储模型，离开了仓储，生产者消费者模型就显得没有说服
837 力了。
838 >实现代码：
839
840 //1. 实体设计：同步栈仓储，共享数据域
841 class SyncStack{
842
843 //同步栈仓储中的数据产品，默认为10个大小
844 private String[] products=new String[10];
845 //数据产品数据的下标索引，初始化为0
846 private int index=0;
847
848 //setter,方法名为push，压栈
849 //同步保证了只有对象只有一个线程占用
850 public synchronized void push(String sst){
851 //如果数据数组的下标递增到10(产品数据中的默认大小)
852 if(index==procucts.length){
853 try{
854 //线程阻塞，等待唤醒，释放自己的锁，使其他线程有机会获得
855 //对象的锁
856 wait();
857 }catch(InterruptedException e){
858 //打印错误踪迹
859 e.printStackTrace();
860 }
861 }
862 //当数组还未满10个对象时，唤醒在此监视器上等待的单个线程
863 this.notify();
864 //设值
865 products[index]=sst;
866
867 index++;
868 }
869
870 //getter，方法名为getPro,获取产品数组
871 public String[] getPro(){
872 return this.products;
873 }
874
875 //delete，方法名为pop,弹栈
876 public String pop(){
877 if(index==0){
878 try{
879 wait();
880 }catch(InterruptedException e){
881 e.printStackTrace();
882 }
883
884 }
885 this.notify();
886 //获取栈顶的元素
887 String product=products[index];
888 index--;
889 return product;
890 }
891
892 }
893
894 //2. 实体设计：生产者
895 class Producer implements Runnable{
896
897 //依赖同步栈的数据域
898 private SyncStack stack;
899 //setter，用构造函数进行设置值
900 public Producer(SyncStack stack){
901 this.stack=stack;
902 }
903
904 //覆写运行的方法
905 public void run(){
906 //循环的往数据域里塞值
907 for(int i=0;i<stack.getPro().length;i++){
908 String product="产品"+i;
909 stack.push(product);
910 syso("生产了"+product);
911 }
912 try{
913 //线程睡眠1秒
914 Thread.sleep(1000);
915 }catch(InterruptedExcetion e){
916 e.printStackTrace();
917 }
918
919 }
920 }
921
922 //3. 实体设计：消费者
923 classs Consumer implements Runnable{
924
925 //依赖同步栈的数据域
926 private SyncStack stack;
927 //setter，用构造函数进行设置值
928 public Consumer(SyncStack stack){
929 this.stack=stack;
930 }
931
932 //覆写运行的方法
933 public void run(){
934 //循环的在数据域弹值
935 for(int i=0;i<stack.getPro().length;i++){
936 String product=stack.pop();
937 syso("消费了"+product);
938 }
939 try{
940 //线程睡眠1秒
941 Thread.sleep(1000);
942 }catch(InterruptedExcetion e){
943 e.printStackTrace();
944 }
945 }
946
947
948 //4. 主方法，轮片调用生产者和消费者线程
949 public class ProCon{
950
951 //创建数据共享域，即数据的仓储
952 SyncStack stack=new SynnStack();
953
954 //以同步栈即共享数据的仓储为参数创建生产者
955 Producer producer=new Producer(stack);
956 //以同步栈即共享数据的仓储为参数创建消费者
957 Consumer consuner=new Consumer(stack);
958
959 //创建生产者线程之后使线程为就绪状态
960 new Thread(producer).start();
961 //创建消费者之后使线程为就绪状态
962 new Thread(consumer).start();
963 }
964
965 3. 静态块: static，可以用于类加载时初始化数据。
966
967 4. Java关键字static:类加载时初始化变量，与类有关系。实例化的对象和类都可以调用静态的属性和方法。
968
969 5. 实例化和初始化的区别：
970 *1. 实例化是为对象在堆中新分配一个内存空间，在栈中存入新建对象在堆内存中的地址。
971 *2. 而初始化一个对象的意思就是说给新建好的对象的属性赋值，或者是给栈中的原始类型变量赋值都称之为
972 初始化。
973
974 6. 用户注销登录的两种方法：
975 *session.remove(key);//在用户会话中移除键值，即用户的注册信息。说白了就是登录用户实体。
976 *session.invalid();//是用户会话失效
977
978 7. 多线程高并发访问时的同步问题：关键字synchronized,有两种同步方式。
979 *原理：同步即是让无序的线程有序，不让cpu按时间片轮回时间地处理请求，效率低。
980 *同步方法
981 大同小异
982 在方法的前面加上关键字synchronized即可：
983 public synchronized static int getInstance(){
984 ...
985 }
986 *同步代码块
987 >synchronized(this){
988 //要同步的代码块
989 }
990
991 8. 序列化:
992 *关键字：serializable,用来序列化域实体，是否在用户会话中入库，即服务器重新启动时是否要重新登录。？？
993
994 9. 单点登录(Single sign-on in action)：？？比较重要
995
996 10. 线程的五种状态：创建 就绪 运行 阻塞 销毁
997
998 11. 画图设计工具：Rose Rational(IBM) StarUML
999 *用例图 ：给用户看的
1000 *类图 ：给程序员看的
1001 *时序图 ：项目流程分析
1002 *状态图 ：功能点的状态分析
1003
1004 12. 要手动地搞开发，不要完全依赖于工具。
1005
1006 13. 对于Java的jdk,用稳定版本就行了。编译器编译级别为jdk-1的版本。？？编译级别版本太低不支持java新特性。
1007
1008 14. MD5加密：
1009 *导包：commons-codec.jar
1010 //加密字符窜密码
1011 *String passStr=DigestUtils.md5Hex(str);
1012
1013 15. 一个方法代码最好不要超过20行，否则就应该重构。
1014
1015 16. JDBC(Java Date Base Connectivity):Java数据库连接API
1016 *伪代码：连接mysql数据库(其中有异常，需要处理)
1017 //1.注册驱动，类加载后由静态代码块自动注册驱动
1018 class.forName("com.mysql.jdbc.Driver");
1019 //2.驱动管理器,打开数据库连接
1020 Connection conn=DriverMangager.getConnection(url,username,pass);
1021 //3.得到查询会话
1022 Statement stmt=conn.getStatement();
1023 //4.获取查询结果集
1024 ResultSet rs=stmt.executeQuery(查询语句);
1025 //5.显示结果集，用循环操作集合
1026
1027 17. 怎么调用存储过程：Oracle的存储过程，了解即可，用到的地方：金融行业，安全性要求非常高的行业，不会让你轻易
1028 改动数据库表数据的行业，调用存储过程来操作表。
1029
1030 18. 处理异常的过程：可以把编译时异常转换为运行时异常，也可以自定义异常消息。异常不能随便乱抛，会弄乱代码结构
1031 破坏封装性。一般底层的代码抛出异常之后，调用方要及时处理异常，不留隐患。
1032
1033 19。Java特性
1034 封装性：信息隐藏
1035 继承：可扩展
1036 多态：可扩展
1037
1038 20. Cookie的结构也是Map，和Session差不多。只是一个存在浏览器客户端，一个存在浏览器服务端。
1039
1040 21. 什么叫面向对象设计：就是把相关性高的一堆代码放在同一个类里面。
1041
1042 22. JSP状态吗404是找不到页面错误，这个错误最好解决，看路径是否有错，状态码500页面解析错误，看错误提示调试错误。
1043
1044 23. 重定向和转发
1045 *重定向：request.getRequestDispather("路径").forward(req,res);
1046 *转发:response.sendRedirect("路径").forward(req,res);
1047 *二者之间的区别：
1048 >重定向是请求两次，会丢失第一次请求参数信息的数据和控制器中准备的数据，属于客户端转发。
1049 地址栏会改变地址。
1050 >转发是请求一次，保留请求参数信息和控制器中准备的数据，属于服务器内部转发。
1051 地址栏的地址不变。
1052
1053 24. 3中编码标准：
1054 *GBK:国标编码，表示一个汉字用2个字节。这是中文的编码标准
1055 *Unicode:宽字节编码，表示一个汉字用两个字节，这个是JVM(Java虚拟机)的编码标准
1056 *UTF-8：表示一个汉字的用3个字节，这个编码标准中文项目用的比较多。这个是中文(也可以是其他语言)文件的
1057 编码标准。
1058
1059 25. 清心寡欲才能把技术学好
1060 。
1061 26. 只要掌握原理，不要在乎版本。
1062
1063 27. CAS(Central Authentication Service):？？？
1064
1065 28. 宠辱不惊，看庭前花开花落，去留无意，望天上云卷云舒。道家思想，体现了对人生，事务，名利的态度，是一种境界。
1066
1067 29. 多表查询(SQL)：
1068 *内连接：获得连个表都有的数据，去除了重复的笛卡尔积，用的比较多。
1069 *左外连接：以主表为准，从表没有的记录设置为NULL
1070 *右外连接：已从表为准,主表没有的记录设置为NULL
1071
1072 30. 建表时，对于日期字段，可以设置为时间戳，并在映射文件中映射即可。如：
1073 建表字段类型：timestamp default CURRENT_TIMESTAMP;这样保存实体字段数据时就可以省略该字段的设置值。
1074
1075 31. Spring 的核心技术：控制反转和面向切面编程，实现配件的可插拔，其实就是个生产对象的工厂。
1076
1077 32. 一个类的字节码文件只能定义一个公共的类。
1078
1079 33. 抽象类就是用来被继承的，子类系需要实现抽象类中的抽象方法，否则也为抽象类。接口是用来被实现的，
1080 实现类必须要实现接口中定义声明的方法。接口的耦合度比抽象类低，所以项目中接口用的比较多，是轻量级的，
1081 实现可插拔式编程，自定义自己的实现，提高程序的可扩展性。
1082
1083 34. Java中的转型，有向上转型，和向下转型，向上转型是自动的，向下转型是强制类型的转换，并且要转型的父类对象是
1084 指向子类的实例。
1085
1086 35. Java新特性：反射，class.forName("").newInstance(),用反射会损失程序效率,不过框架中用到很多的反射，特别是
1087 Spring，给一个类，对象工厂就会实例化一个对象。
1088
1089 36. Hibernate中的双向关联和单向关联，是否要设置双向关联还是单向关联，还得看功能界面中的实体关联关系，
1090 是否是双向关联还是单向关联。
1091
1092 37. 依赖关系有全局依赖和局部依赖，全局依赖是对象为类的成员变量，局部依赖比如方法的参数，方法中的变量，作用域
1093 小于全局依赖的成员变量。
1094
1095 38. 项目的MVC设计模式中的模型层中的Service层生成数据，控制层准备数据，显示层显示数据，数据库即是持久化数据。
1096
1097 39. 中断循环：
1098 break :终止当前循环，也就是跳出循环
1099 continue:终止当前循环，继续下一次循环。
1100 goto：跳出循环，这个关键字Java中省去了，原因是会增加代码复杂度。
1101
1102
1103
1104 2015/8/31
1105
1106
1107
1108 1. 记得保存文档，否则千万后悔。
1109
1110 2. 子程序要操作数据必定会用到依赖，依赖分局部依赖和全局依赖。局部依赖是指方法中的参数，或者方法中的变量。
1111 全局依赖用的很多，比如控制器依赖服务类生成的数据从而准备数据分发到各个页面。
1112
1113 3. 使用接口和抽象类就是为了程序的可扩展性，但是接口更解耦。
1114
1115 4. 抽象就是为了扩展。
1116
1117 5. 编程时刻谨记：可读性 可维护性 可扩展性， 可行性。
1118
1119 6. 请求服务器就是一个设值(setter)并且取值(getter)的过程。
1120
1121 7. 用Map结构可以模拟数据库，一般测试时用得比较多。
1122
1123 8. 对于框架的使用和配置，用注解要比配置文件方便和简洁，但有时还是得用xml配置文件，为了可读性？？看个人
1124 的编程习惯。
1125
1126 9. strut1保存提交表单数据的方式ActionForm,要配置formBean，struts2的方式是模型驱动，用值栈保存，方便好用，
1127 对于有些无法用模型驱动封装的数据可以在动作(Action)中用数据的全局依赖，并提供数据的getter(取值)和setter(设值)
1128 方法。
1129
1130 10. 对于JavaBean这种编程操作数据通过子程序getter和setter方法的模式，在很多地方都有用到，其实setter方法就是初始化
1131 数据对象，而getter就是提供一个供外部访问数据的接口。
1132
1133 11. 初始化和实例化的区别：
1134 *初始化：类加载时设置值或者其他方式的设值setter。
1135 *实例化：在堆内存中开辟一个内存空间，用于存放数据，在java中就是new(新建)关键字。
1136
1137 12. 编程是最好让变量定义即初始化，可以避免不必要的麻烦，特别是C++中的指针，很危险。
1138
1139 13. 项目的编码要统一，必须要从持久化环境中配置数据库编码为utf-8，对于服务器环境不可配置，默认为iso8859-1,
1140 开发环境(编译环境)可配置为utf-8，因为服务器环境你无法左右，所以对于中文参数的get请求，必须要处理编码
1141 问题。对已一般的get请求，参数为中文时，会自动编码后解码，所以你不用utf-8编码后传参数，就会出现乱码问题。
1142 解决方法有，用utf-8编码两次后传参数，在服务端服务器会帮你解一次，你自己必须要解码一次才能真正得到中文的
1143 参数。
1144 对于为什么要用utf-8编码两次，是因为第一次utf-8编码之后的第二次再用utf-8编码，实质上是按照iso8859-1编码，
1145 所以服务器帮你解码时也是按照iso8859-1解码，得到utf-8编码，你自已再用utf-8解码就会得到中文参数。
1146
1147 14. 对于表单POST请求，因为传的参数实在请求体中，服务器不会为你的中文参数iso8859-1编码，所以不会出现中文乱码
1148 问题。？？我就没有遇到中文乱码问题。
1149
1150 15. Hibernate中的Session和服务器中的Session是不一样的，最好的理解就是前者为会话，后者用户会话，和浏览器有
1151 关，开一个浏览器即开一个用户会话，关闭则销毁。
1152
1153 16. 对于上传文件，因为要传的是大数据类型，所以表单要设置上传文件类型为MIME(Multiple Internate Mail Extensions)
1154 类型：enctype="multipart/form-data".
1155 用来接收文件数据的字段为文件字段：File file，要得到文件名或者是文件类型，命名有规定必须是文件字段名+
1156 FileName得到文件名，文件字段名+ContentType,得到内容类型。
1157
1158 17. 即使是死学也要活用。
1159
1160 18. JDBC操作数据库：
1161
1162 *伪代码：conn,stmt,rs 都是资源，用了都需要关闭释放资源，并且这里需要有处理异常。
1163
1164 //1.注册驱动,类加载时注册驱动，这里用到了静态块的代码
1165 Class.forName("com.mysql.jdbc.Driver");
1166 //2.获取连接
1167 Connection conn=DriverManager.getConnection(url,username,pass):
1168 //3.获取子句
1169 Statement stmt=conn.createStatement();
1170 //4.子句执行查询
1171 ResultSet rs=stmt.executeQuery(sql);
1172
1173 19. Hibernate中也用了大量的反射，效率略低于MyBatis，但Hibernate是全自动化的，MyBatis是半自动化的。
1174
1175 20. 架构师的目标：资源，速度。
1176
1177 21. 反射就是从单纯的类到对象的过程，不依赖new关键字。而是用newInstance(),效率低。
1178
1179 22. 面向对象和面向过程(函数，像C，PASCAL)的最大区别及时到底是以数据为中心，还是以代码为中心，是代码为数据服务，
1180 还是数据去匹配代码。
1181
1182 23. 面向切面编程：切面是由切点和通知组成，切点是由连接点组成，通知及时要在连接点织入的方法。通过在特定的代码中
1183 横切入通知(事务，日志等)，达到横向编程的目的，改变类以前的垂直编程的思维方式。
1184
1185 24. 面向接口编程：定义接口即定义一组方法的声明，规范，用户可以自定义自己的实现，提高程序的可扩展性，而且
1186 解耦。
1187
1188 25. JavaBean的特点，及时定义一个实体，并提供对数据的getter和setter操作方法，setter是设置值，getter是提供
1189 供外部访问的接口，目的就是提高对象的原子性，高度封装。
1190
1191 25. 为了区分HQL语句和SQL语句，推荐写HQL语句时关键字都用大写。hql语句是面向对象的查询语句，表即是对象，
1192 首字母要大写，其他的过滤条件和sql差不多，最大的不同就是如何传参数。
1193
1194 26. 坏人偿命，好人反而不偿命。
1195
1196 27. sql语句其实也可以理解为请求语句，请求对象为数据库，相比于请求服务器，查询语句用的最多，有多表查询，
1197 子查询，连接查询。
1198
1199 28. 静态包含和动态包含：
1200
1201 *静态包含：<%@ include file="" /> ,只是把代码片段包含进来，组成jsp页面。
1202 *动态包含：<jsp: include file="" /> ,是把要包含的代码解析之后再包含进来，组成jsp页面。
1203
1204 29. 表，字段和对象，属性是一一对应的，这样理解更好。
1205
1206 30. 写判断语句的比较条件时，推荐写小于等于或大于等于而不要写大于或小于，这样可以更好的避免越界错误。
1207
1208 31. 最好去找一种好的方案而同时避免引发灾难，而不要试图去找最佳的解决方案。(Lampson 1984)
1209
1210 32. 键值对这样的数据结构模型很多，比如前端的json(java脚本对象表示符号)，服务端的属性表文件，Map(映射结构)
1211 其实数据库端的表结构也可以理解为键值对结构，键为列名，值为当前列对应的值。这是一种表示数据对象最轻量级
1212 的方式。
1213
1214 33. 要对如何处理数据充满满满的爱意。
1215
1216 34. 要对编程有感情，把它当做一门艺术来对待。
1217
1218 35. 没学过编程，你就不知道注重细节有多重要。
1219
1220 36. 普通的软件工程实践与最优秀的软件实践差距巨大--多半比其他的工程学科中的这种差距都要大。因此，传播优秀
1221 实践经验的工具是十分重要的。--Fred Brooks
1222
1223 37. 在编程实践中，可读性真个很重要，可以使代码结构清晰，可以避免少出错。
1224
1225 38. 通过隐式的比较，可以减少让阅读你代码的人要阅读的项数，可以增强可读性。
1226
1227 39. 代码结构复杂了之后就要记得重构。
1228
1229 40. if子句最好要加上else子句，增强代码的逻辑性，如果否则部分的确没有内容可以写个空语句。？？这样真的好吗？
1230
1231 41. 把否定形式的判断语句改为肯定形式的判断语句，可以增强可读性，又是可读性。
1232
1233 42. 括号很方便，并且能够改善可读性。
1234
1235 43. sql语句的过滤子句的where 1=1 的作用就是为了拼接语句的方便。
1236
1237
1238
1239 2015/9/1
1240
1241
1242
1243 1. 编程中描述数据对象的方式，类型+数据命名字段：
1244 * 前端编程：即HTML的标签即是类型，编号是名字，类字段也是名字，外加属性需要自己set其值。
1245 * 服务端的编程，即java描述方式为：数据类型+体现功能需求的数据命名字段，
1246 * 数据库端的编程：配置文件(例如：Hibernte的对象和表的映射文件)的数据对象描述方式和HTML的描述方式大
1247 同小异，数据库表中的列字段推荐和实体对象中的属性相对应，最好不要改什么，因为方便。
1248 sql(create语句)语句中描述数据字段的方式为：数据命名字段+数据字段的类型。
1249
1250 2. 对于判断语句，基本上都是获取(getter)数据之后再做条件的判断。
1251
1252 3. 编程的过程就是对数据操作过程，操作过程分为setter(设值)和getter(取值)，遇到需要判断的数据就用条件判断语句
1253 遇到大量的数据用集合或者是数组(内置数据类型,java中不是，也要在堆内存中动态的分配一定的内存空间给用户存储数据)。
1254 再用循环操作数据集合，遍历即是getter(获取数据的过程)，存值及时一个setter的过程。
1255
1256 4. sql语句也是一个请求语句，说白了就是和服务器中的Get语句一样是一个setter和getter的过程，就是请求的对象不一样，
1257 一个是数据库，一个是服务器。
1258
1259 5. 一般的项目都会有主从表的表关联，一对多的关系最多，这里之后就会遇到懒加载的问题，XXX.hbm.xml的配置文件中
1260 对于关联关系属性默认就是懒加载(到用到的时候再来加载数据)，而加载数据就会用到session,它的生命周期在服务
1261 端(Service,服务层)用完就会销毁，因此在页面再用session加载数据就会楚翔懒加载的异常。
1262 解决的方式就是：有两种方法
1263 * 1. Spring框架有一个在视图中打开会话的过滤器，可以延长会话的声明周期到视图的客户端，OpenSessionInViewFilter,
1264 在web.xml中配置即可，至于怎么配置，和其他的过滤器配置方式是一样的。
1265 配置文件代码：
1266 <filter>
1267 <filter-name>过滤器的名字：openSessionInViewFilter</filter-name>
1268 <filter-class>Spring中的过滤器全限定名</filter-class>
1269 </filter>
1270 <filter-mapping>
1271 <filter-name>过滤器的名字</filter-name>
1272 <url-pattern>要过滤的资源</url-pattern>
1273 </filter-mapping>
1274 * 2. 直接在Hibernate的映射文件中的配置关联关系属性的懒加载的值为:假，如：lazy="false"
1275
1276 6. Hibernatge会话工厂的实现类为：org.springframework.orm.hibernate3.LocalSessionFactoryBean
1277
1278 7. 学习框架的一般步骤就是：导包->配置->使用
1279
1280 8. 对于导包，要对每个包的作用相当清楚，不能随便的导包，浪费项目的空间。
1281
1282 9，表的更新和插入最大的区别就是，更新就是往数据库表中已存在的数据项重新设置新值，数据项对应的编号已经存在
1283 插入的数据库没有对应的列的编号，如果设置的主键的自动增长，数据库系统就会为插入新数据新分配一个对应的编号
1284 相同的点就是：都是往数据库中塞值的一个过程。
1285
1286 10. web工程中的每一层多有相对的环境显示层是pageContext,控制器层就是动作环境(ActionContext,解耦的；不解耦
1287 的是ServletActionContext),服务器层的是应用程序环境(ServletContext);
1288
1289 11. 由于你的代码不会像你那么敏锐，因此更好的做法就是用嵌套的判断语句来明确你的用意，而不是要依赖于求值顺序
1290 和短路求职，意思就是说你因该用嵌套的判断代替短路求职或者求值的顺序。
1291
1292 12. 获取ApplicationContext的两种方式
1293 * 1. 独立测试时，直接new(新建)，资源配置文件为类路径下的配置文件。
1294 * 2. 也可以用WebApplicationContextUtils工具类来获取ApplicationContext,例如：
1295 ApplicationContext ac=WebApplicationContextUtils.getWebApplicaitonContext(application);
1296 *注：一般项目会有一个ContextLoaderListener监听器，初始化ApplicationContext，并实例化各种Bean对象。
1297 所以对已你配置好的bean对象，Spring工厂会为你反射造好，到时你直接用既可以了。
1298
1299 13. Struts1和Struts2的区别：
1300 * 1. 是否有容器依赖性
1301 * 2. Action(动作)是否是单例的还是多例的(多例的好处就是不同享同一个数据，每一个行为都有自己的数据域
1302 高并发的时候也不会出现问题，实现方式是每一个行为用线程变量LocalThread存储每一个行为的数据，
1303 用空间换取时间，增加了内存开销)。
1304 * 3. 配置文件不一样
1305 * 4. 是否要在web.xml配置文件中配置Action
1306
1307 14. 关于注解和配置文件
1308 * 1. 怎么用注解：以Spring中的配置文件来说
1309 >需要配置<context:scan-component base-package="要扫描的包及子包"/>
1310 >几个注解关键字：Controller(控制器) scope(作用域) Service(服务) Transactional(事务) Depository(仓库)
1311 > 1. 会话工厂配置sessionFactory 实现类为org.springframework.orm.hibernte3.LocationSessionFactoryBean
1312 依赖的数据为Hibernate.cfg.xml配置文件configLoacation属性
1313 和数据源：dataSource 实现类(用的是c3p0连接池，这个歌连接池较稳定，也可以用其他的连接池)
1314 为com.mchange.v2.c3p0.ComboPooledDataSource
1315 > 2. 事务管理器配置：
1316 TransactionManager配置，实现类为org.springframework.orm.hibernate3.HibernateTransactionManager
1317 依赖属性为：会话工厂SessionFactory
1318 > 3. 事务注解驱动配置：<tx:annotation-driven transaction-manager=""/>
1319 * 2. 配置文件: 同上，只是控制器(Action)，服务(Service)，Transaction要自己配置，不用注解。
1320 > 1. 配置事务管理器：同上
1321 > 2. 配置切面通知：
1322 配置文件的写法为：
1323 //配置事务通知
1324 <tx:advice id="advice" transaction-manager="">
1325 //所依赖的属性
1326 <tx:attributes>
1327 //配置切入事务通知的方法
1328 <tx:method name="" propagation="REQUIRED"/>
1329 ...
1330 <tx:method />
1331
1332 </tx:attributes>
1333
1334 </advice>
1335
1336 // 1. 配置切面
1337 <aop:config>
1338 //配置切点
1339 <aop:point-cut id="pointcut" expression="execution(* *.*(...))"/>
1340 //配置通知,切点
1341 <aop:advisor advice-ref="advice" pointcut-ref=""/>
1342 </aop:config>
1343
1344 // 2. 另一种配置切面的方式
1345 <aop:config>
1346 //配置切面
1347 <aop:aspect ref="">
1348 //配置后置通知,切点
1349 <aop:after-returning method="" pointcut=""/>
1350 ...
1351 <aop:aspect>
1352 </aop:config>
1353
1354 15. 刷新就是根据URL(地址)重新向服务器发出请求。
1355
1356 16. 项目开发中的Struts.xml 配置文件的一般常量配置：
1357 <!--设置用户界面层的主题模式为简单模式，就是不会自动为你的界面添加特殊的格式-->
1358 <constant name="sturts.ui.theme" value="simple"/>
1359
1360 <!--在项目开发中，设置常量值为开发模式，修改局部方法之后，就可以不用重新启动服务器调试代码了。-->
1361 <constant name="struts.devMode" value="true" />
1362
1363 17. MVC:模型-视图-控制器模式
1364 *模型：domain(实体域模型) DAO(数据访问对象) Service(服务)，数据模型层.
1365 *视图：显示层，jsp,asp等页面，数据的显示层.
1366 *控制器：Controller(控制器)，数据的分发中心层.
1367
1368 18. Java程序和数据库之间是通过TCP/IP协议交互的。
1369
1370 19. 数据库也是一种服务。
1371
1372 20. 协议即是一种规定，规定用户该做什么。
1373
1374 21. 模块包含层，项目要分层。
1375
1376 22. SOA(Service Oriented Achitechture): 面向服务的架构
1377
1378 23. 多用对象的方法，少用运算符，因为很容易出错，例如：一般来说，Java程序里因该使用像a.equals(b)(比较的是字符串的内容)
1379 这样的表达式，而不要用a==b(比较的是对象的内存地址).
1380
1381 24. 尽量减少深层嵌套，要么你应该重新设计一个子程序，要么重新设计那部分复杂代码。
1382
1383 25. 实际很少有必要使用case语句。(Meyer 1997)
1384
1385 26. 使用规则性不强的方法所生成的源代码，很难有意义且形象的反应出程序是如何在机器上执行的，就是可读性不强。
1386
1387 27. 可读性差意味着不被理解，最终导致程序的低质量。
1388
1389 28. 结构化编程的中心论点是：任何一种控制流都可以用顺序，选择和迭代三种控制结构生成。(Bohm Jacopini 1944)
1390
1391 29. 编程需要比其他任何活动都要专心。
1392
1393 30. 让事情尽量简单，但不能过于简单。--Albert Eubstein
1394
1395 31. 前端：文档流 服务端：控制流 资源流 文件流
1396
1397 32. 编程的首要任务：降低复杂度，增加可读性。
1398
1399 33. 软件的首要技术任务：管理复杂度。
1400
1401 34. 把代码的复杂度降低到最低水平是编写高质量代码的关键。
1402
1403 35. 软件开发到软件工程的形成需要一个过程。
1404
1405 36. 阅读代码可以找出较多的接口缺陷，功能测试可以可以检测出更多的控制缺陷。
1406
1407 37. 提高代码的可读性，可以减少代码的出错率。
1408
1409 39. 缺陷在代码中存在的时间越长，修正缺陷代码的代价就越高。
1410
1411 40. 尽早的捕捉错误才能有效的节省成本。
1412
1413 41. 编程的数据模型：键值对，数据描述方式:类型名， 数据的操作方式：getter setter delete，
1414 面向对象编程其实就是对一个个javabean对象，增删改查。
1415
1416 42. md5是应用层的加密算法。
1417
1418 43. 世界上没有免费的午餐，就是有，味道也不会好到哪里去。
1419
1420 44. 绝大多数项目的最大规模的一项活动就是调试以及修正那些无法正确工作的代码。
1421
1422 45. 编程的调试和找错是最耗费时间的一个阶段。
1423
1424 46. 把时间投入到前期工作中，能让程序员在后期工作中节省更多的时间。
1425
1426 47. 及时测试工作完成的很有效率，作为完整的质量计划的一部分，复查或者其他类型的协同同样很重要。
1427
1428 48. RMI(Remote Method Inteface):远程方法接口。
1429
1430
1431
1432 2015/9/2
1433
1434
1435 1. 时间戳，日期，和日历的区别：
1436 *TimeStamp时间戳：包名为->java.sql...,精确到时分秒，日期可以转换为时间戳类型，方式为：
1437 TimeStamp date=new TimeStamp(new Date().getTime());
1438 *Date日期：包名为->java.util....,精确到日期
1439 *Calendar日历：包名-> java.util....,包装类，有更丰富的方法
1440
1441 2. 1970年1月1日00:00:00 ：算是Unix 和C语言的生日。主流计算机和操作系统都用它，其他的手机，仪器的时间初始化
1442 也是这个时间，包括Java等高级语言也是这个时间作为Date的初始化时间。
1443
1444 3. Integer.valueOf(str)和Integer.ParseInt(str)的区别：
1445 *返回值不一样，valueOf(str)返回值为Integer的实例对象,而parseInt(str)，是把字符串的解析整型。
1446 *注：Integer.valueOf(str)中，如果str的整形值不在区间[-127,128]之中，就会新建一个Integer对象并
1447 初始化值。
1448
1449 4. 每过一段时间在再想想自己的过去，你就会觉得自己当初是多么的笨，所以学习，总结就是你不断前进的动力。
1450
1451 5. 内置类型：
1452 *整型：byte(1个字节)， shot(两个字节) ，int(4个字节)，long(8个字节)
1453 *小数型：float(4个字节)，double(8个字节)
1454 *字符型：char(java中是两个字节)
1455 *布尔型：bool(一个字节)
1456 *数组：在Java中数据不是基本的内置数据类型，构建时要指定数组的大小，在C中是内置数据类型。
1457 *具名常量：在Java中具名常量是用大写的字符串表示的常量整型，
1458 注：在Java中只有前面的8种是内置的基本数据类型。
1459
1460 6. 不常见的数据类型(时代在前进，这些不常见的数据会逐渐地被淘汰，或者是封装成其他的数据类型)：
1461 *指针：在java中封装为引用，安全好用。
1462 *结构体：其实就是具有关联关系的公有的数据的集合，没有操作数据的子程序，是组合的关系，后面面向对象
1463 编程思维出现之后，演变为类。
1464 *全局数据：全局数据其实就是类中公有的数据对象，和类变量(静态变量)的最大区别就是是否是静态的，是否
1465 是类所有。全局数据因为有风险，破坏了数据的封装性，所以最好用访问器子程序来代替对全局变
1466 量的访问。
1467 方法就是：把全局变量改成私有的或者是受保护的数据变量，再增加一个getter和setter的数据的
1468 访问器子程序。
1469
1470 7. 使用全局数据要比使用局部数据的的风险要大。
1471
1472 8. 模块化和信息隐藏结合使用设计良好的类可能算不上是绝对真理，但他们能极大程度地提升程序的可理解性和可读性。
1473
1474 9. Java中的传值和传引用:
1475 *"Java中参数传递都是按值传递"，这句话的意思就是说，按值传递是传递值的拷贝，按引用传递传递的是引用的
1476 地址值，所以统称按值传递。
1477 *在Java里面只有基本类型和下面这种定义方式是按值传递，其他的是按引用传递。就是直接用双引号的字符串
1478 定义方式。
1479
1480 10. 要操作数据，必须要有依赖。
1481
1482 11. Java中栈是存放基本数据类型值的，比如对象的地址，整型，堆是存放大对象的，比如字符串String等。在栈中
1483 读取数据比堆中读取数的效率要高。
1484
1485 12. 形参和实参的区别就是是否有给参数赋值。
1486
1487 13. http post 请求的内容类型为：application/x-www-form-urlencoded
1488 分析：内容类型一般分为主流数据格式，资源格式？ 例如：text/javascript(java脚本) image/gif(动态图的MIME类型)
1489 imge/jpeg(jpeg图片的MIME格式) application/msword(doc文档的MIME类型)
1490
1491 14. SOAP(Simple Object Access Protocol):简单对象访问协议。
1492
1493 15. Java与模式：
1494 *代理模式：由目标接口，目标对象，代理对象组成，目标对象和代理对象都实现目标接口，自定义实现
1495 接口中的方法，代理对象依赖目标对象，并调用目标对象实现的目标接口的方法，完成代理
1496 功能。
1497 *装饰者模式：由抽象类(或者接口)，具体类(被装饰类，继承抽象类或者实现接口)，装饰者类(继承抽象
1498 类或者实现接口)组成。装饰者类依赖抽象类或者接口，从而动态扩展对象的功能，很抽象。
1499 *二者不同：代理类控制被代理类的对象，对其具有控制权，决定其执行或者不 执行。而装饰者模式中，
1500 装饰者类没有对被装饰对象有控制权，只能是增加一层装饰，以增加被装饰对象的功能。
1501
1502 16. WSDL(Web Service Description Language):网络服务描述语言
1503
1504 17. Java对象的引用:
1505 * 强引用：对象不释放内存，jvm内存满了之后就会报异常。
1506 * 软引用：如果Java虚拟机的内存不够用了，就会释放对象内存。
1507 * 弱引用：检测到对象存在，即释放内存。
1508 * 虚引用：随时会释放掉对象的内存。
1509 注：Java虚拟机是根据对象是否存在引用来回收对象的。
1510
1511 18. J2SE的基础是非常重要的。
1512
1513 19，对于要不要写注释的问题，为了代码的可读性，注释还是写的好，类前面的必须要写，方法必须要写，方法里的每个
1514 语句有时间的画还是写写，可增强可读性，但没有强制的要求。
1515
1516 20. 套接字(socket):有三部分组成，目标IP地址，协议，端口号。
1517 注：地址一般就指的是服务器名，端口号指的就是服务名，协议就指的是文件传输协议。
1518
1519 30. 通过访问器子程序访问类的私有数据，类的实例化对象不能随便地访问类的私有数据，从而提高了数据的封装性，
1520 安全性。
1521
1522 31. 概念模型(实体设计)，数据模型(数据库)，对象模型(JavaBean)，这三个是数据从需求分析到成为对象模型的一个
1523 过程。
1524
1525 32. TCP(Transmission Control Protocol):传输控制协议
1526
1527 33. 分层就是为了解耦，每一层完成自己的一项任务，提高项目的可维护性，和可扩展性。
1528
1529 34. Web开发中严格的MVC设计模式：一张表对应一个Action(动作)，分发数据到不同的页面。
1530
1531 35. 分层隔离，就是为了实现自动化，层与层之间只提供接口进行通信，目的就是为了解耦。
1532
1533 36. Web开发中的请求过程其实就是提交数据给服务器，然后服务器响应处理数据(setter ,getter,delete),最后分发
1534 准备好的数据到各自的页面中显示。
1535
1536
1537
1538
1539 2015/9/3
1540
1541
1542
1543 1. Java Web 开发中如何进行分页
1544
1545 *分页:
1546 >思路：JavaBean(PageBean)->Action(UserAction)->Service(HqlHelper)->Jsp
1547
1548 1. 设计实体PageBean(分页之后显示的页面实体类)，具体的属性有：当前页(currentPage)，总记录
1549 数(recordCount)，每页显示记录数(pageSize)，总页数(pageCount)，其中总页数(pageCount)=
1550 (recourdCount+pageSize-1)/pageSize;这个公式需要自己理解，还有当前页的记录列表集合
1551 (recordList),开始页面的索引号(beginPageIndex)，结束页面的索引号(endPageIndex);
1552
1553 2. 操作用户的动作(UserAction),依赖用户的数据访问对象(UserDao),获取当前页的数据列表集合
1554 之后放到Action的值栈中，分发到分页的当前页显示该数据集合。
1555
1556 3.
1557 3.1 在服务类中实现方法：protected PageBean getPageBean(int pageNum,HqlHelper hql);
1558 3.2 这里涉及到一个业务逻辑工具类即HqlHelper(查询语句助手)
1559
1560 4. Jsp页面，见下文
1561
1562 摘要：所用框架为：Hibernate+Spring+Struts2,以分页显示后台用户列表为例
1563 1.设计实体:页面类PageBean
1564 1.1 分析：
1565 当前页：currentPage(请求数据)
1566 总记录数：recordCount（查数据库:count(*)）
1567 页面大小：pageSize(配置文件设置值)
1568 本页的数据列表：recordList(查询数据库：select *)
1569
1570 总页数：pageCount（计算）=(recordCount+pageSize-1)/pageSize;
1571 开始索引：beginPageIndex（计算）
1572 结束索引：endPageIndex（计算）
1573 1.2 代码，这里以显示10个页码索引为例：
1574 public class PageBean{
1575
1576 private int currentPage;
1577 private int recordCount;
1578 private int pageSize;
1579 private List recordList;
1580
1581 private int pageCount;
1582 private int beginPageIndex;
1583 private int endPageIndex;
1584
1585 public PageBean(int currentPage,int recordCount,int pageSize,int recordList){
1586 //当前页
1587 this.currentPage=currentPage;
1588 //总记录数
1589 this.recordCount=recordCount;
1590 //页面大小
1591 this.pageSize=pageSize;
1592 //当前页的总记录列表
1593 this.recordList=recordList;
1594
1595 //计算pageCount：总记录数
1596 //这里可以用逻辑判断，如：
1597 /*
1598 *if(recordCount%pageSize==0){
1599 * pageCount=recordCount/pageSize;
1600 *}else{
1601 * pageCount=recordCount/pageSize+1;
1602 *}
1603 */
1604 //或则用算法，自己琢磨
1605 pageCount=(recordCount+pageSize-1)/pageSize;
1606
1607 //这里以显示十个页码索引为例，设置开始页码索引和结束页码索引
1608 //当页面总数小于10个时
1609 if(pageCount<=10){
1610 beginPageIndex=1;
1611 endPageIndex=pageCount;
1612 }else{
1613 //当页面总素大于10个时
1614 beginPageIndex=currentPage-4;
1615 endPageIndex=currentPage+5;
1616
1617 if(beginPageIndex<1){
1618 beginPageIndex=1;
1619 endPageIndex=10;
1620 }
1621 else if(endPageIndex>pageCount){
1622 beginPageIndex=pageCount-9;
1623 endPageIndex=pageCount;
1624 }
1625 }
1626 }
1627
1628 //Setter和Getter
1629 set...
1630 get...
1631 }
1632 2.设置实体工具类：HqlHelper
1633 2.1 分析
1634 2.2 代码
1635 public class HqlHelper{
1636 //from子句
1637 private String fromClause;
1638 //where子句
1639 private String whereClause;
1640 //排序子句
1641 private String orderClause;
1642
1643 //参数集合，Hql语句中where子句中用到的参数对象
1644 private List<Object> parameters=new ArrayList<Object>();
1645
1646 //构造函数设置fromClause,默认别名为”o“
1647 public HqlHelper(Class clazz){
1648 this.fromClause="FROM "+clazz.getSimpleName+" o";
1649 }
1650 //自定义别名
1651 public HqlHelper(Class clazz,String alias){
1652 this.fromClause="FROM "+clazz.getSimpleName+alias;
1653 }
1654
1655 //设置where子句的，以及用到的参数对象，这就是查询条件
1656 public HqlHelper addCondition(String condition,Object... params){
1657 if(whereClause.length()==0){
1658 whereClause=" WHERE "+condition;
1659 }else{
1660 where+=" AND "+condition;
1661 }
1662
1663 if(params!=null && params.length>0){
1664 for(Object o:params){
1665 parameters.add(0);
1666 }
1667 }
1668 return this;
1669 }
1670 //设置是否追加，这个接口留给用户，到时方便用户开发
1671 public HqlHelper addCondition(boolean append,String condition,Object... params){
1672 if(append){
1673 addCondition(condition,params);
1674 }
1675 return this;
1676
1677 }
1678
1679 //设置排序条件子句
1680 public HqlHelper addOrder(String propertityName,boolean isAsc){
1681 if(orderClause!=null && orderClause.length()>0){
1682 orderClause=" ORDER BY "+propertityName+(isAsc?" ASC":" DESC");
1683 }else{
1684 orderClause+=", "+popertityName+(isAsc?" ASC":" DESC");
1685 }
1686
1687 return this;
1688 }
1689 //这个增加了是否追加排序条件子句
1690 public HqlHelper addOrder(boolean append ,String propertityName,boolean isAsc){
1691 if(append){
1692 addOrder(propertityName,isAsc);
1693 }
1694 return this;
1695 }
1696
1697 //得到查询子句hql
1698 public String getQueryListHql(){
1699 return fromClause+whereClause+orderClause;
1700 }
1701
1702 //计数hql
1703 public String getCountHql(){
1704 return "SELECT COUNT(*) "+fromClause+whereClause;
1705 }
1706
1707 //参数集合get接口，供外部访问
1708 public List<Object> getParameters(){
1709 return parameters;
1710 }
1711
1712 //这里只要两个参数，跳转的页面，和继承了BaseDao(自己抽取的接口，很有用的)的service
1713 public HqlHelper buildPageBeanForStruts2(int pageNum,BaseDao<?> service){
1714
1715 PageBean pageBean=service.getBean(pageNum,this);
1716 ActionContext.getContext.getValueStack.push(pageBean);
1717 return this;
1718 }
1719 }
1720 3.设计service,这里把方法放到BaseDao中，service继承即可：
1721 3.1 代码
1722 //事物注解（许在Spring中配置,TransactionManager）
1723 @Transactional
1724 public class BaseDaoImpl<T> implements BaseDao<T>{
1725 //这里需要配置SessionFactory在Spring容器中，自己配不难
1726 //这个是注解，相当于Setter
1727 @Resource
1728 private SessionFactory sessionFactory;
1729 //实体类型
1730 protected Class<T> clazz;
1731
1732 //在构造函数中进行初始化clazz
1733 public BaseDaoImpl(){
1734 ParameterirzedType pt=(ParameterizedType)this.getClass().getGenericSuperclass();
1735 this.clazz=(Class)pt.getActualTypeArguments()[0];
1736 }
1737
1738 //获取Session,方便操作数据库
1739 protected Session getSession(){
1740 return sessionFactory.getCurrentSession();
1741 }
1742
1743 public PageBean getBean(int pageNum,HqlHelper hqlHelper){
1744
1745 //参数集合
1746 private List<Object> parameters=hqlHelper.getParameters();
1747 //配置的页面大小
1748 private int pageSize=Configuration.getPageSize();
1749
1750 //recordCount,总记录数
1751 Query countQuery=getSession().createQuery(HqlHelper.getCountHql());
1752 if(parameters!=null && parameters.size()>0){
1753 for(int i=0;i<parameters.size();i++){
1754 countQuery.setParameter(i,parameters.get(i));
1755 }
1756 }
1757 Long recordCount=(Long)countQuery.uniqueResult();
1758
1759 //recordList,当前页的记录列表
1760 Query listQuery=getSession().createQuery(HqlHelper.getQueryListHql());
1761 //设置查询参数
1762 if(parameters!=null && parameters.size()>0){
1763 for(int i=0;i<parameters.size;i++){
1764 listQuery.setParameter(i,parameters.get(i));
1765 }
1766 }
1767 //获取当前页的记录
1768 listQuery.setFirstResutl(pageSize*(pageNum-1));
1769 listQuery.setMaxResults(pageSize);
1770 List recordList=listQuery.list();
1771
1772 return new PageBean(pageNum,recordCount.intValue(),pageSize,recordList);
1773 }
1774 }
1775
1776 4.设计Action：以UserAction为例
1777 4.1 代码：
1778 //顺带把配置加上，交给Spring容器管理
1779 @Controller
1780 @Scope("prototype")
1781 public class UserAction extends ActionSupport{
1782
1783 private int pageNum;
1784 get... set...;
1785
1786 @Resource
1787 private UserService userService;
1788
1789 //用户数据列表，分页显示
1790 public String list(){
1791 new HqlHelper(User.class,"u")//
1792 .buildPageBeanForStruts2(pageNum,userService);
1793 }
1794 }
1795
1796 5.页面：设计一个公共页面 pageView.jspf，通用的
1797 代码：
1798 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
1799 <%@ taglib prefix="s" uri="/struts-tags"%>
1800
1801 <div id=PageSelectorBar>
1802 <div id=PageSelectorMemo>
1803 页次：${currentPage}/${pageCount}页 每页显示：${pageSize}条 总记录数：${recordCount}条
1804 </div>
1805 <div id=PageSelectorSelectorArea>
1806
1807 <a href="javascript:gotoPage(1)" title="首页" style="cursor: hand;">
1808 <img src="${pageContext.request.contextPath}/style/blue/images/pageSelector/firstPage.png" />
1809 </a>
1810
1811 <s:iterator begin="%{beginPageIndex}" end="%{endPageIndex}" var="num">
1812 <s:if test="currentPage==#num">
1813 <%--当前页 --%>
1814 <span class="PageSelectorNum PageSelectorSelected">${num}</span>
1815 </s:if>
1816 <s:else>
1817 <%--非当前页 --%>
1818 <span class="PageSelectorNum" style="cursor: hand;" onClick="gotoPage(${num});">${num}</span>
1819 </s:else>
1820 </s:iterator>
1821 <a href="javascript:gotoPage(${pageCount})" title="尾页" style="cursor: hand;"> <img
1822 src="${pageContext.request.contextPath}/style/blue/images/pageSelector/lastPage.png" /> </a> 转到：
1823 <select id="pn" onchange="gotoPage(this.value)">
1824 <s:iterator begin="1" end="%{pageCount}" var="num">
1825 <option value="${num}">
1826 ${num}
1827 </option>
1828 </s:iterator>
1829 </select>
1830 <script type="text/javascript">
1831 //回显页码
1832 $("#pn").val(${currentPage});
1833 </script>
1834 </div>
1835 </div>
1836
1837
1838 <script type="text/javascript">
1839 function gotoPage(pageNum){
1840 //window.location.href="topicAction_show.action?id=${id}&pageNum="+pageNum;
1841 $(document.forms[0]).append("<input type='hidden' name='pageNum' value='"+pageNum+"'/>");
1842 document.forms[0].submit();//提交表单
1843 }
1844 </script>
1845
1846 2. NoSQL：??
1847
1848 3. 安装项目的过程步骤：如何部署一个项目
1849 * 创建数据库，并初始化数据库。
1850 * 把项目部署到服务器中。
1851 * 测试运行。
1852
1853 4. 简历的重点在项目经验，一定要熟悉你写的项目，做到烂熟于心。
1854
1855 5. 面试笔试题，老师说要做到2000道，才算过关。
1856
1857 6. 常见的Java笔试题，分析。
1858
1859 *Action的execute方法中不返回ActionFoward对象，而是返回null，将会有什么结果？什么情况有这种应用？
1860 （文件下载）
1861
1862 *设计模式的讲解。
1863 *sql关联查询的讲解。
1864 *hibernate二级缓存的讲解。
1865 *数据库的存储过程和触发器也是经常被问到的问题。
1866 *weblogic的使用。
1867 *必须能够独立写出数据库分页代码
1868
1869 7. 对于项目经验，包括项目名称，项目描述，责任描述，技术描述。项目名称为客户名+项目名称。项目描述所要说的就
1870 是你为谁开发的项目，项目的作用，功能，项目包含的模块，简洁明了，3行左右就可以了。责任描述就是你在该项目
1871 中负责的模块，以及工作职责，可以带过。重要的就是技术描述，面试官要问的地方就在项目的功能点，技术点，最好
1872 写清楚使用什么技术，实现了什么功能，至于怎么实现的，就是你面试时要说的。
1873
1874 8. 修改虚拟主机的文件夹路径为：C:\WINDOWS\system32\drivers\etc
1875
1876 9. WINDOWS盘符和文件夹使用":\"分隔 的,网络路径中协议和主机名使用"://"分隔的。
1877 注：
1878 1. 在Windows中物理路径是由"\"分隔的，网络路径是由"/"分隔的，Linux中都是用"/"作为分隔符。
1879 2. 在Window操作系统中字符是不区分大小写的，就像百度搜索时的字符也是不区分大小写的。
1880
1881 10. 安装好jdk(Java Develop Tookit):Java开发工具箱之后,配置：
1882 *1. 配置JAVA_HOME(Java开发工具箱的安装目录): jdk的安装路径。
1883 *2. 配置CLASSPATH(Java类的搜索路径): .;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar;%JAVA_HOME%\lib\dt.jar。
1884 *3. 配置PATH(命令搜索的路径)： %JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;。
1885
1886 11. tomcat是一个调试容器，真正部署项目的时候大多是用WebLogic或者WebSphere,在其中部署10个项目就会跑得很慢
1887 了，建议改用其他的web容器，如：WebLogic。
1888
1889
1890 12. 初级学知识，高级学规律。
1891
1892 13. 程序员的面试中的自我介绍：(以谈技术为核心，两分钟就行，踏实点，说重点，尽快切入主题)
1893
1894 *1. 你是谁(有名字就行)
1895 *2. 你要应聘的职位(Java软件开发工程师)
1896 *3. 你以前做过什么项目(做过什么)
1897 *4. 你擅长的技术(能做什么)
1898 *5. 适当的吹牛逼(少吹点,能不吹就不吹)
1899 注：面试官最想知道的就是你到底具不具备软件开发能力，沟通能力，从而觉得要不要招你。
1900
1901 14. 对于校招，可以适当的写两个项目就行了，不可能有太多的项目经验，工作经验也可不写，因为应届生哪有那么多的工作
1902 经验；对于社招，那就要适当的包装自己，至少2年工作经验，3个项目最适合，重要的项目放在前面。
1903
1904 15. 把老师教给你的项目内化成自己的项目，一定要对象项目中用到的技术熟悉，熟悉，再熟悉，前提是你要有深入才能
1905 简出。
1906
1907 16. 前端编程经验的总结：功能界面设计，涉及到的技术有前端的CSS+DIV布局，以前布局使用表格，框架，现在布局基本上
1908 使用区块的浮动布局。
1909 功能界面实际的一般思路是：
1910 >1. 首先是要有项目的需求分析，完成需求说明的文档，这个部分由需求分析师是完成。
1911 >2. 功能界面的设计，这部分由美工和网站策划师完成。
1912 >3. 前端工程师完成功能界面的实现，必须分毫不差的实现美工的效果。
1913 >4. 布局完成，渲染完成之后，即可以为表单添加特效，校验及其他的特效等，也就是
1914 前端工程师的脚本编程。
1915 >5. 有些异步请求的校验，以及需要用异步请求完成的功能可以是由服务端工程师完成。
1916 注：对于CSS+DIV的布局：
1917 有一般的规律可循：
1918 *1. 搭建结构，用HTML标签元素搭建文档的结构
1919 *2. 添加图片，文件等内容
1920 *3. 给标签元素命名，有利于层叠样式表给特定标签元素的渲染
1921 >类别命名一般用于层叠样式表选择使用
1922 >标号命名一般用户Js编程加特效
1923 注：这里说的是一般，也可以混用，
1924 命名习惯：
1925 #1. 类别命名可以使用标签类型+功能名字的方法
1926 #2. 编号命名根据需要或者是需求命名
1927 注：这里还是得听项目经理的
1928 *4. 给标签的样式表塞值(填表单)：
1929 塞值步骤可以是(个人经验)：
1930 #前提： 可以有公共通用的层叠样式表的塞值文件：
1931 *commons.css可以设置属性，如所有标签
1932 或者是文件中用到的标签内外边距为0，图
1933 片的边框大小为0px，锚标记得字体大小。
1934 颜色，访问样式的设置，如：
1935 text-decoration,a:visited,a:hover,
1936 a:link,a:active
1937 剩下通用字体的设置等等。
1938 #1. width(宽度) height(高度)
1939 #2. line-hight(行高) text-align/vertical-algin
1940 (文本的对齐方式)
1941 是水平对齐还是垂直对齐。
1942 #3. 字体的设置：font-size(字体大小) font-weight
1943 (字体粗细)
1944 color(字体颜色)
1945 注：层叠样式表也支持继承，说白了就是就近原则
1946 覆写的原则。
1947 #4. 背景图片，背景色：background,background-color
1948 #5. 内边距 边框 外边距：
1949 padding border margin
1950 #6. 最后就是布局：是区块元素或者内嵌区块元素就要
1951 布局，float(浮动布局),relative, absolute
1952 overflow等
1953 #7. 特殊的层叠样式表的塞值：
1954 *1. left=-1px;左位移
1955 *2. bottom=-1px;相邻元素向上位移
1956 *3. z-index=0;层叠权限级别
1957 17. Js编程经验总结：脚本编程用到的最多的就是Java脚本库：JQuery,封装了Java脚本编程中对元素的选择方法，Java脚
1958 本编程的操作对象是DOM(Document Object Model)元素:文档对象模型，是基于事件响应的编程，其中用到了许多的回
1959 调函数即函数指针的调用，通过传递函数对象(很多的匿名函数)，局部依赖方法，完成相应的功能。说简单点，其实脚
1960 本编程其实就是选择标签元素后，对表签元素的属性的设置值，移除值，以及对其层叠样式表属性的设值或移除值，对
1961 其文本内容的getter,setter以及对标签元素的getter delete等等，从而对DOM元素添加特效。
1962
1963 18. 异步请求：JQuery的异步请求方式，有6种常用的方法，
1964 注：Js的对象表示方式可以使重量级的xml文件，或者是轻量级的json数据表示方式(字符串键，对象值)
1965 *1. $.ajax({
1966 //请求的地址
1967 url:"",
1968 //异步请求要提交的参数
1969 data:{}，
1970 //是否异步请求
1971 async:true/false,
1972 //是否缓存
1973 cache:true/false,
1974 //异步的请求方式
1975 type:"POST",
1976 //传输的数据类型
1977 dataType:"json",
1978
1979 //异步请求成功之后要调用的函数,result是异步请求的服务端方法成功之后的返回值
1980 success:function(result){
1981 ...
1982 }
1983 });
1984 //url:为你要请求访问服务器地址，data为你要提交的参数,
1985 //function 为异步请求成功之后要执行的函数
1986 *2. $.post(url,data,function);
1987 *3. $.get(url,data,function);
1988 *4. $.load(url,data,function);//不管请求成功或者失败，都会执行回调函数。
1989 *5. $.getJSON(url,data,function);
1990 *6. $.getScript(url,fuction)
1991
1992 19.EL表达式：
1993 *EL表达式中判断对象值是否为空的方式: ${empty 值}
1994 *EL表达式中判断对象值是否相等的方式：
1995 >1. eq 一般选用这个，比较字符串不需要用双引号。
1996 >2. == 这个也可以用
1997
1998 21. 伪协议：href="javascript:"，超链接后为执行javascript类型的方法。
1999
2000 22. <c:out value="" />是jstl标签库中提供的数据输出功能，${}是J2EE中提供的数据输出功能，两者完成的效果一样。
2001
2002 23. el表达式一般不直接用==判断是否相等，> < >= <= !=之类的表示大于，小于，大于等于，小于等于， 不等于，而是
2003 使用字母的表达式，eq，ne,gt,lt,ge,le，字符串比较，不需要使用""。
2004
2005 24. js方式的异步请求：有的企业要求你要会写，
2006 *1. 异步请求的get方式
2007 代码：
2008 //创建一个XmlHttpRequest请求
2009 function createXmlHttpRequest(){
2010 //声明一个请求，并是设置为空
2011 var xhr=null;
2012 try{
2013 //兼容IE浏览器的请求
2014 xhr=new ActiveXObject("microsoft.xmlhttp");
2015 }catch(e){
2016 try{
2017 //其他浏览器的请求对象
2018 xhr=new XmlHttpRequest();
2019 }catch(e){
2020 alert("你的浏览器太差！");
2021 }
2022 }
2023 //返回请求
2024 return xhr;
2025 }
2026
2027 //创建异步get请求,在窗口的加载的时候执行函数
2028 window.onload=function(){
2029
2030 //界面元素的单击事件之后完成异步请求
2031 document.getElementById("").onclick=function(){
2032 //获取请求对象，局部依赖该对象
2033 var xhr=createXmlHttpRequest();
2034 //请求对象的get请求
2035 xhr.open("get",url);
2036 //请求对象发送数据为空
2037 xhr.send(null);
2038 //请求对象的请求完之后的分发的数据
2039 //请求对象的准备状态的改变事件之后执行函数
2040 xhr.onreadystatechange=function(){
2041 //请求对象的准备状态为4时，请求成功
2042 if(xhr.readyState==4){
2043 //请求状态为200或者304时请求成功
2044 if(xhr.status==200 || xhr.status==304){
2045 //获取服务器相应过来的数据
2046 var data=xhr.responseText;
2047
2048 alert(data);
2049 }
2050 }
2051 }
2052
2053 }
2054 }
2055 *2. 异步请求的post方式
2056 //1. 创建请求对象，同上，略
2057
2058 //2. 窗口加载的时候，创建异步请求
2059 window.onload=function(){
2060 //创建请求对象
2061 var xhr=createXmlHttpRequest();
2062 //界面元素单击之后的响应
2063 docuemnt.getElementById("").onclick=function(){
2064 //请求完成之后服务器响应的数据
2065 xhr.onreadystatechange=function(){
2066 //请求对象的准备状态为4时，响应成功
2067 if(xhr.readyState==4){
2068 //请求状态为200或者304时请求成功
2069 if(xhr.status==200 || xhr.status==304){
2070 //获取服务器相应过来的数据
2071 var data=xhr.responseText;
2072
2073 alert(data);
2074 }
2075 }
2076 }
2077 //请求对象向服务器请求数据
2078 xhr.open("post",url);
2079 //设置请求体的数据编码方式
2080 xhr.setRequestHeader("content-type","application/x-www-urlencoded");
2081 //请求对象向服务器发送数据,paramter是向服务器提交的参数
2082 xhr.send(parameter);
2083 }
2084
2085
2086 }
2087
2088 26. xml和json都是表示数数据的格式，xml是重量级的，操作性强，可以操作xml的各个节点，而json是轻量级的，是Javascript
2089 对象表示符号，本质就是一个键值对，没有像xml一样描述数据的节点，所以xml多数用户配置未见，json就是经常用于
2090 传输数据，提交数据，返回数据，轻量级，效率高。
2091
2092 27. web1.0就是个大门户网站兴起的时代，用户是被接受者，web2.0 就是网络交互软件的兴起，比如社交软件的风靡，
2093 网络的内容用户自己创建，是主动创建者，web3.0 时代我猜就是物联网时代，这个还需要研究。
2094
2095 28. 页面出现404错误是找不到资源页面，出现500错误是服务器解析错误，出现302是页面地址重定向，101是服务器接
2096 收到请求，200是请求成功。
2097
2098 29. JQuey插件
2099 jquery_treeview:树形视图(有点像手风琴式的下拉菜单，这也是一个Js插件)
2100 *学习思路：导包(JQuery基础包，插件包) ->配置->使用
2101 >1. 导包：
2102 *1. jquery.treeview.css(JQuery的树形视图的层叠样式表单渲染文件)
2103 *2. jquery-1.7.min.js(JQuery的基础脚本文件)
2104 *3. jquery.treeview.js(JQuery的树形视图脚本文件)
2105 >2. 配置，使树形视图只由一项父目录为展开的，初始化为都不展开
2106 *1. 自定义的配置：就是不太好理解
2107 //为网页文档添加脚本代码
2108 <script type="text/javascript">
2109 //父目录的单击事件之后执行调用函数
2110 $("").click(function(){
2111
2112 /*
2113 *目的是为了选择被单击的父目录节点的其他节点,并隐藏之
2114 */
2115 //$(this)，表示当前被选择的节点
2116 $("").not($(this).next)).hide();
2117 //被单击的父目录执行切换的效果
2118 $(this).next().toggle();
2119 });
2120 </script>
2121 *2. 配置属性：为了可读性，最好用这种配置的方式
2122 注：$(function(){});和$(document).ready(function(){});
2123 的意思是一样的，都是在当前文档加载完之后，执行要调用的方法。
2124 $(function(){
2125
2126 //选择要显示为树形视图的根，一般为无序列表使用树形
2127 //视图的插件
2128 $().treeview(function(){
2129 //配置树形视图的父目录是否缩紧，就是说初始化为不显示
2130 //树形视图的子目录，只显示父目录
2131 collapsed:true,
2132 //配置只显示一个父目录为可以展开的
2133 unique:true
2134 });
2135 });
2136 jquery_validate:验证框架这称个是前端校验，也可以称作用假的校验，可以骗骗小白用户，前端的代码因为
2137 用户是可以看到的，所以安全性不高，对于服务端的业务逻辑代码，是编译之后的字节码文件
2138 部署到服务器上之后，安全性较高，所以服务端的校验是最安全的校验。但是为了用户体验，
2139 前端的校验还是必须要的。
2140 1. 导包
2141 >1. JQuery库基础包：jquery-1.7.min.js
2142 注：
2143 *开发中也可以用jquery.js,但是发布的版本最好用压缩版本，占用的服务器内存小。
2144 *版本的话可以用稳定的版本，不一定最新版的就是最好的，就像开发工具一样用稳定版本的
2145 但是有的插件就是有其版本的要求，比如下面的插件自动补全插件就要求JQuery库版本的号
2146 就是1.7以上的。
2147 >2. jquery.metadata.js
2148 >3. jquery.validate.js
2149 2. 配置：这里的配置使用json的数据格式塞值，其实就是初始化，有模板代码如下，可以不用记，知道
2150 用就行。
2151 jQuery.extend(jQuery.validator.messages,{
2152 //必需的字段,这个用的比较多
2153 required:"",
2154 //验证失败，验证码？？
2155 remote:"",
2156 //是否是网络地址格式
2157 url:"",
2158 //是否是邮件地址格式，用的较多
2159 email:"",
2160 //是否是日期格式
2161 date:"",
2162 //是否是数字格式
2163 number:"",
2164 //是否是整数格式
2165 digits:"",
2166 //是否是信用卡号格式
2167 creditcard:"",
2168 //两次输入是否相等
2169 equalTo:"",
2170 //指定后缀名的字符串
2171 accept:"",
2172 //输入字符最大长度
2173 maxLength:jQuery.validator.format(""),
2174 //输入字符最小长度
2175 minLength:jQuery.validator.format(""),
2176 //输入字符长度在{0}和{1}的值
2177 maxRangeLength:jQuery.validator.format(""),
2178 //输入值在{0}和{1}的值
2179 minRangeLength:jQuery.validator.format(""),
2180 //输入一个最大值{0}的值
2181 max:jQuery.validator.format(""),
2182 //输入一个最小值为{1}的值
2183 min:jQuery.validator.format(""),
2184
2185 });
2186
2187 3. 使用：
2188 *1.
2189 $(function(){
2190 $("form").validate();
2191 });
2192
2193 *2. 用json的数据格式，例如：<input css="{required:true,accept:'.zip'}" />
2194 注：$(function(){});是$("document").ready(function(){});的简写，这里用到了函数的回调。
2195 jquery_autocomplete:自动补全
2196 1. 到包
2197 *1. 导层叠样式表文件：
2198 >jquery.autocomplete.css
2199 >main.css
2200 >thickbox.css
2201
2202 *2. 导jQuery的基础脚本文件：jquery-1.7.min.js
2203 *3. 导自动补全的框架脚本文件：jquery.autocomplete.js
2204 注：一定先导基础的jQuery脚本文件，在导插件脚本文件，顺序出错程序就会无法运行。
2205 2. 配置
2206 样例代码：
2207 //选择要进行自动补全的元素(一般是输入框)
2208 $("#..").autocomplete(url/data,
2209 //自动补全插件的配置
2210 {
2211 //1. 触发自动补全最小字符数(minChars)
2212 minChars:1,
2213 //2. 下拉列表支持的最大数量(max)
2214 max:10,
2215 //3. 下拉列表宽度，默认与文本框同宽(width)
2216 width:auto,
2217 //4. 支持包含匹配(matchContains)
2218 matchContains:true,
2219 //5. 下拉列表的高度(scrollHeight)
2220 scrollHeight:180,
2221 //6. 触发自动补全的延迟毫秒数
2222 delay:1000,
2223 //7. 下拉列表显示的数据，格式化项(formatItem),局部依赖为要在
2224 //下拉列表一行中显示的数据
2225 formatItem:function(row){
2226 return "<div>"+row.word+"<span>"+row.count+"</span></div>"
2227 }，
2228 //8. 如何解析词汇，生成要显示的数据data，以及选择下拉列表项之
2229 //后要显示在输入框中的数据result ,依赖后台返回的json格式数据，
2230 //是键值对模型
2231 parse:function(data){
2232
2233 return $.map(data,function(temp){
2234 return {
2235 //要显示在下拉列表中的数据对象
2236 data:temp,
2237 //要显示在输入框中的值
2238 result:temp.word
2239 }
2240 });
2241 }
2242
2243 }
2244 //自动补全选择列表项之后要执行的方法，数据依赖是事件和传入的数据项对象
2245 ).result(function(event,item){
2246 location.href=url+要提交的参数;
2247 });
2248
2249 3. 使用: 如上
2250 fckeditor:富文本编辑器
2251 1. 导包：
2252 >把开发包到导入就行了。
2253 >fckeditor.js
2254 2. 配置：
2255 *1. 这里可以自定义文件myconfig.js配置富文本编辑器需要显示的工具栏选项，再在fckcon-
2256 fig.js文件中引用就行了，这里就省去了配置。
2257 *2. 使用配置
2258 >样例代码：
2259 //初始化富文本编辑器
2260 $(function(){
2261 //1. 提交表单时本字段使用的参数名，就是要提交的编辑器里的内容content字段
2262 var oFCKeditor=new FCKeditor("content");
2263 //2. 指定编辑器文件夹所在的路径，一定要以"/"结尾，这个必须要有
2264 oFCKeditor.basePath="${pageContext.request.contextPath}/fckeditor/";
2265 //3. 指定编辑器的高度
2266 oFCKeditor.height="";
2267 //4. 指定编辑器的宽度
2268 oFCKeditor.width="";
2269 //5. 指定编辑器的工具栏集合
2270 oFCKeditor.ToolbarSets="";
2271 //6. 替换文本域，我还是不太理解，是不是用编辑器的文本域替换
2272 //html文档字段里的内容字段？？
2273 oFCKeditor.ReplaceTextarea();
2274 });
2275
2276 3. 使用：在要使用富文本编辑器的文本域字段用name属性关联配置定义的字段名content
2277 例如：对象图导航语言，struts标签
2278 <s:textarea name="content"></s:textarea>
2279 注：把对象框架的配置初始化理解为填表单就不会那么不好难了。
2280 30. JQuery的元素选择方法:
2281 *1. next(); 当前节点的同级下一个节点。
2282 *2. siblings(); 当前节点的同级兄弟节点集合。
2283 *3. prev(); 当前节点的同级前一个节点。
2284 *4. parents(); 当前节点的所有父亲节点集合：可以加上过滤器条件例如：$(this).parents(tr:first)
2285 *5. parent(); 获取当前节点的父亲节点。
2286 *6. children(); 当前节点的孩子节点集合。
2287 *7. not(); 就是排除该节点，例如：$().not($(this).next());意思就是说排除当前节点的下一个节点。
2288 *8. find(); 查找并获取特定名字的子元素节点，可以用选择器来表示，例如：$(div .class);
2289 *9. filter(); 查找的是指定名字的同级元素节点。
2290
2291 31. JQuery选择元素之后的操作对象：元素节点，属性，层叠样式表的属性，文档标签内嵌的内容。
2292
2293 32. 作为少年更要珍惜时间。
2294
2295 33. 伪协议的作用：用在锚标记的超链接上，使超链接之后执行java脚本的函数。
2296
2297
2298
2299
2300
2301 2015/9/6
2302
2303
2304
2305
2306
2307 1. 网页是由块级元素和行内元素堆叠成的，块级元素的实质是行内元素的首尾增加了一个换行符，所以块级元素的默认
2308 布局是从上到下排序的；而行内元素是从左到右的默认排序，默认的元素之间的排列是有间隙的，可以通过的设置元
2309 素的内边距和外边距为0消除元素之间的间距。要改变块级元素的默认布局，可以用现在的流行的浮动布局，改变文档
2310 流的流向，从而达到像行内元素一样的布局效果。
2311
2312 2. 判断使用行内元素还是块级元素的标准是看元素里是否有子元素，没有子元素的话就用行内元素，有的就用块级元素。
2313 一般的规则就是文本内容嵌入行内元素，小块元素嵌入大块元素，经过好的布局组成一个好看的为网页。
2314
2315 3. 对于Java Web的项目的开发，前端网页的存放位置，可以放在WEB-INF下，也可以放在WebRoot下，这两者的区别是
2316 外部浏览器是否可以直接输入静态地址访问资源文件，不过网页资源文件放在WebRoot下，可以通过过滤器控制资源
2317 文件的请求访问，说白了就是在WEB-INF目录下的资源文件是受到保护的，是不可以随便外部请求访问的，但是可以
2318 通过控制器servlet，Action(动作)转发或者是重定向访问该文件夹下的内部网页资源文件。
2319
2320 4. 表格元素是块级元素，表格的组成实质就是单元格加上换行符，单元格我觉得就是(inline-block)行内-区块元素，
2321 其中的表格头<thead>,表格主体<tbody>,表格尾<tfoot>,这三个标签元素的作用就是控制表格中内容是否是渲染到
2322 此单元格时加载元素内容，还是渲染完成整个文档之后再加载表格元素内容，提高文档内容的加载效率。
2323
2324 5. 项目开发中的资源的更新
2325 *及时更新：插入内容马上更新，这样做的好处就是方便，代码量少，缺点就是损失系统的性能，不断的插入，
2326 删除更新会增加系统服务器的负担。
2327 *定时更新：每隔自定的时间，定时更新系统的资源，需要用到守护线程定时器定时更新资源，代码复杂。
2328 *选择性的更新: 可以设定更新的按钮，手动的更新资源，需要手动的更新。
2329
2330 6. 守护线程：可以理解为一个后台的服务，是优先级别最低的一个线程，例如java虚拟机的垃圾回收器就是一个守护线
2331 程，数据库连接池和内存管理也是守护线程。
2332 注：
2333 *1. 线程分为，用户线程(User Thread),主线程(Main Thread)，守护线程(Daemon Thread),其中在Java
2334 编程主线程和守护线程是必须会开启的，因为主线程是函数方法的入口，守护线程是Java虚拟机的垃圾回收器。
2335 *2. 我们所熟悉的Java虚拟机中的垃圾回收器就是一个典型的守护线程，我们的程序中不会再有运行的线程时，程
2336 序就不会产生垃圾，垃圾回收器就无事可做，所以当垃圾回收器是Java虚拟机的仅剩线程时，Java虚拟机就会
2337 自动离开。
2338
2339 7. 四个域对象：
2340 *page：页面对象，作用域最小，生命周期最短，仅限于当前的页面。
2341 *request：请求对象，生命周期为一次请求响应之后，一个请求可以包含多个的页面。
2342 *session: 用户会话对象，生命周期和浏览器的生命周期一样，开一个浏览器即开启一个用户会话的对象
2343 *application: 应用程序对象，生命周期和服务器的生命周期一样，随着服务器的开启和关闭也随着关闭，原因
2344 应用程序是部署在服务器端的。
2345
2346 8. 文件过滤器：作用就是用来过滤特定扩展名字的文件，返回值就是文件地址的字符串集合。
2347 *例子,例如以过滤文件扩展名字为jpeg的图片文件的地址集合，方法名字为getBankImages()
2348 *原理：
2349 通过传入文件夹的地址路径，
2350 //返回值为文件地址字符串数组，局部依赖为要过滤的文件夹地址
2351 public String[] getBankImages(String path){
2352 //新建一个目录文件
2353 File file=new File(path);
2354
2355 //返回过滤指定后缀名的文件字符串地址集合,过滤方式式通过文件名字过滤器FilenameFilter
2356 return file.list(new FilenameFilter(){
2357 //实现文件过滤器的接受方法，局部依赖文件夹和文件名字
2358 public boolean accept(File dir,String name){
2359 //如果文件名字的后缀名为jpeg,则返回为真
2360 return name.endsWith("jpeg");
2361 }
2362 });
2363
2364 }
2365
2366 9. 多任务(一个任务可以由多个应用程序来完成)-多进程(应用程序)-多线程(能运行的代码块)：细粒度的不断提高
2367
2368 10. 表单的作用：表单是块级元素，是由行内元素输入框组成的，输入框是内联——区块元素，可以设置宽高，总之表
2369 单的作用就是用POST提交大量的数据参数，提交内存大的数据比如图片等，要用编码类型属性enctype="multipart/
2370 form-data",这个数据类型是MIME类型。与表单相反，在界面编程中，表格的作用就是显示数据，与
2371 数据库端编程中，表的作用也是显示数据一样，而在服务端数据库表就被映射成为了以个由属性和访问器子程序
2372 组成的的类数据实体，经过服务器的业务逻辑处理数据之后形成数据对象或者数据对象的集合，分发到个页面的
2373 用表格的形式显示数据集合。
2374 注：
2375 *用列表的形式也可以显示数据对象集合。列表本质是由列表项组成的，列表项是块级元素，这是和表格的
2376 单元格的最大不同，因为单元格默认是从左到用的顺序排列的，而列表项是块级元素，从上到下的排列顺序。
2377 而且列表和表格有很大的相似之处，例如：表格中可以嵌套表格，列表中可以嵌套列表，都是大区块里装着
2378 小区块，小区块里面装着要显示的数据内容。
2379 *一般是表单里面套一个表格用于布局，控制表单的的结构。
2380 *以前的网页使用表格来布局，但是灵活性很差，所以渐渐地用区块加浮动的布局(专业术语：DIV+CSS).
2381
2382 11. 表格与列表
2383 *表格：由列名和一行一行的数据记录组成，主要的数据作用就是显示数据。
2384 *列表：本质就是用缩进空格的方式，显示数据，一般的用处就是显示父目录和子目录，或者就是只显示一行数据。
2385
2386 12. 标签<label>：我觉得最主要的作用就是标签元素有个for属性，可以设置其关联表单元素的输入框的编号，从而达
2387 到单击标签元素的区域同样选择输入复选框的目的。
2388
2389 13. 卖书就等于贱卖你的人格。
2390
2391 14. 客户端的校验是假校验(可以把校验的代码抽取掉，从而达到骗过前端数据校验)，服务端的数据校验才是真的数据校
2392 验。
2393
2394 15. 虚拟机：和C#的通用语言运行时一样，能运行Java字节码文件，规定的编码方式为宽字节的编码Unicode，无论什么
2395 字符都是用2个字节表示。
2396
2397 16. 程序的输出端有控制台，界面，网页。
2398
2399 17. 编程开发中到处都是请求响应的模型
2400 *服务器端: 请求的对象为服务器，请求的语句是get方式或者post方式的url地址语句。
2401 *数据库端: 请求的对象是数据库，请求的语句是sql语句。
2402 *前端：请求的方式是通过事件的方式。
2403 *界面编程：请求的的方式也是通过界面的事件响应的方式。
2404
2405 18. 要用到事件，基本上是离不开函数指针的回调。
2406
2407 19. 能用迭代处理的就不用递归，不好理解，可读性不强，递归用到的地方可以遍历文件树。
2408
2409 20. 时刻保持谦虚求学的心态才能不断前进。
2410
2411 21. 开发人员让其他人来检查你的工作是很有好处的。
2412
2413 22. 复查是一个很重要的机制，他可以程序员得到关于他们自己的代码的反馈。
2414
2415 23. 复查可以快速的将所有的开发者的水平提升到最优秀的开发者的高度。
2416
2417 24. 即使是无法看到显示器、使用了太小的字体等细枝末节，都可能造成问题。
2418
2419
2420
2421
2422
2423 2015/9/7
2424
2425
2426
2427
2428 1. 编程语句:
2429 * 顺序语句：顺序处理数据。
2430 * 判断语句：判断要操作的数据是否满足条件。
2431 * 循环语句：直接作用就是操作数组和数据列表集合。
2432
2433 2. web开发中的页面从域对象输出数据的方式有4种
2434 *jstl(Java标准标签库):
2435 1. $(域对象里的数据)
2436 2. <c:out value=""/>
2437 *ognl(对象图导航语言)：
2438 1. %(存放在映射里的数据或者是域对象(在struts2中被包装为映射：即Map的结构)里的数据)
2439 注：这里用"%"取值是为了在Jsp中和jstl中的"$"取值符号区分
2440 2. <s:property value=""/>
2441
2442 3. Jsp页面中的超链接：
2443 *jstl：
2444 1. 锚标记(a标签)：建议写动态获取服务器地址的绝对路径，
2445 例如：${pageContext.request.contextPath}:作用就是动态的获取服务器里的项目地址。
2446 2. <c:url var="" value="/...">
2447 <c:param name="" value=""></c:param>
2448 </c:url>
2449 <a hred="${}"></a>
2450 注：这个Jstl的地址标签是自动utf-8编码参数数据的，所以不用担心传中文参数是的乱码问题
2451 地址中的value属性是
2452 3. 表单里的action属性：<form action=""></form>
2453 注：这个Action请求是POST请求，也不用考虑传中文参数的乱码问题
2454 *对象图导航语言：
2455 1.
2456 <s:a action="">
2457 <s:param name="" value=""></s:param>
2458 </s:a>
2459 注：这里向地址栏里传的参数也是自动utf-8编码的
2460 2. <s:form action=""></s:form>
2461
2462 4. 前端编程中有单标签者双标签之分，用哪个看情况而定，有的标签就是单标签，如：<img src=""/>，有的必须要是
2463 双标签，如：表单元素<form></form>,剩下的就是看代码的可读性和简洁性进行权衡选择，标签里面没有内容的可以
2464 用单标签，简洁，当然你可以用双标签肯定是没有错的。
2465
2466 5. 文件的上传下载中，输入流一般指的是资源文件流，输出流指的是输入流要输出到的文件夹。
2467
2468 6. 提高自己的定力，不能整天的胡思乱想。
2469
2470 7. 在权限设置模块，前端的设计中
2471 权限选择功能设计要点
2472 1. 必须要有一个全选的功能。
2473 2. 单击父权限的时候，子权限也必须要全选。
2474 3. 单击子权限的时候，父权限也要被选中。
2475 4. 当子权限的勾选全部取消时，父权限也要取消勾选。
2476 实现方案：
2477 1. 全选功能：这里要用到label标签的for属性，关联表单的输入复选框,当单击全选按钮功能的时候
2478 所有权限的功能都要选上，实现方式就是给该标签元素实现单击事件，完成全选的功能
2479 用的选择器使用JQuery实现的。
2480 *代码：
2481 <input type="checkbox" id="" onClick="$([name=privilegeIds]).attr(checked,this.checked);"/>
2482 2. 实现原理：剩下这三个功能的实现都是通过设置标签元素的是否选中属性是否为真，即attr(checked,true);
2483 2.1 实现第二个功能的代码：是JQuery脚本代码。
2484 $("[name=privilegeIds]").click(function(){
2485
2486 //1. 单击父权限时，所有的子权限也被选中
2487
2488 //如果当前的元素被选中
2489 //注：this表示的是当前对象，$(this)表示的是当前的选择的元素节点
2490 if(this.checked){
2491 //2. 选择子权限时，父权限也要勾选
2492 }else{
2493 //否者当前的元素不被选中
2494 //3. 取消选择所有的子权限时，父级权限也被取消
2495 if(){
2496 }
2497 }
2498 });
2499 ...
2500 注：
2501 *这里最好要看着前端页面的元素节点继承结构来编写，要不然会犯晕的。
2502 *用到的节点选择方法有选择父亲节点，兄弟节点，过滤节点，孩子节点
2503
2504
2505 8. 要你去适应生活，而不是让生活去适应你。
2506
2507 9. 返回上一级的Java脚本代那：<a href="javascript:history.go(-1)"></a>
2508
2509 10. 前端编程中的死链接，有三种方式
2510 1. <a href="###"></a>
2511 注：一个"#"表示的是连接到页面的top锚点，并不是死链接。
2512 2. <a href=":;"></a>
2513 3. <a href="javascript:void(0)"></a>
2514
2515 11. Js中的闭包(closure):简单的理解就像Java类中的全局依赖，只不过在Js中是方法中的一个局部依赖，父方法中嵌套
2516 的子方法操作该依赖的对象。
2517 注：
2518 *在Js中函数是可以嵌套函数的，在Java中是不可以这样的。
2519 *不能滥用闭包，会增加内存开销，因为函数中的依赖变量本质是不属于该函数的(可以理解为是全局依赖变量的
2520 替代)，即使函数执行完了，垃圾回收器也不会回收该依赖的变量。
2521
2522 12. 创建接口的一般步骤就是：
2523 1. 创建接口Service
2524 2. 创建接口的实现类
2525 3. 配置Service
2526 4. 在Action声明Service，其实就是创建一个Action的依赖Service
2527
2528 13. 创建Action的一般步骤：
2529 1. 创建Action类
2530 2. 创建各个要控制数据的方法
2531 3. 创建Action中方法相对应页面UI
2532 4. 配置Action
2533
2534 14. Java Web 开发的步骤
2535 1. 需求分析，生成需求文档，用户确认。(需求分析师)
2536 2. 项目设计，生成项目设计文档。(项目设计师)
2537 3. 功能界面的设计。(美工，网站策划师，实现->前端工程师)
2538 4. 系统架构，接口的设计(项目经理)
2539 5. 实体设计或者是数据库表的设计.(数据库端程序员)
2540 6. Action创建(6.7.8服务端开发工程师)
2541 7. Service创建
2542 8. Jsp页面
2543 9. 项目测试(测试工程师)
2544
2545 15. 生无所息，奋斗不止。
2546
2547 16. 朋友是你一生的财富。
2548
2549 17. 每一天都要珍惜着过,要对的起遇见的每一个人。
2550
2551 18. 过度使用闭包会导致性能下降，函数里面放匿名函数，则会产生闭包。闭包的实质就是延长局部依赖的变量的生命
2552 周期，使之达到和全局依赖的变量效果是一样的。Js语言的特点就是函数里面可以嵌套函数，从而有了闭包这一替换
2553 全局变量的特性，就是子函数访问父函数的局部变量，延长了局部变量的生命周期。闭包就是一个代替全局变量的局
2554 部依赖变量。
2555
2556 19. if you can't explain it to a six-year-old,you really don't understand it yourself.
2557
2558 20. 分层是为了解耦，依赖是为了通信。
2559
2560 21. 依赖分为全局依赖和局部依赖，全局依赖就是指类的私有(private)变量或者是保护(protected)的变量，局部依赖一
2561 般指定而是方法的参数或者是方法中的局部变量。
2562
2563
2564
2565 2015/9/8
2566
2567
2568
2569 1. 人应该活得简单点，不能想太多。
2570
2571 2. DOM元素的节点继承树window->document->块级元素->行内元素。
2572
2573 3. 技术的东西是死的，人是活的，所以说技术性的东西好学，非技术性的东西才真正的是个大难题。
2574
2575 4. 到最后你才会发现人才是一个很难懂的很难学的学问，因为他是活的，你控制不了，也很难地掌握的了。
2576
2577
2578
2579
2580
2581 2015/9/9
2582
2583
2584
2585
2586 1. Sturts1和Sturts2的存储数据的最大不同是就是Struts2的数据中心使用Map映射结构来存储的，request，session,
2587 application者单个内置的域对象都被封装成为了一个Map映射结构。而且Sturts2多了一个值栈中心，前端收集数据的
2588 时候就是相当的方便的了，用值栈的话，再加上模型驱动这一特性，就可以直接往对象的属性里塞值。
2589 注：为什么要把内置的域对象封装成为Map映射结构，(为了使用方便，为了使用接口，为了扩展性，??),有一点就是我
2590 确定的就是为了解耦，为了和Servlet控制器的API充分的解耦，这也是框架2要实现的目标。
2591
2592 2. 现代的世界是没有网络不成文章。
2593
2594 3. Struts1和Struts2提交数据表单的时候，框架1是通过ActionForm封装表单的参数，还要把表单相对应的对象要和
2595 ActionForm相对应，说白了就是还要设计对象的表单实体用来处理表单的数据，最后持久化到数据库中。这里的操作
2596 相当的繁琐，所以框架2中有了模型驱动接口这一新特性，直接实现对实体对象封装，不用再另外构建什么数据模型
2597 了，而且数据类型自动的装换，之后持久化到数据库中是相当的方便的。
2598 注：实现模型驱动接口本质就是像对象模型(JavaBean)一样，实现它的getter和setter方法，可以理解为setter访问器
2599 是实现内部访问数据的接口，而getter方法是实现外部访问数据类实体的接口。
2600
2601 4. 对于Java Web开发中的Java开发工具箱选择，也最好要稳定的版本的jdk6和jdk7现在企业用的最多，当然也有老的项目
2602 是用6以下的，毕竟Jkd5之后Java更新了很多的新特性，比如泛型，枚举，增强for循环，反射(反射是另一种生成对象的
2603 方式，相比在堆中新建一个对象效率较低，但是在对象工厂用的很多，比如框架中的Spring对象工厂，Hibernate的配置
2604 文件等)，如果你的项目用的版本太高的话，而客户的服务器Jdk版本太低，就会出现兼容性问题，到时你的项目就是会
2605 覆水难收的，所以最重要的就是一切以客户的标准来做开发。
2606
2607 6. 一个方法最好是8到20行的代码，否则超过了就得考虑重构，增加代码的可读性。
2608
2609 7. 方法里的参数(局部依赖)最好控制在5个以内，太多了会有冗余，损坏可读性。
2610
2611 8. 控制器的作用就是准备数据分发数据到各个页面显示，或者是把数据通过Service层持久化到数据库中，Service层作用
2612 就是处理生成数据，数据库端就是持久化数据，当然显示层的数据就是显示控制器分发而来的数据，你会发现其实面向
2613 对象的编程其实就是对数据的编程，一切以数据为中心。分层的目的就是为让每一层只做一件事，实现编程的原子性。
2614 这也验证了一句话，就是Java的特性：高内聚，低耦合。
2615
2616 9. 同步锁：关键字，synchronized,作用就是让无序的线程变得有序，牺牲了时间，换得了空间，这里用的地方有共享数据
2617 依赖，多线程并发访问代码块时候，有两种方法设置同步锁,
2618 1. 同步方法，这个很简单，就是往方法的修饰符后面加上关键字synchronized
2619 2. 同步代码块，synchronized(this),这里也可以同步对象锁，例如可以设置一个对象的依赖锁lock，并非一定要
2620 用当前对象的关键字this
2621 把会产生并发问题的代码同步，就不会有线程并发的问题产生了
2622 对于为什么要这样做，就得问Java的底层代码？？
2623 注：多线程并发产生的问题的根源就是多用户访问同一个代码块(线程)，由于有中央系统处理器根据时间片处理
2624 线程的机制。
2625
2626
2627 10. 模仿->实践->积累->总结->深入->浅出->分享,这是学习的一个过程，也就是修炼境界的不断提高。
2628
2629 11. 多看，多听，多思考，多总结。
2630
2631 12. Js编程就是基于方法的编程，其中函数的回调用的很多。
2632
2633
2634
2635
2636 2015/9/10
2637
2638
2639
2640
2641 1. 协同构建有利于传授公司文化以及编程专业知识。
2642
2643 2. 复查可以快速地将所有开发者的水平提示到最优秀的开发者的高度。(Tackett and Van Doren 1999)
2644
2645 3. 简洁即是美，一定要把最重要的东西挑出来，不重要的东西可以放弃或者是删掉。
2646
2647 4. 结对编程时不要强迫程序员与自己关系进紧张的人组队，避免新手组合，一个项目组必须指定一个项目组长。
2648
2649 6. 英语和汉语的最大区别就是修饰词的问题，对于要修饰的词，比如名词，汉语一般是放在修饰词的后面，英语就不
2650 一样，他是放在修饰词的前面，基于这个原因，可能和文化的根源有关系。写文章也是一样的，最大的差别也是在此，
2651 对于把重要的东西放在前面，这个东西是可以借鉴的，为人处世也差不多。
2652
2653 7. 对于方法的命名问题，最好用动宾的结构，对于变量的命名问题，最好根据需求命名，这样可以增加可读性。
2654 因为方法的作用就是要表达的而是要做什么，而变量的表示的是根据需求建模而来的数据模型依赖。
2655
2656 8. 靠谁都应该靠自己。
2657
2658 9. 编程的目的就是模拟现实世界的模型。
2659
2660 10. 做东西一定要减少依赖，解耦，做项目也要减少依赖，不能依赖于平台，可移植性才强。
2661 注：做Web开发，现在客户的服务器都是用的Linux的，Windows的服务器用的很少。
2662
2663 11. 如果说我过去还对正式检查的价值心存疑惑，那么我编写《代码大全》的精力已经让我心服口服了。(代码大全的作
2664 者-Steve McConnel)
2665
2666 12. 详查就是开会给项目排错，走查就是闲聊中给代码找错，前者较正式，正式检查比走查更需要集中精力，同时通常
2667 有更高的回报。
2668
2669 13. 编程中变量的作用是虚拟现实中的数据，方法的作用就是操作数据。方法就是由局部依赖加上处理数据的代码块组成，
2670 代码块就是由顺序语句或者是判断语句，循环语句组成的。
2671
2672
2673 14. 对于正则表达式，可以不用掌握太多，除非你是专门写正则表达式的，网上一收一大堆。
2674
2675 15. 计算机中存储数据的方式就是用键值对的数据模型，不管是外部配置文件properties,还是json格式的
2676 数据表示方式，以及数据库中的数据表示方式，我觉得赋值语句也是键值对模型。
2677
2678 16. 配置文件中的版本冲突问题，xml配置文件的文件头最好用低版本的，用高版本的恐怕有的框架包的版本太低，会出现
2679 兼容性问题，而框架的包最好用稳定版本的，这样就不会有兼容冲突的问题出现，一般是高版本框架包的会兼容低版
2680 本的，而底版本的就不会兼容高版本的。
2681
2682 17. 想的越多。。。。
2683
2684 18. 人总在痛苦中挣扎，即怕得到，也怕失去。
2685
2686 19. 智慧的代价是矛盾，这是对人类人行观开的玩笑。
2687
2688 20. 结构化的数据和半结构化的数据以及非结构化的数据：
2689 *结构化的数据指的是数据库里的数据，其实数据库里的数据是按记录一条一条的储存的，一条数据对应一个对象
2690 的实例，数据库里的数据其实就是服务端对象的实例集合，数据的存储方式高级结构化的，是数据的键值对模型。
2691 *半结构化的数据指的就是xml(重量级的数据表示方式),html(超文本)等
2692 *非结构化的数据：这是趋势，例如，全文检索的索引库里的文档的数据
2693
2694 21. 切忌贪念，恨念，不辨是非。
2695
2696 22. 编程的目的就是实现现实世界业务的自动化，以方便生活，或者是提高工作效率。
2697
2698 23. 操作系统有个心脏叫处理器，能够帮你处理很多的工作业务。
2699
2700 24. 字符流和字节流
2701 1. 字符流：就是字符串流，输入字符流：Reader，输出字节流：Writer，这两个输入输出字符流是抽象类，可以
2702 用具体类来扩张，例如：FileReader,FileWriter
2703 2. 字节流：字节流加上标准的编码就是字符串，字节流有输入输出流，输入流：InputStream 输出流：OutputS-
2704 tream，这两个输入输出字节流是抽象类，可以用实现类来扩展,如：FileInputStream,FileOutputStream。
2705 注：*二者区别就是字符流是要用到缓冲区，而字节流是不用缓冲区，至于什么叫缓冲区，可以理解为增加访问效率
2706 特殊内存区域，开发中字节流用的比较多。
2707 *在硬盘中所有的文件都是以字节形式存储的(图片，声音，视频)，而字符值只有在内存中形成。
2708 *其实计算机只认识字节流，字符流就是字节流包装过后的，字符流一般用的地方只有exel文件或者是.txt文
2709 件。
2710 *IO操作是属于资源的操作，用完之后是一定要记得关闭资源。
2711 *对于资源的操作，一般像连接池的连接对象，IO操作等，用完之后一定要记得关闭。
2712
2713 25. 学过web开发的都应该知道浏览器有缓存，所以浏览器请求资源的时候是根据是否有缓存来请求的，当浏览器有缓存的
2714 时候就不向服务器请求资源。
2715
2716
2717
2718
2719 2015/9/11
2720
2721
2722
2723
2724 1. Js中的空串就指的是Null，而在Java中的空串指的是在堆内存中分配了地址的新建的没有塞值的字符串对象，而空白格
2725 就是给字符串对象塞了一个空格符，而null就指的是空指针，意思是只声明了对象，没有在堆内存中新建分配地址，给
2726 对象初始化为null意思是该对象可以引用，在Java中声明对象不赋值默认是null，但是不可以引用该对象，这既是对象
2727 初始化和不初始化的区别。
2728
2729 2. 只有块级元素才可能有布局，以及宽高的设置，行内元素就是为了给内嵌的文本添加样式的，还有内嵌-区块的元素
2730 也是可以有布局以及宽高的设置。
2731
2732 3. 网站的设计基本上是由块级元素合适的布局组成的，网站的内容就是行内元素加上内嵌的文本，图片，再给网站的DOM
2733 元素加上Js特效以及层叠样式表的渲染，一个网页的基本架构就设计好了。
2734
2735 4. 网页的设计中块级元素中设计原则基本上就是大块内嵌小块，小块内嵌行内元素，行内元素内嵌文本内容，或者是图片。
2736
2737 5. 因为数据是有类型的不同的，所以编程中数据是要分类的，因此有了描述数据的数据类型，计算机中描述数据的方式就
2738 是数据的类型+数据的名字。
2739
2740 6. jQuery.fn.extend();表示向jQuery对象中注册一个方法，jQuery.extend();表示向jQuery类中注册一个方法。可以这样
2741 理解，对象方法就像是Java中的普通的公共的子程序，类方法就像是Java中公共的静态的方法。
2742
2743 7. js这门语言很深奥。
2744
2745 8. 当迭代不能解决问题的时候才考虑用递归，因为递归可读性不好，迭代作用就是来操作数组和集合。
2746
2747 9. 学习编程一定要经过实践之后再去看书。
2748
2749 10. 从机器指令(01010..)到机器的低级语言，再到高级语言，是编程语言向自然语言语言靠拢的一个趋势，也就是编程
2750 语言可读性的不断提高，使程序员的编程效率的不断提高。
2751
2752 11. 配置文件是软编码，相比服务端的硬编码，扩展性更高，在配置文件中是随时可更改要初始化的对象的属性值，而服
2753 务端业务逻辑的代码是编译之后是会成为字节码文件，部署到服务端之后是无法更改数据的配置的。
2754
2755 12. 编程的目的就是如何处理现实生活中海量的数据，从而实现工作业务的自动化，生活质量的提高，工作效率的提高。
2756
2757 13. 我感觉写配置文件也是在填表单，就是给要配置的类的属性设置值。不过这里要注意，属性名字千万不要写错了，写错
2758 了就麻烦了，一般在配置文件中的错误是很难找到的。
2759
2760 14. 适当的集中注意力，不能胡思乱想。
2761
2762 15. Notepad++和MyEclipse是由快捷键的冲突的，所以使用时要注意只能二者选其一。
2763
2764 16. 路漫漫兮其修远兮，吾将上下而求索。
2765
2766
2767
2768
2769
2770 2015/9/12
2771
2772
2773
2774
2775 1. 行内标签元素<span>，是没有宽高的，也没有边框，水平方向有内外边距，垂直方向上是没有内外边距的，不能有布局，
2776 除非你设置显示属性display为inline-block;
2777
2778 2. 行内元素怎么变成块级元素：设置display属性为inline-block;块级元素变成行内元素：设置dispaly属性为inline;
2779
2780 3. 行内元素其实就是为了给内嵌的文本添加样式的，如果添加超链接<a>，设置文本的字体大小，颜色，
2781 粗细<span>；
2782 剩下的就是行内——块级元素(inline-block):比如，<input>,<img>,<select>，<textarea>,这些元素是可以设置宽高
2783 ，并且进行布局的。
2784
2785 4. 浮动帧和frameset(框架集)？？
2786 注：<noframes>是用来兼容有些对框架不兼容的浏览器。用法如下，<noframes><body></body></noframes>
2787
2788 5. 前端开发网页的开发步骤：
2789 *1. 搭建网页的结构
2790 *2. 给标签元素命名，比如类(class)的命名(用户给标签元素添加样式，渲染网页)，编号(id)命名(一般用于给标
2791 签元素添加Js特效)
2792 *3. 给网页填内容，图片等
2793 *4. 给网页的样式表塞值
2794 *5. 前端的Js编程
2795
2796 6. 无论发生什么，一定要坚持地走下去。
2797
2798 7. 活一生不能想太多，想多了是会死人的。
2799
2800 8. 行内元素变成inline-block元素(用属性dispay:inline-block)是会产生空白间隙的，去除inline-block的元素之间的4px
2801 空白间距，使用负值的外间距:margin-left=-4\-3px;意思就是元素左位移4\3个像素.
2802
2803 9. IE5.5、6、7、8中元素对inline-block支持不完整，要达到类似的效果，需要先设置为display:inline;然后设置：
2804 zoom:1;就可以达到和display:inline-block;一样的效果。zoom:1;意思就是触发行内元素的布局属性hasLayout.
2805
2806 10. 至于使用浮动布局还是属性值的inline-block，我觉得本质还是一样的，设置浮动布局其实就是把块级元素变成inline
2807 -block元素，只不过行内元素变成inline-block元素之后是会产生空白间隙的。元素使用浮动之后是会脱离文档流的，
2808 有一个叫区块格式化环境(Block Formatting Contexts)的概念,。。
2809 注：使用浮动有一个难点就是如何清除浮动，要不然布局是会乱的。both:clear,left:clear,right:clear;overflow:
2810 hidden;
2811
2812 11. 如何清除浮动：overflow:hidden;这个属性一般用在父级块元素中，而且子块是用了浮动布局的，之后就是可以清除
2813 子块的浮动布局，清除区块格式化的环境，至于为什么原理，有点难理解。溢出隐藏首先是用来在区块中显示内容时
2814 用滚动条显示内容。
2815 注：有的浏览器不兼容该属性，可以设置zoom:1;触发布局hasLayout。
2816
2817 12. 给元素设置浮动就是让元素的变成可以布局的，也就是变成inline-block元素。
2818
2819 13. 伪协议的作用就是在锚标记的超链接中执行Js脚本的函数：其中刷新的作用就是重新发送请求。
2820
2821 14. 写代码一定要记得写注释，可以增加可读性，没有注释的代码，过一段时间之后再阅读就是发现这是不是你自己
2822 写的。
2823
2824 15. 在web项目开发中数据集合的表示方式用列表表示用的比较多。
2825
2826 16. 服务端业务逻辑编程最重要的还是在Service层，因为控制层(Controller)只是调用Service层组装好的数据之后分发
2827 给显示层页面，而DAO层一般都是封装在框架中，封装了对数据库的增删改查操作，Service层直接调用会话工厂
2828 (SessionFactory)中的会话(Session)就可以操纵数据库的数据.所以Service层是处理项目开发中项目业务最重要的一
2829 层。
2830
2831 17. 对于全文检索，有一个索引库建在服务端，一般文档入库的时候，会根据要求分词的字段(比如标题，或者是内容)进行
2832 分词之后成为关键词(这也是以后搜索索引库的根据)，然后建立索引，关联相应的文档。
2833
2834 18. 对于正则表达式还是上网搜，这个不用记，自己写也不太好写，这个可读性太差了，必须有专业的人写。
2835
2836 19. 面向切面编程中，要织入的方法叫通知，要织入的位置叫连接点，所有连接点组成切点，切点和通知组成切面。
2837
2838 20. 对于变量和字符串的连接一般用的是"+"连接符，字符串一般用的是双引号扩起来的，写变量和字符串连接的时候推荐
2839 先写字符串，再向字符串中添加变量，用"+"前后连接即可。
2840
2841 21. 公开演示是向客户展示软件产品的另一宗复查形式。不要指望公开演示能成为提高产品技术质量的灵丹妙药。要改善技
2842 术品质应当依靠详查、走查，或者是代码阅读。
2843
2844 22. 代码质量优劣的衡量：代码的设计、风格、可读性、可维护性以及效率等。
2845
2846 23. Bug都是程序员自己引入的。
2847
2848 24. 想通过更多的测试来改善软件的质量，就跟妄想通过天天称体重来减肥一样。
2849
2850 25. 测试是在程序中找错误，调试在程序中把发现的错误改正。
2851
2852
2853
2854
2855
2856
2857 2015/9/13
2858
2859
2860
2861
2862
2863
2864 1. 客户端(也就是Js编程)utf-8编码字符串方法：encodeURI(str);
2865
2866 2. 多想对身体不好，尽量集中注意力。
2867
2868 3. 鲁棒性指的就是系统的健壮性，反应的是系统的稳定性，比如计算机在输入错误，磁盘故障，网络过载或者有意攻击
2869 情况下，是否不会出现死机，崩溃现象。
2870
2871 4. 编程就是在操作数据，配置文件就是在初始化数据(犹如填表单)，操作数据之前必须要初始化数据，为了信息隐藏，
2872 所以是通过访问器子程序初始化数据，也就是通过接口初始化数据，更新数据，删除数据，防止数据污染，再提供
2873 对数据的外部访问接口，这样外部的对象就可以访问类内部的数据了。
2874
2875 5. 因为接口就是声明的方法集合，也就是一个规范，需要自己去实现，有时可以理解为方法也就是一个接口。
2876
2877 6. 对于Js编程，操作的数据就是元素节点(remove())，节点的属性(attr())，节点的样式表属性(css("display",""))，
2878 或者是节点里内嵌的文本内容(text())，反正操作的就是DOM元素节点，从而实现html文档的显示特效。所以在
2879 操作元素节点之前，必须要选择好要操作的元素节点，这里还是用jQuery选择器更简单，用Js的DOM元素API太繁琐了。
2880
2881 7. 电子公告牌系统：Bulletin Board System ,也就是论坛。
2882
2883 8. 对于编程中的命名方法，在Java中采用的是驼峰命名法，变量和方法都是第一个单词首字母小写，其后的单词首字母
2884 大写而对于类，就是单词的首字母都应大写。
2885 注：
2886 *变量数据，类的命名方法应该按照需求命名，方法应该按照功能命名，就是要表达要做什么，采用动宾结构。至于
2887 类，我看到的代码(java)就是把类型放在后面，比如：StrutsPrepareAndExecuteFilter，这就是一个框架准备和执行
2888 过滤器
2889 *命名一定要以表达含义为首要的任务，类型次之。
2890
2891 9. StrutsPreparedAndExecuteFilter执行加载配置文件，将请求分发，他是FilterDispather的替代版。
2892
2893 10. FilterDispather(后来的版本用StrutsPrepareAndExecuteFilter代替)是整个控制器的核心，就是MVC中控制层的核心
2894
2895 11. Struts2的工作原理：
2896 *1. 客户端初始化一个指向Servlet容器(例如tomcat)的请求。
2897 *2. 这个请求经过一系列的过滤器(Filter)(这些过滤器中有一个叫ActionContextCleanUp的可选过滤器，这个过
2898 滤器对Struts和其他框架的集成很有帮助)
2899 *3. 接着FilterDispather被调用，FilterDiapather询问ActionMappper来决定这个请求是否需要调用某个Action
2900 FilterDispather是整个控制器的核心。
2901 *4. 如果ActionMapper决定需要调用某个Action，FilterDispather把请求的处理交给ActionProxy
2902 *5. ActionProxy通过ConfigurationManager询问框架的配置文件，找到需要调用的Action类，这里，我们一般
2903 是通过struts.xml文件中读取。
2904 *6. ActionProxy创建一个ActionInvocation实例
2905 *7. ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器(Interceptor)的
2906 调用
2907 *8. 把响应结果分发到各个页面终端。
2908 注:
2909 *上述过程中所有的对象(Action，Results,Interceptors)都是通过对象工厂创建(ObjectFactory)的。
2910 *一般是先创建Action，再创建Interceptor.
2911
2912 12. 请求/响应模型，终端/服务端模型，是相对应的，终端就是用来给客户发送请求的，服务端就是处理数据之后响应客
2913 户端的请求的。服务端一般有数据库，和处理数据的服务端业务逻辑程序，以及要给客户显示的资源页面。
2914 注：把开发好的项目部署到服务器上，其实就是把客户端的开发好的东西帮到服务端，只要有网络，就可以请求服务
2915 器端的资源，服务器端也会用处理业务的程序处理客户端提交过来的数据。
2916
2917 13. Struts1和Struts2的比较：
2918 *1. 最明显的区别就是Struts2比Struts1多了拦截器(Interceptor)，值栈(valueStack)，Map(数据存储中心,里面
2919 提供了对valueStack，request,session,application,parameters等作用域对象的映射，获取这些对象都是通
2920 过ActionContext来得到的)，对象图导航语言(ognl)等概念。
2921 *2. 体系结构：是否和Servlet的API解耦，Struts使用了大量的拦截器来处理请求，从而允许业务逻辑控制器与servlet-api分
2922 离，避免了侵入性。
2923 *3. 请求参数封装对比：请求参数Struts2中是用模型驱动(ModelDriven)实现了对象中参数的封装。
2924 *4. 标签的优势：ognl，sturts标签 。
2925 *5. 线程安全：struts2是多例的，因此是线程安全的，每一个请求会产生一个Action，并且请求提交的数据是保存
2926 在各个每个Action的数据中心，是相互独立的。
2927 *6. 性能方面：Struts2没有容器依赖性，不依赖Servlet的API，测试无需依赖web容器。
2928
2929 14. 只有深入才有浅出。所以你的任务就是实践实践再实践，工作工作再工作，深入深入再深入。不要基于一种语言
2930 编程，而是要深入一种语言去编程。
2931
2932 15. 过滤器(Filter)其实就是特殊的Servlet(控制器)：创建一个过滤器要实现Filter接口，并且覆写doFilter()方法，
2933 这个方法也是要依赖Servlet的API的，具体的说就是要依赖请求对象(HttpServletRequest)和响应对象(HttpServ-
2934 letResponse),之后通过这两个依赖的对象操作数据。
2935
2936 16. 编程中为了能够处理数据一定要建立依赖，不管是依赖数据对象，还是依赖要操作数据的对象。处理数据就是通过
2937 判断，循环，或者是顺序语句实现的，当代码多了之后(超过20行)就是告诉你要重构了，增加代码的可读性是程序
2938 员的首要责任(记住不要随意引入bug)，因为可读性直接影响到项目的后期维护。
2939
2940 17. Js(Javascript)中有五种基本的数据类型：Undefined String Number Null Boolean，Js编程中数据类型中字符串类型用的最多。
2941
2942 18. 怎么搭建框架(ssh:Hibernate3.6+Spring2.5+Struts2.1.8):
2943 *1. 导包
2944 >1. Hibernate3.6
2945 *1. 核心包：hibernate3.jar
2946 *2. 必须要的包：在required文件夹下
2947 >1. 语言识别的其他工具，解析hql语句用的：antlr-2.7.6.jar
2948 >2. 通用的操作集合的包，这个是Apache组织的：commons-collections-3.1.jar
2949 >3. 操作xml文件的包：dom4j-1.6.1.jar
2950 >4. 操作字节码的包：javassist-3.12.0.GA.jar
2951 >5. 用到事务时要使用的包：jta-1.1.jar
2952 >6. 做日志用的包，这里用Spring开发包中提供的slf4j做日志：
2953 *slf4j-api-1.5.0.jar
2954 *slf4j-log4j12-1.5.0.jar
2955 *3. 支持jpa(Java持久化规范的包)，在jpa文件夹下：hibernate-jpa-2.0-api-1.0.0.Final.jar
2956
2957 *4. 组合连接池：c3p0-0.9.1.jar
2958 >2. Spring2.5:在开发文档的lib目录下
2959 *1. dist文件夹下的,Spring核心包：spring.jar
2960 *2. aspectj文件夹下的：AOP(面向切面编程)要用的：
2961 >aspectjrt.jar
2962 >aspectjweaver.jar
2963 *3. cglib文件夹下的，动态代理包：cglib-nodep-2.1_3.jar
2964 *4. jakarta-commons文件夹下的，日志包：commons-logging.jar
2965 *5. jakarta-commons文件夹下的，通用工具jar包，在：
2966 >commons-codec.jar：做md5加密用的
2967 >commons-lang.jar：包含了一些数据类型工具类
2968 >commons-fileupload.jar:文件上传
2969 >commons-io.jar: 输入输出数据流的读写功能
2970 >3. Struts2.1.8:
2971 注：
2972 *导这个框架包最简单了，就是可以在struts2-blank-2.1.8.1.war中解压之后就可以找到
2973 lib库中的包导入即可.
2974 *再导入和Spring框架整合的包：struts2-spring-plugin-2.1.8.1.jar
2975
2976 >4. 数据库的驱动包：例如如果是MySQL的话：mysql-connector-java-5.1.7-bin.jar
2977 注：
2978 *导包切忌包的版本冲突或者是漏掉某些包没有导入。
2979 *要用到json数据时要导入到包：struts2-json-plugin-2.3.4.1.jar
2980
2981 *2. 配置
2982 >1. hibernate配置：配置文件hibernate.cfg.xml
2983 <?xml version="1.0" encoding="utf-8"?>
2984 <!DOCTYPE ...>
2985 <hibernate-configuration>
2986 <session-factory>
2987
2988 <!--数据库配置信息-->
2989 <property name="connection.url" value=""/>
2990 <property name="connection.driver_class" value=""/>
2991 <property name="connection.username" value=""/>
2992 <property name="connection.password" value=""/>
2993 <property name="connection.Dialect" value=""/>
2994
2995 <!--数据库连接池配置-->
2996 <property name="c3p0.initialPoolSize" value=""/>
2997 <property name="c3p0.minPoolSize" value=""/>
2998 <property name="c3p0.maxPoolSize" value=""/>
2999 <property name="c3p0.CheckoutTimeout" value=""/>
3000 ...
3001
3002 <!--一般的属性，比如是否显示sql语句，是否可以从hibernate映射文件到数据库表的关联-->
3003 <property name="show_sql" >true</property>
3004 <property name="hbm2ddl.auto" >update</property>
3005
3006 <!--导入hibernate映射文件-->
3007 <mapping resource="" />
3008
3009 <!--二级缓存的配置，可选-->
3010 <property name="hibernate.cache.use_second_level_cache" >true</property>
3011 <property name="hibernate.cache.provider_class" ></property>
3012 <class-cache usage="" class=""/>
3013 <class-cache usage="" class=""/>
3014 </session-factory>
3015 </hibernate-configuration>
3016 >2. Spring配置
3017 <?xml version="1.0" encoding="utf-8" ?>
3018 <!--这里的头文件要注意别导错了，用到的就需要导入，建议应开发工具导入或者是直接从
3019 开发包中导入文件头,包括beans(JavaBean对象)，tx(事务)，context，aop头文件
3020 -->
3021 <beans ...>
3022
3023 <!--使用注解扫描-->
3024 <context:component-scan base-package=""></context:component-scan>
3025
3026 <!--配置SessionFactory
3027 实现类为：LocalSessionFactoryBean
3028 -->
3029 <bean id="" class="">
3030 <property name="" value=""/>
3031 </bean>
3032
3033 <!--配置事务管理器TransactionManager
3034 实现类为：HiberanteTransactionManager
3035 -->
3036 <bean id="" class="">
3037 <property name="" ref=""/>
3038 </bean>
3039
3040 <!--配置事务注解驱动-->
3041 <tx:annotation-driven transaction-manager=""/>
3042 </beans>
3043 >3. Struts配置：
3044 <?xml version="1.0" encoding="utf-8" ?>
3045 <!DOCTYPE...>
3046 <struts>
3047 <!--配置为开发模式-->
3048 <constant name="" value="" />
3049 <!--配置页面的显示主题-->
3050 <constant name="" value="" />
3051 <!--配置行为的扩展名，也可以不配置，默认为.action-->
3052 <constant name="" value="" />
3053
3054 <!--配置装载行为或者是拦截器的包
3055 其中名字属性name就是用来继承的
3056 -->
3057 <package name="" namespace="/" extends="struts-default">
3058
3059 <!--配置拦截器-->
3060 <interceptors>
3061 <!--声明一个拦截器-->
3062 <interceptor name="" class=""></interceptor>
3063
3064 <!--配置自定义默认拦截器栈-->
3065 <interceptor-stack name="defaultStack">
3066 <interceptor-ref name="" ></interceptor-ref>
3067 <interceptor-ref name="" ></interceptor-ref>
3068 </interceptor-stack>
3069 </interceptors>
3070
3071 <!--配置行为-->
3072 <action name="" class="" method="">
3073 <result name=""></result>
3074 </action>
3075 </package>
3076 </struts>
3077 注：对于到底是使用单标签，还是双标签？？
3078
3079 *3. 使用(测试)
3080
3081 >1. Spring测试
3082 //测试类：SpringTest
3083 public class SpringTest{
3084 //1. 依赖应用程序环境：ApplicationContext，来获取Spring工厂中的对象bean
3085 //2. 测试会话工厂SessionFactory
3086 //3. 测试事务Transaction
3087 }
3088 >2. Struts测试
3089 //测试类：ActionTest
3090 public class ActionTest extends ActionSupport{
3091
3092 //依赖Spring对象工厂中的测试service,类：ServiceTest
3093
3094 //测试执行中转数据的方法，默认的方法为execute
3095 @Override
3096 public String execute(){
3097 //依赖ServiceTest操作数据
3098 }
3099 }
3100 >3. 操作数据要依赖的Service，测试类：ServiceTest
3101 public class ServiceTest{
3102 //依赖会话工厂SessionFactory
3103
3104 //操作数据的方法，例如：saveUsers
3105 public void saveUsers(){
3106
3107 }
3108 }
3109
3110 注：
3111 *这三个框架的整合，其实Spring框架就是其他两个框架的粘合剂，在Spring对象工厂中管理着Hibernate
3112 框架的会话工厂和事务管理器的创建，以及管理着Struts框架中的行为Action的创建。
3113 *至于是否使用注解还是用xml配置文件，注解简单是趋势，但是有的地方还是要用到xml配置文件的。所以
3114 这两个要配合着使用。
3115
3116
3117
3118
3119
3120 2015/9/14
3121
3122
3123
3124
3125 1. web开发中外网的项目有分前台和后台之分，前台一般就像是终端，就是用来显示数据或者是向服务器请求资源时提交
3126 参数数据用的。而后台一般是管理员管理数据的系统
3127
3128 2. 前端向服务器发送请求之后，控制层要做的就是如何调用Service层准备数据，或者是封装前端提交过来的参数数据经过
3129 Service层再通过DAO层或者是hibernate框架向数据库中入库或者是出库数据。
3130 注：数据库要做的就是如何流入流出数据。
3131
3132 3. web.xml文件中的配置对象加载顺序为：创建控制器环境，也就是服务器(ServletContext)->context-param(环境参数)->
3133 listener(监听器)->filter(过滤器)->Servlet(控制器)
3134 注：这个加载顺序和配置文件的中配置的对象的顺序是无关的，但是一定要先配置对象，再来配置对象的映射，也就是说
3135 要先声明对象，再来使用。
3136
3137 4. 连接池的作用：
3138 *1. 减少连接的创建时间
3139 *2. 简化编程模式
3140 *3. 控制资源的使用
3141 配置：
3142 在hibernate.cfg.xml文件中配置见上一天中的配置
3143
3144 5. 全文检索的使用，例子：实现一个小的商城的全文检索系统。
3145 注：实现原理，首先要在服务器端建立索引库，因为这是存放非结构化数据document的数据库，文档入库的时候
3146 根据要分词的字段(field)用分词器分词，之后建立索引，关联相应的文档。
3147 *1. 导包：lucene要用的包:用的是lucene3.0
3148
3149 >1. 核心包：lucene-core-3.0.0.jar
3150
3151 >2. 检索时高亮关键词要用的包：lucene-highlighter-3.0.0.jar
3152
3153 >3. 中文分词器要用的包: IKAnalyzer3.2.8.jar
3154
3155 >4. 标准分词器要用的包: lucene-analyzers-3.0.0.jar
3156
3157 >5. 内存？？lucene-memory-3.0.0.jar
3158
3159 *2. 工具类：
3160 注：
3161 *工具类做可以成像业务逻辑类一样，在Spring的配置文件中需要配置。
3162 *开发步骤为：
3163 >1. 创建类
3164 >2. 创建方法
3165 >3. 配置工具类
3166 >4. 声明service类在Action中
3167
3168 //工具类1：全文检索的配置类:Configuration
3169 public class Configuration{
3170
3171 //全局依赖，分词器
3172 private Analyzer analyzer;
3173 //索引库地址,在Spring配置文件中配置好了
3174 private String dirPath;
3175 public void setDirPath(String dirPath){
3176 this.dirPath=dirPath;
3177 }
3178 //索引库
3179 private Directory directory;
3180
3181
3182 //初始化索引库，分词器为中文分词器,相当于setter，这个方法可以在Spring配置文件中配置
3183 //之后，就相当于一个类的构造函数，用于在类加载实例化的时候初始化数据
3184 public void init(){
3185 try{
3186 //分词器初始化中文分词器
3187 analyzer=new IKAnalyzer(true);
3188 //初始化索引库指定的文件夹库
3189 directory=FSDirectory.open(new File(dirPath));
3190 }cath(Exception e){
3191 throw new RuntimeException(e);
3192 }
3193 }
3194
3195 //提供分词器，以及索引库供外部访问的接口
3196 public Analyzer getAnalyzer(){
3197 return analyzer;
3198 }
3199
3200 public Directory getDirectory(){
3201 return directory;
3202 }
3203
3204 }
3205 //工具类2. 文档工具类：DocumentUtil，提供要操作的实体对象到文档对象的访问
3206 public class DocumentUtil{
3207 //实体对象到文档对象的转换，输入要转换的实体对象，输出转换之后的文档对象
3208 public Document XxxToDocument(Xxx xxx){
3209
3210 //新建文档对象
3211 Document document=new Document();
3212
3213 //实现实体对象到文档对象的转换，并确定哪个字段需要分词之后入库
3214 //是否入库：Store.YES/NO,Index.ANALYZED/NO/NOT_ANALYZED是否分词，是否
3215 //建立索引之后就可以用该字段检索，如果不分词，就不会按照关键词检索，因为
3216 //分词之后就成了一个一个关键词了。
3217 document.add(...);
3218
3219 return document;
3220 }
3221 //文档对象到实体对象的转换，输入要转换的文档对象，输出转换之后的实体对象
3222 public Xxx DocumnetToXxx(Document doc){
3223 //新建实体对象
3224
3225 //封装文档对象中的属性值到实体对象
3226
3227 //返回转换之后的实体对象
3228 return ...;
3229 }
3230
3231 }
3232 //工具类3. 全文检索工具类: LuceneUtil
3233 public class LuceneUtil{
3234
3235 //建立依赖：1. 配置对象：configuration，配置了分词器，索引库
3236 private Configuration configuration;
3237 public void setConfiguration(Cofiguration configuration){
3238 this.configuration=configuration;
3239 }
3240 //依赖2. 索引库写入器：indexWriter，向索引库入库文档用的.
3241 private IndexWriter indexWriter;
3242 //依赖3. 索引库阅读器：indexReader，获取查询关键词用的.
3243 private IndexReader indexReader;
3244 //依赖4. 索引库查询器：indexSearcher,从索引库查询文档.
3245 private IndexSearcher indexSearcher;
3246
3247 //1. 初始化索引写入器,构造Setter接口
3248 public void init(){
3249 //这里会有编译时异常，必须进行捕获处理转化为运行时异常。
3250 try{
3251 //新建索引库查询器，局部依赖为索引库，中文分词器，最大字
3252 //段长度为有限制的
3253 indexWriter=new IndexWriter(configuration.getDirectory(),
3254 configuration.getAnalyzer(),MaxFieldLength.LIMITED);
3255 }catch(Exception e){
3256 throw new RuntimeException(e);
3257 }
3258
3259 }
3260
3261 //提供一个供外部访问索引写入器的接口
3262 public IndexWriter getIndexWriter(){
3263 //每次获取索引写入器都要求关闭先前创建的索引阅读器，索引查询器，因为他们是
3264 //相互关联的
3265 //关闭索引查询器
3266 closeIndexSearcher(indexSearcher);
3267 indexSearcher=null;
3268 //关闭所以阅读器
3269 closeIndexReader(indexReader);
3270 indexReader=null;
3271 //返回索引写入器对象
3272 return indexWriter;
3273 }
3274
3275 /**
3276 *删除索引库写入器，局部依赖为要删除的索引库写入器
3277 *注：可以理解这些对象都是系统的资源，用完之后是要关闭归还给系统的，就像数据库的
3278 *连接对象connection，会话statement,结果集ResultSet用完之后是要关闭释放资源的
3279 */
3280 public closeIndexWiter(IndexWriter indexWriter){
3281
3282 //关闭之前先做个非空判断
3283 if(indexWriter!=null){
3284 //优化关键词，优化索引
3285 indexWriter.optimize();
3286 //关闭索引库写入器
3287 indexWriter.close();
3288 }
3289
3290 }
3291
3292 //再提供一个销毁索引写入器的方法destroy,用于在对象销毁的时候关闭资源时使用
3293 public void destroy(){
3294 //调用关闭索引写入器的方法关闭销毁索引写入器
3295 closeIndexWriter(indexWriter);
3296 }
3297
3298 //2. 提供一个供外部访问索引查询器的方法接口，并且同时在方法中提供对索引查询器的初始化
3299 public IndexSearcher getIndexSearcher(){
3300 //因为要做成单例的，防止在多线程高并发的情况下生成多个查询器实体，需要同步
3301 //该代码块，并进行两次的非空判断，有的时候非空判断可以理解为过滤对象是否空
3302 //的一个过滤器。
3303 //一般创建对象的时候要用的依赖为文件io流的时候，都会有异常需要捕获
3304 if(indexSearcher==null){
3305 synchronized(this){
3306 if(indexSearcher==null){
3307 try{
3308 indexSearcher=new IndexSearcher(Configuration.getDirectory());
3309
3310 }catch(Exception e){
3311 throw new RuntimeException(e);
3312 }
3313
3314 }
3315
3316 }
3317
3318 }
3319
3320
3321 }
3322
3323 //提供一个关闭索引查询器的方法接口
3324 public void closeIndexSearcher(IndexSearcher indexSearcher){
3325 //需要进行非空判断过滤空的索引查询器依赖
3326 if(indexSearcher!=null){
3327 //需要捕获异常
3328 try{
3329 indexSearcher.close();
3330 }catch(Exception e){
3331 throw new RuntimeException(e);
3332 }
3333
3334 }
3335
3336 }
3337
3338 //3. 提供一个供外部访问索引阅读器的方法接口，并且同时在方法中提供对索引阅读器的初始化
3339 public IndexReader getIndexReader(){
3340 //原理和上一个方法getIndexSearcher()一样
3341 if(indexReader==null){
3342 synchronized(this){
3343 if(indexReader==null){
3344 try{
3345 indexReader=IndexReader.open(Configuaration.getDirectory());
3346 }catch(Exception e){
3347 throw new RuntimeException(e);
3348
3349 }
3350 }
3351 }
3352 }
3353 }
3354
3355 //提供一个关闭索引阅读器的方法接口
3356 public void closeIndexReader(IndexReader indexReader){
3357
3358 //需要进行非空判断过滤空的索引阅读器依赖
3359 if(indexReader!=null){
3360 //需要捕获异常
3361 try{
3362 indexReader.close();
3363 }catch(Exception e){
3364 throw new RuntimeException(e);
3365 }
3366
3367 }
3368
3369 }
3370 }
3371
3372 //工具类3. 关键词高亮类：HighLightUtil
3373 public class HighligthUtil{
3374 //注入2个依赖
3375 //依赖1：配置对象configuration
3376 private Configuration configuration;
3377 public void setConfiguration(Configuration configuration){
3378 this.configuration=configuration;
3379 }
3380 //依赖2：高亮用的格式化器formatter
3381 private Formatter formatter;
3382 //在构造函数中初始化格式化器对象
3383 pubic HighlightUtil(){
3384 formatter=new SimpleHTMLFormatter("<font color='red'>","</font>");
3385 }
3386
3387 //提供一个高亮所选字段文本中关键字的的接口，局部依赖参数为
3388 //局部依赖1：查询对象query
3389 //局部依赖2：要高亮的字段的文本fieldText
3390 //局部依赖3：高亮字段的文本之后显示在客户端页面的字段文本大小限制textSizeLimit
3391 //返回值为：高亮之后的字段文本内容fieldTextResult
3392 public String getHighlightText(Query query,String fieldText,int textSizeLimit){
3393
3394 //在方法内部提供2个依赖
3395 //依赖1：段得分器fragmentScorer,就是要高亮的关键词对象
3396 FragmentScorer fragmentScorer=new FragmentScorer(query);
3397 //依赖2：高亮器highLighter,创建高亮器的时候需要两个参数依赖就是段得分器
3398 //(需要高亮的关键词对象)fragmentScorer和格式化器formatter
3399 HighLighter highlighter=new Highlighter(formatter,fragmentScorer);
3400 highlighter.setTextFragmenter(newSimpleFragment(textSizeLimit));
3401 //依赖3；需要返回的字段文本结果fieldTextResult
3402 String fieldTextResult=null;
3403
3404 //这里会有异常，需要捕获
3405 try{
3406 //获取高亮之后的字段文本部分
3407 fieldTextResult=highlighter.getBestFragment(Configuration.getAnalyzer(),null,fieldText);
3408 //如果高亮字段文本的值为空值
3409 if(fieldTextResult==null){
3410 //如果要高亮的文本内容大小超过规定的限制textSizeLimit，对需要返回的字段文本
3411 //进行截取
3412 if(fieldText.length()>textSizeLimit){
3413 fieldTextResult=fieldText.subString(0,textSizeLimit);
3414 }else{
3415 fieldTextResult=fieldText;
3416 }
3417 }
3418 }catch(Exception e){
3419 throw new RutimeException(e);
3420 }
3421
3422 return fieldTestResult;
3423 }
3424
3425 }
3426 *3. 使用：
3427 >1. 构建服务类LuceneServiceImpl
3428 代码：
3429 public class LuceneServiceImpl{
3430 //注入3个依赖对象
3431 //依赖1：文档工具类DocumentUtil,用于实体对象和文档对象的相互转换
3432 private DocumentUtil documentUtil=null;
3433 public void setDocumentUtil(DocumentUtil documentUtil){
3434 this.documentUtil=documentUtil;
3435 }
3436
3437 //依赖2：全文检索工具类LuceneUtil，用于提供索引写入器indexWriter,索引查询器indexSearcher
3438 private LuceneUtil luceneUtil=null;
3439 public void setLuceneUtil(LuceneUtil luceneUtil){
3440 this.luceneUtil=luceneUtil
3441 }
3442 //索引阅读器indexReader的访问接口
3443 //依赖3：用户高亮文本的工具类HighlighterUtil
3444 private HighlighterUtil highlighterUtil=null;
3445 public void setHighlighterUtil(HighlighterUtil highlighterUtil){
3446 this.highlighterUtil=highlighterUtil;
3447 }
3448
3449 //提供两个查询方法，就是从索引库中出库数据
3450 //方法1：根据查询字符串获取索引库中能够匹配的关键词集合
3451 //实体对象关键词KeyWord包含两个属性：关键词的文本内容word和包含该关键词的文档
3452 //数量count
3453 public List<KeyWord> getTermsByKey(String q){
3454
3455 //创建局部依赖
3456 //局部依赖1：索引器
3457 IndexReader indexReader=luceneUtil.getIndexReader();
3458 //局部依赖2：新建一个关键词集合用于存放和查询字符串匹配的关键词
3459 List<KeyWord> keyWordList=new ArrayList<KeyWord>();
3460
3461 //有编译时异常需要捕获
3462 try{
3463 //局部依赖3：关键词集合的枚举器termEnum
3464 TermEnum termEnum=indexReader.terms();
3465
3466 //用while循环操作遍历关键词
3467 while(termEnum.next()){
3468 //局部依赖4：用关键词枚举器遍历获取索引库中的关键词集合中的关键词term
3469 Term term=termEnum.term();
3470 //把查询字符串和索引库中的关键词进行匹配
3471 if(Pattern.matches(q+"(\\w|[\4E00-\u9FA5])*",term.text())){
3472 //如果模糊能够匹配前面的字符串，就添加到关键词集合中
3473 //新建一个自定义关键词对象封装关键词word和出现该关键词的文档数量count
3474 KeyWord keyWord=new KeyWord();
3475 keyWord.setWord(term.text());
3476 keyWord.setCount(termEnum.docFreq());
3477
3478 keyWordList.add(keyWord);
3479 }
3480 }
3481 }catch(Exception e){
3482 throw new RuntimeException(e);
3483 }
3484
3485
3486 //返回能够匹配的关键词集合
3487 reurn keyWordList;
3488
3489
3490 }
3491 //方法2：根据查询字符串获取包含该关键词的文档的集合
3492 public List<Xxx> queryByKey(String queryStr){
3493
3494 //局部依赖1：新建一个集合用于存储要返回的文档对象集合xxxList
3495 List<Xxx> xxxList=new ArrayList<Xxx>();
3496
3497 //捕获抛出的异常
3498 try{
3499 //局部依赖2：索引库查询器indexSearcher
3500 IndexSearcher indexSearcher=LuceneUtil.getIndexSearcher();
3501 //局部依赖3：构建查询对象query
3502 Query query=IKQueryParser.parseMultiField(new String[]{"字段1","字段2"},queryStr);
3503 //局部依赖4：获取符合条件的总记录数topDocs
3504 //这里设置为查询满足结果的前100条记录
3505 TopDocs topDocs=indexSearcher.search(query,100);
3506 //局部依赖5：获取符合条件的文档索引数组scoreDocs
3507 ScoreDoc[] scoreDocs=topDocs.scoreDocs;
3508
3509 //用循环遍历文档索引数组
3510 for(int i=0;i<scoreDocs.length;i++){
3511 //局部依赖6：获取符合条件的文档索引对象
3512 ScoreDoc soreDoc=scoreDocs[i];
3513 //局部依赖7：获取符合条件的文档document
3514 Document documnet=indexSearcher.doc(scoreDoc.doc);
3515 //对要高亮的字段进行高亮
3516 document.getField("字段1")//
3517 .setValue(highlightUtil.getHighlightText(query,document.getXxx("字段1"),textSizeLimit));
3518
3519 //把符合条件的文档加入到集合xxxList中
3520 XxxList.add(documentUtil.documentToXxx(document));
3521 }
3522
3523
3524 }catch(Exception e){
3525 throw new RuntimeException(e);
3526 }
3527
3528 //返回包含该关键词的文档对象的集合
3529 return XxxList;
3530 }
3531
3532 //提供三个向索引库中入库数据的方法
3533 //方法1：向索引库中入库数据文档对象
3534 public void save(Xxx xxx){
3535 //对抛出的异常进行捕获
3536 try{
3537 //注入一个局部依赖：indexWriter
3538 IndexWriter indexWriter=luceneUtil.getIndexWriter();
3539 indexWriter.addDocument(DocumentUtil.XxxToDocument(xxx));
3540 indexWriter.commit();
3541 }catch(Exception e){
3542 throw new RuntimeExeption(e);
3543 }
3544
3545 }
3546 //方法2：向索引库中更新数据文档对象
3547 public void update(Xxx xx){
3548 //对抛出的异常进行捕获
3549 try{
3550 //注入一个局部依赖：indexWriter
3551 IndexWriter indexWriter=luceneUtil.getIndexWriter();
3552 indexWriter.updateDocument(new Term("id字段",id字段值.toString()),DocumentUtil.XxxToDocument(xxx));
3553 indexWriter.commit();
3554 }catch(Exception e){
3555 throw new RuntimeExeption(e);
3556 }
3557 }
3558 //方法3：向索引库中删除数据文档对象
3559 public void delete(int id){
3560 //对抛出的异常进行捕获
3561 try{
3562 //注入一个局部依赖：indexWriter
3563 IndexWriter indexWriter=luceneUtil.getIndexWriter();
3564 indexWriter.deleteDocument(new Term("id字段",id字段值.toString()),DocumentUtil.XxxToDocument(xxx));
3565 indexWriter.commit();
3566 }catch(Exception e){
3567 throw new RuntimeExeption(e);
3568 }
3569 }
3570
3571 //提供3个通知，用于在操作管理员在入库(增save，删delete，改update)数据流到数据
3572 //库的时候自动的把数据流同时流向服务器的索引库,需要在配置文件中配置切面和通知
3573 //这里要用到通知的一个局部依赖参数：连接点joinPoint获取要被织入的方法的参数
3574 public void save(JoinPiont joinPoint){
3575 this.save((Xxx)joinPoint.getArgs[0]);
3576 }
3577 public void update(JoinPiont joinPoint){
3578 this.update((Xxx)joinPoint.getArgs[0]);
3579 }
3580 public void delete(JoinPiont joinPoint){
3581 this.delete((Xxx)joinPoint.getArgs[0]);
3582 }
3583
3584 }
3585 >2. 在动作Action中注入服务类依赖luceneServiceImpl
3586 示例代码：
3587 public class XxxAction extends ActionSupport{
3588
3589 //注入全局依赖1：全文检索服务luceneServiceImpl
3590 private LuceneServiceImpl luceneServiceImpl;
3591 public void setLuceneServiceUtil(LuceneServiceImpl luceneServiceImpl){
3592 this.luceneServiceImpl=luceneServiceImpl;
3593 }
3594 //注入全局依赖2：前台传递过来的查询字符串q(这个是自动补全插件默认的)
3595 private String q;
3596 public void setQ(String q){
3597 this.q=q;
3598 }
3599 public String getQ(){
3600 return q;
3601 }
3602
3603 //自动补全的方法autocomplete
3604 public String autocomplete(){
3605
3606 return "autocomplete";
3607 }
3608
3609 //全文检索的方法查询Query
3610 public String query(){
3611
3612 retrun "query";
3613 }
3614
3615 }
3616
3617 注：
3618 *省略了对这些工具类配置。
3619 *同一个索引库只能有一个索引库写入器
3620 (IndexWriter),索引库查询器(IndexSearcher)，索引库阅读器(IndexReader,用于获取索引库的关键词)，所以
3621 要做成单例的。
3622
3623 6. 要明白接口和实现类的关系，定义接口就是为了扩展的，而且耦合度低，比抽象类减少了依赖，很干净。
3624
3625 7. 向上转型和向下转型，以及多态都是为了扩展性。
3626
3627 8. 定义方法是中的局部依赖参数时，一般是以输入参数数据，要修改的参数数据，输出参数数据顺序定义，最好不要超过
3628 5个参数。
3629
3630 9. 对于空指针异常，是项目中经常遇到的错误，一般是对象为空或者是？？
3631
3632 10. 过滤器过滤客户端对一般的资源文件的请求，拦截器一般拦截对行为Action的的请求。
3633
3634 11. 要操作数据，一定要建立依赖。
3635
3636 12. 写代码的时候一定要记得对变量的非空判断。
3637
3638 13. 操作数据无非就是三种情况
3639 *setter：初始化数据对象，也可以理解为入库。
3640 *getter：提供外部对象访问该数据对象的访问接口。
3641 *delete：删除该对象，可以理解为从库中删除对象。
3642
3643
3644
3645
3646
3647 2015/9/15
3648
3649
3650
3651
3652
3653 1. 对于抛出来的异常，一定要及时处理，把编译时异常转化为运行时异常，异常抛多了不处理会破坏代码结构。其实抛出一个
3654 异常就是声明一个变量对象一样，如果不处理就是等于不初始化，那样的变量是很危险的，只不过异常抛出是在方法的被
3655 调用方，有点像继承，会增加耦合度。
3656
3657 2. 类内部的一个数据依赖对象一般是在类内部塞值(setter方法)，再在类内部提供供外部对象访问类内部数据的接口getter
3658 基本上好多的类都像一个JavaBean。
3659
3660 3. lunece3.5中使用indexWriter.forceMerge(1)来优化索引，即lucene3.5中使用indexWriter.forceMerge(1)来替换
3661 optimize()。
3662
3663 4. lucene框架中的关联方式是：关键词->索引->文档对象。
3664
3665 5. 对于循环的作用就是用来操作数组和数据集合的，到底使用while循环还是用for循环(在Java中增强for循环用的最多)
3666 用for循环简洁，可以减小索引变量的作用域，可以减少出错，对于while循环用的比较少，处理业务数据较多的时候
3667 可以使用。
3668
3669 6. 对于配置，可以理解为填表单就更简单了。
3670
3671 7. 把你所想到的说出来是一种能力，能写出来又是一种能力。
3672
3673 8. 各种协议：作用就是制定一种传输数据的规范，也可以理解为一种服务
3674 *tcp/ip协议：传输控制协议，传输的数据类型是数据包 ？？
3675 *http超文本传输协议，传输的数据类型是html(超文本)：80端口
3676 *ftp文件传输协议，传输的数据类型是文件：21端口
3677 *soap简单对象访问协议：有关webservice的数据？？
3678
3679 9. 回退只是浏览器返回上一个页面，并不会和服务器产生交互。
3680
3681 10. jsp(Java Service Page)页面中在域对象查找数据的顺序是page->requestScope->sessionScope->applicationScope
3682
3683 11. web服务器端的开发都离不开对数据的操作
3684 *增(save)：
3685 >1. 一般用框架的话，用模型驱动对客户端的表单数据进行封装成数据实体对象，之后入库就行了.
3686 >2. 这里涉及到有的属性是关联关系的属性设置，如果要在页面有显示关联关系数据的话，就是在服
3687 务器控制端设置要入库对象的关联关系属性，其实关联关系属性就是可理解为大对象数据。
3688 >3. 伪代码：
3689
3690 //设置对象的关联关系属性
3691 ...
3692 //向数据库入库前端表单提交的数据
3693 XxxService.save(model);
3694 *删(delete)：
3695 >1. 伪代码：
3696 //根据前端提交过来的编号数据删除相应的对象
3697 XxxService.delete(id);
3698
3699 *改(update/edit)：
3700 >1. 伪代码
3701 //向数据库端更新关联关系属性
3702 ...
3703 //向数据库端更新提交过来的表单数据
3704 XxxService.update(model);
3705 *查(list)：
3706 >1. 伪代码：
3707 //向域对象中存放准备好的数据。
3708 注：
3709 *model指的就是用模型驱动封装数据对象之后的数据对象模型。
3710 *更新和向数据库中添加数据的最大区别就是根据数据库中是否有给入库的数据对象分配编号，没有的话就是
3711 向数据库入库数据，由于的话就是向数据库中插入数据。
3712
3713 12. 熟悉(了解原理)->掌握(至少在1个项目中用到)->熟练掌握(至少在3个项目中用到)
3714
3715 13. web开发中外网的系统一般都有前台后台之分，内网的系统一般就是只有后台的管理系统。
3716
3717
3718
3719
3720
3721
3722 2015/9/16
3723
3724
3725
3726
3727
3728 1. 可以尽量控制数据变量的作用域，不要随意扩大数据变量依赖的作用范围，这样可以解耦，减少数据污染，减少依赖。
3729
3730 2. 要建立数据通信，必须要有依赖，但是依赖多了，耦合度就会增加，所以建议使用接口，不使用继承，程序也要独立
3731 才更好的维护，扩展。意思就是依赖接口操作数据对象。
3732
3733 3. 编程开发涉及到的根本就是对数据的流入流出，在客户端流入流出数据，在服务端业务逻辑处理数据，在数据库端入
3734 库出库数据。软件开发就是要掌握数据的流向，数据就是现实世界建模之后虚拟的数据模型。
3735
3736 4. web开发趋势：
3737 *大数据云计算
3738 *便携式可穿戴式设备移动终端
3739 *物联网
3740 *车联网
3741 *智能家居
3742
3743 5. 服务器的作用就是处理数据用的。
3744
3745 6. 首先把每一个变量设置为局局的，仅当需要时才把变量设置为全局的。--《代码大全》
3746
3747 7. 不要直接访问类变量-好像他们是全局变量一样-即便你的编程语言允许你这么做。这一建议等价于高呼：
3748 “模块化！模块化！模块化！” --《代码大全》
3749
3750 8. 变量：作用域从小到大
3751 *循环变量
3752 *类私有变量(类的实例变量，类的实例变量只能是通过访问器子程序访问类的私有变量)
3753 *类保护的变量(作用域可以扩大到子类，类的实例变量也是只能通过访问器子程序访问该变量)
3754 *类变量：类的静态变量(只是属于类所有，类加载时初始化)
3755 *全局变量(尽量少用)
3756
3757
3758
3759
3760
3761 2015/9/17
3762
3763
3764
3765
3766
3767 1. 复习笔试
3768
3769 2. 对于函数方法是否要有返回值的问题，要看函数方法的调用方是否是直接处理数据还是要利用处理过后的数据初始化一个
3770 数据变量，像有些方法比如save(entity)(注：本质就是setter方法)，就是返回值为void的方法，利用hibernate框架的
3771 用户会话的工厂创建的会话(session)直接向数据库中入库数据，并不需要任何的返回值来给其他变量的对象塞值，同理
3772 像什么getter之类的供外部访问类内数据对象的接口就必须要有返回值。
3773
3774 3. 对于在线测试，其实就是在写测试方法，考察的基本上是最基础的编程思维逻辑，以及最基本的API调用
3775 注：这里有一个叫做输入输出的方法，各种编程语言的API不一样，但是原理都是差不多的，都是模拟
3776 项目中的客户端的输入数据端->输入
3777 >java:System.in
3778 >C++:cin(C++很喜欢用操作符，实际上更抽象，降低可读性，所以在Java中操作方法用的更多)
3779 >C:scanf()
3780 项目中的客户端显示数据->输出
3781 >java:单元System.out
3782 项目中的控制器->main方法(调用函数的入口，即主线程)
3783 注：对于单元测试，和主方法的测试的最大区别就是main方法是主线程，而测试时用户的线程。
3784 项目中的数据服务层->那就是各种方法
3785 项目中的数据库->可以用映射(Map)模拟
3786 *日期Date,Calendar
3787 *字符串String
3788
3789 4. 对于项目开发中是否要写注释，怎么写
3790 *有人说在方法前写点注释就可以了
3791 *建议：为了可读性，后期维护，能写就读写点吧，反正不会损毁程序的效率，又可以增加可读性，
3792 何乐而不为呢？
3793 注：其实写注释就是在写伪代码，也是你分析问题的一种方式。
3794 不写注释的话，过一段时间之后你就会发现其实你之前写的代码是你写的吗？
3795
3796 5. 工具类：
3797 *在Java字符串可以转为字符数组:String.toArray();返回一个字符数组
3798 *数组也可以转换为列表集合：Arrays.asList(数组);其中Arrays是操作数组的一个工具类。
3799 *操作文件的工具类FileUtils:
3800 *操作数据库的工具类DBUitils:
3801 *操作JavaBean中的工具类BeanUtils：
3802
3803 6. 在Java中的包的作用和C++/C#中的命名空间的作用是一样的，都是为了分开存放分层之后的代码，可以
3804 减少项目开发中的类的命名冲突。
3805
3806 7. 除了奋斗，我别无选择！
3807
3808 8. 前端开发中的无序列表标签用的很多，其实这个块级元素是有大块<ul>和小块<li>(列表项)，小块列表项中装的是
3809 你要内嵌的内容或者是标签元素，表格和这个块级元素的原理是差不多的，表格<table>其实就是个大块，<tr>元素
3810 我觉得就是个换行符，真正起作用的就是单元格(有点像内嵌-行内元素)，可以设置宽高，单元格里面可以添加内容
3811 或者是内嵌标签元素。
3812 注：块级元素可以有布局，有宽高。行内元素和块级元素是可以相互转换的。
3813
3814 9. SQL注入：比如在sql语句中添加sql注入[' or '1'='1']
3815
3816 10. 列表集合和数组之间是可以相互转换的
3817 *列表集合->数组：list.toArray();
3818 *数组->列表集合：Arrays.asList();
3819
3820 11. 输入数据流的3种方式
3821 *配置文件流：.properties文件
3822 *系统的输入流(测试用的):System.in
3823 *前端的提交的参数或则是数据流
3824 *上传大文件用的文件流：实现类，FileInputStream FileOutputStream
3825
3826 12. 对于大公司的笔试题：
3827 *1. 情商题：看个人
3828 *2. 计算机基础题：计算机网络??，操作系统??，数据结构??，数据库，语言，框架知识
3829 *3. 编程分析题：算法和数据结构，思路分析
3830 *4. 编程实践题：考的都是基本的API调用，编程思维逻辑
3831
3832
3833
3834
3835
3836
3837 2015/9/18
3838
3839
3840
3841
3842
3843 1. 存储过程：pl/sql
3844
3845 2. 全文检索的索引库中的关键词？？
3846
3847 3. 数据库的分页
3848 *MySQL:要用到limit关键字
3849 *Oracle:用Oracle分页的话就麻烦点，要用到行号和子查询
3850 注：项目中一般使用框架进行分页，例如使用框架的Hibernate的hql语句。
3851
3852 4. 软件是一门工艺，也是一门艺术。
3853
3854 5. 数据分类：
3855 *结构化数据：数据库中的数据，就是结构化的键值对数据模型
3856 *半结构化数据：html(超文本),xml(配置文件),数据结构和内容混杂在一起，用元素节点结构化数据
3857 *非结构化的数据：比如文档，图片，视频/音频等，数据模型：无
3858
3859 6. 脚步无法达到的地方,目光可以达到；目光无法达到的地方，梦想可以达到。Has anything you have done made
3860 your life better?(脚步->目光->梦想)
3861
3862 7. shell编程:外壳？？
3863
3864 8. 做软件开发一定要掌握数据流的流向，
3865 *客户端向服务器端提交数据的流向：从客户端流入数据->控制端封装好客户端流入的数据->服务端业务逻
3866 辑层处理数据->数据库端入库数据.
3867 *客户端向服务器端请求数据时的数据流向：数据库出库数据->服务端业务逻辑层组装数据->控制端准备好
3868 数据之后分发到各个页面->客户端显示数据。
3869
3870 9. 做开发时要学会用集成开发环境工具，提高工作效率。
3871
3872 10. 写代码是尽量减小数据依赖的作用域，可以减少开发中错误的出现，也就是java中内聚的目标，以及所谓的原子性。
3873
3874 11. 对于存储过程，对于服务端业务逻辑开发的程序员，只要知道怎么调用存储过程就可以了，存储过程都是数据库端
3875 的开发人员开发封装好了。
3876 注：
3877 *1. 怎么创建存储过程和函数：创建函数和创建存储过程的原理代码都是差不多的，只不过是函数是有返回值的。
3878 示例代码：
3879 create or replace procedure 存储过程名(输入依赖的参数数据，要输出的依赖参数数据)
3880 as
3881 要声明的局部依赖
3882 begin
3883 根据输入参数更新插入数据库或者是从数据库中查询数据(处理数据)
3884 exception
3885 when ... then
3886 dbms_output.put_line("");
3887 end;
3888 注：游标cursor就是数据对象集合，需要用循环来操作数据集合，在数据库中的表示就是多行的数据
3889 创建函数：
3890 create or replace function 函数名(输入要依赖的参数数据，输出要依赖的参数数据)
3891 return 要返回的数据类型。
3892 as
3893 要声明的局部依赖
3894 begin
3895 根据输入的参数数据执行要做的数据处理
3896 return ..;
3897 exception
3898 when ... then
3899 dbms_output.put_line("");
3900 end;
3901
3902 *2. 怎么调用存储过程和函数：
3903 >调用存储过程
3904 示例代码：
3905 1. 创建一个java数据库连接和释放资源对象的工具类：JdbcUtils
3906 注：
3907 *工具类可以做成静态的也可以做成非静态的，不过做成静态的工具类调用方便
3908 做成非静态的工具类调用时需要实例化该工具类对象，或者是通过配置对象工
3909 厂创建对象，进行依赖注入即可。
3910 *静态的数据依赖就指的而是在类加载的时候初始化数据，所以静态的方
3911 法就只能访问类里的全局静态数据依赖，非静态的不能访问。
3912 public class JdbcUtils{
3913 //要连接数据库，必要的4个数据依赖的对象
3914 //依赖对象1：连接Oracle数据库的地址jdbcUrl
3915 private static String jdbcUrl="";
3916 //依赖对象2：连接数据库需要的数据库连接驱动
3917 private static String driverClass="";
3918 //依赖对象3：连接数据库需要的数据库登录名
3919 private static String username="";
3920 //依赖对象4：连接数据库需要的数据库登录密码
3921 private static String password="";
3922
3923 /**
3924 *创建提供对外部访问数据库连接对象的接口,至于是工具类可以做
3925 *成是静态的方法。静态的方法是类所有，调用时可以不用实例
3926 *类的对象进行调用，可以直接用类名调用方法接口就可以访问工具
3927 *类里的数据对象。静态的方法只能调用静态的方法，和静态的全局
3928 *数据依赖。
3929 */
3930 public static Connection getConnection(){
3931
3932 //如果数据库连接不成功，这里会抛异常
3933 try{
3934 //1. 注册数据库连接驱动driverClass
3935 Class.forName(dirverClass);
3936
3937 //2. 创建局部依赖：数据库连接对象conn并初始化该对象
3938 Connection conn=DriverManager.getConnection(jdbcUrl,username,password);
3939 }catch(Exception e){
3940 //把编译时异常转化为运行时异常。
3941 throw new RuntimeException(e);
3942 }
3943
3944 return conn;
3945 }
3946
3947 //创建关闭数据库资源的方法，
3948 public static void close(ResultSet rs,Statememt stmt,Connection conn){
3949
3950 //关闭这些资源不成功时会抛异常，所以要捕获该异常
3951 rs.close();
3952 stmt.close();
3953 conn.close();
3954 //这里用try...catch...finally语句分别包含捕获异常即可。
3955 //另外最好提供对关闭的资源的非空判断，可以增加程序的
3956 //健壮性。
3957 }
3958
3959 }
3960
3961 2. 怎么调用存储过程：
3962 示例代码：
3963 public class ProcedureTest{
3964 //建立依赖
3965 //数据依赖1：数据库连接对象
3966 private Connection conn=null;
3967 //数据依赖2：数据库会话
3968 private CallableStatement pstmt=null;
3969 //数据依赖3：sql语句
3970 private String sql=null;
3971
3972 //测试方法1：测试存储过程
3973 @Test
3974 public void testProcedure(){
3975 //初始化数据库连接对象
3976 conn=JdbcUtils.getConnetion();
3977 //初始化sql语句
3978 sql="{call XXX(?..)}";
3979 //初始化数据库会话
3980 pstmt=conn.prepareCall(sql);
3981
3982 //设置要传入的参数数据
3983 pstmt.setObject(..);
3984 ..
3985
3986 //执行查询
3987 pstmt.execute();
3988
3989 //输出数据流
3990 ...
3991 }
3992 }
3993 3. 怎么调用函数
3994 示例代码：
3995 public class FuctionTest{
3996 ...
3997 }
3998
3999
4000 注：调用存储过程就是调用Oracle数据库提供的服务(向数据库中入库出库的方法)
4001
4002
4003
4004 2015/9/19
4005
4006
4007
4008
4009
4010 1. 冬眠(hibernate)框架其实就是对项目中的DAO(数据对象访问层)的封装，封装了数据对象访问层中对数据库中的数据的
4011 增删改查的数据操作,并提供了一个会话工厂外加事务执行对象数据流的入库出库操作，所以在web项目开发中(如果用
4012 该框架的话)可以省略DAO层不写，因为这个框架帮你做了封装，并提供了一个会话工厂(SessionFactory)，可以理解为
4013 sevice业务逻辑层和该层之间通信的依赖。
4014 注：
4015 *为什么数据入库的时候要加事务，是为了防止意外(exception)的发生，可以回滚操作,或者是自定义提交事务，实
4016 行手动的提交事务之后数据流正式入库。
4017 *事务是数据库的一种安全机制。
4018
4019
4020 2. tomcat(项目调试用的服务器：tom猫)的实现原理就是用套接字(socket),用套接字可以建立客户端浏览器到服务器的
4021 网络连接，访问服务器的里部署的数据资源文件。服务器里提供了供入/出库数据流的数据库，以及要依赖的jdk(
4022 java开发发工具箱)，部署到服务器里的处理数据的业务逻辑程序，客户端要访问的资源文件。
4023
4024 3. 生活中要陶冶情操，培养真性情。
4025
4026 4. 方法就是方便帮助你处理数据用的，方法中的参数就是局部依赖的输入数据流或者是要修改的数据流以及要输出的数据
4027 流，方法内创建的对象也属于局部依赖，方便你处理输入的数据流，有返回值的方法就是有数据流的流出方法，没有
4028 返回值的方法就是直接处理输入的数据流。
4029
4030 6. 编程注重掌握技术原理以及好的解决方案，代码次之。
4031
4032 7. 算法(algorithm)就是在编程中的解决问题的方案。
4033
4034 8. 实体命名最好要表达数据的含义(所以可以把不重要的类型等放到命名的后面)，方法命名就是要表达要做的事情(采用动
4035 宾结构即可)。
4036
4037 9. 编程的首要任务就是在不断的管理项目的复杂度，不断地尽量降低复杂度。
4038
4039 10. 对于重复的代码，可以进行代码的抽取，减少代码的冗余，使代码的结构清晰，增加可读性。
4040
4041 11. 对代码的初始化采取的原则就是就近原则，就像对接口的实现，对抽象类中的方法的覆写，继承，等都是就近原则，以
4042 实现之后的方法进行调用，或者是覆写之后的方法进行调用。
4043
4044 12. Struts2中拦截器就是一个特殊的Action(行为)，只不过框架2中的请求到达控制器action之前需要经过拦截器(
4045 覆写方法intercept(ActionInvocation invocation))的拦截,再通过控制器进行中转，调用业务逻辑层处理数据，决定
4046 进行出库还是入库数据。
4047 注：
4048 *框架2中的是先创建Action(行为)的，在创建拦截器invocation。
4049 *框架2中有18个默认的拦截器，进行参数的拦截，大文件的上传下载等，每个拦截器负责一个功能。
4050
4051 13. 其中面试就是半开卷的考试，面试大纲就是你的简历。简历中问的最多的就是你的项目经历，没有项目经历的就是问你
4052 的基础知识，现在企业要找的就是能编码的熟练工。
4053
4054 14. 操作数据库的statement(会话，可以理解为操作数据库中的数据的语句)
4055 *Statement：用户调用一般的sql语句，方法依赖的sql语句的可读性太差了。
4056 *PreparedStatement：预编译语句，建议使用该语句代替Statement，可以防止sql注入，提高编译的性能(因为有
4057 缓存)，增加可读性，可维护性。
4058 *CallableStatement: 用于调用存储过程的语句。
4059 注：这个三个对象对数据库进行更新插入用方法：executeUpdate(),对数据库进行get查询方法：executeQuery()
4060
4061 15. 拦截器和过滤器：
4062 *1. 拦截器(Interceptor)：
4063 >1. 实现权限拦截器(PrivilegeInterceptor)：
4064 代码：
4065 public class PrivilegeInterceptor{
4066 //
4067 }
4068 >2. 实现日志拦截器(LogsInterceptor)：
4069 *2. 过滤器(Filter)：
4070 注：
4071 *拦截器和过滤器的差别就是拦截器拦截的是Action(行为)，而过滤器过滤的是一般的资源文件，而且是一
4072 般放在项目的WEB-INF文件夹之外的资源页面，放在文件夹WEB-INF里面的资源文件是不可以通过浏览器的
4073 地址栏的静态地址访问的，只能通过控制器访问。
4074 *拦截器的原理就是覆写AbstractInterceptor中的intercept()方法，并在该方法拦截请求。
4075 *过滤器的原理就是要实现接口Filter中的doFilter()方法，并在该方法中对资源进行过滤处理。
4076 *过滤器是个特殊的控制器(servlet)，拦截器是个特殊的Action(行为)，其实框架2(Struts2)就是对控制
4077 器(Servlet)的封装，实现了
4078 *编写拦截器和过滤器的一般步骤是：
4079 >1. 创建类实体(类)
4080 *过滤器类要实现Filter接口
4081 *拦截器类要覆写抽象拦截器中的方法
4082 >2. 实现方法或者是覆写方法(方法)
4083 >3. 页面(拦截器获者是过滤器要跳转到的页面)
4084 >4. 配置(过滤在web.xml文件中配置，拦截器在struts.xml文件中配置)
4085
4086 17. 怎么进行权限控制：原理
4087 *当用户为没有登录状态的时候进行跳转(装发)的登录页面。
4088 *当登录用户的权限不足时，应该定位到一个权限不足错误显示页面。
4089
4090 18. 字符串操作中的获取子串方法substring(fromIndex,toIndex),获取字符串中的字符位置索引indexOf(""),字符串的分割
4091 split(""),字符串的首尾去空格trim(),判断是否是空串isEmpty();
4092
4093 19. 前端用户数据的数据最多的即使字符串，在前端的js编程中也是字符串的数据类型用的最多，在服务端中有提供字符串
4094 数据到其他类型数据的自动转换，例如Struts2，但是struts1中以及控制器Servlet中接收提交的数据参数需要自己提
4095 供对字符串类型到其他数据类型的转换。
4096
4097 20. 服务器的响应基本上就是数据流的回流，数据从数据库中出库之后回流向客户端。
4098
4099 21. 数据在C语言中是基本的数据类型，在Java中数组并不是基本的数据类型，是要在堆内存中自定义分配数组的大小，并
4100 进行初始化，用数组的最大的优点就是访问数据的效率较高，不过现在用的较多的就是用数组实现的数据列表ArrayList
4101 访问数据高效，并且可以动态的自动增加数据列表的大小，如果是要进行插入频繁的数据结构，可以选用LinkedList。
4102
4103 22. 页面显示层中的${},即el(表达式语言)，以及ognl(对象图导航语言)中的%{}都是向控制器数据中心get数据的请求。
4104
4105
4106
4107
4108
4109
4110 2015/9/20
4111
4112
4113
4114
4115 1. Java业务流程管理框架(JBPM)：这是个产品经理眼中的产品，相比Activiti工作流框架(传说是开发这个框架的核心
4116 工程师都是开发jbpm框架的那里分离出来的，这个产品是工程师眼中的产品，API等调用简单点？)，架构？？易用性？
4117
4118 *1. 导包：
4119 >1. 核心包:${JBPM_HOME}/jbpm.jar
4120 >2. 添加${JBPM_HOME}/lib/*.jar,除了junit.jar,servlet-api.jar,cglib.jar
4121 >3. 注意：不要添加cglib.jar,因为Spring中有更高版本的cglib-nodep-2.1_3.jar,会有发生冲突。
4122 >4. 把lib中的juel.jar,juel-engine.jar,juel-impl.jar剪切到tomcat6下的lib
4123 目录中，并删除tomcat6下的lib原来的el-api.jar。因为这个两个lib目录中有关el的jar包有冲突。
4124 *2. 配置：
4125 在Spring的对象工厂的配置文件applicationContext.xml文件中进行配置
4126 >配置的示例文件：
4127 <!--配置流程引擎processEngine-->
4128 <bean id="springHelper" class="org.jbpm.pvm.internal.processEngine.SpringHelper">
4129 <property name="jbpmCfg" value="jbpm.cfg.xml"></property>
4130 </bean>
4131
4132 <bean id="processEngine" factory-bean="springHelper" factroy-method="createProcessEngine">
4133 </bean>
4134
4135 *3. 使用：
4136 >1. 如何实现企业业务工作流(workflow)的审批(approve)和流转。
4137 *1. 实现原理：
4138 >1. 要实现企业业务工作流的审批和流转功能，需要借助用jbpl(Java Business
4139 Process Language，Java业务流程语言)画的企业业务流程图。
4140 >2. 画好业务路程图之后借助流程引擎(processEngine)可以把业务流程图部署到
4141 服务器上，其实本质就是把业务流程图变成数据流入库到数据库中。
4142 >3. 之后就是启动业务流程实例，对工作流的内容进行审批工作，完成任务。
4143 注：全程的工作流的流转(不管是出库业务流还是入库业务流)都是要通过流程引擎进行的。
4144 *2. 实现方式：代码实例，实现办公自动化(automation office)
4145
4146
4147 2. 数组是由索引(即元素的地址)和数据元素组成，可以存放各种数据类型的元素，但是api不太完善，而且不能动态的
4148 增加数组的大小，不太灵活，尽管访问元素的效率较高，所以ArrayList封装了数组，用的比较多，但是数组还是有它
4149 用的地方，例如进行前端的数据参数的搜集(比如对复选框编号集合的搜集，可多选的列表框提交的编号集合的搜集)
4150 都可以用数组来进行搜集再处理。
4151 注：重申遇到数组或者等集合一定要想到用循环来操作数据，因为循环可以遍历操作集合中的每一个元素，然后进行
4152 想要的数据处理。集合和循环都是很伟大的发明，一个可以用来装载量多的数据，一个可以对大量的数据进行遍历
4153 操作。
4154
4155 3. 在Java中字符串(String)本质就是字符数组，只不过是对字符数组进行了封装，提供了更多的操作字符串的API(getter
4156 方法:子串，分割，字符的索引，去空格等，setter方法：用构造函数或者是操作符"=="初始化字符串)
4157
4158 4. 想望的远，就必须要站的高。
4159
4160 5. 客户端要什么数据，在控制端就是要应该准备什么数据。例如角色关联权限，这两个实体是属于多对多的关联关系
4161 ，如果在设置权限页面需要设置权限，则在控制端需要在设置权限的方法中把角色实体对象和权限实体对象相关联，
4162 可以设置为单向关联，因为只需要根据所选则的角色查询该角色所对应的权限集合，即角色关联权限。
4163
4164 6. 字符类型也就是短整型，char类型的本质就是用ASCII码与字符映射，每一个字符对应一个ASCII码，ASCII码使用整数
4165 表示字符串的。所以字符实际上就是短整型，比较两个字符串的值就是比较两个字符的ASCII码值。
4166 注：字符串建立者StringBuilder和StringBuffer(字符串缓冲)的最大区别就是是否能在高并发的线程中的工作，
4167 StringBuilder是线程不安全的，但是操作高效，StringBuffer是线程安全的。
4168
4169 7. 删除数组中的重复元素再排序：
4170 思路一：
4171 原理分析：因为数组中是没有删除元素的方法的，所以要借助一个字符数组，设定字符数组的大小为255个字符长
4172 至于为什么要设定为255个字符长，目的就是要能表示所有的字符
4173
4174 示例代码：
4175 //主程序入口
4176 public static void main(){
4177 //建立依赖
4178 //依赖1：客户端输入的数据流,用System.in模拟项目的客户端
4179 Scanner scanner=new Scanner(System.in);
4180 String inputStr=scanner.nextLine();
4181 //依赖2：把输入的字符串转换为字符数组
4182 char[] inputChars=inputStr.toCharArray();
4183 //依赖3：新建一个字符长为255的字符数组，用来装载不重复的字符元素
4184 char[] chars=new char[255];
4185
4186 //对数组的重复元素进行删除
4187 for(int i=0;i<inputChars.length;i++){
4188 //如果chars字符数组中以inputChars中的元素ACSII码值为数组
4189 //该位置的下标，对应没有数据，这里就是把值设置为1(设置为1/0只是占位
4190 //的标记,说明这个索引位置有数据)
4191 int temp=inputChars[i];
4192 if(chars[temp]==0){
4193 chars[temp]=1;
4194 }
4195 }
4196
4197 //最后对数组进行排序
4198 //依赖5：字符串构建者
4199 StringBuilder sb=new StringBuilder();
4200 for(int i=0;i<chars.length;i++){
4201 //把字符数组chars里的有数据的索引位置取出来，转化为相应的char类型
4202 //追加到字符串中
4203 if(chars[i]==1){
4204 sb.append((char)i);
4205 }
4206
4207 }
4208
4209 //输出要整理过后的数组数据
4210 System.out.println(sb.toString());
4211
4212 }
4213 注：char是基本的数据类型，把此类型理解为短整型就更好了。
4214 思路二：可以把数组转换成集合列表，然后删除重复元素，不过这就是多此一举了。
4215
4216 8. 要处理数据，首先应该采集数据，经过服务器处理之后对数据进行入库，数据库和服务器一个是数据存储中心，一个
4217 是数据中转中心，采集数据的任务一般是通过客户端进行的。
4218
4219 9. web开发中控制器的作用就是把客户端要显示的数据准备好，然后把数据放在数据中转中心(用框架的话就是一个大的
4220 映射表，里面提供了对各个域对象的映射，域对象就是用来存放数据的)。
4221
4222 10. 会写注释也是一种很好的编程习惯。
4223
4224 11. 因为(Struts2)框架2中的提供的对数据对象封装的模型驱动，只是对一般属性的封装，对于有些特殊的属性，比如
4225 对数据计数(counter)的维护，对Data日期(这个可以在数据库中提供默认的当前时间)的维护，还有关联关系就是要
4226 自己对所关联的实体对象进行关联。
4227
4228 12. 写系统的时候特别是编辑页面要记得对显示的数据对象进行回显，控制器端要做的就是调用Service(业务逻辑层)使
4229 数据库中的数据出库之后放在数据中转中心(框架2提供的值栈或者是映射表里的其他域对象)，最后数据流到客户
4230 端，回显之前编辑过的数据。
4231
4232 13. 对于数据库中表的一对多关联关系，一般要清楚主从表的概念，一般主表是提供主键，而从表有和主表相关联的外键。
4233 对于关系型数据库，一般有3种关联关系，其中一对多的关联关系用的最多，多对多的有比如角色和权限的关联关系，
4234 一对一的有人和身份证的一对一关联关系。
4235 注：
4236 *1. 多对多的关联关系一般会有自动生成一张由两张表外键组成的组合外键表，对两张表进行相关联。
4237 *2. 如何自己配置表的关联关系映射，前提是在hibernate.xml文件中提供了从映射文件到数据库定义语言的关联，
4238 配置代码：<property name="hbm2ddl.auto">update</property>
4239 作用就是可以根据Xxx.hbm.xml映射文件到数据库表的映射在数据库中自动创建表更新表。
4240 *3. 主表一般是提供主键，在从表中主表实体对象的表示方式是和主表主键相关联的外键。2
4241 *4. 怎么配置一对多的数据表关联关系表的映射。
4242 例如：部门和雇员表的一对多关联关系配置
4243 <?xml version="1.0" encoding="utf-8"?>
4244 <!DOCTYPE ...>
4245 <hibernate-mapping package="">
4246
4247 <class name="" table="">
4248 <!--主键配置-->
4249 <!--一般的属性配置-->
4250
4251 <!--关联关系-->
4252 <!--一对多的关联关系属性-->
4253 <set name="">
4254 <key column=""></key>
4255 <one-to-many class=""></one-to-many>
4256 </set>
4257 <!--多对多的关联关系属性-->
4258 <set name="" table="">
4259 <key column=""></key>
4260 <many-to-many class="" column=""></many-to-many>
4261 </set>
4262 <!--多对一的关联关系属性-->
4263 <many-to-one name="" column="" class="">
4264 </many-to-one>
4265 </class>
4266
4267 </hibernate-mapping>
4268
4269 14. 你在编程中遇到的问题其他人也同样会遇到，关键是你有没有资格和其他人一起讨论遇到的问题。
4270
4271 15. 可以把Properties理解为能存储数据的域对象，其实属性的数据结构也可理解是一个映射表Map。
4272
4273 16. Spring框架的注解配置中对类对象的配置有控制器的配置注解Controller,对Service层的配置有注解有Service
4274 对事务的配置注解有Transaction,对DAO层的配置有Repository(仓库的意思),对其他对象的配置有配置Component
4275
4276 17. 软件工程是一门工艺，得往深了学。
4277
4278 18. 做软件开发在开发项目中要时刻提醒项目的可行性，可读性，可扩展性，可维护性，所以你要做的就是对项目分层，
4279 解耦，内聚，达到原子性，利用接口或者是抽象类，继承，数据抽象，多态等特性可以增加项目的扩展性，利用信
4280 息隐藏或者是数据封装，提高数据的安全性。
4281 注：项目做完了之后再考虑项目的优化，高并发的等。
4282
4283 19. 方法就是用来操作依赖的数据的，所以要操作数据最好通过访问器子程序访问，减少数据污染，提高数据的安全性，
4284 同时可以减少代码的复杂度。
4285 注：软件工程的首要任务就是管理项目的复杂度。
4286
4287 20. 系统变量和用户变量：
4288 系统变量：是对所有的用户起作用的变量。
4289 用户变量：只对当前用户起作用的变量。
4290
4291 21. 在windows中的变量是不区分大小写的，在Linux中是区分大小写的。
4292
4293 22. 前端js编程中的数据依赖就是元素节点。js中定义的方法就是在操作元素节点，因为js编程是面向浏览器的，是为了
4294 给超文本添加特效的，并不是为了处理数据流。
4295
4296 23. 对于配置文件：可以理解为填表单，但是要尽量注意你要设置值的属性名字，因为这是框架里自动为你提供的属性名字
4297 ，不能写错，注意大小写以及拼写错误，能拷贝的话就拷贝，因为这能减少错误的发生。
4298
4299 24. 其实DOS窗口的指令，可以理解为一个一个的方法，因为指令就是动作，向操作系统请求资源的操作，所以可以向方法
4300 中传参数，之后向操作系统中请求资源，例如：java -version,即能向操作系统中请求java开发工具箱的版本信息。
4301
4302
4303
4304
4305
4306
4307
4308 2015/9/21
4309
4310
4311
4312
4313
4314 1. i/0流中输入流(inputstream)读入的是文件的输入流，构建文件输入流的时候依赖的是该文件的地址路径，但是如果要把
4315 这个输入流输出到某个文件夹输出中，输出流(outputstream)构建的时候要依赖的就因该是要输出的文件夹的地址路径。
4316 注：输入输出流的都是抽象类，具体实现类分别为：FileInputStream FileOutputStream
4317
4318 2. 关于权限控制：
4319 (一)原理分析：
4320
4321 *1. 可以设计一个安装类或者是同过sql语句直接向数据库中入库要控制的权限名称(以后可以出库之后构建请求
4322 地址)，从而实现对项目系统权限的控制。
4323 *2. 对于系统的权限控制，基本上的web系统，无论是外网的还是内网的，都会用到的，所以这个非常重要。
4324 *3. 权限控制分为
4325 >1. 前台对浏览器地址栏的请求地址的权限控制过滤.
4326 >2. 前台系统的用户的界面操作的权限控制(例如在论坛的前端页面中一般的游客的权限只能是浏览论坛
4327 的帖子，不能对帖子的添加删除操作)
4328 >3. 系统的后台一般都有一个侧边栏，不同权限的用户所拥有的权限选项是不同的，所以要对权限进行
4329 控制过滤。
4330
4331 (二)实现方式：
4332
4333 *1. 设计能入库需要控制的权限集合的实体：权限安装类
4334 示例代码：
4335 注：前提是要自己设计好了Privilege实体类，并提供一个有参数的构造方法，对类中的数据
4336 依赖进行
4337 //用Spring对象工厂管理该类
4338 @Component
4339 public class PrivilegeInstaller{
4340
4341 //全局依赖：会话工厂(SessionFactory),这里可以使用Spring对象工厂的依赖注入
4342 //方式为注解
4343 @Resource
4344 private SessionFactory sessionFactory;
4345
4346 //提供一个对权限的入库方法
4347 public void addPrivilege(){
4348
4349 }
4350
4351 //1. 首先对超级管理员进行入库
4352
4353
4354
4355 //2. 对系统的权限进行入库
4356
4357 //提供能把实体类对象入库操作的会话方法getSession()
4358 private Session getSession(){
4359 return sessionFactory.getCurrentSession():
4360 }
4361 }
4362 *2. 设计权限控制类实体：PrivilegeInterceptor
4363
4364 >1. 实现原理：
4365 *1. 要实现拦截的功能，必须要继承抽象类AbstractInterceptor,并且实现覆写方法
4366 intercept(ActionInvocation invocation)
4367 *2. 权限控制的拦截器拦截的一般是有关框架2(Strurts2)中的行为(Action)请求,所以要控制
4368 权限的话，必须要获取客户端的请求地址(依赖1)
4369 *3. 根据请求的地址与数据库中根据用户所属的角色所包含的权限集合进行匹配
4370 *4. 若匹配成功，则放行，调用下一个拦截器(Interceptor)或者是下一个行为Action
4371 注：
4372 *要提供对用户是否登录状态的判断，用户没有登录系统是不能有权限访问系统的功能
4373 界面的。
4374 *拦截器中覆写的方法intercept()中的局部依赖行为调度者invocation是可以通过它
4375 获取到请求(request)域对象，用户会话(session)的域对象，应用程序(application)
4376 的域对象。
4377 实例代码：
4378 //获取请求对象request
4379 HttpServletRequest request=(HttpServletRequest)invocation//
4380 .getInvocationContext().get(StrutsStatics.HTTP_REQUEST);
4381 //获取用户会话session对象
4382 HttpServletSession sessio=(HttpServletSession)invocation//
4383 .getInvocationContext().getSession();
4384 //获取应用程序对象application
4385 ServletContext application=invocation//
4386 .getInvocationContext().get(StrutsStatics.SERVLET_CONTEXT);
4387
4388
4389 >2. 示例代码：
4390 //自定义一个权限拦截器类实体继承于抽象拦截器，并且覆写其中的拦截方法intercept()
4391 public class PrivilegeInterceptor extends AbstractInterceptor{
4392
4393 }
4394
4395 注：过滤器,拦截器的本质就是一个控制器Servlet,其实也是一个数据的中转中心，决定数据流的入库出库操作。
4396
4397
4398 3. 在类中请尽量控制方法或者是依赖变量对象的作用域，适当的使用继承，推荐使用接口，实现解耦。
4399
4400 4. 面向服务器的系统的开发就是请求响应模型，面向浏览器的开发就是前端的js编程是基于事件响应
4401 的模型，面向操做系统的开发也是事件响应模型。
4402
4403 5. 计算机的核心是中央系统处理器，cpu能帮助你做工作，做任务(job),运行在微机之上的是操作系统，操作系统有一个
4404 内核(??)能在之上运行各种写好的计算机程序，控制计算机响应请求，处理事件等。
4405
4406 6. 构建操作系统的架构路径：内核->C++类库->各种框架->开发各种应用程序。一个操作系统也有前台和后台之分，前台就
4407 是依赖图形界面库写的前台客户端，后台就是一个资源管理系统，用来存储各种的数据文件。
4408 注：
4409 *操作系统肯定也是分层的，有前台(图形界面层)，有控制器(内核??),文件管理系统相当于数据库用于存储数据。
4410 *MVC设计模式一开始就是应用在图形界面应用编程的，后来才应用到web开发中的。
4411 *内核：负责线程管理，地址空间和进程间通信，内存，设备驱动程序，文件管理和网络系统，决定这系统和性能
4412 的稳定性。
4413 *浏览器其实就是一个能访问服务器资源的操作系统。
4414 *图形界面应用程序开发和web开发的最大区别就是界面层，所依赖的类库是不一样的，web开发中的界面层是超文本
4415 ，是浏览器能解析的文档流，而图形界面应用程序中的图形界面是用图形类库中的一个一个组件堆砌而成的。至于
4416 控制器，操作系统有内核，浏览器也有内核，只不过web开发中的数据库和资源页面都是放在服务器端而操作系统
4417 的数据库(用户存储数据)是放在客户端的。不过只要联网，运行在操作系统的应用程序也可以和在服务器的数据库
4418 连接，从而入库数据和出库数据，意思就是把在客户端的文件管理系统(能存储数据用的)搬到了另外一台大机器
4419 (就是一台资源吞吐量更大的计算机，即服务器)上面，从而只要联网，就可以用客户端应用程序或者是通过浏览器
4420 客户端访问服务器数据库里的数据。
4421
4422 7. 异步请求：就是为了请求连接服务器并且响应浏览器客户端的操作的一个折中，在不影响向服务器请求数据的同时可以
4423 浏览其他的页面。
4424
4425 8. 设计一个网页的必要元素：
4426
4427 *1. 网页的头部(header):
4428 >1. 组成元素：
4429 *商标(logo): 作用是树立企业的品牌形象，或者是企业的产品。
4430 *导航栏：网站页面的超连接，想到于图像界面编程中的菜单
4431 *搜索栏：基本上的外网系统都会给用户提供一个全文检索的搜索框，最好配置自动不全的效果
4432 给用户提示选择关联的关键词，进行搜索。
4433 *2. 网页的主体(body):
4434 >1. 组成元素：
4435 *文本内容：这是一个网页的肉体，也是主要的组成内容
4436 *图片：图片的作用就是形象
4437 *超链接：导航跳转到网站的另外一个页面
4438 >图片链接
4439 >文字链接
4440 *3. 网页的尾部(footer):
4441 >1. 网站的版权，其他的链接等
4442 注：网页的布局一定要简洁有序，不能杂乱无章，尽量增强用户的体验。
4443
4444
4445
4446
4447
4448
4449 2015/9/22
4450
4451
4452
4453
4454
4455 1. 前端表单元素的作用就是为了给后台的服务器处理程序提交数据之后入库的，表单是一个特殊的块级元素，没有什么
4456 布局，也不需要什么的渲染，所以它只能用来容纳其他的元素，例如表单里面一把都会内嵌表格用来显示数据用的
4457
4458 2. 怎么集中注意力？？？不要胡思乱想。
4459
4460 3. 数据库编程中创建表的时候，就是在用数据定义语言创建表的时候可用的语句为
4461 *原理：对于数据定义语言(ddl),一般定义的是实体对象和数据库表相互关联映射的属性
4462 >属性分为：
4463 *1. 主键(primary key)
4464 *2. 一般的属性字段(例如名字name,年龄age等)
4465 *3. 特殊属性字段(例如日期Date推荐设置为时间戳类型,并且为默认的系统当前时间(timestamp
4466 default CURRENT_STAMP,需要你手动维护的字段counter等)
4467 *4. 关联关系属性，即所谓的外键(从表才有外键)
4468 *5. 至于在建表的时候是否要立即添加外键，即建立各个表之间的关联关系，添加关联关系就是
4469 会增加各个表之间耦合度，建表的时候立即添加外键之后用编译器的逆向工程动态生成实体
4470 以及映射文件的时候就会自动的建立有关系实体之间的双向关联关系，如果不立即添加的外
4471 键的话，这就要求服务端的开发人员自己有需要的时候添加单向关联或者是双向关联关系
4472 这个应该看具体的需求，是通过主表查从表数据，还是通过从表查主表的数据，开发人员
4473 自己定义添加代码，添加映射，不过这就是要求服务端的开发人员的水平要高点，当然数据
4474 库端的开发人员最好提供对表关系之间的外键的添加的代码。
4475 *示例：
4476 create table xxx(
4477 //定义属性字段的时候，这种语言的定义习惯和服务端的编程语言的习惯是不一样的，是把属性
4478 //字段的数据类型放在属性字段名字的后面
4479 //关键字属性字段，一般是不为空的，并且设计为能够在数据库中插入数据是编号为自动增长的
4480 id int not null auto_increment;
4481 //一般的属性字段
4482
4483 //特殊的属性字段
4484
4485 //关联关系属性字段，即从表的外键
4486
4487 //给主键
4488 );
4489
4490 4. 客户端的作用就是用来搜集数据用的，同时也是可以用来向服务器请求数据，客户端就是数据流流入流出的端口。编程
4491 系统开发开发中，要特别注意数据流的流向，数据流流的越深，这个层次机构就越重要。例如：当数据流从客户端流向
4492 数据库端时，是一个数据入库的过程，要经过的系统层次分别为客户端(即数据显示层，view)->控制器层(controller,
4493 控制数据的流向)->业务逻辑层(service,这一层是从控制器层中解耦出来的，也就是重构之后的处理业务数据的方法，
4494 控制器层是依赖该层对数据进行入库的)
4495 ->DAO层(这一层如果用框架冬眠(hibernate)的话,其实就是封装在整个框架中，服务层service依赖该层真正把整理好
4496 的数据正式入库)->数据流入库。
4497 注：
4498 *层与层之间的通信就是通过依 赖进行的。
4499 *数据库是整个系统层次的根基，是非常重要的，安全性，防止数据系统崩溃，优化等等。(高级数据库管理员DBA的
4500 待遇是相当高的)
4501
4502 5. 关于级联(cascade)的删除：on delete SET NULL on update SET NULL
4503
4504 6. inverse(反转):
4505 1. 反转的意思就是说把控制权转移，比如部门(department)和用户(user)的关系，就是主从表的一对多的关系，一般
4506 如果你不自定义设置控制权限的话，默认的关联姑息控制权就是部门department。所以时候在入库部门的数据的时候
4507 ，如果部门所关联的用户数据也要一起入库，那么就会有两种的插入(insert)操作,外加更新操作；如果设置控制
4508 权为反转为真，即inverse=true,也就是说这两张表的关联关系的控制方转移了，交给用户user，有这张表来维护
4509 这两张表之间的关系，表现的结果就是user和department表中会有插入insert操作，没有更新操做。
4510 2. 具体原因：
4511 >1. 对于第一种情况，在主表中插入数据时数据库会自动的生成一个对象记录的编号id主键，在从表中插入
4512 数据时数据库中也会自动的生成一个对象记录的主键。但是关于这两个实体之间的关联关系，就要通过
4513 外键来进行关联了，一般外键的表现方式就是在从表中生成一个外键编号字段参照主表的主键。所以
4514 在主从表都插入数据之后，从表需要更新外键字段，即者两张表之间的关联关系，所以有更新update
4515 操作。
4516 >2. 对于第二种情况，因为控制反转了，就是说从表在插入数据的时候就会同时插入外键字段，用户维护
4517 主从表之间的关联关系，所以这种情况是用不着在用更新update操作了。
4518
4519 注：什么时候用反转inverse？代码优化的时候，在双向关联一对多的主从表关系中，可以把控制权交给从表维护。
4520
4521 7. 注册用户的激活方法就是原理就是在设计用户实体的时候新增加一个用户是否激活的字段，可以设置为整形的0/1或者是
4522 boolean型的true/false;
4523 用户激活更改改字段的状态之后，就可以登录系统进行访问数据页面了。
4524
4525 8. 邮件(mail)就是一个大的数据包，数据流向为从客户端准备好的邮件数据->流向邮件服务器端->你要发送过去的客户端
4526
4527 9. 怎么发送邮件：
4528 原理：
4529 *1. 设计一个操作邮件的工具类MailUtils
4530 *2. 设计一个邮件实体类Mail
4531 *3. 第一步：连接邮件服务器，需要构建session连接会话对象()，构建的时候需要依赖三个数据对象
4532 即主机服务器地址(hostUrl)，登录名(username)，密码(password),即可连接邮件服务器。
4533 *4. 第二步：构建邮件对象(new Mail(from,to,subject,content))，依赖的对象有发送者的地址(from)，
4534 有邮件的接收者的地址(to)，邮件的主题(subject),邮件的内容(content)。
4535 *5. 第三步：发送邮件，用邮件工具类(MailUtils)里自定义的send(..)方法进行发送，其实发送邮件的本
4536 质就是向邮件服务器提交数据的一个过程，邮件服务器会自动帮你转发到你要发送的邮箱
4537 这个过程就是一个数据邮件出库的一个过程。
4538 总结：软件开发就是对数据流的一个入库出库过程，数据流向会经过服务器处理之后流向数据库，向服务器请求
4539 数据的的过程就是数据流的从数据库到客户端的一个回流，所以软件开发就是在控制数据流的流向。
4540
4541 示例代码：
4542 ...
4543 注：
4544 *发送邮件的时候对于所添加的附件，一般会上传在邮件服务器的服务端，接收端需要看附件的时候同
4545 过在服务器下载该大文件(即附件)即可。
4546 *输入流(inputstream)一般就是用来提供下载用的。下载就是大文件从建立在服务端的文件夹出库的一
4547 个过程。无论是数据流的出库还是大文件流的出库入库，都是要转化为流体即数据流(1001...)才能达到
4548 你要的上传下载(入库出库)功能。
4549 *文件的下载就是在控制器把从服务器出库的文件流输出到客户端的一个过程。
4550
4551 10. 和用户进行沟通的时候是要会画系统的用例图，定义系统需要的模块功能，形象地给用户看，生成系统的需求文档。
4552 项目设计的时候需要确定系统的功能界面布局，生成项目设计文档。数据库设计的时候需要会画设计对数据建模的
4553 实体的UML(统一建模语言，是画图的一种语言)图，生成各个实体之间的关系图以及各个实体所具有的属性。
4554 设计好了之后就可以进行系统各个层次的实现，功能界面层有前端工程师实现，服务端业务逻辑有服务端工程师实现
4555 各个功能，数据库的表的生成由数据库端的开发人员实现。
4556
4557 11. 前端开发中的事件用的最多的向鼠标的移入移出(onmouseout,onmouseover)事件，输入框的聚焦(focus)失焦(blur)
4558 事件，表单的提交(submit)事件,按钮的单击(click)事件等。
4559
4560 12. 新浪笔试：
4561 *计算机网络：http协议属于应用层
4562 *javaSE基础：
4563 >1. 所有对象的基类Object提供的方法是没有compareTo()比较方法
4564 >2. 字符串考的叫多，处理字符串一定要记得将字符串转化为字符数组之后用循环来处理
4565 >3. 数据类型的数据的溢出之后的结果
4566 >4. 数据库sql语句
4567 >5. 集合：数组列表集合(ArrayList),能频繁插入删除的双向链表集合(LinkedList)
4568 >6. 算法编程，就是考排序，字符串处理。
4569 *什么缓存MemCache？？
4570
4571 13. 能用动态数组ArrayList就不要用数组Array，因为数组不灵活，而且效率两者没什么差别。
4572
4573 14. 软件的首要任务就是管理项目复杂度，目标就是增强用户体验。
4574
4575 15. 项目开发中的代码的可读性是十分重要的，可以提升代码的质量。
4576
4577 16. 项目开发中应该遵循这4个特性：可行性(需求分析确定)，可读性(代码的质量)，可扩展性(建议使用分层，
4578 接口通信，解耦)，可维护性(做到以上三点项目的维护性就是会得到提高)
4579 注：最后考虑是否进行优化。
4580
4581 17. 原码，反码，补码
4582 *原码：原码就是数值型数据的二进制表示，例如十进制数整形3的表示就是2+1，所以它的二进制的表示方式就是11
4583 原理：二进制数转十进制数其实就是在用2的n(n为二进制数据的位数-1)次方进行相加即可。
4584 *反码：整数保持不变，负数就是在原码的基础上保留符号位其他为取反。
4585 *补码：整数保持不变，负数就是在反码的基础上加1。
4586
4587
4588
4589
4590
4591 2015/9/23
4592
4593
4594
4595
4596
4597 1. 写代码就因该讲究原理，要不然会很容易出错的。
4598
4599 2. 2D(2维图像)太抽象了，3D(3维图像)才是真正的模拟现实世界，现在的游戏基本上都是往3D图像发展了，以提高用户
4600 体验，但是这样就是对机器的配置要求提高了很多。
4601
4602 3. 软件行业的盈利模式
4603 *主要模式就是通过免费试用之后获取注册用户之后进行付费试用，增值付费试用，或者是全免费卖服务，投放
4604 广告等
4605 *软件是否能够挣钱，关键在于使用产品的用户体验，用户体验好的话就可以采集用户的数据，给用户提供增值
4606 服务，会员收费等。
4607 *现在的一般的软件公司基本上都是靠为客户做项目来挣钱，做产品的公司就用用户体验来积累用户收费挣钱，如
4608 过产品质量好的话就能为公司树立品牌，品牌的价值就比较可观了。
4609
4610
4611 4. 考虑一个项目产品的时候需要进行可行性的分析
4612 *经济可行性
4613 *技术可行性
4614 *是否有市场盈利(效益)
4615
4616 5. IT行业：
4617 *软件行业(做项目)
4618 >1. 做企业资源管理(ERP)的公司
4619 >2. 做经融行业的公司
4620 >3. 其他
4621 ...
4622
4623 *互联网行业(做产品->品牌)
4624 >1. 搜索(google，baidu)
4625 >2. 电商(阿里，京东)
4626 >3. 社交软件(Facebook，腾讯)
4627 >4. 门户网站(新浪，搜狐)
4628 >5. 视频网站(Youtube、优酷)
4629 >6. 杀毒产品(奇虎360)
4630 *嵌入式行业(软件绑定机器，是未来的趋势)(品牌)
4631 >大机器：服务器
4632 *IBM
4633
4634 >PC机
4635 *windows(只做软件)
4636 *Apple(有自己的开发语言，操作系统，硬件机器??，独立不依赖)
4637 >手机行业
4638 *1. Apple
4639 *2. 小米
4640 *3. 魅族
4641 ...
4642 >其他的智能终端
4643 ...
4644
4645 注：
4646 *趋势就是需要很大的服务器集群(处理数据)，超大型的数据库(存储数据)，方便好用的智能终端(用户体验，
4647 搜集数据)
4648 *智能终端会越做越小，越智能，越灵活可爱有灵气，酷酷的更好。
4649 *软件开发时的产品最好要做到不依赖，独立解耦，可移植，不依赖什么平台，这样的产品就可推广。
4650 *做软件就是卖服务，因为软件是看不见摸不着的东西，用户可能不太好接受这样的东西。如果能绑定一个机器
4651 终端的话，就成了一个实体了，客户
4652 的接受性就会提高，体验也会提高，反正就是能够使软件服务增值不少。
4653
4654 6. 如何用智能终端收集现实世界的数据。并且要时时刻刻地连接着服务器，进行对数据的入库出库操作，同时智能终端
4655 要向微机一样有操作系统，方便用户操作使用，给机器人传数据指令等。
4656
4657 7. java中的数据类型的转型有向上(子类向父类)转型，为默认的，向下转型需要加强转，并且要是父类对象要指向子类的
4658 实例，意思就是要实现继承和扩展，就像用接口对象指向接口的实现类，实现功能的扩展之后，就可以用接口对象或者
4659 是父类的对象经过强转为所指向的子类的实例之后，就可以使用子类的所扩展的功能。
4660 注：
4661 *这就是所谓的语言的多态特性，目的也就是实现扩展。
4662 *Java中实现扩展的方式有：优先想到的是接口(Interface)，其次是继承(extends)，还有就是数据抽象(Abstract
4663 Data)，抽象类(AbstractClass)，泛型，目的都是为了实现代码的可扩展性。
4664
4665 8. 凡是对数据的初始化都可以理解为填表单，即数据的流入，一般是流入所申请的堆内存中或者是直接流入栈中，经过
4666 业务逻辑数据处理之后可以把内存中的数据流入库到数据库中。
4667
4668 9. 关于开发的项目的抽取
4669 实现原理：
4670 *1. 在创建Service(数据服务)层的时候最好进行代码的抽取工作，把对数据库的数据流的入库出库操作抽取在实
4671 体类BaseService中用于其他的服务继承，这样可以减少代码的冗余度，使代码结构清晰。
4672 *2. 可以提供的方法有
4673 >数据流的入库操作：
4674 *1. 保存实体对象操作，save(entity)
4675 *2. 更新实体对象的操作，update(entity)
4676 *3. 删除实体对象的操作， delete(int id)
4677 >数据流的出库操作：
4678 *1. 获取数据库里该表的所有数据，getAll()，该表的所有数据流出库
4679 *2. 根据请求的参数数据，例如实体对象的编号id,流出所要请求的数据流，getById(int id)，
4680 getByIds(int[] ids).
4681 *3. 把基类服务BaseService做成泛型的类，这样可以增加可扩展性，并且提供一个会话工厂(SessionFactory)依赖
4682 用于对数据的入库出库操作，同时提供一个依赖类(Class<T>)对象,并在构造函数中进行初始化，这样子类在继承
4683 父类的时候就是会自动的调用父类的构造函数对类对象进行初始化为该类实体的类型。
4684
4685 注：
4686 *1. 泛型是java开发工具箱(jdk)后来才加进去的特性，目的也是为了提高代码的可扩展性，控制代码的结构复杂
4687 度原理就是类型的参数化，可以理解为自己定义的类或者是方法添加注入一个数据类型依赖，这是个新的编程思
4688 维。就像方法一样，依赖的注入是数据，而他依赖的注入是数据类型，表示的意思就是该服务类是属于哪个实体
4689 类的。
4690 *2. 在创建抽取基类BaseAction时候，原理是该基类要实现模型驱动的接口(ModelDriven<T>),用
4691 该接口可以实现对数据实体对象的属性数据流的封装,并且提供一个数据模型的依赖，在基类的构造函数中对数据
4692 模型进行初始化，同时提供一个供外部对象访问类内的数据实体模型对象的接口方法，之后其他的子类行为(Action)
4693 就可以继承该基类进行自定义的扩展，很方便。
4694
4695 10. 把对数据对象的初始化操作理解为填表单的操作，就是数据流的流入操作，就会更简单了。
4696
4697 11. 一个服务端是可以连接很多个终端的，意思就是服务器可以做成分布式？？的或者是大型的服务器，可以为很多个终端
4698 进行数据的流入流出服务操作。
4699
4700
4701
4702
4703
4704 2015/9/24
4705
4706
4707
4708
4709
4710 1. 数据收集的过程中，基本上流入的数据类型都是字符串类型的，如果用框架的话就会自动为你进行数据字符串类型到其
4711 他的数据类型的转换，否则的话需要自己提供对数据流的类型的转换工作，供数据流入库使用。
4712
4713 2. 在服务端编程中的控制器层是数据流的中转中心，要获取数据基本上是靠控制器提供的用于户存储数据的几个域对象来获
4714 取，域对象的作用域大小排列为：page(页面对象，生命周期在一个页面之内)->request(请求对象，可以包含几个页面，
4715 一次请求响应之后即是一个请求对象的生命周期)->session(当你开启一个浏览器的时候，就是开启了一个用户的会话
4716 操作，当你关闭一个浏览器的时候该用户会话的生命周期就结束了)->application(应用程序对象，当你开启一个服务器
4717 的时候，就是开启了了一个服务器的应用程序对象application，当你关闭一个服务器的时候该应用程序的对象生命周期
4718 即停止了)。
4719
4720 3. web编程其实就是有传统的界面程序编程的功能界面客户端的搬到了浏览器客户端，可以理解为浏览器是另外的一个操
4721 作系统，他有内核解析代码之后显示功能界面，同时也可以连接服务器请求响应资源。
4722 注：
4723 *传统的界面程序使用运行在操作系统(客户端)之上的，后来网络时代的到临，就有了另外一个客户端浏览器，用于
4724 访问web服务器里的资源，从而进行请求响应交互。
4725 *现在的功能界面程序基本上也都是可以运行在特定的操作系统之上的客户端程序，操作系统的作用就是提供一个兼
4726 容器(硬件和软件之间过渡使用)，使操作系统可以操作硬件机器，当然在操作系统之上可以开发运行各种应用程序
4727 为数据流的处理进行工作。如果客户端界面程序要访问服务器里的资源的话，就需要联网和服务器进行连接。
4728 *操作系统的内核作用：线程(线程就是能够处理数据的代码块??),线程之间通信(通过依赖)，网络(用于处理网络连接)
4729 驱动(可以用来驱动硬件工作)，内存(数据流的临时中转中心，一般数据流经过处理之后就会入库的数据库中，进行
4730 持久化的保存数据流),文件管理(对客户端的文件的管理工作)。
4731 *数据库是个很重要的数据流资源，程序开发中就是为了什么时候让数据流入库什么时候让数据流出库。
4732 *一般客户端和服务器端的连接都是同过协议，地址，端口(即哪个服务)进行的，就像在项目开发中的服务层(Service)
4733 与数据库之间的通信，表面上是通过会话工厂SessionFactory，实际上该工厂也是通过数据库的协议，地址，端口进行
4734 封装之后连接数据库进行通信。
4735 *封装的作用就是方便使用，信息隐藏的作用就是为了数据的安全。
4736 *有的时候对依赖的数据进行非空判断是非常有必要的，可以增强代码的健壮性，防止空指针异常错误的发生。
4737
4738 4. 白首为功名。旧山松竹老，阻归程。欲将心事付瑶琴。知音少，弦断有谁听？
4739
4740 5. 一般入库的数据流都是由终端采集的数据流经过类型装换成特定的属性，再封装成数据对象流之后入库。每一个对象是
4741 对应一张表中的一条记录(record)。
4742
4743 6. 前端jsp页面中的向作用域对象中取值的操作方式
4744 *jstl(Java 标准标签库，java standard tag library)标签:用el(表达式语言),
4745 >1. ${...Scope.对象}
4746 >2. <c:out value="${...Scope.对象}">
4747 *ognl(对象图导航语言Object Graph Navigation Language，struts标签):
4748 >1. %{#域对象.对象}
4749 >2. <s:property value="%{#域对象.对象}">
4750
4751 7. Spring对象工厂可以在服务器启动的时候就会触发ContextLoaderListener监听器,之后该对象工厂就是会为项目中用到的
4752 在工厂里配置到的对象进行实例化放在内存中，到时可以在Action行为中进行依赖注入工厂里实例化的Service对象，在
4753 服务层Service中依赖注入对象工厂里的会话工厂SessionFactory对象。
4754 注：在监听器xxxListener或者是拦截器xxxInterceptor中是不可以进行依赖注入Spring对象工厂里的对象。但是可以
4755 通过WebApplicationContextUtils.getWebApplicationContext(application)获取应用程序环境对象，也就是获取
4756 Spring对象工厂的环境，之后就可以通过该环境获取对象工厂里的配置的实例化好的对象。
4757
4758 8. 编程中的变量或者是方法的命名很大程度会影响到代码的可读性，从而影响代码的可理解性。所以要有好的代码质量，
4759 首先要时刻注意代码的可读性，命名问题。
4760
4761 9. 能用for循环的话就尽量用for循环遍历数组或者是列表集合(在Java中推荐使用增强for循环，可以避免不必要的错误
4762 发生)，迫不得已的话就用while循环遍历集合，因为while循环遍历要在循环体之外定义一个变量对象的依赖，会增
4763 大变量的作用域，破坏代码的可读性。
4764 注：
4765 *有一个定义变量的原则就是尽量缩小定义的数据依赖的作用域，如果该数据依赖需要扩大作用域以便在代码的
4766 多处用到，那就适当地把数据依赖的作用域扩大一点。
4767 *能用ArrayList的话就不要用Array。
4768
4769 10. 如何做一个日志拦截器：这个拦截器的作用是记录哪个用户在什么时候做了什么(实际上就是记录了用户的请求地址以
4770 及向服务器提交的参数数据信息)
4771 *解决方案：
4772 >1. 实现思路：创建日志实体类->创建日志拦截器类(继承扩展于MethodFilterInterceptor)->实现覆写
4773 拦截方法doIntercept(ActionInvocation invocation)->配置该拦截器类。
4774
4775 >2. 拦截doIntercept()方法的实现原理
4776 *1. 该拦截器的方法目的就是拦截用户的请求路径，获取请求参数封装到日志对象(logs)中之后
4777 入库。
4778 *2. 首先判断请求是否出现了异常
4779 *3. 注入Service层的依赖，用于日志类的入库操作
4780 *4. 封装日志类的属性
4781 *5. 入库
4782 >3. 实现的代码：
4783
4784 //设计日志实体类：Logs
4785 public class Logs{
4786
4787 //属性1：主键
4788
4789 //一般的属性
4790 //属性2：请求路径
4791 //属性3：请求参数
4792
4793 //关联关系属性
4794 ...
4795 }
4796
4797 //设计日志拦截器类：LogsInterceptor
4798 public class LogsInterceptor extends MethodFilterInterceptor{
4799
4800 //覆写抽象类中提供的方法doIntercept()
4801 @Override
4802 protected String doIntercept(ActionInvocation invocation){
4803
4804 //1. 首先判断请求是否出现了异常
4805 //注入依赖1：调用拦截器返回的结果result
4806 //注入依赖2：异常映射配置exceptionMappingConfig集合exceptionMappings
4807
4808
4809 //2. 注入Service层的依赖，用于日志类的入库操作
4810 //注入依赖3：应用程序环境applcationContext
4811 //注入依赖4：用应用程序环境applicationContext获取服务logsService实例化bean对象
4812
4813
4814 //3. 封装日志类实体对象的属性
4815 //注入依赖5：新建一个日志对象logs
4816 //
4817 //把日志对象的属性封装，请求路径lpath,请求参数lparam
4818
4819 4. 入库
4820 logsService.save(logs);
4821
4822 }
4823
4824 }
4825
4826 //在配置文件struts.xml中配置
4827 <interceptors>
4828 <interceptor name="" class=""></interceptor>
4829 <interceptor-stack name="defautl-stack">
4830 <interceptor-ref name="">
4831 <param name="includeMethods">...</param>
4832 </interceptor-ref>
4833 <interceptor-ref name="defaultStack"></interceptor-ref>
4834 </interceptor-stack>
4835 </interceptors>
4836
4837 注：
4838 *request.getRequestURI()和request.getRequestRUL()两个方法都是为了获取用户的向服务器的请求路
4839 径，不过前者获取的是：/项目工程名字+/动作action或者是控制器Servlet的名字，而后者是绝对的路
4840 径，包括协议名字+服务器名字+端口(服务名)+工程名字+动作action或者是Servlet的名字
4841 *计算机中的索引一般都是从0开始算的，具体原因可能和C编程中的指针位移习惯有关，例如：*(p+0)位
4842 移为0，解析为数组的第一个元素值。
4843 *MethodFilterInterceptor继承了AbstractInterceptor,并且实现了抽象拦截器类中的提供的intercept
4844 方法，而且还提供了一个抽象的方法doIntercept(),供子类扩展用的。
4845 *在拦截器中获取控制器的域对象request,session,application的两种方式：
4846 >1. 通过局部依赖调度者invocation
4847 代码示例：
4848 invocation.getInvocationContext().get(StrutsStatics.SERVLET_CONTEXT);
4849 >2. 通过控制器环境ActionContext
4850 代码实例：获取的是框架封装过后的域对象映射(Map)结构
4851 ActionContext.getContext().getSession();
4852
4853 14. 编程中的类，变量对象以及函数命名最好不要用什么a,b..x,y..，而应该用可读性高点的名字，类和变量对象以表达含
4854 义和需求为目的，方法以表达动作的含义为目的,所以最好用动词+宾语的结构命名。
4855 注：数组的下表因为是习惯用第一层扫描用下标变量i，第二层扫描下表用j,第三层用k,当然有业务需求的时候推荐可
4856 以取点有意义的名字。数据的扫描超过了3层，你就得想想另外的解决方案，最好是两层可读性才好。
4857
4858 15. web开发中的监听器
4859 *HttpSessionListener:用户会话监听器，作用就是用来在启动浏览器的时候触发监听器，调用监听器的
4860 contextInitailized(ServletContextEvent sce)方法，对要准备的数据流进行初始化之后放在控制器的数据中转
4861 中心。
4862 *ServletContextListener：控制器环境监听器，是在服务器启动的时候出发监听器，调用监听器的初始化环境
4863 的方法，准备数据流到控制器的数据中转中心。
4864 注：在监听器中获取数据流的方式就是通过依赖控制器环境事件对象的方法
4865 >getServletContext()获取应用程序域对象
4866 >getSession()获取用户会话对象
4867 *这两个监听器都是经过事件触发之后通过调用依赖Service层操作数据流的一个出库过程。
4868
4869 16. 如何自定义jstl标签库中的功能方法
4870 原理思路：
4871 *1. 自定义一个实体类，在类中定义实现一个自定义的方法
4872 *2. 配置：这个不用记，在jstl.jar包中有配置自定义标签方法的模板fn.tld,把自定义的实体类
4873 和方法在该文件中配置即可，并且把配置文件放在WEB-INF文件夹下。
4874 *3. 使用：在jsp页面中可以导入该标签的额uri地址，自定义一个前缀就可以使用了。
4875
4876 17. 要成为编程界的高手，必须要十年如一日的编程。
4877
4878 18. 如何处理web功能界面的锚标记<a>标签的权限过滤操作。
4879
4880 *实现原理：就是看操作的用户是否有权限操作该请求，如果没有权限，就不显示该标签，否则的话就是正常
4881 输出锚标签<a>
4882
4883 >1. 覆写类AnchorTag，把该类放在类的源文件夹下，该类就会覆盖Struts的jar包中的原来的类AnchorTag
4884 *覆写其中的方法doEndTag(),
4885 >如果用户有权限的话就显示锚标记<a>标签, return super.doEndTag();
4886 >否则不显示该超链接: return EVAL_PAGE;
4887
4888 19. 深入深入再深入，简化简化再简化。
4889
4890 20. 实践，沉淀，充实，深入，浅出。
4891
4892
4893
4894
4895
4896
4897 2015/9/25
4898
4899
4900
4901
4902
4903 1. 有的时候新的想法就是在喝咖啡或者是闲聊的过程中产生的。
4904
4905 2. Google公司的文化：自由，速度，激情，创意。
4906
4907 3. 在控制器Servlet中获取数据的方式式通过所依赖的请求域对象()进行的，而在框架2(Struts2)中是通过动作
4908 环境ActionContext获取所封装的域对象操作数据中转中心的数据流，在jsp页面端是通过页面环境(PageContext)获
4909 取控制中心的数据对象流的。
4910
4911 4. 未来的世界就是如何创造便捷灵巧的智能用户终端(可以用来做数据采集，或则是用户功能体验)，所以能做好数据采
4912 集的工作离项目的成功就是迈进了一大步。
4913
4914 5. web编程中的客户端页面就是数据流流入流出的端口。
4915
4916 6. 关于web开发中的做分页操作
4917 原理：
4918 *1. 对要分页的页面进行建模模拟设计成一个实体类：PageBean，包含的属性有当前页(currentPage)
4919 页面的大小(pageSize,这个属性可以在资源文件中配置),要转向的页面的数据流集合(recordList)
4920 以及流出数据对象的总记录数(recordCount),总页数(pageCount),页面的开始索引页
4921 码(pageBeginIndex),页面的结束索引页码(pageEndIndex)。
4922 *2. 再设计一个能操作数据库数据流流出库的查询语句助手(HqlHelper)，该助手工具类因该提供查询
4923 语句的过滤条件，例如从哪张表(from子句)，根据什么数据字段的参数值(where子句)，根据哪个
4924 字段排序(order子句)等过滤条件，还要提供外部对象访问页面实体类里的数据的接口。
4925 *4. 在Service层创建一个获取页面对象的方法getBean()，依赖客户端流入的数据参数流，即要转向的页
4926 面数码和查询语句助手HqlHelper的实例化对象，获取要转向的页面的数据流集合以及页面数据记录总
4927 记录数，并初始化页面对象的各个属性之后，把该页面的实体对象流放在控制器的数据中转中心。
4928 *3. 在客户端页面流出页面的实体对象流之后显示数据。
4929
4930 注：最好提供一个前台的客户端组件页面(pageView.jspf,这种扩展名文件的意思就是Java服务页的一
4931 个部分fragment)，就是用来做分页显示的，以后如果那个页面要用到分页操作的话
4932 直接调用静态包含该部分页面就可以了。当然在服务端要调用数据库出库所选择页面的数据流，
4933 放在数据中转中心，这样在要分页的客户端页面就可以流出并且显示该页面的数据流。
4934 实现方案：根据原理写代码即可。
4935
4936 7. 如何做一个简单的论坛。
4937
4938 *1. 实现步骤：实体设计并且映射表或者是建表之后逆向工程生成映射文件和实体类对象->控制器层：动作Action->
4939 ->服务层：Service->显示层：Java服务页面jsp
4940
4941 *2. 实现原理；
4942
4943 >1. 创建实体类：论坛实体(Forum)，主题(Topic),回复(Reply)
4944 >2. 控制器Action：ForumAction,TopicAction,ReplyAction,ForumManageAction
4945 >3. 业务逻辑层：ForumService,TopicService,ReplyService,ForumManageService
4946 >4. 数据流流出页面，并且显示。
4947 注： 项目开发中权限控制很重要，不同的角色会有不同的权限，例如一个论坛的游客(非注册用户user)，普通用户
4948 (registedUser)，论坛的管理员(admin),三个角色所拥有的权限是不一样的。
4949
4950
4951 8. 切记离开电脑之前一定记得保存文档。
4952
4953 9. 画UML图的时候实体类之间的关系有继承，依赖，实现，这三个关联关系的耦合度是依次降低的，在画图工具中的表现方
4954 式是表示关联关系的线的粗细程度。
4955
4956 10. jsp前端页面中下拉列表框(select)和复选框(checkbox)，在当你选择之后其实向服务器提交的数据参数流就是你选择的
4957 选项的编号(id)或者是编号集合数组(ids)。
4958
4959 11. 在jsp页面中如何实现列表项的上移操作和下移操作。
4960
4961 原理：
4962 >1. 这两个操作是要通过数据库里的数据属性position(就是对象记录在数据库表中的最大编号值，即位置)
4963 >2. 通过这为position这个位置属性对数据库流出的数据流集合进行默认的升序排序然后在客户端页面进行
4964 显示。
4965 >3. 当列表项需要上移的时候可以把所选择的当前列表项和它上面的这个列表项的位置position进行交换
4966 然后再次向服务器请求该表的所有数据，数据流出库之后进行显示。
4967 当列表项需要下移的时候原理同上移操作是一样的，只不过所选择的列表项和要交换的列表向是它的
4968 下面的那个，进行交换位置属性的值(就是两个对象的position的值进行交换)，然后在控制层再次向
4969 服务器请求数据流进行显示(这里所实现的方式就是通过在配置文件中对结果集的路由串进行动作重
4970 定向redirectAction)。
4971
4972 注：
4973 *1. 重定向和转发的最大区别就是是否是重新向服务器发送请求出库数据流，转发的意思就是客户端页面提交请求
4974 参数之后向服务器请求数据流之后把数据流放在控制器层的数据中转中心，再流向进行数据流显示的客户端页面，
4975 其中的提交的参数数据流(用框架的话一般是放在值栈valueStack里,用控制器Servlet的话就是放在请求参数对象
4976 Parameter里面，其实用Struts2框架也就是用参数拦截器把客户端流入的参数数据流封装到了值栈中)，数据库
4977 出库的数据流是放在数据中转中心的请求(request)域对象里。而重定向其实就是重新向服务器发送请求，当然因
4978 为是另外的一个请求所以浏览器的地址栏的请求地址是会发生变化的，内存中又重新建立了一个请求域对象，放在
4979 数据中转中心，保存数据库里出库的数据流，从而流向客户端页面。所以就是说重定向是会把原来的请求体中的
4980 数据流以及客户端提交的参数流全部抛弃，重新向服务器请求数据流。
4981 *2. 在框架2(Struts2)中结果类型：
4982 *(一)重定向
4983 >1. redirect：重定向到普通的页面，重新服务器请求一个资源页面。
4984 >2. redirectAction:重定向到一个动作，是重新向服务器请求数据，需要进过控制器控制
4985 重新请求的数据流。
4986 >3. chain:链式重定向，也是重定向到一个动作，这个重定向用的比较少，它会抛弃在数据中心
4987 中保存的数据流，但是请求参数流还是在值栈中的。
4988 *(二)转发
4989 >1. dispather: 作用就是用控制器分发数据流到页面的，就是所谓的转发，在Struts2中是默认
4990 的结果类型。
4991 *(三)什么时候用转发什么时候用重定向
4992 >1. 如果是数据流向的是客户端的页面，那就用转发dispatcher
4993 >2. 如果中转中心没有数据流流向页面，那就用页面重定向redirect
4994 >3. 如果需要重定向到另外的一个动作再次向服务器请求数据流，那就用redirectAction
4995 >4. 还有一点，就是一般像对数据流的入库(add,delete,update)操作推荐用动作重定向
4996 redirectAction,这样可以避免什么刷新重复提交数据，删除数据空指针的问题。像什么
4997 转到什么客户端页面(页面：list.jsp,saveUI.jsp)，就用转发。
4998 *(四)用于下载用的流类型(stream)
4999 >1. 配置方式：
5000 <result name="" type="stream">
5001 <param name="content-Type">要下载文件的内容类型</param>
5002 <param name="inputName">数据文件输入流</param>
5003 //内容处置方式,就是下载后显示文件的名字
5004 <param name="contentDisposition">attachment;filename="${...}"</param>
5005 </result>
5006 *(五)用于向客户端流向json数据格式的数据流的json类型
5007 注：
5008 *在Struts.xml配置文件中的需要继承一个json-default,才能实现json数据流的传输
5009 *json数据格式是一个轻量级的键值对模型的数据格式的数据流，是在js前端编程中
5010 用的最多的数据流格式，xml相反是重量级的。
5011
5012
5013 >1. 配置方式
5014 <result name="" type="json">
5015 <param name="root">json格式数据流</param>
5016 </resultr>
5017
5018
5019
5020 12. 项目开发中的关键在如何对现实中的实体对象建模成计算机中的类实体对象，建模完成之后就成了你可以进行采集
5021 处理入库的数据流，当然就可以方便你今后的数据流使用出库，给用户提供价值服务等等。
5022
5023 13. 项目的代码的可读性不好，之后的维护就会让你头疼。
5024
5025 14. 定时器Timer和TimerTask定时器任务
5026 *1. TimerTask实现了Runnable接口，待执行的任务置于run()方法中
5027 *2. 定时器Timer是一个安排TimerTask的类，因此两者一般一起工作。所以应用时因该首先创建一个
5028 TimerTask的对象，然后用一个定时器Timer的类对象安排执行它。
5029 注：一般定时器和定时器任务是配合使用的，使用的方式就是，例如,new timer()
5030 .schedule(TimerTask timerTask,long delay,long period);
5031
5032 15. 在web开发中Spring框架是如何进行依赖注入的：
5033
5034 *1. 用注解的方式：例如，
5035 @Resource
5036 private UserService userService;
5037 *2. 用配置的方式：
5038 private UserService userService;
5039 public void setUserService(UserService userService){
5040 this.userService=userService;
5041 }
5042
5043 注：这两种的依赖注入方式的原理是一样的，只不过一种是用注解的方式一种是用在类内部提供初始化数据依赖
5044 对象的set方法接口。这两种的依赖注入的方式都是通过框架调用该set接口，初始化依赖对象的，从而实现在
5045 其他的层中注入依赖，使层与层之间可以进行通信。
5046
5047 16. 移动终端可以采集数据，把数据流入服务端处理之后入库，以后就可以使用该数据流资源了。
5048
5049 17. 在框架2(Struts2)中获取原生Servlet域对象request，session，application等，因为在框架2中都别封装成为
5050 了映射(Map)的数据结构，所以有的时候需要用到原生的域对象的时候，可以通过一个和Servlet控制器耦合的
5051 控制器环境ServletActionContext来获取。
5052
5053 18. 在用户模块的注销登录功能(logout)有两种方式
5054 *1. 获取用户会话(session)之后移除键，例如代码：
5055 //这个获取的是框架2封装域对象session过后的映射机构
5056 ActionContext.getContext().getSession().remove("user");
5057 *2. 获取用户会话(session)之后是用户会话对象失效，即代码：
5058 //这个获取的是原生的Servlet控制器域对象
5059 ServletActionContext.getRequest().getSession().invalidate();
5060
5061 19. 使用递归的最好的例子，遍历部门树，而且这个功能方法是不可以用迭代来代替的。
5062
5063 *1. 原理：
5064 >1. 因为部门这个实体类在涉及到关联关系的时候有一个关联属性是自关联，就是子部门从属于父部门，
5065 所以可以通过递归把部门树以父部门和子部门的顺序排序，就是父部门下显示子部门，最好成树
5066 状。
5067
5068 >2. 定义一个方法：用于遍历部门树
5069
5070 示例：
5071 //遍历部门树的三个局部依赖参数：顶级部门列表topList，加在部门名字前面的前缀
5072 //prefix
5073 //新定义的一个列表集合newList
5074 public static void traverseDepartmentTree(List<Department> topList,
5075 String prefix,List newList){
5076 for(Department topDepartment:topList){
5077 //在方法中定义一个局部依赖：department
5078 Department department=new Department();
5079 //对部门对象进行数据属性封装
5080 department.setId(topDepartment.getId());
5081 //在每个遍历出来的部门的名字前面加上一个前缀用于区分父部门和子部门
5082 department.setName(prefix+topDepartment.getName());
5083 //把部门对象添加进新定义的列表集合中
5084 newList.add(department);
5085
5086 //进行递归调用，就是方法自己调用自己，再次把部门遍历进新的列表集合中
5087 traverseDepartment(topDepartment.getChildren()," "+prefix,newList);
5088 }
5089
5090
5091 }
5092
5093 注：
5094 *1. 要设计好实体类Department
5095 *2. 记住要操作集合，一定要用循环
5096 *3. 在操作实体对象的时候其实在数据库中唯一标识一个对象的就是主键字段(标号Id)，数据对象
5097 入库的时候数据库是会自动生成一个编号id唯一标识一条记录，数据对象出库的时候也是根据
5098 编号id进行出库的，出库整个表的所有数据记录或者是根据特定的编号出库特定的数据对象。
5099
5100
5101
5102 注：因为递归很不好理解，所以能用迭代处理的问题就不要用递归，可以增强可读性。
5103
5104 20. 无论是做项目还是做事都要做到分层独立解耦，不要有过多的依赖，层与层之间通过接口通信。
5105
5106
5107
5108
5109
5110 2015/9/26
5111
5112
5113
5114
5115
5116 1. 其实客户端流入的数据流就是你今后要在项目各层中要进行注入的依赖。
5117
5118 2. jbpm:Java业务流程管理框架的使用，用于处理工作流。
5119 (一)解决方案：
5120 *1. 首先用jbdl语言，其实就是用Eclipse安装的JBPM插件画业务流程定义图(JBPM 4 Process Defination)
5121 *2. 把业务流程定义图画好之后可以可以把编译成自动生成的.xml配置文件和.png图片打包成.zip压缩文件
5122 *3. 用java业务流程管理框架提供的流程引擎processEngine对业务流程定义图进行部署，就是把业务流程
5123
5124
5125 (二)实现方式
5126 *1. 导包
5127 *2. 配置
5128 *3. 使用
5129
5130 3. 在编程中会写注释也是一种能力，注释一般要表达的意思就是被注释的语句作用，是用来干什么的。
5131
5132 4. 必须检讨自己的行为，才能获得真正的经验。只有坚持不懈的学习，才能获取经验;若果不这样做，就无法得到经验，
5133 无论你工作多少年。--《代码大全》
5134
5135 5. 在软件开发行业，任何人放松下来就很快跟不上形式。为了让自己仍然有用，你必须紧跟潮流。对于求知欲强的年轻
5136 程序员来说，这会是他们的优势；而老程序员常常自认为有资历，讨厌年复一年的证明自己的能力。--《代码大全》
5137
5138 6. 关于搜狗的笔试
5139 1. 数据结构：？？？
5140 *1. 二叉树
5141 *2. 怎么遍历树
5142 2. 多线程
5143 3. finalize:Java技术允许使用finalize()方法在垃圾回收器将对象从内存中清理出去之前做必要的清理工作。
5144 这个方法是由垃圾回收器在确定该对象没有任何引用的时候对这个对象调用的。它是在Object对象中定义的，因
5145 此所有的类都继承类它。子类覆盖finalize()方法以整理系统资源或者是整理其他的清理工作。
5146 注：
5147 *1. finalize()和C++中的撤销函数(destruct)的功能很像。因为Java用的是Java虚拟机的垃圾回收器
5148 回收没有被引用的对象的，所以几乎没有必要使用撤销函数。
5149 *2. 垃圾回收器回收垃圾对象的时候是会自动呼叫对象的finalize()方法的，用来进行一些用户自定义
5150 的非内存清理工作。 因为垃圾回收器是不会回收对象所占内存以外的东西，所以有时是要自定义
5151 一些清理的方法如finalize(),处理文件和端口(服务)之类的非内存资源。
5152 *3. wait()方法也是在Object对象中定义的接口。
5153 *4. 使用finalize(),就是在垃圾回收器在回收对象期间进行的垃圾清扫工作(如关闭流等操作)，但是
5154 JVM(Java虚拟机)不保证此方法总是执行。
5155 4. join(): 意思就是在主线程中插入一个子线程，主线程进入阻塞状态，等待子线程执行结束之后，会唤醒主
5156 线程，主线程重新获取cpu(中央处理器单元)，继续运行。
5157 注：线程的5个状态：创建->就绪->运行->阻塞->销毁
5158
5159 5. 异常(Exception)和错误(error):
5160 *1. 异常(Exception)：异常意思就是程序可能会出错的地方，是可以抛出之后捕获处理的。
5161 >1. 编译时异常：Java编译器强制要求你必须要对出现的这些异常进行捕获(catch)
5162 >2. 运行时异常：当出现这样的异常时，总是由虚拟机接管。
5163 *2. 错误(error):表示有虚拟机侦测到的无法预期的错误，由于这是属于java虚拟机的层次的严重错
5164 误，导致Java虚拟机无法正常继续运行。因此，这是不可捕捉到的，无法采取任何的恢复。一般
5165 很少见，也很难通过程序解决。它可能源于程序的漏洞，但一般可能源于环境问题，如内存耗尽。
5166 错在程序中是无需要处理，而是有运行环境处理。
5167 注：什么时候对异常进行捕获，什么是对异常进行抛出？
5168 抛出异常就是声明一个异常对象，异常一般都是往上层抛，建议在被调用方抛出异常之后，在调用方要
5169 及时的处理捕获，尽量编译时异常转换为运行时异常。好一点的理解方式就是捕获异常其实是实例化抛出
5170 的异常对象，所以异常不要乱抛，不但会破坏代码结构，而且会给代码增加耦合度，
5171
5172
5173
5174 7. 其实编程中的注释就是伪代码，也就是你写代码的思路。
5175
5176 8. 写代码的时候要时刻记住你写的代码是要给其他人看的，你就会时刻注意你写代码的风格，尽量增加可读性。
5177
5178 9. 有注释的代码可以增加可读性，当你过一个月之后或者是很长时间再来看自己以前写的代码，如果没有注释的辅助你
5179 就会感叹这代码是谁写成这样的。
5180
5181 10. 开发项目的4大特性，从左到右依次重要性递减: 可行性->可读性->可扩展性->可维护性，但是要时刻谨记这几个要素
5182 因为都很重要，只有达到了这4个要求，你的项目才算是高质量的。
5183
5184 11. 架构师(即是核心技术的掌握者，同时也是领导，生成技术规格说明书)的主要职责：确定需求(系统的需求)->系统分解
5185 (用什么样的系统架构)->技术选型(具体采用
5186 什么技术，例如用什么操作系统，什么数据库，什么框架)->制定技术规格(技术规格说明书)
5187 注:
5188 *1. 能力有（技能[基础知识，开发，设计]、领导、决策、 业务、沟通）。
5189 >1. 系统架构需要的相关知识和经验。
5190 >2. 很强的自学能力和分析问题，解决问题的能力
5191 >3. 写作，沟通，表达，培训。
5192 *2. 架构师的目的：对系统的重用性，扩展性，安全性，性能，伸缩性，简洁性等做系统级的把握。
5193 *3. 一个好的架构师决定了整个项目的成败。
5194 *4. 思想->行为->习惯->性格->命运
5195
5196 12. 项目开发中的第一步也是最重要的就是给现实世界的实体物件进行建模设计成类实体，确定其应该有的属性，
5197 并提供对类属性的访问器子程序，使它能成为计算机操作的数据流。
5198
5199
5200
5201
5202
5203
5204 2015/9/27
5205
5206
5207
5208
5209
5210 1. 编程中的客户端一般就是数据流的流入端口，在服务器端有处理数据流的程序，其中包包括各种框架，都是为了更好的
5211 封装数据流，处理数据流服务的，并最终以一个一个对象的形式在数据库中表中以一条一条的记录的形式入库。如果流
5212 入的数据流是大文件，即不是字符串流(一般在控制端会把各个属性的字符串流封装成对象流)的形式流入控制端的，而
5213 是以另一种的数据流的格式，像.doc,.img,...等，其实这些数据流的本质也是字节流，只不过计算机给这写的大文件
5214 进行了封装分类处理，便于处理操作。像这些大文件是一般是会以文件(file)的形式在客户端流入到控制端，进过业务
5215 服务层封装处理该文件的字节流流入到服务端的指定的文件夹中，相反下载大文件就是文件流的一个出库过程，也是
5216 把要转换的大文件流包装层字节流之后出库到数据中转中心，再流向客户端经过解析后，成为你想要的文件内容格式，
5217 以及文件的名字。
5218
5219 2. 字节流(byte[])加上特定的编码格式就会成为字符串流(String)。
5220
5221 3. 在个物件建模类实体之后就成了计算机认识的数据流，也就是是你今后要在服务端编程的代码结构中要注入的依赖，例
5222 如在类中注入全局的依赖，在方法中注入局部依赖(包括方法的参数依赖，在方法体中注入的局部依赖)。处理依赖的数
5223 据流一般就是用编程语言的几种语句
5224 *1. 顺序语句：一般就是赋值语句，可以理解为赋值语句等号左边就是你新定义的变量，而右边就是你要注入
5225 的数据流，也可以理解为这条语句就是你要注入的依赖。
5226 *2. 判断语句：对依赖的变量进行判断，进行真值(true/false)判断之后决定数据流的流向。
5227 *3. 循环语句：操作大的数据流集合，例如早期的数组，以及后来扩展封装成的各种集合数据结构，列表集合(List)，
5228 映射(Map)，集合(set)。
5229 *4. 中断语句：
5230 >1. return(返回语句): 从函数中返回，不执行该语句下面的语句，一般如果函数或者是方法有返回值的话就是会返回
5231 一个值。这个关键字是语言级别的，表示了调用堆栈的返回。
5232 >2. break(中断语句): 中断跳出当前的循环。
5233 >3. continue(继续语句): 中断本次的循环，但是不中断整个的循环。
5234 >4. System.exit(0)(退出程序的方法): exit(0)表示正常终止程序，exit(1)表示异常终止程序。这个
5235 退出程序的方法意思就是将整个Java虚拟机都关掉了，内存里根本就不会有什么东西。这个函数是
5236 系统调用级别的，表示了一个进程的结束。
5237 >5. exit函数用于在程序运行的过程中随时结束。stdlib.h void exit(int status);
5238 >6. 每个进程都有一个返回值的。进程开始时是由一个系统的启动函数调用了main函数的，例如：
5239 int nMainRetVal=main();当从main函数中退出之后，启动函数便调用exit函数，正常情况下，
5240 main函数是不会调用exit函数的，而是有return 0；返回值给nMainRetVal的，exit在接收这个
5241 值作为参数的。所以正常情况下是以exit(0)退出的。如果程序发生异常，你可以调用exit(1)
5242 强制退出程序，强制终止进程，其中1(非0)表示不正常退出。
5243 注：
5244 *1. 进程就是一个应用程序，一个进程可以包括很多个线程，而线程就是一个处理数据的代码块。
5245 *2. 返回给操作系统的，0是正常退出，其他值是异常退出，在退出前给一些提示信息，或在调试
5246 程序中察看出错原因。
5247 *3. exit()和return的区别：
5248 >1. 按照ANSI C,在最初的调用的main()中使用return和exit的效果是一样的。但要注意
5249 这里的所说的是"最初调用"，如果main在一个递归程序中，exit仍然会终止程序，
5250 但是return会将控制权交给上一级，直到最初的那一级，此时return才会终止程序。
5251 >2. 即使在除main之外的函数中调用exit(),它也将终止程序。
5252 *4. _exit()和exit()的区别：
5253 >1. 头文件
5254 *exit:#include<stdlib.h>
5255 *_exit:#include<unistd.h>
5256 >2. _exit()直接使进程停止运行，清除其使用的内存空间，并销毁其在内核中的各种数
5257 据结构。
5258 exit()则在这些基础上做了一些包装，在执行退出之前加了若干都工序。
5259 exit()函数在系统调用之前要检查文件的打开情况，把文件缓冲区的内容写回文件。
5260
5261
5262 *5. 捕获异常的语句try...catch：用于在程序的可能出错的代码的块捕获异常。
5263
5264 4. 定义变量的时候尽量不要用操作符，因为用操作符会降低可读性。
5265
5266 5. 在编程中各种语言都有其存在的必要性，存在即是合理的。但是站在可读性角度来看，我觉得Java做的好一点。效率的话
5267 C/C++。
5268 注：各种语言的特性
5269 *1. C：能够较好的嵌入式硬件开发，可以移植。
5270 *2. C++: 有个各种大型的类库，同时兼容C,能移植，有具有面向对象编程的特性，效率高，适用于大型的应用系统
5271 同时也可以写各种类库供其他的层次及语言调用，因为效率高。但是学习难度大。
5272 *3. Java: 使用于做移动的web开发，可操作性强，有各种框架，但是不适用于写大型的界面程序，虚拟机解析需要
5273 时间。可以写服务器的处理数据的程序，也可以做终端的客户端(Android,jsp)
5274 *4. C#: 和Java差不多，但是有平台的依赖性束缚。
5275 *5. php：使用于做安全性不高的网站，是一门嵌入脚本语言。
5276 *6. Objective-c: 水果公司的语言，做iOS应用开发的话需要学这个。
5277 *注：C++是一门很深的语言，很底层的东西都是用它来封装的。因为C++门槛高，所以对程序员的要求是相当高的。
5278
5279 6. 细节很重要！
5280
5281 7. 客户端的作用就是可以不断的向服务器端请求数据流或者是提交数据流搜集数据。
5282
5283 8. 要增加代码的可读性，可以尽量减少操作符的使用，因为操作符比自然字符可读性要低，有点抽象，像判断if(!false)这
5284 样的语句，虽然说显得很专业，但是没有if(true)好理解。
5285
5286 9. 在写方法体带代码的时候，一般会有注入局部参数的依赖，至于在方法体内部注入依赖，可以遵循的原则
5287 就是用到即定义，尽量缩小所定义依赖的作用域。这样的代码结构就更好，可读性会提高许多。所以所遇到数组或者是
5288 集合，能用for循环(在Java中可以使用增强for循环)就不要用while循环，不过有的时候必须要用到while循环的时候那就
5289 用while。
5290 注：while循环一般是要般循环变量写循环体的外部，没有for循环简洁。
5291
5292 10. 在类中要注入全局依赖(就是在类中子程序可以访问)的话，建议把依赖写在类的前面，子程序写在后面，这样也可以增加
5293 可读性。
5294
5295 11. 对于在Spring框架中的面相切面的编程
5296 （1）一般会涉及到的概念：
5297 *1. 织入(weave)：可以理解为在插入，例如在一个方法的前面插入一段处理数据的代码程序。
5298 *2. 通知：就是将要织入的方法。
5299 *3. 连接点(JointPoint)：通知将要织入的地方位置。
5300 *4. 切点(Point-cut)：所有的连接点组成切点。
5301 *5. 切面(Aspect)：所有的切点和通知组成切面。
5302 *6. 前置通知(aop:before)：在方法前面织入的通知。
5303 *7. 后置通知：after,aop:after-returning(能获取返回值)。
5304 *8. 环绕通知(aop:around)：在方法前后织入的通知。
5305 *9. 异常通知(aop:after-throwing)：在方法抛出异常之后织入通知。
5306 （2）怎么配置切面：
5307 >1. xml配置文简单的方式
5308 *1. 怎么配置事务通知
5309 <!--配置通知:数据库的事务-->
5310 <tx:advice>
5311 <tx:attributes>
5312 <tx:method name="" propagation=""/>
5313 </tx:attributes>
5314 </tx:advice>
5315
5316 <!--配置切面-->
5317 <aop:config>
5318 <!--配置通知-->
5319 <aop:point-cut id="" expression="execution(* *(..))"></aop:point-cut>
5320 <!--配置切面-->
5321 <aop:advisor advice-ref="" point-ref="">
5322 </aop:config>
5323 *2. 怎么配置自定义的通知
5324 <!--配置切面-->
5325 <aop:config>
5326 <!--配置切面-->
5327 <aop:aspect ref="">
5328 <!--配置切面和通知:以后置通知after-returning为例-->
5329 <aop:after-retruning point-cut="" method="" />
5330
5331 </aop:aspect>
5332 </aop:config>
5333 >2. 注解annotation的方式：
5334 示例代码：定义配置一个切面
5335 @Component
5336 @Aspect
5337 public class AspectTest{
5338
5339 //前置通知
5340 @Before("execution(* *(..))")
5341 public void testBefore(JointPoint joinPoint){
5342 }
5343
5344 //后置通知
5345 @After("execution(* *(..))")
5346 public void testAfter(JointPoint joinPoint){
5347 }
5348
5349 //有返回值的后置通知
5350 @AfterReturning(value="execution(* *(..))",returning="result")
5351 public void testAfterReturning(JointPoint jointPoint,Object result){
5352 }
5353
5354 //环绕通知
5355 @Around("execution(* *(..))")
5356 public void testAround(ProceedingJointPoint jointPoint){
5357 }
5358
5359 //异常通知
5360 @AfterThrowing(value="execution(* *(..))",throwing="ex")
5361 public void testAfterThrowing(JointPoint jointPoint,Exception ex){
5362 }
5363 }
5364 注：要好好的理解面向切面编程的切面(Aspect),可以和面向对象编程的类进行类比，可以把切面中的切点(所有的
5365 连接点)理解为类中的属性依赖，把通知理解为类中的访问器子程序。要在某个方法里织入一个通知意思就是
5366 在织入的地方横切织入一个方法用于处理数据。
5367
5368
5369
5370
5371
5372
5373 2015/9/28
5374
5375
5376
5377
5378
5379 1. 现在服务器端的数据处理技术已经成熟了，以后的重点在于客户端的设计研发，就是如何便捷地搜集数据。
5380
5381 2. 生活就像是一座围城，在城里的想出去，在城外的想进来。因为人们总是对这个笼子里的世界感到好奇。
5382
5383 3. 梅贻琦：大概或者也许是，不过我们不敢说。可是学校总认为，恐怕仿佛不见得。
5384
5385 4. 感性思维，理性思维，主观想法，客观想法。
5386
5387
5388
5389
5390
5391 2015/9/29
5392
5393
5394
5395
5396 1. 在代码中注入依赖的时候特别要注意注入依赖的位置，因为这涉及到注入的依赖的作用域问题，切忌不能随便
5397 扩大注入依赖的作用域，使代码结构混乱，破坏代码的可读性，同时也有可能增加出错的可能性。
5398
5399 2. 对于客户端的设计，一定要注重用户体验，不能太怪物，太吓人，首先考虑可行性，再考虑注重实用性，灵巧
5400 性，用户的可接受性，是否能够投入市场。
5401
5402 3. 行走在汪洋中的一条破船，就会随风而走，随心摆渡，飘到哪里算了就是那里。
5403
5404
5405
5406
5407
5408
5409 2015/9/30
5410
5411
5412
5413
5414 1. 乔布斯
5415
5416 *1. 死亡可能是生命中最大的发明，是生命交替的媒介，送走老人们，给新生代开出道路。现在你们是
5417 新生代，但是不久的将来，你们也会逐渐变老，被送出人生的舞台。
5418 *2. 求知若饥，虚心若愚。(Stay hungry,Stay foolish!)
5419 *3. 你们时间有限，所以不要浪费在重复他人的生活上。不要被教条束缚，盲从教条就是活在别人思考
5420 的结果里。不要让别人的意见淹没你的心声。最重要的，你要有勇气去听从你直觉和心灵的指示--
5421 它们从某种程度上知道你要成为什么样子，所有其他的事情都是次要的。
5422 *4. 创新决定了你是领袖还是追随者。创新是无极限的，有限的是想象力。如果是一个成长性企业，创新就是要让
5423 产品使人更有效率，更容易使用，更容易用来工作。如果是一个萎缩的行业，创新就是要快速的从原有模式退出
5424 来，在产品及服务变得过时时，不好用之前迅速改变自己。
5425 *5. 和最优秀的人一起工作，一个创业公司的前十个员工决定了公司的水平。为了把事情办好，工作不仅仅由一个人
5426 完成，必须找到能力非凡的人来合作。最终把个体互动产生的力量汇总，这样整体的力量就会远远大于个体的力量
5427 总和。
5428 *6. 完美的质量没有捷径，必须将优秀的质量定位给自己的承诺，并坚定不移的坚持下去。当对自己的要求更高，并
5429 关注所有的细节后，产品就会和别人不一样。
5430 *7. 在产品中置入美学因素。
5431 *8. 了解消费者需求而不掌握消费者的反馈意见。
5432 *9. 创造力就是把所有的相关的事务连接起来。
5433 *10. 不招聘俗套的员工。能够让Macintosh成为伟大产品的部分因素就是得益于从事此相关的工作人员都是音乐家、
5434 诗人、即艺术家等，甚至还有动物学家和历史学家，巧合的是，他们又是世界上最优秀的电脑科学家。
5435 *11. 不追求复杂，简单就是快乐。苹果绝对是努力研发简单的应用方案，因为人们喜欢简单明了。
5436 *12. 出售梦想而非产品。苹果打动消费者的不是其生产的产品本身，而是这些产品所代表的具体涵意。
5437
5438
5439 2. 扎克伯格
5440 *1. 一个透明度高的世界，其组织会更好，也会更公平。
5441
5442 3. 李彦宏
5443 *1. 做自己喜欢并且擅长的事情，不跟风，不动摇。
5444 *2. 硅谷给我最大的感触是，希望通过技术改变世界，改变生活。
5445
5446 4. web2.0时代是互联网的巅峰，因为有大量的网上用户，也成就了不少的伟大的公司。这个时代的网络搜集数据的
5447 方式就是通过客户端(一般是网站的表单)进行的。
5448
5449
5450
5451
5452
5453 2015/10/1
5454
5455
5456
5457
5458 1. 在对数据库中的数据进行操作的时候，实体对象的编号(id)很重要，因为一切的数据流的操作都是根据这个字段
5459 进行的。在数据收集的时候，也就是数据对象封装收集之后的属性数据时再经过业务逻辑端的数据处理后入库到
5460 数据库中，数据库会自动的为你的对象流生成一个唯一标识的编号。以后数据对象出库的时候也就是根据这个编
5461 号字段进行的，包括删除/更新对象记录也都是根据这个编号字段找对应的实体对象之后再进行删除/更新。
5462
5463 2. 一般在进行数据流的收集的时候，一定要切记在客户端提交了什么属性流在控制端的数据中心都要对对象的属性
5464 流进行封装，用Struts2框架的模型驱动(ModleDriven)属性的特性，框架就是会自动的为你的表单对象的一般属
5465 性进行封装，剩下的有大对象之间的关联关系以及对象的特殊属性，需要自己维护的属性等是要自己在控制端进
5466 行封装的，不过这里你要遵循一个规则就是在客户端提交什么数据你就要对什么数据进行一定的封装，因为这些
5467 数据是你以后要用的，例如，数据流的出库操作。
5468
5469 3. 在js编程中的操作的依赖一般就是文档流的节点，因为Js编程是面向浏览器的编程，其中要为文档流添加特效的
5470 时候基本上是要同过事件来操作，这个原理和界面编程的是一样的。其实事件就是系统默认定义的一个方法，例
5471 如单击事件，就在在鼠标单击按钮的时候经过监听器侦测之后所触发的一个方法。在事件的方法中，一般传递的
5472 就是函数指针，这就是所谓的回调函数，意思就是你在单击某个按钮的时候会执行的一个方法。
5473 注：操作系统中使用了大量的回调函数，其实就是为了面向桌面编程时对桌面事件的一个响应操作。jQuery库也
5474 就是封装js操作文档流节点对象方法的一个库，当然要响应浏览器中按钮的单击事件，所以也少不了回调函数的
5475 调用。其实到最后你会发现，操作系统和浏览器原理都是差不多的，只不过操作系统是连接本地的文件管理系统
5476 和数据库，运行在操作系统之上的就是桌面的界面程序(用来搜集数据)，而浏览器的作用就是连接的是远程的文
5477 件，就是在服务器端的文件，数据库，而显示在浏览器端的就是文档流(可以用来收集数据)。
5478
5479 4. 对数据依赖的操作无非就是三种操作
5480 *1. setter：给数据依赖提供一个初始化值的方法接口。
5481 *2. getter：给数据依赖提供个一个访问它的方法接口。
5482 *3. delete：给数据依赖提供一个删除它的方法接口。
5483
5484 5. 枚举(Enumeration)与迭代(Iterator)：
5485 *1. 相同点
5486 >1. 都是用来遍历迭代集合的数据的接口
5487 *2. 不同点：
5488 >1. 迭代器是枚举器的升级版
5489 >2. 当遍历集合的时候用迭代器提供了一种安全方式,可以在迭代过程中删除底层集合中的元素，原因
5490 是当遍历集合是底层集合删除元素时，迭代器提供的方法remove()会在移除元素之后自动更新迭代
5491 器所维护的指针，继续遍历下一个元素。而相反枚举器是不会更新指针的，意思就是在遍历的时候
5492 删除了元素，枚举器就会自动的跳过下一个元素遍历其他的元素。
5493 >3. 其他线程是不能够修改正在被迭代器Iterator遍历的集合里面的对象，所以说迭代器相对安全。
5494 >4. 迭代器主要用于迭代集合对象，而枚举器主要用于Vector和Hashtable.
5495 >5. 枚举器的遍历效率要比迭代器高(2倍)。
5496
5497 注：
5498 *1. 推荐使用迭代器Iterator。
5499 *2. 集合的底层实现方式还是数组。
5500 *3. Java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针(引用)，所有的数据
5501 结构都是可以用这两个数据结构来构造的。
5502
5503
5504
5505
5506
5507
5508 2015/10/2
5509
5510
5511
5512
5513
5514 1. Java基础中的集合很重要，因为当你要操作多个数据的时候，用集合容器是你唯一承载多个数据对象的选择。
5515
5516 2. 前端编程中Js难学的因素：
5517 *1. 数据变量的基本数据类型太少，用的最多的就是string字符串类型
5518 *2. 定义方法时是没有方法的返回值的声明
5519 *3. 语法很奇怪，数据模型无论是定义数据还是方法的时候都习惯用Json格式的模型，原因就是json的意思就是Java
5520 Script Object annotation(JavaScript 对象表示符)，就是用来表示JavaScript对象的数据的。
5521 *4. 无法在静态编译时检测错误，很容易为后面的调试埋下隐患。
5522
5523 3. Google：Do cool things that matter.
5524
5525 4. 其实所有的类都可以依据JavaBean的模型进行编写，这样的话代码的可读性会提高很多。
5526 注：如何命名类中的方法？动词+宾语(名词)
5527 （一）动词：
5528 *1. 入库数据流操作：
5529 >1. 保存：
5530 >1. 模型层(JavaBean)：set,init
5531 >2. 业务逻辑层(Service)：save,set,add
5532 >3. 控制层(Controler)：add
5533 >2. 更新：
5534 >1. 模型层(JavaBean)：set
5535 >2. 业务逻辑层(Service)：update
5536 >3. 控制层(Controler)：edit
5537 >3. 删除:
5538 >1. 模型层(JavaBean)：destroy,close
5539 >2. 业务逻辑层(Service)：delete
5540 >3. 控制层(Controler)：delete
5541 *2. 出库数据流操作：
5542 >1. 模型层(JavaBean)：get
5543 >2. 业务逻辑层(Service)：get，find
5544 >3. 控制层(Controler)：list
5545 （二）名词：体现需求含义，就像变量，类命名一样的。
5546
5547 注：这里只是说一般，有一些特殊的业务逻辑有可读性较好的动词也可以使用，但是有一个原则一定要注意代码的
5548 可读性，是否真正的体现了方法的功能。
5549
5550 5. 框架Spring是一个很伟大的发明，提出可很多的新的编程思想,其实就是抽象工厂模式的实现方式，对于一些需要注入的
5551 对象，依赖对象工厂进行装配实例化
5552 *1. 控制反转(inverse of control)
5553 *2. 面向切面编程(Aspect of Programming)
5554 *3. 依赖注入(Dependency Injection)
5555
5556 6. 耦合度由高到底的排序：继承(extends)>依赖(Dependency Injection)>实现(implements)
5557
5558
5559
5560
5561 2015/10/3
5562
5563
5564
5565
5566 1. 不如别人就要认，要追赶！盲目的自我迷信终究是在害自己。
5567
5568 2. 智慧的代价是矛盾，这是人类对人行观开的玩笑。
5569
5570 3. Deliver your words not by number but by weight.言不在于多,而在有物。
5571
5572 4. A silent tongue and true heart is the most admireble things on earth.缄默的嘴，真诚的心，是世界上最令人赞
5573 美的东西。
5574
5575 5. Take time when time cometh,lest time steal away.时来必须要趁时，不然时去无声息。
5576
5577 6. 编程就是解决如何收集数据流(客户端)的问题和如何处理好数据流的问题(服务端)。
5578
5579 7. MyEclipse是Eclipse装上插件之后的产物，是Genuitec公司的，一般企业使用是要收费的。如果是做Web开发的话，建议
5580 用这个集成开发环境，因为它继承了很多的插件，例如对各个框架的集成等。用Eclipse的话需要自己装插件，编译，调试
5581 测试，部署等都不太方便。
5582
5583 8. Java的核心思想在于JavaBean，一切理念都凝聚在这颗豆子。
5584
5585 9. 细节决定成败！
5586
5587 10. 如果是控制器出库数据流 ，就在数据中心准备好数据之后用转发到另外一个页面，如果是入库数据，就在入库数据流之
5588 后重定向到另外一个页面，这样写的代码健壮性就会得到提高，漏洞减少。
5589
5590
5591
5592
5593 2015/10/4
5594
5595
5596
5597
5598 1. web开发中网页就是用来收集数据的客户端，网页是用表单form来收集数据的，其实可以这么想，严格的MVC设计模式
5599 就是一个实体类对应一张表，一个控制该实体数据流流转的控制器，从而在页面的表示方式就是对应一张网页的表单
5600 或者是列表。
5601 注：在客户端的一张表单在服务端的表示方式就是一个实体对象。
5602
5603 2. 明清的史学失去了宋元时候的活力，从而导致受教育者缺乏历史修养，思想麻木，思维僵化，固步自封，加之对事件的
5604 认识缺乏历史的眼光和谋略，为中国近代的屈辱埋下了祸根。
5605
5606 3. 爱因斯坦：一个没有个人独创性和个人意愿的规矩的统一的个人所组成的社会，将会是一个没有发展可能的不幸社会。
5607
5608 4. 顾炎武：八股之害等于焚书，而败坏人才有甚于咸阳之郊。
5609
5610 5. 鲁迅：八股原是愚笨的产物。
5611
5612 6. 周作人《论八股文》：八股文...它永就是中国文学--不，简直大胆一点说是中国文化的结晶......。
5613
5614 7. 吴敬梓《儒林外史》：八股文若做的好，随你做什么东西，要诗就诗，要赋就赋，都是一鞭一条痕，一掴一掌血。
5615
5616 8. 顾炎武：八股之害，等于焚书，而败坏人才，有甚于咸阳之郊所坑者，但四百六十余人也。
5617
5618 9. Friendship multiplies joys and divides griefs. 友谊可以增添快乐，同时减轻痛苦。
5619
5620 10. 《代码大全》：
5621 *1. 使用一个检查表，其中记录着你在本项目迄今为止所犯的，以及在过去的项目中所犯的错误类型。
5622 *2. 越早修复这些缺陷，成本就越低，因此，要尽早地对测试进行规划并找出缺陷。
5623 *3. 总而言之，我认为测试现行的编程是过去十几年中所形成的最有用的软件开发实践之一，同时也是一个
5624 非常好的通用方法。
5625 *4. 在编写代码之前先编写测试用例，能更早的把需求上的问题暴露出来，因为对于一个糟糕的需求来说，要写
5626 出测试用例是一件很困难的事情。
5627 *5. 如果在对变量赋值之前将其定义了两次，那么需要的不是一个更好的程序，而是一台更好的计算机！其实这
5628 是多此一举，就算当时没有出错，也是非常危险的。
5629 *6. 一个变量不能被销毁两次。变量不能死而复生，如果变量复活，那说明变量写的太随意了。同样，对指针销
5630 毁两次是致命的--想让你的计算机崩溃的最好方式就是两次释放同一个指针。
5631 *7. 你如果越了解你的对手--错误，你的错误就越有可能做得更好。
5632 *8. 错误并非平均地分布在所有的子程序里面，而是集中在少数几个子程序里面。人们还发现这些容易出问题的
5633 子程序是“程序中最昂贵的部分”(Jones 1986a),他们每一千行代码包含的缺陷达到50个之多，修复它们的代
5634 价是开发整个系统的成本的10倍。(这里的成本包括客户支持以及现场的维护)
5635 *9. 俗话说"时间就是金钱"，我的推论是"金钱也是时间"，也就是说，如果能避免卷入到那些烦人的子程序中，
5636 那么你就可以省下近80%的错误。
5637 *10. 提高质量就能缩短开发周期，同时降低开发成本。
5638 *11. 大多数错误的影响范围是相当有限的，85%的错误是可以在修改不超过一个子程序的范围内得以修正。
5639 *12. 许多的错误发生在构建的范围之外，三种最为常见的错误源头，它们分别是:缺乏应用领域知识，频繁变动
5640 且相互矛盾的需求，以及沟通和协调的失效。
5641 *13. 大多数的构建期错误是编程人员的失误造成的。
5642 *14. 让人惊奇的是，笔误(拼写错误)是一个常见的问题根源。有史以来最为昂贵的软件错误--其代价分别是16亿
5643 美元，9亿美元，2.45亿美元，都是因为原本正确的程序中的一个不正确的字符造成的(Weinberg 1983)。
5644 *15. 程序员所犯错误的原因，错误理解设计这条会经常出现。因此花点时间来彻底理解设计是十分值得的。
5645 *16. 大约85%的错误可以在几个小时的时间内修正，大约15%的错误可以在几个小时到几天之内得以修正，只有大
5646 约1%的错误需要花更长的时间(Weiss 1975;Ostrand and Weyuker 1984;Grady 1992)。因此，你因当尽可能
5647 地通过早期对需求和设计的复查来避免软件中的硬伤，以及尽可能有效地处理大量存在的小错误。
5648 *17. 不同组织的人会有完全不同的错误处理经验，因此，很难将在其他组织所获取的经验应用到你所在的组织中。
5649 一个良好的开始就是评估你的开发方法，以便了解问题出现在什么地方。
5650 *18. 不在调试上面画时间？那真是一个很有价值的目标！
5651 *19. 开发高质量的软件，比开发低质量的软件然后修正的成本要低廉。
5652 *20. 少数几个项目，如航天飞机的软件，能够达到50万行代码0缺陷的水平，这需要使用一个系统的形式化开发方
5653 法，同事复查(peer review),以及系统的测试(Fishman 1996)。
5654
5655
5656 11. 迄今为止，编程中所犯的错误最多的种类
5657 *1. 配置文件中的属性写错，这种错误也是最难找的，一般没经验的就会找死。
5658 *2. 配置文件的文件头和jar包不兼容。
5659 *3. 导包冲突。
5660 *4. 服务端代码的空指针异常，这种错误一般会有很多，但是可以通过调试解决。
5661 *5. 前端js编程中，要特别注意变量的拼写，因为这个东西没有后台语言编码如Java有编译器编译时的错误检
5662 查提示，出错了就坑爹了。
5663 注：一般服务端的代码逻辑错误也有点难找，其他的可以通过调试缩小范围排错，还有就是配置文件的错误要尽量
5664 避免，因为这种错误和编译器的提示打不着边，很难找到的。
5665
5666 12. 重申：开发项目的首要目标就是如何管理项目的复杂度。
5667
5668
5669
5670
5671
5672
5673 2015/10/5
5674
5675
5676
5677
5678 1. 梅贻琦：
5679 *1. 诸君在国外的时候，不要忘记祖国；在新奇的社会里，不要忘掉自己；在求学遇到困难的时候，务要保持科学
5680 态度，研求真理。
5681 *2. 以老师为大鱼，学生为小鱼。认为“学校犹水也，师生犹鱼也，其行动犹游泳也。大鱼前导，小鱼尾随，是从游
5682 也。从游既久，其濡染观摩之效自不求而至，不为而成。”以教师的高尚品行来自然地引导学生，达到“不为而
5683 成”，是很高明的教育方法。
5684 *3. 老师不但要“以己之专长之特科知识为明晰讲授”，而要为学生的“自谋修养、意志锻炼和情绪裁节”树立榜样。
5685 *4. 身教重于言教。
5686 *5. 所谓大学者，非谓有大楼之谓也，有大师之谓也。
5687 *6. 诸君在美的这几年，亦正是世界上经受巨大变化的时期，将来有许多组织或要沿革，有许多学说或要变更。我
5688 们应该保持科学家的态度，不存先见，不存意气，安安静静的去研究，才是正当的办法，才可以免除将来冒险
5689 的实验，无谓的牺牲。
5690 *7. 学术自由和独立思考在这样的环境里自然魏然成风，且大大滋养了学生。
5691 *8. 一个大学之所以为大学，全在于有没有好教授。孟子说所谓故国者，非谓有乔木之谓也，有世臣之谓也，我现
5692 在可以仿照说所谓大学者，非谓有大楼之谓可，大师之谓也。
5693 *9. 余对政治无深研究，于共产主义亦无大认知。对于校局，则以追随蔡孑民先生兼容并包之态度，以克尽学术自
5694 由之使命。昔日之所谓新旧，今之所谓左右，其在学校应均予以自由探讨之机会。这是“昔日北大之所以为北
5695 大，将来清华之所以为清华”的根本。
5696 *10. 假使一个政府的法令，可以和梅先生说话那样严谨，那样少，那个政府就是最理想的。
5697
5698 2. 西南联大：
5699 *1. 冯友兰在西南联大教书，留有长髯，身穿长袍，颇有道家气象。一次他去授课，路遇金岳霖，金岳霖问："
5700 芝生，到什么境界了？"冯答："到天地境界了。"两人大笑，擦身而过，各自上课去了。
5701 *2. 在西南联大时，有一次学生请他将小说和哲学的关系，他讲完之后的结论是小说和哲学没有关系。
5702
5703 3. 金岳霖：
5704 *1. "与其在部里拍马，不如在水果摊子上唱歌",这是一种人生境界，不说远大的理想了，在今日，能实践金岳霖
5705 这个早年的愿望就很不容易。
5706 *2. "与其做官，不如开剃头店，与其在部里拍马，不如在水果摊子上唱歌。"
5707 *3. 金岳霖自始至终都以最高的理智驾驭自己的感情，他终生未取，爱了林徽因一生。
5708
5709 4. 罗敷
5710 *1. 昨夜星辰昨夜风，花楼西畔桂堂东。身无彩凤双飞翼，心有灵犀一点通。
5711
5712 5. 梁启超：
5713 *1. 只有读书可以忘记打牌，只有打牌可以忘记读书--梁实秋
5714 *2. 美术之所以能产生科学，全从真美合一的观念产生出来。他们觉得真即是美，有觉得真才是美，所以求美，
5715 从求真入手。
5716 *3. 世界之运，犹乱而进于平，胜败之原，由力而趋于智，故言自强于今日，以开明智为第一义。亡而存之，
5717 废而举之，愚而治之，弱而强之。
5718 *4. 我们一面要养成读书心细的习惯，一面要养成读书眼快的习惯。心不细则毫无所得，等于白读；眼不快
5719 则不够用，不能博搜资料。
5720 *5. 少年智则国智，少年富则国富，少年强则国强，少年独立则国独立，少年自由则国自由，少年进步则国进步，
5721 少年胜于欧洲则国胜于欧洲，少年雄于地球则国雄于地球。
5722
5723 9. 陈寅恪：
5724 *1. 独立之思想，自由之精神。
5725 *2. 合中西新旧各种学问而统论之，吾必以寅恪为全中国最博学之人。寅恪虽系吾友而实吾师。--吴宓
5726 *3. 前人讲过的，我不讲；近人讲过的，我不讲；外国人讲过的，我不讲；我自己过去讲过的，也不讲。现在只
5727 讲未曾有人讲过的。
5728 *4. 其历年在中国文学、鸣学及诗之一道，所启迪、指教宓者，更多不胜记也.--吴宓
5729
5730 10. 吴宓：
5731 *1. 一个男人，学问不如人，很是可耻；大丈夫娶妻不如人，何故难为情？--陈寅恪
5732 *2. 女儿是水做的骨肉，男儿是泥做的骨肉，我见了女儿便清爽，见了男人便觉浊臭逼人。
5733 *3. 一介平民，一介书生，常人也；做学问，教书，写诗，均不过中等平平。然宓一生效忠中国传统文化，虽九
5734 死而不悔；一生追求人格上的独立自由，追求学术上的独立自由，从不人云亦云。
5735 *4. "给我水喝，我是吴宓教授。给我饭吃，我是吴宓教授！"--这是吴宓1978年临终的呓语。
5736 注：在一个做学问的人的眼里，教授是一个了不起的头衔。没有人记得他的教授的身份，除了他自己。在知识不曾
5737 贬值的日子里，教授货真价实代表应得的荣誉和地位。教授的意义，是我们今天很多俗人无法理解的。可见
5738 "文革"中的不幸遭遇给老人的创伤是多么的至深！"教授"两字，在吴宓心中是多么的崇高！教授，在无知者的
5739 眼中是一个不名一文的空头衔；教授，在俗人的面前，是一种谋生的资本；教授，在学人的心中，代表着学问
5740 、荣誉和地位；教授，在吴宓先生那里，是一生的自豪的称号，是他理想人格的载体。吴宓，一个名副其实的
5741 教授。吴宓，有着真学识，真性情，却自比古希腊悲剧的英雄，而他的命运，恰恰中了他的谶语。
5742
5743 11. 萧伯纳：
5744 *1. 人生有两大悲剧。一是得不到想得到的东西，一是得到不想得到的东西。
5745
5746 12. "精诚所至，金石为开。"在情感的世界里，这是一句害人不浅的"至理名言"。
5747
5748 13. 鲁迅：
5749 *1. 强不爱以为爱是人生最大的痛苦。
5750
5751 14. 冯友兰：
5752 *1. '为天地立心，为生民立命，为往圣继绝学，为万世开太平'，此哲学家所应自期许者也。况我国家民族，值
5753 贞元之会，当绝续之交，通天人之际，达古今之变，明内圣外王之道者，岂可不尽所欲言，以为我国家致太
5754 平？虽不能至，心向往之。非日能之，愿学焉。
5755 *2. 有着五千年文明之深厚基础的中华民族绝不会灭亡，困厄只是暂时的，很快就会过去。
5756
5757 15. 梁漱溟：
5758 *1. 中国文化以孔子为代表，以儒家学说为根本，以伦理为本位，它是人类文化的理想归宿，比西洋文化要来的
5759 高妙，认定"世界未来的文化就是中国文化复兴"，认为只有以儒家思想为基本价值取向的生活，才能使人们
5760 尝到"人生的真味"。
5761 *2. 三军可夺帅，匹夫不可夺志。
5762
5763 16. 蔡孑民：20世纪新文化运动的导师，现代中国文化名人的一面旗帜。倡导教育救国，学术救国，科学救国，推动中国的
5764 思想启蒙和文化复兴。后人评价到："他是新文化运动之父，他通过改变一所大学进而改变了一个民族！"
5765 *1. 教育是国家兴旺之根本，是国家富强之根基。教育思想灵活，兼容并包，不因学术争议而排斥，广泛吸收各家
5766 之所长。
5767 *2. "教育者，养成人格之事业也。"他主张教育要注重学生，反对呆板僵化。提倡美育，健康教育，人格教育。
5768 *3. 提倡民权与女权，倡导自由思想，致力革除"读书为官"的旧俗，开科学研究风气，重视公民道德教育及附带的
5769 世界观，人生观，美学教育。
5770 *4. 教育要平衡发展人的个性和群性。
5771 *5. 教育是求远效的，着眼于未来，其效果不能在短时间表现出来，所以讲"百年树人"。
5772 *6. 教育要超脱各派政党之外。
5773 *7. 大学为研究高尚学问之地。
5774 *8. 诸君来此求学，必有一宗旨，欲求宗旨之正大与否，必先之大学之性质。今人肄业专门学校，学成任事，此固
5775 势所必然。而在大学则不然，大学者，研究高深之学问者也。
5776 *9. 大学不能只从事教学，还必须掌握科学研究。
5777 *10. 凡大学者必有各种科学的研究
5778 理由
5779 >1. 大学无研究院，则教员易陷入抄发讲义不求进步之陋习。
5780 >2. 设立研究所，为大学毕业生深造创造条件。
5781 >3. 使大学高年级的学生得以在导师的指导下，有从事科学研究的机会。
5782 *11. 五育并举
5783 >1. 军国民教育
5784 *（一）邻强交逼，亟图自卫，而历年丧失之国权，非凭借武力，势难恢复。
5785 *（二）非行举国皆兵制，否则无以平均其势力。
5786 >2. 实利主义教育：加强科学技术教育，提高生产力，发展国民经济，国家富强才能在世界竞争中生存下来。
5787 >3. 公明道德教育：自由，平等，博爱(西方近代资产阶级)=>义，恕，仁(儒家)
5788 >4. 世界观的教育：思想自由，言论自由，不要束缚于某学说的思想。
5789 >5. 美育教育：人我之差别，幸福之营求。
5790 *12. 民主与科学。
5791 *13. 思想自由，兼容并包。
5792 *14. 依靠即懂得教育，又有学问的专家实行民主治校。
5793 *15. 教育者，养成人格之事业也。
5794 *16. 思想自由，是世界大学的先例。
5795 *17. 大学为纯粹研究学问之机关，不可视为养成资格之所，亦不可视为贩卖知识之所。学者当有研究学问之兴趣，
5796 尤当养成学问家之人格。
5797 *18. 对学生提出3点要求：一曰抱定宗旨，二曰砥砺德行，三曰敬爱师长。
5798 *19. 我国输入欧化，六十年矣。始而造兵，继而练军，继而变法，最后乃始知教育之必要。
5799 *20. 这是我了解科学的开端--蒋梦麟
5800 *21. 通过世界观的教育，让国人对生活有更高层次的追求。
5801 *22. 大学学生当以研究学术为天职，不当以大学为升官发财之阶梯。
5802 *23. 我素信学术上的派别，是相对的，不是绝对。所以每一种学科的教员，即使主张不同，若都是‘言之有理、持
5803 之有故’的，就让他们并存，令学生有选择的余地。
5804 *25. 这样容纳异己的雅量，尊重学术自由思想的卓见，在习于专制、好同恶异的东方人中实属罕有。--陈独秀
5805 *26. 教授治校,民主办学。
5806 *27. 只要培养一大批学者，国家就会有希望。而教育就够就是培养老百姓。
5807 *28. 拿各国的大学校长来比较，牛津、剑桥、巴黎、柏林、哈佛、哥伦比亚等校长中，在某些学科上有卓越贡献
5808 的不乏其人。但是，以一个校长的身份，能领导一所大学对一个民族和一个时代起转折作用的，除蔡元培以
5809 外，找不出第二个人。--美国著名哲学家、教育家杜威
5810 *29. 希望培养的学者，不仅具学识，尤当有修为。
5811 *30. "五四运动"的主力是北大，而精神上的指导者是蔡元培。--许德珩
5812 *31. 倡导以军国民教育、实利主义教育为急务，以道德教育为中心，以世界观教育为目的，以美育教育为桥梁。
5813 *32. 我对于学生运动，素有一种成见：以为学生在学校里面，应以学习为最大目的，不应有何等政治的组织。其
5814 有20岁以上，对于政治有特殊兴趣者，可以个人资格，参加政治团体，不必牵涉学校。(可谈政，不涉政)
5815 *33. 在对学生上，无论是一般的罢课还是大规模的学潮，无论学生处于什么动机，有什么背景，国立大学校长总是
5816 受害者和政府之间非常重要的调节因素，他们的选择非常重要。
5817
5818
5819 17. 伊利若大学校长詹姆士：
5820 *1. 哪一个国家能够做到教育这一代的中国年轻人，哪一个国家就能由于这方面所支付的努力，而在精神和商业上
5821 的影响取回最大的收获。
5822 *2. 商业追随精神上的支配，比追随军旗更为可靠。
5823
5824 18. 李提摩太：
5825 *1. 建大学，克服人们的无知和迷信。
5826
5827 19. 李鸿章：
5828 *1. 如何让国家少受损失，李鸿章叹道："不能预料！唯有竭力磋磨，展缓年份，尚不知能做得到否？吾尚有几年？
5829 一日和尚一日钟，钟不鸣，和尚死矣！"
5830 *2. 只有自强，只有发展，才是硬道理。
5831 *3. 敬李鸿章之才，惜李鸿章之识，悲李鸿章之遇。--梁启超
5832
5833 20. 李大钊：
5834 *1. 时至今日，吾人所当努力者，惟在如何吸取西洋文明之长，以济吾东洋文明之穷。
5835
5836 21. 辜鸿铭：
5837 *1. 正被国人摒弃的中国传统文化，恰是拯救世界的良方，而儒学即是这个文化精髓所在。
5838 *2. 要懂得真正的中国人和中国文明，那个人必须是深沉的，博大的和纯朴的，因为"中国人的性格和中国文明的
5839 3大特征，正是深沉、博大和纯朴(deep,broad and simple),此外还有灵敏(delicacy)"
5840 *3. 中国人给人留下的总体印象是"温良(gentle,温文尔雅)","那种难以言表的温良".
5841 *4. 中国理想女性的三个本质特征：即"悠闲恬静之爱，羞涩或腼腆以及'debonair'一词所表达的那种无法言状的
5842 优雅和妩媚，最后是纯洁或贞洁"。
5843 *5. 欧洲宗教要"人们做一个好人"，中国的宗教则要人们"做一个识礼的好人"；基督教叫人"爱人"，孔子则叫人
5844 "爱之以礼"。
5845 *6. 生在南洋，学在西洋，婚在东洋，仕在北洋，教在北大。
5846 *7. 现在中国只有两个好人，一个是蔡元培先生，一个便是我。为什么这么说呢？因为蔡元培先生点了翰林之后
5847 不肯做官而要去革命，到现在仍然在革命。而我呢。自从跟了张文襄(张之洞)做了前清的官之后，到现在还在
5848 保皇。
5849 *8. 我头上的辫子是有形的，你们心中的辫子是无形的。
5850
5851 22. 王国维：
5852 *1. 古之成大事者，大学问者，必经过三种境界。"昨夜西风凋碧树，独上高楼，望尽天涯路"，此一境界也；"衣
5853 带渐宽终不悔，为伊消得人憔悴"，此第二境界也；"众里寻她千百度，回头蓦见，那人却在灯火阑珊处"，此
5854 第三境界也。
5855 *2. 看山是山，看水是水；看山不是山，看水不是水；看山还是山，看水还是水。
5856 *3. 未有不阅第一第二阶级，而能遽跻第三阶级者，文学亦然，此有文学上之天才者，所以又需莫大之修养也。
5857 *4. 哲学者，论自然、人生、知识等之根本原理之学也。
5858
5859 23. 林语堂：
5860 *1. 乃得语言自然节奏之散文，如在风雨之夕围炉谈天，善拉扯，带情感，亦庄亦谐，深入浅出，如与高僧谈禅，
5861 如与名士谈心，似连贯而未尝有痕迹，似散漫而未尝无伏线，欲罢不能，欲删不得，读其文如闻其声，听其语
5862 如见其人。
5863
5864 24. 高尔基：
5865 *1. 照天性来说，人都是艺术家，他无论在什么地方，总是希望把美带到他们的生活中去。
5866
5867 25. 张伯苓：
5868 *1. 环境美能影响心灵美，心灵美的人才创造环境美，维护环境美。
5869 *2. 中国不亡吾辈在！
5870
5871 25. 康德：
5872 *1. 人只有认识到看不到的本体世界，才能超越现象世界，达到美的世界。
5873
5874 26. 北京大学：
5875 *1. 思想自由，兼容并包：拖着长辫的辜鸿铭不买胡适的账，坚持旧文学的黄侃在课堂上大骂倡导新文学的师弟
5876 钱玄同有辱师门，但校长蔡元培绝无门户之见。于是北大有了历史上最辉煌的阵容。既有主张新文化运动的
5877 领袖人物胡适、陈独秀、鲁迅，也有主张恢复帝制的辜鸿铭、刘师培；而提倡"情人制"、"外婚制"的"性博
5878 士"张竞生，也没有被封建卫道士的唾沫淹死。
5879
5880 27. 周树人：
5881 *1. 这中国好比一间铁屋子，绝无窗户而万难破毁，里面的人们从昏睡如死灭，并不感到临死的悲哀。而如果
5882 惊起了较为清醒的几个人，反倒使他们感到无可挽救的临终的苦楚。
5883
5884 28. 潘光旦：
5885 *1. 日夕旁伺，无力拯援，凄风惨雨，徒呼奈何？--费孝通
5886 *2. 发挥了中国儒家的基本精神，利用现代科学知识力图为人类寻求一条中和位育、遂生乐业之道。--费孝通
5887 *3. 自知者明，自胜者强。
5888 *4. 教师不应该是专家，而应该是通才。
5889 *5. 教育的对象就是人生，教育就是人生，学习与做学问的目的就是做人，学问离不开生活而独立。
5890 *6. 德、智、体、群、美、富，群、富在先前教育中未曾提及过，潘光旦个别作了这样的解释：群育就是培养协作
5891 精神及人与人之间关系的能力，所谓富育就是培养吃饭能力、并在生计上富裕的能力。
5892 *7. 教师风度的表率作用远远胜过训导实行的那些生活戒条和所订的那些奖惩功过的条例。
5893 *8. 切莫忘记提高教师的素养才是"素质教育"中至关重要的一步。
5894 *9. 教育只能产生并光大于教育对象生存的土壤。
5895 *10. 甚盼中国教育与欧美教育宣告独立，而新教育的领袖，应该根据中国的需要，在中国国内养成之。新教育应
5896 因地制宜。
5897 注：
5898 *1. "中和位育"是儒家的核心口号，是修养功夫之至极，"中和"是目的，不偏不倚，协调适度；"位育"是手段，各
5899 守其分，适应处境。
5900 *2. 喜怒哀乐之未发，谓之中;发而皆中节，谓之和。中也者，天下之大本也；和也者，天下之达道也。致中和，天
5901 地位焉、万物育焉。
5902
5903 29. 孔子：核心思想->仁爱，忠恕，中庸
5904 *1. 己所不欲，勿施于人。
5905 *2. 己欲立而力人，己欲达而达人。
5906 *3. 夫子之道，忠恕之道也。就是所孔子的思想就是忠恕而已。
5907 *4. 你心里只有你自己，你又怎么谈得到爱别人呢?
5908 *5. 天下有道则见，无道则隐。
5909 *6. 君子周而不比，小人比而不周。
5910 *7. 居处恭，执事敬，与人忠。
5911 *8. 对于时代安宁的向往，对于国家世人的责任。
5912 *9. 小人就是孔子的困惑，也就是孔子那个时代人文危机的总结，更是孔子一辈子无法改变的现实而产生的绝望呐喊。
5913 *10. 孔子的思想是仁学，仁的最基本的一个内涵是爱人。
5914 *11. 从现实生活中来讲。推己及人是一切社会公德的基础。要维护正常的社会秩序，就要遵守社会公德。文明愈
5915 发展，社会公德就愈重要。而社会公德要得到遵守，最基本的就是要有推己及人的思想。
5916 *12. 克己：抑制欲望才有欲望的幸福，放纵欲望就是欲望的坟墓。
5917 *13. 己所不欲，勿施于人。
5918 *14. 仁爱。
5919 *15. 批评是为了进步，不是为了扼杀。
5920 *16. 以直报怨，以德报德。
5921 *17. 举直错诸枉，能使枉者直。
5922 *18. 有教无类。
5923 注：稳定才有文化，安定才有文明。孔子以无保留的智慧，奉献有保留的人生，人能做到于此尽矣。孔子不曾负我，
5924 我亦何忍负孔子。故请当世君子，明诚修身，恪守圣训，以大同为人生目标，国家的命运，人类的命运念兹在
5925 兹，必能成就今生之伟业，必能成就今世之伟人。
5926
5927 注：
5928 *1. 中国最古老的中庸之道其实讲究的就是"合适"，就是"刚刚好"。品格可以分成三等，各类中的第一类和末一等都是
5929 极端和缺德，居中的才是道德或优越性。
5930 *2. 中庸并非像数学的中项恰恰是精确可计的两端的平均数；它随着环境中左右各种情况的变更而变更，并且只对
5931 成熟而有灵活性的理性才显露自身。卓越是靠训练有素而得来的一种艺术修养，我门并不是因为有了道德或卓
5932 越才行为举止正确合理，我们才拥有这些的。人形成这写美德是由于人采取了这样的行动，我们反复而行，就
5933 形成目前这个样子。因此卓越并非一种行动举止，而是一种习惯："人的善行是灵魂在实现圆满生命中卓越方
5934 面的一种作用;......正如一只飞燕或晴朗的一天就能形成春天一样，一朝一夕或昙花一现的一瞬间也不是能
5935 便人幸运德福的。"
5936 *3. 凡事要适可而止，不偏不倚，这就是中庸之道。
5937 *4. 待人如己，宽以待人，严以律己。
5938 *5. 第一：做事不要太苦；第二：享欲不要太乐；第三：待人不要太苛；第四：用物不要太荣。
5939 *6. 中庸之道其实就是佛道，佛道就是要我们每一个人的生活里，凡事不要太左也不要太右，不要太紧也不要太松；
5940 能够不偏不倚即为"中"。
5941 *7. 儒家把"中庸"看成是一个最好的道德标准，也是解决一切问题的最高智慧。中庸之道亦被称为中道或中和之道。
5942 *8. 《中庸》写与济宁。而中庸的"中"，在济宁的方言中为可以，行的意思。而中庸中的"庸"字，则由两部分组成，
5943 一个变庚的"庚"和一个"用"。意为，变化...为...用。则中庸的意思就是，变化...为...所用而达到可以、行
5944 的结果，是一个做人的标准、方法。
5945 *9. 不偏之谓中，不易谓之庸。
5946 *10. 中庸之道的主要原则有三条：一是慎独自修，而是忠恕宽容，三是至诚尽性。
5947 *11. 物格而后知至，知至而后意诚，意诚而后心正，心正而后修身，身修而后齐家，齐家而后国治，国治而后天下
5948 平。
5949 *12. "中庸"是孔子倡导用于处世为人的一套思想。
5950 *13. 中庸就是上负责国家，下负责家庭，中负责黎民百姓。
5951 *14. 中庸，就是恪守中道，坚持原则，不偏不倚，无过不不及。在处理矛盾时善于执两用中，折中致和，追求中正、
5952 中和、稳定、和谐。并且随时以处中，因时制宜，与时俱进。
5953
5954 30. 在常人的眼里，鬣狗似乎是"丑陋"的，但，在自然母亲的眼里，鬣狗和人类一样，都是她的宠儿。
5955
5956 31. 叶企孙：
5957 *1. 一、不谈宗教；二、不谈政治；三、宗旨忌远；四、议论忌高；五、切实求学；六、切实做事。
5958
5959 32. 达尔文：
5960 *1. 人根植于动物世界，只是动物发展的自然延续，人类的进化只能是在漫长的自然选择中完成。
5961
5962 33. 严复：
5963 *1. 物竞天泽，优胜劣汰。
5964
5965 34. 丹麦：
5966 *1. 有钱人乐意缴税，帮助能力差的人。这不是财富问题，而是立场问题。有能力的人，就因该帮助能力差的人。
5967
5968 35. 罗家伦：
5969 *1. 大学应该承担起"创立民族文化的使命"，"如果一个大学不能负担起创立民族文化的使命，便根本失掉大学存
5970 在的意义。"
5971
5972 36. 胡适：
5973 *1. 大胆的假设，小心的求证。少说些空话，多读些好书。
5974
5975 38. 林徽因：
5976 *1. 她承认自己是受双文化教育长大的，英语对于她来说是内在思维和表达方式、一种灵感、一个完整的文化世界。
5977
5978 39. 傅斯年：
5979 *1. 教育如无相当的独立，是办不好的。政府的责任第一是确立教育经费的独立，不管是中央还是地方。第二是严格
5980 审定校长，保障他们的地位。
5981
5982 40. 章士钊：
5983 *1. 今人讲新文学，颇采报端之见，挥斥一切旧者，欲从文学上划出一新纪元，号之曰新。愚谓所见太狭，且亦决不
5984 可能。
5985 *2. 今之社会道德，旧者破坏，新者未立意，颇呈青黄不接之观......人心世道之忧。莫切于此。
5986 *3. 新机不可滞，旧德亦不可忘，挹彼注此，逐渐改善，新旧相衔，斯成调和。
5987 *4. 所谓文明野蛮，不过循环蝉递
5988
5989 41. 陈炯明：
5990 *1. 为英雄能活人杀人，功罪是非，自由千秋青史在；与故交曾一战再战，公仇私谊，全凭一寸赤心知。
5991
5992 42. 张治中：
5993 *1. 这一役牺牲是应该的，生还算是意外的了。
5994
5995 43. 郭子仪：
5996 *1. 权倾天下而朝不忌惮，功盖一代而主不疑。
5997
5998 44. 陶行知：
5999 *1. 社会即教育，生活即教育，教学合一。
6000 *2. 和马牛羊鸡犬豕做朋友，对稻梁麦菽黍稷下工夫。
6001 *3. 生活教育与生具来，与生同去。出世便是破蒙；进棺材才算毕业。
6002 *4. 在一般的生活里，找出教育的特殊意义，发挥出教育的特殊力量。同时要在特殊的教育里，找出一般的生活关系，
6003 展开对一般生活的普遍而深刻的影响。把生活推广到生活包括的领域，使生活提高到教育所瞄准的水平。
6004 *5. 平民教育，生活即教育，社会即学校，教学作合一。
6005 *6. 捧着一颗心来，不带半根草去。
6006 *7. 道德是做人的根本。
6007 *8. 教育是救国的根本。
6008 *7. 人生办一件大事来，做一件大事去。
6009 *8. 多少白发翁，蹉跎悔歧路。觊觎少年人，莫将少年误。
6010
6011 45. 马相伯：
6012 *1. 国家富强之术，在于提倡科学，兴办实业。
6013 *2. 自强之道，以作育人才为本；救才之道，尤宜设立学堂为先。
6014 *3. 今乃始见我祖国得一完备有条理之私立学校，吾欲狂喜。--梁启超
6015 *4. 欲革命救国，必自研究近代科学始；欲研究近代科学，必自通其语言文字始。有欲通外国语言文字，以研究近代科
6016 学而为科学救国准备者，请归我。
6017 *5. 崇尚科学，注重文艺，不谈教理。
6018
6019
6020
6021
6022
6023
6024
6025
6026 2015/10/6
6027
6028
6029
6030
6031 1. 《代码大全》
6032 *1. 有效测试的关键之一，就是在待测试项目开始之初就拟定测试计划。就重要性而言，测试应当与设计和编码平起
6033 平坐，这就要求项目为测试分配时间，重视测试并保障这一过程的质量。
6034 *2. 除非在每次修改后重新对程序进行系统化的测试，否者要开发出一个高质量的软件几乎是痴人说梦。
6035 *3. 调试是确定错误根本原因并纠正此错误的过程。在一些项目中，调试可能占到整个开发周期的50%，对很多程序员
6036 来说，调试是程序设计中最为困难的部分。
6037
6038 2. 在Java中的JavaBean为什么会有权限修饰符private,protected,public,以及提供对数据属性依赖的访问器子程序。
6039 *1. 为了控制类的属性成员的作用域，外部对象访问类内的属性数据的时只有通过类内提供的访问接口。
6040 *2. 因为控制了类的变量作用域，所以在继承扩展的时候，例如private数据属性就不会传递到子类中。
6041 *3. 从更高的目的来说就是实现了解耦。
6042
6043 3. 养成良好的编码习惯：在定义变量的时候一定要及时的对其进行初始化，就像是注入依赖的时候，千万不要注入没有定义
6044 的依赖，哪怕是你给变量初始化一个空值(null)也可以减少程序的出错概率。当然在Java的集成开发环境中，一般对定义
6045 之后没有初始化的变量会默认的给一个null值，但是这个变量是不可以引用的，意思就是说当你使用的时候还是会有危险。
6046
6047 4. 数组中元素的地址表示方式是以每个元素的所占内存的第一个字节表示。
6048
6049
6050
6051
6052 2015/10/7
6053
6054
6055
6056
6057 1. Love make all hard hearts gentle.爱情把一切冷酷的心变得温柔。
6058
6059 2. You can go as far as you want to go. 心有多远，你就有多远。
6060
6061 3. Art, in itself,is an attempt to bring order out of chaos.艺术就是试图找到混乱中的秩序。
6062
6063 4. A goal is a dream with a deadline.目标就是给梦想一个期限。
6064
6065 5. Tough times never last, but tough people do. 苦难的日子终将过去，但强者永存。
6066
6067 6. All the bright precious things fade so fast and they don't come back.美好的事务总是转瞬即逝，一去不返。
6068
6069 7. Love makes your soul crawl out from its hiding place. 爱让你的灵魂无处隐藏。
6070
6071 8. Sometimes your whole life boils down to one insane move.人一辈子，有时就靠一次疯狂的举动扭转乾坤。
6072
6073 9. We don't see things as they are,we see them as we are.我们所看见的不是事务的本质，而是自己的样子。
6074
6075 14. 能不用全局变量就不要用它，因为这会给代码的出错留下隐患，不过在Java中有一个用处就是在类中定义全局的静态
6076 常量，注意这里仅仅是常量，就是不可变更的意思，如public static final int ...
6077 注：
6078 *1. 全局变量的弊端：增加内存开销，降低函数通用性。
6079
6080 15. assert断言的意思就是说这条语句是不会出错的，而Exception异常的意思就是说这段代码是有可能会出错的。
6081
6082 16. 现代操作系统的堆数据结构一般包括堆块和堆表组成。
6083 *1. 堆块：堆区的内存按照不同大小组织成块，以堆块为单位进行标识，而不是按照字节进行标识。一个堆块
6084 包括两个部分：块首和块身
6085 >1. 块首：是块头部的几个字节，用来标识这个堆块自身的信息，包括本块的大小、本快空闲还是
6086 占用信息。
6087 >2. 块身：是紧跟在块首后面的部分，是最终分配给用户使用的数据。
6088 *2. 堆表：位于堆区的起始位置，用于索引堆区中堆块的重要信息。堆表的数据结构决定了整个堆区的组织方式。
6089 堆表在设计时可能会考虑采用平衡二叉树等高级数据结构用于优化查找效率。现代操作系统的堆表往往
6090 不止一种数据结构。
6091
6092
6093
6094
6095
6096
6097 2015/10/8
6098
6099
6100
6101 1. 架构师的责任：资源和速度。
6102
6103 2. 栈帧的组成：
6104 *1. 局部变量表
6105 *2. 操作数栈
6106 *3. 动态链接
6107 *4. 方法返回地址
6108
6109 3. 一定要增加代码的可读性，才有说代码优雅的可能性。
6110
6111 4. 一般Java在内存分配时会涉及到以下区域：
6112 *1. 寄存器：我们在程序中无法控制。
6113 *2. 栈：存放基本类型的数据和对象的引用，但对象的本身并不放在栈中，而是放在堆中。
6114 >1. 当在一段代码块中定义一个变量时，Java就在栈中为这个变量分配内存空间，当变量退出该作用域后，
6115 Java会自动的释放掉为该变量分配的内存空间，该内存空间即可以被另作他用。
6116 *3. 堆：存放用new创建产生的对象。
6117 *4. 静态域：存放在对象中用static定义的静态成员。
6118 *5. 常量池：存放常量。
6119 *6. 非RAM(Random Access Memory)存储：硬盘等永久存储空间。
6120 注：
6121 >1. 栈用来存放一些原始数据类型的局部变量数据和对象的引用(String,数组，对象等等)，但不存放对象内容。
6122 >2. 堆中存放使用new关键字创建的对象。
6123 >3. 字符串是一个特殊的包装类，其引用是放在栈里的，而对象内容必须根据创建方式(常量池和堆)的不同，
6124 有的是在编译器就已经创建好了，存放在字符串常量池中，而有的是运行时才被创建，使用new关键字
6125 存放在堆中。
6126
6127
6128 5. 控制器的操作有3种
6129 *1. 控制数据流的流出操作：例如list(流出数据库中某表所有的数据)
6130 *2. 控制数据流的流入操作:
6131 >1. 对数据流进行入库操作：例如add(添加),edit(修改),delete(删除)
6132 >2. 单纯地转发到某一个页面，例如添加页面(addUI)，对于这个表单页面，是没有数据流出库，是无需
6133 要对数据进行回显；而修改页面(editUI)，这个操作是要有数据流的出库操作，因为一般这样的表单
6134 页面要有回显的功能。
6135
6136 6. 只有通过new()方法才能保证每次都创建一个对象。
6137
6138 7. StringBuffer和StringBuilder
6139 *1. StringBuffer是线程安全的，StringBuilder是线程不安全的。
6140 *2. 效率的话StringBuilder>StringBuffer。
6141 注：如果要操作少量的数据可以用String。
6142
6143 8. 科技可以带来文明，艺术可以带来美。
6144
6145 9. 为了实现封装，在Java中用私有(private)属性和访问器子程序构成类,其实最终目的是为了解耦。若要求访问类中的数据
6146 成员，最好通过访问器子程序接口。所以为了实现解耦，类的属性最好不要定义为公有public的,但是有时为了扩展，即
6147 用子类继承父类的部分属性时，可以把属性的访问权限定位受保护的protected。记住这样做的目的就是为了子类扩展而已，
6148 好处就是子类的代码结构清晰，坏处就是子类和父类之间的代码耦合度提高了，对后期的代码维护会产生影响。
6149 注：
6150 *1. 所以说能用接口就不要用继承，可以增加代码的维护性。或者是用注入依赖实现两个类之间的通信。
6151 *2. 继承和接口的最大区别就是一个是重量级的，一个是轻量级的。因为接口只是方法的声明，你实现接口时只需要
6152 自己自定义的实现接口中的方法。而继承一个父类时，会自动的为子类注入父类的依赖，从而增加耦合度，破坏
6153 代码结构。
6154 *3. 要实现继承的方式就是用protected关键字。
6155 *4. 用接口进行通信是最理想的方式。
6156 *5. 在项目中对冗余度高的代码进行抽取到一个基类时，使代码结构清晰，这时继承的用处就来了。同时很多的子类
6157 可以继承基类，可以减少代码的冗余，这就是继承的好处。还有一个就是对抽象类的继承，那就是像接口一样
6158 目的就是为了扩展，只不过抽向类里提供了属性依赖，还有就是抽象类是不可以进行实例化的。抽向类的目的就
6159 是为了实现扩展用的。
6160 *6. 所以说继承还是很有存在的必要性，存在即是合理的。
6161
6162 10. lazy-init="true" 意思就是懒加载，只有在用到的时候才会实例化该对象，在Spring对象工厂的配置文件中的bean的属
6163 性中适当地配置可以增加Spring对象工厂加载对象时的效率。
6164
6165
6166
6167
6168
6169 2015/10/9
6170
6171
6172
6173
6174
6175 1. Each man is the architect of his own fate.命运掌握在自己手中。
6176
6177 2. 越高级的语言编程效率越高，但是有一个弊病就是代码的运行效率会有所降低。
6178
6179 3. xsd(XML Schemas Defination):xml结构定义
6180 *1. XML Schema是DTD(Document Type Defination,文档类型定义)的替代品。XML Schema语言也就是XSD.
6181 *2. XML Schema描述了xml文档的结构。可以用一个指定的xml schema来验证某个xml文档，以检查该xml文档是否
6182 符合其要求。文档设计者可以通过xml schema指定一个xml文档所允许的内容和结构，并可据此检查一个xml文
6183 档是否是有效的。XML Schema本身是一个xml文档，它符合xml的语法结构。可以通过xml解析器解析它。
6184 *3. 一个xml schema会定义：文档中出现的元素、文档中出现的属性、子元素、子元素的数量、子元素的顺序、
6185 元素是否为空、元素和属性的数据类型、元素或属性的默认和固定值。
6186 *4. XSD是DTD替代者的原因，一是据将来的条件可扩展，二是比DTD丰富和有用，三是用xml书写，四是支持数据类型
6187 五是支持命名空间。
6188
6189 4. 欲把西湖比西子，淡妆浓抹总相宜。
6190
6191 5. Spring的容器是提供了lazy-load(懒加载)的，默认的缺省设置是bean实体是没有lazy-load，即该属性处于false状态，这
6192 就导致Spring对象工厂在启动的时候是会自动的加载整个对象实例图，从初始化Action控制器，到Service到dao，乃至到
6193 数据库的连接，事务的配置等等。所以Spring对象工厂在启动的时候回将近的花费1分钟，可以尝试把beans的属性default-lazy
6194 -init的属性值设置为true，启动Spring对象工厂的时候花费的时间就会大约是在8秒钟左右。
6195 注：
6196 *1. 在项目的开发过程中适当的用懒加载(用到即加载)的属性，可以提高开发效率。
6197 *2. bean的属性init-method是实例化bean对象时初始化构造时执行的方法，distroy-method属性指定bean对象销毁
6198 时执行的方法。
6199
6200 7. 怎么设计实体：
6201 *1. 最简单的就是看表单，因为表单的数据就是你要收集的数据。
6202 *2. 如果有什么特殊要处理的属性，如计数count，日期等不是表单收集的数据，而是需要自己维护的属性，
6203 可以通过看显示数据的列表，看有什么要显示的数据属性然后确定。
6204 注：设计实体的属性时看表单更直观，外加看显示实体数据的列表确定是否有要添加的属性。
6205
6206 8. 怎么确定要实现的业务逻辑方法
6207 *1. 看功能界面中所要实现的功能，一般就是分为两大类。
6208 >1. 数据流的入库操作：
6209 >2. 数据流的出库操作：
6210 *2. 之后在控制器端确定要控制数据流流入流出的方法名称。
6211
6212 9. 前端编程中的js不太好学但是很重要。
6213
6214 10. 对于前端表单页面中的下拉列表以及复选框的选择等，提交之后在控制器端的表现方式是以编号id或者是编号集合ids
6215 来体现的，存放在服务器端的控制器的数据中转中心供操作实体对象使用。
6216
6217 11. 在编程中各处都有依赖注入的思想，能好好理解这个概念可以大大的帮助你理解编程的要理。
6218
6219
6220
6221
6222
6223 2015/10/10
6224
6225
6226
6227
6228 1. Circumstance are therulers of the weak,instrument of the wise. 弱者困于环境，智者利用环境。
6229
6230 2. 封装对象的信息的时候有两种情况：
6231 *1. 第一种是实现框架的模型驱动接口，框架会自动地帮助你封装对象的属性数据信息，但是这些属性一般都是
6232 一般的属性数据流。
6233 *2. 对于像什么特殊属性(日期date，计数count等)或者是和其他对象的关联关系，需要自己进行封装之后再入库
6234 对象。但是入库一个对象的数据的时候一定要注意和这个实体对象相关联的其他对象是否也要更新相关的属
6235 性信息等等，都是要自己谨慎考量的。
6236
6237 3. 控制器的作用
6238 *1. 数据流入库：就是对实体对象的属性数据流的打包
6239 *2. 数据流出库：根据要求出库一个实体数据还是多个实体数据集合。
6240
6241 4. 学习编程一定要培养自己的分析问题的能力，解决问题的能力，以及画图设计的能力。写代码的话一定要注意可读性，
6242 另外再来讲究效率的问题，注意代码的结构，冗余度，是否要重构等等。
6243
6244 5. 当一个控制器操作多张表的数据流入流出时，问题的复杂性就会显然地增加。
6245
6246 6. 相对于jstl(Java Standard Template Labrary),框架Struts2提供的ognl(对象图导航语言，即Struts标签)封装了很
6247 多，易用性提高了很多，建议用框架的话，前端Jsp页面即用于收集数据和显示数据的客户端页面用Struts标签写效率
6248 更高。
6249
6250 7. 实体设计很重要，难度也很大。就是如何把客户端页面的表单属性以及其他要添加的属性考虑周全，如何抽象，如何
6251 关联表之间的关联关系等等。因为页面的表单提供的实体对象要收集的属性数据并不周全，还要考虑其的特殊属性，
6252 需要关联的其他实体对象等等。例如如果要上传文件的话，在数据库表中的表象方式一般就是入库所上传文件的路径，
6253 而实体与实体之间的关联关系在数据库表中的体现方式就是以外键编号id的方式进行通信。
6254 注：表之间的关联关系有三种
6255 >1. 一对多，多对一：在从表会有参照主表的主键的外键体现关联关系。
6256 >2. 多对多：这种关联关系在数据库中的表现方式是会以一张中间表(即两表之间进行通信的外键组成)。
6257 >3. 一对一 ：这个关系可以理解为特殊的一对多关联关系，可以在从表用外键与主表进行关联。
6258 注：主表子在一对多的关联关系中是以"一"的一方，而在多对多的关联关系中两个表都可以是主表，在一对一
6259 关联关系中不太好确定，但是可以这样理解，一般以主动的一方为主表，例如学生和学生卡，一般以学生
6260 为主表。
6261
6262 8. 网络游戏的盈利模式：其实这个和一般的软件项目的盈利根本是一样的，就是通过卖服务赚钱。
6263 *1. 收费游戏：一般以出售游戏赚取盈利，如销售游戏卡点或者是包时收费。
6264 *2. 增殖业务收费：一般采用游戏免费、增殖服务收费形式，如道具、装备收费等，目前这种模式在市场中占有率较高。
6265 *3. 广告收费：将产品或品牌信息嵌入游戏，用户在玩游戏的过程中，接触到广告产品，向第三方广告商收取费用。
6266 *4. 周边产品：指通过自行或授权生产，开发与游戏相关的实体产品获取利润。
6267
6268 9. 游戏分类：
6269 *1. 端游：高投入，回报有风险。3A游戏研发科技含量，艺术含量，创意含量最高，所以叫高投入。
6270 *2. 手游：低投入，高回报。
6271 *3. 网游：高投入，高回报。
6272
6273 10. 缺乏创新的游戏以及人才的缺乏是网络游戏公司面临的首要问题。网络游戏要兼顾游戏性与网络技术，需要的是集文学、
6274 美术、编程能力为一体的复合型人才。一名游戏从业人员必须要具备软件行业家和艺术家的创新能力。
6275
6276 11. 东方人的消费习惯直接导致软件行业的畸形发展，不注重知识产权，也就是不尊重知识。
6277 盈利模式
6278 *1. 广告模式
6279 *2. 电商模式
6280 *3. 游戏模式
6281 *4. 招聘模式
6282 *5. 其他：会员模式或其他直接收费模式
6283
6284 12. 帮人挣钱，才是最好的挣钱方式。
6285
6286 13. 喜欢才会珍惜，珍惜才会在意。
6287
6288
6289
6290
6291
6292
6293 2015/10/11
6294
6295
6296
6297
6298
6299 1. A contented mind is the greatest blessing a man can enjoy in this world. 知足是人生在世界最大的幸事。
6300
6301 2. 当在客户端的页面进行跳转的时候，一定要注意的是跳转页面的时候是否要经过控制器，开始单纯地链接到其他的页面。
6302 意思就是说到底是本项目的资源页面之内跳转，内部跳转(转发，不改变地址栏的地址)，还是重定向(地址栏的地址会
6303 改变)
6304
6305 3. web开发中，写代码的时候要注意代码的结构，建立项目的时候要注意项目的结构，分层开发，模块开发，分包存放各种
6306 层次的类，分文件夹存放各种前端的文件。
6307
6308 4. 因为要集中到处理多个数据，所以有了数据集合，数组等数据结构的核心概念。
6309
6310 5. 在编程中的方法定义时传的局部参数基本上就是放在栈里的数据，因为存放在栈里的数据是值类型，所以说在Java中所有
6311 的对象都是按值传递，即便是传的是对象，其本质就是传递的是对象的存放在栈里的引用(地址)值。
6312
6313 6. 学习C/C++一定要好好地区分地址和值的区别，也就是用来描述大对象的指针，就是这个东西，即灵活但是又有危险。
6314
6315 9. 写函数或者是方法的时候要注意函数的健壮性，必要的进行对象非空判断，数组越界判断等等。
6316
6317 10. 编程开发中地址的概念很重要，因为这是各个模块，或者是各个元素之间通信的基础。往大了说，例如客户端要访问
6318 服务器端的资源，必需要有地址。往小了说，一个数组或者是链表的元素的数据结构的构成也是通过地址进行连接通信
6319 的。在数据结构的科学里这个地址就叫作指针，则web编程中这个地址就叫url(Uniform Resource Locator,全球资源
6320 定位器)。
6321
6322
6323
6324
6325
6326
6327
6328
6329 2015/10/12
6330
6331
6332
6333
6334 1. 在数据结构中对链表节点的操作，例如增(add),删(remove)，其实本质就是对节点的地址的更新，并没有释放节点所
6335 占用的内存。最后释放链表所申请的内存，其实还是需要通过free函数进行释放。
6336
6337 2. 理解MVC(Model->View->Controller，模型->视图->控制器)的设计模式很重要，软件工程的项目的架构基本上都是要
6338 基于这个设计模式。
6339
6340
6341
6342
6343
6344
6345 2015/10/13
6346
6347
6348
6349
6350 1. Govern you thoughts when you along,and your tongue when in company.一人独处时要慎于思，与人相处时要慎于言。
6351
6352
6353
6354
6355
6356
6357
6358 2015/10/14
6359
6360
6361
6362
6363
6364 1. Blessed is he whose fame does not outshine his truth. 有福之人，是因为他的真实比他的名誉更耀眼。
6365
6366 2. 如果要操作数组或者是集合数据结构里的数据，首先要想到的就是用循环遍历数组的元素，在进行下一步对数据元素的操作。
6367
6368
6369
6370
6371
6372 2015/10/15
6373
6374
6375
6376
6377 1. He alone is poor who does not posess knowledge. 没有知识，才是贫穷。
6378
6379 2. hql(Hibernate Query Language)和sql(Strutct Query Language)语句的最大区别就是hql是面向对象的查询语句，而sql
6380 是面向表字段的查询语句。
6381
6382 3. 如果牛逼点，其实编程的本质就是把项目设计师设计好的项目功能界面翻译成代码。
6383
6384 4. 写代码还是要以可读性为首要任务，代码的执行效率次之，因为这根本就不会影响项目的多少运行效率。
6385
6386 5. 其实在编程中方法就是一个限制了变量作用域的代码块，该代码块用循环语句，判断语句，中断语句对数据进行处理之后
6387 在输出。更深一层的说法就是，方法其实也可以理解为一个个依赖，方法名字就是数据依赖的变量名。当你的代码行数超
6388 过20行之后，为了代码的可读性，以及代码的结构，你就得考虑要重构方法了。
6389
6390
6391
6392
6393
6394
6395 2015/10/16
6396
6397
6398
6399
6400
6401 1. 天还是过去的蓝，水还是往昔的清，人还是旧的好，情还是简单的真。
6402
6403 2. 我这辈子走过许多地方的路，行过许多的地方的桥，看过多次数的云，喝过多种类的酒，却只爱过一个正当年龄的人。--沈从文
6404
6405 3. Grow old along with me,the best is yet to be. 执子之手，与子偕老。
6406
6407 4. 循环和递归都是用来操作数据集合的，只不过用循环的可读性比较好，用递归不好理解，但是有的情况下是必须用递归来操作
6408 遍历数据集合的元素的，比如说遍历树，图等比较复杂的数据结构。
6409
6410 5. 一个系统通常对服务器中的数据资源的出库操作请求比入库操作请求要多。
6411
6412
6413
6414
6415
6416 2015/10/17
6417
6418
6419
6420 1. A friend is a second self. 朋友是另一个我。
6421
6422
6423
6424
6425
6426 2015/10/18
6427
6428
6429
6430
6431 1. A bit in morning is better than nothing all day. 略有胜于全无。
6432
6433 2. 不积跬步无以至千里，不积小流无以成江海。
6434
6435 3. 二叉树的三种遍历方式：
6436 *1. 二叉树：
6437 A
6438 B E
6439 C D F
6440 *2. 三种遍历方式：
6441 >1. 前序遍历：ABCDEF
6442 >2. 中序遍历：CBDAFE
6443 >3. 后序遍历：CDBFEA
6444 *3. 算法：
6445 >1. 前序遍历：
6446 遍历根节点->遍历左子树->遍历右子树
6447 >2. 中序遍历：
6448 遍历左子树->遍历根节点->遍历右子树
6449 >3. 后序遍历：
6450 遍历左子树->遍历右子树->遍历根节点
6451 *4. 实现方式：
6452 >实现原理：这些节点都用链表的线性结构存储，要遍历树的节点，实现方式就是用循环和递归配合地
6453 遍历各个节点。
6454 >实现代码：用C语言实现
6455 #include <stdio.h>
6456 #include <stdlib.h>
6457
6458 //1. 设计实体：二叉树节点实体（用C的结构体实现）
6459 typedef struct TreeNode{
6460 //属性1：树节点的数据
6461 char data;
6462 //属性2：树根节点的左子树地址
6463 struct TreeNode *leftNodePtr;
6464 //属性3：树根节点的右子树地址
6465 struct TreeNode *rightNodePtr;
6466
6467 }TreeNode;
6468
6469 //2. 声明方法：3种遍历树节点的方法,一个初始化树节点的方法，相当于一个构造函数
6470 //方法1：创建二叉树
6471 TreeNode* createBinaryTree(void);
6472 //方法2：前序遍历
6473 void preorderTraverse(TreeNode*);
6474 //方法3：中序遍历
6475 void inorderTraverse(TreeNode*);
6476 //方法4：后序遍历
6477 void postorderTraverse(TreeNode*);
6478
6479 //3. 测试
6480 int main(int argc,char *argv[]){
6481 TreeNode *treeNodePtr=createBinaryTree();
6482 //前序遍历
6483 printf("\n前序遍历：");
6484 preorderTraverse(treeNodePtr);
6485 //中序遍历
6486 printf("\n中序遍历:");
6487 inorderTraverse(treeNodePtr);
6488 //后序遍历
6489 printf("\n后序遍历:");
6490 postorderTraverse(treeNodePtr);
6491
6492 return 0;
6493 }
6494
6495 //4. 声明方法的具体实现代码
6496 //方法1：创建二叉树
6497 TreeNode* createBinaryTree(void){
6498 //注入依赖
6499 //局部依赖1：树节点treeNode的地址
6500 TreeNode *treeNodePtr;
6501 //局部依赖2：客户端输入的数据，树节点的数据treeNodeData
6502 char treeNodeData;
6503 //客户端输入树节点的数据
6504 scanf("%c",&treeNodeData);
6505
6506 //创建树节点，并封装数据data，leftNodePtr,rightNodePtr
6507 if(treeNodeData=='#'){
6508 treeNodePtr=null;
6509 }else{
6510 treeNodePtr=(*TreeNode)malloc(sizeof(TreeNode));
6511 treeNodePtr->data=treeNodeData;
6512 treeNodePtr->leftChildPtr=createBinaryTree();
6513 treeNodePtr->rightChildPtr=createBinaryTree();
6514 }
6515
6516 return treeNodePtr;
6517 }
6518 //方法2：前序遍历,用递归
6519 void preorderTraverse(TreeNode* rootNodePtr){
6520 if(rootNodePtr){
6521 printf("%c",rootNodePtr->data);
6522 preorderTraverse(rootNodePtr->leftChildPtr);
6523 preorderTraverse(rootNodePtr->rightChildPtr);
6524 }
6525
6526 }
6527 //方法3：中序遍历
6528 void inorderTraverse(TreeNode* rootNodePtr){
6529 inorderTraverse(rootNodePtr->leftChildPtr);
6530 printf("%c",rootNodePtr->data);
6531 inorderTraverse(rootNodePtr->rightChildPtr);
6532
6533 }
6534 //方法4：后序遍历
6535 void postorderTraverse(TreeNode* rootNodePtr){
6536 inorderTraverse(rootNodePtr->leftChildPtr);
6537 inorderTraverse(rootNodePtr->rightChildPtr);
6538 printf("%c",rootNodePtr->data);
6539 }
6540 注：展握理解递归的主要方式就是要理解函数参数或者是局部依赖是在每一次递归调用的使用时候都是会变化的，
6541 然后在函数内部对变化的局部依赖参数进行必要的处理即可。
6542
6543 4. 循环和递归都可以用来遍历数据集合的元素，但是递归的可读性不好，也不好理解，所以细看一点你可以发现其实循环
6544 使用递归来实现的，为了增加代码的可读性，用循环对递归进行了封装。
6545
6546 5. 在编程中递归和对调这两个概念都是比较难理解的，不过他的本质都是函数指针的调用，也就是说函数的参数传递的
6547 是函数的指正地址，只不过递归传递的地址是函数本身的地址，而回调传递的函数地址是其他函数的地址。
6548 注：要理解函数的地址，可以把函数理解为一个变量，函数名就像是变量名，也就是函数的指针地址，这些地址
6549 其实都是放置在栈中的。
6550
6551 6. 我们可以把方法理解为一个依赖，只不过方法是一个代码块，在代码块里用了顺序赋值语句，循环语句，判断语句，
6552 中断语句对传递过来的参数进行了必要的处理之后返回一个值或者是不返回值。本质来说方法就是程序重构的产物。
6553 注：为什么叫程序，意思就是说程序的执行顺序是垂直向下的，无论是后来的面向对象编程思想，还是面向切面的
6554 编程思想，都是在面向过程的基础进行封装的，都是为了程序的模块化，解耦，可维护性，可读性，编程效率所进
6555 行的带代码结构的改善。它们之间分离开来之后的通信是通过地址进行的。
6556
6557 7. 在进行编程时，特别是在写方法的时候需要特别注意变量的作用域，很重要的，也是很容易出错的。要注意全局变量
6558 和局部变量的区别，作用域的大小，生命周期。推荐尽量地把变量依赖的作用域限制在最小的范围之内，增加可读性的
6559 同时可以减少程序错误的发生。
6560
6561 8. 在java中全部都是按值传递的意思就是说如果传递的是基本的数据类型的数据的话，那就是传递的是值的拷贝，如果传递
6562 的是大对象，其实本质就是传递的是新建大对象在堆内存中的地址值，所以说都是按值传递。这些值都是存放在栈内存中
6563 的。
6564 注：栈内存的存取效率较高，而且是操作系统自动分配的，但是内存的大小有限制，而堆内存的内存大小更大，效率
6565 较低，为对象分配内存的时候需要程序员自己分配。
6566
6567
6568
6569
6570 2015/10/19
6571
6572
6573
6574
6575
6576 1. Age wrinkles the body,quitting wrinkles the soul. 岁月使皮肤起皱，放弃使灵魂起皱。
6577
6578 2. 要处理大量的数据一定要考虑用循环遍历操作。
6579
6580 3. 现代比较时髦的语言基本上都是基于C语言的，像Java就是对C和C++的优化和封装的结果。
6581
6582 4. 学习编程最好要是一专多能，持续学习是你不断前进的动力，要不然就很容易限制在一个地方，遭到淘汰。
6583
6584
6585
6586
6587
6588 2015/10/20
6589
6590
6591
6592
6593
6594 1. Oracle
6595 *1. Choices as exciting as our technology.Careers as astounding as our solutions.Options as limitless
6596 as your imagination.
6597
6598 2. 存储信息数据时一般有以下三种方式作为选择：
6599 *1. 存储到session中
6600 *2. 存储到cookie中
6601 *3. 存储到数据库中
6602
6603 3. 序列化的作用就是存储信息数据：将一个对象的状态(各个属性)保存起来，然后适当的时候再获得。
6604 *1. 序列化：
6605 >1. 将数据分解成字节流，以便存储在文件中或者是在网络中传输。对象序列化不仅要将基本数据类
6606 型转换成字节表示，有时还要恢复数据。恢复数据要求有恢复数据对象的实例。
6607 >2. 如果某个类能够被序列化，其子类也可以被序列化
6608
6609 *2. 反序列化：打开字节流并重构对象。
6610 *3. 对象序列化可以实现分布式对象。例如：RMI(Remote Method Invocation)要利用对象序列化运行远程主机上
6611 的服务，就像在本地主机上运行对象时一样。
6612 *4. 对象序列化不仅可以保留一个对象的数据，而且递归保存对象引用的每个对象的数据。可以将整个对象层次
6613 写入字节流中，可以保存在文件中或者是在网络连接中传递。利用对象的序列化可以实现对象的深复制，即
6614 复制对象的本身以及引用的对象本身。序列化一个对象可能得到整个对象的序列。
6615
6616
6617 4. TCP和UDP
6618 TCP(Transmission Control Protocol,传输控制协议):
6619 *1. 提供IP环境下的数据可靠传输(一台计算机发出的字节流会毫无差错的发往网络上的其他计算机，而且计算机
6620 A接收数据包的时候同时也会向计算机B发送数据包，这也会产生部分通信量)，有效流控，全双工操作(数据
6621 在两个方向上同时传递)，多路复用服务，是面向连接，端到端的数据传输。
6622 *2. 面向连接:正式通信前必须要和对方获得连接。事先为所发送的数据开辟出连接好的通道，然后再进行数据发
6623 送，像打电话。
6624 *3. TCP支持的应用协议：Telnet(远程登录)、FTP(文件传输协议)、SMTP(简单邮件传输协议)。TCP用于传输数据
6625 量大，可靠性要求高的数据传输应用。
6626 UDP(User Data Protocol,用户数据报协议):
6627 *1. 面向非连接的（正式通信前不必与对方建立连接，不管对方的状态就直接发送，像短信，qq），不能提供可靠
6628 性、流控，差错恢复功能。UDP用于一次传输少量的数据，可靠性低，传输经济等应用。
6629 *2. UDP支持的应用协议：NFS(Network File System, 网络文件系统)，SNMP(Simple Network Management Protocol
6630 简单网络管理协议)，DNS(Domain Naming System,域名系统)，TFTP(Trivial File Transmission Protocol,
6631 通用文件传输协议)。
6632 总结：
6633 *1. TCP: 面向连接、传输可靠（保证数据的正确性，保证数据的顺序）、用于传输大量的数据（流模式）、速度慢、建立
6634 连接需要开销较多(时间，系统资源)。
6635 *2. UDP: 面向非连接，传输不可靠、用于传输少量数据（数据包模式）、速度快。
6636 *3. 当数据的传输性能必须让位与数据传输的可靠性，完整性，可控制性，TCP协议是首要的选择，当要强调数据的
6637 传输性能时而不是传输的完整性时，当然要选择UDP协议
6638 注: 传输协议的意思就是说在网络中要进行传输的数据格式。
6639
6640
6641 5. RMI(Remote Method Invocation)：能够让某个Java虚拟机上的对象调用另外一个Java虚拟机中的对象的方法。可以用此方法调用的
6642 任何对象都必须要实现该远程接口。RMI是非常重要的底层技术，EJB是建立在rmi基础之上的，现在还有一些开源的远程
6643 调用组件，其底层技术也是rmi。
6644
6645 6. 面向对象编程核心思想就是一切出发点都是基于类的。
6646
6647 7. 其实编程最有技术含量的地方是在给现实中的实体建模的这个过程，至于控制器端的处理数据主要任务是要你如何
6648 封装对象的属性数据之后是入库，或者是响应客户端的请求出库一条还是多条数据。客户端最好要设计的简洁精美，
6649 以用户体验为首要的任务即可。
6650
6651
6652
6653
6654
6655 2015/10/21
6656
6657
6658
6659
6660 1. You make my heart smile. 我心因你而笑。
6661
6662
6663
6664
6665
6666
6667 2015/10/22
6668
6669
6670
6671
6672
6673 1. A day is miniature of eternity. 一日是一生的缩影。
6674
6675 2. pwd ls cat mkdir rm cd tar
6676 *1. pwd(print working directory): 打印当前的工作目录。
6677 *2. cat(concatenate files and print on the standard output): 连接文件然后把文件的内容打印在屏幕上。
6678 *3. ls(list): 把文件夹里的文件或者是文件夹用列表形式横向地展现出来。
6679 *4. mkdir(make directory): 创建不重名的文件夹。
6680 *5. rm(remove): 移除文件或文件夹，可以递归地移除。
6681 rmdir(remove directory) : 移除文件夹。
6682 *6. cd(change directory): 改变工作目录，输入参数时你要转向的工作目录地址路径。
6683 *7. tar(tale archive)：压缩打包文件,将文件备份到磁带上。
6684 *8. su(switch user): 切换用户。
6685 *9. ps(process status): 用户的进程状态，相当于windows的任务管理器，参数-auxf。
6686 *10. du(disk usage): 磁盘使用了多少内存。
6687 *11. df(disk free): 磁盘还剩下多少内存。
6688
6689
6690
6691
6692
6693 2015/10/23
6694
6695
6696
6697
6698 1. Conceit is the quicksand of success. 自负是成功的流沙。
6699
6700 2. 《代码大全》：如何寻找缺陷
6701 *1. 调试代码的难度是首次编写代码的两倍。因此如果你在编写代码的时候就已经发挥了你的全部聪明才智，那么从
6702 概念上讲，你将无法凭借你自己的智慧去调试这些代码。--Brian Kernighan
6703 *2. 同测试一样，调试本身并不是改进代码质量的方法，而是诊断代码缺陷的一种方法。软件的质量必须从开始逐步
6704 建立：开发高质量软件产品的最佳途径是精确描述需求，完善设计，并使用高质量的代码编写规范。(意思就是说
6705 要在软件开发的细节过程中把错误扼杀在摇篮里)调试只是迫不得已时采用的手段。
6706 *3. 提高软件质量能够减少开发成本。最好的程序员能够找出最多的错误，最快地找出错误，并且能够正确改正错误。
6707 不需要硬着头皮在质量、成本和开发周期之间做出选择--鱼和熊掌尽可能兼得。
6708 *4. 你并不需要学会如何修正缺陷。你应该学会如何在一开始就避免缺陷的产生。
6709 *5. 绝大多数人或多或少都会犯错，然而，如果只是适度的疏忽，你还是可能会成为一位优秀的程序员。这是，程序
6710 中的错误为你提供了学习很多东西的绝好机会。
6711 *6. 你可以从错误中得到以下好处：
6712 >1. 理解你正在编写的程序。你所面对的程序一定有一些东西需要你去了解。因为如果你确实已经透彻的了解
6713 了它，这个程序就不应该还有缺陷，你应该早就纠正了缺陷。
6714 >2. 明确你犯了那种类型的错误。如果是你写的程序，缺陷就是你引进的。
6715 >3. 从代码阅读者的角度分析代码质量。你必须阅读自己的代码，以便发现其中的缺陷。
6716 >4. 审视自己解决问题的方法。想想那么多项目已经在调试上花费了大量的时间，如果你注意审视自己的调试
6717 方法，你或许就不会耗费那么多的时间。花点时间来分析并改进你的调试方法，可能就是减少程序开发
6718 时间的最有效的方法。
6719 >5. 审视自己修正缺陷的方法。除了审视自己如何发现缺陷，你还有关注自己如何修正缺陷。
6720 *7. 调试其实是一片及其富饶的土地，它孕育着你进步的种子。这片土地也是所有软件构建之路所交织的地方：
6721 可读性、设计、软件质量，凡是你能想到的无所不包。编写优秀的代码所得到的回报，如果你能精于此道，你
6722 甚至无须频繁调试。
6723 *8. 程序员们往往不愿意使用现成的数据来约束他们的推理。他们往往喜欢进行琐碎和无理性的修改，而且他们通常
6724 不愿意推翻以前不正确的修改。--Iris Vessey
6725 *9. 只有你在无法确定自己的程序在干什么的时候，编程才比较刺激。
6726 *10. 要知道如果你写的程序出了问题，那就是你的原因，不是计算机的，也不是编译器的。程序不会每次都产生不同
6727 的结果。它不是自己写出来的，是你写的，所以，请对它负责。
6728 *11. 即使某个错误初看似乎不能归咎于你，但出于你自身的利益，最好还是假设它的产生同你有关。这样的假设
6729 有助于你的调试。
6730 *12. 你集中注意力去寻找，要在程序里发现问题就已经足够困难了，更何况在你认为自己的代码完美无缺的时候。
6731 如果你宣称某个错误源自别人的代码，其他的程序员将会相信你已经仔细研究过这个问题。因此如果你一开
6732 始就假设错误是你引发的，就能避免陷入这样的尴尬境地：在公众面前先指责别人犯了错，最终却发现错误
6733 其实由你生。
6734 *13. 调试包括了寻找缺陷和修正缺陷。寻找缺陷--并理解缺陷--通常占到了整个调试工作的90%。
6735 *14. 对于调试，你并不需要随机猜测，也不需要求助于撒旦。思考问题的本身将会更加有效，也更为有趣。
6736 *15. 绝大多的程序员会开动脑筋进行调试会给自己带来更多的满足感。
6737 *16. 高效的程序员只需要花费抵消程序员的1/20的时间，他们并不是随机地猜测如何修正程序。他们使用科学的方法
6738 --即所有的科学探索所必须的发现和实证的过程。
6739 *17. 如果错误只是时不时的出现，那么几乎没有可能找出它发生的可能的原因。在工作中，让某个不定期的错误有
6740 规律地重现几乎是最具挑战性的工作任务之一。
6741 *18. 有时你太关注你的问题了，已经到了无法思考的程度。你有多少次从工作中暂停下来去泡一杯咖啡，在你走向
6742 咖啡机的路上却灵光一现解决了问题。暂时放弃思考的好处是可以减少调试带来的焦虑。不是潜入头脑中的
6743 焦虑感是一个明确的信号：到了该休息的时候了。
6744
6745
6746
6747 3. 编辑器
6748 *1. MarkDownPad 2:
6749 *2. UtralEdit
6750 *3. NotePad++
6751 *4. EditPlus
6752
6753
6754
6755
6756 2015/10/24
6757
6758
6759
6760
6761
6762 1. sow nothing,reap nothing。 没有耕耘，就没有收获。
6763
6764 2. 《代码大全》：如何修正缺陷
6765 *1. 具有语法分析能力的编辑器是开发环境成熟与否的重要标志。
6766 *2. 调试过程中最让人头疼的部分是寻找缺陷。修正缺陷则是较为简单的部分。但如同很多简单的任务一样，正
6767 是因为它太过简单才让人们经常对它掉以轻心。、
6768 *3. 在动手之前先要理解问题，如果想让自己的生活潦倒，让自己的代码质量一塌糊涂的最好方法，就是不懂装懂
6769 地动手修补程序缺陷。在修补问题之前，请保证你已经很透彻地理解了它。
6770 *4. 理解程序本身，而不仅仅是问题。与对问题只知皮毛相比，如果理解了整个问题的来龙去脉，你就更容易解决
6771 它。那些对整个程序有着全局理解的程序员们成功修改程序的可能性要比那些仅仅关注局部程序的程序员们高
6772 得多。
6773 *5. 绝对不要站着调试。--Gerald Weinberg
6774 *6. 验证对错误的分析。在匆匆下手之前，需要确认你对问题的分析只是正确的。花点时间运行测试用例，证明你
6775 的假设，证明你的假设，并证伪你的假设的逆命题。
6776 *7. 休息足够长的时间能让你肯定自己的解决方案是对的。不要受到所谓捷径的诱惑。休息一下或许会让你花掉更
6777 多的时间，但在多数的情况下，你为问题所付出的成本会更少。如果没有意外，休息之后你将会正确地改正程
6778 序中的错误，你的经理也绝不会在你享受滑雪度假的时候打电话让你回到公司。
6779 *8. 保存最初的源代码。在堆缺陷动手的之前，一定要把原始版本的代码打包存放起来，这样你才能在出现问题的
6780 时候恢复到原始版本。如果拥有最初的源代码，至少你能对新旧文件进行比较，看看自己到底改了那些地方。
6781 *9. 治标，而不是治本。你也应该解决问题的表象，但更应该把注意力放在解决更深层次的问题上，而不是把编程
6782 用绷带将代码裹起来。没有彻底理解问题，就不要去修改嗲吗。如果仅仅是治标，你只会把代码搞得更糟糕。
6783 *10. 计算机适合用于可预测的系统性的计算。而人在数据的创造性使用上更胜一筹。
6784 *11. 修改代码时一定要有恰当的理由。在做一项改动之前，先确信自己的修改能够起作用。改错了代码只会让你
6785 目瞪口呆愣在一旁。这会让你自我怀疑，甚至想重新衡量自己的价值并对自己的内心进行深入的剖析。这样
6786 的情况越少越好。
6787 *12. 一次只改一个地方。在一次只完成一个改动的情况下，你会发现错误已经够狡猾了。
6788 *13. 检查自己的改动。自己检查程序，再让别人检查程序。或者是同别人一道检查程序。
6789 *14. 搜索类似的缺陷。找到一个缺陷以后，因该看看还有没有与之类似的缺陷。缺陷常常会成群结队的出现，如
6790 果能抓住这一类的一个，你就能改掉这一类缺陷。但要找出这些类似的缺陷，需要你对整个程序有透彻的理
6791 解。如果你想不出如何查找类似缺陷，这就意味着你还没有完全理解问题。
6792 *15. 如同任何其他的软件开发活动一样，调试是一种要求程序员花费大量脑力的工作。在阅读自己所编写的代码
6793 的时，你不得不同这些非常熟悉的东西保持距离，并对自己希望出现的运行结果又所警惕。
6794 *16. 人总希望你个新的现象类似于他们见到过的某种现象。他们希望新的控制结构像老的控制结构一样工作。
6795 *17. 养成良好编程习惯的重要性：规范的格式、恰当的注释、良好的变量和子程序的命名方式，以及其他编程
6796 风格要素都有助于构建编程的良好基础。在这样的基础之上，可能发生的错误将因为与众不同而变得格外
6797 引人注目。
6798 *18. 调试程序最高效的程序员们能够在调试时对程序中的无关部分的选择视而不见。(Basili,Selby,and Hutchens
6799 1986)
6800 *19. 在调试代码的时候，要警惕那些没有足够心里距离的相似变量名或者是子程序名。而在编写代码的时候，应
6801 该为变量或子程序选择差别较大的名字，这样你就可以避免此类问题的发生。
6802 *20. 将编译器的警告级别设置为最高级，尽可能不放过任何一个警告，然后修正编译器所报告的全部错误。要有
6803 这样一种假设：那些编写编译器的人对你所使用的语言的了解要远远胜过你自己。如果他们对你的程序提出
6804 了警告，这常常会表示你现在有了一个学习你所使用的语言更多知识的良机。要努力去理解这些警告信息的
6805 正真含义。
6806 *21. 用对待错误的态度来处理警告。一些编译器允许将警告看做是错误。使用这一功能的意义在于它能够提升警告
6807 信息所显示出的重要性。
6808 *22. 你或许会奇怪居然会有人批评这些调试器。但计算机科学领域中的泰山北斗的确建议完全不要使用调试器。他
6809 们主张使用你的大脑，避免使用调试工具。依靠自己的思考你能更为快速更为准确地发现问题。他们建议，与
6810 其使用调试器，你不如在头脑里执行程序，把其中的缺陷清理出来。
6811 *23. 调试器当然无法带起良好的思维，但是在一些情况下，思维也无法取代优秀的调试器。因此，最为有效的组合
6812 是良好的思维加上优秀的调试器。
6813 *24. 调试同整个软件开发的成败息息相关。花点时间来提高自己的调试技术还是很划算的，因为优秀和拙劣的调试
6814 表现之间的差距至少是10:1。
6815 *25. 专注于你的调试工作，让每一次测试都能让你朝着正确的方向前进一步。
6816
6817 3. 《代码大全》：重构
6818 *1. 所有成功的软件都经历过改变。--Fred Brooks
6819 *2. 再庞大复杂的代码都可以通过重构加以改善。--Gerald Weinberg
6820 *3. 良性的软件演化使代码得到了发展，就如猴子进化到穴居人再进化到我们这样的身份高贵的软件工程师。然而，
6821 有时演化的力量也会以另外一种方式打击你的程序，甚至将它送入不断退化的螺旋形轨道。
6822 *4. 构建期的修改常常是随心所欲之作--系统处于高度动态阶段，出现错误的代价较小。这样的环境孕育着与维护
6823 期不同的软件演化风格。
6824 *5. 程序员在参与到软件演化时有一个普遍的弱点，这就是将其作为一种并非有意而为的过程。
6825 *6. 演化一开始就充满危险，但同时也是使你的软件开发接近完美的天赐良机。演化应当提升程序的内在质量。
6826 *7. 复制粘贴即设计之谬。--David Parnas
6827 *8. 注释被用于解释难懂的代码。注释在程序中扮演了重要的角色，但它不应当被用来为拙劣的代码的存在而
6828 辩护。
6829 *9. 不要为拙劣的代码编写文档--应当重写代码。(Kernighan and Plauger 1978)
6830 *10. 用多态的来替代条件语句(尤其是重复的case语句) 结构化程序里很多的case语句中的逻辑都可以被放到
6831 继承关系中，通过多态函数来调用实现。
6832 *11. 与其将分解一个正在正常工作的系统比作替换水槽里的塞子，倒不如把它看成是替换大脑中的一根神经。如果
6833 我们把软件维护称为"软件脑补外科手术"，工作起来会不会要轻松一些。--Gerald Weinberg
6834 *12. 如果说在第一次运行程序的时候检查代码是必须的，那么在接下来的修改工作中，时刻关注代码则更为重要。
6835 *13. 程序员在对代码尝试第一次修改的时候，有超过50%的可能性出错。有趣的是，如果程序员处理一大部分代码
6836 而不是区区几行，那么他们的修改是正确的几率则会有所提高。
6837 *14. 不要把代码当做先写后改的代名词。重构最大的问题在于被滥用。
6838 *15. 重构的风险类似于代码调整的风险。
6839 *17. 修改是程序一生都要面对的事情，不仅包括最初的开发阶段，还包括首次发布之后。
6840 *18. 在修改中软件的质量要么改进，要么恶化。软件演化的首要法则就是代码演化应当提升程序的内在质量。
6841 *19. 重构成功之关键在于程序员应学会关注那些标志着代码需要重构的众多的警告或"代码臭味"。重构成功的另
6842 一要素就是程序员应当掌握大量特定的重构方法。重构成功的最后要点在于要有安全重构的策略。一些重构
6843 的方法会比其他重构方法要好。
6844 *20. 开发阶段的重构是提升程序员质量的最佳时机，因为你可以立刻让刚刚产生的改变梦想变成现实。请珍惜开
6845 发阶段的天赐良机！
6846
6847
6848
6849
6850
6851
6852 2015/10/25
6853
6854
6855
6856
6857 1. Sucess is getting what you want,happiness is wanting what you get. 成功是得其所想，幸福是想其所得。
6858
6859 2. 《代码大全》：代码的调整策略
6860 *1. 在着手任何较大规模的性能调整工作之前，最好想想代码调整策略，这样你就不会在原本应当去做其他工作的
6861 时候耗费时间对代码做优化了。
6862 *2. 代码调整只是调高程序性能的一种方法。除此之外，你还可以找到提高性能的其他方法，这些方法能让你以更
6863 少的时间和对代码更少的负面影响来实现你的目标。
6864 *3. 对用户来说，程序员按时交付软件，提供一个清爽的用户界面，避免系统死机常常比程序的性能更为重要。
6865 *4. 性能同代码速度之间存在着很松散的联系。如果只是关注于代码的运行速度，你的工作不免顾此失彼。要特别
6866 当心放弃其他功能去让你的代码跑得更远。如果过分强调速度，程序的整体性能(表现)常常不升反降。
6867 *5. 一旦你选择把效率作为头等大事，无论重点是在处理速度还是在处理代码所占用的资源上，你都应该考虑一下
6868 其他可能的选择，而且应当是在代码以及选择提高速度还是减少资源占用之前去做。
6869 >考虑的方面
6870 >1. 程序的需求
6871 >1. 在花费时间处理一个性能问题之前，请想清楚你的确都是在解决一个确实需要解决
6872 的问题。
6873 >2. 程序的设计
6874 >1. 如果你知道程序的资源占用量和速度至关重要，那么就应该仔细设计程序架构来满
6875 足这些需求吗。在设计架构时优先考虑整体性能，然后在为单个的子系统、类和类
6876 设置要达到的资源占用目标。
6877 >3. 类和子程序的设计（实体设计）
6878 >1. 设计类和子程序的内部机制为高性能的谁提供了另一个机会。在这一层次的处理中，
6879 是否选择了合适的数据类型和算法将对性能产生重要影响。因为这两者通常会同时
6880 影响程序的内存占用和执行速度。
6881 >4. 程序同操作系统的交互
6882 >5. 代码编译
6883 >6. 硬件
6884 >7. 代码调整
6885 >1. 从系统设计到代码调整的各个层面上，你都有可能极大地提高程序性能。要使程序
6886 各层的优化同其他层的优化无关，而这是几乎不可能的，但考虑到可能产生的效果
6887 这样的潜力还是很鼓舞人心的。
6888 >2. 代码调整它富有吸引力还在于展握高效代码的这门编程艺术是成为严肃意义上程序
6889 员所需的加冕仪式。
6890 >3. 代码调整的问题在于，高校的代码并不一定就是"更好"的代码。
6891 >4. 在高级语言中，减少代码的行数就可以提升所生成的机器代码的运行速度，或是减
6892 少资源占用--错误！
6893 *6. 相对于其他的单个因素--包括瞎搅蛮干，计算之罪
6894 更多的归咎于效率(即使效率并非关键所在)。--W. A. Wulf
6895 *7. Algol是绝大部分的现代语言的开山鼻祖，也是有史以来最具影响力的语言之一。
6896 *8. The best is the enemy of the good.（完美是优良之大敌）愈是最求完美，越有可能完不成任务。程序员们
6897 首先应该实现程序应该具备的所有功能，然后在再使程序臻于完美。而这时，需要精益求精的部分通常是很少
6898 的。
6899 *9. 我们应当忘记那些琐屑的效率提升，因为在97%的场合下，不成熟的优化乃万恶之源。--Donald Knuth
6900 *10. 抛开最简洁代码所具备的美感不谈，高级语言代码行数和程序最终的资源占用和运行速度之间并无必然联系。
6901 *11. 在极少情况下，程序员能正确确定出程序的瓶颈。如果优化放在整个系统完成之后，那么程序员就可以明确各
6902 个问题域以及各自的相对重要性，从而有效地对全部优化所用时间进行分配。
6903 *12. 如果能将开发最简单程序所节省下来的时间放到优化可运行程序上面，结果得到的程序必然会比那些未经斟酌
6904 便去优化的程序更快。(Stevens 1981)
6905 *13. 对于特定类型的项目，运行速度或资源占用是程序员需要重点考虑的问题。这种类型的项目比人们通常所认为
6906 的要少，并且随着时间的推移会越来越少。这类项目的性能风险必须通过初期的设计来规避。对其他的项目而
6907 言，过早地优化则会对软件的整体质量产生严重的威胁，受到影响的甚至会包括软件的性能。
6908 *14. Jadkson的优化法则。法则一：不要对代码进行优化。法则二：(仅限于高手使用)：不要优化--除非你已经有了
6909 一个非常清晰，而且未经优化的解决方案。--M. A. Jackson
6910 *15. 程序员应当使用高质量的程序设计，把程序编写正确。使之模块化并易于修改，将让后期的卫华工作变得很容
6911 易。在程序已经完成并正确之后，再去减产系统的性能。如果程序运行迟钝，那么再设法让它变得更小。除非
6912 你对需要完成的工作一清二楚，否者绝不要对程序做优化。
6913 *16. 程序效率低下的根源之一就是不必要的输入/输出。如果你可以选择在内存中处理文件，就不要费力地通过磁盘、
6914 数据库，或是跨越网络访问相同的文件。除非程序对空间占用非常敏感，否者数据都应放在内存里面。访问内存
6915 比访问文件快上1000倍。的确，在我所使用的C++编译器中，访问内存的时间甚至短得无法测量。
6916 *17. 内存所带来的高效，已经足够让你对是否将I/O引入到一个对速度要求苛刻的程序中再三斟酌了。
6917 *18. 调用系统子程序的代价常常是十分可观的。
6918 *19. 解释性语言似乎应当为系统性能所受到的损害做出解释，在机器代码创建和执行之前，解释型语言必须要处理
6919 每一条程序指令。
6920 *20. 程序性能的终极麻烦就是代码中的错误。
6921 *21. 为经常使用的表格定义索引根本不算优化，这只是一种很好的编程习惯罢了。
6922 *22. 绝大部分常用操作所耗费的时间相差无几--成员函数调用、赋值、整形运算、和浮点运算等等之间都差不多。
6923 超越函数的计算则会用去非常多的时间。多态函数调用比其他函数调用略微费时。
6924 *23. 由于程序中某一小部分常常会耗费同自己体积不成比例的运算时间，所以你应当测量代码性能，找出代码中的
6925 热点(hot spots)。一旦发现了这样的区域并对该处的代码进行了优化，就再一次进行测量，看看你到底有了多
6926 少改进。性能很多的方面都是违反直觉的。
6927 *24. 经验对性能优化也没有太大的帮助。一个人的经验或许来源于一台老掉牙的计算机，或许来自于过时的语言或
6928 编译器--在任何一种因素发生改变后，所有的经验之谈也会成为狗屁。除非对效果进行评估，否则你永远也无
6929 法确定某次优化所带来的影响。
6930 *25. 如果你认为没有必要通过测量来证实哪种方法更为有效，那么同样也没有必要牺牲代码的可读性，而把赌注压
6931 在性能的提高上。
6932 *26. 如果没有数据，任何程序员都无法预测或分析出性能瓶颈在哪儿。无论你猜测性能会如何变化，你都会惊奇的发
6933 现试试与你的设想背道而驰。--Joshph M. Newcomer
6934 *27. 尽管绝大部分优化方法单独看起来都收效甚微，但累计起来，效果是惊人的。从提升百分比来看，没有三四种
6935 优化方法能达到我的性能目标。但这些方法结合起来最终收到了很好的效果。
6936 *28. 如果你的坑挖得足够深，你总会看到惊人的宝藏。
6937 *29. 代码每执行一次二位数组访问，就会进行费时的乘法和加法运算。
6938 *30. 如果你认为没有必要通过测量来证实那种方法更为有效，那么同样也没有必要牺牲代码可读性，而把赌注押在
6939 系能的提高上。
6940 *31. 一旦确定了性能的瓶颈，你一定会为自己通过代码调整为获得的代码性能提升吃惊不已。尽管几乎不可能从一
6941 种方法中获得10倍的性能改进，但你可以将多种方法有效地结合起来。 在优化时应当反复尝试，直到发现了
6942 有用的方法。
6943 *32. 用良好的代码来开发软件，从而使程序易于理解和修改。
6944 *33. 性能知识软件整体质量的一个方面，通常不是最重要的。精细的代码调整也只是实现整体性能的一种方法，通
6945 常也不是决定性的。相对于代码本身的效率而言，程序的架构、细节设计以及数据结构和算法选择对程序的运
6946 行速度和资源占用的影响通常会更大。
6947 *34. 定量测量是实现性能最优化的关键。定量测量需要找出能真正决定程序性能的部分，在修改之后，应当通过重
6948 复测量来明确修改是提高还是降低了软件的性能。绝大多数的程序都有那么一小部分代码耗费了绝大部分的运
6949 行时间。如果没有测量，你不会知道是哪一部分代码。代码调整需要反复尝试，这样才能获得理想的性能提高。
6950 *35. 为性能优化工作做好准备的最佳方式就是在最初阶段编写清晰的代码，从而使代码在后序工作中易于理解和修
6951 改。
6952
6953 4. 《代码大全》：代码调整技术
6954 *1. 不要盲从于任何优化建议的重要性--特定编译器实现将会极大地影响到优化的结果。
6955 *2. 简而言之，没有设什么能代替测量得出的结论。
6956 *3. 在很多情况下，代码的可读性和可维护性都要比运行速度或资源占用更为重要。
6957 *4. 在最初的代码编写阶段，你可以尽情地使用可读性更好的方法，而班代码运行速度放到稍后来处理。
6958 *5. 尽可能减少在循环内部做的工作。如果你可以在循环外面计算某语句或某部分语句，而在循环内部只是使用
6959 计算结果，那么就把它们放到外面。这是一种良好的编程实践，在很多情况下还可以改善代码程序的可读性。
6960 *6. 把最忙的循环放在最内层。
6961 *7. 数据类型的改变同样可以成为减少程序规模和改进执行速度方面的利器。对某种特定数据类型实现进行恰如其
6962 分的调整，同样也能提高代码的性能。例如：整形树的加法和乘法要比浮点数的相应运算快很多。
6963 *8. 多年来积累的编程智慧表明，处理多维数组的代价是惊人的。
6964 *9. 盲目采纳各种代码调整建议会有多么危险，除非在自己特定的环境下尝试了这种方法，否则你永远不能对它带
6965 来的效果信以为真。
6966 *10. 缓存元素或将新元素存放到缓存中的开销越小，缓存体现的价值就越大。同其他优化技术一样，缓存增加了程
6967 序的复杂性，使得程序更容易出错。
6968 *7. 当程序遭遇性能瓶颈的时候，你应当用低级语言重写代码。
6969 *8. 性能是一个永恒的话题。编写桌面应用程序的人可以对优化毫不关心，但那些为嵌入式系统、实时系统和其他有
6970 着严格速度和资源限制的系统编写代码的人仍然可以从中获益。
6971 *9. 代码调整无可避免地为性能改善的良好愿望而付出复杂性、可读性、简单性、可维护性方面的代价。由于每一次
6972 调整后需要对性能进行重新评估，代码调整后需要对性能进行重新评估，代码调整还引入了巨额的管理维护开销。
6973 *10. 恪守"对每一次的改进进行量化"的准则，是抵御思考成熟前匆忙优化之诱惑的法宝，这一准则也帮助我坚守编写
6974 清晰代码的一贯作风。未经测量的代码优化对性能山个改善充其量是一次投机，然而，其对可读性等产生的负面影
6975 响则确凿无疑。
6976 *11. 优化结果在不同的语言，编译环器和环境下有很大的差异。如果你没有对每一次的优化进行测量，你将无法判断
6977 优化到你是帮助还是损害了这个程序。
6978 *12. 第一次优化通常不会是最好的。即使找到了效果很不错的，也不要停下扩大战果的步伐。
6979 *13. 代码调整这一话题有点类似于核能，富有争议，甚至会让人冲动，请务必谨慎行事。
6980 5. 指针的特性就是高效、灵活、易出错。
6981
6982 6. 代码调整技术的核心就是如何减少对数据的运算强度，但是要记住不要为了优化代码而去优化代码。
6983
6984 7. 《大码大全》：程序规模对构建的影响。
6985 *1. 改善交流效率的常用方式就是采用正式的文档。
6986 *2. 随着项目规模的增大，通常需求和设计犯得错误会更多。有些时候，错误仍然主要来自构建。在小项目中，构建
6987 错误大约占所有被发现错误的75%。方法论对于代码质量的影响不大，对应用程序质量影响最大的通常是编写程序
6988 的各个开发者的技能(Jones 1998).
6989 *3. 没人能够独享成功的奖牌，组织结构对项目的成败的影响力更大。
6990 *4. 小项目以构建活动为主。更大的项目需要做更多的架构、集成工作和系统测试工作才能成功。
6991 *5. 不论项目的规模如何，有些技术总是很有价值的：有训练的编码实践、让其他开发者审查代码设计和代码、好的
6992 工具支持，以及使用高级语言。这些技术对小项目很有价值，对大项目的价值更是无法衡量。
6993 *6. 代码行数和团队规模并不是影响项目大小的仅有的因素。另一个更敏感的影响因素是最终软件的质量和复杂度。
6994 *7. 形式化的方法不一定总是有趣，而且如果用得不合适也可能得不偿失。然而项目越大，复杂度也就越大，也就越
6995 需要有意识的去关注方法论。
6996 *8. 你要协调的人越多，那么为了与他们相互协调，所需要些的文档也就越正规。
6997 *9. 随着项目规模的扩大，交流需要加以支持。大多数方法论的关键点都是在于减少交流中的问题，而一项方法论
6998 的存亡关键也应取决于它能否以促进交流。
6999 *10. 变更控制的是指就是确定什么最重要，所以不要因为害怕官僚主义就不去享受变更控制的诸多益处。
7000
7001 8. 《代码大全》：管理构建
7002 *1. 软件项目管理是人类在21世纪面临的一项重大挑战。评估项目的规模和完成项目所需的工作量是软件项目管理
7003 最具挑战性的方面之一。
7004 *2. 项目早期的评估结果注定不会很准确。随着项目的推进，评估的准确度会越来越高。在项目进行过程中要定期
7005 地重新评估，用你在每一项活动中学到的知识去改进你对下一项活动的评估。
7006 *3. 在软件开发中，很难做出一个不适合采用迭代法的领域。迭代对于评估非常有用。
7007 *4. 程序的规模对生产力和质量的影响并不总是很直观的。
7008 *5. 对软件项目进度影响力最大的是所开发的程序的规模。
7009 *6. 最初的及评估的准确度的重要性远远比不上你"随后为了完成进度而成功地控制资源"的重要性。
7010 *7. 越接近项目后期，延误和超支的现象就越严重。项目并不能在后期把时间补回来；而是会越来越落后。
7011 *8. 简单的说，"往一个延期的项目里增加人手会让它延期更久"却掩盖不了这样一个事实，那就是在某些场合下，往
7012 延期的项目里增加人手是能够让它提速的。
7013 *9. 如果做不到完整的去掉某项特征，那么还可以提供一个该功能的简化版本。
7014
7015
701
