面試之Java的六大設計模式思想詳解

1 單例模式

單例模式可以說是大多數開發人員在實際中使用最多的，常見的Spring默認創建的bean就是單例模式的。

單例模式有很多好處，比如可節約系統內存空間，控制資源的使用。

其中單例模式最重要的是確保對象只有一個。

簡單來說，保證一個類在內存中的對象就一個。

RunTime就是典型的單例設計，我們通過對RunTime類的分析，一窺究竟。

源碼剖析：

/**
 * Every Java application has a single instance of class
 * <code>Runtime</code> that allows the application to interface with
 * the environment in which the application is running. The current
 * runtime can be obtained from the <code>getRuntime</code> method.
 * An application cannot create its own instance of this class.
 * @author  unascribed
 * @see     java.lang.Runtime#getRuntime()
 * @since   JDK1.0
 */

public class Runtime {
    //1、創建靜態的全局唯一的對象
    private static Runtime currentRuntime = new Runtime(); 
    //2、私有構造方法，不讓外部來調用
    /** Don't let anyone else instantiate this class */
    private Runtime() {} 
    //3、通過自定義的靜態方法獲取實例
    public static Runtime getRuntime() {
        return currentRuntime;
    }
}

上面代碼沒有看懂的話，我在給你舉個例子。或者簡單點說，單例模式中，就是一個應用程序中，某個類的實例對象只有一個，你沒有辦法去new，因爲構造器是被private修飾的，一般通getInstance()的方法來獲取它們的實例。

getInstance()的返回值是一個對象的引用，並不是一個新的實例，所以不要錯誤的理解成多個對象。

public class Singleton {

private static Singleton singleton;

private Singleton() {}

public static Singleton getInstance() {
	 if (singleton == null) {
		  singleton = new Singleton();
	 }
	 return singleton;
		}
}

單例模式實現非常簡單，下面我再多謝幾種單例模式的寫法：

懶漢式（線程安全）：

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

餓漢式寫法：

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

靜態內部類：

public class Singleton {  
	private static class SingletonHolder {  
	   private static final Singleton INSTANCE = new Singleton();  
   }  
	   private Singleton (){}  
		   public static final Singleton getInstance() {  
			   return SingletonHolder.INSTANCE;  
	   }  
}

枚舉：

public enum Singleton {  
   INSTANCE;  
   public void whateverMethod() {  
   }  
}

這種方式是Effective Java作者Josh Bloch 提倡的方式，它不僅能避免多線程同步問題，而且還能防止反序列化重新創建新的對象，可謂是很堅強的壁壘啊。

雙重校驗鎖：

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

總結：
首先，爲什麼要私有化構造方法呢，目的就是爲了控制外界創建對象的權利。如果還想用靜態方法，就用類名訪問（修飾成靜態的）。

2 觀察者模式

對象間一對多的依賴關係，當一個對象的狀態發生改變時，所有依賴於它的對象都得到通知並被自動更新。
觀察者模式UML圖

看不懂圖的人端着小板凳到這裏來，給你舉個栗子：假設有三個人，小美（女，22），小王和小李。小美很漂亮，小王和小李是兩個程序猿，時刻關注着小美的一舉一動。有一天，小美說了一句：“誰來陪我打遊戲啊。”這句話被小王和小李聽到了，結果樂壞了，蹭蹭蹭，沒一會兒，小王就衝到小美家門口了，在這裏，小美是被觀察者，小王和小李是觀察者，被觀察者發出一條信息，然後觀察者們進行相應的處理，看代碼：

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

這個接口相當於小王和小李的電話號碼，小美髮送通知的時候就會撥打getMessage這個電話，撥打電話就是調用接口，看不懂沒關係，先往下看：

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);
	}
}

代碼很簡單，我們再看看小美的代碼：

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("你們過來吧，誰先過來誰就能陪我一起玩兒遊戲!");
        }
    }
}

我們寫一個測試類來看一下結果對不對：

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();
   }
}

3 裝飾者模式

