国产亚洲精品福利在线无卡一,亚洲日本在线看片,91亚洲性爱在线视频

��h��中立 — Sat, 21 Jun 2014 15:33:00 GMT

在一个项目里面有�q�么一个技术需�?
1.集合中元素个�?10M
2.�Ҏ��上限和下限从一个Set中过滤出满��要求的元素集�?

实际�q�个是个很典型的技术要�? 之前的项目也遇见�q?但是因�ؓ当时的类库不�? 都是直接手写实现�? 方式基本�{�同于第一个方�?

在这个过�E�中, 我写了四个方�? 基本记录��C��?
�W�一个方�?对Set�q�行�q�代器遍�? 判断每个元素是否都在上限和下限范围中.如果满��则添加到�l�果集合�? 最后返回结果集�?
��试效果:集合大小100K, �q�算旉�� 3000ms+
�q��o部分的逻辑如下:

1     void filerSet(Set targetSet, String lower, String higher) {
2         BigDecimal bdLower = new BigDecimal(Double.parseDouble(lower));
3         BigDecimal bdHigher = new BigDecimal(Double.parseDouble(higher));
4
5         Set returnSet = new HashSet();
6         for (BigDecimal object : targetSet) {
7             if (isInRange(object, bdLower, bdHigher)) {
8                 returnSet.add(object);
9             }
10         }
11     }
12
13     private boolean isInRange(BigDecimal object, BigDecimal bdLower,
14             BigDecimal bdHigher) {
15         return object.compareTo(bdLower) >= 0
16                 && object.compareTo(bdHigher) <= 0;
17     }

�W�二个方�? 借助TreeSet, 原始集合�q�行排序, 然后直接subset.
��试效果: 集合大小10M, �q�算旉��: 12000ms+(获得TreeSet) , 200ms(获得�l�果)
�q��o部分的逻辑如下(非常�J�琐):

1     Set getSubSet(TreeSet targetSet, String lower,
  2             String higher) {
  3
  4         BigDecimal bdLower = new BigDecimal(Double.parseDouble(lower));
  5         BigDecimal bdHigher = new BigDecimal(Double.parseDouble(higher));
  6
  7         if ((bdHigher.compareTo(targetSet.first()) == -1)
  8                 || (bdLower.compareTo(targetSet.last()) == 1)) {
  9             return null;
10         }
11
12         boolean hasLower = targetSet.contains(bdLower);
13         boolean hasHigher = targetSet.contains(bdHigher);
14         if (hasLower) {
15             if (hasHigher) {
16                 System.out.println("get start:" + bdLower);
17                 System.out.println("get end:" + bdHigher);
18                 return targetSet.subSet(bdLower, true, bdHigher, true);
19             } else {
20                 BigDecimal newEnd = null;
21                 System.out.println("get start:" + bdLower);
22                 SortedSet returnSet = null;
23                 if (bdHigher.compareTo(targetSet.last()) != -1) {
24                     newEnd = targetSet.last();
25                 } else {
26                     SortedSet newTargetSet = targetSet
27                             .tailSet(bdLower);
28                     for (BigDecimal object : newTargetSet) {
29                         if (object.compareTo(bdHigher) == 1) {
30                             newEnd = object;
31                             break;
32                         } else if (object.compareTo(bdHigher) == 0) {
33                             newEnd = object;
34                             break;
35                         }
36                     }
37                 }
38                 returnSet = targetSet.subSet(bdLower, true, newEnd, true);
39                 if (newEnd.compareTo(bdHigher) == 1) {
40                     returnSet.remove(newEnd);
41                 }
42                 return returnSet;
43             }
44
45         } else {
46             if (hasHigher) {
47                 System.out.println("get end:" + bdHigher);
48                 TreeSet newTargetSet = (TreeSet) targetSet
49                         .headSet(bdHigher, true);
50                 BigDecimal newStart = null;
51                 SortedSet returnSet = null;
52
53                 if (bdLower.compareTo(targetSet.first()) == -1) {
54                     newStart = targetSet.first();
55                 } else {
56                     for (BigDecimal object : newTargetSet) {
57                         if (object.compareTo(bdLower) != -1) {
58                             newStart = object;
59                             break;
60                         }
61                     }
62                 }
63                 returnSet = targetSet.subSet(newStart, true, bdHigher, true);
64
65                 return returnSet;
66             } else {
67                 System.out.println("Not get start:" + bdLower);
68                 System.out.println("Not get end:" + bdHigher);
69                 BigDecimal newStart = null;
70                 BigDecimal newEnd = null;
71                 if (bdHigher.compareTo(targetSet.last()) != -1) {
72                     newEnd = targetSet.last();
73                 }
74                 if (bdLower.compareTo(targetSet.first()) == -1) {
75                     newStart = targetSet.first();
76                 }
77                 for (BigDecimal object : targetSet) {
78                     if (newStart == null) {
79                         if (object.compareTo(bdLower) != -1) {
80                             newStart = object;
81                             if (newEnd != null) {
82                                 break;
83                             }
84                         }
85                     }
86
87                     if (newEnd == null) {
88                         if (object.compareTo(bdHigher) != -1) {
89                             newEnd = object;
90                             if (newStart != null) {
91                                 break;
92                             }
93                         }
94                     }
95                 }
96
97                 if (newStart == null) {
98                     if (newEnd == null) {
99                         if ((bdHigher.compareTo(targetSet.first()) == -1)
100                                 || (bdLower.compareTo(targetSet.last()) == 1)) {
101                             return null;
102                         }
103                         return targetSet;
104                     } else {
105                         SortedSet newTargetSet = targetSet.headSet(
106                                 newEnd, true);
107                         if (newEnd.compareTo(bdHigher) == 1) {
108                             newTargetSet.remove(newEnd);
109                         }
110                         return newTargetSet;
111                     }
112                 } else {
113                     if (newEnd == null) {
114                         SortedSet newTargetSet = targetSet.tailSet(
115                                 newStart, true);
116                         return newTargetSet;
117                     } else {
118                         SortedSet newTargetSet = targetSet.subSet(
119                                 newStart, true, newEnd, true);
120                         if (newEnd.compareTo(bdHigher) == 1) {
121                             newTargetSet.remove(newEnd);
122                         }
123                         return newTargetSet;
124                     }
125                 }
126             }
127         }
128     }

�W�三�U�方�? 使用Apache Commons Collections, 直接对于原始Set�q�行filter.
��试效果:集合大小10M,�q��o�l�果1M, �q�算旉��: 1000ms+
�q��o部分的代码如�?

1 //�q��o的主体逻辑
2     void filterSet(Set targetSet, String lower, String higher) {
3         final BigDecimal bdLower = new BigDecimal(Double.parseDouble(lower));
4         final BigDecimal bdHigher = new BigDecimal(Double.parseDouble(higher));
5
6         Predicate predicate = new Predicate() {
7             public boolean evaluate(Object object) {
8                 BigDecimal bDObject = (BigDecimal) object;
9                 return bDObject.compareTo(bdLower) >= 0
10                         && bDObject.compareTo(bdHigher) <= 0;
11             }
12         };
13
14         CollectionUtils.filter(targetSet, predicate);
15     }

�W�四�U�方�?使用Guava(google Collections), 直接对于原始Set�q�行Filter
��试效果:集合大小10M,�q��o�l�果1M, �q�算旉��: 100ms-
�q��o部分的代码如�?

1 //guava filter
2
3     Set filterSet(Set targetSet, String lower,
4             String higher) {
5         final BigDecimal bdLower = new BigDecimal(Double.parseDouble(lower));
6         final BigDecimal bdHigher = new BigDecimal(Double.parseDouble(higher));
7
8         Set filterCollection = Sets.filter(targetSet,
9                 new Predicate() {
10                     @Override
11                     public boolean apply(BigDecimal input) {
12                         BigDecimal bDObject = (BigDecimal) input;
13                         return bDObject.compareTo(bdLower) >= 0
14                                 && bDObject.compareTo(bdHigher) <= 0;
15                     }
16                 });
17
18         return filterCollection;
19     }

四种方式�Ҏ��如下:
�W�一�U�方�? 仅依赖于JAVA原生�c�d�� 遍历旉��最�? 代码量很��?br />�W�二�U�方�? 仅依赖于JAVA原生�c�d�� 遍历旉��比较�?主要慢在生成有序Set), 代码量最�?br />�W�三�U�方�? 依赖于Apache Commons Collections, 遍历旉��比较�? 代码量很��?br />�W�四�U�方�? 依赖于Guava, 遍历旉��最�? 代码量很��?br />
��Z��目前个�h的技术水�q�_��视野, �W�四�U�方式可能是最佳选择.

