java工厂模式例子

Ⅰ java工厂模式例子

产品
public interface Work {

void doWork();
}
ConcreteProct
public class StudentWork implements Work {

public void doWork() {
System.out.println("学生做作业!");
}

}
public class TeacherWork implements Work {

public void doWork() {
System.out.println("老师审批作业!");
}

}
生产者
public interface IWorkFactory {

Work getWork();
}
ConcreteCreator
public class StudentWorkFactory implements IWorkFactory {

public Work getWork() {
return new StudentWork();
}

}
public class TeacherWorkFactory implements IWorkFactory {

public Work getWork() {
return new TeacherWork();
}

}
Test
public class Test {

public static void main(String[] args) {
IWorkFactory studentWorkFactory = new StudentWorkFactory();
studentWorkFactory.getWork().doWork();

IWorkFactory teacherWorkFactory = new TeacherWorkFactory();
teacherWorkFactory.getWork().doWork();
}

}

Ⅱ java 工厂模式 单例模式

工厂模式分简单工厂、工厂方法、抽象工厂 三类。
很复杂。
看这本电子书： Java与模式(清晰书签版).pdf
下载不到的话加QQ：844576121
传给你

Ⅲ Java中常用的设计模式有哪些请详细说明一下工厂模式。

1.单例模式（有的书上说叫单态模式其实都一样）
该模式主要目的是使内存中保持1个对象
2.工厂模式
该模式主要功能是统一提供实例对象的引用。看下面的例子：
public class Factory{
public ClassesDao getClassesDao(){
ClassesDao cd = new ClassesDaoImpl();
return cd;
}
}
interface ClassesDao{
public String getClassesName();
}
class ClassesDaoImpl implements ClassesDao {
public String getClassesName(){
System.out.println("A班");
}
}
class test
{
public static void main(String[] args){
Factory f = new Factory();
f.getClassesDao().getClassesName();
}
}
这个是最简单的例子了，就是通过工厂方法通过接口获取对象的引用
3.建造模式
该模式其实就是说，一个对象的组成可能有很多其他的对象一起组成的，比如说，一个对象的实现非常复杂，有很多的属性，而这些属性又是其他对象的引用，可能这些对象的引用又包括很多的对象引用。封装这些复杂性，就可以使用建造模式。
4.门面模式
这个模式个人感觉像是Service层的一个翻版。比如Dao我们定义了很多持久化方法，我们通过Service层将Dao的原子方法组成业务逻辑，再通过方法向上层提供服务。门面模式道理其实是一样的。
5.策略模式
这个模式是将行为的抽象，即当有几个类有相似的方法，将其中通用的部分都提取出来，从而使扩展更容易。

Ⅳ java简单工厂模式是什么

就是专门写一个类，他有一个方法根据传入的参数不同，返回不同的对象。
比如有一台自动售货机AutoSeller， 然后它卖很多饮料Drink, 有茶Tea， 有可乐Cola, 当你去买的时候，你可能是通过按不同的按钮，但对AutoSeller的实现来说，他可能都是同样的方法，只是根据不同的参数（按钮），返回给你不同的对象（Tea或Cola）。
public interface Drink {
enum Type {TEA, COLA};
}
public Tea implements Drink {
}
public Cola implements Drink {
}
public class AutoSeller {//工厂
public static Drink getDrink(Drink.Type type) {
switch(type) {
case TEA:
return new Tea();
case COLA:
return new Cola();
default:break;
}
}
}

如上， 在你选择饮料按下按钮里， 自动售货机的代码可能只要执行AutoSeller.getDrink(type)就可以返回你想要的饮料了。
之所以要把Drink定义成接口，一般来讲，用这种架构的话， Drink里面会声明一些接口方法， 这些方法是Tea和Cola都需要的， 但Drink不用关心方法的具体实现， 具体实现只要由Tea和Cola去完成。
而你通过AutoSeller.getDrink(type)去拿到一个Drink对象后，可以用这个对象直接去调Drink中声明的方法。

Ⅳ 求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 设计模式（工厂方法）

面向抽象（抽象类或接口）编程。
IWorkFactory studentWorkFactory = new StudentWorkFactory(); 注意：类型是接口类型，即抽象工厂，抽象工厂生产的是抽象产品，而new的则是具体工厂，是由子类实现的，具体工厂生产具体产品。面向抽象的好处：1.在设计抽象的时候不用管具体的实现，只要定义接口知道它用来干什么就行，这样，我只需要知道抽象接口就能继续下面的开发设计工作了，而不用事先设计具体的实现内容；2. 可以扩展多个子类实现抽象接口，更利于系统后期的扩展，而对原系统不造成任何影响，即：开-闭原则。

