设计模式

简单的介绍几种设计模式

单例模式：懒汉式：

public class Entrance {
  public static void main(String[] args) {
    // 单例模式中的懒汉式
    Person person1 = Person.getPerson();
    Person person2 = Person.getPerson();
    System.out.println(person1 == person2);
  }


}


class Person {
  private static Person p = null;


  private Person() {
  }


  public static Person getPerson() {
    if (p == null) {
      p = new Person();
    }
    return p;
  }
}

• 优点：只有在第一次使用的时候创建空间，否则这辈子都不会创建了

• 缺点：线程不安全，多线程时，会发生非单例情况，可以加synchronnized锁，但加锁会影响效率

单例模式中的饿汉式：

class Student{
  private static Student s = new Student();
  private Student() {}
  public static Student getStudent() {
    return s;
  }
}

• 优点：线程安全

• 缺点：类加载时就创建空间，浪费资源

工厂模式：

interface Phone{
  public void make();
}


class Mi implements Phone{
  @Override
  public void make() {
    System.out.println("小米在制造手机");
  }


  @Override
  public String toString() {
    return "Mi";
  }
  
}
class Iphone implements Phone{
  @Override
  public void make() {
    System.out.println("苹果正在制造手机");
  }
}
class MakeFactory{
  public static Phone makePhone(String nameString) {
    if(nameString.equals("小米")) {
      return new Mi();
    }
    if(nameString.equals("苹果")) {
      return new Iphone();
    }
    return null;
  }
}

适配器模式：

public class Entrance {
  public static void main(String[] args) {
    
    Person person = new Person();
    person.chi();
    Dog dog = new Dog();
    dog.sa();
    
  }
}


/**
 * 适配器模式
 * @author 曹
 *
 */
interface make{
  public void chi();
  public void he();
  public void la();
  public void sa();
  public void shui();
  //............
}
/**
 * 适配器类，用来实现接口的所有方法
 * @author 曹
 *
 */
class Adapter implements make{


  @Override
  public void chi() {
    // TODO Auto-generated method stub
    
  }


  @Override
  public void he() {
    // TODO Auto-generated method stub
    
  }


  @Override
  public void la() {
    // TODO Auto-generated method stub
    
  }


  @Override
  public void sa() {
    // TODO Auto-generated method stub
    
  }


  @Override
  public void shui() {
    // TODO Auto-generated method stub
    
  }
  
}
class Person extends Adapter{


  @Override
  public void chi() {
    System.out.println("人只有吃方法");
  }


  @Override
  public void he() {
    System.out.println("人只有喝方法");
  }


  @Override
  public void la() {
    System.out.println("人只有拉方法");
  }
  
}
class Dog extends Adapter{


  @Override
  public void sa() {
    System.out.println("狗只有撒方法");
  }


  @Override
  public void shui() {
    System.out.println("狗只有睡方法");
  }
  
}

代理模式：静态代理：由一个代理主题操作真实主题

public class Entrance {
  public static void main(String[] args) {


    wangtong wangtong = new wangtong(new dianxin());
    wangtong.make();


  }
}


interface NetWork {
  public void make();
}


/**
 * 真实代理
 * 
 * @author 曹
 *
 */
class dianxin implements NetWork {


  @Override
  public void make() {
    System.out.println("上网浏览信息");
  }
}


/**
 * 代理主题
 * 
 * @author 曹
 *
 */
class wangtong implements NetWork {


  private NetWork net;


  public wangtong(NetWork net) {
    this.net = net;
  }


  private void test() {
    System.out.println("这是网通的其他业务");
  }


  @Override
  public void make() {
    test();
    net.make();
  }
}

建造者模式：

public class Entrance {
  public static void main(String[] args) {


    CreateRoubt createRoubt = new CreateRoubt();
    Roubt roubt = createRoubt.createRoubtSpeak(new Service());
    System.out.println(roubt);
  }


}


/**
 * 创建一个复杂对象
 * 
 * @author 曹
 *
 */
class Roubt {
  private String headString;
  private String bodyString;
  private String handString;
  private String rootString;


  public String getHeadString() {
    return headString;
  }


  public void setHeadString(String headString) {
    this.headString = headString;
  }


  public String getBodyString() {
    return bodyString;
  }


  public void setBodyString(String bodyString) {
    this.bodyString = bodyString;
  }


  public String getHandString() {
    return handString;
  }


  public void setHandString(String handString) {
    this.handString = handString;
  }


  public String getRootString() {
    return rootString;
  }


  public void setRootString(String rootString) {
    this.rootString = rootString;
  }


  @Override
  public String toString() {
    return "Roubt [headString=" + headString + ", bodyString=" + bodyString + ", handString=" + handString
        + ", rootString=" + rootString + "]";
  }


}


