简单的工厂模式,一句话概括“我们不生产类，我们只从子类拿”

工厂模式学习

        1、简单工厂模式学习

                     1、简单工厂模式中，分为三个主要角色，工厂类，抽象产品类，具体产品类，工厂类是整个类的核心，主要功能是根据调用者传入的值，返回外界想要的对象，调用者无需知道内部是如何创建的，只需要知道自己想要某个类即可。

                 以下我们分别将三个角色实现：以下场景的需求为获取水果工厂里生产的水果

                     2、先创建抽象产品类，该类为接口，主要是为了具体产品类进行调用

package simpleFactory;

//水果接口
public interface Fruit {
    public void get();
}

                    3、创建具体产品类时间接口，该类的目的是为了创建对象，如果需要多个，就可以创建多个对象来实现

package simpleFactory;


public class Apple implements Fruit {
    @Override
    public void get() {
        System.out.println("生产苹果");
    }
}

                   4、创建工厂类，调用对象中的方法，调用者调用该类来获取对象，不需要单独去创建每一个对象，可以添加static来修饰，可以不需要new工厂对象，调用更方便

package simpleFactory;

public class SimpleFactory {

    //static 修饰  不需要再去new对象
    public static Fruit getApple(){
        return new Apple();
    }

}

                 5、具体调用

    public static void main(String[] args) {
        Fruit apple = SimpleFactory.getApple();
        apple.get();

        //打印 ：生产苹果
    }

 

         2、工厂模式的学习

                   1、工厂模式是简单工厂模式的一个优化，工厂类中不需要再去像简单工厂中new对象，只需要提供一个让子工厂必须实现的方法即可，这样的的好处在于可以不用修改子工厂就可以引进新的产品，以下我们来代码实现下：

                   2、先创建抽象产品类，该类为接口，主要是为了具体产品类进行调用

package simpleFactory;

//水果接口
public interface Fruit {
    public void get();
}

                    3、创建具体产品类时间接口，该类的目的是为了创建对象，如果需要多个，就可以创建多个对象来实现

package simpleFactory;


public class Apple implements Fruit {
    @Override
    public void get() {
        System.out.println("生产苹果");
    }
}

                   4、此时创建的工厂类不再去真正new对象，而是改为了接口的方式

public interface FruitFactory {

    //获取水果对象
    Fruit getFruit();
}

                  5、有了工厂类， 再创建子类来实现工厂类，此时，以后再想有个新的产品加入工厂类，只需要创建一个子工厂类，实现工厂接口即可，不需要再去修改工厂类代码

public class AppleFactory implements FruitFactory{

    @Override
    public Fruit getFruit() {
        return new Apple();
    }
}

                  6、工厂模式调用

   public static void main(String[] args) {

        FruitFactory fruitFactory = new AppleFactory();
        Fruit fruit = fruitFactory.getFruit();
        fruit.get();

    }

 

        3、抽象工厂的学习

                  1、抽象工厂的出现，主要应用场景如下：

                          普通工厂中，工厂中有苹果，但是如果此时我们把苹果分类为了普通苹果，进口苹果等等等，此时我们就需要再去创建普通苹果工厂，进口苹果工厂，那样创建的工厂就会很多，为了解决这种问题，也就出现了抽象工厂模式，

                     核心就是苹果类拆分为普通和进口，工厂类也进行了拆分，拆分为了普通和进口，各个工厂调用自己类型的产品，此时，如果又有了新的品种，比如外星球苹果，只需要创建一个外星球苹果，和一个外星球苹果的子工厂然后实现工厂，就弥补

                    了创建工厂数量多的问题，以下我们来代码实现

                  2、先创建抽象产品类，该类为接口，主要是为了具体产品类进行调用

package simpleFactory;

//水果接口
public interface Fruit {
    public void get();
}

                 3、创建苹果接口，这里就和工厂模式产生了区别，之前的苹果是类，这里改为了抽象类，因为这里的类不是为了创建实例，而是为了让子类继承

public abstract class Apple implements Fruit{
    public abstract void get();
}

 

                  4、有了苹果抽象类，创建一个普通苹果品类继承，如果有更多品类，直接继承苹果抽象类即可，以下只写一个

public class AppPt extends Apple {
    @Override
    public void get() {
        System.out.println("生产普通苹果");
    }
}

 

                   5、要调用的类已经创建完了，我们这就要创建工厂类了，这里的工厂类也做了修改，改成了工厂接口，让子工厂进行调用

public abstract class FruitFactory {

    //获取苹果对象
    public abstract Fruit getApple();
}

                 6、之后创建子工厂，继承工厂类，这里的子工厂主要创建各自品类的对象

public class FruitFactoryPt extends FruitFactory{
    @Override
    public Fruit getApple() {
        return new AppPt();
    }
}

               7、类都创建完了 ，我们来调用一下，会发现调用普通苹果工厂，就可以创建普通苹果

 public static void main(String[] args) {

        FruitFactory fruitFactory = new FruitFactoryPt();
        Fruit fruit = fruitFactory.getApple();
        fruit.get();

    }