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=value;
 
}
 
public int getValue(){
 
return value;
 
}
 
}
 
class CompositeNode extends Node{
 
private List children=new ArrayList();
 
public CompositeNode(Node... nodes){
 
for(Node n:nodes){
 
children.add(n);
 
}
 
}
 
public int getValue(){
 
int result=0;
 
for(Node n:children){
 
result+=n.getValue();
 
}
 
return result;
 
}
 
} 

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{
 
}