设计模式 第二节 工厂模式（Factory）

    1、 使用场景：系统更换皮肤、spring-BeanFactory
        简单工厂用于创建单一产品，经常和单例模式一起使用，例如用简单工厂创建缓存对象（ 文件缓存 ），某天需要改用 Redis 缓存，修改工厂即可。
            Spring 中的BeanFactory 就是简单工厂模式的体现，根据传入一个唯一的标识来获得Bean 对象
        抽象工厂常用于创建一整个产品族，而不是单一产品。通过选择不同的工厂来达到目的，其优势在于可以通过替换工厂而快速替换整个产品族。
            抽象工厂适用于更换子分类
    2、 分类：
        简单工厂模式（静态工厂方法模式）
            1、是类的创建模式，又叫静态工厂方法模式。由一个工厂对象决定创建出哪一种产品类的实例。通常它根据自变量的不同返回不同的类的实例。
            2、角色构成：
                1）接口
                2）实现类
                3）工厂类

        工厂方法模式（Factory Method）
            角色构成：
                1）接口
                2）实现类
                3）工厂接口
                4）工厂实现类
        
        抽象工厂模式
            角色构成：
                1）接口
                2）实现类
                3）工厂抽象类（方法：返回接口类型的每一个实现类方法）
                4）工厂实现类 
    3、 优点：客户端与具体要创建的产品解耦，扩展性和灵活性高。
        缺点：增加要创建的对象时，需要增加的代码较多，会使系统变得较为复杂。

 

public interface Clothe {
    public String buyClothe();
}

public class Pants implements Clothe {
    @Override
    public String buyClothe() {
        return "Pants";
    }
}

public class Shirt implements Clothe {
    @Override
    public String buyClothe() {
        return "Shirt";
    }
}

public class Skirt implements Clothe {
    @Override
    public String buyClothe() {
        return "Skirt";
    }
}

//静态工厂

public class ClotheFactory {

    public Clothe getClothe(String TypeClothe){
        if("Skirt".equals(TypeClothe)){
            return new Skirt();
        }else if("Pants".equals(TypeClothe)){
            return new Pants();
        }else if("Shirt".equals(TypeClothe)){
            return new Shirt();
        }else{
            System.out.println("没有您要的品类。");
            return null;
        }
    }
}

public class SimpleFactoryTest {

    public static void main(String[] args) {
        ClotheFactory clotheFactory = new ClotheFactory();
        System.out.println(clotheFactory.getClothe("Skirt"));
    }
}

//工厂方法

public interface ClotheFactory {

    Clothe getClothe();
}

public class PantsFactory implements ClotheFactory {
    @Override
    public Clothe getClothe() {
        return new Pants();
    }
}

public class ShirtFactory implements ClotheFactory {
    @Override
    public Clothe getClothe() {
        return new Shirt();
    }
}

public class SkirtFactory implements ClotheFactory {
    @Override
    public Clothe getClothe() {
        return new Skirt();
    }
}

public class FunctionFactoryTest {
    public static void main(String[] args) {
        ClotheFactory clotheFactory = new PantsFactory();
        System.out.println(clotheFactory.getClothe());
    }
}

//抽象工厂方法

public abstract class AbstractFactory {

    abstract Clothe getPants();
    abstract Clothe getShirt();
    abstract Clothe getSkirt();
}

public class ClotheFactory extends AbstractFactory {

    @Override
    Clothe getPants() {
        return new Pants();
    }

    @Override
    Clothe getShirt() {
        return new Shirt();
    }

    @Override
    Clothe getSkirt() {
        return new Skirt();
    }
}

public class AbstractFactoryTest {
    public static void main(String[] args) {
        ClotheFactory clotheFactory = new ClotheFactory();
        System.out.println(clotheFactory.getPants());
    }
}