国产精品久久久久久久久动漫,肉色丝袜一区二区,欧美日韩一区精品

public abstract class RepTempRule{

protected String oldString="";
public void setOldString(String oldString){
　　this.oldString=oldString;
}

protected String newString="";
public String getNewString(){
　　return newString;
}

public abstract void replace() throws Exception;

}

在RepTempRule�?有一个抽象方法abstract需要��承明��?�q�个replace里其实是替代的具体方�?
我们现在有两个字�W�替代方�?
1.��文本中aaa替代成bbb;
2.��文本中aaa替代成ccc;

对应的类分别是RepTempRuleOne RepTempRuleTwo

public class RepTempRuleOne extends RepTempRule{

public void replace() throws Exception{

　　//replaceFirst是jdk1.4新特�?
　　newString=oldString.replaceFirst("aaa", "bbbb")
　　System.out.println("this is replace one");
　　
}

}

public class RepTempRuleTwo extends RepTempRule{

public void replace() throws Exception{

　　newString=oldString.replaceFirst("aaa", "ccc")
　　System.out.println("this is replace Two");
　　
}

}

�W�二步：我们要徏立一个算法解决类�Q�用来提供客��L��可以自由选择��法�?/p>

public class RepTempRuleSolve {

　　private RepTempRule strategy;

　　public RepTempRuleSolve(RepTempRule rule){
　　　　this.strategy=rule;
　　}

　　public String getNewContext(Site site,String oldString) {
　　　　return strategy.replace(site,oldString);
　　}

　　public void changeAlgorithm(RepTempRule newAlgorithm) {
　　　　strategy = newAlgorithm;
　　}

}

调用如下:

public class test{

......

　　public void testReplace(){

　　//使用�W�一套替代方�?br />　　RepTempRuleSolve solver=new RepTempRuleSolve(new RepTempRuleSimple());
　　solver.getNewContext(site,context);

　　//使用�W�二�?/p>

　　solver=new RepTempRuleSolve(new RepTempRuleTwo());
　　solver.getNewContext(site,context);

　　}

.....

}

我们辑ֈ�了在�q�行期间�Q�可以自由切换算法的目的�?/p>

实际整个Strategy的核心部分就是抽象类的��?使用Strategy模式可以在用户需要变化时,修改量很��?而且快�?

Strategy和Factory有一定的�c�M��,Strategy相对��单容易理�?�q�且可以在运行时刻自由切换。Factory重点是用来创建对象�?/p>

Strategy适合下列场合:

1.以不同的格式保存文�g;

2.以不同的��法压羃文�g;

3.以不同的��法截获图象;

