java工厂模式java工厂模式，懂的人进

java 工厂模式

public class Factory { //生产对象 public Object createObject() { return new Object(); } } 最最简单的工厂

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. 这样,在整个就不涉及到Sample的具

求java工厂模式的一个简单代码例子，尽量简单

这个应该比较简单一点。

某系统日志记录器要求支持多种日志记录方式，如文件记录、数据库记录等，且用户可以根据要求动态选择日志记录方式。

现使用工厂方法模式设计该系统,并写出相应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("数据库记录"); ????} } 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中的factory模式是什么 怎么运用的

用接口或父类接受工厂类返回的子类相应的对象 Exp: Father.java: abstract public class Father { abstract public void shout(); } Daughter.java: public class Daughter extends Father { public void shout() { System.out.println("shout from Daughter"); } } Son.java: public class Son extends Father { public void shout() { System.out.println("shout from Son"); } } Factory.java: public class Factory { public static Father getFatherInstance() { return new Daughter(); //return new Son(); } } Test.java: public class Test { public static void main(String[] args) { Father father = Factory.getFatherInstance(); father.shout(); } } 在真正使用中,只对父类有接触,并不接触真正的实例.. 这是最简单的工厂模式

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： .jzkangta.factorydemo01; //定义接口 interface Car{ public void run(); public void (); } //具体实现类 class Benz implements Car{ public void run(){ System.out.println("Benz开始启动了。

。

。

。

。

"); } public void (){ System.out.println("Benz停车了。

。

。

。

。

"); } } //具体实现类 class Ford implements Car{ public void run(){ System.out.println("Ford开始启动了。

。

。

"); } public void (){ 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(); (); } } 实例二： package fac; //定义接口 interface Car{ public void run(); public void (); } //具体实现类 class Benz implements Car{ public void run(){ System.out.println("Benz开始启动了。

。

。

。

。

"); } public void (){ System.out.println("Benz停车了。

。

。

。

。

"); } } class Ford implements Car{ public void run(){ System.out.println("Ford开始启动了。

。

。

"); } public void (){ 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(); (); }else{ System.out.println("造不了这种汽车。

。

。

"); } } } 实例三： interface Car{ public void run(); public void (); } class Benz implements Car{ public void run(){ System.out.println("Benz开始启动了。

。

。

。

。

"); } public void (){ System.out.println("Benz停车了。

。

。

。

。

"); } } class Ford implements Car{ public void run(){ System.out.println("Ford开始启动了。

。

。

"); } public void (){ System.out.println("Ford停车了。

。

。

。

"); } } class Toyota implements Car{ public void run(){ System.out.println("Toyota开始启动了。

。

。

"); } public void (){ System.out.println("Toyota停车了。

。

。

。

"); } } class Factory{ public static Car getCarInstance(String type){ Car c=null; try { c=(Car)Class.forName(&.jzkangta.factorydemo03."+type).newInstance();//利用反射得到汽车类型　 } catch (InstantiationException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (essException 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(); (); }else{ System.out.println("造不了这种汽车。

。

。

"); } } } 对比三个实例： 实例一，虽然实现了简单工厂，但每次只能得到一种汽车，如果我们想换一种，就得修改工厂，太不方便，而实例二则改变了这种情况，便得我们可以按照我们的需要更换汽车，但我们所更换的汽车必须是实现类中有的，如果我们想要增加一种汽车的时候，我们还是得更改工厂，通过改进，实例三利用反射机制，得到汽车类型，这样当我们需要增加一种新的汽车时，就无需要再修改工厂，而只需要增加要实现的类即可。

也就是说要增加什么样的汽车直接增加这个汽车的类即可，而无需改变工厂。

从而达到了工厂分离的效果。