java接口工廠（java 編寫接口）

本文目錄一覽：

• 1、做java項目時，要求程序支持功能擴展。這就需要用到接口和工廠模式。有必要給每一個類都增加接口和工廠嗎?
• 2、java中 什麼是工廠
• 3、java中的工廠模式是什麼意思？
• 4、Java的幾個工廠方法解析

做java項目時，要求程序支持功能擴展。這就需要用到接口和工廠模式。有必要給每一個類都增加接口和工廠嗎?

這個是設計模式，設計模式不是框架，沒有特定的場景，不過你多做項目，然後經驗多了會不經意的去尋找開發項目的快捷性，當你實現了你的這種思路之後，他就是設計模式，不要刻意去使用設計模式，只有當你需要或者解決某中需求的時候，發現java里的一些設計模式適合你的需求，你就可以用他，對於程序的拓展性，java中你必須明白

1，一個類有且僅有一個引起他變化的因素

2，對於程序，應該對修改關閉，對新增開放，就是說你設計一個模塊的時候盡量讓它做到不要去

修改，但是新增模塊可以，

總之設計模式很重要，如果你領會了，會對你以後的編程帶來層次上的提高，它是編程思想上的提升

java中 什麼是工廠

工廠是一種設計模式！

為何使用?

工廠模式是我們最常用的模式了,著名的Jive論壇 ,就大量使用了工廠模式，工廠模式在Java程序系統可以說是隨處可見。

為什麼工廠模式是如此常用？因為工廠模式就相當於創建實例對象的new，我們經常要根據類Class生成實例對象，如A a=new A() 工廠模式也是用來創建實例對象的，所以以後new時就要多個心眼，是否可以考慮實用工廠模式，雖然這樣做，可能多做一些工作，但會給你系統帶來更大的可擴展性和盡量少的修改量。

我們以類Sample為例， 如果我們要創建Sample的實例對象:

Sample sample=new Sample();

可是，實際情況是，通常我們都要在創建sample實例時做點初始化的工作,比如賦值 查詢數據庫等。

首先，我們想到的是，可以使用Sample的構造函數，這樣生成實例就寫成:

Sample sample=new Sample(參數);

但是，如果創建sample實例時所做的初始化工作不是象賦值這樣簡單的事，可能是很長一段代碼，如果也寫入構造函數中，那你的代碼很難看了（就需要Refactor重整）。

為什麼說代碼很難看，初學者可能沒有這種感覺，我們分析如下，初始化工作如果是很長一段代碼，說明要做的工作很多，將很多工作裝入一個方法中，相當於將很多雞蛋放在一個籃子里，是很危險的，這也是有背於Java 面向對象的原則，面向對象的封裝(Encapsulation)和分派(Delegation)告訴我們，盡量將長的代碼分派“切割”成每段，將每段再 “封裝”起來(減少段和段之間偶合聯繫性)，這樣，就會將風險分散，以後如果需要修改，只要更改每段，不會再發生牽一動百的事情。

在本例中，首先，我們需要將創建實例的工作與使用實例的工作分開, 也就是說，讓創建實例所需要的大量初始化工作從Sample的構造函數中分離出去。

這時我們就需要Factory工廠模式來生成對象了，不能再用上面簡單new Sample(參數)。還有,如果Sample有個繼承如MySample, 按照面向接口編程,我們需要將Sample抽象成一個接口.現在Sample是接口,有兩個子類MySample 和HisSample .我們要實例化他們時,如下:

Sample mysample=new MySample();

Sample hissample=new HisSample();

隨着項目的深入,Sample可能還會”生出很多兒子出來”, 那麼我們要對這些兒子一個個實例化,更糟糕的是,可能還要對以前的代碼進行修改:加入後來生齣兒子的實例.這在傳統程序中是無法避免的.

但如果你一開始就有意識使用了工廠模式,這些麻煩就沒有了.

工廠方法

你會建立一個專門生產Sample實例的工廠:

public class Factory{

public static Sample creator(int which){

//getClass 產生Sample 一般可使用動態類裝載裝入類。

if (which==1)

return new SampleA();

else if (which==2)

return new SampleB();

}

}

那麼在你的程序中,如果要實例化Sample時.就使用

Sample sampleA=Factory.creator(1);

這樣,在整個就不涉及到 Sample的具體子類,達到封裝效果,也就減少錯誤修改的機會,這個原理可以用很通俗的話來比喻:就是具體事情做得越多,越容易范錯誤.這每個做過具體工作的人都深有體會,相反,官做得越高,說出的話越抽象越籠統,范錯誤可能性就越少.好象我們從編程序中也能悟出人生道理?呵呵.

使用工廠方法 要注意幾個角色，首先你要定義產品接口，如上面的Sample,產品接口下有Sample接口的實現類,如SampleA,其次要有一個factory類，用來生成產品Sample，如下圖，最右邊是生產的對象Sample：

進一步稍微複雜一點，就是在工廠類上進行拓展，工廠類也有繼承它的實現類concreteFactory了。

抽象工廠

工廠模式中有: 工廠方法(Factory Method) 抽象工廠(Abstract Factory).

這兩個模式區別在於需要創建對象的複雜程度上。如果我們創建對象的方法變得複雜了,如上面工廠方法中是創建一個對象Sample,如果我們還有新的產品接口Sample2.

這裡假設：Sample有兩個concrete類SampleA和SamleB，而Sample2也有兩個concrete類Sample2A和SampleB2

