7_Java常用设计模式.pdf

上传人:asd****56 文档编号:69681367 上传时间:2023-01-07 格式:PDF 页数:63 大小:3.47MB
返回 下载 相关 举报
7_Java常用设计模式.pdf_第1页
第1页 / 共63页
7_Java常用设计模式.pdf_第2页
第2页 / 共63页
点击查看更多>>
资源描述

《7_Java常用设计模式.pdf》由会员分享,可在线阅读,更多相关《7_Java常用设计模式.pdf(63页珍藏版)》请在taowenge.com淘文阁网|工程机械CAD图纸|机械工程制图|CAD装配图下载|SolidWorks_CaTia_CAD_UG_PROE_设计图分享下载上搜索。

1、Java与设计模式Lesson 1设计模式分类创建模式结构模式行为模式优点面向接口编程降低耦合性增加灵活性创创建模式建模式设计模式之Factory-工厂模式客户类和工厂类分开。消费者任何时候需要某种产品,只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时,工厂类也要做相应的修改。设计模式之Factory-工厂模式 public class Factory public static Sample creator(int which)if(which=1)return new SampleA();else if(which=2)return new SampleB();pub

2、lic class SampleA extends Sample public class SampleB extends Sample 如果要实例化Sample时.就使用 Sample a=Factory.creator(1);/instance of SampleA Sample b=Factory.creator(2);/instance of SampleB public class Factory public static Sample creator(String className)/getClass 产生Sample 一般可使用动态类装载装入类。Class c=Class.f

3、orName(className);return(Sample)c.newInstance();如何调用Builder模式:Sample a=Factory.creator(“SampleA”);/instance of SampleA Sample b=Factory.creator(“SampleB”);/instance of SampleB设计模式之FACTORY METHOD-工厂方法模式核心工厂类不再负责所有产品的创建,而是将具体创建的工作交给子类去做,成为一个抽象工厂角色,仅负责给出具体工厂类必须实现的接口,而不接触哪一个产品类应当被实例化这种细节。设计模式之FACTORY ME

4、THOD 工厂模式 public abstract class Factory public abstract Sample creator();public abstract Sample2 creator(String name);public class SimpleFactory extends Factorypublic Sample creator()return new SampleApublic Sample2 creator(String name)return new Sample2A public class BombFactory extends Factorypubl

5、ic Sample creator().return new SampleB public Sample2 creator(String name)return new Sample2B 設計模式之Builder-建造模式将产品的内部表象和产品的生成过程分割开来,从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化,客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。設計模式之Builder-建造模式public interface Builder void buildPartA();/創建部件A比如創建汽車車輪void buil

6、dPartB();/創建部件B 比如創建汽車方向盤void buildPartC();/創建部件C 比如創建汽車發動機/返回最後組裝成品結果(返回最後裝配好的汽車)/成品的組裝過程不在這裏進行,而是轉移到下面的Director類別中進行。/從而實現解耦Product getResult();public class Director private Builder builder;public Director(Builder builder)this.sbuilder=builder;public void construct()/將部件partA partB partC最後組成複雜物件bu

7、ilder.buildPartA();builder.buildPartB();builder.buildPartC();Product getResult()return builder.getResult();public class ConcreteBuilder implements Builder Part partA,partB,partC;public void buildPartA()/这里是具体如何构建partA的代码 public void buildPartB()/这里是具体如何构建partB的代码public void buildPartC()/这里是具体如何构建par

8、tB的代码 public Product getResult()/返回最后组装成品结果 如何调用Builder模式:Builder builder=new ConcreteBuilder();Director director=new Director(builder);director.construct();Product product=builder.getResult();設計模式之PROTOTYPE-原始模型模式通过给出一个原型对象来指明所要创建的对象的类型,然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减少产品类,产品类不需要非得有任何事先确定的

9、等级结构,原始模型模式适用于任何的等级结构。缺点是每一个类都必须配备一个克隆方法。設計模式之PROTOTYPE-原始模型模式 public abstract class AbstractSpoon implements Cloneable String spoonName;public void setSpoonName(String spoonName)this.spoonName=spoonName;public String getSpoonName()return this.spoonName;public Object clone()Object object=null;try ob

