• 一. 為什麼要學設計模式

1. 我們在學習程式設計的時候，都有了解過設計模式，通過這些模式讓你找到“封裝變化” 、“物件間鬆散耦合”、“針對介面程式設計”的感覺，從而設計出易維護、易擴充套件、易複用、靈活性好的成語。學好設計模式，培養好面向物件的程式設計思維。

• 二.簡單工廠模式

1. 簡單工廠模式就是通過一個工廠類來建立你需要的不同的例項。

比如 現在來實現一個簡單的計算器

public class SampleFactory {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		
		System.out.println("請輸入第一個數字：");
		double first = Double.parseDouble(in.next());
		
		System.out.println("請輸入運算子號");
		String operType = in.next();
		
		System.out.println("請輸入第二個數字");
		double second = Double.parseDouble(in.next());
		
		in.close();
		double resultTest = 0;
		Operation_test operTest = new Operation_test();
		switch(operType) {
		case "+" :
			resultTest = operTest.getAddResult(first, second);
			break;
		case "-" :
			resultTest = operTest.getSubResult(first, second);
			break;
		case "*" :
			resultTest = operTest.getMulResult(first, second);
			break;
		case"/" :
			try {
				resultTest = operTest.getDivResult(first, second);
			} catch (Exception e1) {
				System.out.println(e1.getMessage());
			}
			break;
}
	System.out.println(first + operType +second + "=" + resultTest );
}

}

public class Operation_test {
	
	public double getAddResult(double numberA,double numberB) {
		double result = numberA + numberB;
		
		return result;
	}
	public double getSubResult(double numberA,double numberB) {
		double result = numberA - numberB;
		
		return result;
	}
	public double getMulResult(double numberA,double numberB) {
		double result = numberA * numberB;
		
		return result;
	}
	
	public double getDivResult(double numberA,double numberB) throws Exception {
		double result = 0;
		if(numberB== 0) {
			throw new Exception("除數不能為0");
		}else {
			result = numberA / numberB;
		}
		return result;
}
}

 

這樣看已經實現了基本的實現了計算器的基本四種運算，如果要在繼續新增其他的計算方式在運算類中就可以了，但是所有的計算方式都在一個類中，如果修改其中一個，影響到了其他的幾種計算方式，或者隨這計算的方式增加，這個計算類的可維護性就會變差，這個時候我們就要用到了設計模式。

1 簡單工廠模式來實現

首先我們建立一個父類來將計算所需要的屬性與方法放進去（封裝）

/**
 * 
 */
package sample_factory;

/**
 * @author manyi
 * 
 * 計算方法父類
 */
public class Operation {
		
	private double numberA;
		
	private double numberB;
		
		public double getNumberA() {
			return numberA;
		}
		public void setNumberA(double numberA) {
			this.numberA = numberA;
		}
		public double getNumberB() {
			return numberB;
		}
		public void setNumberB(double numberB) {
			this.numberB = numberB;
		}
		
		public double getResult() throws Exception {
			double result = 0;
			return result;
		}
		
}
 

然後我們建立計算方法的具體實現子類（繼承）

/**
 * 
 */
package sample_factory;

/**
 * @author manyi
 * 
 * 加法計算類
 */
public class OperationAdd extends	Operation{
	
	public double getResult() {
		
		double result = 0	;
		result = getNumberA() + getNumberB();
		return result;
		
	}
}

/**
 * 
 */
package sample_factory;

/**
 * @author manyi

 * 減法運算類
 */
public class OperationSub extends Operation{

	public double getResult() {
		double result = 0;
		result = getNumberA() - getNumberB();
		return result;
	}
}

/**
 * 
 */
package sample_factory;

/**
 * @author manyi

 * 乘法運算類
 */
public class OperationMul extends Operation{
	
	public double getResult() {
		double result = 0;
		result = getNumberA() * getNumberB();
		return result;
	}
}

/**
 * 
 */
package sample_factory;

/**
 * @author manyi
 * 除法計算類
 */
public class OperationDiv extends Operation{
	
	public double getResult() throws Exception {
		double result = 0 ;
		
		if(getNumberB() == 0) {
			throw new Exception("除數不能為0");
		}else {
			result = getNumberA() / getNumberB();
		}
		return result;
	}
}



 

接下來建立工廠類來根據客戶端傳來的計算方式來建立返回正確的計算方式例項（多型）

/**
 * 
 */
package sample_factory;

/**
 * @author manyi
 * 計算工廠類
 * @return 返回一個輸入的計算方法類例項
 */
public class OperationFactory {
		public static Operation createOperation(String type) {
			Operation oper = null;
			
			switch(type) {
					case "+" :
						oper = new OperationAdd();
						break;
					case "-" :
						oper = new OperationSub();
						break;
					case "*" :
						oper = new OperationMul();
						break;
					case"/" :
						oper = new OperationDiv();
						break;
			}
			
			return oper;
		}
}

/**
 * 
 */
package sample_factory;

import java.util.Scanner;

/**
 * @author manyi
 * @Date 2018年12月9日
 */
public class SampleFactory {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		
		System.out.println("請輸入第一個數字：");
		double first = Double.parseDouble(in.next());
		
		System.out.println("請輸入運算子號");
		String operType = in.next();
		
		System.out.println("請輸入第二個數字");
		double second = Double.parseDouble(in.next());
		
		in.close();
	
		new OperationFactory(); //建立一個計算工廠類例項
		Operation oper = OperationFactory.createOperation(operType);// 通過傳入的計算符號返回一個對應的計算類例項
		oper.setNumberA(first);
		oper.setNumberB(second);
		double result = 0;
		try {
			 result = oper.getResult();
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
		System.out.println(first + operType +second + "=" + result);
		
	}
}

這樣就減少了計算方法之間的耦合，修改其中一個也不會影響其他的方法，增加的新的方法時新增一個新的計算類繼承父類就可以實現了。

優點： 
1、使用者想建立一個物件，只要知道其名稱就可以從工廠中獲取物件。 
2、擴充套件性高，如果想增加一個產品，只要擴充套件一個具體產品類就可以。 
3、遮蔽產品的具體實現，使用者只關心產品的介面。 
缺點： 
每次增加一個產品時，都需要增加一個具體類和物件實現工廠，使得程式中出現大量的類，在一定程度上增加系統的複雜度。