设计模式大全---工厂模式

简单介绍

工厂模式属于创建型模式，主要是定义一个对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

优点：

1.一个调用者想创建一个对象，只要知道其名称就可以了。

2.扩展性高，如果想增加一个产品，只要拓展一个工厂类就可以。

3.可以屏蔽产品的具体实现，调用者只需要关心产品的接口。

4.具有解耦的作用，降低了代码的重复。

缺点：

每次增加一个产品，需要增加一个具体的实现类，和工厂类。

工厂类的使用场景：

• 数据库访问

• Spring中通过getBean(“xxx”)获取Bean

• JMS中使用连接工厂创建一个连接对象

简单工厂模式【静态工厂方法模式】

创建一个厨师，可以各种菜：鱼，鸡，虾。

1.创建Cook接口

public interface Cook {
    public void cook();
}

2.创建具体的实现类

鱼：

public class Fish implements Cook {
    @Override
    public void cook() {
        System.out.println("Cook Fish");
    }
}

鸡：

public class Chicken implements Cook {
    @Override
    public void cook() {
        System.out.println("Cook Chicken");
    }
}

虾：

public class Shrimp implements Cook {
    @Override
    public void cook() {
        System.out.println("Cook Shrimp");
    }
}

3.创建工厂类

public class CookFactory {
    public static Cook cooking(String type) {
        if (type == null) {
            return null;
        }
        if (type.equalsIgnoreCase("FISH")) {
            return new Fish();
        }
        if (type.equalsIgnoreCase("SHRIMP")) {
            return new Shrimp();
        }
        if (type.equalsIgnoreCase("CHICKEN")) {
            return new Chicken();
        }
        return null;
    }
}

4.测试

public class Test {
    public static void main(String[] args) {
        Cook fish = CookFactory.cooking("fish");
        fish.cook();
        Cook shrimp = CookFactory.cooking("shrimp");
        shrimp.cook();
        Cook chicken = CookFactory.cooking("chicken");
        chicken.cook();
    }
}

输出结果如下：

Cook Fish
Cook Shrimp
Cook Chicken

上面示例存在一个问题，如果我们新增具体的实现类的话，就要更改工厂类中的cooking()方法。这个问题我们可以使用反射机制进行解决。

public class CookFactoryImprove {
    public static Object getClass(Class<? extends Cook> clazz){
        Object obj = null;
        try{
            obj = Class.forName(clazz.getName()).newInstance();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        return obj;
    }
}

测试

public class Test {
    public static void main(String[] args) {
        Cook fish = (Cook) CookFactoryImprove.getClass(Fish.class);
        fish.cook();
        Cook shrimp = (Cook) CookFactoryImprove.getClass(Shrimp.class);
        shrimp.cook();
        Cook chicken = (Cook) CookFactoryImprove.getClass(Chicken.class);
        chicken.cook();
    }
}

输出结果如下：

Cook Fish
Cook Shrimp
Cook Chicken

工厂方法模式

工厂方法模式是对每一个对象都有一个与之对应的工厂

工厂方法模式主要是由： 抽象工厂， 具体工厂， 抽象产品 ，具体产品组成。

争对简单工厂模式升级我们只需要增加一个抽象工厂，和对他的实现即可。

1.抽象工厂

public interface Factory {
    public Cook getCook();
}

2.对工厂的具体实现

鱼

public class FishFactory implements Factory {
    @Override
    public Cook getCook() {
        return new Fish();
    }
}

虾

public class ShrimpFactory implements Factory {
    @Override
    public Cook getCook() {
        return new Shrimp();
    }
}

鸡

public class ChickenFactory implements Factory {
    @Override
    public Cook getCook() {
        return new Chicken();
    }
}

3.测试

public class Test {
    public static void main(String[] args) {
        Factory fishFactory = new FishFactory();
        Cook fish = fishFactory.getCook();
        fish.cook();
        Factory shrimpFactory = new ShrimpFactory();
        Cook shrimp = shrimpFactory.getCook();
        shrimp.cook();
        Factory chickenFactory = new FishFactory();
        Cook chicken = chickenFactory.getCook();
        chicken.cook();
    }
}

输出结果如下：

Cook Fish
Cook Shrimp
Cook Chicken

抽象工厂模式【Kit模式】

提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体情况下，创建多个产品族中的产品对象。
详解看图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tyIT6QOK-1607740445593)(https://cdn.jsdelivr.net/gh/yunshanmister/picture/imgs1586436377(1)].jpg)

这个我使用水果工厂举例

1.创建水果接口，水果工厂接口

public interface Fruit {
    public void get();
}

public interface FruitFactory {
    public Fruit getAppple();

    public Fruit getPeach();
}

2.创建具体的水果抽象类

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

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

3.创建具体的水果类，水果分为1，2两个等级。

public class Apple_1 extends Apple {
    @Override
    public void get() {
        System.out.println("生产一级苹果");
    }
}

public class Apple_2 extends Apple {
    @Override
    public void get() {
        System.out.println("生产二级苹果");
    }
}

public class Peach_1 implements Fruit {
    @Override
    public void get() {
        System.out.println("生产一级梨子");
    }
}

public class Peach_2 implements Fruit {
    @Override
    public void get() {
        System.out.println("生产二级梨子");
    }
}

4.创建一级水果和二级水果的一类工厂和二类工厂

public class FruitFactory_1 implements FruitFactory {
    @Override
    public Fruit getAppple() {
        return new Apple_1();
    }

    @Override
    public Fruit getPeach() {
        return new Apple_1();
    }
}

public class FruitFactory_2 implements FruitFactory {
    @Override
    public Fruit getAppple() {
        return new Apple_2();
    }

    @Override
    public Fruit getPeach() {
        return new Apple_2();
    }
}

5.测试

public class Test {
    public static void main(String[] args) {
        FruitFactory factory1 = new FruitFactory_1();
        FruitFactory factory2 = new FruitFactory_2();

        Fruit apple_1 = factory1.getAppple();
        apple_1.get();
        Fruit apple_2 = factory2.getAppple();
        apple_2.get();
        Fruit peach_1 = factory1.getPeach();
        peach_1.get();
        Fruit peach_2 = factory2.getPeach();
        peach_2.get();
    }
}

输出结果如下：

生产一级苹果
生产二级苹果
生产一级苹果
生产二级苹果