/**
 * 规范复杂对象的各个组成成分的建造
 * 
 * @author 曹
 *
 */
interface BuilderRoubt {
  public void builderHead();


  public void builderBody();


  public void builderHand();


  public void builderFoot();


  public Roubt createRoubt();
}


/**
 * 复杂对象的表现
 * 
 * @author 曹
 *
 */
class Service implements BuilderRoubt {


  private Roubt roubt;


  public Service() {
    this.roubt = new Roubt();
  }


  @Override
  public void builderHead() {
    roubt.setHeadString("强大的头脑");
  }


  @Override
  public void builderBody() {
    roubt.setBodyString("苗条的身材");
  }


  @Override
  public void builderHand() {
    roubt.setHandString("手指很灵活");
  }


  @Override
  public void builderFoot() {
    roubt.setRootString("双脚很光滑");
  }


  @Override
  public Roubt createRoubt() {
    return roubt;
  }


}


/**
 * 对复杂对象进行构建
 * 
 * @author 曹
 *
 */
class CreateRoubt {
  public Roubt createRoubtSpeak(BuilderRoubt roubt) {
    roubt.builderBody();
    roubt.builderFoot();
    return roubt.createRoubt();
  }
}

public class Entrance {
  public static void main(String[] args) {


    // 去肯德基，汉堡、可乐、薯条、炸鸡等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。
    // 套餐一：
    QingKfc taocanyi = new QingKfc();
    KFCcontent kfCcontent = taocanyi.createKfCcontentLa(new TasteLa());
    System.out.println(kfCcontent);
    // 套餐二：
    DuanKFC taocaner = new DuanKFC();
    KFCcontent kfCcontent2 = taocaner.createCcontent(new TasteSuan());
    System.out.println(kfCcontent2);
  }


}


/**
 * 这是一个复杂对象，克的及店内所有食物
 * 
 * @author 曹
 *
 */
class KFCcontent {
  private String hanbaoString;
  private String keleString;
  private String shutiaoString;
  private String zhajiString;


  public String getHanbaoString() {
    return hanbaoString;
  }


  public void setHanbaoString(String hanbaoString) {
    this.hanbaoString = hanbaoString;
  }


  public String getKeleString() {
    return keleString;
  }


  public void setKeleString(String keleString) {
    this.keleString = keleString;
  }


  public String getShutiaoString() {
    return shutiaoString;
  }


  public void setShutiaoString(String shutiaoString) {
    this.shutiaoString = shutiaoString;
  }


  public String getZhajiString() {
    return zhajiString;
  }


  public void setZhajiString(String zhajiString) {
    this.zhajiString = zhajiString;
  }


  @Override
  public String toString() {
    return "KFCcontent [hanbaoString=" + hanbaoString + ", keleString=" + keleString + ", shutiaoString="
        + shutiaoString + ", zhajiString=" + zhajiString + "]";
  }


}


/**
 * 复杂对象的各个组成成分的建造
 * 
 * @author 曹
 *
 */
interface Builder {
  public void builderHanbao();


  public void builderKele();


  public void builderShutiao();


  public void builderZhaji();


  public KFCcontent creKfCcontent();
}


/**
 * 变现特性：麻辣
 * 
 * @author 曹
 *
 */
class TasteLa implements Builder {


  private KFCcontent kfc;


  public TasteLa() {
    this.kfc = new KFCcontent();
  }


  @Override
  public void builderHanbao() {
    kfc.setHanbaoString("BT辣");
  }


  @Override
  public void builderKele() {
    kfc.setKeleString("酒精可乐");
  }


  @Override
  public void builderShutiao() {
    kfc.setShutiaoString("五项麻辣");
  }


  @Override
  public void builderZhaji() {
    kfc.setZhajiString("麻辣");
  }


  @Override
  public KFCcontent creKfCcontent() {
    return kfc;
  }


}


/**
 * 表现特性二：酸甜
 * 
 * @author 曹
 *
 */
class TasteSuan implements Builder {


  private KFCcontent kfc;


  public TasteSuan() {
    this.kfc = new KFCcontent();
  }


  @Override
  public void builderHanbao() {
    kfc.setHanbaoString("酸爽");
  }


  @Override
  public void builderKele() {
    kfc.setKeleString("柠檬可乐");
  }


  @Override
  public void builderShutiao() {
    kfc.setShutiaoString("柔软酸爽");
  }


  @Override
  public void builderZhaji() {
    kfc.setZhajiString("醋香鸡腿");
  }


  @Override
  public KFCcontent creKfCcontent() {
    return kfc;
  }


}


/**
 * 创建具体表现的对象一
 * 
 * @author 曹
 *
 */
