设计模式1.docx
《设计模式1.docx》由会员分享，可在线阅读，更多相关《设计模式1.docx（24页珍藏版）》请在冰豆网上搜索。
设计模式1
自己总结的Java开发中的23种设计模式，通俗易懂有实例代码
（2011-11-2414:
14:
00）
转载▼
标签：
java
设计模式
杂谈
分类：
Java笔记_基础很重要
从追MM谈Java的23种设计模式
1、FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。
麦当劳和肯德基就是生产鸡翅的Factory.
工厂模式：
客户类和工厂类分开。
消费者任何时候需要某种产品，只需向工厂请求即可。
消费者无须修改就可以接纳新产品。
缺点是当产品修改时，工厂类也要做相应的修改。
如：
如何创建及如何向客户端提供。
程序代码
以下是引用片段：
Java代码
1.publci class Sample{
2. ....
3.}
4.
5.public class A extends Sample{
6. ....
7.}
8.
9.public class B extends Sample{
10. ......
11.}
工厂类处于决定实例化那个产品类的中心位置
Java代码
1.public class Factory{
2.
3. //静态工厂方法，无必要再去实例化这个工厂类，增加没有必要的代码
4. public static Sample create（int which）{
5. if（which==1）
6. return new A（）;
7. if（which==2）
8. return new B（）;
9. }
10.}
使用简单工厂初始化一个类
Java代码
1.Sample newSample=Factory.create
（1）;
2.工厂方法模式
植物接口及两个实现类
Java代码
1.public interface Plant{}
2.
3.public class PlantA implements Plant{
4.}
5.
6.public class PlantB implements Plant{
7.}
水果接口及两个实现类
Java代码
1.public interface Fruit{}
2.
3.public class FruitA implements Fruit{
4.}
5.
6.public class FruitB implements Fruit{
7.}
抽象工厂
Java代码
1.public interface AbstractFactory{
2. public Plant createPlant（）;
3. public Fruit creatFruit（）;
4.}
工厂类A
Java代码
1.public Class FactoryA implements AbstractFactory{
2. public Plant createPlant（）{
3. return new PlantA（）;
4. }
5. public Fruit creatFruit（）{
6. return new FruitA（）;
7. }
8.}
工厂类B
Java代码
1.public Class FactoryB implements AbstractFactory{
2. public Plant createPlant（）{
3. return new PlantB（）;
4. }
5. public Fruit creatFruit（）{
6. return new FruitB（）;
7. }
8.}
工厂模式分为三种：
SimpleFactory模式
专门定义一个类来负责创建其它类的实例，被创建的实例通常都具有共同的父类。
FactoryMethod模式
将对象的创建交由父类中定义的一个标准方法来完成，而不是其构造函数，究竟应该创建何种对象由具体的子类负责决定。
AbstractFactory模式
提供一个共同的接口来创建相互关联的多个对象。
一、SimpleFactory模式：
水果接口：
Fruit.java
packagedesignpattern.factory.simplefactory;
publicinterfaceFruit{
voidplant（）;
voidenableEat（）;
}
苹果类实现水果接口：
Apple.java
packagedesignpattern.factory.simplefactory;
publicclassAppleimplementsFruit{
@Override
publicvoidenableEat（）{
System.out.println（"EatApple"）;
}
@Override
publicvoidplant（）{
System.out.println（"PlanApple"）;
}
}
葡萄类实现水果接口：
Grape.java
packagedesignpattern.factory.simplefactory;
publicclassGrapeimplementsFruit{
@Override
publicvoidenableEat（）{
System.out.println（"EatGrape"）;
}
@Override
publicvoidplant（）{
System.out.println（"PlantGrape"）;
}
}
买水果工厂类，可根据不同的参数类型返回对应的实例：
FruitFactory.java
packagedesignpattern.factory.simplefactory;
publicclassFruitFactory{
publicstaticFruitgetFruitFactory（StringfruitType）{
if（fruitType.equals（"Apple"））{
returnnewApple（）;
}
if（fruitType.equals（"Grape"））{
returnnewGrape（）;
}
returnnull;
}
}
测试类，根椐不同的输入参数从工厂类中得到对应的实例并调用相应实例的方法：
FruitTest.java
packagedesignpattern.factory.simplefactory;
publicclassFruitTest{
publicstaticvoidmain（String[]args）{
Fruitfruit=FruitFactory.getFruitFactory（"Apple"）;
fruit.plant（）;
fruit.enableEat（）;
}
}
A：
我要需要苹果，只需向工厂角色（FruitFactory）请求即可。
而工厂角色在接到请求后，会自行判断创建和提供哪一个产品。
B：
但是对于工厂角色（FruitFactory）来说，增加新的产品（比如说增加草莓）就是一个痛苦的过程。
工厂角色必须知道每一种产品，如何创建它们，以及何时向客户端提供它们。
换言之，接纳新的产品意味着修改这个工厂。
C：
因此SimpleFactory模式的开放性比较差。
有什么办法可以解决这个问题吗？
那就需要FactoryMethod模式来为我们服务了。
二、FactoryMethod模式：
把水果工厂定义成接口再用各种水果去实现自己的实例，这样做的好处就是如果再增加一种水果，只要增加它的对象和实现工厂就可以了，而不必修改任何代码。
水果接口：
Fruit.java
packagedesignpattern.factory.simplefactory;
publicinterfaceFruit{
voidplant（）;
voidenableEat（）;
}
苹果类实现水果接口：
Apple.java
packagedesignpattern.factory.simplefactory;
publicclassAppleimplementsFruit{
@Override
publicvoidenableEat（）{
System.out.println（"EatApple"）;
}
@Override
publicvoidplant（）{
System.out.println（"PlanApple"）;
}
}
葡萄类实现水果接口：
Grape.java
packagedesignpattern.factory.simplefactory;
publicclassGrapeimplementsFruit{
@Override
publicvoidenableEat（）{
System.out.println（"EatGrape"）;
}
@Override
publicvoidplant（）{
System.out.println（"PlantGrape"）;
}
}
苹果工厂类：
AppleFactory.java
packagedesignpattern.factory.factorymodel;
publicclassAppleFactoryimplementsFruitFactory{
@Override
publicFruitgetFruitFactory（）{
returnnewPear（）;
}
}
葡萄工厂类：
GrapeFactory.java
packagedesignpattern.factory.factorymodel;
publicclassGrapeFactoryimplementsFruitFactory{
@Override
publicFruitgetFruitFactory（）{
returnnewGrape（）;
}
}
水果工厂类：
FruitFactory.java
packagedesignpattern.factory.factorymodel;
publicinterfaceFruitFactory{
publicFruitgetFruitFactory（）;
}
测试类：
FruitTest.java
packagedesignpattern.factory.factorymodel;
publicclassFruitTest{
publicstaticvoidmain（String[]args）{
//Apple
AppleFactoryappleFactory=newAppleFactory（）;
appleFactory.getFruitFactory（）.plant（）;
appleFactory.getFruitFactory（）.enableEat（）;
//Soifyouwantaddpear,youshalladdpearandpearfactoryclass.
//andnotneedmodifyanything.
//Pear
PearFactorypearFactory=newPearFactory（）;
pearFactory.getFruitFactory（）.plant（）;
pearFactory.getFruitFactory（）.enableEat（）;
}
}
上面加了一个梨的水果，所以只要添加对应的代码即可。
A：
工厂方法模式和简单工厂模式在结构上的不同是很明显的。
工厂方法模式的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。
工厂方法模式可以允许很多具体工厂类从抽象工厂类中将创建行为继承下来，从而可以成为多个简单工厂模式的综合，进而推广了简单工厂模式。
B：
工厂方法模式退化后可以变得很像简单工厂模式。
设想如果非常确定一个系统只需要一个具体工厂类，那么就不妨把抽象工厂类合并到具体的工厂类中去。
由于反正只有一个具体工厂类，所以不妨将工厂方法改成为静态方法，这时候就得到了简单工厂模式。
C：
如果需要加入一个新的水果，那么只需要加入一个新的水果类以及它所对应的工厂类。
没有必要修改客户端，也没有必要修改抽象工厂角色或者其他已有的具体工厂角色。
对于增加新的水果类而言，这个系统完全支持"开-闭"原则。
D：
对FactoryMethod模式而言，它只是针对一种类别（如本例中的水果类Fruit），但如果我们还想买肉，那就不行了，这是就必须要AbstractMethod模式帮忙了。
三、AbstractMethod模式：
A：
抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，创建多个产品族中的产品对象。
这就是抽象工厂模式的用意。
B：
抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。
C：
抽象工厂模式与工厂方法模式的最大区别就在于，工厂方法模式针对的是一个产品（Fruit）等级结构；而抽象工厂模式则需要面对多个产品等级结构（Fruit、Meat）。
Fruit.java
packagedesignpattern.factory.abstractfactory;
publicinterfaceFruit{
voidplant（）;
voidenableEat（）;
}
Fruit.java
packagedesignpattern.factory.abstractfactory;
publicclassAppleimplementsFruit{
@Override
publicvoidenableEat（）{
System.out.println（"EatApple"）;
}
@Override
publicvoidplant（）{
System.out.println（"PlanApple"）;
}
}
Grape.java
packagedesignpattern.factory.abstractfactory;
publicclassGrapeimplementsFruit{
@Override
publicvoidenableEat（）{
System.out.println（"EatGrape"）;
}
@Override
publicvoidplant（）{
System.out.println（"PlantGrape"）;
}
}
Pear.java
packagedesignpattern.factory.abstractfactory;
publicclassPearimplementsFruit{
@Override
publicvoidenableEat（）{
System.out.println（"EatPear"）;
}
@Override
publicvoidplant（）{
System.out.println（"PlanPear"）;
}
}
Apple.java
packagedesignpattern.factory.abstractfactory;
publicclassAppleimplementsFruit{
@Override
publicvoidenableEat（）{
System.out.println（"EatApple"）;
}
@Override
publicvoidplant（）{
System.out.println（"PlanApple"）;
}
}
Meat.java
packagedesignpattern.factory.abstractfactory;
publicinterfaceMeat{
voidfeed（）;
voidenableEat（）;
}
Cow.java
packagedesignpattern.factory.abstractfactory;
publicclassCowimplementsMeat{
@Override
publicvoidenableEat（）{
System.out.println（"EatCow"）;
}
@Override
publicvoidfeed（）{
System.out.println（"FeedCow"）;
}
}
Pig.java
packagedesignpattern.factory.abstractfactory;
publicclassPigimplementsMeat{
@Override
publicvoidenableEat（）{
System.out.println（"EatPig"）;
}
@Override
publicvoidfeed（）{
System.out.println（"FeedPig"）;
}
}
IFactory.java
packagedesignpattern.factory.abstractfactory;
publicinterfaceIFactory{
publicFruitgetFruitFactory（FruitwhichFruit）;
publicMeatgetMeatFactory（MeatwhichMeat）;
}
MyFactory.java
packagedesignpattern.factory.abstractfactory;
publicclassMyFactoryimplementsIFactory{
@Override
publicFruitgetFruitFactory（FruitwhichFruit）{
//TODOAuto-generatedmethodstub
returnwhichFruit;
}
@Override
publicMeatgetMeatFactory（MeatwhichMeat）{
//TODOAuto-generatedmethodstub
returnwhichMeat;
}
}
FruitTest.java
packagedesignpattern.factory.abstractfactory;
publicclassFruitTest{
publicstaticvoidmain（String[]args）{
Fruitapple=newApple（）;
Meatpig=newPig（）;
MyFactorymy=newMyFactory（）;
my.getFruitFactory（apple）.plant（）;
my.getFruitFactory（apple）.enableEat（）;
System.out.println（"---------------------------"）;
my.getMeatFactory（pig）.feed（）;
my.getMeatFactory（pig）.enableEat（）;
}
}
2、BUILDER—MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞掂，这就是我的“我爱你”builder。
（这一定比美军在伊拉克用的翻译机好卖）
建造模式：
将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。
建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。
建造模式可以强制实行一种分步骤进行的建造过程。
java代码
//首先是一个建造工具（builder）接口
1.public interface builder {
2.
3. void zhuji（）;//主机
4. void jianpan（）;//键盘
5. void xianshiqi（）;//显示器
6. void shubiao（）;//鼠标
7. computer getcomputer（）;//返回产品
8.}
Java代码
1.//建造工具的具体建造方式：
2.public class ConcreteBuilder implements builder {
3.
4. private String zhuji;
5. private String xianshiqi;
6. private String jianpan;
7. private String shubiao;
8. @Override
9. public void zhuji（） {
10. //
11. System.out.println（"生产主机"）;
12. zhuji= "MAC主机";
13. }
14.
15. @Overrid
升级会员 