《Java与模式》读后记.docx
《《Java与模式》读后记.docx》由会员分享，可在线阅读，更多相关《《Java与模式》读后记.docx（17页珍藏版）》请在冰豆网上搜索。
《Java与模式》读后记
《Java与模式》读后记
类图中的关系：
1.一般化关系普通的继承关系
（单向的）
2.关联关系如：
在类A中有类B这个类型的成员变量（属性）；类A与类B是平等的；使用一根直线连接；可以是单向，也可以是双向的。
（双向的，可以使用两个箭头，也可以一个也不用）。
3.聚合关系体现整体与部分的关系，如：
在类A中有类B这个类型的成员变量（属性）；类A与类B是不同层次的；只能是单向。
（连线的起始点上有一个空心圈）
4.合成关系体现整体与部分的关系，且整体负责部分的生命周期，如：
在类A中有类B这个类型的成员变量；类A与类B是不同层次的；只能是单向。
（连线的起始点上有一个实心圈），不能共享。
5.依赖关系如：
在类A中要使用类B这个类型的临时变量或参数变量或类B中的静态函数，表示类A依赖于类B；只能是单向的。
UML建模工具：
Together可以画图，可以生成代码
RationalRose可以画图，可以生成部分代码
Visio只能画图
导致一个软件设计的可维护性较低，并随着要求的变化而“腐烂”的原因：
过于僵硬，过于脆弱，复用率低，黏度过高
遵循以下原则，可以有效地提高系统的复用性、可维护性：
开闭原则（Open-ClosedPrinciple）：
一个软件实体应当对修改关闭，而对扩展开放。
里氏代换原则（LiskovSubsitituionPrinciple）：
任何基类可以出现的地方，子类一定可以出现。
依赖倒转原则（DependencyInversionPrinciple）：
要依赖于抽象，不要依赖于实现。
合成/聚合复用原则（Composition/AggregationPrinciple）：
要尽量使用合成/聚合，而不是使用继承关系来达到复用的目的。
迪米特法则（LawofDemeter）：
一个软件实体应当与尽可能少的其它实体发生相互作用。
（只与接口发生相互作用，而不与具体类。
）
接口隔离原则（InterfaceSegregationPrinciple）：
应当为客户端提供尽可能小的单独的接口，而不要提供大的总接口。
开闭原则的关键是“抽象”，将可变的因素封装起来（即抽象出来），然后由各个具体的子类来实现。
模式分为：
架构模式、设计模式、代码模式。
架构模式：
是一个系统的最高层次策略，确定整体性质、整体目标、整体实现方式的规划等。
（如：
MVC模式）
设计模式：
是中等尺度的结构策略，确定一些组件的结构、行为、相互配合关系等。
代码模式：
是特定范围的代码设计规范、实现方式、编程技巧等。
设计模式可以划分为：
创建模式、结构模式、行为模式。
创建模式：
---------------------------------------------------------------------------------------------------------------------------
1.简单工厂模式:
又称为静态工厂模式，是一种“创建模式”，是一个工厂对象根据参数决定创建哪一种产品对象的实例。
将大量有共同接口的类实例化。
抽象产品类可以是接口，也可以是抽象类；一般情况下，如果各产品之间有共同的特性，则应该使用抽象类来充当抽象产品角色。
有三个角色：
工厂、抽象产品、产品。
有些情况下，工厂类与抽象产品类可以合并。
缺点：
要扩展子类时，需要修改工厂类。
此模式只能在有限的程度上支持“开闭原则”（对客户而言是支持的，对工厂而言是不支持的）。
2.工厂方法模式:
是一种“创建模式”，是虚拟构造子模式，或多态性工厂模式。
是简单工厂模式的进一步的抽象和推广，即保留了简单工厂模式的优点，
但克服了简单工厂模式的缺点，即将具体创建的工作交给子类去做，而工厂类只是一个抽象类，只给出如何做的接口。
有四个角色：
抽象工厂、具体工厂、抽象产品、具体产品。
特点：
要扩展子类时，需要创建具体工厂类和具体产品类。
其核心是抽象工厂类（简单工厂模式的核心是具体工厂类）。
对于客户是支持“开闭原则”的，对于抽象工厂也是支持的。
总之，对于增加新产品而言，此模式是完全支持“开闭原则”的。
3.抽象工厂模式：
是一种“创建模式”，与工厂方法模式最大的区别在于，工厂方法模式针对的是一个产品等级结构，而抽象工厂模式针对的是多个产品等级结构。
有四个角色：
抽象工厂、具体工厂、抽象产品、具体产品。
其中，具体工厂类含有选择合适的产品对象的逻辑。
一般而言，有多少个产品等级结构，有会在工厂角色中发现多少个工厂方法。
每一个产品等级结构中有多少个具体产品，就会有多少个产品族。
也就会在产品等级结构中发现多少个具体工厂。
当不变更或增加产品等级结构时，如果要扩展产品族，则要增加“新的产品族的具体工厂类”、“本产品族的每一个产品等级结构的具体产品类”。
这种情况是支持“开闭原则”的；
而如果要变更或增加产品等级结构（增加产品），则需要修改抽象工厂类及所有的工厂角色，这种情况是不支持“开闭原则”的。
注意：
具体工厂类可以设计成单例模式。
4.单例模式：
要求产品类的构造函数是私有的，也就是不允许客户自己创建一个产品类，而必须是通过工厂（这个工厂可能是产品类自己的一个方法）创建。
换言之，单例模式通过自己的一个静态方法创建自己的实例。
它使用一个静态属性存储自己的实例，工厂方法永远只提供这一个实例。
单例模式从实现方式是分为：
饿汉式（静态成员一开始就初始化）和懒汉式（静态成员在调用实例化类时创建），这两种方式由于构造函数是
私有的，所以此类不能被继承。
不过，如果想要继承单例模式的类，可以将它的构造函数申请为Protected。
一般用于提供工具性的函数类。
双重检查成例：
是一种从C语言移植过来的代码模式。
在C语言中，它常常用在多线程环境中类的晚实例化里。
不过，JAVA中不能使用，因为无法通过编译。
MXRecord：
MailExchangeRecord
JNDI架构：
JavaNamingandDirectoryInterface（Java命名和地址界面）
5.多例模式：
与单例模式的区别是工厂可以产生多个自己的实例，这些实例用一个集聚对象存储。
应用到的地方有：
比如，每个实例可以代表一个状态。
与单例模式一样，也是一种“创建模式”。
6.建造模式：
也是对象的“创建模式”。
建造模式可以将一个对象内部的表象与产品的生产过程分割开来，从而可以使一个产品的建造过程具有不同的内部
表象的对象。
建造模式利用一个导演者对象和具体的建造者对象一个一个地建造出所有的零件（属性或对象），从而建造所完整的对象。
有四个角色：
导演者、抽象建造者、具体建造者、产品。
还可能有抽象产品角色。
导演者角色是与客户端打交道的角色，它将客户端创建产品的请求划分为对各个零件的建造请求，再将这些请示委派给具体建造者角色。
一般来说，每有一个产品类，就会有一个相应的具体建造者类，而此产品的零件数目也就是此具体建造者类建造方法的数目。
对于不需要增加产品零件时，要扩展产品时，需要增加产品类、具体建造者类。
而如果要增加产品零件，则要修改抽象建造者。
在以下二种情况下可以使用建造模式：
1）产品对象有复杂的内部结构（如零件是对象）；
2）产品对象的属性相互依赖，有强制的建造顺序；
3）当产品对象的属性没有确定之前，产品对象不能使用；
例如：
肯德基的食品不管在哪个店，味道总是一样的，这就是因为它将产品的生产过程流程过、规范化，客户只要产品，而不管食品是如何
生产出来的，这就是建造模式，即将创建产品的过程由另一方通过流程化的方式来建造。
7.原始模型模式：
是对象的创建模式。
通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的办法创建出更多同类型的对象。
它有二种表现形式：
1）简单形式；2）登记形式；这二种形式有着不同的实现，对原始模型模式的模式结构的细节的处理也不相同。
1）简单形式：
有三个角色：
客户，抽象原型，具体原型。
2）登记形式：
有四个角色：
客户，抽象原型，具体原型，原型管理器。
扩展新产品时，只需动态地复制原型对象就可以了，只不过要考虑是浅复制还是深复制，如果是浅复制，则直接使用clone方法就可以；
如果是深复制，则原型对象类要实现一个接口Serialization，且此类中的引用对象的原型类都要实现此接口，深复制要深入到多少层
是一个不容易确定的问题，在决定以深复制来复制一个对象的时候，必须确定对间接对象是采用深复制还是浅复制，即要决定深度。
此模式的主要的缺点是：
原型类需要配备克隆方法，配备克隆方法需要对类的功能进行通盘考虑，这对于一个新的类不难，但对于已经
存在的类不是很容易，特别是当一个类引用不支持串行化的对象，或者引用含有聚集或循环结构时。
浅复制：
复制对象的属性，但被复制的对象与复制的对象中的引用属性指向的是同一个引用。
即只复制属性值。
默认用Object.clone（）可以实现；
深复制：
复制对象的属性，并对引用属性重新赋一个有效的新引用。
要实现深复制的类需要实现Serialization接口，并使用对象流进行复制。
串行化：
将一个Java对象串行化只需要实现两个接口中的一个即可：
要么实现Serialization接口，要么实现Externalizable接口。
---------------------------------------------------------------------------------------------------------------------------
结构模式：
描述如何将类或对象结合在一起形成更大的结构。
它描述两种东西：
类、类的实例，所以它分为“类的结构模式”和“对象的结构模式”。
类的结构模式：
使用继承把类、接口等组合在一起。
是静态的。
对象的结构模式：
把不同类型的对象组合在一起，是动态的。
---------------------------------------------------------------------------------------------------------------------------
8.适配器模式：
把一个类的接口变换成客户端所期待的另一种接口，从而使因接口不匹配而无法在一起工作的两个类能够在一起工作。
类的适配器模式：
有三个角色：
目标角色、源角色、适配器角色。
其实就是利用“继承”与“实现”，用适配器角色将源角色适配成目标角色。
对象的适配器模式：
有三个角色：
目标角色、源角色、适配器角色。
使用“委派”而不使用继承与实现，即在适配器类中使用源角色。
此模式应用相当广泛。
9.缺省适配模式：
为一个接口提供缺省实现，这样子类型就可以从这个缺省实现进行扩展，而不必从原有接口进行扩展。
此模式是适配器模式的一个特例。
如：
WindowAdapter。
在任何时候，如果不准备实现一个接口的所有的方法，就可以模仿WindowAdapter的做法制造一个抽象类，给出所有方法的平庸实现，
这样，从这个抽象类再继承下去的子类就不用再实现所有的方法了。
10.合成模式：
又叫做“部分---整体模式”，同时也是一个树结构。
合成模式的实现根据所实现接口的区别分成两种形式，分另称“透明式”和“安全式”。
透明式和安全式的合成模式都有三个角色：
抽象构件、树技构件、树叶构件。
透明式：
在抽象构件类里面声明管理子类对象的方法，如：
add（）,remove（）,getChild（），但在运行时对树叶节点做这些操作时会报错。
安全式：
只在树技构件中声明管理子类对象的方法，运行时不会报错，但树技与树叶没有共同的接口，不够透明。
其实，每一个合成模式的对象都是一个容器对象，本身包含两种对象，一种是普通对象，另一种是可以包含子对象的对象。
例子：
System.Web.UI.Control就是一个合成模式的应用。
11.装饰模式：
又称为包装模式。
装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。
角色有：
抽象构件角色Component、具体构件角色ConcreteComponent、装饰角色Decorator、具体装饰角色ConcreteDecrator。
“具体构件角色”从“抽象构件角色继承”，“装饰角色”从“抽象构件角色”继承，“具体装饰角色”从“装饰角色”继承。
使用时，先定义一个子类对象（ConcreteComponent），再定义一个装饰子类对象（ConcreteDecrator），并传入前一个对象，
Componentcomp=newConcreteComponent（）;
Componentcompnew=newConcreteDecorator（comp）;
compnew.simpleOperation（）;//这里执行被装饰的对象的事件，在此事件中调用了父对象的相关方法，即comp的方法，这就是装饰。
即将“一个ConcreteComponent对象”装饰成“一个ConcreteDecorator对象”，那么compnew这个对象有了ConcreteDecorator的功能，
但这个对象的核心还是一个ConcreteComponent对象，所以compnew还拥有后者的功能，即将原对象功能扩展了在新对象中才有的功能。
装饰模式应用最多的是在Java的I/O库，如InputStream、OutputStream、ByteInputStream、ByteOutputStream、Reader、Writer。
12.代理模式：
给一个对象提供一个代理对象，并由代理对象控制原对象。
其实就是加一个中转站。
好处是：
系统有了客户向原对象提出的请求的控制。
Windows系统的“快捷方式”就是一个代理模式的例子。
角色有：
抽象主题角色、代理主题角色、真实主题角色。
java语言中的java.lang.reflect库中有三个类能直接支持代理模式：
Proxy、InvocationHandler、Method。
13.享元模式：
flyWeight。
享元模式以共享的方式高效地支持大量的细粒度对象。
享元模式能做到共享的关键是区分内蕴状态和外蕴状态。
内蕴状态存储在
享元对象内部，可以共享，不受环境影响；而外蕴状态却受环境影响，不能共享，必须由客户端保存，只在需求的时候才传入享元对象内部。
根据所涉及到的享元对象的内部表象，享元模式分为“单纯享元模式”和“复合享元模式”。
单纯享元模式的角色有：
抽象享元角色、具体享元角色、享元工厂角色、客户端。
复合享元模式的角色有：
抽象享元角色、具体享元角色、复合工厂角色、享元工厂角色、客户端。
此模式的精髓是：
为每一种类型（即内蕴对象）的对象只创建一个实例，而不用每次都创建新的对象，这样实例对象就能在外面实现共享。
在设计一个类时，如果想要它支持享元模式，则要将能共享的状态（可以说是属性）与不能共享的状态区分开，即将不能共享的状态剔除，
那些不能共享的状态可以做为外蕴对象在使用那个类时，做为一个参数传进去。
另外，这个类的创建过程必须由一个工厂对象加以控制，
这个工厂对象应当使用一个列表来保存已经创建出来的对象。
当客户端请求一个新对象进，工厂对象首先检查此列表，看是否已经有一个
同状态的对象。
如果有，则直接返回此对象；如果没有，则创建一个新对象，并将此对象存入列表。
14.门面模式：
外部与一个子系统的通信必须通过一个统一的门面（facade）对象进行。
如：
一个保安系统中控制台，通过控制台可以控制所有保安设备。
角色有：
门面角色，子系统角色。
15.桥梁模式：
又称为柄体（如一个杯子的手柄）模式或接口模式。
图示也像一座桥。
此模式的精髓是：
尽量使用合成/聚合，而不是继承关系来达到扩展系统功能的目的。
目的是“分离抽象化与实现化”。
比抽象工厂模式更好。
如：
有二种飞机，客机和货机，Boeing、Airbus、MD都生产这二种飞机，那么如果客户想要买Airbus的客机或Boeing的货机，是不是
要创建出六个对象才行呢？
如果使用继承来描述，则要设计六个类，且关系是僵化的，用抽象工厂模式可能好一些，但也要创建出六个对象，
而用桥梁模式，则不需要创建六个对象，只需通过合成/聚合的方式就可以办到。
即：
在客机对象中，根据用户传入的条件（应用“简单工厂
模式”），创建出对应的制造商对象，那么在客户端使用时，就可以使用如“Airbus的客机”的对象。
角色有：
抽象化角色，修正抽象化角色，实现化角色，具体实现化角色。
---------------------------------------------------------------------------------------------------------------------------
行为模式：
是对在不同的对象之间划分责任和算法的抽象化。
是关于类和对象的，也是关于它们之间的相互作用的。
分：
类的行为模式和对象的行为模式。
类的行为模式：
使用继承关系在几个类之间分配行为；
对象的行为模式：
使用对象的聚合来分配行为。
---------------------------------------------------------------------------------------------------------------------------
16.不变模式：
一个对象的状态在被创建之后就不再变化，这就是所谓的不变模式。
即一个类的内部状态创建后，在整个生命周期内不会发生变化。
不变模式分为：
弱不变模式、强不变模式（如：
String类、Integer类等就是一个强不变类）。
弱不变模式：
一个类的实例的状态是不可变化的，但这个类的子类的实例具有可能会变化的状态。
（方法与成员变量为私有的）
强不变模式：
一个类的实例的状态是不可变化的，且这个类的子类的实例也具有不可变化的状态。
（类是final的，或所有方法都是final）
实际上，大多数的享元对象是不变对象，但享元对象允许修改它的内蕴对象，修改后，只要享元对象本身还是可以共享的就可以。
17.策略模式：
在一个系统中，如果有一组算法（系统中的一部分），那么就将每一个算法封装起来，让它们有共同的接口，使得它们可以在使用时互换。
角色有：
环境角色，抽象策略角色，具体策略角色。
以下情况可以考虑使用策略模式：
一、如果在一个系统中有很多类，它们之间的区别仅在于它们的行为，那么可以使用策略模式封装它们，使用时选择其一就行。
二、一个系统需要动态地在几种算法中选择一种。
与简单工厂模式不同的是：
具体在使用什么策略类由客户端指定，而不是由一个工厂方法给出。
优点：
一、可用于管理算法族，恰当地使用继承可以将公共的代码移到父类里面，从而避免写重复的代码。
二、可以避免使用多重条件转移语句。
缺点：
一、客户端必须知道所有的具体策略类，并自行决定使用哪一种策略类。
18.模板方法模式：
申明一个抽象类，将部分逻辑以具体方法或构造函数的形式实现，然后申明一些抽象方法来迫使子类实现剩余的逻辑。
模板方法模式是java中最常见的模式之一，如javax.servlet.Servlet及子类就是这个模式的应用。
钩子方法的命名规则是以“do”开头。
19.观察者模式：
又叫做“发布-订阅模式”、“模型-视图模式”、“源-监听器模式”、“从属者模式”。
观察者模式定义一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。
这个主题对象在状态发生改变时，会通知所有的
观察者对象，使它们能够自动更新自己。
最常见的观察者模式的例子是java中的事件监听器。
另外，java.util.Observer接口和java.util.Observable类也支持观察者模式，可以直接应用这二个类来产生自己的观察者模式。
角色有：
抽象主题角色、具体主题角色、抽象观察者角色、具体观察者角色。
在常见的事件处理模型中，对象分为三种：
“事件对象”（从EventObject继承），“事件制造者对象”（即一般的类）及“事件接收者对象”（EventListener）
20.迭代子模式：
此模式又称为：
“游标模式”。
迭代子模式可以顺序地访问一个聚集中的元素，而不必暴露聚集的内部表象。
在Java语言的聚集框架中，广泛地使用迭代子模式来遍历聚集对象，如Iterator接口就是一个迭代器接口。
优点：
迭代子简化了聚集的界面，免将聚集对象直接暴露给用户，且迭代的算法可以独立于聚集角色的变化；
缺点：
迭代子的迭代顺序并不一定就是聚集的元素顺序，且迭代子给出的元素没有类型特征。
21.责任链模式：
在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链，“请求”在这个链上传递，直到链上的某一个或一些对象
来处理此“请求”。
此模式可以在不影响客户端的情况下动态地组织链和分配责任。
如：
游戏“击鼓传花”、“Window系统的事件处理机制”。
角色有：
抽象处理者、具体处理者。
责任链模式分为：
“纯责任链模式”和“不纯的责任链模式”，纯责任链模式就是要求只能且必须由一个处理者处理请求，而不纯的责任链模式
的每一个处理者都可以处理，且只处理一部分，并将请求传递给下一下处理者，或者所有的处理者都不处理请求。
22.命令模式：
又称为“行动模式”或“交易模式”。
命令模式把一个请求或一个操作封装到一个对象中，可以提供命令的撤消（Undo）或恢复（Redo）功能。
命令模式是的命令的封装，它把发出命令的责任和执行命令的责任分割开，委派给不同的对象。
角色有：
客户、命令、请求者、接收者。
java中的例子：
awt中的事件处理机制。
23.备忘录模式：
备忘录对象是一个用来存储另外一个对象内部状态的快照的对象。
此模式常常与命令模式和迭代子模式一起使用。
备忘录的用意是在不破坏封装的条件下，将一个对象的状态捕捉住，并存储起来，从而可以在将来合适的时候将这个对象的状态还原。
角色有：
备忘录角色、发起人角色、负责人角色。
双重接口：
一个类或对象（O）对另外两种类或对象（A、B）分别提供两种不同范围接口，一个宽接口（即A能访问O的所有成员），一个窄接口（即B只能访问
O的公共成员）。
这种方法的实现方法是：
将O写成A的内部类，同时O实现自一个标识接口I，这样A就能访问O的所有成员，而对B只提供接口I，所
以B只能访问I中定义的方法，也就是只能访问O中很少的方法。
24.状态模式：
又称为状态对象模式。
状态模式允许一个对象（环境角色）在其内部状态（内部的状态对象）改变的时候改变其行为（改变为不同的状态对象）。
角色有：
抽象状态角色、具体状态角色、环境角色。
与策略模式的区别在于：
状态模式的环境角色有明显的状态转移，而策略模式的环境角色的状态是不变的。
分派：
根据对象的类型而对方法进行的选择就叫“分派”。
静态分派：
发生在编译时期。
如：
重载时对方法进行选择就是一种静态分派。
动态分派：
发生在运行时期。
根据对象的运行期类型（实际类型）来分派。
如：
子类对父类的一个方法的覆盖就是一种动态分派。
宗量：
一个方法所属的对象叫做方法的接收者，方法的接收者
升级会员 