java 工厂模式例子_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

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！

猫母亲生了一只小猫眯

狗母亲生了一只小狗

奶羊生了一只小羊

奶羊生产了羊奶

奶牛生了一只小牛

奶牛生产了牛奶

发布者：全栈程序员栈长，转载请注明出处：https://javaforall.cn/162272.html原文链接：https://javaforall.cn