项目：某公司综合业务管理系统制作花絮（数据库操作）

嗯，做交互式的页面自然会用到数据库。
在这次项目中，我们选用的是Microsoft SQL Server 2000 Enterprise Edition。

在做登录验证的时候，会用到需要从数据库中读出用户注册信息。这样，常规的操作便是：

1using System.Data.SqlClient;
2
3string source = "server=(local); uid=sa; pwd= 123; database=Northwind";
4SqlConnection conn = new SqlConnection(source);
5conn.open();
6//Do something
7conn.close();

可是，我一想到，如果需要在每个需要用到数据库的页面都这样写，那代码的可重用性就太低啦。而且这样不停的粘贴代码的撰写方式，就和写ASP差不多啦。所以，我决定以OOP的思想，把这个功能封装起来！

在这次的项目中，我是这样操作的：
1、建立一个类，名为DBShortcut，也就是数据库快捷方式的意思。
2、由于是用户验证，所以仅需要一个SqlDataReader就可以了。于是，我再建立一个方法，取名叫UseDataReaderEX，这里方法名中加上EX是提醒自己，需要对抛出的异常进行捕获！出于方便的因素，我把处理异常的代码放到调用这个类的那个页面中去。在这个类中就不再包含异常处理逻辑了。另外，既然这个方法的名字叫UseDataReaderEX，那么这个方法的返回值理所当然的是一个SqlDataReader。
3、在需要用到SqlDataReader的地方，只要先生成一个DBShortcut类，然后调用该类中的UseDataReaderEX方法，就可以得到一个满足需要的SqlDataReader了。这样真的是方便了很多噢！

下面就贴代码吧：

 1/**//*自贡网通综合业务系统
 2 * 版本：V1.0
 3 * 日期：2006-01-18
 4 * 作者：何适
 5 * */
 6
 7using System;
 8
 9using System.Data;
10using System.Data.OleDb;
11using System.Data.SqlClient;
12
13namespace zgcnc
14{
15    /**//// <summary>
16    /// 操作数据库而撰写的中间层。
17    /// 为操作数据库提供快捷方式。
18    /// </summary>
19    public class DBShortcut
20    {
21        private string serverip = "";
22        private string dbname = "";
23        private string dbuser = "";
24        private string dbpassword = "";
25        private string todosql = "";
26        
27        /**//// <summary>
28        /// 带参数构造函数
29        /// </summary>
30        /// <param name="serverip">数据库服务器IP</param>
31        /// <param name="dbname">数据库库名</param>
32        /// <param name="dbuser">数据库用户名</param>
33        /// <param name="dbpassword">数据库密码</param>
34        /// <param name="todosql">需要执行的SQL语句</param>
35        public DBShortcut(string serverip, string dbname, string dbuser, string dbpassword, string todosql)
36        {
37            this.serverip = serverip;
38            this.dbname = dbname;
39            this.dbuser = dbuser;
40            this.dbpassword = dbpassword;
41            this.todosql = todosql;
42        }
43
44        /**//// <summary>
45        /// 得到一个SqlDataReader的函数
46        /// </summary>
47        /// <returns>一个SqlDataReader</returns>
48        public SqlDataReader UseDataReaderEX()
49        {
50            string source = "uid="+this.dbuser+";pwd="+this.dbpassword+";initial catalog="+this.dbname+";Server="+this.serverip+";Connect Timeout=30";
51            string sql = todosql;
52            SqlConnection conn = new SqlConnection(source);
53            conn.Open();
54            SqlCommand cmd = new SqlCommand(sql, conn);
55            SqlDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
56            return reader;
57        }
58
59
60    }
61}

使用的时候，只需要这样就可以了：

1DBShortcut dbshortcut01 = new DBShortcut("(local)", "cnc", "sa", "123456", sql);
2SqlDataReader dbreader = dbshortcut01.UseDataReaderEX();

当然，别忘了对异常进行捕获：

 1try
 2{
 3   if(dbreader.Read())
 4   {
 5      //Do something
 6   }
 7   else
 8   {
 9      //Do something
10   }
11}
12catch(Exception Ex01)
13{
14   //Do something
15}
16finally
17{
18   dbreader.Close();
19}

