梓晨
胤祥Q寓意： 拥有金钱与权力。）
瑞霖Q寓意： 吉祥的甘霌Ӏ）
明哲Q寓意： 拥有聪明的智慧。）
天翊Q有q天际Q大展宏图之意。）
凯瑞Q寓意： 吉祥 q福 安康 Q?br />健雄Q寓意： w体强健的男子汉。）
耀李ͼ寓意Q?才能Z的英杰。）
潇然Q寓意： 自然׃Q潇z大斏V）
子涵Q取自`子部京涵`寓意Q?拥有光明的前途与博大的胸怀。）
{Q寓意： 博学文雅Q超过厅R）
钰轩Q有气质高贵Q潇z大气之意。）
Q寓意： 拥有辉煌的未来与智慧。）
致远 Q出自诸葛亮的《诫子书》：“非淡泊无以明志,非宁静无以致q”）
俊驰Q出自成语：俊才星驰Q?br />雨泽 (恩惠像雨一样多)
烨磊 Q光明磊落）
晟睿Q“晟”是光明、兴盛的意思，读sh؈ngQ“睿”是智慧的意思）
文昊Q昊的字意是Q广大无边）
修洁Q修QŞ容n材修镉K大，z：整洁Q?br />黎昕 (黎：黎明 昕：明亮的样?)
q航Q好男儿Q就放他去远航吧Q?br />旭尧 (旭：旭日 ：上古时期的贤明君主，后泛指圣?)
鸿涛 (鸿：旺盛,兴盛 )
伟祺 (伟：伟大 ?Q吉?)
荣轩 (轩：气度不凡 )
泽 (泽：q博的水?
宇 Q胸怀犹如宇宙Q浩瀚无IP
瑄 Q出自成语――握瑾怀瑜，比喻拥有好的品P
皓轩 Q意为：光明落Q气宇轩昂）
擎苍 Q顶天立圎ͼ男儿本色Q（宋代诗h苏轼的《江城子`密州出猎》“…左牵黄,x苍…”）
擎宇Q意思同上）
志泽 (泽：q域的水?)
子轩 (轩：气度不凡 )
睿渊 (睿智;学识渊博)
弘文 (弘扬;?文学?
哲?(拥有q大的学?
雨泽 (恩惠)
L (?h;?吉祥)
(建造辉煌成?
晋鹏( 晋：q也Q本义，上进 鹏：比喻前程q大 )
天磊 (：众石累积 )
l辉( l：l承 辉：光辉 )
泽洋 (qK的vz?)
鑫磊 (鑫：财富 )
鹏煊 (煊：光明Q读xuānn )
昊强 (昊：苍天Q苍I?)
伟宸 (宸：古代君王的U?)
博超 (博：博大 ：越 )
君浩 (君：君子 ：大 )
子骞 (骞：高DQ飞?)
鹏涛 (鹏：比喻气势雄伟 )
炎{ (炎：燃烧 彬：形容文雅 )
鹤轩 (鹤：闲云野鹤 轩：气度不凡 )
{ Q{QŞҎ?Q?br />风华 Q风华正?Q?br />靖琪 Q靖Q^?琪：玉 Q?br />明辉 Q辉Q光?Q?br />伟诚 (伟：伟大 诚：诚实 )
明轩 (轩：气度不凡 )
健柏Q?柏：松柏Q是长寿的象征。“健柏”就是健康长寿的意思）
修杰Q修QŞ容n材修镉K大）
志泽 (泽：q域的水?)
弘文 (弘扬,?文学?
ȝ (?高大威猛;?前途一片光?
嘉懿 (?好;?好)
煜城 (照耀城市)
懿轩 (?好;?气宇轩昂)
烨伟 (烨：光耀)
苑博 (博：博学)
伟泽 (伟：伟大 泽：q域的水?
熠T (熠：光耀 彤：U色Q?br />鸿煊 (鸿：大也 煊：光明Q?br />博涛 (博：博学Q?br />烨霖 Q烨Q光明）
烨华 Q烨Q光耀Q?br />煜祺 Q煜Q照耀 ：吉祥Q?br />智宸 (智：智慧 宸：古代君王的Uͼ
正豪 Q豪Q豪气）
昊然 (昊：苍天Q苍I）
明杰 Q明智，杰出Q?br />立诚 Q诚Q诚实）
立轩 Q轩Q气度不凡）
立辉 Q辉Q辉煌）
ȝ (?高大威猛;?前途一片光?
弘文 (弘扬;?文学?
熠T 熠：光耀 彤：U色
鸿煊 鸿：大也 煊：光明
烨霖 烨：光明
哲?(拥有q大的学?
鑫鹏 鑫：财富 鹏：比喻气势雄伟
昊天 思聪 展鹏 W愚 志强 炫明 雪松 思源 智渊 思淼
晓啸 天宇 然 文轩 鹭洋 振家 乐驹 晓博 文博 昊焱
立果 金鑫 锦程 嘉熙 鹏飞 子默 思远 轩 语堂 聪健
]]>
UMLcdW号?/strong>
1.c（ClassQ：使用三层矩Ş框表C?br />W一层显C类的名Uͼ如果是抽象类Q则q斜体昄?br />W二层是字段和属性?br />W三层是cȝҎ?br />注意前面的符P?’表CpublicQ?’表CprivateQ?’表Cprotected?/p>
2.UMLcdW号之接口：使用两层矩Ş框表C，与类囄区别主要是顶端有<<interface>>昄?br />W一行是接口名称?br />W二行是接口Ҏ?/p>
3.UMLcdW号之承类QextendsQ：用空心三角Ş+实线来表C?/p>
4.UMLcdW号之实现接口（implementsQ：用空心三角Ş+虚线来表C?/p>
5.UMLcdW号之关联（AssociationQ：用实U箭头来表示Q例如：燕子与气?/p>
6.UMLcdW号之聚合（AggregationQ：用空心的菱Ş+实线头来表C?br />聚合Q表CZU弱的‘拥有’关p，体现的是A对象可以包含B对象Q但B对象不是A对象的一部分Q例如：公司和员?br />l合QCompositionQ：用实心的菱Ş+实线头来表C?br />l合Q部分和整体的关p，q且生命周期是相同的。例如：Z?/p>
7.UMLcdW号之依赖（DependencyQ：用虚U箭头来表示Q例如：动物与氧?/p>
8.UMLcdW号之基敎ͼq线两端的数字表明这一端的cd以有几个实例Q比如：一个鸟应该有两只翅膀。如果一个类可能有无C实例Q则q‘n’来表示。关联、聚合、组合是有基数的?/p>
|上关于此类的讨论非常多Q发现对于该问题的理解各有各的说法，而各个说法中又相ȝq。通过览q些讨论以及寏VO'Reilly - UML 2.0 In A Nutshell (2007)》的参考，发表一下自q看法
c间关系有很多种Q在大的cd上可以分ZU：U向关系、横向关pR?/p>
U向关系是l承关系Q它的概念非常明，也成为OO的三个重要特征之一Q这里不q多的讨论?/p>
横向关系较ؓ微妙Q按照UML的徏议大体上可以分ؓ四种Q?/p>
- 依赖 QDependencyQ?
- 兌 QAssociationQ?
- 聚合 QAggregationQ?
- l合 QCompositionQ?
它们的强弱关pL没有异议的：依赖 < 兌 < 聚合 < l合
然而它们四个之间的差别却又不那么好拿捏Q需要好好体会?/p>
-
依赖
Q?
- UML表示法：虚线 + 头
- 关系Q? ... uses a ..."
- 此关pL为简单，也最好理解，所谓依赖就是某个对象的功能依赖于另外的某个对象Q而被依赖的对象只是作ZU工具在使用Q而ƈ不持有对它的引用?
- 典型的例子很多，比如Q?br />class Human
{
public void breath()
{
Air freshAir = new Air();
freshAir.releasePower();
}
public static void main()
{
Human me = new Human();
while(true)
{
me.breath();
}
}
}
class Air
{
public void releasePower()
{
//do sth.
}
}
- 释义Q一个h自创生就需要不停的呼吸Q而h的呼吸功能之所以能l持生命在于吸q来的气体发挥了作用Q所以说I气只不q是人类的一个工P而hq不持有对它的引用?
- UML表示法：虚线 + 头
-
兌
Q?
- UML表示法：实线 + 头
- 关系Q? ... has a ..."
- 所谓关联就是某个对象会长期的持有另一个对象的引用Q而二者的兌往往也是怺的。关联的两个对象彼此间没有Q何强制性的U束Q只要二者同意，可以随时解除关系或是q行兌Q它们在生命期问题上没有MU定。被兌的对象还可以再被别的对象兌Q所以关联是可以׃n的?
- 典型的例子很多，比如Q?br />class Human
{
ArrayList friends = new ArrayList();
public void makeFriend(Human human)
{
friends.add(human);
}
public static void main()
{
Human me = new Human();
while(true)
{
me.makeFriend(mySchool.getStudent());
}
}
}
- 释义Qh从生x都在不断的交朋友Q然而没有理p为朋友的生死与我的生L必然的联p，故他们的生命期没有关联，我的朋友又可以是别h的朋友，所以朋友可以共享?
- UML表示法：实线 + 头
-
聚合
Q ?
- UML表示法：I心菱Ş + 实线 + 头
- 关系Q? ... owns a ..."
- 聚合是强版本的关联。它暗含着一U所属关pM及生命期关系。被聚合的对象还可以再被别的对象兌Q所以被聚合对象是可以共享的。虽然是׃n的，聚合代表的是一U更亲密的关pR?
- 典型的例子很多，比如Q?br />class Human
{
Home myHome;
public void goHome()
{
//在回家的路上
myHome.openDoor();
//看电?br /> }
public static void main()
{
Human me = new Human();
while(true)
{
//上学
//吃饭
me.goHome();
}
}
}
- 释义Q我的家和我之间h着一U强烈的所属关p，我的家是可以分n的，而这里的分n又可以有两种。其一是聚合间的分享，q正如你和你媛_儉K对这个家有着同样的强烈关联；其二是聚合与兌的分享，如果你的朋友来家里吃个便饭，估计你不会给他配一把钥匙?
- UML表示法：I心菱Ş + 实线 + 头
-
l合
Q?
- UML表示法：实心菱Ş + 实线 + 头
- 关系Q? ... is a part of ..."
- l合是关pd中的最强版本，它直接要求包含对象对被包含对象的拥有以及包含对象与被包含对象生命期的关系。被包含的对象还可以再被别的对象兌Q所以被包含对象是可以共享的Q然而绝不存在两个包含对象对同一个被包含对象的共享?
- 典型的例子很多，比如Q?br />class Human
{
Heart myHeart = new Heart();
public static void main()
{
Human me = new Human();
while(true)
{
myHeart.beat();
}
}
}
- 释义Q组合关pd是整体与部分的关p，部分属于整体Q整体不存在Q部分一定不存在Q然而部分不存在整体是可以存在的Q说的更明确一些就是部分必d生于整体创生之后Q而销毁于整体销毁之前。部分在q个生命期内可以被其它对象关联甚臌合，但有一点必L意，一旦部分所属于的整体销毁了Q那么与之关联的对象中的引用׃成ؓI引用，q一点可以利用程序来保障。心脏的生命期与人的生命期是一致的Q如果换个部分就不那么一定，比如阑尾Q很多h在创生后的某个时间对其厌倦便提前销毁了它，可它和hcȝ关系不可辩驳的属于组合?br />在UML中存在一U特例，是允许被包含对象在包含对象销毁前转移l新的对象，q虽然不自然Q但它给需要心脏移植的患者带来了音?
- UML表示法：实心菱Ş + 实线 + 头
]]>
import java.io.*;
import java.util.*;
//*********创徏型模?**************
//factory method 1
//1具体的构造算??构造出的具体品由子类实现
interface Product {
}
//或者我也提供一个工厂的接口,p个抽象类来承它
abstract class Factory {
abstract public Product fmd();
//我认个方Ҏ的存在是,是对FactoryMethodҎ的补?br />//例如可以为生成的对象赋?计算为生成对象应付何?前后的日?br />//且这些都是公用的,生成产品的最主要法q是在FactoryMethod?
//q个Ҏ只是赯助作?q也是一U思维Ҏ,具体的法实现在一个方法中
//而我不直接调用此Ҏ,而用另外的一个方法封装它,{到了更灉|的效??br />//子类需实现的内ҎFactoryMethod
//此方法是一个TemplateMethod
public Product creat() {
Product pd = null;
System.out.println("before operation");
pd = fmd();
System.out.println("end operation");
return pd;
}
}
class Product1 implements Product {
}
class Factory1 extends Factory {
public Product fmd() {
Product pd = new Product1();
return pd;
}
}
//FactroyMethod 2
//q种方式单实?br />interface Producta {
}
interface Factorya {
Producta create();
}
class Producta1 implements Producta {}
class Factorya1 implements Factorya {
public Producta create() {
Producta pda = null;
pda = new Producta1();
return pda;
}
}
//AbstractFactory
//AbstractFactory与FactoryMethod的不同在于AbstractFactory创徏多个产品
//感觉此模式没有什么大?/p>
//当然可以q有更多的接?br />interface Apda {}
interface Apdb {}
interface Afactory {
Apda createA();
Apdb createB();
}
class Apda1 implements Apda {}
class Apdb1 implements Apdb {}
//有几个接口就有几个对应的Ҏ
class Afactory1 implements Afactory {
public Apda createA() {
Apda apda = null;
apda = new Apda1();
return apda;
}
public Apdb createB() {
Apdb apdb = null;
apdb = new Apdb1();
return apdb;
}
}
//Builder
//一个品的生成分ؓ生成部g和组装部?不同的品每个部件生成的方式不同
//而组装的方式相同,部g的生成抽象成接口Ҏ,而组装的Ҏ使用一个TemplateMethodҎ
interface Cpda {}
class Cpda1 implements Cpda {}
interface BuilderI {
void buildPart1();
void buildPart2();
void initPd();
Cpda getPd();
}
abstract class BuilderA implements BuilderI {
Cpda cpda;
public Cpda getPd() {
initPd();
//对对象的内容q行讄
buildPart1();
buildPart2();
return cpda;
}
}
class Builder extends BuilderA {
public void buildPart1() {
System.out.println(cpda);
}
public void buildPart2() {
System.out.println(cpda);
}
public void initPd() {
cpda = new Cpda1();
}
}
//一个简单的生成产品的实?br />//1
abstract class Fy {
public abstract void med1();
static class Fy1 extends Fy {
public void med1() {
}
}
public static Fy getInstance() {
Fy fy = new Fy1();
return fy;
//Fy fy = new Fy1() {//q种匿名内部cL静态的Q！
//public void med1() {
//}
//};
//return fy;
}
}
//2
interface Pdd {}
class Pdd1 implements Pdd {}
abstract class Fya {
public static Pdd getPd() {
Pdd pdd = new Pdd1();
return pdd;
}
}
//Prototype 在java中就是clone,又包含深拯和浅拯
class CloneObja {
public CloneObja MyClone() {
return new CloneObja();
}
}
class CloneObjb {
public CloneObjb MyClone() throws Throwable {
CloneObjb cobj = null;
cobj = (CloneObjb) pcl(this);
return cobj;
}
//深度拯法
private Object pcl(Object obj) throws Throwable {
ByteArrayOutputStream bao = new ByteArrayOutputStream(1000);
ObjectOutputStream objo = new ObjectOutputStream(bao);
objo.writeObject(obj);
ByteArrayInputStream bai = new ByteArrayInputStream(bao.toByteArray());
ObjectInputStream obji = new ObjectInputStream(bai);
Object objr = obji.readObject();
return objr;
}
}
//Singleton
//一个类只有一个对?例如一个线E池,一个cache
class Singleton1 {
public static Singleton1 instance = new Singleton1();
private Singleton1() {
}
public static Singleton1 getInstance() {
return instance;
}
}
class Singleton2 {
public static Singleton2 instance;
private Singleton2() {
}
//public static Singleton2 getInstance() {
//if (instance == null) {
//instance = new Singleton2();
//}
//
//return instance;
//}
public static Singleton2 getInstance() {
synchronized(Singleton2.class) {
if (instance == null) {
instance = new Singleton2();
}
}
return instance;
}
}
//**********l构型模?*********
//Adapter
//基本Ҏ有两U?一U是使用引用一U用?br />//不W合标准的接口{成符合标准的接口,接口的修改主要是参数的增?
//q回值类?当然q有Ҏ?br />//感觉q就是封装的另一U表CŞ?装有用Ҏ装(在方法中调用功能Ҏ),
//用类装(先传入功能方法所在的cȝ对象,通过调用此对象的功能Ҏ)
//使用引用的Ş?br />class Adapteea {
public void kk() {}
}
interface Targeta {
String vv(int i, int k);
}
class Adaptera implements Targeta{
Adapteea ade;
public Adaptera(Adapteea ade) {
this.ade = ade;
}
public String vv(int i, int k) {
//具体的业务方法实现在Adaptee?q个Ҏ
//只vC接口转换的作?br />//调用此方法是通过引用
ade.kk();
return null;
}
}
//使用l承形式?br />class Adapteeb {
public void kk() {}
}
interface Targetb {
String vv(int i, int k);
}
class Adapterb extends Adapteeb implements Targetb {
public String vv(int i, int k) {
//调用此方法是通过l承
kk();
return null;
}
}
//Proxy
interface Subject {
void request();
}
class realSubject implements Subject {
public void request() {
//do the real business
}
}
class Proxy implements Subject {
Subject subject;
public Proxy(Subject subject) {
this.subject = subject;
}
public void request(){
System.out.println("do something");
subject.request();
System.out.println("do something");
}
}
//Bridge
//感觉是多态的实现
interface Imp {
void operation();
}
class Cimp1 implements Imp {
public void operation() {
System.out.println("1");
}
}
class Cimp2 implements Imp {
public void operation() {
System.out.println("2");
}
}
class Invoker {
Imp imp = new Cimp1();
public void invoke() {
imp.operation();
}
}
//Composite
interface Component {
void operation();
void add(Component component);
void remove(Component component);
}
class Leaf implements Component {
public void operation() {
System.out.println("an operation");
}
public void add(Component component) {
throw new UnsupportedOperationException();
}
public void remove(Component component) {
throw new UnsupportedOperationException();
}
}
class Composite implements Component {
List components = new ArrayList();
public void operation() {
Component component = null;
Iterator it = components.iterator();
while (it.hasNext()) {
//不知道此component对象是leafq是composite,
//如果是leaf则直接实现操?如果是composite则l递归调用
component = (Component) it.next();
component.operation();
}
}
public void add(Component component) {
components.add(component);
}
public void remove(Component component) {
components.remove(component);
}
}
//Decorator
//对一个类的功能进行扩展时,我可以用?但是不够灉|,所以选用?br />//另外的一UŞ?引用与扉K可活得对对象的一定的使用能力,而用引用将更灵z?br />//我们要保证是对原功能的追加而不是修?否则只能重写Ҏ,或用新的方?br />//注意concrete的可以直接new出来,
//而decorator的则需要用一个另外的decorator对象才能生成对象
//使用对象装,和公用接?br />//Decorator链上可以有多个元?/p>
interface Componenta {
void operation();
}
class ConcreteComponent implements Componenta {
public void operation() {
System.out.println("do something");
}
}
class Decorator implements Componenta {
private Componenta component;
public Decorator(Componenta component) {
this.component = component;
}
public void operation() {
//do something before
component.operation();
//do something after
}
}
//Facade
//非常实用的一U设计模?我可以ؓ外部提供感兴的接口
class Obj1 {
public void ope1() {}
public void ope2() {}
}
class Obj2 {
public void ope1() {}
public void ope2() {}
}
class Facade {
//我得C一个简z清晰的接口
public void fdMethod() {
Obj1 obj1 = new Obj1();
Obj2 obj2 = new Obj2();
obj1.ope1();
obj2.ope2();
}
}
//Flyweight
//I?/p>
//**********行ؓ型模?************
//Chain of Responsibility
//与Decorator的实现Ş式相cM,
//Decorator是在原来的方法之上进行添加功??br />//Chain则是判断信号如果不是当前处理的则转交个下一个节点处?br />//我可以用if分支来实现相同的效果,但是不够灉|,链上的每个节Ҏ可以替换增加?相对
//比较灉|,我们可以设计接口实现对节点的增删操作,而实现更方便的效?br />//q个是一个链状的l构,有没有想q用环状结?/p>
interface Handler {
void handRequest(int signal);
}
class CHandler1 implements Handler {
private Handler handler;
public CHandler1(Handler handler) {
this.handler = handler;
}
public void handRequest(int signal) {
if (signal == 1) {
System.out.println("handle signal 1");
}
else {
handler.handRequest(signal);
}
}
}
class CHandler2 implements Handler {
private Handler handler;
public CHandler2(Handler handler) {
this.handler = handler;
}
public void handRequest(int signal) {
if (signal == 2) {
System.out.println("handle signal 2");
}
else {
handler.handRequest(signal);
}
}
}
class CHandler3 implements Handler {
public void handRequest(int signal) {
if (signal == 3) {
System.out.println("handle signal 3");
}
else {
throw new Error("can't handle signal");
}
}
}
class ChainClient {
public static void main(String[] args) {
Handler h3 = new CHandler3();
Handler h2 = new CHandler2(h3);
Handler h1 = new CHandler1(h2);
h1.handRequest(2);
}
}
//Interpreter
//感觉跟Composite很类?只不q他分文l结W和非终l符
//Template Method
abstract class TemplateMethod {
abstract void amd1();
abstract void amd2();
//此方法ؓ一个Template MethodҎ
public void tmd() {
amd1();
amd2();
}
}
//State
//标准?br />//状态和操作不应该耦合在一?br />class Contexta {
private State st;
public Contexta(int nst) {
changeStfromNum(nst);
}
public void changeStfromNum(int nst) {
if (nst == 1) {
st = new CStatea1();
}
else if (nst == 2) {
st = new CStatea2();
}
throw new Error("bad state");
}
void request() {
st.handle(this);
}
}
interface State {
void handle(Contexta context);
}
class CStatea1 implements State {
public void handle(Contexta context) {
System.out.println("state 1");
//也许在一个状态的处理q程中要改变状?例如打开之后立即关闭q种效果
//context.changeStfromNum(2);
}
}
class CStatea2 implements State {
public void handle(Contexta context) {
System.out.println("state 2");
}
}
//工厂?br />//Ҏ状态不通生成不同的state
//class StateFactory {
//public static State getStateInstance(int num) {
//State st = null;
//
//if (num == 1) {
//st = new CStatea1();
//}
//else if (num == 2) {
//st = new CStatea2();
//}
//
//return st;
//}
//}
//Strategy
//跟Bridge相类?是一U多态的表示
//Visitor
//双向引用,使用另外的一个类调用自己的方?讉K自己的数据结?br />interface Visitor {
void visitElement(Elementd element);
}
class CVisitor implements Visitor {
public void visitElement(Elementd element) {
element.operation();
}
}
interface Elementd {
void accept(Visitor visitor);
void operation();
}
class CElementd implements Elementd {
public void accept(Visitor visitor) {
visitor.visitElement(this);
}
public void operation() {
//实际的操作在q里
}
}
class Clientd {
public static void main() {
Elementd elm = new CElementd();
Visitor vis = new CVisitor();
vis.visitElement(elm);
}
}
//Iteraotr
//使用q代器对一个类的数据结构进行顺序P?/p>
interface Structure {
interface Iteratora {
void first();
boolean hasElement();
Object next();
}
}
class Structure1 implements Structure {
Object[] objs = new Object[100];
//使用内部cLZ对Struture1的数据结构有完全的访问权
class Iteratora1 implements Iteratora {
int index = 0;
public void first() {
index = 0;
}
public boolean hasElement() {
return index < 100;
}
public Object next() {
Object obj = null;
if (hasElement()) {
obj = objs[index];
index++;
}
return obj;
}
}
}
//Meditor
class A1 {
public void operation1() {}
public void operation2() {}
}
class A2 {
public void operation1() {}
public void operation2() {}
}
class Mediator {
A1 a1;
A2 a2;
public Mediator(A1 a1, A2 a2) {
this.a1 = a1;
this.a2 = a2;
}
//如果我想实现q个功能我可能会把他攑֜A1?br />//但是q样耦合?我不惛_A1中出现A2对象的引?
//所以我使用了Mediator作ؓ中介
public void mmed1() {
a1.operation1();
a2.operation2();
}
public void mmed2() {
a2.operation1();
a1.operation2();
}
}
//Command
//我认为就是将Ҏ转换成了c?/p>
class Receiver {
public void action1() {}
public void action2() {}
}
interface Command {
void Execute();
}
class CCommand1 implements Command {
private Receiver receiver;
public CCommand1(Receiver receiver) {
this.receiver = receiver;
}
public void Execute() {
receiver.action1();
}
}
class CCommand2 implements Command {
private Receiver receiver;
public CCommand2(Receiver receiver) {
this.receiver = receiver;
}
public void Execute() {
receiver.action2();
}
}
//Observer
//在这里看gq个模式没有什么用
//但是如果我有一个线E监控Subject,如果Subject的状?br />//发生了变?则更改Observer的状?q出发一些操?q样有实际的意义了
//Observer与Visitor有相似的地方,都存在双向引?br />//Subject可以注册很多Observer
interface Subjectb {
void attach(Observer observer);
void detach(Observer observer);
void mynotify();
int getState();
void setState(int state);
}
class Subjectb1 implements Subjectb {
List observers = new ArrayList();
int state;
public void attach(Observer observer) {
observers.add(observer);
}
public void detach(Observer observer) {
observers.remove(observer);
}
public void mynotify() {
Observer observer = null;
Iterator it = observers.iterator();
while (it.hasNext()) {
observer = (Observer) it.next();
observer.Update();
}
}
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
}
}
interface Observer {
void Update();
}
class Observer1 implements Observer {
Subjectb subject;
int state;
public Observer1(Subjectb subject) {
this.subject = subject;
}
public void Update() {
this.state = subject.getState();
}
public void operation() {
//一些基于state的操?br />}
}
//Memento
//感觉此模式没有什么大?/p>
class Memento {
int state;
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
}
}
class Originator {
int state;
public void setMemento(Memento memento) {
state = memento.getState();
}
public Memento createMemento() {
Memento memento = new Memento();
memento.setState(1);
return memento;
}
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
}
}
class careTaker {
Memento memento;
public void saverMemento(Memento memento) {
this.memento = memento;
}
public Memento retrieveMemento() {
return memento;
}
}
//E序最l还是顺序执行的,是由不通部分的操作拼接h?br />//不同类的代码拼接v来是通过引用实现?有了引用我就
//相当于有了一定访问数据结构和Ҏ的能?q与写在cd?br />//差不?例如我想一个类中的一个方法抽d?因ؓq个Ҏ依赖与此cȝ数据和其他方?br />//直接代码移走是不行?但如果我们拥有了此类对象的引?则与写在此类
//内部无异,所以我们拥有了引用可以将此方法移?br />public class Pattern {
public static void main(String[] args) {
}
}
]]>
二。改变数据模型Table的字体大?br />Tools------>Display Prefrences------>Format------->Table--------->Modify------->Font-------->ҎSymbol选项不同改变字体的大?img src ="http://m.tkk7.com/toby/aggbug/290004.html" width = "1" height = "1" />
]]>
Rational Rose2003破解安装详解
Rational Rose 2003下蝲地址Q?/font>
破解文g的下载地址Q?/font> 1.安装Rational Rose2003Ӟ在需选择安装的时候，只选择Rational Rose EnterPrise Edition卛_Q不需选择其他V?/font> 2.安装好Rational Rose Enterprise Editon后，打开rose2003crack.rar压羃包，里面有四个文Ӟ分别为flexlm.cpl、license.dat、lmgrd.exe、rational.exe?/font> 3.用记事本或者是EditPlus打开license.dat文gQ大U在文g的中间位|有QSERVER Microsoft ANY DAEMON rational “C:\Program Files\Rational\common\rational.exe”，其修改为：SERVER 计算机名 ANY DAEMON rational “自己安装的目录\rational.exe”后Q保?/font> 注：若是按默认目录安装，则只需修改计算机名卛_?/font> 4.license.dat?lmgrd.exe 、rational.exe三个文g一h贝到Q安装目录\rational\common\下面?/font> 注：若ؓ默认则ؓQC:\Program Files\Rational\common\目录?/font> 5.flexlm.cpl拯到system32目录下。如win2000pȝ中ؓC:\WINNT\system32目录?/font> 6.q入控制面板Q则在控刉板的上方会增加了一个图标，即FLEXlm License ManagerQ将其打开Q在Setup中lmgrd.exe右侧目录写ؓQC:\Program Files\Rational\Common\lmgrd.exeQ若为默认安装目录） License File右侧目录写ؓQC:\Program Files\Rational\Common\license.dat 7.回到Control，点击StartQ若出现”Server Started”，则表C已l成功，可以点击Status,若状态ؓQ计机名：license server UP(MASTER)则成功?/font> 8.q时可打开安装的Rational Rose Enterprise EditionQ若q是出现ErrorQ则打开Rational License Key Administrator Q点dh中的W一个工PStart WIzardQ?点击下一步，在Server Name中的名字改ؓ自己的计机名即可?/font> |
]]>