介绍:
工厂模式划分来说一般有三种:简单工厂(静态工厂)、工厂模式、抽象工厂模式,其中简单工厂不属于23种设计模式之一。
A.简单工厂
简单工厂又叫静态工厂(Static Factory Method),由工厂决定创建出哪一系类的实例,实质是由工厂类传入的参数,动态的决定创建哪个系类的产品,属于创建型模式,但不属于GOF(四人帮)23设计模式
适用场景:
工厂类创建对象比较少,客户端(应用层)只需要知道传入工厂的参数,对于创建对象的逻辑不用关心。
优点:只需要传入一个正确的参数,就能获取你要的对象,而不需要知道创建细节。
缺点:工厂类的职责较重,增加新的产品,需要改变工厂类的原有逻辑,违背了开闭原则。
源码展示:
1、创建一个接口(接口的定义,该接口可以通过简单工厂来创建)
public interface A
{
void oper(String str);
}
2、接口的实现类
public class B implements A
{
@Override
public void oper(String str)
{
System.out.println(str+"B");
}
}
public class C implements A
{
@Override
public void oper(String str)
{
System.out.println(str+"C");
}
}
3、工厂创建接口对象
public class Factory
{
public static A createApi(int condition)
{
A api = null;
if(condition == 1){
api = new B();
}else if(condition == 2){
api = new C();
}
return api;
}
}
4、写一个测试类
public class Run
{
public static void main(String[] args)
{
A a=Factory.createApi(2);
a.oper("s");
}
}
B.工厂模式(Factory Pattern)
工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。它提供了一种创建对象的最佳方式。在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。
定义一个接口,让其子类决定实例化哪一个工厂类,工厂模式创建延迟到子类进行。(主要用来解决接口的问题),在我们明确计划根据不同条件创建不同实例的时候。(创建过程必须在子类进行)。
举例:
哪一天你突然想打球,可以直接去球店买一个球,不需要知道球是怎么做出来的,以及具体实现。?
优点:
- 需要一个对象,只要知道他的名称就可以了。
- 扩展性好,你要新增一个产品,只要扩展一个工厂类就可以了。
- 屏蔽产品的具体实现,只要关心产品的接口。
缺点:
每增加一个产品就要加一个具体类和对象实现工厂,使的系统的类成倍增加,增加了系统的复杂度,增加了系统的依赖
温馨提示:
在生产复杂对象的时候可以用到工厂模式。而简单对象就直接new就好了,不必多此一举,因为增加一个工厂类,会提高系统的复杂度。
源码展示:
1.定义一个接口
public interface Ball {
void ball();
}
2.创建接口的实体类 篮球类
public class Basketball implements Ball {
@Override
public void ball() {
System.out.println("篮球来了");
}
}
3.创建接口的实体类? 足球类
public class Football implements Ball {
@Override
public void ball() {
System.out.println("足球来了");
}
}
4.创建球的工厂?生成基于给定信息的实体类的对象。
public class BallFactory
{
//使用 getBall 方法获取形状类型的对象
public Ball getBall(String ball){
if(ball == null){
return null;
}
if(ball.equalsIgnoreCase("篮球")){
return new Basketball();
} else if(ball.equalsIgnoreCase("足球")){
return new Football();
}
return null;
}
}
5.写一个测试类
public class Run {
public static void main(String[] args) {
BallFactory ballFactory=new BallFactory();
Ball ball=ballFactory.getBall("篮球");
ball.ball();
Ball ball1=ballFactory.getBall("足球");
ball1.ball();
}
}
得到输出结果:篮球来了 、足球来了
C.抽象工厂模式(Abstract Factory Pattern)
抽象工厂也可以叫超级工厂,超级工厂生产其他工厂,抽象工厂又称其他工厂的工厂(超级工厂里面放工厂),接口负责创建一个相关对象的工厂,不需要显示指定他们的类。每个生产的工厂都能按工厂模式提供对象。
主要来解决接口选择问题,在一个产品族里,定义多个产品,在一个工厂聚合多个产品
举例:
假设有一个做电脑配件的大工厂(抽象工厂),里面会有专门生产鼠标、键盘的工厂(工厂),你要买什么就直接到这个大工厂的某一个工厂买就可以了。
优点:
当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。
缺点:
产品族扩展非常困难,要增加一个系列的某一产品,既要在抽象的 Creator 里加代码,又要在具体的里面加代码。
温馨提示:
- 产品族难扩展,产品等级易扩展。
- ?当一个系统只存在一个等级结构的产品,抽象工厂模式退化到工厂方法模式。
源码展示:
1.定义鼠标的接口
public interface Mouse
{
void mouse();
}
2.定义键盘的接口
public interface Keyboard
{
void keyboard();
}
3.创建鼠标的实现类
public class DellMouse implements Mouse
{
@Override
public void mouse()
{
System.out.println("戴尔鼠标来了");
}
}
public class HuaruiMouse implements Mouse
{
@Override
public void mouse()
{
System.out.println("华瑞鼠标来了");
}
}
4.创建键盘的实体类
public class HuaruiKeyboard implements Keyboard
{
@Override
public void keyboard()
{
System.out.println("华瑞鼠标来了");
}
}
public class DellKeyboard implements Keyboard
{
@Override
public void keyboard()
{
System.out.println("戴尔键盘来了");
}
}
5.为 鼠标对象 和 键盘?对象创建抽象类来获取工厂。
public abstract class AbstractFactory
{
public abstract Keyboard getKeyboard(String keyboard);
public abstract Mouse getMouse(String mouse);
}
6、创建扩展了 AbstractFactory 的工厂类,基于给定的信息生成实体类的对象。
public class KeyboardFactory extends AbstractFactory
{
@Override
public Keyboard getKeyboard(String keyboard)
{
if (keyboard==null){
return null;
}
if (keyboard.equalsIgnoreCase("华瑞键盘")){
return new HuaruiKeyboard();
}else if (keyboard.equalsIgnoreCase("戴尔键盘")){
return new DellKeyboard();
}
System.out.println("没有此类销售");
return null;
}
@Override
public Mouse getMouse(String mouse) {
return null;
}
}
public class MouseFactory extends AbstractFactory
{
@Override
public Keyboard getKeyboard(String keyboard) {
return null;
}
@Override
public Mouse getMouse(String mouse)
{
if (mouse==null){
return null;
}
if (mouse.equalsIgnoreCase("华瑞鼠标")){
return new HuaruiMouse();
}else if (mouse.equalsIgnoreCase("戴尔鼠标")){
return new DellMouse();
}
System.out.println("暂无此类鼠标");
return null;
}
}
7、创建一个工厂创造器/生成器类,通过传递形状或颜色信息来获取工厂。
public class FactoryProducer {
public static AbstractFactory getFactory(String factory){
if (factory.equalsIgnoreCase("鼠标工厂")){
return new MouseFactory();
}else if (factory.equalsIgnoreCase("键盘工厂")){
return new KeyboardFactory();
}
System.out.println("不好意思,我们没有这类工厂");
return null;
}
}
8、使用 FactoryProducer 来获取 AbstractFactory,通过传递类型信息来获取实体类的对象。
public class Run
{
public static void main(String[] args)
{
AbstractFactory abstractFactory=FactoryProducer.getFactory("鼠标工厂");
Mouse m=abstractFactory.getMouse("华瑞鼠标");
Mouse mouse=abstractFactory.getMouse("戴尔鼠标");
m.mouse();
mouse.mouse();
AbstractFactory abstractFactory1=FactoryProducer.getFactory("键盘工厂");
Keyboard keyboard=abstractFactory1.getKeyboard("华瑞键盘");
Keyboard keyboard1=abstractFactory1.getKeyboard("戴尔键盘");
keyboard.keyboard();
keyboard1.keyboard();
}
}
|