Java常用的設計模式代碼實現方式彙總

單例模式

懶漢式寫法（線程安全）

public class Singleton {
   private volatile static Singleton singleton;
   private Singleton (){}
   public static Singleton getSingleton() {
   if (singleton == null) {
       synchronized (Singleton.class) {
       if (singleton == null) {
           singleton = new Singleton();
       }
       }
   }
   return singleton;
   }
}

餓漢式寫法

public class Singleton {
   private static Singleton instance = new Singleton();
   private Singleton (){}
   public static Singleton getInstance() {
   return instance;
   }
}

觀察者模式

1、定義接口類

public interface Person {
   //小王和小李通過這個接口可以接收到小美髮過來的消息
   void getMessage(String s);
}

2、實現接口類

public class LaoWang implements Person {

   private String name = "小王";

   public LaoWang() {
   }

   @Override
   public void getMessage(String s) {
       System.out.println(name + "接到了小美打過來的電話，電話內容是：" + s);
   }

}

public class LaoLi implements Person {

   private String name = "小李";

   public LaoLi() {
   }

   @Override
   public void getMessage(String s) {
       System.out.println(name + "接到了小美打過來的電話，電話內容是：->" + s);
   }

}

3、定義一個觀察者類

public class XiaoMei {
   List<Person> list = new ArrayList<Person>();
    public XiaoMei(){
    }

    public void addPerson(Person person){
        list.add(person);
    }

    //遍歷list，把自己的通知發送給所有暗戀自己的人
    public void notifyPerson() {
        for(Person person:list){
            person.getMessage("你們過來吧，誰先過來誰就能陪我一起玩兒遊戲!");
        }
    }
}

4、編寫一個測試類看看效果

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

       XiaoMei xiao_mei = new XiaoMei();
       LaoWang lao_wang = new LaoWang();
       LaoLi lao_li = new LaoLi();

       //小王和小李在小美那裏都註冊了一下
       xiao_mei.addPerson(lao_wang);
       xiao_mei.addPerson(lao_li);

       //小美向小王和小李發送通知
       xiao_mei.notifyPerson();
   }
}

裝飾者模式

1、定義一個父類

public class Food {

   private String food_name;

   public Food() {
   }

   public Food(String food_name) {
       this.food_name = food_name;
   }

   public String make() {
       return food_name;
   };
}

2、子類繼承父類

//麪包類
public class Bread extends Food {

   private Food basic_food;

   public Bread(Food basic_food) {
       this.basic_food = basic_food;
   }

   public String make() {
       return basic_food.make()+"+麪包";
   }
}

//奶油類
public class Cream extends Food {

   private Food basic_food;

   public Cream(Food basic_food) {
       this.basic_food = basic_food;
   }

   public String make() {
       return basic_food.make()+"+奶油";
   }
}

//蔬菜類
public class Vegetable extends Food {

   private Food basic_food;

   public Vegetable(Food basic_food) {
       this.basic_food = basic_food;
   }

   public String make() {
       return basic_food.make()+"+蔬菜";
   }

}

3、編寫一個測試類看看效果

public class Test {
   public static void main(String[] args) {
       Food food = new Bread(new Vegetable(new Cream(new Food("香腸"))));
       System.out.println(food.make());
   }
}

適配器模式

1、編寫一個是適配器

// 變壓器
class VoltageAdapter {
   // 改變電壓的功能
   public void changeVoltage() {
       System.out.println("正在充電...");
       System.out.println("原始電壓：" + Phone.V + "V");
       System.out.println("經過變壓器轉換之後的電壓:" + (Phone.V - 200) + "V");
   }
}

2、編寫一個手機類

// 手機類
class Phone {

   public static final int V = 220;// 正常電壓220v，是一個常量

   private VoltageAdapter adapter;

   // 充電
   public void charge() {
       adapter.changeVoltage();
   }

   public void setAdapter(VoltageAdapter adapter) {
       this.adapter = adapter;
   }
}

3、編寫一個測試類實現手機充電的功能

public class Test {
   public static void main(String[] args) {
       Phone phone = new Phone();
       VoltageAdapter adapter = new VoltageAdapter();
       phone.setAdapter(adapter);
       phone.charge();
   }
}

工廠模式

簡單工廠模式

一個抽象的接口，多個抽象接口的實現類，一個工廠類，用來實例化抽象的接口，具體代碼如下：
1、編寫一個抽象類

