java 工厂模式简单介绍及例子
java中工厂模式在java ee中常常遇见，是一种常见的模式，其可分为三种：静态工厂模式、工厂方法模式、抽象工厂模式。一下作一简单讲述和例子。java
静态工厂模式：顾名思义就知道他是用静态方法实现的，其建立的对象具备必定的特性，譬如说是某类的派生或者某接口的实现。其比较简单。例子以下ide
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;
}
}
猫类：this
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;spa
/**
* 狗类
* @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！");
}
}
静态工厂类：orm
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();
}
母狗类：get
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！
猫母亲生了一只小猫眯
狗母亲生了一只小狗
奶羊生了一只小羊
奶羊生产了羊奶
奶牛生了一只小牛
奶牛生产了牛奶
相关文章
- 1. 简单介绍工厂模式和单例模式
- 2. JavaScript设计模式--简单工厂模式例子---XHR工厂
- 3. 单例模式，简单工厂模式
- 4. java工厂模式例子
- 5. 简单工厂模式简单实例
- 6. Java简单工厂模式
- 7. 单工厂模式，工厂模式和抽象工厂模式超级简单介绍
- 8. Java ------ 工厂模式、单例模式
- 9. 简单工厂(一)——介绍
- 10. 设计模式之简单工厂模式介绍
- 更多相关文章...
- • Scala 模式匹配 - Scala教程
- • SVN 启动模式 - SVN 教程
- • 委托模式
- • Java Agent入门实战（一）-Instrumentation介绍与使用
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
欢迎关注本站公众号,获取更多信息
相关文章
- 1. 简单介绍工厂模式和单例模式
- 2. JavaScript设计模式--简单工厂模式例子---XHR工厂
- 3. 单例模式，简单工厂模式
- 4. java工厂模式例子
- 5. 简单工厂模式简单实例
- 6. Java简单工厂模式
- 7. 单工厂模式，工厂模式和抽象工厂模式超级简单介绍
- 8. Java ------ 工厂模式、单例模式
- 9. 简单工厂(一)——介绍
- 10. 设计模式之简单工厂模式介绍