設計模式-工廠模式
分類 工廠模式延伸了三類
簡單工廠模式
定義
- 屬於類的創建型模式,又叫做靜態工廠方法模式。
- 通過專門定義一個工廠類來負責創建其他類的實例，被創建的實例通常都具有共同的父類。
- 將抽象子類的創建，和關於抽象子類相關的業務邏輯分離
主要組成
工廠類：核心類，根據外界的需求，決定創建並返回哪個具體的抽象子類。抽象類：定義抽象子類所需的屬性和方法，子類通過繼承自抽象類獲得這些方法。抽象子類：繼承自抽象類，是具體操作的實現者，根據需求重寫父類繼承過來的方法。
UML類圖
![在這裏插入圖片描述]()
代碼實現
Compare.java(抽象類)
public abstract class Compare {
protected String strA = "";
protected String strB = "";
public abstract boolean GetResutl();
public Compare() {
super();
}
public Compare(String strA, String strB) {
super();
this.strA = strA;
this.strB = strB;
}
public String getStrA() {
return strA;
}
public void setStrA(String strA) {
this.strA = strA;
}
public String getStrB() {
return strB;
}
public void setStrB(String strB) {
this.strB = strB;
}
}
CompareFactory
public class CompareFactory{
public static Compare createCompare(String strA, String strB, String compare) {
Compare comp = null;
switch (compare) {
case "<":
comp = new LtCompare(strA,strB);
break;
case "<=":
comp = new LtOREqualCompare(strA,strB);
break;
case "=":
comp = new EqualCompare(strA,strB);
break;
case ">":
comp = new GtCompare(strA,strB);
break;
case ">=":
comp = new GtOREqualCompare(strA,strB);
break;
default :
comp = new EqualCompare(strA,strB);
break;
}
return comp;
}
}
抽象子類
public class LtCompare extends Compare {
public LtCompare(){
super();
}
public LtCompare(String strA, String strB){
super(strA,strB);
}
@Override
public boolean GetResutl() {
return NumberUtil.compare(Double.parseDouble(strA),Double.parseDouble(strB)) == -1
? true : false;
}
}
public class EqualCompare extends Compare {
public EqualCompare() {
super();
}
public EqualCompare(String strA, String strB) {
super(strA, strB);
}
@Override
public boolean GetResutl() {
return strA.equals(strB) ? true : false;
}
}
public class GtCompare extends Compare {
public GtCompare(){
super();
}
public GtCompare(String strA, String strB){
super(strA,strB);
}
@Override
public boolean GetResutl() {
return NumberUtil.compare(Double.parseDouble(strA),Double.parseDouble(strB)) == 1
? true : false;
}
}
LtOREqualCompare.java(小於或等於比較類)
public class LtOREqualCompare extends Compare {
public LtOREqualCompare(){
super();
}
public LtOREqualCompare(String strA, String strB){
super(strA,strB);
}
@Override
public boolean GetResutl() {
double d1 = Double.parseDouble(strA);
double d2 = Double.parseDouble(strB);
return NumberUtil.compare(d1,d2) <= 0
? true : false;
}
}
GtOREqualCompare.java(大於或等於比較類)
public class GtOREqualCompare extends Compare {
public GtOREqualCompare() {
super();
}
public GtOREqualCompare(String strA, String strB) {
super(strA,strB);
}
@Override
public boolean GetResutl() {
double d1 = Double.parseDouble(strA);
double d2 = Double.parseDouble(strB);
return NumberUtil.compare(d1,d2) >= 0
? true : false;
}
}
測試
public class CompareTest {
public static void main(String[] args) {
Compare compare;
String str1;
String str2;
str1 = "10.666";
str2 = "10.50";
compare = CompareFactory.createCompare(str1,str2,"<");
System.out.println("str1 < str2 : "+compare.GetResutl());
compare = CompareFactory.createCompare(str1,str2,"=");
System.out.println("str1 = str2 : "+compare.GetResutl());
compare = CompareFactory.createCompare(str1,str2,">");
System.out.println("str1 > str2 : "+compare.GetResutl());
compare = CompareFactory.createCompare(str1,str2,"<=");
System.out.println("str1 <= str2 : "+compare.GetResutl());
compare = CompareFactory.createCompare(str1,str2,">=");
System.out.println("str1 >= str2 : "+compare.GetResutl());
}
}
運行結果
str1 < str2 : false
str1 = str2 : false
str1 > str2 : true
str1 <= str2 : false
str1 >= str2 : true
優缺點
優點
缺點
- 工廠類中集中了所有實力的創建邏輯，所以 高內聚 這方面做的不夠好，
- 當具體 抽象子類增多時，需要修改工廠類代碼。擴展性不夠好
使用場景
- 簡單工廠模式主要適用於抽象子類的業務邏輯相同，但具體實現不同的情況。
- 以上例子中，兩個數的比較的方式不外乎就是以上哪幾種，具體實現種類不多的情況下 是適合用
簡單工廠模式 的
工廠方法模式
定義
- 屬於類的創建型模式。
- 定義一個用於創建對象的接口，讓子類決定實例化哪一個類。工廠方法使一個類的實例化延遲到其子類。
- 工廠方法針對每一種產品提供一個工廠類，通過不同的工廠實例來創建不同的產品實例，相比於
簡單工廠模式來說，不再提供一個統一的工廠創建所有的對象
主要組成
抽象工廠類：抽象類，提供創建抽象子類的接口方法，不參與創建實例。具體工廠類：實現抽象工廠接口的具體工廠類，用於創建具體抽象子類。抽象類：定義抽象子類所需的屬性和方法，子類通過繼承自抽象類獲得這些方法。抽象子類：繼承自抽象類，是具體操作的實現者，根據需求重寫父類繼承過來的方法。
UML類圖
![在這裏插入圖片描述]()
代碼實現
CompareFactory.java(抽象工廠類)
public interface CompareFactory{
public Compare createCompare();
}
LtCompareFactory.java (具體工廠類)
public class LtCompareFactory implements CompareFactory{
@Override
public Compare createCompare() {
return new LtCompare();
}
}
GtCompareFactory.java (具體工廠類)
public class GtCompareFactory implements CompareFactory{
@Override
public Compare createCompare() {
return new GtCompare();
}
}
EqualCompareFactory.java (具體工廠類)
public class EqualCompareFactory implements CompareFactory{
@Override
public Compare createCompare() {
return new EqualCompare();
}
}
LtOREqualCompareFactory.java (具體工廠類)
public class LtOREqualCompareFactory implements CompareFactory{
@Override
public Compare createCompare() {
return new LtOREqualCompare();
}
}
GtOREqualCompareFactory.java (具體工廠類)
public class GtOREqualCompareFactory implements CompareFactory{
@Override
public Compare createCompare() {
return new GtOREqualCompare();
}
}
以下類與簡單工廠模式的一樣
Compare.java- 抽象類EqualCompare.java - 抽象子類LtCompare.java - 抽象子類GtCompare.java - 抽象子類GtOREqualCompare.java - 抽象子類LtOREqualCompare.java - 抽象子類
測試
public class CompareTest {
public static void main(String[] args) {
Compare compare;
compare = new GtCompareFactory().createCompare();
compare.setStrA("100");
compare.setStrB("50");
System.out.println(compare.GetResutl());
compare = new LtCompareFactory().createCompare();
compare.setStrA("100");
compare.setStrB("50");
System.out.println(compare.GetResutl());
compare = new EqualCompareFactory().createCompare();
compare.setStrA("100");
compare.setStrB("50");
System.out.println(compare.GetResutl());
}
}
運行結果
true
false
false
優缺點
優點
Client不需要再負責對象的創建，明確的各個類的職責- 增加新的對象，只要增加一個具體的類和具體的工廠類即可
- 不會影響已有的代碼，可維護性、擴展性好
缺點
抽象工廠模式
總結
簡單工廠：使用一個工廠對象用來創建同一等級結構中的任意比較對象 (Compare)。（不支持拓展增加 比較類）工廠方法：使用多個工廠對象用來創建同一等級結構中對應的固定比較對象 (Compare)。（支持拓展增加 比較類）
感謝
感謝您的閱讀，有收穫？希望兄弟姐妹三叔六嬸大姨大媽阿公阿婆來個三連擊，給更多的同學看到 這篇文章，感謝
你的每一次回眸都是永恆，每一次鼓勵都是我前進的動力，每一次分享都是對我的認可。