记录一�? 以后可能�q�会有更好的�Ҏ��.

��h��中立 2014-06-21 23:33 发表评论

一个Sudoku的java求解��法

��h��中立 — Thu, 13 Jul 2006 08:19:00 GMT

�q�个��的project是前一个阶�D�，待业在家的时候，�q�h��sudoku的时候，自己写来玩的�?br />正好当时在看Uncle Bob的《Agile Software Development: Principles, Patterns, and Practices�?�Q�敏捯��Y件开发：原则、模式与实践�Q?所以就按照自己对书中的一些概念和�Ҏ��的理解，�l�合自己之前的开发经验写出来一�D�小的代码�?br />
代码行数�Q?< 900
�cȝ��个数�Q?18
抽象�cȝ��个数�Q?
工厂�cȝ��个数�Q?
包的个数�Q?

一些关于类和包作用的说明：
1.Cell:表示一个Cell�Q�是一个游戏中的一个单元格�?br /> Cell主要�?个部分组成，Point,Value,Status.
2.Point:表示一个坐标，主要格式�?(2,3).
�Q�！�Q�注意：�׃��个�h比较�?所以开始的错误被诏��M��下来�?br /> �q�个错误��是�Q?�Q?�Q�表�C�的是由最左上的位�|��ؓ坐标原点�Q�第二行和第三列所��定的那个单元格。也��是�U�坐标在前，横坐标在后了�?br />3.Value:表示一个�?br />4.Status:表示Cell的状态，只有两个状态，一个是NotSure,另一个是Sure.

5.AbstractCells�Q�表�C�Z��些cell的集合，主要有三个子�c?br />     BlockCells�Q�表�C�Z��个由多个Cell�l�成的块�Q�例如一�?*2�?个Cell�l�成的块�Q�或者一�?*3�?个Cell�l�成的块
     HorizonCells:表示一个横行，卻I��从（0�Q?�Q�到(0,n)坐标��定的所有Cell的集合�?br />     VerticalCells:表示一个纵行，卻I��从（0�Q?�Q�到(n,0)坐标��定的所有Cell的集合�?br />6.AbstractPolicy:��是游戏的策略�?br />   �q�个主要表示的是�Q?*4的游戏，�q�是9*9的游戏�?br />   可以在以后对此类�q�行�l�承和扩展，例如16*16的游戏我��没有实现�?br />   主要扩展3个方法：
                  1�Q�getValueRange�Q�返回当前policy的value的个数�?*4的游戏的getValueRange�q�回的就应该�?�?br />        2�Q�getStep�Q�表�C�当前policy中相�ȝ��两个BlockCells的坐标差�?br />        3�Q�getIncrease�Q�说不明白了�Q�）�Q�只可意会不可言传。）
7.Game�Q�进行Policy的场所�Q�我一直想抛弃�q�个�c�）
8.TestGame:游戏�q�行的地方，包括从PolicyFactory取得指定的Policy,讄��输入输出文�g的�\径�?br />9.PolicyFactory�Q�取得Policy的工厂�?br />    getPolicy(int x) :�q�个�Ҏ��获得的是正方形的sudoku的策略。例�?4*4的，9*9,16*16�?br />    getPolicy(int x, int y)�Q�这个方法获得的是长方�Ş的Sudoku的策略。例如：9*12的�?br />