TeacherWork tt = new TeacherWork(); 不用说就是面向具体实现类编程，缺点就是扩展性不好，对系统后期维护扩展影响较大。

举个简单的例子：
假如在系统的A.java中代码中使用了TeacherWork 类型对象，是满足了目前软件的需求，但是，如果有一天需求变化了需要一个StudentWork 类型对象，该怎么办？只能修改A.java类来满足这样的修改需求。这样就影响了原来系统结构稳定性，需要重新调试和测试，而这带来的维护成本是非常大的，有时可能还会带来系统错误，而影响系统运行。
如果在A.java类中应用Work接口类型就不会存在这种问题，A.java不需要任何修改，只需要修改注入到A中的Work接口的具体实现类即可。

面向抽象编程的好处就在于对系统维护和扩展上，即在不影响原系统稳定运行的基础上增加新的扩展行为，即要符合“开-闭”原则。可能会因此而失去一定的效率问题，但是对于后期的维护成本来说，这个可以忽略不计。 推荐你一本好书：《软件秘笈-设计模式那点事》其中讲解的设计模式很到位，还有每个模式的静态类图和JDK中设计模式的具体分析讲解，读了收获一定很大。祝你成功！

Ⅶ 关于java工厂模式

工厂模式有以下几种形态:

简单工厂(Simple Factory)模式

工厂方法(Factory Method)模式,又称多形性工厂(Polymorphic Factory)模式

抽象工厂(Abstract Factory)模式,又称工具箱(Kit或Toolkit)模式

在简单工厂模式中,一个工厂类处于对产品类实例化调用的中心位置上,它决定那一个产品类应当被实例化, 如同一个交通警察站在来往的车辆流中,决定放行那一个方向的车辆向那一个方向流动一样。

工厂方法模式是简单工厂模式的进一步抽象化和推广，工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化,这个决定被交给子类去作。

工厂方法模式和简单工厂模式在定义上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类,而不像简单工厂模式, 把核心放在一个实类上。工厂方法模式可以允许很多实的工厂类从抽象工厂类继承下来, 从而可以在实际上成为多个简单工厂模式的综合,从而推广了简单工厂模式。
反过来讲,简单工厂模式是由工厂方法模式退化而来。设想如果我们非常确定一个系统只需要一个实的工厂类, 那么就不妨把抽象工厂类合并到实的工厂类中去。而这样一来,我们就退化到简单工厂模式了。

抽象工厂模式是所有形态的工厂模式中最为抽象和最具广泛性的一种形态，抽象工厂模式是工厂方法模式的进一步扩广化和抽象化。如下图：

在抽象工厂模式中，抽象产品 (AbstractProct) 可能是一个或多个，从而构成一个或多个产品族(Proct Family)。 在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。

总结： 简单工厂模式是由一个具体的类去创建其他类的实例，父类是相同的，父类是具体的。
工厂方法模式是有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成。
抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。

Ⅷ 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的工厂模式有哪一些，分别有什么作用，一般用在哪些地方

我简单的说下，举个例子，当我们的程序结构比较繁杂时，比如有100个类，而类中又有很多方法，这些方法之间都互相有依赖关系，也就是一个方法之间的某段逻辑处理需要用到另一个类中的代码逻辑，这种时候对于整个程序而言是非常不利于开发的（我们需要考虑到很多类、方法之间的耦合问题），那么就有一个概念了，也就是面对接口编程。通俗的说就是把类中的方法封装起来，外部调用的人完全不需要考虑方法是如何实现的，但是这样做也有一个不好的地方，我们的接口是不提供方法实现的，而需要在类中实现接口的方法。那么问题产生了，我们在new接口对象的时候需要明确的知道他的实例类。
想象一下，如果程序在继续庞大，接口非常多，接口实例类非常多，这样又会产生我们之前的问题（我们需要考虑到很多类、方法之间的耦合问题）那么这个时候就产生了一中设计思想，也就是工厂模式，这种模式的核心思想就是管理接口的实例对象，把接口和实例对象之间的关系封装起来处理，外部需要用到某个接口的实例时，由工厂进行分配，而不需要关注具体是哪个实例。
如果你做到比较复杂的程序时你应该就能体会到了。

Ⅹ java中的工厂模式是什么，请举例说明

工厂模式在Java程序系统可以说是随处可见。 为什么工厂模式是如此常用？因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑使用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。 说白了就是在一个类里写别的类 让外部好调用啊