Java的幾個工廠方法解析

Java工廠模式可分為三種：

創(chuàng)新互聯(lián)是一家專注于成都做網(wǎng)站、網(wǎng)站建設與策劃設計,鐵西網(wǎng)站建設哪家好?創(chuàng)新互聯(lián)做網(wǎng)站,專注于網(wǎng)站建設10多年,網(wǎng)設計領域的專業(yè)建站公司;建站業(yè)務涵蓋:鐵西等地區(qū)。鐵西做網(wǎng)站價格咨詢:13518219792

1.靜態(tài)工廠模式

2.工廠方法模式

3.抽象工廠模式

一、靜態(tài)工廠模式：用靜態(tài)的方法實現(xiàn)，其創(chuàng)建的對象具有一定的特性

舉例如下：

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

}

}

靜態(tài)工廠類：

（靜態(tài)工廠創(chuàng)建一個對象，

靜態(tài)工廠創(chuàng)建的對象一般都有一個共同的特性，

繼承自某一個類，

或者引用一個接口）

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;

}

}

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

如果說靜態(tài)工廠是一個綜合的交通工具建造工廠，

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

各自生產(chǎn)各自的產(chǎn)品，但是造出來的還是交通工具。

交通工具制造接口：

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;

}

}

三、抽象工廠模式：抽象工廠生產(chǎn)的對象可能是沒有共同特性的。比如，一個制造工廠BusMake不僅能制造Bus還能生產(chǎn)輪胎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生產(chǎn)了一輛Bus");

return bus;

}

@Override

public Wheel makeWheel(){

Wheel busWheel=new BusWheel();

System.out.println("WheelBusMake生產(chǎn)了一個Bus輪子");

return busWheel;

}

}

輪子CarMake：

public class WheelCarMake implements WheelVehicleMake{

@Override

public Vehicle make(){

Vehicle car=new Car();

System.out.println("WheelCarMake生產(chǎn)了一輛Car");

return car;

}

@Override

public Wheel makeWheel(){

Wheel carWheel=new CarWheel();

System.out.println("WheelCarMake生產(chǎn)了一個Car輪子");

return carWheel;

}

}

求java工廠模式的一個簡單代碼例子，盡量簡單

這個應該比較簡單一點。

某系統(tǒng)日志記錄器要求支持多種日志記錄方式，如文件記錄、數(shù)據(jù)庫記錄等，且用戶可以根據(jù)要求動態(tài)選擇日志記錄方式?，F(xiàn)使用工廠方法模式設計該系統(tǒng),并寫出相應Java代碼。

interface Log{

public void writeLog();

}

class FileLog implements Log{

public void writeLog(){

System.out.println("文件記錄");

}

}

class DatabaseLog implements Log{

public void writeLog(){

System.out.println("數(shù)據(jù)庫記錄");

}

}

interface LogFactory{

public Log createLog();

}

class FileLogFactory implements LogFactory{

public Log createLog(){

return new FileLog();

}

}

class DatabaseLogFactory implements LogFactory{

public Log createLog(){

return new DatabaseLog();

}

}

public class Client{

public static void main(String[] args) {

try{

Log log;

LogFactory factory;

//這里可以改成使用DOM和Java反射機制讀取XML文件，獲取工廠類名

factory=new DatabaseLogFactory ();

log=factory.createLog();

log.writeLog();

}

catch(Exception e){

System.out.println(e.getMessage());

}

}

}

java工廠模式，懂的人進

舉兩個例子以快速明白Java中的簡單工廠模式：

女媧摶土造人

話說：“天地開辟，未有人民，女媧摶土為人?！迸畫z需要用土造出一個個的人，但在女媧造出人之前，人的概念只存在于女媧的思想里面。

女媧造人，這就是簡單工廠模式的應用。

首先，在這個造人的思想里面，有幾個重要的角色：女媧本身、抽象的人的概念和女媧所造出的一個個具體的人。

1.）女媧是一個工廠類，也就是簡單工廠模式的核心角色。

2.）具休的一個個的人，包括張三，李四等。這些人便是簡單工廠模式里面的具體產(chǎn)品角色

3.）抽象的人是最早只存在于女媧的頭腦里的一個想法，女媧按照這個想法造出的一個個具體的人，便都符合這個抽象的人的定義。換言之，這個抽象的想法規(guī)定了所有具體的人必須都有的接口（特征或者功能）

　其UML類圖出下所示：

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

有一個農(nóng)場公司，專門向市場銷售各類水果，在這個系統(tǒng)里需要描述下列水果：

　葡萄　Grape

　草莓　Stuawberry

　蘋果　Apple

