您的位置:

java工厂,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;

}

}