常用的设计模式及java代码描述

http://blog.csdn.net/haoxingfeng/article/details/9191619

1>代理模式    

 http://www.cnblogs.com/chinajava/p/5880870.html

 代理模式分静态代理和动态代理

 静态代理：（需要一个接口，一个委托类实现接口，一个代理类实现接口，） 代理模式就是提供一个代理对象，其可以实现委托类的部分功能，而且也可以拓展自己的功能

 例如（委托类）售票厅可以售票、改签、退票；（代理类）黄牛售票只可以售票，要办理改签或者退票的业务必须去售票厅

//接口
package com.wyx.proxyTest;
public interface ISubject {
    public void request();
}

//委托类
package com.wyx.proxyTest;
public class SubjectImpl implements ISubject {
    @Override
    public void request() {
        System.out.println("this is real subject");
    }
        public void otherFun(){
        }  
}     

//代理类
package com.wyx.proxyTest;
/*
 * 这个是代理类，它只有SubjectImpl中的部分功能
 */
public class SubjectProxy implements ISubject{
    private ISubject sub = null;
    
    public SubjectProxy(ISubject sub){
        this.sub = sub;
    }
    @Override
    public void request() {
        System.out.println("This is Proxy");
        sub.request();
    }
}   

//代理类测试
package com.wyx.proxyTest;
public class MainTest {
    public static void main(String[] args){
        
        SubjectImpl sub = new SubjectImpl();
        
        SubjectProxy proxy = new SubjectProxy(sub);
        proxy.request();
    }
}

动态代理：

2>装饰模式

3>策略模式（这个模式是行为的抽象，蒋其他几个类有相似的方法，用通用的抽象的方法提取出来，更容易拓展）

　　

4>单例模式（使得内存中只存在一个这样的对象，有饿汉式、饱汉式）

public class SingleMain{
　　//主方法
　　public static void main(String[] args){
　　
　　}
}

//饿汉式
class SingletonDome1{
　　//私有的对象
　　private static final SingletonDome1 sgd1 = new SingletonDome1();　　
　　///私有的构造方法
　　private SingletonDome1(){}
　　//
　　public static SingletonDome1 getSgd1(){
　　　　return sgd1;
　　}
}
//饱汉式
class SingletonDome2{
　　//私有的对象
　　private static SingletonDome2 sgd2 = new SingletonDme2();
　　//私有的构造方法
　　private SingletonDome2(){}
　　//
　　public static SingletonDome2 getSgd2(){
　　　　if(sgd2 == null){
　　　　　　sgd2 = new SingletonDome2();
　　　　}
　　　　return sgd2;
　　}
}

5>工厂模式（是实例化对象的方法模式，即：用工厂方法代替New操作的一种模式，例：以下是个简单的例子）

/*
*静态工厂模式
*/
//接口
public interface Alphabet{
　　public void alphabetFun(Object... params)；
}
//接口的实现A类
public class A implements Alphabet{
　　@Override
　　public void alphabetFun(Object... params){
　　　　System.out.println(params[0]+" "+"This is A");
　　}
}

//接口的实现B类
public class B implements Alphabet{
　　@Override
　　public void alphabetFun(Object... params){
　　　　System.out.println(params[0]+" "+"This is A");
　　}
}

//工厂类 
public class FactoryCls{
　　public static Alphabet factoryFun(String abc){
　　　　Alphabet tempObj;
　　　　//利用了java反射的机制
　　　　Class cls = null;
　　　　try{
　　　　　　cls = Class.forName("类路径");
　　　　}catch(Expection e){
　　　　　　e.printStackTrace();
　　　　}　　　　

　　　　/*
　　　　if(abc=="A"){
　　　　　　tempObj = new A();
　　　　}else if(abc=="B"){
　　　　　　tempObj = new B();
　　　　}
　　　　*/
　　　　return tempObj;
　　}
}