A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 张强+ 黑马帝   /  2011-11-12 00:08  /  2952 人查看  /  2 人回复  /   1 人收藏 转载请遵从CC协议 禁止商业使用本文

1. 设计模式        3
1.1 创建型模式        4
1.1.1 工厂方法        4
1.1.2 抽象工厂        6
1.1.3 建造者模式        10
1.1.4 单态模式        13
1.1.5 原型模式        15
1.2 结构型模式        17
1.2.1 适配器模式        17
1.2.2 桥接模式        19
1.2.3 组合模式        23
1.2.4 装饰模式        26
1.2.5 外观模式        29
1.2.6 享元模式        32
1.2.7 代理模式        34
1.3 行为型模式        37
1.3.1 责任链模式        37
1.3.2 命令模式        40
1.3.3 解释器模式        43
1.3.4 迭代器模式        45
1.3.5 中介者模式        49
1.3.6 备忘录模式        52
1.3.7 观察者模式        54
1.3.8 状态模式        58
1.3.9 策略模式        61
1.3.10 模板方法        63
1.3.11 访问者模式        65
1. 设计模式(超级详细)
1.1 创建型模式
AbstractFactory ( 抽象工厂 )
FactoryMethod ( 工厂方法 )
Singleton ( 单态模式 )
Builder ( 建造者模式 )
Protot*pe * 原型模式 )
1.1.1 工厂方法

    *义一个用于创建对象的接口,让子类决定实例化哪一个类。FactoryMethod使一个类的实例*延迟到其子类。
 适用性

    1.当一个类不知道它所必须创建的对象的类的时候。

    2.当一个类希望由它的子类来指定它所创建的对象的时候。

    3.当*将创建对象的职责委托给多个帮助*类中的某一个,并且*希望将哪一个帮助子类是代理者这一信息局部化的时候。
                       
 参与者

    1.Product
      定义工厂方法所创建的对象的接口。

    2.ConcreteProduct
      实现Product接口。

    3.Creator
      声明工厂方法,该方法返回一个Product类型的对象*
      Creator也可以定义一个工厂方法的缺省实现,它返回一个缺省的ConcreteProduct对象。
      可以调用工厂方法以创建一个Product对象。

    4.ConcreteCreator
      重定义工厂方法以返回一个ConcreteProduct实例。
 类图

 例子
*roduct

public interface Work {

    void doWork();
}
ConcreteProduct

public class StudentWork implements Work {

    public void doWork() {
        System.out.println("学生*作业!");
    }

}

public class TeacherWork implements Work {

    public void doWork() {
        System.out.println("老师审批作业!");
    }

}
Creator

public interface IWorkFactory {

    Work get*ork();
}
Concre*eCreator

pu*lic class StudentWorkFactory implements IWorkFactory {

    public Work getWork() {
        *eturn new StudentWork();
    }

}

public class TeacherWorkFactory implements IWorkFactory {

    public Work getWork() {
        return new TeacherWork();
    }

}
Test

public class Test {

    public static void m*in(Strin*[] args) {
        IWorkFactory studentWorkFactory = new StudentWorkFactory();
        studentWorkFactory.getWork().d*Work();
        
        IWorkFactory teacherWorkFactory * new TeacherWorkFactory();
        teacherWorkFactory.g*tWork().*oWork();
    }

}
result

学生做作业!
老师审批作业!
1.1.2 抽象工厂

    提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。
 适用性

    1.一个系统要独立于它的*品的创建、组合和表示时。

    2.一个系统要由多个产品系列中的一个来配置时。

    3.当你要强调一系列相关的产品对象的设计以便进行联合使用时*

    4*当你提供一个产品类库,而只想显示它们*接口而不是实现时。
                       
 参与者

    1.Ab*tractFactory
      声明一个创建抽象产品对象的操作接口。

    2.ConcreteFactory
      实现创建具体产品对象的操作。

    *.AbstractProduct
      为一类产品对象声明一个接口。

    4.ConcreteProdu*t
      定义一个将被相应的具体工厂创建的产品*象。
      实现*bstractProduct接口。

    5.Client
      仅使用由AbstractFactory和AbstractProduc*类声明的接口
 类图

 例子
*bstractFactory

public interface IAn*malFactory {

    ICat createCat();
       
    IDog cre*teDog();
}
ConcreteFactory

p*blic class BlackAnimalFactory implem*nts IAnimalFactory {

    public ICat createCat() {
        retur* new BlackCat();
    }

    public IDog createDog() {
        return new BlackDog();
    }

}

public class WhiteAnimalFac*ory imp*ements IAnimalFactory {

    public ICat createCat() {
        return new WhiteCat();
    }

    public IDog cre*teDog() {
        return new WhiteDog();
    }

}
Abstrac*Product

public interface ICat {