难点提示
用这个方法来进行数据库操作，使用起来十分的方便。同时，由于是封装在类中的（DBShortcut），将来以后如果有进一步的功能需求（如需要DataSet，则新建立一个方法——“public DataSet UseDataSetEX()”即可。），也可以十分方便的扩充。
使用这种思路唯一的难点就是对打开的数据库联系进行关闭。
当我们使用完了我们得到的SqlDataReader后，可以在页面里使用“dbreader.Close();”很方便得将SqlDataReader关闭掉。但打开的数据库连接依然存在，Connection并没有随之关闭！

常规的思路是调用“conn.Close();”，可无奈在当前的情况中，由于使用了DBShortcut，并不能直接在调用DBShortcut对象的页面中使用“conn.Close();”。
如果把“conn.Close();”放到UseDataReaderEX()方法的return语句前面，则又会发现返回的SqlDataReader有错。整个程序都不能正常运行了。

经过查询多方资料，终于找到解决方法，即是把如下语句：

1SqlDataReader reader = cmd.ExecuteReader();

修改为：

1SqlDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);

这样，当我们释放掉SqlDataReader时，与之相关的SqlConnection也就随之关闭了。

类别    ：Rich Web Client
关键词  ：JS OOP，JS Framwork, Rich Web Client，RIA，Web Component，
          DOM，DTHML，CSS，JavaScript，JScript

项目发起：aimingoo (aim@263.net)
项目团队：aimingoo, leon(pfzhou@gmail.com)
有贡献者：JingYu(zjy@cnpack.org)
================================================================================

八、JavaScript面向对象的支持
~~~~~~~~~~~~~~~~~~
很少有人对JavaScript的面向对象特性进行系统的分析。我希望接下来的文字让你了解到这
个语言最少为人知的一面。

1. JavaScript中的类型
--------
虽然JavaScript是一个基于对象的语言，但对象(Object)在JavaScript中不是第一型的。JS
是以函数(Function)为第一型的语言。这样说，不但是因为JS中的函数具有高级语言中的函
数的各种特性，而且也因为在JS中，Object也是由函数来实现的。——关于这一点，可以在
后文中“构造与析构”部分看到更进一步的说明。

JS中是弱类型的，他的内置类型简单而且清晰：
---------------------------------------------------------
undefined : 未定义
number    : 数字
boolean   : 布尔值
string    : 字符串
function  : 函数
object    : 对象

 1). undefined类型
========================
在IE5及以下版本中，除了直接赋值和typeof()之外，其它任何对undefined的操作都将导致
异常。如果需要知道一个变量是否是undefined，只能采用typeof()的方法：
<script>
var v;
if (typeof(v) == 'undefined') {
  // ...
}
</script>

但是在IE5.5及以上版本中，undefined是一个已实现的系统保留字。因此可以用undefined来
比较和运算。检测一个值是否是undefined的更简单方法可以是：
<script>
var v;
if (v === undefined) {
  // ...
}
</script>

因此为了使得核心代码能(部分地)兼容IE5及早期版本，Romo核心单元中有一行代码用来
“声明”一个undefined值：
//---------------------------------------------------------
// code from Qomolangma, in JSEnhance.js
//---------------------------------------------------------
var undefined = void null;

这一行代码还有一点是需要说明的，就是void语句的应用。void表明“执行其后的语句，且
忽略返回值”。因此在void之后可以出现能被执行的任何“单个”语句。而执行的结果就是
undefined。当然，如果你愿意，你也可以用下面的代码之一“定义undefined”。
//---------------------------------------------------------
// 1. 较复杂的方法，利用一个匿名的空函数执行的返回
//---------------------------------------------------------
var undefined = function(){}();

//---------------------------------------------------------
// 2. 代码更简洁，但不易懂的方法
//---------------------------------------------------------
var undefined = void 0;

