工厂设计模式:工厂模式可以动态的决定实例化哪一个类,减少类与类之间的耦合度,尽量让类达到:高内聚,低耦合。
工厂设计模式有2种:
1.静态工厂
2.实例工厂
一.简单工厂
简单工厂又被称为静态工厂,主要有一个静态方法,用它来接收参数,并根据参数来决定返回实现同一个接口的不同类型的实例。需要什么类型,就传递什么类型的参数!
简单工厂实现代码:
1.建立一个抽象类(Animal抽象类):
package animalFactory1;
//定义一个动物抽象类
/**
*类描述:抽象动物类
*@author: 张宇
*@date: 日期: 2018年6月29日 时间: 上午11:01:51
*@version 1.0
*/
public abstract class Animal {
//有一个吃的抽象方法
public abstract void eat();
}
2.实现抽象类方法的动物实例(Cat实例):
package animalFactory1;
/**
* 类描述:猫类继承动物类
* @author: 张宇
* @date: 日期: 2018年6月29日 时间: 上午11:00:47
* @version 1.0
*/
public class Cat extends Animal {
// 猫重写了动物的抽象方法
@Override
public void eat() {
System.out.println("猫吃鱼!");
}
}
3.实现抽象类方法的动物实例(Dog实例):
package animalFactory1;
/**
*类描述:狗类实现动物类
*@author: 张宇
*@date: 日期: 2018年6月29日 时间: 上午11:02:48
*@version 1.0
*/
public class Dog extends Animal{
//狗也重写了动物的抽象方法
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("狗吃肉!");
}
}
4.动物工厂类的实例化过程(AnimalFactory):
package animalFactory1;
/**
*类描述:
*@author: 张宇
*@date: 日期: 2018年6月29日 时间: 上午10:53:32
*@version 1.0
*/
public class AnimalFactory {
private AnimalFactory() {}
//静态方法判断哪个动物是哪个类,如果是狗就创建狗类型,如果是猫就创建猫类型,如果都不是就返回为空
/*
* @param type 动物的类型
* @param return 返回创建对象的类型
*/
public static Animal CreateAnimal(String type){
if("dog".equals(type)){//判断是否等于这个类型
return new Dog();
}else if("cat".equals(type)){//判断是否等于这个类型
return new Cat();
}else{
return null;
}
}
}
5.简单静态工厂的测试类(AnimalDemo):
package animalFactory1;
/**
* 类描述:工厂模式测试类
* @author: 张宇
* @date: 日期: 2018年6月29日 时间: 上午11:00:12
* @version 1.0
*/
public class AnimalDemo {
public static void main(String[] args) {
// 具体类调用
// Dog d=new Dog();
// d.eat();
// Cat c=new Cat();
// c.eat();
// System.out.println("-------------------------------");
// 狗的静态工厂方法
Animal animal = AnimalFactory.CreateAnimal("dog");
animal.eat();
// 猫的静态工厂方法
animal = AnimalFactory.CreateAnimal("cat");
animal.eat();
// 猪的静态工厂方法
animal = AnimalFactory.CreateAnimal("pig");
if (animal != null) {
animal.eat();
} else {
System.out.println("不好意思,暂时没有这种动物!");
}
}
}
测试结果:
狗吃肉!
猫吃鱼!
不好意思,暂时没有这种动物!
由上面的代码看出,简单工厂的核心就是一个核心AnimalFactory类,我们想要什么样的产品之间传递参数就好了!
二,实例工厂:
实例工厂设计模式先创建类对象,然后通过对象来调用创建实例对象的方法,而不是在自己的类中创建对象。
实例工厂设计模式代码实现例子:
1.创建一个接口(Animal接口):
package InstanceAnimalFactory;
public abstract class Animal {
public abstract void eat();
}
2.创建动物类的实现类(Cat类)
package InstanceAnimalFactory;
public class Cat extends Animal {
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("猫要吃鱼!");
}
}
3.创建动物类的实现类(Dog类):
package InstanceAnimalFactory;
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃肉!");
}
}
4.创建动物类的工厂(Factory类):
package InstanceAnimalFactory;
public interface Factory {
public abstract Animal createAnimal();
}
5.创建动物类的工厂(Cat类的工厂):
package InstanceAnimalFactory;
public class CatFactory implements Factory{
public Animal createAnimal() {
// TODO Auto-generated method stub
return new Cat();
}
}
6.创建动物类的工厂(Dog类的工厂):
package InstanceAnimalFactory;
public class DogFactory implements Factory {
public Animal createAnimal() {
// TODO Auto-generated method stub
return new Dog();
}
}
7.实例工厂的测试类:
package InstanceAnimalFactory;
import org.junit.Test;
/**
*类描述:测试工厂类设计模式
*@author: 张宇
*@date: 日期: 2018年7月2日 时间: 下午8:34:32
*@version 1.0
*/
public class AnimalDemo {
@Test
public void fun(){
DogFactory f1=new DogFactory();//获取工厂的调用对象
Animal a=f1.createAnimal();// 利用该对象调用方法创造该动物类型的对象
a.eat();//然后用该动物对象调用方法
System.out.println("-------------");
CatFactory f2=new CatFactory();
Animal b=f2.createAnimal();
b.eat();
System.out.println("-------------");
}
}
运行结果:
狗吃肉!
-------------
猫要吃鱼!
-------------
实例工厂就是谁创建,就用谁的的工厂创建对象,降低类与类直接的耦合度,增强代码的实用性。
关于工厂模式的适用场景:
情况一:一个对象拥有很多子类,那么创建该对象的子类使用工厂模式是最合适的,不但可以面向接口的编程,为维护以及开发带来方便。
情况二:如果创建某个对象时需要进行许多额外的操作,如查询数据库然后将查询到的值赋予要创建的对象(单例初始化时使用比较多),或是需要许多额外的赋值等等,都需要工厂类设计模式。
Spring 框架中也用到了工厂模式--BeanFactory创建对象的实例,另外Spring框架中除了用到了工厂模式,还用到了前端控制器:spring用前端控制器DispatcherServlet对请求进行分发 ;单例模式:spring中bean默认是单例模式 。