Java与设计模式.ppt

1、Java与设计模式,面向接口编程、降低耦合性、增加灵活性2008年5月,第 2 页,提纲,第 3 页,创建模式,创建模式,Prototype,第 4 页,创建模式 Factory(工厂模式),客户类和工厂类分开，消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改,第 5 页,创建模式 Factory(工厂模式),追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory。,第 6 页,创

2、建模式 Factory(工厂模式),/抽象的创建对象基类 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 Windo

3、w !“); ,第 7 页,创建模式 Factory(工厂模式),/工厂类 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 testpublic static void main(String arg

4、s) Factory myFactory = new Factory();Window myBigWindow = myFactory.CreateWindow(“Big“);myBigWindow.func();Window mySmallWindow = myFactory.CreateWindow(“Small“);mySmallWindow.func(); ,第 8 页,创建模式 Abstract Factory(抽象工厂模式),核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化

5、这种细节。,第 9 页,创建模式 Abstract Factory(抽象工厂模式),请MM去麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Abstract Factory模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。,第 10 页,创建模式 Abstract Factory(抽象工厂模式),定义两种墙：public abstract class Wall /private Wall wall;public abstract String getName(); public class LivingRoomWall

6、 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; ,第 11 页,创建模式 Abstrac

7、t Factory(抽象工厂模式),/定义两种门： 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 Do

8、or private String doorName;public BedRoomDoor() doorName = “BedRoomDoor“;public String getName() return doorName; ,第 12 页,创建模式 Abstract Factory(抽象工厂模式),/定义两种房间 public abstract class Room /抽象工厂类public abstract Wall makeWall();public abstract Door makeDoor(); public class BedRoom extends Room public B

9、edRoom() 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 LivingRoomD

10、oor();public Wall makeWall() return new LivingRoomWall(); ,第 13 页,创建模式 Abstract Factory(抽象工厂模式),/测试类： 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 Livi

11、ngRoom();public static void main(String args) RoomMaker myMaker = new RoomMaker();/- Create Living RoomRoom myLivingRoom = myMaker.CreateRoom(“LivingRoom“);/- Create a door in living roomDoor livingDoor = myLivingRoom.makeDoor();System.out.println(“Living room door name is:“ + livingDoor.getName() )

12、;/- Create a wall in living roomWall livingWall = myLivingRoom.makeWall();System.out.println(“Living room wall name is:“ + livingWall.getName() );/- Create Bed RoomRoom myBedRoom = myMaker.CreateRoom(“BedRoom“);/- Create a door in bedroomDoor BedDoor = myBedRoom.makeDoor();System.out.println(“Bed ro

13、om door name is:“ + BedDoor.getName() );/- Create a wall in bedroomWall BedWall = myBedRoom.makeWall();System.out.println(“Bed room wall name is:“ + BedWall.getName() ); ,第 14 页,创建模式 Builder(建造模式),将产品、产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同内部表象的产品对象。建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的

14、建造过程。,第 15 页,创建模式 Builder(建造模式),MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞掂，这就是我的“我爱你”builder。（这一定比美军在伊拉克用的翻译机好卖） 。,第 16 页,创建模式 Builder(建造模式),public class House /最终要建造的对象int roomNumber;int doorNumber;public House() roomNumber

15、= 0;doorNumber = 0;public int getRoomNumber() return roomNumber;public int getDoorNumber() return doorNumber; ,第 17 页,创建模式 Builder(建造模式),/ An abstract Builder public abstract class HouseBuilder public abstract void buildRoom(int roomNo);public abstract void buildDoor(int room1, int room2);public abs

16、tract 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 Househouse.roomNumber+;public void buildDoor(int room1, int room2)

17、 / you can create a new door assotiated with 2 room/ and added this door into a househouse.doorNumber+;public House getHouse() return house; ,第 18 页,创建模式 Builder(建造模式),/建造过程 public class HouseDirector public void createHouse(HouseBuilder concreteBuilder) concreteBuilder.buildRoom(1);concreteBuilder.