void也能像函数一样使用，因此void(0)也是合法的。有些时候，一些复杂的语句可能不能
使用void的关键字形式，而必须要使用void的函数形式。例如：
//---------------------------------------------------------
// 必须使用void()形式的复杂表达式
//---------------------------------------------------------
void(i=1);       // 或如下语句:
void(i=1, i++);

 2). number类型
========================
JavaScript中总是处理浮点数，因此它没有象Delphi中的MaxInt这样的常量，反而是有这
样两个常值定义：
  Number.MAX_VALUE  : 返回 JScript 能表达的最大的数。约等于 1.79E+308。
  Number.MIN_VALUE  : 返回 JScript 最接近0的数。约等于 2.22E-308。

因为没有整型的缘故，因此在一些关于CSS和DOM属性的运算中，如果你期望取值为整数2，
你可能会得到字符串“2.0”——或者类似于此的一些情况。这种情况下，你可能需要用
到全局对象(Gobal)的parseInt()方法。

全局对象(Gobal)中还有两个属性与number类型的运算有关：
  NaN      : 算术表达式的运算结果不是数字，则返回NaN值。
  Infinity : 比MAX_VALUE更大的数。

如果一个值是NaN，那么他可以通过全局对象(Gobal)的isNaN()方法来检测。然而两个NaN
值之间不是互等的。如下例：
//---------------------------------------------------------
// NaN的运算与检测
//---------------------------------------------------------
var
  v1 = 10 * 'a';
  v2 = 10 * 'a';
document.writeln(isNaN(v1));
document.writeln(isNaN(v2));
document.writeln(v1 == v2);

全局对象(Gobal)的Infinity表示比最大的数 (Number.MAX_VALUE) 更大的值。在JS中，
它在数学运算时的价值与正无穷是一样的。——在一些实用技巧中，它也可以用来做一
个数组序列的边界检测。

Infinity在Number对象中被定义为POSITIVE_INFINITY。此外，负无穷也在Number中被定
义：
  Number.POSITIVE_INFINITY  : 比最大正数（Number.MAX_VALUE）更大的值。正无穷。
  Number.NEGATIVE_INFINITY  : 比最小负数（-Number.MAX_VALUE）更小的值。负无穷。

与NaN不同的是，两个Infinity(或-Infinity)之间是互等的。如下例：
//---------------------------------------------------------
// Infinity的运算与检测
//---------------------------------------------------------
var
  v1 = Number.MAX_VALUE * 2;
  v2 = Number.MAX_VALUE * 3;
document.writeln(v1);
document.writeln(v2);
document.writeln(v1 == v2);

在Global中其它与number类型相关的方法有：
 isFinite()   : 如果值是NaN/正无穷/负无穷，返回false，否则返回true。
 parseFloat() : 从字符串(的前缀部分)取一个浮点数。不成功则返回NaN。

 3). boolean类型
========================
 (略)

 4). string类型
========================
JavaScript中的String类型原本没有什么特殊的，但是JavaScript为了适应
“浏览器实现的超文本环境”，因此它具有一些奇怪的方法。例如：
  link() : 把一个有HREF属性的超链接标签<A>放在String对象中的文本两端。
  big()  : 把一对<big>标签放在String对象中的文本两端。
以下方法与此类同：
  anchor()
  blink()
  bold()
  fixed()
  fontcolor()
  fontsize()
  italics()
  small()
  strike()
  sub()
  sup()

除此之外，string的主要复杂性来自于在JavaScript中无所不在的toString()
方法。这也是JavaScript为浏览器环境而提供的一个很重要的方法。例如我们
声明一个对象，但是要用document.writeln()来输出它，在IE中会显示什么呢？

下例说明这个问题：
//---------------------------------------------------------
// toString()的应用
//---------------------------------------------------------
var
  s = new Object();

s.v1 = 'hi,';
s.v2 = 'test!';
document.writeln(s);
document.writeln(s.toString());

s.toString = function() {
  return s.v1 + s.v2;
}
document.writeln(s);

在这个例子中，我们看到，当一个对象没有重新声明(覆盖)自己toString()方
法的时候，那么它作为字符串型态使用时(例如被writeln)，就会调用Java Script
环境缺省的toString()。反过来，你也可以重新定义JavaScript理解这个对象
的方法。