4.以不同的格式输出同样数据的图�?比如曲线或框图bar�{?/p>

阿成 2006-08-18 09:09 发表评论

Java设计模式 �?工厂模式

阿成 — Mon, 08 May 2006 01:12:00 GMT

工厂模式定义:提供创徏对象的接�?
��Z��么工厂模式是如此常用�Q�因为工厂模式就相当于创建实例对象的new�Q?br />我们�l�常要根据类Class生成实例对象�Q�如A a=new A() 工厂模式也是用来
创徏实例对象的，所以以后new时就要多个心��|��是否可以考虑实用工厂模式�Q?br />虽然�q�样做，可能多做一些工作，但会�l�你�pȝ��带来更大的可扩展性和��量��?br />的修攚w��?/p>

我们以类Sample��Z��Q?如果我们要创建Sample的实例对�?
Sample sample=new Sample();
可是�Q�实际情冉|��Q�通常我们都要在创建sample实例时做点初始化的工�?比如
赋�?查询数据库等。首先，我们惛_��的是�Q�可以��用Sample的构造函敎ͼ��q�样
生成实例��写�? Sample sample=new Sample(参数);
但是�Q�如果创建sample实例时所做的初始化工作不是象赋��D��L��单的事，可能
是很长一�D�代码，如果也写入构造函��C��Q�那你的代码很难看了�Q�就需要Refactor重整�Q��?br />��Z��么说代码很难看，初学者可能没有这�U�感觉，我们分析如下�Q�初始化工作如果
是很长一�D�代码，说明要做的工作很多，��很多工作装入一个方法中�Q�相当于��很多鸡
蛋放在一个篮子里�Q�是很危险的�Q�这也是有背于Java面向对象的原则，面向对象�?br />��装(Encapsulation)和分�z?Delegation)告诉我们�Q�尽量将长的代码分派“切剜y��成
每段�Q�将每段再“封装”�v�?减少�D�和�D�之间偶合联�p�L�?�Q�这��P��׃��风险分散，
以后如果需要修改，只要更改每段�Q�不会再发生牵一动百的事情�?br />在本例中�Q�首先，我们需要将创徏实例的工作与使用实例的工作分开, 也就是说�Q?br />让创建实例所需要的大量初始化工作从Sample的构造函��C��分离出去�?br />�q�时我们��需要Factory工厂模式来生成对象了�Q�不能再用上面简单new Sample(参数)�?br />�q�有,如果Sample有个�l�承如MySample, 按照面向接口�~�程,我们需要将Sample抽象成一�?br />接口.现在Sample是接�?有两个子�c�MySample 和HisSample .我们要实例化他们�?如下:
Sample mysample=new MySample();
Sample hissample=new HisSample();
随着��目的深�?Sample可能�q�会"生出很多儿子出来", 那么我们要对�q�些儿子一个个
实例�?更糟�p�的�?可能�q�要对以前的代码�q�行修改:加入后来生出儿子的实�?�q�在�?br />�l�程序中是无法避免的.
但如果你一开始就有意识��用了工厂模式,�q�些�ȝ��没有了.
工厂�Ҏ��
你会建立一个专门生产Sample实例的工�?
public class Factory{
　　public static Sample creator(int which){
　　//getClass 产生Sample 一般可使用动态类装蝲装入�c�R�?br />　　if (which==1)
　　　　return new SampleA();
　　else if (which==2)
　　　　return new SampleB();
　　}
}
那么在你的程序中,如果要实例化Sample�?��׃��?br />Sample sampleA=Factory.creator(1);
�q�样,在整个就不涉及到Sample的具体子�c?辑ֈ��装效果,也就减少错误修改的机�?
�q�个原理可以用很通俗的话来比�?��是具体事情做得��多,��容易范错误.�q�每个做
�q�具体工作的人都深有体会,相反,官做得越�?说出的话��抽象越�W�统,范错误可能�?br />��p��?好象我们从编�E�序中也能悟��Z�h生道�?呵呵.
使用工厂�Ҏ��要注意几个角�Ԍ��首先你要定义产品接口�Q�如上面的Sample,产品接口
下有Sample接口的实现类,如SampleA,其次要有一个factory�c�，用来生成产品Sample�?br />�q�一步稍微复杂一点，��是在工厂类上进行拓展，工厂�c�M��有��承它的实现类
concreteFactory了�?br />抽象工厂
工厂模式中有: 工厂�Ҏ��(Factory Method) 抽象工厂(Abstract Factory).
�q�两个模式区别在于需要创建对象的复杂�E�度上。如果我们创建对象的�Ҏ��变得复杂�?
如上面工厂方法中是创��Z��个对象Sample,如果我们�q�有新的产品接口Sample2.
�q�里假设�Q�Sample有两个concrete�c�SampleA和SamleB�Q�而Sample2也有两个concrete�c?br />Sample2A和SampleB2�Q�那么，我们��将上例中Factory变成抽象�c?��共同部分封装在�?br />象类�?不同部分使用子类实现�Q�下面就是将上例中的Factory拓展成抽象工�?
public abstract class Factory{
　　public abstract Sample creator();
　　public abstract Sample2 creator(String name);
}
public class SimpleFactory extends Factory{
　　public Sample creator(){
　　　　.........
　　　　return new SampleA
　　}
　　public Sample2 creator(String name){
　　　　.........
　　　　return new Sample2A
　　}
}
public class BombFactory extends Factory{
　　public Sample creator(){
　　　　......
　　　　return new SampleB
　　}
　　public Sample2 creator(String name){
　　　　......
　　　　return new Sample2B
　　}
}
从上面看��C��个工厂各自生产出一套Sample和Sample2,也许你会疑问�Q��ؓ什么我
不可以��用两个工厂方法来分别生��Sample和Sample2?
抽象工厂�q�有另外一个关键要点，是因�?SimpleFactory内，生��Sample和生�?br />Sample2的方法之间有一定联�p�，所以才要将�q�两个方法捆�l�在一个类中，�q�个工厂
�c�L��其本�w�特征，也许刉��过�E�是�l�一的，比如�Q�制造工艺比较简单，所以名�U?br />叫SimpleFactory�?br />在实际应用中�Q�工厂方法用得比较多一些，而且是和动态类装入器组合在一起应用，
举例
我们以Jive的ForumFactory��Z��Q�这个例子在前面的Singleton模式中我们讨��Q?br />现在再讨论其工厂模式:
public abstract class ForumFactory {
　　private static Object initLock = new Object();
　　private static String className = "com.jivesoftware.forum.database.DbForumFactory";
　　private static ForumFactory factory = null;
　　public static ForumFactory getInstance(Authorization authorization) {
　　　　//If no valid authorization passed in, return null.
　　　　if (authorization == null) {
　　　　　　return null;
　　　　}
　　　　//以下使用了Singleton 单态模�?br />　　　　if (factory == null) {
　　　　　　synchronized(initLock) {
　　　　　　　　if (factory == null) {
　　　　　　　　　　　　......
　　　　　　　　　　try {
　　　　　　　　　　　　　　//动态�{载类
　　　　　　　　　　　　　　Class c = Class.forName(className);
　　　　　　　　　　　　　　factory = (ForumFactory)c.newInstance();
　　　　　　　　　　}
　　　　　　　　　　catch (Exception e) {
　　　　　　　　　　　　　　return null;
　　　　　　　　　　}
　　　　　　　　}
　　　　　　}
　　　　}

　　　　//Now, �q�回 proxy.用来限制授权对forum的访�?br />　　　　return new ForumFactoryProxy(authorization, factory,
　　　　　　　　　　　　　　　　　　　　factory.getPermissions(authorization));
　　}