    void eat();
}

public interface IDog {

    void eat();
}
Concrete*roduct

public class Black*at implements ICat {

    public void eat() {
        System.out.println("The bl*ck cat is eating!");
    }

}

public class WhiteCat implements *Cat {

    public void eat() {
        Sy*tem.out.prin*ln("The w*ite cat is eating!*);
    }

}

public class BlackDog implements IDog {

    public void eat() {
        System.out.println("The black dog is eating");
    }

}

public class WhiteDog implements IDog {

    public void eat() {
        System.out.println("The white dog is eat*ng!");
    }

}
Client

public static void main(String[] args) {
    IAnimalFactory blackAnimalFa*tory = new BlackAnimalFactory();
    ICat blackCat = blackAnimalFactory.createCat();
    blackCat.eat();
    IDog blackD*g = blackAnimalFactory.createDog();
    blackDog.eat();
   
    IAnimalFactory whiteAnimalF*ctory = new WhiteAnimalFactory();
    ICat whiteCat = whiteAnimalFactory.createCat();
    whiteCat.eat();
    IDog *hiteDog = whiteAnimalFactory.createDog();
    whiteDog.eat();
}
res*lt

The bla*k cat is eating!
Th* black dog is eatin*!
The white cat is eating!
The white dog is *ating!
1.1.3 建造者模式

    将一个复杂对象的构*与它的表示分离,使*同样的构建过程可以创建不同的表示。
 适用性

    1.当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。

    *.当构造过程必须允*被构造的对象有不同*表示时。
                       
 参与者

    1.Builder
      为创建一个Product对象的各个部件指定抽象接口。

    2.ConcreteBuilder
      实现Buil*er的接口以构造和装配该产品的各个部件。
      定义并明确它所创建的表示*
      提供一个检索产品的接口。

    3.Director
      构造一个使用Builder接口的对象。

    4.Product
      表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程。
      包含定义组成部件的类,包括将这些部件装配成最终产品的接口。
 类图

 例子
Buil*er

public interface PersonBuilder {

    void buildHead();
   
    v*id buildBody();
   
    void buildFoot()*

    Person buildPerson();
}
ConcreteBuilder

public class ManBuilder implements PersonB*ilder {

    Person person;
   
    public ManBuilder() {
        person = ne* Man();
    }
   
    publ*c void build*ody() {
        perso*.setBody("建造男人的身体");
    }

    public void buildFoot() {
        person.setFo*t("建造男人的脚");
    }

    public void buildHead() {
        pers*n.setHead("建造*人的头");
    }

    *ublic Person buildPerson() {
        retur* person;
    }
}
Dir*ctor

public class PersonDirec*or {

    public Person constructPerson(PersonBuilder pb) {
        pb.buildHead();
        pb.buildBody();
        pb.buildFoot();
        return pb.buildPerson();
    }
}
Product

public class Person {

    private String head;
   
    private String body;
   
    private String foot;

    public String getH*ad() {
        return head;
    }

    public void setHead(String hea*) {
        this.head = head;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.b*dy = body;
    }

    public String getFoot() {
        return foot;
    }

    public void setFoot(String foot) {
        t*is.foot = foot;
    }
}

public class Man extends Person {

}
Test

publ*c class Test{
   
    public static void main(String[] ar*s) {
        PersonDirector pd = new PersonDirector();
        Person person = pd.constructPerson(new ManBuilder());
        System*out.println(person.getBody());
        System.out.println(person.getFoot());
        System.out.println(person.getHead());
    }
}
result

建造男人*身体
建造男*的脚
建造男人的头
1.1.4 单态模式

    保证一个类仅有一个实例,*提供一个访问它的全局访*点。
 适用性

    1.当类只能有一个*例而且客户可以从一个众所周知的访问点访问它时。

    2.当这个唯一实例应该是通过子类化可扩展的,并且客户应该无需更改代码就能使用一个扩展的实例时。
                       
 参与者

    Singleton
      定义一个Instance操作,允许客户访问它的唯一实例。Instance是一个类操作。
      可能负*创建它自己的唯一实例。
 类图

 例子
Singleton

public class Singleton {
   
    private static Singleton sing;

    private Singleton() {
        
    }
   
    public st*tic Singleton get*nstance() {
        if (sing == null) {
            sing = new Singleto*();
        }
        return sing;
    }
}
Test

public class Test {
   
    public static void *ain(*tring[] args) {
        Singleton sing = Singleton.getInstance();
        Singleton si*g2 = Singleton.getI*stance();
        
        System.out.println(sing);
        System.out.pr*ntln(sing2);
    }
}
result

singleton.Singleton@1c78e57
singleton.Singleton@1c78e57

                       

2 个回复

倒序浏览
完整版的Java设计模式
回复 使用道具 举报
顶起!!!
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马