`
yaoweinan
  • 浏览: 137537 次
  • 性别: Icon_minigender_1
  • 来自: 苏州
社区版块
存档分类
最新评论

java 工厂模式简单介绍及例子

 
阅读更多

java中工厂模式在java ee中经常碰见,是一种常见的模式,其可分为三种:静态工厂模式、工厂方法模式、抽象工厂模式。一下做一简单讲述和例子。

 

静态工厂模式:顾名思义就知道他是用静态方法实现的,其创建的对象具有一定的特性,譬如说是某类的派生或者某接口的实现。其比较简单。例子如下

 

Animal类:

 

package com.bean;

/**
 * 动物类
 * @author Lyon Yao
 *
 */
public abstract class Animal {
	
	private String name;
	
	public Animal() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Animal(String name) {
		super();
		this.name = name;
	}
	public abstract void eat();
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
}

 猫类:

 

package com.bean;

/**
 * 猫类
 * @author Lyon Yao
 *
 */
public class Cat extends Animal {

	public Cat() {
		// TODO Auto-generated constructor stub
	}

	public Cat(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("I like to eat fish!");
	}

}
 

 

狗类:package com.bean;

/**
 * 狗类
 * @author Lyon Yao
 *
 */
public class Dog extends Animal {

	public Dog() {
		// TODO Auto-generated constructor stub
	}

	public Dog(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("I like to eat bone!");
	}

}
 

 

静态工厂类:

 

package com.factory.sta;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * 静态工厂创建一个对象  静态工厂类产生的对象一般都有共同的特性,继承某一类,或者引用接口之类,在此
 * 没有看似没有,但不可否认他们都是Object或者Object的一个子类
 * @author Lyon Yao
 *
 */
public class StaticFatory {
	public static Object getInstance(String className){
		Object instance=null;
		try {
			Class cls=Class.forName(className);
			instance= cls.newInstance();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return instance;
		
	}
	public static Object getInstance(String className,Object ...agrs) {
		Class cls=null;
		try {
			cls = Class.forName(className);
		} catch (ClassNotFoundException e1) {
			// TODO Auto-generated catch block
			return null;
		}
		Constructor[] constructors = cls.getConstructors();
		Object instance=null;
		for(Constructor cons:constructors){
			Class <?>[] clses=cons.getParameterTypes();
			if(clses.length>0){
				boolean isThisConstructor=true;
				for(int i=0;i<clses.length;i++){
					Class c=clses[i]; 
					if(! c.isInstance(agrs[i]) ){
						isThisConstructor=false;
					}
				}
				if(isThisConstructor){
					try {
						instance=cons.newInstance(agrs);
						break;
					} catch (IllegalArgumentException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} catch (InvocationTargetException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} catch (InstantiationException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} catch (IllegalAccessException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}else{
					continue;
				}
				
			}
		}
		return instance;
	}
}

 

 

 

 

工厂方法模式:其主要是对各个类型的东西分类生产,但分类生产的对象仍然是具有某一特性的。譬如说:前面的静态工厂类是一个综合造车工厂,不管是汽车还是火车都能生产,而工厂方法模式就是工厂具体分工,造汽车的工厂只造汽车,造火车的只造火车,不管造汽车还是火车但造出来的还是车。

具体代码例子如下:(这里的例子和上面的例子是一起的,具狗生好多小狗,猫生好多小猫的例子,如果不具体那么是母动物都能生的)

 

母动物接口:

 

package com.factory;

import com.bean.Animal;

/**
 * 母亲接口
 * @author Lyon
 *
 */
public interface AnimalMother {
	/**
	 * 生育动物
	 * @return
	 */
	public  Animal giveBirth();
}

 

 母狗类:

 

package com.factory.impl;

import com.bean.Animal;
import com.bean.Dog;
import com.factory.AnimalMother;

/**
 * 狗母亲  生狗
 * @author Lyon Yao
 *
 */
public class DogMother implements AnimalMother {

	@Override
	public Animal giveBirth() {
		// TODO Auto-generated method stub
		Animal dog=new Dog();
		System.out.println("狗母亲生了一只小狗");
		return dog;
	}

}
 

 

母猫类:

 

package com.factory.impl;

import com.bean.Animal;
import com.bean.Cat;
import com.factory.AnimalMother;

/**
 * 猫母亲 生猫咪
 * @author Lyon Yao
 *
 */
public class CatMother implements AnimalMother {

	@Override
	public Animal giveBirth() {
		// TODO Auto-generated method stub
		Animal cat=new Cat();
		System.out.println("猫母亲生了一只小猫眯");
		return cat;
	}

}

 

 

 

 

抽象工厂模式:前面工厂方法模式是比较具体的,是猫肯定生的是小猫,这是不会有问题的,是具体的,那么抽象工厂它所产生的就不是那么具体,产生的对象可能是没有共同特性的。譬如说 一只奶羊不仅仅能够生小羊,同时也能生产羊奶,但小羊是动物,羊奶是食物。

例子如下:

 

总工厂:

 

package com.factory;

import com.bean.Milk;

/**
 * 能产奶的 动物母亲
 * 这里继承 AnimalMother 实现 生育小动物  产奶在此接口声明 构成抽象工厂总接口
 * @author Lyon Yao
 *
 */
public interface MilkAnimalMother extends AnimalMother {
	/**
	 * 产奶
	 * @return
	 */
	public Milk produceMilk();
}
 

奶羊:

 

package com.factory.impl;

import com.bean.Animal;
import com.bean.Milk;
import com.bean.Sheep;
import com.bean.SheepMilk;
import com.factory.MilkAnimalMother;

/**
 * 奶羊
 * @author Lyon Yao
 *
 */
public class SheepMilkMother implements MilkAnimalMother{

	@Override
	public Animal giveBirth() {
		// TODO Auto-generated method stub
		Animal sheep=new Sheep();
		System.out.println("奶羊生了一只小羊");
		return sheep;
	}

	@Override
	public Milk produceMilk() {
		// TODO Auto-generated method stub
		Milk milk=new SheepMilk();
		System.out.println("奶羊生产了羊奶");
		return milk;
	}

}

 奶牛:

 

package com.factory.impl;

import com.bean.Animal;
import com.bean.Cattle;
import com.bean.CattleMile;
import com.bean.Milk;
import com.factory.MilkAnimalMother;

/**
 * 奶牛()
 * @author Lyon Yao
 *
 */
public class CattleMilkMother implements MilkAnimalMother {

	@Override
	public Animal giveBirth() {
		// TODO Auto-generated method stub
		Cattle cattle=new Cattle();
		System.out.println("奶牛生了一只小牛");
		return cattle;
	}

	@Override
	public Milk produceMilk() {
		// TODO Auto-generated method stub
		Milk milk=new CattleMile();
		System.out.println("奶牛生产了牛奶");
		return milk;
	}

}

 

 

下面是测试例子:

 

package com.test;

import org.junit.Test;

import com.bean.Animal;
import com.bean.Cat;
import com.bean.Dog;
import com.factory.AnimalMother;
import com.factory.MilkAnimalMother;
import com.factory.impl.CatMother;
import com.factory.impl.CattleMilkMother;
import com.factory.impl.DogMother;
import com.factory.impl.SheepMilkMother;
import com.factory.sta.StaticFatory;

/**
 * 测试类
 * 
 * @author Lyon Yao
 * 
 */
public class TestCase {
	/**
	 * 静态工厂类 测试
	 */
	@Test
	public void staticFactoryTest() {
		Animal ani1=(Animal) StaticFatory.getInstance(Cat.class.getName());
		System.out.println(ani1.getName());
		ani1.eat();
		ani1=(Animal) StaticFatory.getInstance(Dog.class.getName(),"dog");
		System.out.println(ani1.getName());
		ani1.eat();
	}
	/**
	 * 工厂方法模式测试
	 */
	@Test
	public void methodFactoryTest(){
		AnimalMother mother=new CatMother();
		mother.giveBirth();
		mother=new DogMother();
		mother.giveBirth();
	}
	/**
	 * 抽象工厂模式测试
	 */
	@Test
	public void abstrFactoryTest(){
		MilkAnimalMother mother=new SheepMilkMother();
		mother.giveBirth();
		mother.produceMilk();
		mother=new CattleMilkMother();
		mother.giveBirth();
		mother.produceMilk();
	}
}

 控制台输出:

 

 

null

I like to eat fish!

dog

I like to eat bone!

猫母亲生了一只小猫眯

狗母亲生了一只小狗

奶羊生了一只小羊

奶羊生产了羊奶

奶牛生了一只小牛

奶牛生产了牛奶

 

 

例子可能比较牵强,各位见笑了。


分享到:
评论

相关推荐

    Java 简单工厂模式例子

    在给定的"Java 简单工厂模式例子"中,可能包含如下代码结构: ```java // Product(产品)接口或抽象类 public interface Computer { void start(); } // ConcreteProduct(具体产品)类 public class Laptop ...

    一个简单的工厂模式例子

    java工厂模式一个简单的工厂模式例子工厂模式简单代码案例,仅供参考。java工厂模式一个简单的工厂模式例子工厂模式简单代码案例,仅供参考。java工厂模式一个简单的工厂模式例子工厂模式简单代码案例,仅供参考。...

    设计模式--工厂模式java例子

    这里我们主要探讨基于Java的例子,即简单工厂模式。 简单工厂模式的核心思想是定义一个工厂类,这个类负责创建对象,而客户端代码不再直接创建对象,而是调用工厂类的静态方法来获取所需对象。这样做可以隔离类的...

    Java中工厂模式案例

    工厂模式分为三种主要类型:简单工厂模式、工厂方法模式和抽象工厂模式。 **1. 简单工厂模式(Simple Factory)** 简单工厂模式中,有一个中心工厂类负责创建对象。这个工厂类通常由一个静态方法构成,根据传入的...

    JAVA 设计模式 工厂模式 代理模式 迭代模式 责任链模式 源码

    以下是关于JAVA设计模式中提及的四种模式——工厂模式、代理模式、迭代器模式以及责任链模式的详细说明。 1. **工厂模式**:工厂模式是一种创建型设计模式,它提供了一种创建对象的最佳方式。在工厂模式中,当创建...

    关于简单工厂模式的一个java例子

    在这个"关于简单工厂模式的一个java例子"中,我们将深入探讨这种模式的基本概念、实现方式以及它在Java编程中的应用。 简单工厂模式的核心思想是将对象的创建过程封装在一个单独的工厂类中,客户只需要知道产品类型...

    java 23种设计模式及具体例子

    java 设计模式是软件工程的基石,它们被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式可以让代码更容易被他人理解、保证代码可靠性、提高代码的重用性。 一、设计模式的分类 设计...

    Java 23种设计模式及例子

    本文将详细介绍23种常用的设计模式,分为创建型模式、结构型模式和行为型模式三大类。 #### 二、设计模式的六大原则 1. **开闭原则**(Open-Closed Principle, OCP) - 描述:开闭原则提倡代码应该是开放扩展但...

    java工厂模式例子描述

    Java工厂模式是一种设计模式,主要用于解决对象创建的问题。在编程中,当系统无法预见需要创建哪种类型的实例,或者系统不应依赖于对象如何被创建、组合和表达的细节时,工厂模式是一个很好的选择。 简单工厂模式是...

    java三种工厂模式文档+三个实例.rar

    Java工厂模式是面向对象设计模式中的一个重要概念,它提供了一种创建对象的最佳方式。在工厂模式中,我们创建对象时不直接实例化具体类,而是通过一个接口或者抽象类来间接创建。这种模式的核心在于将对象的创建过程...

    三种工厂模式java实现

    工厂模式通常分为三种:简单工厂模式、工厂方法模式和抽象工厂模式。下面我们将详细探讨这三种工厂模式在Java中的实现。 **1. 简单工厂模式** 简单工厂模式是最早期的工厂模式形式,它通过一个静态工厂方法来创建...

    java工厂设计模式讲解+例子

    java工厂设计模式讲解+例子,三种工厂模式的讲解,简单工厂、工厂方法、抽象工厂

    java与模式之简单工厂模式

    在Java编程中,简单工厂模式通过一个公共的工厂类来创建对象,避免了客户端代码直接new对象,增强了代码的可维护性和扩展性。 在Java与模式之简单工厂模式中,我们首先理解其基本概念。简单工厂模式包含三个主要...

    Java设计模式经典例子

    这些只是Java设计模式中的一部分例子,实际的压缩包文件可能包含了更多设计模式的详细解释和示例代码,如代理模式、装饰器模式、适配器模式等。学习并熟练应用这些设计模式,可以帮助开发者编写出更加高效、灵活且...

    java设计模式pdf

    ### Java设计模式详解 ...通过以上内容可以看出,《Java设计模式PDF》这本书不仅提供了对各种设计模式的详细介绍,而且还结合了大量的示例代码和实用建议,对于Java开发者来说是一本非常有价值的参考书。

    Java简单工厂模式和传统模式实现对比

    Java简单工厂模式是一种设计模式,它是创建型模式的一种,用于将对象的创建过程封装...了解并熟练运用简单工厂模式是Java开发者进阶的必经之路,而Spring框架则是在实际项目中将工厂模式应用得淋漓尽致的一个典型例子。

    java 工厂模式代码

    在软件设计模式中,工厂模式是一种非常基础且实用的创建型模式。它的主要目的是提供一个创建对象的接口,隔离了具体类的实例化过程,使得客户端可以无须知道所创建的对象的具体类,只需要知道它是从某个特定的工厂来...

    JAVA设计模式的工厂模式文档和代码

    简单工厂模式通常用于相对简单的对象创建,工厂方法模式则允许子类决定创建哪种产品,而抽象工厂模式关注于一组相关或相互依赖的对象的创建,提供一个创建对象族的接口。 "工厂模式.txt"文本文件可能进一步阐述了...

    java简单工厂模式文档简单汇总

    【Java 简单工厂模式】简单工厂模式是一种创建型设计模式,它的主要思想是提供一个工厂类,根据传入的参数动态地返回一个产品对象。这种模式将对象的创建与对象的使用分离,使得代码更加简洁且易于维护。 在Java中...

Global site tag (gtag.js) - Google Analytics