很多JavaScript框架，在实现“模板”机制的时候，就利用了这个特性。例如
他们用这样定义一个FontElement对象：
//---------------------------------------------------------
// 利用toString()实现模板机制的简单原理
//---------------------------------------------------------
function FontElement(innerHTML) {
  this.face = '宋体';
  this.color = 'red';
  // more...

  var ctx = innerHTML;
  this.toString = function() {
    return '<Font FACE="' + this.face + '" COLOR="' + this.color + '">'
      + ctx
      + '</FONT>';
  }
}

var obj = new FontElement('这是一个测试。');

// 留意下面这行代码的写法
document.writeln(obj);

 5). function类型
========================
javascript函数具有很多特性，除了面向对象的部分之外(这在后面讲述)，它自
已的一些独特特性应用也很广泛。

首先javascript中的每个函数，在调用过程中可以执有一个arguments对象。这个
对象是由脚本解释环境创建的，你没有别的方法来自己创建一个arguments对象。

arguments可以看成一个数组：它有length属性，并可以通过arguments[n]的方式
来访问每一个参数。然而它最重要的，却是可以通过 callee 属性来得到正在执行
的函数对象的引用。

接下的问题变得很有趣：Function对象有一个 caller 属性，指向正在调用当前
函数的父函数对象的引用。

——我们已经看到，我们可以在JavaScript里面，通过callee/caller来遍历执行
期的调用栈。由于arguments事实上也是Function的一个属性，因此我们事实上也
能遍历执行期调用栈上的每一个函数的参数。下面的代码是一个简单的示例：

//---------------------------------------------------------
// 调用栈的遍历
//---------------------------------------------------------
function foo1(v1, v2) {
  foo2(v1 * 100);
}

function foo2(v1) {
  foo3(v1 * 200);
}

function foo3(v1) {
  var foo = arguments.callee;
  while (foo && (foo != window)) {
    document.writeln('调用参数：<br>', '---------------<br>');

    var args = foo.arguments, argn = args.length;
    for (var i=0; i<argn; i++) {
      document.writeln('args[', i, ']: ', args[i], '<br>');
    }
    document.writeln('<br>');

    // 上一级
    foo = foo.caller;
  }
}

// 运行测试
foo1(1, 2);

2. JavaScript面向对象的支持
--------
在前面的例子中其实已经讲到了object类型的“类型声明”与“实例创建”。
在JavaScript中，我们需要通过一个函数来声明自己的object类型：
//---------------------------------------------------------
// JavaScript中对象的类型声明的形式代码
// (以后的文档中，“对象名”通常用MyObject来替代)
//---------------------------------------------------------
function 对象名(参数表) {
  this.属性 = 初始值;

  this.方法 = function(方法参数表) {
    // 方法实现代码
  }
}

然后，我们可以通过这样的代码来创建这个对象类型的一个实例：
//---------------------------------------------------------
// 创建实例的形式代码
// (以后的文档中，“实例变量名”通常用obj来替代)
//---------------------------------------------------------
var 实例变量名 = new 对象名(参数表);

接下来我们来看“对象”在JavaScript中的一些具体实现和奇怪特性。

 1). 函数在JavaScript的面向对象机制中的五重身份
 ------
“对象名”——如MyObject()——这个函数充当了以下语言角色：
  (1) 普通函数
  (2) 类型声明
  (3) 类型的实现
  (4) 类引用
  (5) 对象的构造函数

一些程序员(例如Delphi程序员)习惯于类型声明与实现分开。例如在delphi
中，Interface节用于声明类型或者变量，而implementation节用于书写类型
的实现代码，或者一些用于执行的函数、代码流程。

但在JavaScript中，类型的声明与实现是混在一起的。一个对象的类型(类)
通过函数来声明，this.xxxx表明了该对象可具有的属性或者方法。

