工廠設計模式

❶ java什麼是工廠設計模式

把創建對象的工作，交給一個抽象出來的概念'工廠'去做，就是工廠設計模版式。比如,你要新建一個用權戶對象 User user=new User();這很簡單，也好理解。但是如果你用工廠設計模式去做，就算最簡單的實現你也得加個類型，如：UserFactory，而裡面的代碼可能只是：
public static User getUser(){
return new User();
}
在使用的時候就是變成：User user = UserFactory.getUser();
嗯，看起來是多此一舉，沒錯，我這場景就是多此一舉。工廠模式適用場景，首先得有較復雜的子父類結構，再者創建邏輯可能很復雜，這樣才有意義，才有必要去使用工廠模式。又或者這個傻逼對象創建起來很消耗性能，且不是非得是全新的才能用，那麼可以配合單例模式一起使用，實現對象的復用，達到性能優化的目的。
嗯，你可能又會疑惑，啥是單例，給你個很傻的描述：有個神奇的類，他有個神奇的方法，這個方法會幫你創建一個對象，且不管調用幾次，怎麼調用，他都保證只給你一個，且百分百是同一個。

❷ Java中常用的設計模式有哪些請詳細說明一下工廠模式。

1.單例模式（有的書上說叫單態模式其實都一樣）
該模式主要目的是使內存中保持1個對象
2.工廠模式
該模式主要功能是統一提供實例對象的引用。看下面的例子：
public class Factory{
public ClassesDao getClassesDao(){
ClassesDao cd = new ClassesDaoImpl();
return cd;
}
}
interface ClassesDao{
public String getClassesName();
}
class ClassesDaoImpl implements ClassesDao {
public String getClassesName(){
System.out.println("A班");
}
}
class test
{
public static void main(String[] args){
Factory f = new Factory();
f.getClassesDao().getClassesName();
}
}
這個是最簡單的例子了，就是通過工廠方法通過介面獲取對象的引用
3.建造模式
該模式其實就是說，一個對象的組成可能有很多其他的對象一起組成的，比如說，一個對象的實現非常復雜，有很多的屬性，而這些屬性又是其他對象的引用，可能這些對象的引用又包括很多的對象引用。封裝這些復雜性，就可以使用建造模式。
4.門面模式
這個模式個人感覺像是Service層的一個翻版。比如Dao我們定義了很多持久化方法，我們通過Service層將Dao的原子方法組成業務邏輯，再通過方法向上層提供服務。門面模式道理其實是一樣的。
5.策略模式
這個模式是將行為的抽象，即當有幾個類有相似的方法，將其中通用的部分都提取出來，從而使擴展更容易。

❸ java 工廠設計模式有什麼好處 回到最好能通俗一點

如果用工廠模式，你只需要修改工廠代碼。其他地方引用工廠，可以做到只修改一個地方，其他代碼都不動，就是解耦了，也就是降低了代碼的耦合性

❹ 什麼是PHP中的工廠設計模式

工廠模式分為三種：簡單工廠、工廠方法、抽象工廠 ,三種工廠的區別是，抽象工廠由多條產品線，而工廠方法只有一條產品線，是抽象工廠的簡化。而工廠方法和簡單工廠相對，大家初看起來好像工廠方法增加了許多代碼但是實現的功能和簡單工廠一樣。但本質是，簡單工廠並未嚴格遵循設計模式的開閉原則，當需要增加新產品時也需要修改工廠代碼。但是工廠方法則嚴格遵守開閉原則，模式只負責抽象工廠介面，具體工廠交給客戶去擴展。在分工時，核心工程師負責抽象工廠和抽象產品的定義，業務工程師負責具體工廠和具體產品的實現。只要抽象層設計的好，框架就是非常穩定的。

❺ 工廠設計模式的作用是什麼