水果與其他植物不同，最終可以采摘食用，那么一個自然的做法是建立一個各種水果都適用的接口，以便與其他農(nóng)場里的植物區(qū)分開來，

此時，則是為水果類聲明了一個接口，表現(xiàn)在代碼上：

1 public interface Fruit {

2 // 生長

3 void grow();

4 // 收獲

5 void harvest();

6 // 種植

7 void plant();

8 }

9

10

水果接口規(guī)定出所有的水果必須實現(xiàn)的接口，包括任何水果類必須具備的方法plant(),grow(),和harvest();

Apple類是水果類的一種，因此它實現(xiàn)了水果接口所聲明的所有方法。另處，由于蘋果是多年生植物，因此多出一個treeAge性質(zhì)，描述蘋果的樹齡。代碼如下所示：

package fac;

public class Apple implements Fruit { // 通過implements實現(xiàn)接口Fruit

private int treeAge;

public void grow() {

log( " Apple is growing " );

}

public void harvest() {

log( " Apple has been harvested " );

}

public void plant() {

log( " Apple ha been planted " );

}

public static void log(String msg) {

System.out.println(msg);

}

public int getTreeAge() {

return treeAge;

}

public void setTreeAge( int treeAge) {

this .treeAge = treeAge;

}

}

同理，葡萄　Grape：

package fac;

public class Grape implements Fruit{

private boolean seedless;

public void grow(){

log("Grape is growing.");

}

public void harvest(){

log("Grape has been harvested");

}

public void plant(){

log("Grape ha been planted");

}

public static void log(String msg){

System.out.println(msg);

}

public boolean isSeedless() {

return seedless;

}

public void setSeedless(boolean seedless) {

this.seedless = seedless;

}

}

草莓　Stuawberry：

package fac;

public class Strawberry implements Fruit{

public void grow(){

log("Strawberry is growing");

}

public void harvest(){

log("Strawberry has been harvested");

}

public void plant(){

log("Strawberry has been planted");

}

public static void log(String msg){

System.out.println(msg);

}

}

農(nóng)場園丁也是系統(tǒng)的一部分，由一個類來代表，F(xiàn)ruitGardener類，代碼如下：

package fac;

public class FruitGardener{

public static Fruit factory(String which)throws Exception{

if(which.equalsIgnoreCase("apple")){

return new Apple();

}else if(which.equalsIgnoreCase("strawberry")){

return new Strawberry();

}else if (which.equalsIgnoreCase("grape")){

return new Grape();

}else{

throw new Exception("Bad fruit request");

}

}

}

這時有人來果園玩，和園丁說，給我們介紹下你的水果吧。于是園?。?/p>

package fac;

public class People {

public static void main(String[] args) throws Exception {

FruitGardener fg=new FruitGardener();

Fruit ap=fg.factory("Apple");

ap.grow();

Fruit gp=fg.factory("Grape");

gp.plant();

Fruit dd=fg.factory("ddd");//拋出Bad fruit request異常

}

}

（注：以上代碼在JDK5.0，Myeclise3.2下編譯通過）

類比兩個例子，園丁就相當于女媧，而水果就相當于具體的人，接口水果類就相當于存在于類女媧思想里的人的抽象概念。

由以上兩個例子可得出，簡單工廠模式需要由以下角色組成：

接口

接口的實現(xiàn)類（簡單工廠模式里面的具體產(chǎn)品角色）

工廠

理解了以下兩個例子，再來看第三個例子：

注意對比以下三個實例的不同

實例1：

package org.jzkangta.factorydemo01;

//定義接口

interface Car{

public void run();

public void stop();

}

//具體實現(xiàn)類

class Benz implements Car{

public void run(){

System.out.println("Benz開始啟動了。。。。。");

}

public void stop(){

System.out.println("Benz停車了。。。。。");

}

}

//具體實現(xiàn)類

class Ford implements Car{

public void run(){

System.out.println("Ford開始啟動了。。。");

}

public void stop(){

System.out.println("Ford停車了。。。。");

}

}

//工廠

class Factory{

public static Car getCarInstance(){

return new Ford();

}

}

public class FactoryDemo01 {

public static void main(String[] args) {

Car c=Factory.getCarInstance();

c.run();

c.stop();

}

}

實例二：

package fac;

//定義接口

interface Car{

public void run();

public void stop();

}

//具體實現(xiàn)類

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 FactoryDemo02 {

public static void main(String[] args) {

Car c=Factory.getCarInstance("Benz");

if(c!=null){

c.run();

c.stop();

}else{

System.out.println("造不了這種汽車。。。");

}

}

}

實例三：

