null初级开发人员Java
设计
领导形象设计圆作业设计ao工艺污水处理厂设计附属工程施工组织设计清扫机器人结构设计
模式初级开发人员Java设计模式目录目录二 Java设计模式-创建模式三 Java设计模式-结构模式四 Java设计模式-行为模式五
总结
初级经济法重点总结下载党员个人总结TXt高中句型全总结.doc高中句型全总结.doc理论力学知识点总结pdf
1.1设计模式概念1.1设计模式概念设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。1.1设计模式概念1.1设计模式概念如果把编写程序比作打仗，那么设计模式就是战争中的三十六计、孙子兵法1.2设计模式的分类1.2设计模式的分类创建对象，在类实例化的时候使用的模式关注类和对象之间的联系类（对象）怎样组合在一起组成一种较大的结构目录目录一 什么是设计模式二 Java设计模式-创建模式三 Java设计模式-结构模式四 Java设计模式-行为模式五 总结创建模式创建模式创建模式-单例模式创建模式-单例模式PrototypeBuilderAbstract FactoryFactorySingleton1 Singleton-概念1 Singleton-概念什么是单例模式？
单例类只能有一个实例。
单例类必须自己创建自己的唯一实例。
单例类必须给所有其它对象提供这一实例。
第 * 页2 Singleton-应用场景2 Singleton-应用场景应用范围：某些情况某个类我们只需要创建一个对象，并且最多创建一个对象，这个时候我们就需要单态模式。
1）Printer Spooler
2）序列号生成
3）缓存服务
第 * 页3 Singleton-代码实现1观察这段代码：
public class Spooler
{
private static Spooler ms_spooler = new Spooler();
private Spooler()
{
}
public static Spooler CreateInsance()
{
return ms_spooler;
}
}不具备延迟初始化的能力3 Singleton-代码实现13 Singleton-代码实现2观察这段代码：
public class Spooler
{
private static Spooler ms_spooler = null;
private Spooler()
{
}
public static Spooler CreateInsance()
{
if(ms_spooler == null)
ms_spooler = new Spooler();
return ms_spooler;
}
}如果两个同时运行的线程都会调用CreateInstance来获取实例，上面的代码安全吗?3 Singleton-代码实现23 Singleton-代码实现3观察这段代码：
public class Spooler
{
private static Spooler ms_spooler = null;
private Spooler()
{
}
public static synchronized Spooler CreateInsance()
{
if(ms_spooler == null)
ms_spooler = new Spooler();
return ms_spooler;
}
}3 Singleton-代码实现34 Singleton-引申4 Singleton-引申1）对于一次请求来说，request是不是一个单例？
2）对于一个用户来说，session是不是一个单例？
3）如果我们吧对象创建的个数限制到一定的程度是不是也是一种单例？比如线程池、数据库连接池创建模式-工厂模式创建模式-工厂模式134521 工厂模式-概念1 工厂模式-概念简单工厂模式根据提供给它的数据，返回几个可能类中的一个类的实例。
通常工厂返回的类都有一个共同的父类和共同的方法，但每个方法执行的任务不同，而且根据不同的数据进行了优化。第 * 页2 工厂模式-应用场景19952001200320052009邮件短信 彩信博客微博2 工厂模式-应用场景SendMsg(Msg msg, send Type)
{
If(type == 短信)
{
发短信
}
Else if(type == 邮件)
{
发邮件
}
Else if
。。。。。。。
}
2 工厂模式-应用场景2 工厂模式-应用场景实现3实现1实现2工厂类CEO3 工厂模式-代码1第 * 页3 工厂模式-代码1
//抽象的创建对象基类
public abstract class Window {
public abstract void func();
}
//创建对象类
public class WindowBig extends Window {
public void func() {
System.out.println("This is Big Window !");
}
}
//创建对象类
public class WindowSmall extends Window {
public void func() {
System.out.println("This is Small Window !");
}
}3 工厂模式-代码2第 * 页3 工厂模式-代码2//工厂类
public class Factory {
public Window CreateWindow (String type) {
if(type.equals("Big")) {
return new WindowBig();
} else if(type.equals("Small")) {
return new WindowSmall();
} else {
return new WindowBig();
}
}
// The Main function only for our test
public static void main(String[] args) {
Factory myFactory = new Factory();
Window myBigWindow = myFactory.CreateWindow("Big");
myBigWindow.func();
Window mySmallWindow = myFactory.CreateWindow("Small");
mySmallWindow.func();
}
}创建模式-抽象工厂创建模式-抽象工厂134521抽象工厂-概念1抽象工厂-概念
抽象工厂模式是类的创建模式，其用意是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。
抽象工厂模式是简单工厂模式的进一步抽象和推广。由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。
在抽象工厂模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不接触哪一个产品类被实例化这种细节。这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。2 抽象工厂-应用场景2 抽象工厂-应用场景当要创建的类不确定性很高，简单工厂满足不了的时候
比如：
1、工作流自动节点
2、比如类型转换。 Number类型的会建一类，Date类型一类， String一类等。
想一个游戏：扑克牌抽象工厂-代码实现抽象工厂-代码实现定义两种墙：
public abstract class Wall {
//private Wall wall;
public abstract String getName();
}
public class LivingRoomWall extends Wall {
private String wallName;
public LivingRoomWall() {
wallName = "LivingRoomWall";
}
public String getName() {
return wallName;
}
}
public class BedRoomWall extends Wall {
private String wallName;
public BedRoomWall() {
wallName = "BedRoomWall";
}
public String getName() {
return wallName;
}
}第 * 页抽象工厂-代码实现抽象工厂-代码实现//定义两种门：
public abstract class Door {
//private Door door;
public abstract String getName() ;
}
public class LivingRoomDoor extends Door {
private String doorName;
public LivingRoomDoor() {
doorName = "LivingRoomDoor";
}
public String getName() {
return doorName;
}
}
public class BedRoomDoor extends Door {
private String doorName;
public BedRoomDoor() {
doorName = "BedRoomDoor";
}
public String getName() {
return doorName;
}
}第 * 页抽象工厂-代码实现抽象工厂-代码实现//定义两种房间
public abstract class Room { //抽象工厂类
public abstract Wall makeWall();
public abstract Door makeDoor();
}
public class BedRoom extends Room {
public BedRoom() {
System.out.println("Initiated a bedroom !");
}
public Door makeDoor() {
return new BedRoomDoor();
}
public Wall makeWall() {
return new BedRoomWall();
}
}
public class LivingRoom extends Room {
public LivingRoom() {
System.out.println("Initiated a living room !");
}
public Door makeDoor() {
return new LivingRoomDoor();
}
public Wall makeWall() {
return new LivingRoomWall();
}
}第 * 页抽象工厂-代码实现抽象工厂-代码实现//测试类：
public class RoomMaker {
public Room CreateRoom(String roomType) {
if(roomType.equals("LivingRoom")) {
return new LivingRoom();
} else if(roomType.equals("BedRoom")) {
return new BedRoom();
} else {
return new LivingRoom();
}
}
public static void main(String[] args) {
RoomMaker myMaker = new RoomMaker();
//----- Create Living Room
Room myLivingRoom = myMaker.CreateRoom("LivingRoom");
//----- Create a door in living room
Door livingDoor = myLivingRoom.makeDoor();
System.out.println("Living room door name is:" + livingDoor.getName() );
//----- Create a wall in living room
Wall livingWall = myLivingRoom.makeWall();
System.out.println("Living room wall name is:" + livingWall.getName() );
//----- Create Bed Room
Room myBedRoom = myMaker.CreateRoom("BedRoom");
//----- Create a door in bedroom
Door BedDoor = myBedRoom.makeDoor();
System.out.println("Bed room door name is:" + BedDoor.getName() );
//----- Create a wall in bedroom
Wall BedWall = myBedRoom.makeWall();
System.out.println("Bed room wall name is:" + BedWall.getName() );
}
}第 * 页创建模式-建造模式创建模式-建造模式134521 建造模式-概念1 建造模式-概念Builder模式的缘起： 假设创建游戏中的一个房屋House设施，该房屋的构建由几部分组成，且各个部分富于变化。如果使用最直观的设计方法，每一个房屋部分的变化，都将导致房屋构建的重新修正。 动机（Motivation): 在软件系统中，有时候面临一个"复杂对象"的创建工作，其通常由各个部分的子对象用一定算法构成;由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合到一起的算法却相对稳定。 如何应对种变化呢？如何提供一种"封装机制"来隔离出"复杂对象的各个部分"的变化，从而保持系统中的"稳定构建算法"不随需求的改变而改变？ 意图(Intent)： 将一个复杂对象的构建与其
表
关于同志近三年现实表现材料材料类招标技术评分表图表与交易pdf视力表打印pdf用图表说话 pdf
示相分离，使得同样的构建过程可以创建不同的表示。第 * 页2 建造模式-结构2 建造模式-结构建造模式的结构
抽象建造者角色（Builder）：给出一个抽象的接口，用来规范产品对象的各个组成成分的建造。
具体建造者角色（Concrete Builder ）：
1.实现抽象建造者所申明的接口，给出一步一步地完成创建产品实例的操作。
2.在建造过程完成后，提供产品的实例。
导演者角色（Director）：用来调用具体建造者以创建产品对象。
产品角色（Product）：要建造的对象。
第 * 页创建模式 – Builder(建造模式)创建模式 – Builder(建造模式)
public class House {//最终要建造的对象
int roomNumber;
int doorNumber;
public House() {
roomNumber = 0;
doorNumber = 0;
}
public int getRoomNumber() {
return roomNumber;
}
public int getDoorNumber() {
return doorNumber;
}
}
第 * 页创建模式 – Builder(建造模式)创建模式 – Builder(建造模式)// An abstract Builder
public abstract class HouseBuilder {
public abstract void buildRoom(int roomNo);
public abstract void buildDoor(int room1, int room2);
public abstract House getHouse();
}
//建造房子的功能类
public class ConcreteHouseBuilderA extends HouseBuilder {
private House house;
public ConcreteHouseBuilderA() {
house = new House();
}
public void buildRoom(int roomNo) {
// you can create a new Room added to a House
house.roomNumber++;
}
public void buildDoor(int room1, int room2) {
// you can create a new door assotiated with 2 room
// and added this door into a house
house.doorNumber++;
}
public House getHouse() {
return house;
}
}第 * 页创建模式 – Builder(建造模式)创建模式 – Builder(建造模式)//建造过程
public class HouseDirector {
public void createHouse(HouseBuilder concreteBuilder) {
concreteBuilder.buildRoom(1);
concreteBuilder.buildRoom(2);
concreteBuilder.buildDoor(1, 2);
}
}
//测试类
public class Test {
public static void main(String[] args) {
HouseBuilder myHouseBuilder = new ConcreteHouseBuilderA();
HouseDirector myHouseDirector = new HouseDirector();
myHouseDirector.createHouse(myHouseBuilder);
House myHouse = myHouseBuilder.getHouse();
System.out.println("My house has room :" + myHouse.getRoomNumber());
System.out.println("My house has door :" + myHouse.getDoorNumber());
}
}第 * 页建造模式-要点建造模式-要点Builder模式的几个要点: Builder模式 主要用于“分步骤构建一个复杂的对象”。在这其中“分步骤”是一个稳定的乘法，而复杂对象的各个部分则经常变化。 Builder模式主要在于应对“复杂对象各个部分”的频繁需求变动。其缺点在于难以应对“分步骤构建算法”的需求变动。 Abstract Factory模式解决“系列对象”的需求变化，Builder模式解决“对象部分”的需求变化。Builder械通常和Composite模式组合使用。创建模式-原始模型模式创建模式-原始模型模式13452原始模型模式-概念原始模型模式-概念工作原理：允许一个原型对象重新创建一个与自己一模一样的新对象。
在Java里面，我们可以很容易的通过Clone()方法实现原型模式。任何类，只要想支持克隆，必须实现Cloneable接口。Cloneable接口中有一Clone方法，可以在类中重载实现自定义的克隆方法。通过序列化实现深度克隆。
第 * 页Prototype-代码Prototype-代码//原始模型模式接口类
public interface IGraphic extends Cloneable, Serializable {
public String getName() ;
public void setName(String gName);
}
//Prototype抽象类
public abstract class Graphic implements IGraphic {
private String name;
public Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e){
System.out.println("Do not support clone !!!");
throw new InternalError();
}
}
public String getName() {
return name;
}
public void setName(String gName) {
name = gName;
}
public abstract void DoSomething();
} 第 * 页Prototype-代码Prototype-代码
//Prototype类
public class LineSymbol extends Graphic {
public void DoSomething() {
System.out.println("I am used to draw a line !");
}
}
//Prototype类
public class NoteSymbol extends Graphic {
public void DoSomething() {
System.out.println("I am used to draw a note !");
}
}
//Prototype实例注册
public class SymbolLoader {
private Hashtable symbols = new Hashtable();
public SymbolLoader() {
symbols.put("Line", new LineSymbol());
symbols.put("Note", new NoteSymbol());
}
public Hashtable getSymbols() {
return symbols;
}
}第 * 页Prototype-代码Prototype-代码
//测试类
public class GraphicTool {
public static void main(String[] args) {
//----- Initial our prototype instance ----------
SymbolLoader myLoader = new SymbolLoader();
Hashtable mySymbols = myLoader.getSymbols();
//----- Draw a Line -------------------------------
Graphic myLine = (Graphic)((Graphic)mySymbols.get("Line")).clone();
myLine.DoSomething();
}
}第 * 页原型模式-深度克隆原型模式-深度克隆 private static Object cloneObject(Object obj) throws Exception {
ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(byteOut);
out.writeObject(obj);
ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
ObjectInputStream in =new ObjectInputStream(byteIn);
return in.readObject();
｝
目录目录一 什么是设计模式二 Java设计模式-创建模式三 Java设计模式-结构模式四 Java设计模式-行为模式五 总结结构模式结构模式67结构模式结构模式适配器-换个包装再利用适配器-换个包装再利用适配器模式把一个类的接口变换成客户端所期待的另一种接口，从而使原本接口不匹配而无法在一起工作的两个类能够在一起工作。
名称由来：
这很像变压器（Adapter），变压器把一种电压变换成另一种电压。
Adapter模式也很像货物的包装过程：被包装的货物的真实样子被包装所掩盖和改变，因此有人把这种模式叫做包装（Wrapper）模式。事实上，大家经常写很多这样的Wrapper类，把已有的一些类包装起来，使之有能满足需要的接口。 适配器-换个包装再利用适配器-换个包装再利用适配器模式的两种形式 ：
类的适配器模式(适配与被适配：继承关系)
对象的适配器模式 (适配与被适配：引用关系)
类的Adapter模式的结构 类的Adapter模式的结构 由图中可以看出，Adaptee类没有Request方法，而客户期待这个方法。
为了使客户能够使用Adaptee类，提供一个中间环节，即类Adapter类，Adapter类实现了Target接口，并继承自Adaptee，Adapter类的Request方法重新封装了Adaptee的SpecificRequest方法，实现了适配的目的。类的Adapter模式-代码public interface ITarget { // Methods void Request(); } //外部库
public class Adaptee { // Methods public void SpecificRequest() { System.out.println("Called SpecificRequest()" ); } } // "Adapter" public class Adapter extends Adaptee implements ITarget { // Implements ITarget interface public void Request() { // Possibly do some data manipulation // and then call SpecificRequest this.SpecificRequest(); } } public class Client { public static void main(String[] args) { ITarget t = new Adapter(); t.Request(); } } 类的Adapter模式-代码对象的Adapter模式的结构 对象的Adapter模式的结构 客户端需要调用Request方法，而Adaptee没有该方法，为了使客户端能够使用Adaptee类，需要提供一个包装（Wrapper）类Adapter。
这个包装类包装了一个Adaptee的实例，从而将客户端与Adaptee衔接起来。
由于Adapter与Adaptee是委派关系，这决定了这个适配器模式是对象的。 对象的Adapter模式-代码public interface ITarget { // Methods void Request(); } //外部库
public class Adaptee { // Methods public void SpecificRequest() { System.out.println("Called SpecificRequest()" ); } } // "Adapter" public class Adapter implements ITarget { Adaptee adaptee = new Adaptee();
public void Request() { adaptee.SpecificRequest(); } } public class Client { public static void main(String[] args) { ITarget t = new Adapter(); t.Request(); } } 对象的Adapter模式-代码在什么情况下使用适配器模式 在什么情况下使用适配器模式 1、 系统需要使用现有的类，而此类的接口不符合系统的需要。
例子：
你现在用的组织结构是自己的， 但是公司要求统一，使用同样的组织结构实现，这个时候就需要使用适配器。结构模式结构模式Bridge-分成功能层次和实现层次Bridge-分成功能层次和实现层次桥梁模式负责连两大不同层次的参与者：
功能的类层次：子类继承父类而扩展（父类）功能
实现的类层次：抽象父类定义接口，子类负类实现第 * 页功能接口类层交实现类层
次Bridge：分成功能层次和实现层次Bridge：分成功能层次和实现层次生活中的例子： 我想大家小时候都有用蜡笔画画的经历吧。红红绿绿的蜡笔一大盒，根据想象描绘出格式图样。而毛笔下的国画更是工笔写意，各展风采。而今天我们的故事从蜡笔与毛笔说起。
设 想要绘制一幅图画，蓝天、白云、绿树、小鸟，如果画面尺寸很大，那么用蜡笔绘制就会遇到点麻烦。毕竟细细的蜡笔要涂出一片蓝天，是有些麻烦。如果有可能， 最好有套大号蜡笔，粗粗的蜡笔很快能涂抹完成。至于色彩吗，最好每种颜色来支粗的，除了蓝天还有绿地呢。这样，如果一套12种颜色的蜡笔，我们需要两套 24支，同种颜色的一粗一细。呵呵，画还没画，开始做梦了：要是再有一套中号蜡笔就更好了，这样，不多不少总共36支蜡笔。
Bridge-分成功能层次和实现层次Bridge-分成功能层次和实现层次 再看看毛笔这一边，居然如此简陋：一套水彩12色，外加大中小三支毛笔。你可别小瞧这"简陋"的组合，画蓝天用大毛笔，画小鸟用小毛笔，各具特色。
Bridge -代码Bridge -代码1 abstract class Brush 2 { 3 protected Color c; 4 public abstract void Paint(); 5 6 public void SetColor(Color c) 7 { this.c = c; } 8 }1 class BigBrush extends Brush 2 { 3 public override void Paint() 4 { System.out.println("Using big brush and color {0} painting");
c.write();
} 5 }1 class Color 2 { 3 public string write(); 4 } class Red extends Color { public write() {
System.out.println(“red");
} }。。。。。。。。。。。。。。在什么情况下使用Bridge模式 在什么情况下使用Bridge模式 1、桥梁模式最大特征就在于将接口方法区分成“功能的类层次”和“实现的类层次”。
例子：
假设要现有类 (由继承而形成的)嵌入本地文件读写。程序里会因OS不同面变的部分。这个因OS不同而变的部分就要采用Bridge查式的“实现的类层次”来表现。而类自身（由继承产生）层次则属于“功能的类层次”。Spring中“依赖注入”原则其思想就是典型的 “Bridge模式”。
桥梁模式与策略模式比较相似，只不过桥梁模式采用“继承”思想，而策略模式为“接口”思想。继承可是多层的，而接口与实现类之间只有一层。Bridge -代码Bridge -代码 3 public static void Main() 4 { 5 Brush b = new BigBrush(); 6 b.SetColor(new Red()); 7 b.Paint(); 8 b.SetColor(new Blue()); 9 b.Paint(); 10 b.SetColor(new Green()); 11 b.Paint(); 12 13 b = new SmallBrush(); 14 b.SetColor(new Red()); 15 b.Paint(); 16 b.SetColor(new Blue()); 17 b.Paint(); 18 b.SetColor(new Green()); 19 b.Paint(); 20 }结构模式结构模式Proxy-要用再建立Proxy-要用再建立代理（Proxy）模式给某一个对象提供一个代理，并由代理对象控制对原对象的引用。
代理模式的英文叫做Proxy或Surrogate，中文都可译成"代理"。所谓代理，就是一个人或者一个机构代表另一个人或者另一个机构采取行动。在一些情况下，一个客户不想或者不能够直接引用一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。 Proxy-要用再建立代理的种类
如果按照使用目的来划分，代理有以下几种：
(1)远程（Remote）代理：为一个位于不同的地址空间的对象提供一个局域代表对象。这个不同的地址空间可以是在本机器中，也可是在另一台机器中。远程代理又叫做大使（Ambassador）。
(2)虚拟（Virtual）代理：根据需要创建一个资源消耗较大的对象，使得此对象只在需要时才会被真正创建。
(3)Copy-on-Write代理：虚拟代理的一种。把复制（克隆）拖延到只有在客户端需要时，才真正采取行动。
(4)保护（Protect or Access）代理：控制对一个对象的访问，如果需要，可以给不同的用户提供不同级别的使用权限。
(5)Cache代理：为某一个目标操作的结果提供临时的存储空间，以便多个客户端可以共享这些结果。
(6)防火墙（Firewall）代理：保护目标，不让恶意用户接近。
(7)同步化（Synchronization）代理：使几个用户能够同时使用一个对象而没有冲突。
(8)智能引用（Smart Reference）代理：当一个对象被引用时，提供一些额外的操作，比如将对此对象调用的次数记录下来等。
在所有种类的代理模式中，虚拟（Virtual）代理、远程（Remote）代理、智能引用代理（Smart Reference Proxy）和保护（Protect or Access）代理是最为常见的代理模式。Proxy-要用再建立Proxy-要用再建立抽象主题角色（Subject）：声明了真实主题和代理主题的共同接口，这样一来在任何使用真实主题的地方都可以使用代理主题。
代理主题（Proxy）角色：代理主题角色内部含有对真是主题的引用，从而可以在任何时候操作真实主题对象；代理主题角色提供一个与真实主题角色相同的接口，以便可以在任何时候都可以替代真实主体；控制真实主题的应用，负责在需要的时候创建真实主题对象（和删除真实主题对象）；代理角色通常在将客户端调用传递给真实的主题之前或之后，都要执行某个操作，而不是单纯的将调用传递给真实主题对象。
真实主题角色（RealSubject）角色：定义了代理角色所代表的真实对象。Proxy-要用再建立Proxy-代码public abstract class Subject { // Methods abstract public void Request(); } public class RealSubject extends Subject { // Methods public void Request() { System.out.println("Called RealSubject.Request()"); } } public class Proxy extends Subject { // Fields RealSubject realSubject; // Methods public void Request() { // Uses “lazy initialization“要用再建立 if( realSubject == null ) realSubject = new RealSubject(); preRequest(); realSubject.Request(); postRequest(); } public void preRequest() { System.out.println("PreRequest."); } public void postRequest() { System.out.println("PostRequest."); } } Proxy-代码Proxy－代码public class Client { public static void Main( string[] args ) { // Create proxy and request a service Proxy p = new Proxy(); p.Request(); } } Proxy－代码结构模式结构模式享元模式-有相同的部分就“共享”Flyweight在拳击比赛中指最轻量级，即“蝇量级”，有些作者翻译为“羽量级”。
享元模式以共享的方式高效地支持大量的细粒度对象。享元对象能做到共享的关键是区分内蕴状态（Internal State）和外蕴状态（External State）。内蕴状态是存储在享元对象内部并且不会随环境改变而改变。因此内蕴状态并可以共享。
外蕴状态是随环境改变而改变的、不可以共享的状态。享元对象的外蕴状态必须由客户端保存，并在享元对象被创建之后，在需要使用的时候再传入到享元对象内部。外蕴状态与内蕴状态是相互独立的。享元模式在编辑器系统中大量使用。一个文本编辑器往往会提供很多种字体，而通常的做法就是将每一个字母做成一个享元对象。享元对象的内蕴状态就是这个字母，而字母在文本中的位置和字模风格等其他信息则是外蕴状态。比如，字母a可能出现在文本的很多地方，虽然这些字母a的位置和字模风格不同，但是所有这些地方使用的都是同一个字母对象。这样一来，字母对象就可以在整个系统中共享。享元模式-有相同的部分就“共享”单纯享元模式 单纯享元模式 在单纯享元模式中，所有的享元对象都是可以共享的。 抽象享元(Flyweight)角色：此角色是所有的具体享元类的超类，为这些类规定出需要实现的公共接口。那些需要外蕴状态(External State)的操作可以通过调用商业方法以参数形式传入。
具体享元(ConcreteFlyweight)角色：实现抽象享元角色所规定的接口。如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。享元对象的内蕴状态必须与对象所处的周围环境无关，从而使得享元对象可以在系统内共享的。
享元工厂(FlyweightFactory)角色：本角色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候，享元工厂角色会检查系统中是否已经有一个复合要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个合适的享元对象。
客户端(Client)角色：本角色需要维护一个对所有享元对象的引用。本角色需要自行存储所有享元对象的外蕴状态。享元模式-代码public class FlyweightFactory { // Fields private HashMap flyweights = new HashMap(); // Constructors public FlyweightFactory() { flyweights.put("X", new ConcreteFlyweight()); flyweights.put("Y", new ConcreteFlyweight()); flyweights.put("Z", new ConcreteFlyweight()); } // Methods public Flyweight GetFlyweight(string key) { return (Flyweight)flyweights.get( key ); } }public abstract class Flyweight { // Methods public abstract void Operation( int extrinsicstate ); } public class ConcreteFlyweight extends Flyweight { private string intrinsicstate = "A"; // Methods public void Operation( int extrinsicstate ) { System.out.println(intrinsicstate.toString())
System.out.println(extrinsicstate.toString() ); } }享元模式-代码nullpublic class Client { public static void main( String[] args ) { // Arbitrary extrisic state int[ ] extrinsicstate = {21,22,23,24,25}; FlyweightFactory f = new FlyweightFactory(); // Work with different flyweight instances Flyweight fx1 = f.GetFlyweight("X"); fx.Operation( extrinsicstate [0]);
Flyweight fx2 = f.GetFlyweight("X"); fx.Operation( extrinsicstate [3]);
Flyweight fy = f.GetFlyweight("Y"); fy.Operation( extrinsicstate[1] ); Flyweight fz = f.GetFlyweight("Z"); fz.Operation( extrinsicstate[2] ); } }复合享元模式的结构 复合享元模式的结构 将一些单纯享元使用合成模式加以复合，形成复合享元对象。这样的复合享元对象本身不能共享，但是它们可以分解成单纯享元对象，而后者则可以共享。 抽象享元角色：此角色是所有的具体享元类的超类，为这些类规定出需要实现的公共接口。那些需要外蕴状态(External State)的操作可以通过方法的参数传入。抽象享元的接口使得享元变得可能，但是并不强制子类实行共享，因此并非所有的享元对象都是可以共享的。
具体享元(ConcreteFlyweight)角色：实现抽象享元角色所规定的接口。如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。享元对象的内蕴状态必须与对象所处的周围环境无关，从而使得享元对象可以在系统内共享。有时候具体享元角色又叫做单纯具体享元角色，因为复合享元角色是由单纯具体享元角色通过复合而成的。
复合享元(UnsharableFlyweig
浙公网安备 33021202002483