在面向對象編程中, 最通常的方法是一個new操作符產生一個對象實例,new操作符就是用來構造對象實例的。但是在一些情況下, new操作符直接生成對象會帶來一些問題。舉例來說, 許多類型對象的創造需要一系列的步驟: 你可能需要計算或取得對象的初始設置; 選擇生成哪個子對象實例; 或在生成你需要的對象之前必須先生成一些輔助功能的對象。 在這些情況, 新對象的建立就是一個 「過程」，不僅是一個操作，像一部大機器中的一個齒輪傳動。
問題
你如何能輕松方便地建立這么" 復雜 " 的對象即操作中不需要粘貼復制呢?

解決方法
建立一個工廠（一個函數或一個類方法）來製造新的對象。為了理解工廠的用處, 試想以下的不同之處……
下載php設計模式.chm

❻ Java，設計模式，簡單工廠。

這個問題很簡單啊，就是一個介面，N個具體類，然後創建一個抽象工廠根據傳入的類名生成不同的處理類。首先看看工程結構圖：

Common介面：

packagepkg1.pkg2;

/**

*Common計算介面

*

*@author

*

*/

publicinterfaceCommon{

//介面方法返回結算結果

publiclongcalulate(inta,intb,intc);

}

packagepkg1;

importpkg1.pkg2.Common;

/**

*Car007具體實現

*

*@author

*

*/

{

publiclongcalulate(inta,intb,intc){

returna*b/c;

}

}

packagepkg1;

importpkg1.pkg2.Common;

/**

*Plane具體實現

*

*@author

*

*/

{

publiclongcalulate(inta,intb,intc){

returna+b+c;

}

}

importpkg1.pkg2.Common;

/**

*主程序應用方法

*

*@author

*

*/

publicclassComputeTime{

/**

*獲得Common對象

*

*@paramclazz

*@return

*/

(Stringclazz){

Commoncommon=null;

//生成介面對象

try{

common=(Common)Class.forName("pkg1."+clazz).newInstance();

}

catch(InstantiationExceptione){

e.printStackTrace();

}

catch(IllegalAccessExceptione){

e.printStackTrace();

}

catch(ClassNotFoundExceptione){

e.printStackTrace();

}

returncommon;

}

/**

*計算運行distance所需要的時間

*

*@paramdistance

*距離

*@paramcommon

*計算速度的介面對象

*@parama

*@paramb

*@paramc

*@return

*/

publicstaticdoublecalulate(longdistance,Commoncommon,inta,intb,intc){

if(common!=null){returndistance/common.calulate(a,b,c);}

return0;

}

/**

*主程序方法

*

*@paramargs

*/

publicstaticvoidmain(String[]args){

if(args==null||args.length<4){

System.out.println("參數個數不正確!正確格式:javaComputeTimeXXABC");

return;

}

//獲得a

inta=Integer.parseInt(args[1]);

//獲得b

intb=Integer.parseInt(args[2]);

//獲得c

intc=Integer.parseInt(args[3]);

//計算1000公里的時間

System.out.println(args[0]+"運行1000公里所需的時間為："+calulate(1000,getCommonObject(args[0]),a,b,c)+"小時");

}

}

最後程序運行結果：

MicrosoftWindowsXP[版本5.1.2600]

(C)版權所有1985-2001MicrosoftCorp.

E:>cdE:workspace estin

E:workspace estin>javaComputeTimePlane203040

Plane運行1000公里所需的時間為：11.0小時

E:workspace estin>javaComputeTimeCar007233445

Car007運行1000公里所需的時間為：58.0小時

E:workspace estin>

❼ java 設計模式（工廠方法）

面向抽象（抽象類或介面）編程。
IWorkFactory studentWorkFactory = new StudentWorkFactory(); 注意：類型是介面類型，即抽象工廠，抽象工廠生產的是抽象產品，而new的則是具體工廠，是由子類實現的，具體工廠生產具體產品。面向抽象的好處：1.在設計抽象的時候不用管具體的實現，只要定義介面知道它用來干什麼就行，這樣，我只需要知道抽象介面就能繼續下面的開發設計工作了，而不用事先設計具體的實現內容；2. 可以擴展多個子類實現抽象介面，更利於系統後期的擴展，而對原系統不造成任何影響，即：開-閉原則。