interface 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 Toyota implements Car{

public void run(){

System.out.println("Toyota開始啟動了。。。");

}

public void stop(){

System.out.println("Toyota停車了。。。。");

}

}

class Factory{

public static Car getCarInstance(String type){

Car c=null;

try {

c=(Car)Class.forName("org.jzkangta.factorydemo03."+type).newInstance();//利用反射得到汽車類型　

} catch (InstantiationException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IllegalAccessException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (ClassNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return c;

}

}

public class FactoryDemo03 {

public static void main(String[] args) {

Car c=Factory.getCarInstance("Toyota");

if(c!=null){

c.run();

c.stop();

}else{

System.out.println("造不了這種汽車。。。");

}

}

}

對比三個實例：

實例一，雖然實現(xiàn)了簡單工廠，但每次只能得到一種汽車，如果我們想換一種，就得修改工廠，太不方便，而實例二則改變了這種情況，便得我們可以按照我們的需要更換汽車，但我們所更換的汽車必須是實現(xiàn)類中有的，如果我們想要增加一種汽車的時候，我們還是得更改工廠，通過改進，實例三利用反射機制，得到汽車類型，這樣當我們需要增加一種新的汽車時，就無需要再修改工廠，而只需要增加要實現(xiàn)的類即可。也就是說要增加什么樣的汽車直接增加這個汽車的類即可，而無需改變工廠。從而達到了工廠分離的效果。

用java 編寫程序?qū)懗龊唵蔚墓S模式?

java中工廠模式分為:

簡單工廠模式(Simple Factory)?

2. 工廠方法模式(Factory Method)?

3. 抽象工廠模式(Abstract Factory)

每種方法的實現(xiàn)不同

提供一個簡單工廠模式的案例：

public abstract class Woman {

private String mySkill;

public String getMySkill() {

return mySkill;

}

public Woman() {

//System.out.println("我是女人");

}

public void setMySkill(String mySkill) {

this.mySkill = mySkill;

}

}

----------------------------

public class LovelinessWoman extends Woman{

/*

* 可愛型女人

*/

public LovelinessWoman()

{

String mySkill="撒過嬌、出過軌、勾引領導下過水";

? this.setMySkill(mySkill);

}

}

-----------------------------

public class SteelinessWoman extends Woman{

/*

* 冷酷型女人

*/

public SteelinessWoman()

{

String mySkill="裝過神、弄過鬼，跟別人老公親過嘴";

? this.setMySkill(mySkill);

}

}

--------------------------------------

public class WomanMakeFactory {

public Woman findWoman(int typeID) {

switch (typeID) {

case 1:

return new LovelinessWoman();

case 2:

return new VirtuousWoman();

case 3:

return new SteelinessWoman();

default:

return null;

}

}

public Woman findWoman(String type) throws ClassNotFoundException, InstantiationException, IllegalAccessException {

/*

* Type t = Type.GetType("SimpleFactory." + type);

* Woman wm =

* (Woman)Activator.CreateInstance(t); return wm;

*/

String string="cn.jbit.design.simplefactory."+type;

Class c = Class.forName(string);

Woman wm = (Woman) c.newInstance();

return wm;

}

}

-------------------------

調(diào)用

public class Test2 {

/**

* @param args

* @throws IllegalAccessException

* @throws InstantiationException

* @throws ClassNotFoundException

*/

public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {

Scanner input=new Scanner(System.in);

boolean sel=false;

do {

System.out.println("請選擇你要找的女人的類型");

System.out.println("LovelinessWoman：可愛型女人 VirtuousWoman：善良型女人 SteelinessWoman：冷酷型女人");

String typeid=input.next();

? ? ? ?WomanMakeFactory factory = new WomanMakeFactory();

? ? ? ?Woman wm=factory.findWoman(typeid);

? ? ? ?System.out.println("該類型女人的新標準：");

? ? ? ?System.out.println(wm.getMySkill());

? ? ?

? ? ? ?System.out.println("還想看看別的類型嗎？y代表想，n代表再也不想了");

? ? ?

? ? ? ?sel=input.next().equals("y");

} while (sel);

}

}

分享文章：java工廠模式代碼實現(xiàn) java設計模式之工廠模式
文章分享：http://www.ekvhdxd.cn/article22/dodipjc.html

成都網(wǎng)站建設公司_創(chuàng)新互聯(lián)，為您提供網(wǎng)站排名、標簽優(yōu)化、定制開發(fā)、靜態(tài)網(wǎng)站、虛擬主機、網(wǎng)站營銷

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉載內(nèi)容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉載，或轉載時需注明來源： 創(chuàng)新互聯(lián)