10、ject=spoonName.clone();catch(CloneNotSupportedException exception)System.err.println(AbstractSpoon is not Cloneable);return object;public class SoupSpoon extends AbstractSpoon public SoupSpoon()setSpoonName(Soup Spoon);public class SaladSpoon extends AbstractSpoon public SaladSpoon()setSpoonName(Sal

11、ad Spoon);调用Prototype模式很简单:AbstractSpoon spoon1=new SoupSpoon();String s1=(String)spoon1.clone();AbstractSpoon spoon2=new SaladSpoon();String s2=(String)spoon2.clone();当然也可以结合工厂模式来创建AbstractSpoon实例设计模式之Singleton-单例模式单例模式确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例单例模式。单例模式只应在有真正的“单一实例”的需求时才可使用。设计模式之Singleton-单例

12、模式 public class Singleton private Singleton()private static Singleton instance=null;public static synchronized Singleton getInstance()/不用每次都进行生成对象,只是第一次使用时生成实例,提高了效率!if(instance=null)instancenew Singleton();return instance;Singleton s=Singleton.getInstance();結構模式結構模式設計模式之Adapter-适配器把一个类的接口变换成客户端所期待的

13、另一种接口,从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。适配类可以根据参数返还一个合适的实例给客户端。設計模式之Adapter-适配器public interface IRoundPegpublic void insertIntoHole(String msg);public interface ISquarePegpublic void insert(String str);public class PegAdapter implements IRoundPeg,ISquarePegprivate IRoundPeg roundPeg;private ISquarePeg

14、squarePeg;/構造方法public PegAdapter(IRoundPeg peg)this.roundPeg=peg;public PegAdapter(ISquarePeg peg)(this.squarePeg=peg;)/方法public void insert(String str)roundPeg.insertIntoHole(str);public void insertIntoHole(String str)SquarePeg.insert(str);設計模式之Bridge-桥梁模式将抽象化与实现化脱耦,使得二者可以独立的变化,也就是说将他们之间的强关联变成弱关联,也

15、就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系,从而使两者可以独立的变化。設計模式之Bridge-桥梁模式public abstract class CoffeeCoffeeImp coffeeImp;public void setCoffeeImp()this.CoffeeImp=CoffeeImpSingleton.getTheCoffeImp();public CoffeeImp getCoffeeImp()return this.CoffeeImp;public abstract void pourCoffee();public abstract class

16、CoffeeImppublic abstract void pourCoffeeImp();/bridgepublic class CoffeeImpSingletonprivate static CoffeeImp coffeeImp;public CoffeeImpSingleton(CoffeeImp coffeeImpIn)this.coffeeImp=coffeeImpIn;public static CoffeeImp getTheCoffeeImp()return coffeeImp;/中杯public class MediumCoffee extends Coffeepubli

17、c MediumCoffee()setCoffeeImp();public void pourCoffee()CoffeeImp coffeeImp=this.getCoffeeImp();for(int i=0;i 2;i+)coffeeImp.pourCoffeeImp();/大杯public class SuperSizeCoffee extends Coffeepublic SuperSizeCoffee()setCoffeeImp();public void pourCoffee()CoffeeImp coffeeImp=this.getCoffeeImp();for(int i=0

18、;i 5;i+)coffeeImp.pourCoffeeImp();/加奶public class MilkCoffeeImp extends CoffeeImpMilkCoffeeImp()public void pourCoffeeImp()System.out.println(加了美味的牛奶);/不加奶public class FragrantCoffeeImp extends CoffeeImpFragrantCoffeeImp()public void pourCoffeeImp()System.out.println(什么也没加,清香);看看中杯加奶 和大杯加奶 是怎么出来的:动态