// 抽象產品類
abstract class Car {
   public void run();

   public void stop();
}

2、編寫具體實現類

// 具體實現類
class Benz implements Car {
   public void run() {
       System.out.println("Benz開始啓動了。。。。。");
   }

   public void stop() {
       System.out.println("Benz停車了。。。。。");
   }
}

class Ford implements Car {
   public void run() {
       System.out.println("Ford開始啓動了。。。");
   }

   public void stop() {
       System.out.println("Ford停車了。。。。");
   }
}

3、編寫一個工廠類

// 工廠類
class Factory {
   public static Car getCarInstance(String type) {
       Car c = null;
       if ("Benz".equals(type)) {
           c = new Benz();
       }
       if ("Ford".equals(type)) {
           c = new Ford();
       }
       return c;
   }
}

4、編寫一個測試類看看效果

public class Test {

   public static void main(String[] args) {
       Car c = Factory.getCarInstance("Benz");
       if (c != null) {
           c.run();
           c.stop();
       } else {
           System.out.println("造不了這種汽車。。。");
       }

   }
}

具體工廠模式

不再是由一個工廠類去實例化具體的產品，而是由抽象工廠的子類去實例化產品，具體代碼如下：

// 抽象產品角色
public interface Moveable {
   void run();
}

// 具體產品角色
public class Plane implements Moveable {
   @Override
   public void run() {
       System.out.println("plane....");
   }
}

public class Broom implements Moveable {
   @Override
   public void run() {
       System.out.println("broom.....");
   }
}

// 抽象工廠
public abstract class VehicleFactory {
   abstract Moveable create();
}

// 具體工廠
public class PlaneFactory extends VehicleFactory {
   public Moveable create() {
       return new Plane();
   }
}

public class BroomFactory extends VehicleFactory {
   public Moveable create() {
       return new Broom();
   }
}

// 測試類
public class Test {
   public static void main(String[] args) {
       VehicleFactory factory = new BroomFactory();
       Moveable m = factory.create();
       m.run();
   }
}

抽象工廠模式

抽象工廠模式中的工廠生產多個產品，具體代碼如下：

//抽象工廠類
public abstract class AbstractFactory {
   public abstract Vehicle createVehicle();
   public abstract Weapon createWeapon();
   public abstract Food createFood();
}
//具體工廠類，其中Food,Vehicle，Weapon是抽象類，
public class DefaultFactory extends AbstractFactory{
   @Override
   public Food createFood() {
       return new Apple();
   }
   @Override
   public Vehicle createVehicle() {
       return new Car();
   }
   @Override
   public Weapon createWeapon() {
       return new AK47();
   }
}
//測試類
public class Test {
   public static void main(String[] args) {
       AbstractFactory f = new DefaultFactory();
       Vehicle v = f.createVehicle();
       v.run();
       Weapon w = f.createWeapon();
       w.shoot();
       Food a = f.createFood();
       a.printName();
   }
}

代理模式

1、編寫一個代理接口

//代理接口
public interface ProxyInterface {
  //需要代理的是結婚這件事，如果還有其他事情需要代理，比如喫飯睡覺上廁所，也可以寫
  void marry();
  //代理喫飯(自己的飯，讓別人喫去吧)
  //void eat();
  //代理拉屎，自己的屎，讓別人拉去吧
  //void shit();
}

2、實現代理接口類-婚慶公司類

public class WeddingCompany implements ProxyInterface {

  private ProxyInterface proxyInterface;

  public WeddingCompany(ProxyInterface proxyInterface) {
   this.proxyInterface = proxyInterface;
  }

  @Override
  public void marry() {
   System.out.println("我們是婚慶公司的");
   System.out.println("我們在做結婚前的準備工作");
   System.out.println("節目彩排...");
   System.out.println("禮物購買...");
   System.out.println("工作人員分工...");
   System.out.println("可以開始結婚了");
   proxyInterface.marry();
   System.out.println("結婚完畢，我們需要做後續處理，你們可以回家了，其餘的事情我們公司來做");
  }

}

3、實現代理接口類-結婚家庭類

public class NormalHome implements ProxyInterface{

  @Override
  public void marry() {
   System.out.println("我們結婚啦～");
  }

}

4、編寫測試類看看效果

public class Test {
  public static void main(String[] args) {
   ProxyInterface proxyInterface = new WeddingCompany(new NormalHome());
   proxyInterface.marry();
  }
}