这个函数的同时也是“类引用”。在JavaScript，如果你需要识别一个对象
的具体型别，你需要执有一个“类引用”。——当然，也就是这个函数的名
字。instanceof 运算符就用于识别实例的类型，我们来看一下它的应用：
//---------------------------------------------------------
// JavaScript中对象的类型识别
//   语法:  对象实例 instanceof 类引用
//---------------------------------------------------------
function MyObject() {
  this.data = 'test data';
}

// 这里MyObject()作为构造函数使用
var obj = new MyObject();
var arr = new Array();

// 这里MyObject作为类引用使用
document.writeln(obj instanceof MyObject);
document.writeln(arr instanceof MyObject);

================
(未完待续)
================
接下来的内容：

2. JavaScript面向对象的支持
--------

 2). 反射机制在JavaScript中的实现
 3). this与with关键字的使用
 4). 使用in关键字的运算
 5). 使用instanceof关键字的运算
 6). 其它与面向对象相关的关键字

3. 构造与析构

4. 实例和实例引用

5. 原型问题

6. 函数的上下文环境

7. 对象的类型检查问题

================================================================================
Qomolangma OpenProject v0.9

类别    ：Rich Web Client
关键词  ：JS OOP，JS Framwork, Rich Web Client，RIA，Web Component，
          DOM，DTHML，CSS，JavaScript，JScript

项目发起：aimingoo (aim@263.net)
项目团队：aimingoo, leon(pfzhou@gmail.com)
有贡献者：JingYu(zjy@cnpack.org)
================================================================================

 2). 反射机制在JavaScript中的实现
 ------
  JavaScript中通过for..in语法来实现了反射机制。但是JavaScript中并不
明确区分“属性”与“方法”，以及“事件”。因此，对属性的类型考查在JS
中是个问题。下面的代码简单示例for..in的使用与属性识别：
//---------------------------------------------------------
// JavaScript中for..in的使用和属性识别
//---------------------------------------------------------
var _r_event = _r_event = /^[Oo]n.*/;
var colorSetting = {
  method: 'red',
  event: 'blue',
  property: ''
}

var obj2 = {
  a_method : function() {},
  a_property: 1,
  onclick: undefined
}

function propertyKind(obj, p) {
  return  (_r_event.test(p) && (obj[p]==undefined || typeof(obj[p])=='function')) ? 'event'
    : (typeof(obj[p])=='function') ? 'method'
    : 'property';
}

var objectArr = ['window', 'obj2'];

for (var i=0; i<objectArr.length; i++) {
  document.writeln('<p>for ', objectArr[i], '<hr>');

  var obj = eval(objectArr[i]);
  for (var p in obj) {
    var kind = propertyKind(obj, p);
    document.writeln('obj.', p, ' is a ', kind.fontcolor(colorSetting[kind]), ': ', obj[p], '<br>');
  }

  document.writeln('</p>');
}

一个常常被开发者忽略的事实是：JavaScript本身是没有事件(Event)系统的。通
常我们在JavaScript用到的onclick等事件，其实是IE的DOM模型提供的。从更内核
的角度上讲：IE通过COM的接口属性公布了一组事件接口给DOM。

有两个原因，使得在JS中不能很好的识别“一个属性是不是事件”：
  - COM接口中本身只有方法，属性与事件，都是通过一组get/set方法来公布的。
  - JavaScript中，本身并没有独立的“事件”机制。

因此我们看到event的识别方法，是检测属性名是否是以'on'字符串开头(以'On'开
头的是Qomo的约定)。接下来，由于DOM对象中的事件是可以不指定处理函数的，这
种情况下事件句柄为null值(Qomo采用相同的约定)；在另外的一些情况下，用户可
能象obj2这样，定义一个值为 undefined的事件。因此“事件”的判定条件被处理
成一个复杂的表达式：
   ("属性以on/On开头" && ("值为null/undefined" || "类型为function"))

另外，从上面的这段代码的运行结果来看。对DOM对象使用for..in，是不能列举出
对象方法来的。

最后说明一点。事实上，在很多语言的实现中，“事件”都不是“面向对象”的语
言特性，而是由具体的编程模型来提供的。例如Delphi中的事件驱动机制，是由Win32
操作系统中的窗口消息机制来提供，或者由用户代码在Component/Class中主动调用
事件处理函数来实现。

