首页 > 代码库 > java设计模式演示样例

java设计模式演示样例

创建模式

1.工厂方法模式(Factory Method)  将程序中创建对象的操作,单独出来处理,创建一个产品的工厂接口,把实际的工作转移到详细的子类。大大提高了系统扩展的柔性,接口的抽象化处理给相互依赖的对象创建提供了最好的抽象模式。

public class TestFactoryMethod {public static void main(String[] args) {AnimalFactory af=new DogFactory();Animal1 a=af.getAnimal();}}abstract class Animal1{}class Dog1 extends Animal1{}class Cat1 extends Animal1{}abstract class AnimalFactory{public abstract Animal1 getAnimal();}class DogFactory extends AnimalFactory{public Animal1 getAnimal(){System.out.println("Dog");return new Dog1();}}class CatFactory extends AnimalFactory{public Animal1 getAnimal(){System.out.println("Cat");return new Cat1();}} 

 

2.抽象工厂模式(Abstract Factory) 针对多个产品等级的情况,而工厂方法模式针对单一产品等级的情况。
import java.awt.*;import javax.swing.*;import java.awt.event.*;public class TestAbstractFactory {public static void main(String[] args) {GUIFactory fact=new SwingFactory();Frame f=fact.getFrame();Component c1=fact.getButton();Component c2=fact.getTextField();f.setSize(500,300);f.setLayout(new FlowLayout());f.add(c1);f.add(c2);f.setVisible(true);f.addWindowListener(new WindowAdapter(){public void windowClosing(WindowEvent e){System.exit(0);}});}}abstract class GUIFactory{public abstract Component getButton();public abstract Component getTextField();public abstract Frame getFrame();}class AWTFactory extends GUIFactory{public Component getButton() {return new Button("AWT Button");}public Frame getFrame() {return new Frame("AWT Frame");}public Component getTextField() {return new TextField(20);}}class SwingFactory extends GUIFactory{public Component getButton() {return new JButton("Swing Button");}public Frame getFrame() {return new JFrame("Swing Frame");}public Component getTextField() {return new JTextField(20);}} 
3.单例模式(Singleton) 改善全局变量和命名空间的冲突,能够说是一种改良了的全局变量。这样的一个类仅仅有一个实例,且提供一个訪问全局点的方式,更加灵活的保证了实例的创建和訪问约束。系统中仅仅有一个实例,因此构造方法应该为私有 饿汉式:类载入时直接创建静态实例 懒汉式:第一次须要时才创建一个实例,那么newInstance方法要加同步 饿汉式比懒汉式要好,虽然资源利用率要差。可是不用同步。
public class TestSingleton {public static void main(String[] args) {}}class ClassA{ //饿汉式private static ClassA i=new ClassA();public static ClassA newInstance(){return i;}private ClassA(){}}class ClassB{ //懒汉式private static ClassB i=null;public static synchronized ClassB newInstance(){if (i==null) i=new ClassB();return i;}private ClassB(){}} 

4.建造模式(Builder) 将一个对象的内部表象和建造过程切割,一个建造过程能够造出不同表象的对象。可简化为模版方法模式.

public class TestBuilder { public static void main(String[] args) { Builder b=new BuilderImpl1(); Director d=new Director(b); Product p=d.createProduct(); }} interface Builder{ void buildPart1(); void buildPart2(); void buildPart3(); Product getProduct(); } class BuilderImpl1 implements Builder{public void buildPart1() { System.out.println("create part1"); }public void buildPart2() { System.out.println("create part2");}public void buildPart3() { System.out.println("create part3"); }public Product getProduct() { return new Product(); }}class Director{ Builder b; public Director(Builder b){ this.b=b; } public Product createProduct(){ b.buildPart1(); b.buildPart2(); b.buildPart3(); return b.getProduct(); } } class Product{} 

5.原型模式(ProtoType) 通过一个原型对象来创建一个新对象(克隆)。Java中要给出Clonable接口的实现,详细类要实现这个接口,并给出clone()方法的实现细节,这就是简单原型模式的应用。 ? 浅拷贝:仅仅拷贝简单属性的值和对象属性的地址 ? 深拷贝:拷贝本对象引用的对象,有可能会出现循环引用的情况。能够用串行化解决深拷贝。写到流里再读出来,这时会是一个对象的深拷贝结果。

import java.io.*;public class TestClonealbe {public static void main(String[] args) throws Exception {Father f=new Father();User u1=new User("123456",f);User u2=(User)u1.clone();System.out.println(u1==u2);System.out.println(u1.f==u2.f);}}class User implements Cloneable,Serializable{String password;Father f;public User(String password,Father f){this.password=password;this.f=f;}public Object clone() throws CloneNotSupportedException {//return super.clone();ObjectOutputStream out=null;ObjectInputStream in=null;try {ByteArrayOutputStream bo=new ByteArrayOutputStream();out = new ObjectOutputStream(bo);out.writeObject(this);out.flush();byte[] bs=bo.toByteArray();ByteArrayInputStream bi=new ByteArrayInputStream(bs);in = new ObjectInputStream(bi);Object o=in.readObject();return o;} catch (IOException e) {e.printStackTrace();return null;} catch (ClassNotFoundException e) {e.printStackTrace();return null;}finally{try {out.close();in.close();} catch (IOException e) {e.printStackTrace();}}}}class Father implements Serializable{}

结构模式 怎样把简单的类依据某种结构组装为大的系统 

6.适配器模式(Adapter) 在原类型不做不论什么改变的情况下,用一个适配器类把一个接口转成还有一个接口,扩展了新的接口,灵活且多样的适配一切旧俗。这样的打破旧框框,适配新格局的思想,是面向对象的精髓。以继承方式实现的类的 Adapter模式和以聚合方式实现的对象的Adapter模式,各有千秋,各取所长。

public class TestAdapter {public static void main(String[] args) {USB mouse=new Mouse();PC pc=new PC();//pc.useMouse(mouse);PS2 adapter=new USB2PS2Adapter(mouse);pc.useMouse(adapter);}}interface PS2{void usePs2();}interface USB{void useUsb();}class Mouse implements USB{public void useUsb(){System.out.println("通过USB接口工作");}}class PC{public void useMouse(PS2 ps2Mouse){ps2Mouse.usePs2();}}class USB2PS2Adapter implements PS2{private USB usb;public USB2PS2Adapter(USB usb) {this.usb = usb;}public void usePs2(){System.out.println("把对usePS2的方法调用转换成对useUSB的方法调用");usb.useUsb();}} 

 

7.组合模式(Composite) 把总体和局部的关系用树状结构描写叙述出来,使得client把总体对象和局部对象同等看待。

import java.util.*;public class TestComposite {public static void main(String[] args) {Node n1=new LeafNode(3);Node n2=new LeafNode(4);Node n3=new LeafNode(6);Node n4=new LeafNode(5);Node n5=new LeafNode(2);Node n6=new LeafNode(9);Node n7=new LeafNode(12);Node n8=new LeafNode(7);Node n9=new LeafNode(8);Node c1=new CompositeNode(n1,n2,n3);Node c4=new CompositeNode(n8,n9);Node c3=new CompositeNode(n5,c4);Node c2=new CompositeNode(n4,c3);Node c5=new CompositeNode(n6,n7);Node root=new CompositeNode(c1,c2,c5);System.out.println(root.getValue());}}abstract class Node{public abstract int getValue();}class LeafNode extends Node{int value;public LeafNode(int value){this.value=http://www.mamicode.com/value;>

8.装饰模式(Decorator) 以对客户透明的方式来扩展对象的功能。 用户依据功能需求任意选取组成对象的成分,通过方法的链式调用来实现。 能够给对象动态的添加功能,比继承灵活性更大。

public class TestDecorator {public static void main(String[] args) {Teacher t1=new SimpleTeacher();Teacher t2=new CppTeacher(t1);Teacher t3=new JavaTeacher(t2);t3.teach();//t.teach();}}abstract class Teacher{public abstract void teach();}class SimpleTeacher extends Teacher{public void teach(){System.out.println("Good Good Study, Day Day Up");}}class JavaTeacher extends Teacher{Teacher teacher;public JavaTeacher(Teacher t){this.teacher=t;}public void teach(){teacher.teach();System.out.println("Teach Java");}}class CppTeacher extends Teacher{Teacher teacher;public CppTeacher(Teacher t){this.teacher=t;}public void teach(){teacher.teach();System.out.println("Teach C++");}} 

9.代理模式(Proxy) 用一个代理对象来作为还有一个对象的代理,对客户来说是透明的。 存在一个抽象主题类,详细主题类和代理主题类都继承(实现)抽象主题,代理主题类中的方法会调用详细主题类中相相应的方法。

10.享元模式(Flyweight Pattern) 对象的状态分为内蕴状态和外蕴状态。内蕴状态不随环境变化而变化,因此能够作成系统共享. 

11.门面模式(Facade) 訪问子系统的时候,通过一个Façade对象訪问。Facade类是单例的。 客户代码仅仅须要和门面对象通信,不须要和详细子系统内部的对象通信,使得他们之间的耦合关系减弱。 这次将表现层和逻辑层隔离,封装底层的复杂处理,为用户提供简单的接口,这种样例随处可见。

门面模式非常多时候更是一种系统架构的设计,在我所做的项目中,就实现了门面模式的接口,为复杂系统的解耦提供了最好的解决方式。 

12.桥梁模式(Bridge) 将抽象和实现脱耦,使得二者能够单独变化。使得一个继承关系不承担两个变化因素.使用合成来取代继承的一种体现.

public YuanUser(BankAccount account) {super(account);}public void getMoney() {System.out.print("人民币");account.withdraw();}public void saveMoney() {System.out.print("人民币");account.deposit();}}class DollarUser extends BankUser{public DollarUser(BankAccount account) {super(account);}public void getMoney() {System.out.print("美元");account.withdraw();}public void saveMoney() {System.out.print("美元");account.deposit();}} 
 

行为模式 描写叙述怎样在对象之间划分责任 

13.策略模式(Strategy) 如同LayoutManager和详细的布局管理器的关系,在抽象策略类中定义方法,将易于变化的部分封装为接口,通常Strategy 封装一些运算法则,使之能互换。Bruce Zhang在他的博客中提到策略模式事实上是一种“面向接口”的编程方法,真是恰如其分。 在详细策略子类中实现,客户代码依据不同的须要选择对应的详细类,比如电子商务中多种价格算法。 一种策略一旦选中,整个系统执行期是不变化的

public class TestStrategy {public static void main(String[] args) {Strategy s1=new May1Strategy();Strategy s2=new June1Strategy();Book b=new Book(100);b.setS(s2);System.out.println(b.getPrice());}}class Book{Strategy s;public Book(double price){this.price=price;}private double price;public void setS(Strategy s) {this.s = s;}public double getPrice(){return price*s.getZheKou();}}interface Strategy{double getZheKou();}class May1Strategy implements Strategy{public double getZheKou(){return 0.8;}}class June1Strategy implements Strategy{public double getZheKou(){return 0.7;}} 
14.模板方法(Template Method) 准备一个抽象类,把部分确定的逻辑定义在某些方法中,用其它抽象方法实现剩余的逻辑。不同子类对这些逻辑有不同的实现。 使用方法:定义多个抽象操作,定义并实现一个模板方法,将步骤放在这个详细方法里,推迟到子类实现。子类能够改变父类的可变部分,但不能改变模板方法所代表的顶级逻辑。
public class TestTemplateMethod {public static void main(String[] args) {XiaoPin xp=new DaPuKe();xp.act();}}abstract class XiaoPin{public abstract void jiaoLiu();public abstract void xuShi();public abstract void gaoXiao();public abstract void shanQing();public final void act(){jiaoLiu();xuShi();gaoXiao();shanQing();}}class DaPuKe extends XiaoPin{public void jiaoLiu(){System.out.println("顺口溜");}public void xuShi(){System.out.println("火车除夕,老同学见面");}public void gaoXiao(){System.out.println("名片当作扑克");}public void shanQing(){System.out.println("马家军");}} 
 

 

15.观察者模式(Observer) 定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 全部依赖于它的对象都得到通知并被自己主动更新。观察者和被观察者的分开,为模块划分提供了清晰的界限。在低耦合的对象间完毕协调。 Java中的事件模型就是一个应用。

16.迭代器模式(Iterator) 相似于集合中的Iterator,使用迭代器来统一不同集合对象的遍历方式。在绝大多数的系统中,都会用到数组、集合、链表、队列这种类型,关心迭代模式的来龙去脉很有必要。在遍历算法中,迭代模式提供了遍历的顺序訪问容 器,GOF给出的定义为:提供一种方法訪问一个容器(container)对象中各个元素,而又不需暴露该对象的内部细节。.NET中就是使用了迭代器来 创建用于foreach的集合。

public class TestIterator {public static void main(String[] args) {Stack s=new Stack();s.push("Liucy");s.push("Huxz");s.push("George");LinkedList l=new LinkedList();l.addFirst("Liucy");l.addFirst("Huxz");l.addFirst("George");print(l.iterator());}public static void print(Itr it){while(it.hasNext()){System.out.println(it.next());}}}interface Itr{boolean hasNext();Object next();}class Stack{Object[] os=new Object[10];int index=0;private void expand(){Object[] os2=new Object[os.length*2];System.arraycopy(os,0,os2,0,os.length);os=os2;}public void push(Object o){if (index==os.length) expand();os[index]=o;index++;}public Object pop(){index--;Object o=os[index];os[index]=null;return o;}private class StackItr implements Itr{int cursor=0;public boolean hasNext(){return cursor}public Object next(){return os[cursor++];}}public Itr iterator(){return new StackItr();}}class LinkedList{private class Node{Object o;Node next;public Node(Object o){this.o=o;}public void setNext(Node next){this.next=next;}public Node getNext(){return this.next;}}Node head;public void addFirst(Object o){Node n=new Node(o);n.setNext(head);head=n;}public Object removeFirst(){Node n=head;head=head.getNext();return n.o;}class LinkedListItr implements Itr{Node currentNode=head;public boolean hasNext(){return this.currentNode!=null;}public Object next(){Node n=currentNode;currentNode=currentNode.getNext();return n.o;}}public Itr iterator(){return new LinkedListItr();}} 

 

17.责任链(Chain of Responsibility) 多个处理器对象连成一串,请求在这条链上传递,由该处理这个请求的处理器来处理。发出请求的client并不知道哪个对象处理请求。

public class TestChain {public static void main(String[] args) {String pass1="123456";String pass2="123456";String personId="123456789012345678";String email="chmask@163.com";register(pass1,pass2,personId,email);}public static void register(String pass1,String pass2,String personId,String email){Filter f1=new PasswordFilter1();Filter f2=new PasswordFilter2();Filter f3=new PersonIdFilter();Filter f4=new EmailFilter();f1.setNext(f2);f2.setNext(f3);f3.setNext(f4);System.out.println(f1.doFilter(pass1,pass2,personId,email));}}abstract class Filter{Filter next=null;public Filter getNext() {return next;}public void setNext(Filter next) {this.next = next;}public String doFilter(String pass1,String pass2,String personId,String email){if (next==null) return "成功";else return next.doFilter(pass1,pass2,personId,email);}}class PasswordFilter1 extends Filter{public String doFilter(String pass1,String pass2,String personId,String email){if (!(pass1.equals(pass2)))return "两次password输入不一致";else return super.doFilter(pass1,pass2,personId,email);}}class PasswordFilter2 extends Filter{public String doFilter(String pass1,String pass2,String personId,String email){if (pass1.length()!=6)return "password长度必须为6";else return super.doFilter(pass1,pass2,personId,email);}}class PersonIdFilter extends Filter{public String doFilter(String pass1,String pass2,String personId,String email){if (personId.length()!=15 && personId.length()!=18)return "身份证号码非法";else return super.doFilter(pass1,pass2,personId,email);}}class EmailFilter extends Filter{public String doFilter(String pass1,String pass2,String personId,String email){int i1=email.indexOf("@");int i2=email.indexOf(".");if (i1==-1 || i2==-1 || i2-i1<=1 || i1==0 || i2==email.length()-1)return "email非法";else return super.doFilter(pass1,pass2,personId,email);}} 

18.状态模式(State) 在对象内部状态改变时改变其行为。把所研究的对象的行为封装在不同的状态对象中。

import static java.lang.System.*;public class TestState {public static void main(String[] args) {BBSUser u=new BBSUser();u.setState(new GuestState());u.publish();u.setState(new NormalState());u.publish();u.setState(new BlockedState());u.publish();u.setState(new NewComerState());u.publish();}}class BBSUser{private State state;public void setState(State state){this.state=state;}public void publish(){state.action();}}abstract class State{public abstract void action();}class GuestState extends State{public void action(){out.println("您处在游客状态,请先登录");}}class NormalState extends State{public void action(){out.println("您处在正常状态,文章发表成功");}}class BlockedState extends State{public void action(){out.println("您处在被封状态,文章发表失败");}}class NewComerState extends State{public void action(){out.println("您是新手,请先学习一下,3天后再来");}}class StateFactory{public static State createState(int i){if (i==1) return new GuestState();else return new NormalState();}} 

19.备忘录模式(Memento) 备忘录对象用来存储还有一个对象的快照对象,保存其内部状态,使得能够随时恢复。 备忘录角色:保存发起人对象的内部状态,保护内容不被除发起人对象之外的对象获取。窄接口:负责人对象和其它对象看到的接口,仅仅同意把备忘录对象传给其它对象。宽接口:发起人能看到的接口,同意读取内部状态。 发起人角色:创建并使用备忘录对象来保存其状态 负责人角色:负责保存备忘录对象。 ? 白箱实现:备忘录类对其它类也可见,这样发起人的状态可能会存在安全问题。 ? 黑箱实现:把备忘录类作成发起人的内部类,对外提供一个标识接口。

public class TestMemento{public static void main(String[] args){Originator ori=new Originator();Caretaker c=new Caretaker();ori.setState("State 1");IFMemento m=ori.createMemento();c.save(m);ori.setState("State 2");m=c.retrieve();ori.restore(m);System.out.println("Now State:"+ori.getState());}}class Originator{String state;public void setState(String s){state=s;System.out.println("State change to: "+s);}public String getState(){return this.state;}public IFMemento createMemento(){return new Memento(state);}public void restore(IFMemento m){Memento mt=(Memento)m;this.state=mt.getState();}private class Memento implements IFMemento{private String state;public Memento(String s){this.state=s;}public String getState(){return this.state;}}}class Caretaker{private IFMemento m;public IFMemento retrieve(){return this.m;}public void save(IFMemento m){this.m=m;}}interface IFMemento{}

java设计模式演示样例