java工廠,java工廠模式應用場景

本文目錄一覽：

• 1、java工廠模式，懂的人進
• 2、java工廠類怎麼實現
• 3、用java 編寫程序寫出簡單的工廠模式?
• 4、java中的factory是啥意思，怎麼用能達到那種效果
• 5、Java的幾個工廠方法解析

java工廠模式，懂的人進

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

女媧摶土造人

話說：“天地開闢，未有人民，女媧摶土為人。”女媧需要用土造出一個個的人，但在女媧造出人之前，人的概念只存在於女媧的思想裡面。

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

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

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

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

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

　其UML類圖出下所示：

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

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

　葡萄　Grape

　草莓　Stuawberry

　蘋果　Apple

水果與其他植物不同，最終可以採摘食用，那麼一個自然的做法是建立一個各種水果都適用的接口，以便與其他農場里的植物區分開來，

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

1 public interface Fruit {

2 // 生長

3 void grow();

4 // 收穫

5 void harvest();

6 // 種植

7 void plant();

8 }

9

10

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

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

package fac;

public class Apple implements Fruit { // 通過implements實現接口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);

}

}

農場園丁也是系統的一部分，由一個類來代表，FruitGardener類，代碼如下：

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

}

}

}

這時有人來果園玩，和園丁說，給我們介紹下你的水果吧。於是園丁：

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下編譯通過）

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

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

接口

接口的實現類（簡單工廠模式裡面的具體產品角色）

工廠

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

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

實例1：

package org.jzkangta.factorydemo01;

//定義接口

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

}

//具體實現類

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(“造不了這種汽車。。。”);

}

}

}

對比三個實例：

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

java工廠類怎麼實現

工廠方法模式分為三種：

1、普通工廠模式，就是建立一個工廠類，對實現了同一接口的一些類進行實例的創建

2、多個工廠方法模式，是對普通工廠方法模式的改進，在普通工廠方法模式中，如果傳遞的字符串出錯，則不能正確創建對象，而多個工廠方法模式是提供多個工廠方法，分別創建對象。

3、靜態工廠方法模式，將上面的多個工廠方法模式里的方法置為靜態的，不需要創建實例，直接調用即可。

具體代碼請參考：java設計模式   第三大節

如果對您有幫助，請及時採納謝謝

用java 編寫程序寫出簡單的工廠模式?

java中工廠模式分為:

簡單工廠模式(Simple Factory) 

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

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

每種方法的實現不同

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

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;

}

}

————————-

調用

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中的factory是啥意思，怎麼用能達到那種效果

factory應該說的是java的工廠設計模式，在創建這個類的實例時，不手動new出來，而是交給工廠類來創建，在java開發中很多地方都用到了這種設計模式。要達到這種效果很簡單啊，在工廠類中寫一個方法，讓這個方法返回該類或該類子類的實例即可。

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;

}

}