1:工厂模式
1.1简单工厂模式
优点: 简单工厂模式,封装了创建对象的逻辑,完成了创建对象逻辑与业务代码逻辑的解耦。 试想客户端是多个service层的文件,对比不使用简单工厂模式,当我们要改变产生对象的逻辑时, 需要在多个service文件中找到这部分代码进行修改。在使用简单工厂模式后,只需要修改简单工厂中生成对象的逻辑即可, 不需要修改业务代码。完成了解耦。 缺点: 每当具体产品类的抽象产品类增多时,会需要在简单工厂类中新增关于新增产品类对象生成的方法。 当抽象产品类很多时,抽象工厂会很臃肿。并且在这种情形下,SimpleFactory类也不符合开闭原则。
public class SimpleFactory {
public static void main(String[] args) {
A a = getFactory("A1");
a.method();
a = getFactory("A2");
a.method();
}
public static A getFactory(String type){
if("A1".equals(type)){
return new A1();
}else
return new A2();
}
}
interface A{
void method();
}
class A1 implements A{
public void method(){
System.out.println("A1-----------");
}
}
class A2 implements A{
public void method(){
System.out.println("A2-----------");
}
}
1.2工厂模式
从简单工厂模式的讲述知道:简单工厂的一个缺点在于,每当需要新增产品时, 都需要修改负责生产产品的SimpleFactory类,违背了“开闭原则”, 并且会使SimpleFactory类十分的臃肿。 而使用工厂方法模式后,当新增ProductC时, 只需要对应创建具体产品类ProductC和负责生产ProductC的具体工厂FactoryC即可。符合“开闭原则”,便于扩展。 它的缺点在于: (1)类的个数容易过多,增加复杂度 (2)实现抽象工厂接口的具体工厂只能生产出一种产品(可以用抽象工厂模式解决)
public class Factory {
public static void main(String[] args) {
B b1 = new B1Factory().getB();
b1.method();
B b2 = new B2Factory().getB();
b2.method();
}
}
interface B {
void method();
}
class B1 implements B {
@Override
public void method() {
System.out.println("B1----------");
}
}
class B2 implements B {
@Override
public void method() {
System.out.println("B2----------");
}
}
interface Factorys {
B getB();
}
class B1Factory implements Factorys {
@Override
public B getB() {
return new B1();
}
}
class B2Factory implements Factorys {
@Override
public B getB() {
return new B2();
}
}
1.3抽象工厂模式
抽象工厂模式是用于解决“一类产品”的创建问题(在上述场景中,可以把“李宁篮球”,“李宁足球”,“安踏篮球”,“安踏足球”归纳为:“篮球”,“足球”这两类商品)
public class AbstractFactory {
public static void main(String[] args) {
AbstractFactorys lnFactory = new LNFactory();
lnFactory.getFootballFactory().makeFootBall();
lnFactory.getBasketballFactory().makeBasketBall();
AbstractFactorys nkFactory = new NKFactory();
nkFactory.getFootballFactory().makeFootBall();
nkFactory.getBasketballFactory().makeBasketBall();
}
}
//抽象工厂
interface AbstractFactorys{
Football getFootballFactory();
Basketball getBasketballFactory();
}
//抽象产品
interface Football{
void makeFootBall();
}
interface Basketball{
void makeBasketBall();
}
//具体产品
class LNFootball implements Football{
@Override
public void makeFootBall() {
System.out.println("makeLNFootball-----------");
}
}
class NKFootball implements Football{
@Override
public void makeFootBall() {
System.out.println("makeNKFootball-----------");
}
}
class LNBasketball implements Basketball{
@Override
public void makeBasketBall() {
System.out.println("makeLNBasketball-----------");
}
}
class NKBasketball implements Basketball{
@Override
public void makeBasketBall() {
System.out.println("makeNKBasketball-----------");
}
}
//具体工厂
class LNFactory implements AbstractFactorys{
@Override
public Football getFootballFactory() {
return new LNFootball();
}
@Override
public Basketball getBasketballFactory() {
return new LNBasketball();
}
}
class NKFactory implements AbstractFactorys{
@Override
public Football getFootballFactory() {
return new NKFootball();
}
@Override
public Basketball getBasketballFactory() {
return new NKBasketball();
}
}