19、结合,我们现在可以喝到至少四种咖啡:1.中杯加奶2.中杯不加奶3.大杯加奶4.大杯不加奶/拿出牛奶CoffeeImpSingleton coffeeImpSingleton=new CoffeeImpSingleton(new MilkCoffeeImp();/中杯加奶MediumCoffee mediumCoffee=new MediumCoffee();mediumCoffee.pourCoffee();/大杯加奶SuperSizeCoffee superSizeCoffee=new SuperSizeCoffee();superSizeCoffee.pourCoffee();注意:Bri

20、dge模式的执行类如CoffeeImp和Coffee是一对一的关系,正确创建CoffeeImp是该模式的关键,設計模式之Composite-合成模式合成模式将对象组织到树结构中,可以用来描述整体与部分的关系。合成模式就是一个处理对象的树结构的模式。合成模式把部分与整体的关系用树结构表示出来。合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。設計模式之Composite-合成模式 public abstract class Equipmentprivate String name;public Equipment(final String name)this.name=

21、name;public abstract double netPrice();/網路價格public abstract double discountPrice();/折扣價格/增加部件方法public boolean add(Equipment equipment)return false;/刪除部件方法public boolean remove(Equipment equipment)return false;/注意,這裏就提供一種用於訪問組合體類別的部件方法。public Iterator iter()return null;public class Disk extends Equip

22、mentpublic Disk(String name)super(name);public double netPrice()return 1.;/定义Disk网络价格为1public double discountPrice()return.5;/定义了disk折扣价格是0.5 对折。abstract class CompositeEquipment extends Equipmentprivate int i=0;/定义一个ArrayList用来存放儿子instanceprivate List equipments=new ArrayList();public CompositeEqui

23、pment(String name)super(name);public boolean add(Equipment equipment)this.equipments.add(equipment);return true;public double discountPrice()double discountPrice=0.;Iterator iter=equipments.iterator();for(iter.hasNext()public double netPrice()double netPrice=0.;Iterator iter=equipments.iterator();fo

24、r(iter.hasNext()netPrice+=(Equipment)iter.next().netPrice();return netPrice;discountPrice+=(Equipment)iter.next().discountPrice();return discountPrice;public class Chassis extends CompositeEquipmentpublic Chassis(String name)super(name);public double netPrice()return 1.+Price();public double discoun

25、tPrice()return.5+super.discountPrice();public class Cabinet extends CompositeEquipmentpublic Cabinet(String name)super(name);public double netPrice()return 1.+Price();public double discountPrice()return.5+super.discountPrice();客户端调用Composote代码:Chassis chassis=new Chassis(PC Chassis);chassis.add(new

26、Disk(10 GB);/将硬盘装到盘盒里 Cabinet cabinet=new Cabinet(Tower);cabinet.add(chassis);/将盘盒装到箱子里/调用 netPrice()方法;System.out.println(netPrice=+Price();System.out.println(discountPrice=+cabinet.discountPrice();設計模式之DECORATOR-装饰模式装饰模式以对客户端透明的方式扩展对象的功能,是继承关系的一个替代方案,提供比继承更多的灵活性。动态给一个对象增加功能,这些功能可以再动态的撤消。增加由一些基本功能的

27、排列组合而产生的非常大量的功能。設計模式之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;/核心功能private ArrayList others=new ArrayList();/額外增加的功能被打包在這個List中/在構造器中使用組合

28、new方式,引入Work物件;public Decorator(Work work)this.work=work;others.add(挖坑);others.add(釘木板);/在新方法中,我們在insert之前增加其他方法,這裏次序先後是用戶靈活指定的public void insert()otherMethod();work.insert();public void otherMethod()ListIterator listIterator=others.listIterator();while(listIterator.hasNext()System.out.println(Strin

29、g)(listIterator.next()+正在進行);如何调用:Work squarePeg=new SquarePeg();Work decorator=new Decorator(squarePeg);decorator.insert();为什么使用为什么使用Decorator?我们通常可以使用继承来实现功能的拓展,如果这些需要拓展的功能的种类很繁多,那么势必生成很多子类,增加系统的复杂性,同时,使用继承实现功能拓展,我们必须可预见这些拓展功能,这些功能是编译时就确定了,是静态的.使用使用Decorator的理由的理由:这些功能需要由用户动态决定加入的方式和时机.Decorator提供

30、了即插即用的方法,在运行期间决定何时增加何种功能.設計模式之Facade-门面模式外部与一个子系统的通信必须通过一个统一的门面对象进行。门面模式提供一个高层次的接口,使得子系统更易于使用。每一个子系统只有一个门面类,而且此门面类只有一个实例,也就是说它是一个单例模式。但整个系统可以有多个门面类。設計模式之Facade-门面模式 public class DBCompare String sql=“SELECT*FROM WHERE =?”;try MyDB msql=new MyDB(sql);/Facade PreparedStatement prep=msql.getPreparedSta

31、tement();prep.setString(1,);ResultSet rset=prep.executeQuery();if(rset.next()System.out.println(rset.getString(column name);catch(SException e)e.printStackTrace();finally mysql.close();mysql=null;設計模式之FLYWEIGHT-享元模式 FLYWEIGHT在拳击比赛中指最轻量级。享元模式以共享的方式高效的支持大量的细粒度对象。享元模式能做到共享的关键是区分内蕴状态和外蕴状态。内蕴状态存储在享元内部,不会

32、随环境的改变而有所不同。外蕴状态是随环境的改变而改变的。外蕴状态不能影响内蕴状态,它们是相互独立的。将可以共享的状态和不可以共享的状态从常规类中区分开来,将不可以共享的状态从类里剔除出去。客户端不可以直接创建被共享的对象,而应当使用一个工厂对象负责创建被共享的对象。享元模式大幅度的降低内存中对象的数量。避免大量拥有相同内容的小类的开销(如耗费内存),使大家共享一个类(元类).設計模式之FLYWEIGHT-享元模式 public class CD private String title;private int year;private Artist artist;public String g

33、etTitle()return title;public int getYear()return year;public Artist getArtist()return artist;public void setTitle(String t)title=t;public void setYear(int y)year=y;public void setArtist(Artist a)artist=a;public class Artist private String name;/內部狀態public Artist(String n)name=n;String getName()retur

34、n name;/note that Artist is immutable.Flyweight factory负责维护一个Flyweight池(存放内部状态),当客户端请求一个共享Flyweight时,这个factory首先搜索池中是否已经有可适用的,如果有,factory只是简单返回送出这个对象,否则,创建一个新的对象,加入到池中,再返回送出这个对象池.Flyweight模式是一个提高程序效率和性能的模式,会大大加快程序的运行速度.应用场合很多:比如你要从一个数据库中读取一系列字符串,这些字符串中有许多是重复的,那么我们可以将这些字符串储存在Flyweight池(pool)中.public

35、class ArtistFactory Hashtable pool=new Hashtable();public static Artist getArtist(String key)Artist result;result=(Artist)pool.get(key);/産生新的Artistif(result=null)result=new Artist(key);pool.put(key,result);return result;設計模式之PROXY-代理模式 代理模式给某一个对象提供一个代理对象,并由代理对象控制对源对象的引用。代理就是一个人或一个机构代表另一个人或者一个机构采取行动。

36、某些情况下,客户不想或者不能够直接引用一个对象,代理对象可以在客户和目标对象直接起到中介的作用。客户端分辨不出代理主题对象与真实主题对象。代理模式可以并不知道真正的被代理对象,而仅仅持有一个被代理对象的接口,这时候代理对象不能够创建被代理对象,被代理对象必须有系统的其他角色代为创建并传入。設計模式之PROXY-代理模式public class ForumPermissions implements Cacheable public class ForumProxy implements Forum public class DbForum implements Forum,Cacheable

37、行为模式設計模式之Chain of Responsibility-職責鏈在责任链模式中,很多对象由每一个对象对其下家的引用而接 起来形成一条链。请求在这个链上传递,直到链上的某一个对象决定处理此请求。客户并不知道链上的哪一个对象最终处理这个请求,系统可以在不影响客户端的情况下动态的重新组织链和分配责任。处理者有两个选择:承担责任或者把责任推给下家。一个请求可以最终不被任何接收端对象所接受。設計模式之Chain of Responsibility 職責鏈public interface Handlerpublic void handleRequest(Request request);publi

38、c class Requestprivate String type;public Request(String type)this.type=type;public String getType()return type;public void execute()/request真正具體行爲代碼public class ConcreteHandler implements Handlerprivate Handler successor;public ConcreteHandler(Handler successor)this.successor=successor;public void

39、handleRequest(Request request)if(request instanceof HelpRequest)request.execute();/這裏是處理HelpRequest的具體代碼else if(request instanceof PrintRequest)request.execute();/這裏是處理PrintRequst的具體代碼elsesuccessor.handleRequest(request);/傳遞到下一個設計模式之COMMAND-命令模式命令模式把一个请求或者操作封装到一个对象中。命令模式把发出命令的责任和执行命令的责任分割开,委派给不同的对象。

40、命令模式允许请求的一方和发送的一方独立开来,使得请求的一方不必知道接收请求的一方的接口,更不必知道请求是怎么被接收,以及操作是否执行,何时被执行以及是怎么被执行的。系统支持命令的撤消。設計模式之COMMAND-命令模式public interface Command public abstract void execute();public class Producerpublic static List produceRequests()List queue=new ArrayList();queue.add(new Engineer();queue.add(new Politician()

41、;queue.add(new Programmer();return queue;public class Engineer implements Command public void execute()/do Engineers command public class Programmer implements Command public void execute()/do programmers command public class Politician implements Command public void execute()/do Politicians command

42、 具体的Command模式代码各式各样,因为如何封装命令,不同系统,有不同的做法.下面事例是将命令封装在一个Collection的List中,任何对象一旦加入List中,实际上装入了一个封闭的黑盒中,对象的特性消失了,只有取出时,才有可能模糊的分辨出:public class TestCommand public static void main(String args)List queue=Producer.produceRequests();for(Iterator it=queue.iterator();it.hasNext();)(Command)it.next().execute()

43、;由此可见,调用者基本只和接口打交道,不和具体实现交互,这也体现了一个原则,面向接口编程,这样,以后增加第四个具体命令时,就不必修改调用者TestCommand中的代码了.設計模式之INTERPRETER-解释器模式 给定一个语言后,解释器模式可以定义出其文法的一种表示,并同时提供一个解释器。客户端可以使用这个解释器来解释这个语言中的句子。解释器模式将描述怎样在有了一个简单的文法后,使用模式设计解释这些语句。在解释器模式里面提到的语言是指任何解释器对象能够解释的任何组合。在解释器模式中需要定义一个代表文法的命令类的等级结构,也就是一系列的组合规则。每一个命令对象都有一个解释方法,代表对命令对象

44、的解释。命令对象的等级结构中的对象的任何排列组合都是一个语言。設計模式之INTERPRETER-解释器模式定義語言的文法,並且建立一個解釋器來解釋該語言中的句子。設計模式之ITERATOR-迭代子模式迭代子模式可以顺序访问一个聚集中的元素而不必暴露聚集的内部表象。多个对象聚在一起形成的总体称之为聚集,聚集对象是能够包容一组对象的容器对象。迭代子模式将迭代逻辑封装到一个独立的子对象中,从而与聚集本身隔开。迭代子模式简化了聚集的界面。每一个聚集对象都可以有一个或一个以上的迭代子对象,每一个迭代子的迭代状态可以是彼此独立的。迭代算法可以独立于聚集角色变化。設計模式之ITERATOR-迭代子模式 用來

45、遍曆Collection中对象 public class TestCommand public static void main(String args)List queue=Producer.produceRequests();for(Iterator it=queue.iterator();it.hasNext();)/取出List中对象,其他特徵都不能確定,只能保證一個特徵是100%正確,他們至少是Command的兒子。所以強制轉換類別型爲Command(Command)it.next().execute();設計模式之MEDIATOR-调停者模式 调停者模式包装了一系列对象相互作用的方

46、式,使得这些对象不必相互明显作用。从而使他们可以松散偶合。当某些对象之间的作用发生改变时,不会立即影响其他的一些对象之间的作用。保证这些作用可以彼此独立的变化。调停者模式将多对多的相互作用转化为一对多的相互作用。调停者模式将对象的行为和协作抽象化,把对象在小尺度的行为上与其他对象的相互作用分开处理。設計模式之MEDIATOR-调停者模式 public interface Mediator public class ConcreteMediator implements Mediator /假設當前有兩個成員.private ConcreteColleague1 colleague1=new C

47、oncreteColleague1();private ConcreteColleague2 colleague2=new ConcreteColleague2();.public class Colleague private Mediator mediator;public Mediator getMediator()return mediator;public void setMediator(Mediator mediator)this.mediator=mediator;public class ConcreteColleague1 public class ConcreteColl

48、eague2 設計模式之MEMENTO-备忘录模式备忘录对象是一个用来存储另外一个对象内部状态的快照的对象。备忘录模式的用意是在不破坏封装的条件下,将一个对象的状态捉住,并外部化,存储起来,从而可以在将来合适的时候把这个对象还原到存储起来的状态。設計模式之MEMENTO-备忘录模式public class Originator private int number;private File file=null;public Originator()/創建一個Mementopublic Memento getMemento()return new Memento(this);/恢復到原始值pub

49、lic void setMemento(Memento m)number=m.number;file=m.file;private class Memento implements java.io.Serializable private int number;private File file=null;public Memento(Originator o)number=o.number;file=o.file;設計模式之OBSERVER-观察者模式观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时,会通知所有观察者对象,使他们能够

50、自动更新自己。設計模式之OBSERVER-观察者模式public class product extends Observable private String name;private float price;public String getName()return name;public void setName()this.name=name;/設置變化點setChanged();notifyObservers(name);public class NameObserver implements Observer private String name=null;public void

展开阅读全文
相关资源
相关搜索

当前位置:首页 > 应用文书 > 财经金融

本站为文档C TO C交易模式,本站只提供存储空间、用户上传的文档直接被用户下载,本站只是中间服务平台,本站所有文档下载所得的收益归上传人(含作者)所有。本站仅对用户上传内容的表现方式做保护处理,对上载内容本身不做任何修改或编辑。若文档所含内容侵犯了您的版权或隐私,请立即通知淘文阁网,我们立即给予删除!客服QQ:136780468 微信:18945177775 电话:18904686070

工信部备案号:黑ICP备15003705号© 2020-2023 www.taowenge.com 淘文阁