class QingKfc {
  public KFCcontent createKfCcontentLa(TasteLa la) {
    la.builderHanbao();
    la.builderKele();
    la.builderShutiao();
    la.builderZhaji();
    return la.creKfCcontent();
  }
}


/**
 * 创建具体表现对象二
 * 
 * @author 曹
 *
 */
class DuanKFC {
  public KFCcontent createCcontent(TasteSuan suan) {
    suan.builderHanbao();
    suan.builderKele();
    suan.builderShutiao();
    suan.builderZhaji();
    return suan.creKfCcontent();
  }
}

门面模式：

public class Entrance {
  public static void main(String[] args) {
    //门面模式:一个流程拍一个队。
    MenMian menMian = new MenMian();
    menMian.shangwu();
    menMian.xiawu();
  }


}
/**
 * 第一个门面
 * @author 曹
 *
 */
class Computer{
  public void upJava() {
    System.out.println("等待Java上");
  }
  public void downJava() {
    System.out.println("等待Java下课");
  }
  
}
/**
 * 第二个门面
 * @author 曹
 *
 */
class Food{
  public void downToast() {
    System.out.println("等待吐丝下课");
  }
  public void upToast() {
    System.out.println("等待吐丝上课");
  }
}
/**
 * 结束吃饭
 * @author 曹
 *
 */
class Canteen{
  public void startEat() {
    System.out.println("开始吃饭");
  }
  public void endEat() {
    System.out.println("结束吃饭");
  }
}
/**
 * 设计一个门面类
 * @author 曹
 *
 */
class MenMian{
  private Computer computer;
  private Food food;
  private Canteen canteen;
  public MenMian() {
    computer=new Computer();
    food=new Food();
    canteen=new Canteen();
  }
  /**
   * 上午流程
   */
  public void shangwu() {
    computer.upJava();
    food.upToast();
    canteen.startEat();
  }
  /**
   * 下午流程
   */
  public void xiawu() {
    canteen.endEat();
    food.upToast();
    computer.upJava();
    computer.downJava();
  }
}

桥接模式：是通过抽象化和实现化的方式进行解耦，使得二者互不相连，独立变化，因为此时A和B没有任何直接关系。

public class Entrance {
  public static void main(String[] args) {


    A1 a1 = new A1();//来源地
    a1.qiao=new B1();//目的地，父类的引用指向了子类的对象
    a1.fromA();
    a1.qiao.ObjB();
  }
}


/**
 * 简历一个桥接
 * 
 * @author 曹
 *
 */
interface Qiao {
  public void ObjB();
}


abstract class A {
  public Qiao qiao;


  abstract void fromA();
}


/**
 * 目的地1
 * 
 * @author 曹
 *
 */
class B1 implements Qiao {
  @Override
  public void ObjB() {
    System.out.println("我要去B1");
  }
}


/**
 * 目的地2
 * 
 * @author 曹
 *
 */
class B2 implements Qiao {


  @Override
  public void ObjB() {
    System.out.println("我要去b2");


  }
}


/**
 * 目的地3
 * 
 * @author 曹
 *
 */
class B3 implements Qiao {
  @Override
  public void ObjB() {
    System.out.println("我要去b3");


  }
}
/**
 * 来源地一
 * @author 曹
 *
 */
class A1 extends A {


  @Override
  void fromA() {
    System.out.println("我来自a1");
  }
}
/**
 * 来源地二
 * @author 曹
 *
 */
class A2 extends A {


  @Override
  void fromA() {
    System.out.println("我来自a2");


  }
}
/**
 * 来源地三
 * @author 曹
 *
 */
class A3 extends A {


  @Override
  void fromA() {
    System.out.println("我来自a3");


  }
}

观察者模式--又称做发布--订阅模式：

public class Entrance {
  public static void main(String[] args) {
    B b = new B();
    b.addObserver(new A());
    b.addObserver(new C());
    b.modify(10);
  }
}
/**
 * 定义一个发布者，也就是被观察者 ,需要实现Java中的Observable接口
 * @author 曹
 *
 */
class B extends Observable{
  int data=20;
  public void modify(int data) {
    this.data = data;
    setChanged();//自动调用 标记发布者的数据改变了
    notifyObservers("我改变了"+this.data);//订阅者updat方法中的实参  ，参数作为update方法中arg的实参   
  }
}
/**
 * 定义一个观察者，也就是订阅者，当发布者改变的时候，当发布者被改变后，订阅者中的update方法会被自动执行
 * @author 曹
 *
 */
class A implements Observer{
  @Override
  public void update(Observable o, Object arg) {//o是B的对象，arg为B传进来的参数
    System.out.println(o+"我改变了"+arg);
  }
}
class C implements Observer{
  @Override
  public void update(Observable o, Object arg) {//o是B的对象，arg为B传进来的参数
    System.out.println(o+"我改变了"+arg);
  }
}