设计模式-工厂模式

目录

一.简单工厂模式

1.什么时简单工厂模式

2.对简单工厂模式的理解

3.代码演示

 二.工厂方法模式

1.什么时工厂方法模式

2.对工厂方法模式的理解

3.代码演示

三.抽象工厂

1.什么抽象工厂

2.对抽象工厂的理解

3.代码演示

---

一.简单工厂模式

1.什么时简单工厂模式

        简单工厂模式(Simple Factory Pattern）是指由一个工厂对象决定创建出哪一种产品类的实例。
属于创建型模式，但它不属于GOF，23种设计模式。

2.对简单工厂模式的理解

        如果有一类A，创建这个A类的对象比较复杂，我们就可以写一个工厂类，在这个工厂类中写一个创建A类对象的一个方法，以后我们再想创建A类的对象时就可以创建这个工厂，然后直接调用工厂的创建方法就可以获取这个A类的对象了。

        相当于我们创建一个家具工厂，如果我们需要沙发可以从工厂里直接拿，如果我们需要床也可以直接在工厂里拿。但如果我们想在工厂里添加新家具就必须要改造我们的工厂，这违背开闭原则，后面会提出工厂方法模式。

简单工厂适用场景：

• 工厂类负责创建的对象较少。
• 客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心。

简单工厂的缺点:

• 工厂类的职责相对过重，增加新的产品时需要修改工厂类的判断逻辑，违背开闭原则。
• 不易于扩展过于复杂的产品结构。

3.代码演示

类图:

IFueniture接口:

public interface IFurniture {
    void sign();
}

Sofa类实现IFueniture接口：

public class Sofa implements IFurniture{
    @Override
    public void sign() {
        System.out.println("我是沙发~");
    }
}

Bed类实现IFueniture接口

public class Bed implements IFurniture{
    @Override
    public void sign() {
        System.out.println("我是床~");
    }
}

创建Furniture工厂

public class FurnitureFactory {

    /**
     * 根据class创建对象
     * @param clazz
     * @return
     */
    public IFurniture getInstance(Class clazz) {
        try {
            if (clazz != null) {
                return (IFurniture) clazz.newInstance();
            }
        } catch (Exception e) {

        }
        return null;
    }

    /**
     * 根据String创建对象
     * @param name
     * @return
     */
    public IFurniture getInstance(String name) {
        try {
            if (null != "name") {
                if (name.equals("sofa")) {
                    //sofa
                    return new Sofa();
                } else if (name.equals("bed")) {
                    //bed
                    return new Bed();
                }
            }
        } catch (Exception e) {

        }
        return null;
    }
}

利用工厂创建Sofa、Bed

public class SimplefactoryTest {
    public static void main(String[] args) {
        //创建工厂
        FurnitureFactory furnitureFactory = new FurnitureFactory();
        //利用工厂创建sofa对象
        IFurniture furniture1 = furnitureFactory.getInstance(Sofa.class);
        furniture1.sign();
        IFurniture furniture2 = furnitureFactory.getInstance("bed");
        furniture2.sign();

    }
}

 二.工厂方法模式

1.什么时工厂方法模式

工厂方法模式(Fatory Method Pattern)是指定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。

属于创建型设计模式。

适用场景:创建对象需要大量重复的代码。
客户端(应用层）不依赖于产品类实例如何被创建、实现等细节。一个类通过其子类来指定创建哪个对象。

优点:用户只需关心所需产品对应的工厂，无须关心创建细节。加入新产品符合开闭原则，提高了系统的可扩展性。

缺点：

• 类的个数容易过多，增加了代码结构的复杂度。
• 增加了系统的抽象性和理解难度。

2.对工厂方法模式的理解

        相比于简单工厂模式，工厂方法模式生产的产品更清晰，比如沙发工厂就生产沙发，床工厂就生产床，如果想添加椅子直接造一个椅子工厂就好，已经创建好的工厂不需要更改，这些工厂都实现超级工厂。扩展性更好。

3.代码演示

类图:

IFurnitureFactory工厂接口：

public interface IFurnitureFactory {
    IFurniture creat();
}

SofaFurnitureFactory生产沙发的工厂

public class SofaFurnitureFactory implements IFurnitureFactory {
    @Override
    public IFurniture creat() {
        return new Sofa();
    }
}

BedFurnitureFactory生产床的工厂

public class BedFurnitureFactory implements IFurnitureFactory{
    @Override
    public IFurniture creat() {
        return new Bed();
    }
}

沙发工厂制造沙发，床工厂制造床

public class FactoryMethedTest {
    public static void main(String[] args) {
        //创建Sofa工厂
        IFurnitureFactory sofaFactory = new SofaFurnitureFactory();
        IFurniture sofa = sofaFactory.creat();
        sofa.sign();

        //创建Bed工厂
        IFurnitureFactory bedFactory = new BedFurnitureFactory();
        IFurniture bed = bedFactory.creat();
        bed.sign();
    }
}

三.抽象工厂

1.什么抽象工厂

        抽象工厂模式( Abastract Factory Pattern)爱行远m一个建一系列相关或相互依赖对象的接口，无须指定他们具体的类.

属于创建型设计模式。

2.对抽象工厂的理解

        工厂里的家具分欧式风格的家具和美式风格的家具，欧式工厂可以生产所有的欧式家具，美式工厂可以生产美式的家具。易于扩展，但是不符合开闭原则(当我们添加新的家具时，需要修改写好的工厂，在写好的工厂里添加创建新家具的代码).

适用场景：

• 客户端(应用层）不依赖于产品类实例如何被创建、实现等细节。
• 强调一系列相关的产品对象(属于同一产品族)一起使用创建对‘象需要大量重复的代码。
• 提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。

优点：

• 具体产品在应用层代码隔离，无须关心创建细节（最少知道原则）
• 将一个系列的产品族统一到一起创建。

缺点:

• 规定了所有可能被创建的产品集合，产品族中扩展新的产品困难需要修改抽象工厂的接口。
• 增加了系统的抽象性和理解难度。

3.代码演示

欧式沙发:

public class EuropeTypeSofa implements IFurniture {
    @Override
    public void sign() {
        System.out.println("我是欧式沙发");
    }
}

欧式床:

public class EuropeTypeBed implements IFurniture {
    @Override
    public void sign() {
        System.out.println("我是欧式床");
    }
}

工厂接口:

public interface IFurnitureFactory {
    IFurniture creatSofe();//创建沙发
    IFurniture creatBed();//创建床
}

欧式家具：

/**
 * 欧式家具工厂
 * 只生产欧式的家具
 */
public class EuropeTypeFurniturnFactory implements IFurnitureFactory{
    @Override
    public IFurniture creatSofe() {
        //创建欧式沙发
        return new EuropeTypeSofa();
    }

    @Override
    public IFurniture creatBed() {
        //创建欧式床
        return new EuropeTypeBed();
    }
}

美式工厂:

/**
 * 美式家具工厂
 */
public class AmericanFurnitureFactory implements IFurnitureFactory{
    @Override
    public IFurniture creatSofe() {
        return null;
    }

    @Override
    public IFurniture creatBed() {
        return null;
    }
}

Test

public class AbstractFactoryTest {
    public static void main(String[] args) {
        //创建欧式家具工厂
        IFurnitureFactory europeTypeFactory = new EuropeTypeFurniturnFactory();
        europeTypeFactory.creatBed().sign();
        europeTypeFactory.creatSofe().sign();
        //创建美式家具工厂  这个工厂里的方法并没有实现 我们并没有创建美式家具的实体类
        IFurnitureFactory americanFactory = new AmericanFurnitureFactory();
        americanFactory.creatBed();
        americanFactory.creatSofe();
    }
}