设计模式-工厂模式JAVA实现

在出库拣货完成后自然要通过物流将货物发到最终的2B或2C客户，这个时候可能有多种方式。比如例子提到的通过自有车队，第三方车队，快递和物流这四种方式将货物发给最终方。那么在选择最终方的时候就可以考虑用工厂模式将进行相关对象的创建

第一种工厂模式 形似而神不似的 简单工厂模式。
简单工厂就是我传递给你一个变量，你看到后根据指定的变量发给我要用到的对象

在这里首先将仍然是设计一个顶层的物流接口，然后四种物流形式（自有车队，第三方车队，快递，物流)进行具体的实现

package factory;

/**

• TMS顶层接口
• @author [email protected]

• */
  public interface ITms {

  //运输
  public void transport();
  }

package factory;

/**

• 公司自有车队
• @author [email protected]

• */
  public class Tms implements ITms{

  @Override
  public void transport() {

  System.out.println("使用自有车队承运");

  }

}

package factory;

/**

• 快递公司
• @author zhous

• */
  public class TmsExpress implements ITms{

  @Override
  public void transport() {

  System.out.println("使用快递公司承运");

  }

package factory;

/**

• 物流公司
• @author zhous

• */
  public class TmsLogistics implements ITms{

  @Override
  public void transport() {

  System.out.println("使用物流公司承运");

  }

}

package factory;

/**

• 第三方车队
• @author [email protected]

• */
  public class TmsThird implements ITms{

  @Override
  public void transport() {

  System.out.println("使用第三方车队承运");

  }

}

在完成了基本物流形式的抽象与实现后展示简单工厂的实现实例
最简单的办法就是我传个名称，你按图索骥把对象返回给我。再就是根据全限定名返给我一个对象，最后是根据类型来返回我一个对象。

总之是根据参数找到类的对象，然后返给调用方

package factory.factorysimple;

import factory.ITms;
import factory.Tms;
import factory.TmsExpress;
import factory.TmsLogistics;
import factory.TmsThird;

/**

• 简单工厂模式实现
• @author [email protected]

• */
  public class SimpleFactory {

  /**

  • 通过变量决定取哪个具体的物流实现
    */
    public ITms getTms(String name){
    if("tms".equals(name))
    return new Tms();
    if("third".equals(name))
    return new TmsThird();
    if("express".equals(name))
    return new TmsExpress();
    if("logistics".equals(name))
    return new TmsLogistics();
    else
    return null;
    }
    /**
  • 以类的全限定名去加载，可以少写好多废话
    */
    public ITms getTms1(String className){
    try {
    if( null != className && !"".equals(className)){
    return (ITms)Class.forName(className).newInstance();
    }
    }catch (Exception e){
    e.printStackTrace();
    }
    return null;
    }

  /**

  • 传入Class
    */
    public ITms getTms2(Class clazz){
    if (null != clazz) {
    try {
    return (ITms) clazz.newInstance();
    } catch (Exception e) {
    e.printStackTrace();
    }
    }
    return null;
    }

}
实例调用
package factory.factorysimple;

import factory.ITms;
import factory.TmsExpress;

public class SimpleFactoryMain {

public static void main(String[] args) {

    SimpleFactory factory = new  SimpleFactory();

    //自有车队承运
    ITms tms = factory.getTms("tms");

    tms.transport();

    //第三方车队承运
    ITms tms1 = factory.getTms1("factory.TmsThird");

    tms1.transport();

    //快递公司承运
    ITms tms2 = factory.getTms2(TmsExpress.class);

    tms2.transport();
}

}

调用展示

第二种是一般意义上的工厂模式
这套工厂模式实际上是对工厂进行了抽象。建立了一套工厂接口和实现体系，通过不同的工厂返回不同的对象

首先新建相应的项层接口和各个工厂的实现
package factory.fatorymethod;

import factory.ITms;

/**

• 创建Tms工厂顶层接口
• @author zhous

• */
  public interface ITmsFactory {

  public ITms getTms();

}

package factory.fatorymethod;

import factory.ITms;
import factory.Tms;

/**

• 自有车队工厂
• @author zhous

• */
  public class TmsFactory implements ITmsFactory {

  @Override
  public ITms getTms() {

  return new Tms();

  }

}

package factory.fatorymethod;

import factory.ITms;
import factory.TmsThird;

/**

• 第三方车队工厂
• @author zhous

• */
  public class TmsThirdFactory implements ITmsFactory {

  @Override
  public ITms getTms() {

  return new TmsThird();

  }

}

package factory.fatorymethod;

import factory.ITms;
import factory.TmsExpress;

/**

• 快递工厂
• @author zhous

• */
  public class TmsExpressFactory implements ITmsFactory {

  @Override
  public ITms getTms() {

  return new TmsExpress();

  }

}

package factory.fatorymethod;

import factory.ITms;
import factory.TmsLogistics;

/**

• 物流工厂
• @author zhous

• */
  public class TmsLogicticsFactory implements ITmsFactory {

  @Override
  public ITms getTms() {

  return new TmsLogistics();

  }

}

实例调用
package factory.fatorymethod;

import factory.ITms;

public class MethodFactoryMain {

public static void main(String[] args) {

    //调用自营车队
    ITmsFactory factory1 = new TmsFactory();
    ITms tms1 = factory1.getTms();
    tms1.transport();

    //调用自营车队
    ITmsFactory factory2 = new TmsThirdFactory();
    ITms tms2 = factory2.getTms();
    tms2.transport();

    //调用物流
    ITmsFactory factory3 = new TmsLogicticsFactory();
    ITms tms3 = factory3.getTms();
    tms3.transport();
}

}

调用结果展示

第三个是抽象工厂模式，这个适合实际业务中比较复杂的业务逻辑，比如有通用业务变量，通用业务方法等。需要各自单独实现的部分由具体类扩展。否则按下边的简单示例来看，就和普通的工厂方法没什么区别了

下边是简写的，大致了解有这一种路数就可以了，这里边没有写顶层的接口，直接从抽象类开始
package factory.factoryabstract;

import factory.ITms;

/**

• declare abstract class
• @author [email protected]

• */
  public abstract class AbstractTmsFactory {

  public abstract ITms getTms();

}

具体实现类
package factory.factoryabstract;

import factory.ITms;
import factory.Tms;

/**

• declare tms's extends class
• @author [email protected]

• */
  public class TmsAbstractFactory extends AbstractTmsFactory{

  @Override
  public ITms getTms() {

  return new Tms();

  }

}

package factory.factoryabstract;

import factory.ITms;
import factory.TmsExpress;

/**

• declare TmsExpress's extends class
• @author [email protected]

• */
  public class TmsExpressAbstractFactory extends AbstractTmsFactory{

  @Override
  public ITms getTms() {

  return new TmsExpress();

  }

}

实例调用
package factory.factoryabstract;

public class AbstractFactoryMain {

public static void main(String[] args) {

    //自有车队
    AbstractTmsFactory factory = new TmsAbstractFactory();
    //快递
    AbstractTmsFactory factory1 = new TmsExpressAbstractFactory();

    factory.getTms().transport();

    factory1.getTms().transport();
}

}

调用效果