對已有的業務邏輯進一步的封裝，使其增加額外的功能，如Java中的IO流就使用了裝飾者模式，用戶在使用的時候，可以任意組裝，達到自己想要的效果。舉個栗子，我想喫三明治，首先我需要一根大大的香腸，我喜歡喫奶油，在香腸上面加一點奶油，再放一點蔬菜，最後再用兩片面包夾一下，很豐盛的一頓午飯，營養又健康。（ps：不知道上海哪裏有賣好喫的三明治的，求推薦～）那我們應該怎麼來寫代碼呢？首先，我們需要寫一個Food類，讓其他所有食物都來繼承這個類，看代碼：

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

代碼很簡單，然後我們寫幾個子類繼承它：

//麪包類
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()+"+蔬菜";
	}
}

這幾個類都是差不多的，構造方法傳入一個Food類型的參數，然後在make方法中加入一些邏輯，最後來做個測試。

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

看到沒有，一層一層封裝，我們從裏往外看：最裏面new了一個香腸，在香腸的外面包裹了一層奶油，在奶油的外面又加了一層蔬菜，最外面放的是麪包，是不是很形象。這個設計模式簡直跟現實生活中一摸一樣，看懂了嗎？看看運行結果吧

運行結果：

4 適配器模式

將兩種完全不同的事物聯繫到一起，就像現實生活中的變壓器。假設一個手機充電器需要的電壓是20V，但是正常的電壓是220V，這時候就需要一個變壓器，將220V的電壓轉換成20V的電壓，這樣，變壓器就將20V的電壓和手機聯繫起來了。

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


// 手機類
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;
   }
}

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

5 工廠模式

簡單工廠模式：一個抽象的接口，多個抽象接口的實現類，一個工廠類，用來實例化抽象的接口

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

   public void stop();
}

// 具體實現類
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停車了。。。。");
   }
}

// 工廠類
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;
   }
}

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();
   }
}

6 代理模式

有兩種，靜態代理和動態代理。先說靜態代理，什麼真實角色，抽象角色，代理角色，委託角色。基本上都是給你分析有什麼什麼角色，理論一大堆，這裏咱們直接用生活中的例子說話。

到了一定的年齡，我們就要結婚，結婚是一件很麻煩的事情，（包括那些被父母催婚的）。有錢的家庭可能會找司儀來主持婚禮，顯得熱鬧，洋氣～好了，現在婚慶公司的生意來了，我們只需要給錢，婚慶公司就會幫我們安排一整套結婚的流程。整個流程大概是這樣的：家裏人催婚->男女雙方家庭商定結婚的黃道即日->找一家靠譜的婚慶公司->在約定的時間舉行結婚儀式->結婚完畢

婚慶公司打算怎麼安排婚禮的節目，在婚禮完畢以後婚慶公司會做什麼，我們一概不知。我們只要把錢給人家，人家會把事情給我們做好。所以，這裏的婚慶公司相當於代理角色。

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

看看婚慶公司的代碼：

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("結婚完畢，我們需要做後續處理，你們可以回家了，其餘的事情我們公司來做");
}
}

婚慶公司需要做的事情很多，再看看結婚家庭的代碼：

public class NormalHome implements ProxyInterface{

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

這個已經很明顯了，結婚家庭只需要結婚，而婚慶公司要包攬一切，前前後後的事情都是婚慶公司來做，聽說現在婚慶公司很賺錢的，這就是原因，乾的活多，能不賺錢嗎？

來看看測試類代碼：

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

運行結果如下：

面試之Java的六大設計模式思想詳解

1 單例模式

源碼剖析：

懶漢式（線程安全）：

餓漢式寫法：

靜態內部類：

枚舉：

雙重校驗鎖：

2 觀察者模式

3 裝飾者模式

4 適配器模式

5 工廠模式

6 代理模式

IO流的基礎案例

如何理解MapReduce計算器，這篇文章能給你答案

Java---OOP之多態

VMware安裝CentOS詳細圖解，收藏必備

關於Web前端之HTML5，你知道多少？

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結