“事件”是一个“如何驱动编程模型”的机制／问题，而不是语言本身的问题。然
而以PME(property/method/event)为框架的OOP概念，已经深入人心，所以当编程语
言或系统表现出这些特性来的时候，就已经没人关心“event究竟是谁实现”的了。

 3). this与with关键字的使用
 ------
 在JavaScript的对象系统中，this关键字用在两种地方：
   - 在构造器函数中，指代新创建的对象实例
   - 在对象的方法被调用时，指代调用该方法的对象实例

 如果一个函数被作为普通函数(而不是对象方法)调用，那么在函数中的this关键字
将指向window对象。与此相同的，如果this关键字不在任何函数中，那么他也指向
window对象。

 由于在JavaScript中不明确区分函数与方法。因此有些代码看起来很奇怪：
//---------------------------------------------------------
// 函数的几种可能调用形式
//---------------------------------------------------------
function foo() {
  // 下面的this指代调用该方法的对象实例
  if (this===window) {
    document.write('call a function.', '<BR>');
  }
  else {
    document.write('call a method, by object: ', this.name, '<BR>');
  }
}

function MyObject(name) {
  // 下面的this指代new关键字新创建实例
  this.name = name;
  this.foo = foo;
}

var obj1 = new MyObject('obj1');
var obj2 = new MyObject('obj2');

// 测试1: 作为函数调用
foo();

// 测试2: 作为对象方法的调用
obj1.foo();
obj2.foo();

// 测试3: 将函数作为“指定对象的”方法调用
foo.call(obj1);
foo.apply(obj2);

在上面的代码里，obj1/obj2对foo()的调用是很普通的调用方法。——也就
是在构造器上，将一个函数指定为对象的方法。

而测试3中的call()与apply()就比较特殊。

在这个测试中，foo()仍然作为普通函数来调用，只是JavaScript的语言特性
允许在call()/apply()时，传入一个对象实例来指定foo()的上下文环境中所
出现的this关键字的引用。——需要注意的是，此时的foo()仍旧是一个普通
函数调用，而不是对象方法调用。

与this“指示调用该方法的对象实例”有些类同的，with()语法也用于限定
“在一段代码片段中默认使用对象实例”。——如果不使用with()语法，那
么这段代码将受到更外层with()语句的影响；如果没有更外层的with()，那
么这段代码的“默认使用的对象实例”将是window。

然而需要注意的是this与with关键字不是互为影响的。如下面的代码：
//---------------------------------------------------------
// 测试: this与with关键字不是互为影响的
//---------------------------------------------------------
function test() {
  with (obj2) {
    this.value = 8;
  }
}
var obj2 = new Object();
obj2.value = 10;

test();
document.writeln('obj2.value: ', obj2.value, '<br>');
document.writeln('window.value: ', window.value, '<br>');

你不能指望这样的代码在调用结束后，会使obj2.value属性置值为8。这几行
代码的结果是：window对象多了一个value属性，并且值为8。

with(obj){...}这个语法，只能限定对obj的既有属性的读取，而不能主动的
声明它。一旦with()里的对象没有指定的属性，或者with()限定了一个不是对
象的数据，那么结果会产生一个异常。

 4). 使用in关键字的运算
 ------
 除了用for..in来反射对象的成员信息之外，JavaScript中也允许直接用in
关键字去检测对象是否有指定名字的属性。

 in关键字经常被提及的原因并不是它检测属性是否存在的能力，因此在早期
的代码中，很多可喜欢用“if (!obj.propName) {}” 这样的方式来检测propName
是否是有效的属性。——很多时候，检测有效性比检测“是否存有该属性”更
有实用性。因此这种情况下，in只是一个可选的、官方的方案。

 in关键字的重要应用是高速字符串检索。尤其是在只需要判定“字符串是否
