设计模式-工厂模式
分类 工厂模式延伸了三类
简单工厂模式
定义
- 属于类的创建型模式,又叫做静态工厂方法模式。
- 通过专门定义一个工厂类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
- 将抽象子类的创建，和关于抽象子类相关的业务逻辑分离
主要组成
工厂类：核心类，根据外界的需求，决定创建并返回哪个具体的抽象子类。抽象类：定义抽象子类所需的属性和方法，子类通过继承自抽象类获得这些方法。抽象子类：继承自抽象类，是具体操作的实现者，根据需求重写父类继承过来的方法。
UML类图
代码实现
Compare.java(抽象类)
public abstract class Compare {
protected String strA = "";
protected String strB = "";
// 抽象方法
public abstract boolean GetResutl();
public Compare() {
super();
}
public Compare(String strA, String strB) {
super();
this.strA = strA;
this.strB = strB;
}
public String getStrA() {
return strA;
}
public void setStrA(String strA) {
this.strA = strA;
}
public String getStrB() {
return strB;
}
public void setStrB(String strB) {
this.strB = strB;
}
}
CompareFactory
public class CompareFactory{
public static Compare createCompare(String strA, String strB, String compare) {
Compare comp = null;
// 根据需求（不同参数-compare）创建对应的 比较类实例
switch (compare) {
case "<":
comp = new LtCompare(strA,strB);
break;
case "<=":
comp = new LtOREqualCompare(strA,strB);
break;
case "=":
comp = new EqualCompare(strA,strB);
break;
case ">":
comp = new GtCompare(strA,strB);
break;
case ">=":
comp = new GtOREqualCompare(strA,strB);
break;
default :
// 默认创建 EqualCompare 类 实例
comp = new EqualCompare(strA,strB);
break;
}
return comp;
}
}
抽象子类
LtCompare.java(小于比较类)
public class LtCompare extends Compare {
public LtCompare(){
super();
}
public LtCompare(String strA, String strB){
super(strA,strB);
}
@Override
public boolean GetResutl() {
return NumberUtil.compare(Double.parseDouble(strA),Double.parseDouble(strB)) == -1
? true : false;
}
}
EqualCompare.java(等于比较类)
public class EqualCompare extends Compare {
public EqualCompare() {
super();
}
public EqualCompare(String strA, String strB) {
super(strA, strB);
}
@Override
public boolean GetResutl() {
return strA.equals(strB) ? true : false;
}
}
GtCompare.java(大于比较类)
public class GtCompare extends Compare {
public GtCompare(){
super();
}
public GtCompare(String strA, String strB){
super(strA,strB);
}
@Override
public boolean GetResutl() {
return NumberUtil.compare(Double.parseDouble(strA),Double.parseDouble(strB)) == 1
? true : false;
}
}
LtOREqualCompare.java(小于或等于比较类)
public class LtOREqualCompare extends Compare {
public LtOREqualCompare(){
super();
}
public LtOREqualCompare(String strA, String strB){
super(strA,strB);
}
@Override
public boolean GetResutl() {
double d1 = Double.parseDouble(strA);
double d2 = Double.parseDouble(strB);
return NumberUtil.compare(d1,d2) <= 0
? true : false;
}
}
GtOREqualCompare.java(大于或等于比较类)
public class GtOREqualCompare extends Compare {
public GtOREqualCompare() {
super();
}
public GtOREqualCompare(String strA, String strB) {
super(strA,strB);
}
@Override
public boolean GetResutl() {
double d1 = Double.parseDouble(strA);
double d2 = Double.parseDouble(strB);
return NumberUtil.compare(d1,d2) >= 0
? true : false;
}
}
测试
public class CompareTest {
public static void main(String[] args) {
Compare compare;
String str1;
String str2;
str1 = "10.666";
str2 = "10.50";
// 简单工厂模式 - 比较判断
compare = CompareFactory.createCompare(str1,str2,"<");
System.out.println("str1 < str2 : "+compare.GetResutl());
compare = CompareFactory.createCompare(str1,str2,"=");
System.out.println("str1 = str2 : "+compare.GetResutl());
compare = CompareFactory.createCompare(str1,str2,">");
System.out.println("str1 > str2 : "+compare.GetResutl());
compare = CompareFactory.createCompare(str1,str2,"<=");
System.out.println("str1 <= str2 : "+compare.GetResutl());
compare = CompareFactory.createCompare(str1,str2,">=");
System.out.println("str1 >= str2 : "+compare.GetResutl());
}
}
运行结果
str1 < str2 : false
str1 = str2 : false
str1 > str2 : true
str1 <= str2 : false
str1 >= str2 : true
优缺点
优点
- 就一个具体的工厂类创建对象，代码量少
缺点
- 工厂类中集中了所有实力的创建逻辑，所以 高内聚 这方面做的不够好，
- 当具体 抽象子类增多时，需要修改工厂类代码。扩展性不够好
使用场景
- 简单工厂模式主要适用于抽象子类的业务逻辑相同，但具体实现不同的情况。
- 以上例子中，两个数的比较的方式不外乎就是以上哪几种，具体实现种类不多的情况下 是适合用
简单工厂模式的
工厂方法模式
定义
- 属于类的创建型模式。
- 定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
- 工厂方法针对每一种产品提供一个工厂类，通过不同的工厂实例来创建不同的产品实例，相比于
简单工厂模式来说，不再提供一个统一的工厂创建所有的对象
主要组成
抽象工厂类：抽象类，提供创建抽象子类的接口方法，不参与创建实例。具体工厂类：实现抽象工厂接口的具体工厂类，用于创建具体抽象子类。抽象类：定义抽象子类所需的属性和方法，子类通过继承自抽象类获得这些方法。抽象子类：继承自抽象类，是具体操作的实现者，根据需求重写父类继承过来的方法。
UML类图
代码实现
CompareFactory.java(抽象工厂类)
public interface CompareFactory{
public Compare createCompare();
}
LtCompareFactory.java (具体工厂类)
public class LtCompareFactory implements CompareFactory{
@Override
public Compare createCompare() {
// TODO Auto-generated method stub
return new LtCompare();
}
}
GtCompareFactory.java (具体工厂类)
public class GtCompareFactory implements CompareFactory{
@Override
public Compare createCompare() {
// TODO Auto-generated method stub
return new GtCompare();
}
}
EqualCompareFactory.java (具体工厂类)
public class EqualCompareFactory implements CompareFactory{
@Override
public Compare createCompare() {
// TODO Auto-generated method stub
return new EqualCompare();
}
}
LtOREqualCompareFactory.java (具体工厂类)
public class LtOREqualCompareFactory implements CompareFactory{
@Override
public Compare createCompare() {
// TODO Auto-generated method stub
return new LtOREqualCompare();
}
}
GtOREqualCompareFactory.java (具体工厂类)
public class GtOREqualCompareFactory implements CompareFactory{
@Override
public Compare createCompare() {
// TODO Auto-generated method stub
return new GtOREqualCompare();
}
}
以下类与简单工厂模式的一样
Compare.java- 抽象类EqualCompare.java- 抽象子类LtCompare.java- 抽象子类GtCompare.java- 抽象子类GtOREqualCompare.java- 抽象子类LtOREqualCompare.java- 抽象子类
测试
// Client
public class CompareTest {
public static void main(String[] args) {
Compare compare;
// 工厂方法模式 - 比较判断
compare = new GtCompareFactory().createCompare();
compare.setStrA("100");
compare.setStrB("50");
System.out.println(compare.GetResutl());
compare = new LtCompareFactory().createCompare();
compare.setStrA("100");
compare.setStrB("50");
System.out.println(compare.GetResutl());
compare = new EqualCompareFactory().createCompare();
compare.setStrA("100");
compare.setStrB("50");
System.out.println(compare.GetResutl());
}
}
运行结果
true
false
false
优缺点
优点
Client不需要再负责对象的创建，明确的各个类的职责- 增加新的对象，只要增加一个具体的类和具体的工厂类即可
- 不会影响已有的代码，可维护性、扩展性好
缺点
- 编写额外的代码，代码量大
抽象工厂模式
待更
总结
简单工厂：使用一个工厂对象用来创建同一等级结构中的任意比较对象 (Compare)。（不支持拓展增加 比较类）工厂方法：使用多个工厂对象用来创建同一等级结构中对应的固定比较对象 (Compare)。（支持拓展增加 比较类）
感谢
感谢您的阅读，有收获？希望兄弟姐妹三叔六婶大姨大妈阿公阿婆来个三连击，给更多的同学看到 这篇文章，感谢
你的每一次回眸都是永恒，每一次鼓励都是我前进的动力，每一次分享都是对我的认可。
原创文章 14
获赞 33
访问量 9082