那麼，我們就將上例中Factory變成抽象類,將共同部分封裝在抽象類中,不同部分使用子類實現，下面就是將上例中的Factory拓展成抽象工廠:

public abstract class Factory{

public abstract Sample creator();

public abstract Sample2 creator(String name);

}

public class SimpleFactory extends Factory{

public Sample creator(){

………

return new SampleA

}

public Sample2 creator(String name){

………

return new Sample2A

}

}

public class BombFactory extends Factory{

public Sample creator(){

……

return new SampleB

}

public Sample2 creator(String name){

……

return new Sample2B

}

}

從上面看到兩個工廠各自生產出一套Sample和Sample2,也許你會疑問，為什麼我不可以使用兩個工廠方法來分別生產Sample和Sample2?

抽象工廠還有另外一個關鍵要點，是因為 SimpleFactory內，生產Sample和生產Sample2的方法之間有一定聯繫，所以才要將這兩個方法捆綁在一個類中，這個工廠類有其本身特徵，也許製造過程是統一的，比如：製造工藝比較簡單，所以名稱叫SimpleFactory。

在實際應用中，工廠方法用得比較多一些，而且是和動態類裝入器組合在一起應用。

java中的工廠模式是什麼意思？

工廠模式簡單的講就是用工廠方法代替了new的操作，

在通俗點就是說，你new一個對象的時候直接調用工廠方法就行了，

在編程時，需要定義一個工廠接口，由不同的的子類去實現，再定一個具體工廠類，定義一個產生實例的方法，我們通過這個方法來獲得實例就行了，

Java的幾個工廠方法解析

Java工廠模式可分為三種：

1.靜態工廠模式

2.工廠方法模式

3.抽象工廠模式

一、靜態工廠模式：用靜態的方法實現，其創建的對象具有一定的特性

舉例如下：

Vehicle類：

public abstract class Vehicle

{

private String name;

public Vehicle (){

super();

}

public Vehicle (String name){

super();

this.name=name;

}

public abstract void run();

public String getName(){

return name;

}

public void setName(String name){

this.name=name;

}

}

Bus類：

public class Bus extends Vehicle

{

private String name;

public Bus(){}

public Bus(String name){

super(name);

}

@Override

public abstract void run(){

System.out.println(“Bus is running”);

}

}

Car類：

public class Car extends Vehicle

{

private String name;

public Car(){}

public Car(String name){

super(name);

}

@Override

public abstract void run(){

System.out.println(“Car is running”);

}

}

靜態工廠類：

（靜態工廠創建一個對象，

靜態工廠創建的對象一般都有一個共同的特性，

繼承自某一個類，

或者引用一個接口）

public class StaticFactory{

public static Object getInstance(String className){

Object instance=null;

try{

Class c=Class.forName(className);

instance=c.newInstance();

}catch(Exception e){}

return instance;

}

public static Object getInstance(String className,Object …args){

Class c=null;

try{

c=Class.forName(className);

}catch(Exception e){}

Constructor[] cons=c.getConstructors();

Object instance=null;

for(Constructor con:cons){

Class?[] cs=con.getParmeterTypes();

if(cs.length0){

boolean isConstructor=true;

for(int i=0;ics.length;i++){

Class t=cs[i];

if(!t.isInstance(args[i])){

isConstructor=false;

}

}

if(isConstructor){

try{

instance=con.newInstance(args);

break;

}catch(Exception e){}

}else{

continue;

}

}

}

return instance;

}

}

二、工廠方法模式：主要是對各類東西分類生產，但分類生產的對象仍然具有某一特性。

如果說靜態工廠是一個綜合的交通工具建造工廠，

那麼工廠方法模式就是具體分工，分成Bus與Car的工廠，

各自生產各自的產品，但是造出來的還是交通工具。

交通工具製造接口：

public interface VehicleMake{

/**製造交通工具**/

public Vehicle make();

}

Bus製造類：

public class BusMake implements VehicleMake{

@Override

public Vehicle make(){

Vehicle bus=new Bus();

System.out.println(“Bus工廠製造了一輛Bus”);

return bus;

}

}

Car製造類：

public class CarMake implements VehicleMake{

@Override

public Vehicle make(){

Vehicle car=new Car();

System.out.println(“Car工廠製造了一輛Car”);

return car;

}

}

三、抽象工廠模式：抽象工廠生產的對象可能是沒有共同特性的。比如，一個製造工廠BusMake不僅能製造Bus還能生產輪胎wheel等配件，Bus是交通工具，wheel是配件（代碼中有部分類沒具體寫出來只給了類名）

總工廠（抽象工廠總接口）：

public interface WheelVehicleMake extends VehicleMake{

/**製造輪胎**/

public Wheel makeWheel();

}

輪子BusMake：

public class WheelBusMake implements WheelVehicleMake{

@Override

public Vehicle make(){

Vehicle bus=new Bus();

System.out.println(“WheelBusMake生產了一輛Bus”);

return bus;

}

@Override

public Wheel makeWheel(){

Wheel busWheel=new BusWheel();

System.out.println(“WheelBusMake生產了一個Bus輪子”);

return busWheel;

}

}

輪子CarMake：

public class WheelCarMake implements WheelVehicleMake{

@Override

public Vehicle make(){

Vehicle car=new Car();

System.out.println(“WheelCarMake生產了一輛Car”);

return car;

}

@Override

public Wheel makeWheel(){

Wheel carWheel=new CarWheel();

System.out.println(“WheelCarMake生產了一個Car輪子”);

return carWheel;

}

}