存在”的情况下。例如10万个字符串，如果存储在数组中，那么检索效率将会
极差。
//---------------------------------------------------------
// 使用对象来检索
//---------------------------------------------------------
function arrayToObject(arr) {
  for (var obj=new Object(), i=0, imax=arr.length; i<imax; i++) {
    obj[arr[i]]=null;
  }
  return obj;
}

var
  arr = ['abc', 'def', 'ghi']; // more and more...
  obj = arrayToObject(arr);

function valueInArray(v) {
  for (var i=0, imax=arr.length; i<imax; i++) {
    if (arr[i]==v) return true;
  }

  return false;
}

function valueInObject(v) {
  return v in obj;
}

这种使用关键字in的方法，也存在一些限制。例如只能查找字符串，而数
组元素可以是任意值。另外，arrayToObject()也存在一些开销，这使得它
不适合于频繁变动的查找集。最后，(我想你可能已经注意到了)使用对象
来查找的时候并不能准确定位到查找数据，而数组中可以指向结果的下标。

1.经常总结完成模块中共性的代码，封装成方法或组件，方便以后调用。
   比如，数据访问，XML配置操作，分页控件，数据校验，加密等等我都总结成一个个独立的模块或组件，使用的时候拿来调用就行了，为项目争取了很多时间，也留出更多的时间来想业务逻辑的处理。

2.复杂业务简单化
   对一些复杂的业务系统，可以通过抽象的方式，来简单化，把复杂的问题抽象成简单的模型，变成人们容易理解的业务模型。能用简单的方式解决的问题我们为什么要搞的那么复杂。我们开发软件就是来解决问题的，不是来做秀的。

3.思路清晰，代码简洁，通读易懂。特别对团队开发很是重要。
   我不知道有些程序员怎么了，个人英雄主义很重，总是把代码写的稀奇古怪，这样好像来表示自己的不同凡响，技术水平高。其实，我认为作为现在的团队开发，这样会给企业带来很大的隐患。同时我个人觉得这也不是一个好的编码习惯，因为写代码也是人一种表达思想的方式，用最少的话和最精辟的词表达出人们容易理解的问题才是最厉害的。就像人穿衣服注意整洁一样，再高贵的衣服，如果不注意整洁，给人的感觉一样很糟糕的。

4.注意高内聚和低耦合。减少模块间的耦合度，抽离出通用的模块，每个模块就像一块积木。这样做一个系统时，如果能充分利用这些资源，会起到事半功倍的效果。省时省力。我总结的角色权限管理摸块就是这样，用到了很多项目，也确实为我节省了不少时间，也可以说为公司创造了不少效益。

5.做好架构设计。好的架构会给开发人员一个明确的导向，且不会让程序员作太多的无用功和重复劳动和返工。并且好的可扩展性设计会对项目善变的需求有好的应对能力。

6.采用OOP，分层开发等经典的开发模式，从一定程度上减少重复，增强扩展性。

7.尽量采用成熟可靠的技术。
    这句话我想有两种理解，
一：采用最合适的技术，而不是选择“最先进”的。不能因为“用技术”而“用技术”。它给项目带来的后果是不可估量的，风险也是很大的，以至甚至延期等等。当然学习好它还是很好的，但是在做商业应用方面还要考虑好。
二：去用那些已经存在的成熟的模式或代码，不要自己再去“造车”了。一来缩短开发周期，二来降低风险。所以，我们平常开发时，还是要有一定的“拿来主义”，这没什么不好的，相反，应该是一个明智的选择。

8.学会改变世界。
    写了很久的程序，养成一个习惯，就是坚持用尽量少的代码实现尽量多的事情，所以一般能共用的代码，我就写成共用的，这样基本上就减少了不少的代码量。另外，通过一定的抽象过程，本人已经总结出一定规律，并成功的开发出一个.Net(C#)代码自动生成器工具，基本上我尝试了一下，一个有二十几个表的系统，二十分钟内，我就完成了三层架构的构建，生成了80%的代码，这个过程如果纯手工的话，我觉得效率高的也要一两周吧。人类的进步是从使用工具开始的，我们要进步也比须制造工具来替代人工，改变世界，其实我们的生活可以很精彩。