设计模式微总结【学习中】

一、策略模式

1. 定义一个接口：WorkStrategy
2. 对接口有多个实现:WorkStrategy1;WorkStrategy2;WorkStrategy3
3. 通过多态实现策略的自定义引入（Contenxt）

/** 
 * @author
 * 核心代码
 */ 
public class Context { 
 //构造函数，传入你要使用的策略 
 private WorkStrategy straegy; 
 public Context(WorkStrategy strategy){ 
  this.straegy = strategy; 
 } 
  
 @Override
 public void operate(){ 
  this.straegy.operate(); 
 } 
} 

 二、代理模式

关键：代理人与被代理人都要实现接口，main调用的时候直接通过代理人调用被代理人的方法。

1. 定义一个公共接口
2. 代理人与被代理人实现接口
3. 代理人特殊转换

/** 
 * @author
 * 核心代码
 */ 
 private KindWomen kindWomen; 
  
 public WangPo(KindWomen kindWomen){//传入实现了kindWomen的被代理人 
  this.kindWomen = kindWomen; 
 } 

 @Override
 public void happyWithMan() { 
  this.kindWomen.happyWithMan(); //特殊处理,使用被代理人的方法
 } 

三、单例模式

关键：一个类只允许有一个实例对象

/** 
 * @author
 * 核心代码：懒汉式
 */ 
public class SingletonPattern { 
 private static SingletonPattern singletonPattern= null; 
 //限制住不能直接产生一个实例 
 private SingletonPattern(){ 
   
 } 
  
 public SingletonPattern getInstance(){ 
  if(this.singletonPattern == null){  //如果还没有实例，则创建一个 
   this.singletonPattern = new SingletonPattern(); 
  }   
  return this.singletonPattern; 
 } 
  
} 

/** 
 * @author
 * 核心代码：饿汉式
 */ 
public class SingletonPattern { 
 private static final SingletonPattern singletonPattern= new SingletonPattern(); 
//解决多线程的问题
  
 //限制住不能直接产生一个实例 
 private SingletonPattern(){ 
 } 
  
 public synchronized static SingletonPattern getInstance(){  
  return singletonPattern; 
 } 
 
} 

四、工厂模式   

1.优势

• 使用工厂模式的优点在于一个调用者想创建一个对象，只要知道其名称（也就是不同的标签）就可以在工厂获取具体的对象
• 扩展性强，如果想增加一个产品（也就是具体的对象），只要扩展工厂类就可以（也就是增加不同的标签，增加不同标签所对应的对象）。
• 屏蔽产品的具体实现，调用者只关心产品的接口、无需关心内部实现。

2.简单工厂模式

//1.定义一个接口（给工厂类创建的对象）
public interface Human {
    public void talk();
    public void run();
}

//实现接口
public class HumanBlackImpl implements Human {
    @Override
    public void talk() {
        System.out.println("BT");
    }

    @Override
    public void run() {
        System.out.println("BR");
    }
}


//实现接口
public class HumanYellowImpl implements Human {
    @Override
    public void talk() {
        System.out.println("YT");
    }

    @Override
    public void run() {
        System.out.println("YR");
    }
}


