揭秘设计模式之工厂模式

简单工厂模式

定义

简单工厂模式是指由一个工厂对象决定创建出哪一个产品类的实例,但它不属于GOF23种设计模式。简单工厂适用于工厂类负责创建的对象较少的场景,且客户端只需要传入工厂类的参数,对于如何创建对象的逻辑不需要关心。创建型模式。

package simple;
/**
 * 水果接口
 */
public interface Fruit {
    void whatIm();
}

package simple;
public class Pear implements Fruit {
    @Override
    public void whatIm() {
        System.out.println("梨");
    }
}

package simple;
public class Apple implements Fruit {
    @Override
    public void whatIm() {
        System.out.println("苹果");
    }
}

package simple;
public class FruitFactory {

    public static Fruit createFruit(String type){
        if(type.equals("apple")){
           return new Apple();
         }else if(type.equals("pear")){
          return new Pear();
        }else {
            System.out.println("没有找到");
        }
        return null;
    }

    public static Fruit createNewFruit(Class<? extends Fruit> clazz){
        try {
            if(clazz != null){
              return clazz.newInstance();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}

package simple;

/**
 * 简单工厂模式是指由一个工厂对象决定创建出哪一个产品类的实例,但它不属于GOF23种设计模式。
 * 简单工厂适用于工厂类负责创建的对象较少的场景,且客户端只需要传入工厂类的参数,
 * 对于如何创建对象的逻辑不需要关心。创建型模式。
 */
public class SimpleTest {

    public static void main(String[] args) {
        FruitFactory.createFruit("apple").whatIm();
        FruitFactory.createNewFruit(Pear.class).whatIm();
    }
}

结果

工厂方法模式

定义

工厂方法模式是指定义一个用于创建对象的接口,但让实现这个接口的类来决定实例化哪一个类。FactoryMethod使一个类的实例化延迟到其子类。在工厂方法模式中用户只需要关心所需产品对应的工厂,无须关心创建细节。

package factory;
import simple.Fruit;

public interface FruitFactory {
    Fruit createFruit();
}

package factory;
import simple.Apple;
import simple.Fruit;
public class AppleFactory implements FruitFactory {
    @Override
    public Fruit createFruit() {
        return new Apple();
    }
}

package factory;
import simple.Fruit;
import simple.Pear;
public class PearFactory implements FruitFactory {
    @Override
    public Fruit createFruit() {
        return new Pear();
    }
}

package factory;
/**
 * 工厂方法模式是指定义一个用于创建对象的接口,但让实现这个接口的类来决定实例化哪一个类在工厂方法模式。
 * Factory Method使一个类的实例化延迟到其子类。在工厂方法模式中用户只需要关心所需产品对应的工厂,
 * 无须关心创建细节。
 */
public class FactoryTest {
    public static void main(String[] args) {
        FruitFactory fruitFactory = new AppleFactory();
        fruitFactory.createFruit().whatIm();
    }
}

结果

抽象工厂模式

定义

抽象工厂模式(Abastract Factory Pattern)是指提供一个创建一系列相关或相互依赖对象的接口,无须指定他们具体的类。客户端（应用层）不依赖于产品类实例如何被创建、实现等细节,强调的是一系列相关的产品对象(属于同一产品族）一
起使用创建对象需要大量重复的代码。需要提供一个产品类的库，所有的产品以同样的接口出现,从而使客户端不依赖于具体实现。讲解抽象工厂之前,我们要了解两个概念产品等级结构和产品族,看下面的图：

package abstrac;
public interface INote {
    void edit();
}

package abstrac;
public interface IVideo {
    void record();
}

package abstrac;
public class JavaNote implements INote {
    @Override
    public void edit() {
        System.out.println("java笔记");
    }
}

package abstrac;
public class JavaViedo implements IVideo {
    @Override
    public void record() {
        System.out.println("java视频");
    }
}

package abstrac;
public interface StudyFactory {
    INote studyNote();
    IVideo studyVideo();
}

package abstrac;
public class JavaFactory implements StudyFactory {
    @Override
    public INote studyNote() {
        return new JavaNote();
    }
    @Override
    public IVideo studyVideo() {
        return new JavaViedo();
    }
}

package abstrac;
public class GoNote implements INote {
    @Override
    public void edit() {
        System.out.println("GO笔记");
    }
}

package abstrac;
public class GoViedo implements IVideo {
    @Override
    public void record() {
        System.out.println("GO视频");
    }
}

package abstrac;
public class GoFactory implements StudyFactory {
    @Override
    public INote studyNote() {
        return new GoNote();
    }
    @Override
    public IVideo studyVideo() {
        return new GoViedo();
    }
}

package abstrac;
/**
 * 抽象工厂模式(Abastract Factory Pattern)是指提供一个创建一系列相关或相互依赖对象的接口,
 * 无须指定他们具体的类。
 */
public class AbstractTest {
    public static void main(String[] args) {
        JavaFactory javaFactory = new JavaFactory();
        javaFactory.studyNote().edit();
        javaFactory.studyVideo().record();
    }
}

结果

这里的解释很好