　　//真正创徏forum的方法由�l�承forumfactory的子�c�d��完成.
　　public abstract Forum createForum(String name, String description)
　　throws UnauthorizedException, ForumAlreadyExistsException;

　　....

}
因�ؓ现在的Jive是通过数据库系�l�存放论坛帖子等内容数据,如果希望更改为通过文�g�pȝ��实现,�q�个工厂�Ҏ��ForumFactory��提供了提供动态接�?

private static String className = "com.jivesoftware.forum.database.DbForumFactory";

你可以��用自己开发的创徏forum的方法代替com.jivesoftware.forum.database.DbForumFactory��可�?

在上面的一�D�代码中一��q��了三�U�模�?除了工厂模式�?�q�有Singleton单态模�?以及proxy模式,proxy模式主要用来授权用户对forum的访�?因�ؓ讉K��forum有两�U��h:一个是注册用户一个是游客guest,那么那么相应的权限就不一�?而且�q�个权限是诏�I�整个系�l�的,因此建立一个proxy,�c�M��|�关的概�?可以很好的达到这个效�?

看看Java宠物店中的CatalogDAOFactory:

public class CatalogDAOFactory {

　　/**

　　* 本方法制定一个特别的子类来实现DAO模式�?br />　　* 具体子类定义是在J2EE的部�|�描�q�器中�?br />　　*/

　　public static CatalogDAO getDAO() throws CatalogDAOSysException {

　　　　CatalogDAO catDao = null;

　　　　try {

　　　　　　InitialContext ic = new InitialContext();
　　　　　　//动态装入CATALOG_DAO_CLASS
　　　　　　//可以定义自己的CATALOG_DAO_CLASS�Q�从而在无需变更太多代码
　　　　　　//的前提下�Q�完成系�l�的巨大变更�?/p>

　　　　　　String className =(String) ic.lookup(JNDINames.CATALOG_DAO_CLASS);

　　　　　　catDao = (CatalogDAO) Class.forName(className).newInstance();

　　　　} catch (NamingException ne) {

　　　　　　throw new CatalogDAOSysException("
　　　　　　　　CatalogDAOFactory.getDAO: NamingException while
　　　　　　　　　　getting DAO type : \n" + ne.getMessage());

　　　　} catch (Exception se) {

　　　　　　throw new CatalogDAOSysException("
　　　　　　　　CatalogDAOFactory.getDAO: Exception while getting
　　　　　　　　　　DAO type : \n" + se.getMessage());

　　　　}

　　　　return catDao;

　　}

CatalogDAOFactory是典型的工厂�Ҏ��Q�catDao是通过动态类装入器className获得CatalogDAOFactory具体实现子类�Q�这个实现子�c�d��Java宠物店是用来操作catalog数据库，用户可以�Ҏ��数据库的�c�d��不同�Q�定制自��q��具体实现子类�Q�将自己的子�c�d��l�与CATALOG_DAO_CLASS变量��可以�?/p>

由此可见�Q�工厂方法确实�ؓ�pȝ��l�构提供了非常灵�z�d��大的动态扩展机�Ӟ��只要我们更换一下具体的工厂�Ҏ��Q�系�l�其他地�Ҏ��需一点变换，��有可能��系�l�功能进行改头换面的变化�?/p>

设计模式如何在具体项目中应用见《Java实用�pȝ��开发指南�?/p>

阿成 2006-05-08 09:12 发表评论