//定义一个工厂类
public class HumanFactory {
    public static Human createHuman(Class c){
        Human human=null;
        try {
            human = (Human) Class.forName(c.getName()).newInstance();//反射来创建对象
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return human;
    }
}

//通过工厂创建对象
public class FF {
    public static void main(String[] args) {
        Human human = HumanFactory.createHuman(HumanYellowImpl.class);
        human.talk();
    }
}

2.抽象工厂模式

//抽象工厂能够自定义抽象工厂能生成的对象。扩展性较高

//定义一个顶层接口
public interface Human {
    public void talk();
    public void run();
    public void sex();//给子接口抽象去自定义是否要实现，达成更高的扩展性
}


//定义一个抽象类实现父接口，可以部分实现方法，达成更高的扩展性
public abstract class AbstractHumanBlack implements Human{
    @Override
    public void run() {
        System.out.println("BR");
    }
    @Override
    public void talk() {
        System.out.println("BT");
    }
}

//定义一个抽象类实现实现类，实现sex的方法
public abstract class HumanBlackMan implements AbstractHumanBlack{
    @Override
    public void sex() {
        System.out.println("黑男人");
    }
}


//定义一个工厂接口
public interface HumanFactory {
    public Human createBlackMan();
    public Human createYellowMan();
}

//定义一个抽象类实现工厂接口
public abstract class HumanFactoryAbstract implements HumanFactory {
    public Human createHuman(Class c){
        Human human = null;
        try {
            human = (Human) Class.forName(c.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return human;
    };
}

//集成抽象的工厂接口
public class HumanFactoryAbstractBoy extends HumanFactoryAbstract {
    @Override
    public Human createBlackMan() {
        return  super.createHuman(HumanBlackMan.class);
    }

    @Override
    public Human createYellowMan() {
        return null;
    }
}

//通过工厂方法创建对象
public static void main(String[] args) {
        HumanFactory humanFactoryAbstractBoy = new HumanFactoryAbstractBoy();
        Human blackMan = humanFactoryAbstractBoy.createBlackMan();
        blackMan.sex();
    }

五、门面模式

简单理解：定义一个类封装了将会调用的方法，将实现的细节交给这个刚定义的类。

//抽象一个动作接口
public interface LetterProcess {
    //首先要写信的内容
    public void writeContext(String context);

    //其次写信封
    public void fillEnvelope(String address);

    //把信放到信封里
    public void letterIntoEnvelope();

    //然后邮递
    public void sendLetter();
}


//实现接口
public class LetterProcessImpl implements LetterProcess{

    //写信
    @Override
    public void writeContext(String context) {
        System.out.println("填写信的内容...." + context);
    }

    //在信封上填写必要的信息
    @Override
    public void fillEnvelope(String address) {
        System.out.println("填写收件人地址及姓名...." + address);
    }

    //把信放到信封中，并封好
    @Override
    public void letterIntoEnvelope() {
        System.out.println("把信放到信封中....");
    }

    //塞到邮箱中，邮递
    @Override
    public void sendLetter() {
        System.out.println("邮递信件...");
    }
}

//对外提供的门面
public class ModenPostOffice {
    private LetterProcess letterProcess = new LetterProcessImpl();

    //写信，封装，投递，一体化了
    public void sendLetter(String context, String address) {

        //帮你写信
        letterProcess.writeContext(context);

        //写好信封
        letterProcess.fillEnvelope(address);

        //把信放到信封中
        letterProcess.letterIntoEnvelope();

        //邮递信件
        letterProcess.sendLetter();
    }
}

//模拟发送信件
public class Client {

    public static void main(String[] args) {
        //现代化的邮局，有这项服务，邮局名称叫Hell Road
        ModenPostOffice hellRoadPostOffice = new ModenPostOffice();

        //你只要把信的内容和收信人地址给他，他会帮你完成一系列的工作；
        String address = "Happy Road No. 666,God Province,Heaven"; //定义一个地址
        String context = "Hello,It's me,do you know who I am? I'm your old lover.I'd like to....";
        hellRoadPostOffice.sendLetter(context, address);
    }
}

六、适配器模式

简单理解：一个公司的人力管理系统想从另一个公司的人力系统中获取人的相关信息。可知两个系统的数据存储格式是不同的，这时候适配器模式就派上用处了。可以通过适配器做一个中间转换的操作来实现。

//1.
public interface WorkerInfoInner {
    public String getName();
    public String getPhone();
    public String getZW();
}


//2.
public interface WorkerInfoOuter {
    public String getTName();
    public String getTPhone();
    public String getTZW();
}

//3.
public class WorkerInfoOuterImpl implements WorkerInfoOuter {
    @Override
    public String getTName() {
        System.out.println("外派");
        return null;
    }

    @Override
    public String getTPhone() {
        System.out.println("138****0504");
        return null;
    }

    @Override
    public String getTZW() {
        System.out.println("经理");
        return null;
    }
}

//4.适配器
public class WorkInnerToOuterAdapter extends WorkerInfoOuterImpl implements WorkerInfoInner {

    @Override
    public String getName() {
        getTName();
        return null;
    }

    @Override
    public String getPhone() {
        getTPhone();
        return null;
    }

    @Override
    public String getZW() {
        getTZW();
        return null;
    }
}

//5.
public class Client {
    public static void main(String[] args) {
        WorkerInfoInner workerInfoInner = new WorkInnerToOuterAdapter();
        workerInfoInner.getPhone();
    }
}