TeacherWork tt = new TeacherWork(); 不用說就是面向具體實現類編程，缺點就是擴展性不好，對系統後期維護擴展影響較大。

舉個簡單的例子：
假如在系統的A.java中代碼中使用了TeacherWork 類型對象，是滿足了目前軟體的需求，但是，如果有一天需求變化了需要一個StudentWork 類型對象，該怎麼辦？只能修改A.java類來滿足這樣的修改需求。這樣就影響了原來系統結構穩定性，需要重新調試和測試，而這帶來的維護成本是非常大的，有時可能還會帶來系統錯誤，而影響系統運行。
如果在A.java類中應用Work介面類型就不會存在這種問題，A.java不需要任何修改，只需要修改注入到A中的Work介面的具體實現類即可。

面向抽象編程的好處就在於對系統維護和擴展上，即在不影響原系統穩定運行的基礎上增加新的擴展行為，即要符合「開-閉」原則。可能會因此而失去一定的效率問題，但是對於後期的維護成本來說，這個可以忽略不計。 推薦你一本好書：《軟體秘笈-設計模式那點事》其中講解的設計模式很到位，還有每個模式的靜態類圖和JDK中設計模式的具體分析講解，讀了收獲一定很大。祝你成功！

❽ mvc模式和工廠設計模式是同一層次上的概念

簡單工廠模式（Simple Factory Pattern），又稱靜態工廠模式（Static Factory Pattern）。舉兩個例子以快速明白Java中的簡單工廠模式：

女媧摶土造人
話說：「天地開辟，未有人民，女媧摶土為人。」女媧需要用土造出一個個的人，但在女媧造出人之前，人的概念只存在於女媧的思想裡面。
女媧造人，這就是簡單工廠模式的應用。

首先，在這個造人的思想裡面，有幾個重要的角色：女媧本身、抽象的人的概念和女媧所造出的一個個具體的人。
1.）女媧是一個工廠類，也就是簡單工廠模式的核心角色。

2.）具休的一個個的人，包括張三，李四等。這些人便是簡單工廠模式裡面的具體產品角色
3.）抽象的人是最早只存在於女媧的頭腦里的一個想法，女媧按照這個想法造出的一個個具體的人，便都符合這個抽象的人的定義。換言之，這個抽象的想法規定了所有具體的人必須都有的介面（特徵或者功能）


注意：女媧與張三，李四屬於創建依賴關系，上圖箭頭應該是虛線（實現代表關聯關系）。而張三，李四與人屬於實現關系，上圖三角形頭的箭頭也應該是虛線（實線代表繼承關系）。

理解了上面的這些東西，再來理解下面的例子，對照理解，相信看完這篇文章，便對java簡單工廠模式有一個很好的理解：

有一個農場公司，專門向市場銷售各類水果，在這個系統里需要描述下列水果：
葡萄Grape
草莓Strawberry
蘋果Apple
水果與其他植物不同，最終可以採摘食用，那麼一個自然的做法是建立一個各種水果都適用的介面，以便與其他農場里的植物區分開來，
此時，則是為水果類聲明了一個介面，表現在代碼上：
public interface Fruit
{
//種植
public void plant();

//生長
public void grow();

//收獲
public void harvest();
}
水果介面規定出所有的水果必須實現的介面，包括任何水果類必須具備的方法plant(),grow(),和harvest();