虽然是尽量避免bad code smell�Q�但是由于能力有限，�q�是出现了一些不好的地方�?br />例如�Q�之间的兌��关系�q�是很多�Q�而且很强�Q�抽象的�Ҏ��和抽象类的个数偏��等�{��?br />
里面实现了三个解决sudoku的方法：
1.在一个Cell中出现的Value,不会在和�q�个Cell处在同一个AbstractCells中的所有Cell中出玎ͼ�
2.如果一个Cell中，所有可能出现的Value的个��Cؓ1�Q�那么Cell的Value必然是这个最后的Value�Q?br />2.如果一个Value,如果在当前AbstractCells的所有其他的Cell中都不可能出玎ͼ�那么它必然是最后一个Cell的Value�?br />
附�g1�Q�src code
http://www.tkk7.com/Files/GandofYan/sudoku.rar
附�g2�Q�输入输出文件的example
http://www.tkk7.com/Files/GandofYan/temp.rar

��h��中立 2006-07-13 16:19 发表评论

��h��中立 — Tue, 30 May 2006 05:31:00 GMT

�ȝ��一下最�q�关于domain object以及相关的讨�?/font>

在最�q�的围绕domain object的讨��Z��现出来了三�U�模型，(�q�有一些其他的旁枝�Q�不一一分析�?�Q�经�q�一番讨论，各种问题逐渐清晰��h��Q�在�q�里我试囑ց�一个�ȝ��Q�便于大家了解和掌握�?

�W�一�U�模型：只有getter/setter�Ҏ��的纯数据�c�，所有的业务逻辑完全由business object来完�?又称TransactionScript)�Q�这�U�模型下的domain object被Martin Fowler�U�C��为“��血的domain object”。下面用举一个具体的代码来说明，代码来自Hibernate的caveatemptor�Q�但�l�过我的改写�Q?

一个实体类叫做Item�Q�指的是一个拍卖项�?
一个DAO接口�c�d��做ItemDao
一个DAO接口实现�c�d��做ItemDaoHibernateImpl
一个业务逻辑�c�d��做ItemManager(或者叫做ItemService)

java代码:

														

														
																public
																class Item implementsSerializable{
    privateLong id = null; 
    privateint version; 
    
privateString name; 
    private User seller; 

    privateString description; 
    private MonetaryAmount 
initialPrice; 
    private MonetaryAmount 
reservePrice; 
    privateDate startDate; 
    privateDate endDate; 
    privateSet categorizedItems = newHashSet(); 

    privateCollection bids = newArrayList(); 

    private 
Bid successfulBid; 
    private ItemState state; 

    private 
User approvedBy; 
    privateDate approvalDatetime; 
    privateDate created = newDate(); 

    //  
getter/setter�Ҏ��省略不写�Q�避免篇�q�太�?/span>
}
												

java代码:

														

														
																public
																interface ItemDao {
    public Item 
getItemById(Long id); 
    publicCollection findAll(); 

    publicvoid 
updateItem(Item item); 
}
												

ItemDao定义持久化操作的接口�Q�用于隔��L��久化代码�?

java代码:

														

														
																public
																class 
ItemDaoHibernateImpl implements ItemDao extends 
HibernateDaoSupport {
    public Item 
getItemById(Long id){
        return(Item) getHibernateTemplate().load(Item.class, id); 
    }
    publicCollection findAll(){
        return(List) getHibernateTemplate().find("from 
Item"); 
    }
    publicvoid updateItem(Item item){
        getHibernateTemplate().update(item); 

    }
}
												

ItemDaoHibernateImpl完成具体的持久化工作�Q�请注意�Q�数据库资源的获取和释放是在ItemDaoHibernateImpl 里面处理的，每个DAO�Ҏ��调用之前打开Session�Q�DAO�Ҏ��调用之后�Q�关闭Session�?Session攑֜�ThreadLocal中，保证一�ơ调用只打开关闭一��?

java代码:

														

														
																public
																class ItemManager {
    private ItemDao itemDao; 

    publicvoid 
setItemDao(ItemDao itemDao){ 
this.itemDao = itemDao;}
    public Bid 
loadItemById(Long id){
        itemDao.loadItemById(id); 

    }
    publicCollection listAllItems(){
        return  itemDao.findAll(); 

    }
    public Bid placeBid(Item item, User bidder, MonetaryAmount 
bidAmount, 
                            Bid currentMaxBid, Bid 
currentMinBid)throws BusinessException 
{
            if(currentMaxBid != null && 
currentMaxBid.getAmount().compareTo(bidAmount) > 0){
            throw new 
BusinessException("Bid too low."); 
    }
    
    // Auction is active
    if( !state.equals(ItemState.ACTIVE))
            throw new 
BusinessException("Auction is not active yet."); 
    
    // Auction still valid
    if( item.getEndDate().before(newDate()))
            throw new 
BusinessException("Can't place new bid, auction already 
ended."); 
    
    // Create new Bid
    Bid newBid = 
new Bid(bidAmount, item, bidder); 
    
    // Place bid for this Item
    
item.getBids().add(newBid); 
    itemDao.update(item);  
   //  调用DAO完成持久化操�?/span>
    return newBid; 
    
}
}
												

事务的管理是在ItemManger�q�一层完成的�Q�ItemManager实现具体的业务逻辑。除了常见的和CRUD有关的简单逻辑之外�Q�这里还有一个placeBid的逻辑�Q�即��目的竞标�?

以上是一个完整的�W�一�U�模型的�C�Z��代码。在�q�个�C�Z��中，placeBid�Q�loadItemById�Q�findAll�{�等业务逻辑�l�统攑֜�ItemManager中实玎ͼ�而Item只有getter/setter�Ҏ��?/span>

�W�二�U�模型，也就是Martin Fowler指的rich domain object是下面这样子的：

一个带有业务逻辑的实体类�Q�即domain object是Item
一个DAO接口ItemDao
一个DAO实现ItemDaoHibernateImpl
一个业务逻辑对象ItemManager

java代码:

												

												
														public
														class Item implementsSerializable{
    //  所有的属性和getter/setter�Ҏ��同上�Q�省�?/span>
    
public Bid 
placeBid(User bidder, MonetaryAmount 
bidAmount, 
                        Bid currentMaxBid, Bid currentMinBid)
            throws BusinessException 
{
    
            // Check highest bid (can also be a different 
Strategy (pattern))
            if(currentMaxBid != null && 
currentMaxBid.getAmount().compareTo(bidAmount) > 0){
                    throw new 
BusinessException("Bid too low."); 
            }
    
            // Auction is active
            
if( !state.equals(ItemState.ACTIVE))
                    throw new 
BusinessException("Auction is not active yet."); 
    
            // Auction still valid
            
if( this.getEndDate().before(newDate()))
                    throw new 
BusinessException("Can't place new bid, auction already 
ended."); 
    
            
// Create new Bid
            
Bid newBid = new 
Bid(bidAmount, this, bidder); 
    
            // Place bid for this Item
          
  this.getBids.add(newBid);  // 
��h��意这一句，透明的进行了持久化，但是不能在这里调用ItemDao�Q�Item不能对ItemDao产生依赖�Q?/span>
    
        
    return newBid; 

    }
}
										

竞标�q�个业务逻辑被放入到Item中来。请注意this.getBids.add(newBid); 如果没有Hibernate或者JDO�q�种O/R Mapping的支持，我们是无法实现这�U�透明的持久化行�ؓ的。但是请注意�Q�Item里面不能去调用ItemDAO�Q�对ItemDAO产生依赖�Q?

ItemDao和ItemDaoHibernateImpl的代码同上，省略�?

java代码:

												

												
														public
														class ItemManager {
    private ItemDao itemDao; 

    publicvoid 
setItemDao(ItemDao itemDao){ 
this.itemDao = itemDao;}
    public Bid 
loadItemById(Long id){
        itemDao.loadItemById(id); 

    }
    publicCollection listAllItems(){
        return  itemDao.findAll(); 

    }
    public Bid placeBid(Item item, User bidder, MonetaryAmount 
bidAmount, 
                            Bid currentMaxBid, Bid 
currentMinBid)throws BusinessException 
{
        item.placeBid(bidder, bidAmount, currentMaxBid, 
currentMinBid); 
        itemDao.update(item);  
  // 必须昑ּ�的调用DAO�Q�保持持久化
    }
}
										

在第二种模型中，placeBid业务逻辑是放在Item中实现的�Q�而loadItemById和findAll业务逻辑是放�? ItemManager中实现的。不�q�值得注意的是�Q�即使placeBid业务逻辑攑֜�Item中，你仍焉��要在ItemManager中简单的��装一层，以保证对placeBid业务逻辑�q�行事务的管理和持久化的触发�?

�q�种模型是Martin Fowler所指的真正的domain model。在�q�种模型中，有三个业务逻辑�Ҏ��Q�placeBid�Q�loadItemById和findAll�Q�现在的问题是哪个逻辑应该攑֜�Item 中，哪个逻辑应该攑֜�ItemManager中。在我们�q�个例子中，placeBid攑֜�Item�?但是ItemManager也需要对它进行简单的��装)�Q�loadItemById和findAll是放在ItemManager中的�?

切分的原则是什么呢�Q?Rod Johnson提出原则是“case by case”，可重用度高的�Q�和domain object状态密切关联的攑֜�Item中，可重用度低的�Q�和domain object状态没有密切关联的攑֜�ItemManager中�?

我提出的原则是：看业务方法是否显式的依赖持久化�?/span>

Item的placeBid�q�个业务逻辑�Ҏ��没有昑ּ�的对持久化ItemDao接口产生依赖�Q�所以要攑֜�Item中�?span style="color: red;">��h��意，如果��q��了Hibernate�q�个持久化框�Ӟ��Item�q�个domain object是可以进行单元测试的�Q�他不依赖于Hibernate的持久化机制。它是一个独立的�Q�可�U�L��的，完整的，自包含的域对�?/span>�?

而loadItemById和findAll�q�两个业务逻辑�Ҏ��是必��L��式的�Ҏ��久化ItemDao接口产生依赖�Q�否则这个业务逻辑��无法完成。如果你要把�q�两个方法放在Item中，那么Item��无法脱��Hibernate框架�Q�无法在Hibernate框架之外独立存在�?/span>

�W�三�U�模型印象中好像是firebody或者是Archie提出�?也有可能不是�Q�记不清楚了)�Q�简单的来说�Q�这�U�模型就是把�W�二�U�模型的domain object和business object合二��Z��了。所以ItemManager��׃��需要了�Q�在�q�种模型下面�Q�只有三个类�Q�他们分别是�Q?

Item�Q�包含了实体�c�M��息，也包含了所有的业务逻辑
ItemDao�Q�持久化DAO接口�c?
ItemDaoHibernateImpl�Q�DAO接口的实现类

�׃��ItemDao和ItemDaoHibernateImpl和上面完全相同，��q��略了�?

java代码:

												

												
														public
														class Item implementsSerializable{
    //  所有的属性和getter/setter�Ҏ��都省�?/span>
   privatestatic ItemDao itemDao; 

    publicvoid 
setItemDao(ItemDao itemDao){this.itemDao = itemDao;}
    
    publicstatic Item 
loadItemById(Long id){
        return(Item) itemDao.loadItemById(id); 

    }
    publicstaticCollection findAll(){
        return(List) itemDao.findAll(); 

    }

    public Bid placeBid(User bidder, MonetaryAmount bidAmount, 
    
                Bid currentMaxBid, Bid currentMinBid)
    throws BusinessException 
{
    
        // Check highest bid (can also be a different 
Strategy (pattern))
        if(currentMaxBid != null && 
currentMaxBid.getAmount().compareTo(bidAmount) > 0){
                throw new 
BusinessException("Bid too low."); 
        }
        
        // Auction is active
        if( !state.equals(ItemState.ACTIVE))
                throw new 
BusinessException("Auction is not active yet."); 
        
        // Auction still valid
        if( this.getEndDate().before(newDate()))
                throw new 
BusinessException("Can't place new bid, auction already 
ended."); 
        
        
// Create new Bid
        Bid 
newBid = new 
Bid(bidAmount, this, bidder); 
        
        // Place bid for this Item
        
this.addBid(newBid); 
        itemDao.update(this);  
    //  调用DAO�q�行昑ּ�持久�?/span>
        
return newBid; 

    }
}
										

在这�U�模型中�Q�所有的业务逻辑全部都在Item中，事务��理也在Item中实现�?/span>

在上面三�U�模型之外，�q�有很多�q�三�U�模型的变种�Q�例如partech的模型就是把�W�二�U�模型中的DAO�? Manager三个�c�d��q��ؓ一个类后�Ş成的模型�Q�例如frain....(id很长��C��?的模型就是把�W�三�U�模型的三个�c�d��全合�q��ؓ一个单�c�d��形成的模型；例如Archie是把�W�三�U�模型的Item又分出来一些纯数据�c?可能是，不确�?形成的一个模型�?

但是不管怎么变，基本模型归纳��h��是上面的三�U�模型，下面分别��单评价一下：

�W�一�U�模型绝大多��C�h都反对，因此反对理由我也不多讲了。但遗憾的是�Q�我观察到的实际情�Ş是，很多使用Hibernate的公司最后都是这�U�模型，�q�里面有很大的原因是很多公司的技术水�q�x��有达到这�U�层�ơ，所以导致了�q�种贫血模型的出现。从�q�一�Ҏ��_��Martin Fowler的批评声音不是太响了�Q�而是太弱了，�q�需要再�l�箋呐喊�?

�W�二�U�模型就是Martin Fowler一直主张的模型�Q�实际上也是我一直在实际��目中采用这�U�模型。我没有看过Martin的POEAA�Q�之所以能够自己摸索到�q�种模型�Q�也是因��Z��02�q�我已经开始思考这个问题�ƈ且寻求解��x��案了�Q�但是当时没有看到Hibernate�Q�那时候做的一个小型项目我已经按照�q�种模型来做了，但是�׃��没有O/R Mapping的支持，写到后来又不得不全部�Ҏ��贫血的domain object�Q�项目做完以后再�l�箋找，随后��发��C��Hibernate。当�Ӟ��现在很多��Z��开始就是用Hibernate做项目，没有�l�历�q�我�l�历的那个阶�D�c�?

不过我觉得这�U�模型仍然不够完��，因�ؓ你还是需要一个业务逻辑层来��装所有的domain logic�Q�这昑־�非常�|�嗦�Q��ƈ且业务逻辑对象的接口也不够�E�_��。如果不考虑业务逻辑对象的重用性的�?业务逻辑对象的可重用性也不可能好)�Q�很多�h�q�脆��去掉了xxxManager�q�一层，在Web层的Action代码直接调用xxxDao�Q�同时容器事务管理配�|�到Action�q�一层上来�? Hibernate的caveatemptor��是�q�样架构的一个典型应用�?

�W�三�U�模型是我很反对的一�U�模型，�q�种模型下面�Q�Domain Object和DAO形成了双向依赖关�p�，无法��q��框架��试�Q��ƈ且业务逻辑层的服务也和持久层对象的状态耦合��C��一��P��会造成�E�序的高度的复杂性，很差的灵�z�L��和�p�糕的可�l�护性。也许将来技术进步导致的O/R Mapping��理下的domain object发展到��够的动态持久透明化的话，�q�种模型才会成�ؓ一个理想的选择。就像O/R Mapping的流行��得第二种模型成�ؓ了可�?O/R Mapping��行以前�Q�我们只能用�W�一�U�模型，�W�二�U�模型那时候是不现实的)�?/span>

既然大家都统一了观点，那么��有了一个很好的讨论问题的基��了。Martin Fowler的Domain Model�Q�或者说我们的第二种模型��N��是完��无�~�的吗？当然不是�Q�接下来我就要分析一下它的不��I��以及可能的解军_��法，而这些都来源于我个�h的实跉|��索�?

在第二种模型中，我们可以清楚的把�q?个类分�ؓ三层�Q?

1、实体类层，即Item�Q�带有domain logic的domain object
2、DAO层，即ItemDao和ItemDaoHibernateImpl�Q�抽象持久化操作的接口和实现�c?
3、业务逻辑层，即ItemManager�Q�接受容器事务控�Ӟ��向Web层提供统一的服务调�?

在这三层中我们大家可以看刎ͼ�domain object和DAO都是非常�E�_��的层�Q�其实原因也很简单，因�ؓdomain object是映��数据库字段的，数据库字�D�不会频�J�变动，所以domain object也相对稳定，而面向数据库持久化编�E�的DAO层也不过��是CRUD而已�Q�不会有更多的花��P��所以也很稳定�?

问题��在于这个充当business workflow facade的业务逻辑对象�Q�它的变动是相当频繁的�?span style="color: red;">业务逻辑对象通常都是无状态的、受事务控制的、Singleton�c?/span>�Q�我们可以考察一下业务逻辑对象都有哪几�c�M��务逻辑�Ҏ��Q?

�W�一�c�：DAO接口�Ҏ��的代�?/span>�Q�就是上面例子中的loadItemById�Ҏ��和findAll�Ҏ��?

ItemManager之所以要代理�q�种�c�，目的有两个：向Web层提供统一的服务调用入口点和给持久化方法增加事务控制功�?/span>。这两点都很�Ҏ��理解�Q�你不能既给Web层程序员提供xxxManager�Q�也�l�他提供xxxDao�Q�所以你需要用xxxManager��装xxxDao�Q�在�q�里�Q�充当了一个简单代理功能；而事务控制也是持久化�Ҏ��必须的，事务可能需要跨��多个DAO�Ҏ��调用�Q�所以必��L��在业务逻辑层，而不能放在DAO层�?

但是必须看到�Q�对于一个典型的web应用来说�Q�绝大多数的业务逻辑都是��单的CRUD逻辑�Q�所以这�U�情况下�Q�针�Ҏ��个DAO�Ҏ��Q�xxxManager都需要提供一个对应的��装�Ҏ��Q�这不但是非常枯燥的�Q�也是��o人感觉非�怸�好的�?

�W�二�c�：domain logic的方法代�?/span>。就是上面例子中placeBid�Ҏ��。虽然Item已经有了placeBid�Ҏ��Q�但是ItemManager仍然需要封装一下Item的placeBid�Q�然后再提供一个简单封装之后的代理�Ҏ��?

�q�和�W�一�U�情�늱��|��其原因也一��P��也是��Z��l�Web层提供一个统一的服务调用入口点和给隐式的持久化动作提供事务控制�?

同样�Q�和�W�一�U�情况一��P��针对每个domain logic�Ҏ��Q�xxxManager都需要提供一个对应的��装�Ҏ��Q�同��h��枯燥的，令�h不爽的�?

�W�三�c�：需要多个domain object和DAO参与协作的business workflow。这�U�情冉|��业务逻辑对象真正应该完成的职责�?

在这个简单的例子中，没有涉及到这�U�情况，不过大家都可以想像的出来�q�种应用场景�Q�因此不必�D例说明了�?

通过上面的分析可以看出，只有�W�三�c�M��务逻辑�Ҏ��才是业务逻辑对象真正应该承担的职责，而前两类业务逻辑�Ҏ��都是“无奈之�䏀�，不得不�ؓ之的事情�Q�不但枯燥，而且令�h沮��?

分析完了业务逻辑对象�Q�我们再回头看一下domain object�Q�我们要仔细考察一下domain logic的话�Q�会发现domain logic也分��Z��c�：

�W�一�c�：需要持久层框架隐式的实现透明持久化的domain logic�Q�例如Item的placeBid�Ҏ��中的�q�一句：

java代码:

												
this.getBids().add(newBid);

上面已经着重提刎ͼ�虽然�q�仅仅只是一个Java集合的添加新元素的操作，但是实际上通过事务的控�Ӟ��会潜在的触发两条SQL�Q�一条是insert一条记录到bid表，一条是更新item表相应的记录。如果我们让Item��q��Hibernate�q�行单元��试�Q�它��是一个单�U�的Java集合操作�Q�如果我们把他加入到Hibernate框架中，他就会潜在的触发两条SQL�Q?span style="color: red;">�q�就是隐式的依赖于持久化的domain logic�?
特别��h��意的一�Ҏ��Q�在没有Hibernate/JDO�q�类可以实现“透明的持久化”工具出��C��前，�q�类domain logic是无法实现的�?

对于�q�一�c�domain logic�Q�业务逻辑对象必须提供相应的封装方法，以实��C��务控制�?

�W�二�c�：完全不依赖持久化的domain logic�Q�例如readonly例子中的Topic�Q�如下：

java代码:

												

												
														class Topic {
    boolean 
isAllowReply(){
        Calendar dueDate = 
Calendar.getInstance(); 

        dueDate.setTime(lastUpdatedTime); 
        dueDate.add(Calendar.DATE, forum.timeToLive); 
    
        Date now = newDate(); 

        return 
now.after(dueDate.getTime()); 
    }
}
										

注意�q�个isAllowReply�Ҏ��Q�他和持久化完全不发生一丁点关系。在实际的开发中�Q�我们同样会遇到很多�q�种不需要持久化的业务逻辑(主要发生在日期运��、数��D��和枚�D�q�算斚w��)�Q�这�U�domain logic不管��q��不脱��L��在的框架�Q�它的行为都是一致的。对于这�U�domain logic�Q�业务逻辑层�ƈ不需要提供封装方法，它可以适用于�Q何场合�?/span>

��h��中立 2006-05-30 13:31 发表评论

[转]O/R Mapping 基本概念

��h��中立 — Tue, 30 May 2006 05:20:00 GMT

原文地址�Q?a >http://www.cnblogs.com/idior/archive/2005/07/04/186086.html

�q�日有关o/r m的讨论突然多了�v�? 在这里觉得有必要澄清一些概�? 免的大家讨论来讨论去, 才发现最�Ҏ��的理解有问题.

1. 何谓实体?
实体(�c�M��于j2ee中的Entity Bean)通常指一个承载数据的对象, 但是注意它也是可以有行�ؓ�? 只不�q�它的行��Z��般只操作自��n的数�? 比如下面�q�个例子:

class Person
{
  string firstName;
  string lastName;

  public void GetName()
  {
     return  lastName+firstName;
  }
}

GetName��是它的一个行�?

2 何谓对象?
对象最重要的特性在于它拥有行�ؓ. 仅仅拥有数据,你可以称它�ؓ对象, 但是它却失去它最重要的灵��?

class Person
{
  string firstName;
  string lastName;
  Role role;
  int baseWage;
  public void GetSalary()
  {
     return baseWage*role.GetFactory();
  }
}

�q�样需要和别的对象(不是Value Object)打交道的对象,我就不再�U�其为实�? 领域模型��是指由�q�些��h��业务逻辑的对象构成的模型.

3. E/R M or O/R M?!!
仔细��x��我们��Z��么需要o/r m,无非是想利用oo的多态来处理复杂的业务逻辑, 而不是靠一堆的if else.
而现在在很多人的手上o/r m全变成了e/r m.他们不考虑对象的行�? 而全��x��于如何保存数�?�q�样也难怪他们会产生��CRUD�q�些操作攑օ�对象中的念头. 如果你不能深�ȝ��解oo, 那么我不推荐你��用o/r m, Table Gateway, Row Gateway才是你想要的东西.

作�ؓ一个O/R M框架�Q�很重要的一点就是实现映��的透明性（Transparent�Q�，比较显著的特点就是在代码中我们是看不到SQL语句的（框架自动生成了）。这里所指的O/R M��是�c�M��于此的框�Ӟ��

4. POEAA中的相关概念
  很多�ơ发现有人错用其中的概念, �q�里��Z��ȝ��一�?
  1. Table Gateway
    以表为单位的实体,基本没有行�ؓ,只有CRUD操作.
  2. Row Gateway
    以行为单位的实体,基本没有行�ؓ,只有CRUD操作.
  3. Active Record
    以行为单位的实体,拥有一些基本的操作自��n数据的行�?如上例中的GetName),同时包含有CRUD操作.