18、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(

19、);System.out.println(“My house has room :“ + myHouse.getRoomNumber();System.out.println(“My house has door :“ + myHouse.getDoorNumber(); ,第 19 页,创建模式 Prototype (原始模型模式),通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。缺点是每一个类都必须配备一个克隆方法。,第 2

20、0 页,创建模式 Prototype (原始模型模式),跟MM用QQ聊天，一定要说些深情的话语了，我搜集了好多肉麻的情话，需要时只要copy出来放到QQ里面就行了，这就是我的情话prototype了。（100块钱一份，你要不要） 。,第 21 页,创建模式 Prototype (原始模型模式),/原始模型模式接口类 public interface IGraphic extends Cloneable, Serializable public String getName() ;public void setName(String gName); /Prototype抽象类 public ab

21、stract 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;p

22、ublic abstract void DoSomething(); ,第 22 页,创建模式 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 us

23、ed 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; ,第 23 页,创建模式 Prototype (原始模型模式),/测试类 public class

24、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(); ,第 24 页,创建模式 Singleton(单例

25、模式),单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。单例模式只应在有真正的“单一实例”的需求时才可使用。,第 25 页,创建模式 Singleton(单例模式),俺有6个漂亮的老婆，她们的老公都是我，我就是我们家里的老公Singleton，她们只要说道“老公”，都是指的同一个人，那就是我(刚才做了个梦啦，哪有这么好的事) 。,第 26 页,创建模式 Singleton(单例模式),public class Singleton private static Singleton instance = null; /*这个方法有所改进，不用每次都进行生成对象，只

26、是第一次 *使用时生成实例，提高了效率！ */public static synchronized Singleton getInstance() if (instance = null) instance new Singleton(); return instance; ,第 27 页,提纲,第 28 页,结构模式,结构模式,第 29 页,结构模式 Adapter（适配器）,把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。适配类可以根据参数返还一个合适的实例给客户端。,第 30 页,结构模式 Adapter（适配器）,在朋友聚会上

27、碰到了一个美女Sarah，从香港来的，可我不会说粤语，她不会说普通话，只好求助于我的朋友kent了，他作为我和Sarah之间的Adapter，让我和Sarah可以相互交谈了(也不知道他会不会耍我) 。,第 31 页,结构模式 Adapter（适配器）,/The Adaptee in this sample public class Text private String content;public void SetContent(String str) content = str;public String GetContent() return content; /a interface

28、public interface Shape public void Draw();public void Border(); /The Class Adapter in this sample public class TextShapeClass extends Text implements Shape public void Draw() System.out.println(“Draw a shap ! Impelement Shape interface !“);public void Border() System.out.println(“Set the border of t

29、he shap ! Impelement Shape interface !“);public static void main(String args) TextShapeClass myTextShapeClass = new TextShapeClass();myTextShapeClass.Draw();myTextShapeClass.Border();myTextShapeClass.SetContent(“A test text !“);System.out.println(“The content in Text Shape is :“+ myTextShapeClass.Ge

30、tContent(); ,第 32 页,结构模式 Bridge(桥梁模式),将抽象化与实现化脱耦，使得二者可以独立的变化，也就是说将他们之间的强关联变成弱关联，也就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以独立的变化。,第 33 页,结构模式 Bridge(桥梁模式),早上碰到MM，要说早上好，晚上碰到MM，要说晚上好；碰到MM穿了件新衣服，要说你的衣服好漂亮哦，碰到MM新做的发型，要说你的头发好漂亮哦。不要问我“早上碰到MM新做了个发型怎么说”这种问题，自己用Bridge组合一下不就行了,第 34 页,结构模式 Bridge(桥梁模式),publi

31、c interface TextImp public abstract void drawTextImp(); public class TextImpMac implements TextImp public void drawTextImp() System.out.println(“The text has a Mac style !“); public class TextImpLinux implements TextImp public void drawTextImp() System.out.println(“The text has a Linux style !“); ,第

32、 35 页,结构模式 Bridge(桥梁模式),/ The Abstract of Text public abstract class Text public abstract void drawText(String text);protected TextImp getTextImp(String type) if (type.equals(“Mac“) return new TextImpMac(); else if (type.equals(“Linux“) return new TextImpLinux(); else return new TextImpMac(); /The R

33、efinedAbstraction public class TextItalic extends Text private TextImp imp;public TextItalic(String type) imp = getTextImp(type);public void drawText(String text) System.out.println(text);System.out.println(“The text is italic text!“);imp.DrawTextImp(); /The RefinedAbstraction public class TextBold

34、extends Text private TextImp imp;public TextBold(String type) imp = getTextImp(type);public void drawText(String text) System.out.println(text);System.out.println(“The text is bold text!“);imp.DrawTextImp(); ,第 36 页,结构模式 Bridge(桥梁模式),/ test public class Test public static void main(String args) Text

35、 myText = new TextBold(“Mac“);myText.drawText(“= A test String =“);myText = new TextBold(“Linux“);myText.drawText(“= A test String =“);System.out.println(“-“);myText = new TextItalic(“Mac“);myText.drawText(“= A test String =“);myText = new TextItalic(“Linux“);myText.drawText(“= A test String =“); ,第

36、 37 页,结构模式 Composite（合成模式）,合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。合成模式就是一个处理对象的树结构的模式。合成模式把部分与整体的关系用树结构表示出来。合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。,第 38 页,结构模式 Composite（合成模式）,Mary今天过生日“我过生日，你要送我一件礼物。” “嗯，好吧，去商店，你自己挑。” “这件T恤挺漂亮，买，这条裙子好看，买，这个包也不错，买。” “喂，买了三件了呀，我只答应送一件礼物的哦。” “什么呀，T恤加裙子加包包，正好配成一套呀，小姐，麻烦你包起来。” “”

37、，MM都会用Composite模式了，你会了没有？,第 39 页,结构模式 Composite（合成模式）,public class Employee String name;float salary;Vector subordinates;boolean isLeaf;Employee parent = null; public Employee(Employee _parent, String _name, float _salary) name = _name;salary = _salary;parent = _parent;subordinates = new Vector();is

38、Leaf = false; public void setLeaf(boolean b) isLeaf = b; /if true, do not allow children public float getSalary() return salary; public String getName() return name; public boolean add(Employee e) if (! isLeaf) subordinates.addElement(e);return isLeaf; /false if unsuccessfulpublic void remove(Employ

39、ee e) if (! isLeaf) subordinates.removeElement(e);,第 40 页,结构模式 Composite（合成模式）,public Enumeration elements() return subordinates.elements(); public Employee getChild(String s) Employee newEmp = null;if(getName().equals(s) return this; else boolean found = false;Enumeration e = elements();while(e.has

40、MoreElements() ,第 41 页,结构模式 Decorator（装饰模式）,装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案，提供比继承更多的灵活性。动态给一个对象增加功能，这些功能可以再动态的撤消。增加由一些基本功能的排列组合而产生的非常大量的功能。,第 42 页,结构模式 Decorator（装饰模式）,Mary过完轮到Sarly过生日，还是不要叫她自己挑了，不然这个月伙食费肯定玩完，拿出我去年在华山顶上照的照片，在背面写上“最好的的礼物，就是爱你的Fita”，再到街上礼品店买了个像框（卖礼品的MM也很漂亮哦），再找隔壁搞美术设计的Mike设计了一个漂亮的盒

41、子装起来，我们都是Decorator，最终都在修饰我这个人呀，怎么样，看懂了吗？,第 43 页,结构模式 Decorator（装饰模式）,public interface Work public void insert(); public class SquarePeg implements Work public void insert() System.out.println(“方形樁插入“); public class Decorator implements Work private Work work; /額外增加的功能被打包在這個List中 private ArrayList ot

42、hers = new ArrayList(); /在構造器中使用組合new方式,引入Work物件; public Decorator(Work work) this.work=work; others.add(“挖坑“);others.add(“釘木板“); public void insert()newMethod(); /在新方法中,我們在insert之前增加其他方法,這裏次序先後是用戶靈活指定的 public void newMethod() otherMethod(); work.insert(); public void otherMethod() ListIterator list

43、Iterator = others.listIterator(); while (listIterator.hasNext() System.out.println(String)(listIterator.next() + “ 正在進行“); ,第 44 页,结构模式 Facade（门面模式）,外部与一个子系统的通信必须通过一个统一的门面对象进行。门面模式提供一个高层次的接口，使得子系统更易于使用。每一个子系统只有一个门面类，而且此门面类只有一个实例，也就是说它是一个单例模式。但整个系统可以有多个门面类。,第 45 页,结构模式 Facade（门面模式）,我有一个专业的Canon相机，我就喜

44、欢自己手动调光圈、快门，这样照出来的照片才专业，但MM可不懂这些，教了半天也不会。幸好相机有Facade设计模式，把相机调整到自动档，只要对准目标按快门就行了，一切由相机自动调整，这样MM也可以用这个相机给我拍张照片了。,第 46 页,结构模式 Facade（门面模式）,class Wall public Wall() System.out.println(“Create a wall !“); class Door public Door() System.out.println(“Create a door !“); class FacadeRoom public void CreateR

45、oom() Wall wall1 = new Wall();Wall wall2 = new Wall();Wall wall3 = new Wall();Wall wall4 = new Wall();Door door = new Door();public class Test public static void main(String args) FacadeRoom room = new FacadeRoom();room.CreateRoom(); ,第 47 页,结构模式 Flyweight（享元模式）,Flyweight在拳击比赛中指最轻量级。享元模式以共享的方式高效的支持大

46、量的细粒度对象。享元模式能做到共享的关键是区分内蕴状态和外蕴状态。内蕴状态存储在享元内部，不会随环境的改变而有所不同。外蕴状态是随环境的改变而改变的。外蕴状态不能影响内蕴状态，它们是相互独立的。将可以共享的状态和不可以共享的状态从常规类中区分开来，将不可以共享的状态从类里剔除出去。客户端不可以直接创建被共享的对象，而应当使用一个工厂对象负责创建被共享的对象。享元模式大幅度的降低内存中对象的数量。,第 48 页,结构模式 Flyweight（享元模式）,每天跟MM发短信，手指都累死了，最近买了个新手机，可以把一些常用的句子存在手机里，要用的时候，直接拿出来，在前面加上MM的名字就可以发送了，再不

47、用一个字一个字敲了。共享的句子就是Flyweight，MM的名字就是提取出来的外部特征，根据上下文情况使用。,第 49 页,结构模式 Flyweight（享元模式）,/A FlyWeight public interface Font public abstract void setFont(String color, int size);public abstract void getFont(); /A shared ConcreteFlyweight public class ConcreteFont implements Font private String color;privat

48、e int size;private String str;public ConcreteFont(String s) str = s;public void setFont(String _color, int _size) color = _color;size = _size;public void getFont() System.out.println(“String :“ + str + “- color is:“ + color + “- size is:“ + size); /A Flyweight Factory public class FontFactory private Hashtable charHashTable = new Hashtable(); public Font getFlyWeight(String s) if(charHashTable.get(s) != null) return (Font)charHashTable.get(s); else Font tmp = new ConcreteFont(s);charHashTable.put(s, tmp);return tmp;public Hashtable getFactory() return charHashTable; ,