Apple類是水果類的一種，因此它實現了水果介面所聲明的所有方法。另處，由於蘋果是多年生植物，因此多出一個treeAge性質，描述蘋果的樹齡。代碼如下所示：
/**
*
* 類名稱：Apple
* 類描述：農場蘋果類
*
*/
public class Apple implements Fruit
{
/**
* 蘋果為多年生植物
*/
private int treeAge;
/* (non-Javadoc)
* @see fac.Fruit#grow()
*/
@Override
public void grow()
{
System.out.println("蘋果開始生長。。。");
}
/* (non-Javadoc)
* @see fac.Fruit#harvest()
*/
@Override
public void harvest()
{
System.out.println("蘋果開始收獲。。。");
}
/* (non-Javadoc)
* @see fac.Fruit#plant()
*/
@Override
public void plant()
{
System.out.println("蘋果種入農場。。。");
}
public int getTreeAge()
{
return treeAge;
}
public void setTreeAge(int treeAge)
{
this.treeAge = treeAge;
}

}
同理，葡萄Grape：
public class Grape implements Fruit
{
/**
* 葡萄分為有籽無籽
*/
private boolean seedless;

/* (non-Javadoc)
* @see fac.Fruit#grow()
*/
@Override
public void grow()
{
System.out.println("葡萄開始生長。。。");
}
/* (non-Javadoc)
* @see fac.Fruit#harvest()
*/
@Override
public void harvest()
{
System.out.println("葡萄開始收獲。。。");
}
/* (non-Javadoc)
* @see fac.Fruit#plant()
*/
@Override
public void plant()
{
System.out.println("葡萄種入農場。。。");
}
public boolean isSeedless()
{
return seedless;
}
public void setSeedless(boolean seedless)
{
this.seedless = seedless;
}

}
草莓Stuawberry：
public class Strawberry implements Fruit
{
/* (non-Javadoc)
* @see fac.Fruit#grow()
*/
@Override
public void grow()
{
System.out.println("草莓開始生長。。。");
}
/* (non-Javadoc)
* @see fac.Fruit#harvest()
*/
@Override
public void harvest()
{
System.out.println("草莓開始收獲。。。");
}
/* (non-Javadoc)
* @see fac.Fruit#plant()
*/
@Override
public void plant()
{
System.out.println("草莓種入農場。。。");
}
}
農場園丁也是系統的一部分，由一個類來代表，FruitGardener類，代碼如下：
public class FruitGardener
{
public static Fruit factory(String which) throws Exception
{
if(which.equalsIgnoreCase("apple"))
{
return new Apple();
}
else if(which.equalsIgnoreCase("grape"))
{
return new Grape();
}
else if(which.equalsIgnoreCase("strawberry"))
{
return new Strawberry();
}
else
{
throw new Exception("抱歉，本農場不生產此種水果");
}
}
}
這下，農場一片繁榮景象了。來年一定是個豐收年。
這時有客戶來果園查看情況，和園丁說，給我們介紹下你的水果吧。於是園丁：
類描述：來農場訂購水果，看水果情況的客戶
public class Client
{
public static void main(String[] args) throws Exception
{
FruitGardener fruitGardener = new FruitGardener();
Fruit apple = fruitGardener.factory("apple");
apple.grow();
Fruit strawBerry = fruitGardener.factory("strawberry");
strawBerry.harvest();
Fruit ddd = fruitGardener.factory("ddd");
ddd.plant();
}
}

❾ 設計模式（二）：簡單工廠，工廠和抽象工廠的區別

首先來看看這兩者的定義區別：工廠模式：定義一個用於創建對象的借口，讓內子類決定實例化容哪一個類抽象工廠模式：為創建一組相關或相互依賴的對象提供一個介面，而且無需指定他們的具體類個人覺得這個區別在於產品，如果產品單一，最合適用工廠模式，但是如果有多個業務品種、業務分類時，通過抽象工廠模式產生需要的對象是一種非常好的解決方式。再通俗深化理解下：工廠模式針對的是一個產品等級結構 ，抽象工廠模式針對的是面向多個產品等級結構的。再來看看工廠方法模式與抽象工廠模式對比：

❿ 設計模式簡單工廠模式

工廠是指生產實例的地方。那就簡單一個，直接命名為createInstance()。此方法通常是靜態的，而且回還會帶有答參數和返回值。舉個例子：例如牛、羊、馬、狗都繼承動物類，那createInstance()的返回值應該為 動物(因為工廠就是生產動物的嘛，所以返回值也應該為動物)，參數應該為動物名稱(這樣工廠根據名稱才知道你要生產哪種動物啊)。這樣就可以根據傳入的的動物名稱，產生一個動物實例。createInstance的實現：switch(動物名稱) case 牛：return new 牛();case 羊：return new 羊();case 馬:return new 馬();case 狗:return new 狗();