其实Active Record最�W�合某些��单的需�? 接近于E/R m.
通常也有很多人把它当作O/R m.不过需要注意的是Active Record中是充满了SQL语句�?不像orm的SQL透明), 所以有人想��h��利用O/R m来实�?Active Record", 虽然在他们眼里看��h��很方�? 其实�Ҏ��是�q�祖.
用CodeGenerator来实现Active Record也许是一个比较好的方�?
  4. Data Mapper
�q�才是真正的O/R m,Hibernate�{�等工具的目�?

5.O/R M需要关注的地方 (希望大家帮忙完善一�?
1. 兌��, O/R M是如何管理类之间的关�?当然�q�不仅于o/r m有关与设计者的设计水��^也有很大关系.
2. O/R M对��承关�pȝ��处理.
3. O/R M对事务的支持.
4. O/R M�Ҏ��询的支持.

以上观点仅属个�h意见, 不过在大家讨论有关O/R m之前, 希望先就一些基本概念达成共�? 不然讨论下去会越��越�q?

(��: 如果对oo以及dp没有一定程度的了解, 最好别使用o/r m, dataset 加上codesmith或许是更好的选择)

��h��中立 2006-05-30 13:20 发表评论

面向对象设计的基本原�?�?

��h��中立 — Sun, 09 Apr 2006 06:06:00 GMT

最�q�在�?lt; 敏捷软�g开发：原则、模式与实践 >在网上找了一些资�?��把他们集合��C��一�?便于自己学习

此篇内容来自一下两�?br />
http://blog.joycode.com/microhelper/archive/2004/11/30/40013.aspx

http://www.tkk7.com/ghawk/

�?关于面向对象设计的原则比较权威的是Uncle Bob-- Robert C. Martin�?br />

Principles Of Object Oriented Design

http://c2.com/cgi/wiki?PrinciplesOfObjectOrientedDesign

单一职责原则——SRP
��׃��个类而言�Q�应该仅有一个引起它的变化的原因

原则

最��单，最单纯的事情最�Ҏ��控制�Q�最有效
�cȝ��职责��单而且集中�Q�避免相同的职责分散��C��同的�c�M��中，避免一个类承担�q�多的职�?br />减少�c�M��间的耦合
当需求变化时�Q�只修改一个地�?/font>

�l��g

每个�l��g集中做好一件事�?br />�l��g的颗�_�度
发布的成�?br />可重用的成本

�Ҏ��

避免写臃肿的�Ҏ��
Extract Method

重构

Move Field/Move Class
Extract Method/Extract Class

最��单的�Q�也是最难以掌握的原�?/font>

实例分析

单一职责很容易理解，也很�Ҏ��实现。所谓单一职责�Q�就是一个设计元素只做一件事。什么是“只做一件事”？��单说��是��管闲事。现实中��是如此�Q�如果要你专心做一件事情，��M��人都有信心可以做得很��。但如果�Q�你整天被�ؕ七八�p�的事所累，�q�有心思和�_�֊�把每件事都作好么�Q?br />
“单一职责”就是要在设计中为每�U�职责设计一个类�Q�彼此保持正交，互不�q�涉。这个雕塑（二重奏）��是正交的一个例子，钢琴家和��提琴家各自演奏自己的乐谱，而结果就是一个和谐的交响乐。当�Ӟ��真实世界中，演奏��提琴和弚w��琴的必须是两个�h�Q�但是在软�g中，我们往往会把两者甚��x��多搅和到一��P��很多时候只是�ؓ了方便或是最初设计的时候没有想到。�?br />
�q�样的例子在设计中很常见�Q�书中就�l�了一个很好的例子�Q�调制解调器。这是一个调�? 解调器最基本的功能。但是这个类事实上完成了两个职责�Q�连接的建立和中断、数据的发送和接收。显�Ӟ��q�违反了SRP。这样做会有潜在的问题：当仅需要改�? 数据�q�接方式�Ӟ��必须修改Modem�c�，而修改Modem�cȝ��l�果��是使得��M��依赖Modem�cȝ��元素都需要重新编译，不管它是不是用到了数据连接功能�? 解决的办法，书中也已�l�给出：重构Modem�c�，从中抽出两个接口�Q�一个专门负责连接、另一个专门负责数据发送。依赖Modem�cȝ��元素也要做相应的�l? 化，�Ҏ��职责的不同分别依赖不同的接口。最后由ModemImplementation�c�d��现这两个接口�?br /> 从这个例子中�Q�我们不隑֏�玎ͼ��q�反SRP通常是由于过于“真实”地设计了一个类所造成的。因此，解决办法是往更高一层进行抽�? 化提取，��对某个具体�cȝ��依赖改变为对一�l�接口或抽象�cȝ��依赖。当�Ӟ��q�个抽象化的提取应该�Ҏ��需要设计，而不是盲目提取。比如刚才这个Modem的例�? 中，如果有必要，�q�可以把DataChannel抽象为DataSender和DataReceiver两个接口�?br />

开攑ְ�闭原�?/span>——OCP
软�g实体�Q�类�Q�模块，函数�Q�应该是可以扩展的，但是不可修改�?/font>

原则

�Ҏ��展是开攄��Q�当需求改变时我们可以�Ҏ��块进行扩展，使其��h��新的功能
�Ҏ��Ҏ��闭的，�Ҏ��块扩展时�Q�不需要改动原来的代码
面对抽象而不是面对细节，抽象比细节活的更�?br />僵化的设计——如果程序中一处改动��生连锁反应�?/font>

�Ҏ��

条�gcase if/else 语句

重构

Replace Type Code With Class
Replace Type Code With State/Strategy
Replace Conditional with polymorphism

实例

开闭原则很��单，一句话�Q�“Closed for Modification; Open for Extension”——“对变更关闭�Q�对扩展开�䏀�。开闭原则其实没什么好讲的�Q�我��其归结��Z��个高层次的设计��d��。就�q�一�Ҏ��Ԍ��OCP的地位应该比SRP优先�?

OCP的动机很��单：软�g是变化的。不论是优质的设计还是低劣的设计都无法回避这一问题。OCP说明了��Y件设计应该尽可能��C��架构�E�_��而又�Ҏ��满��不同的需求�?

��Z��么要OCP�Q�答案也很简单——重用�?

“重用”，�q�不是什么��Y件工�E�的专业词汇�Q�它是工�E�界所��q��的词汇。早在��Y件出现前�Q�工�E�师们就在实践“重用”了。比如机��C�品，通过雉�� 件的�l�装得到最�l�的能够使用的工兗��由于机械部件的设计和制造过�E�是极其复杂的，所以互换性是一个重要的�Ҏ��。一辆�R可以用不同的发动机、不同的变速箱�? 不同的轮胎……很多东西我们直接买来装上就可以了。这也是一个OCP的例子。（可能是由于我是搞机械��n的吧�Q�所以就举些机械斚w��的例子^_^�Q��?

如何在OO中引入OCP原则�Q�把对实体的依赖改�ؓ�Ҏ��象的依赖��p��了。下面的例子说明了这个过�E�：

05赛季的时候，一辆F1赛�R有一台V10引擎。但是到�?6赛季�Q�国际汽联修改了规则�Q�一辆F1赛�R只能安装一台V8引擎。�R队很快投入了新赛�? 的研发，不幸的是�Q�从工程师那里得到消息，旧�R�w�的设计不能够装�q�新研发的引擎。我们不得不为新的引擎重新打造�R�w�，于是一辆新的赛车诞生了。但是，�ȝ�� 的事接踵而来�Q�国际汽联频频修改规则，搞得设计师在“赛车”上改了又改�Q�最�l�变得不成样子，只能把它废弃�?

��Z��能够重用�q�辆昂贵的赛车，工程师们提出了解��x��案：首先�Q�在车��n的设计上预留出安装引擎的位置和管�Uѝ��然后，�Ҏ��q�些设计好的规范设计引擎�Q�或是引擎的适配器）。于是，新的赛�R设计�Ҏ��p��栯��生了�?

昄��Q�通过重构�Q�这里应用的是一个典型的Bridge模式。这个实现的关键之处在于我们预先�l�引擎留��Z��位置�Q�我们不必因为对引擎的规则的频频变更而制造相当多的�R�w�，而是��可能地沿用和改良现有的车��n�?br />说到�q�里�Q�想说一说OO设计的一个误区�?br />�? 习OO语言的时候，��Z��能够说明“��扎쀝（或者说“is-a”）�q�个概念�Q�教�U�书上经常用实际生活中的例子来解释。比如汽车是车，电�R是�R�Q�F1赛�R是汽车，所以�R是汽车、电车、F1赛�R的上层抽象。这个例子�ƈ没有错。问题是�Q�这��L��例子�q�于“�Ş象”了�Q�如果OO设计直接��可以将现实生活中的概念引用�q? 来，那也��׃��需要什么��Y件工�E�师了！OO设计的关键概忉|��抽象。如果没有抽象，那所有的软�g工程师的努力都是徒劳的。因为如果没有抽象，我们只能��L��造世界中每一个对象。上面这个例子中�Q�我们应该看到“引擎”这个抽象的存在�Q�因��R队的工程师们为它预留了位�|�，为它制定了设计规范�?br />上面�q�个设计�? 实现了后面要说的DIP�Q�依赖倒置原则�Q�。但是请��C��Q�OCP是OO设计原则中高层次的原则，其余的原则对OCP提供了不同程度的支持。�ؓ了实现OCP�Q? 我们会自觉或者不自觉地用到其它原则或是诸如Bridge、Decorator�{�设计模式。然而，对于一个应用系�l�而言�Q�实现OCP�q�不是设计目的，我们所希望的只是一个稳定的架构。所以对OCP的追求也应该适可而止�Q�不要陷入过渡设计。正如Martin本�h所��_��“No significant program can be 100% closed.”“Closure not complete but strategic�?span style="font-size: 32pt; font-family: 宋体;">

Liskov替换原则—�?/span> LSP

子类型必��能够替换它的基�c�d��

原则

主要针对�l�承的设计原�?br />所有派生类的行为功能必��d��客户�E�序对其基类所期望的保持一致�?br />�z��c�d��L��_��c�d��客户�E�序的约�?br />IS-A是关于行为方式的�Q�依赖客��L��序的调用方式

重构

Extract Supper Class

实例

长方形和正方�?br />

OCP作�ؓOO的高层原则，��d��使用“抽�?Abstraction)”和“多�?Polymorphism)”将设计中的静态结构改为动态结构，�l�持设计的封闭性�?

“抽象”是语言提供的功能。“多态”由�l�承语义实现�?

如此�Q�问题��生了�Q�“我们如何去度量�l�承关系的质量？�?

Liskov�?987�q�提��Z��一个关于��承的原则“Inheritance should ensure that any property proved about supertype objects also holds for subtype objects.”——“��承必��ȝ��保超�c�L��拥有的性质在子�c�M��仍然成立。”也��是��_��当一个子�cȝ��实例应该能够替换��M��其超�cȝ��实例�Ӟ��它们之间才具�? is-A关系�?

该原则称为Liskov Substitution Principle——里氏替换原则。林先生在上课时风趣地称之�ؓ“老鼠的儿子会打洞”。^_^

我们来研�I�一下LSP的实质。学习OO的时候，我们知道�Q�一个对象是一�l�状态和一�p�d��行�ؓ的组合体。状态是对象的内在特性，行�ؓ是对象的外在�Ҏ��。LSP所表述的就是在同一个��承体�p�M��的对象应该有共同的行为特征�?

�q�一点上�Q�表明了OO的��承与日常生活中的�l�承的本质区别。�D一个例子：生物学的分类体系中把企鹅归属为鸟�c�R��我们模仿这个体�p�，设计��L��c�d��关系�?

�c�Z��鸟”中有个�Ҏ��fly�Q�企鹅自然也�l�承了这个方法，可是企鹅不能飞阿�Q�于是，我们在企鹅的�c�M��覆盖了fly�Ҏ��Q�告诉方法的调用者：�? 鹅是不会飞的。这完全�W�合常理。但是，�q�违反了LSP�Q�企鹅是鸟的子类�Q�可是企鹅却不能飞！需要注意的是，此处的“鸟”已�l�不再是生物学中的鸟了，它是�? 件中的一个类、一个抽象�?

有�h会说�Q�企鹅不能飞很正常啊�Q�而且�q�样�~�写代码也能正常�~�译�Q�只要在使用�q�个�cȝ��客户代码中加一句判断就行了。但是，�q�就是问题所在！首先�Q�客户代码和“企鹅”的代码很有可能不是同时设计的，在当今��Y件外包一层又一层的开发模式下�Q�你甚至�Ҏ��不知道两个模块的原��地是哪里�Q�也��p��? 上去修改客户代码了。客��L��序很可能是遗留系�l�的一部分�Q�很可能已经不再�l�护�Q�如果因��计出�q�么一个“企鹅”而导致必��M��改客户代码，谁应该承担这部分责�Q呢？�Q�大概是上帝吧，谁叫他让“企鹅”不能飞的。^_^�Q�“修改客户代码”直接违反了OCP�Q�这��是OCP的重要性。违反LSP��既有的设计不能封闭！

修正后的设计如下�Q?

但是�Q�这��是LSP的全部了么？书中�l�了一个经典的例子�Q�这又是一个不�W�合常理的例子：正方形不是一个长方�Ş。这个悖论的详细内容能在�|�上扑ֈ��Q�我��׃��多废话了�?

LSP�q�没有提供解册��个问题的�Ҏ��Q�而只是提��Z��q�么一个问题�?

于是�Q�工�E�师们开始关注如何确保对象的行�ؓ�?988�q�_��B. Meyer提出了Design by Contract�Q�契�U�式设计�Q�理论。DbC从�Ş式化�Ҏ��中借鉴了一套确保对象行为和自��n状态的�Ҏ��Q�其基本概念很简单：

每个�Ҏ��调用之前�Q�该�Ҏ��应该校验传入参数的正��性，只有正确才能执行该方法，否则认�ؓ调用方违反契�U�，不予执行。这�U�Cؓ前置条�g(Pre-condition)�?
一旦通过前置条�g的校验，�Ҏ��必须执行�Q��ƈ且必��ȝ��保执行结果符合契�U�，�q�称之�ؓ后置条�g(Post-condition)�?
对象本��n有一套对自��n状态进行校验的��查条�Ӟ��以确保该对象的本质不发生改变�Q�这�U�C��Z��变式(Invariant)�?/li>

以上是单个对象的�U�束条�g。�ؓ了满��LSP�Q�当存在�l�承关系�Ӟ��子类中方法的前置条�g必须与超�c�M��被覆盖的�Ҏ��的前�|�条件相同或者更宽松�Q�而子�c�M��Ҏ��的后�|�条件必��M��类中被覆盖的方法的后置条�g相同或者更��Z��根{�?

一些OO语言中的�Ҏ��能够说明这一问题�Q?

�l�承�q�且覆盖��类�Ҏ��的时候，子类中的�Ҏ��的可见性必��ȝ��于或者大于超�c�M��的方法的可见性，子类中的�Ҏ��所抛出的受��异常只能是超�c�M��对应�Ҏ��所抛出的受��异常的子�c�R�?
public class SuperClass{
    public void methodA() throws IOException{}
}

public class SubClassA extends SuperClass{
    //this overriding is illegal.
    private void methodA() throws Exception{}
}

public class SubClassB extends SuperClass{
    //this overriding is OK.
    public void methodA() throws FileNotFoundException{}
}
从Java5开始，子类中的�Ҏ��的返回��g��可以是对应的��类�Ҏ��的返回值的子类。这叫做“协变�?Covariant)
public class SuperClass {
    public Number caculate(){
        return null;
    }
}

public class SubClass extends SuperClass{
    //only compiles in Java 5 or later.
    public Integer caculate(){
        return null;
    }
}

可以看出�Q�以上这些特性都非常好地遵��@了LSP。但是DbC呢？很遗憾，��L��的面向对象语�a��Q�不论是动态语�a��q�是静态语�a��Q�还没有加入对DbC的支持。但是随着AOP概念的��生，�怿�不久DbC也将成�ؓOO语言的一个重要特性之一�?

依赖倒置原则—�?DIP

a�Q�高层模块不应依赖于底层模块�Q�两者都应该依赖于抽�?br />b�Q�抽象不应该依赖于细节，�l�节应该依赖于抽�?/font>

原则

如何解释倒置
高层依赖底层�Q�重用变得困难，而最�l�常重用的就是framework和各个独立的功能�l��g
高层依赖底层�Q�底层的改动直接反馈到高层，形成依赖的传�?/font>

面向接口的编�E?/font>

实例

Ioc模式
DomainObject / DomianObjectDataService

接口隔离原则—�?ISP

使用多个专门的接口比使用单一的��L��口总要好。换而言之，从一个客��L��的角度来�Ԍ��一个类对另外一个类的依赖性应当是建立在最��接口上的�?/p>原则

�q�于臃肿的接口是�Ҏ��口的污染。不应该��客户依赖于它们不用的�Ҏ��?/p>

My object-oriented umbrella�Q�摘自Design Patterns Explained�Q?/p>

Let me tell you about my great umbrella. It is large enough to get into! In fact, three or four other people can get in it with me. While we are in it, staying out of the rain, I can move it from one place to another. It has a stereo system to keep me entertained while I stay dry. Amazingly enough, it can also condition the air to make it warmer or colder. It is one cool umbrella.

My umbrella is convenient. It sits there waiting for me. It has wheels on it so that I do not have to carry it around. I don't even have to push it because it can propel itself. Sometimes, I will open the top of my umbrella to let in the sun. (Why I am using my umbrella when it is sunny outside is beyond me!)

In Seattle, there are hundreds of thousands of these umbrellas in all kinds of colors. Most people call them cars.

实现�Ҏ��Q?br />1、 ��用委托分��L��?br />2、 ��用多重��承分��L��?/p>

惛_��一个朋友说的话�Q�所有的接口都只有一个方法，具体的类�Ҏ��自己需要什么方法去实现接口

��h��中立 2006-04-09 14:06 发表评论

国产亚洲精品福利在线无卡一,亚洲日本在线看片,91亚洲性爱在线视频

一个Sudoku的java求解���法

[转]O/R Mapping 基本概念

面向对象设计的基本原�?�?

Principles Of Object Oriented Design

一个Sudoku的java求解��法