设计模式之-工厂模式_工厂方法模式的特征是

一、什么是工厂模式

    工厂模式属于创建型模式，创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

二、工厂模式的特点

    1.有一个创建对象的接口。

    2.创建过程在其子类执行。

三、优缺点

    优点：

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

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

        3、屏蔽产品的具体实现，调用者只关心产品的接口。

    缺点：

        每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。(摘自：菜鸟教程)

四、分类

    1.简单工厂模式（静态工厂模式）

    2.工厂方法模式

    3.抽象工厂模式

五、简单工厂模式实例

    1、创建人类接口

package com.xiao.designpattern.factorypattern;
 
/**
 * @Description 人类接口
 * @Auther: 笑笑
 * @Date: 14:41 2018/10/31
 */
public interface Person {
 
    public void eat();
}

    2、创建男人‘类’

package com.xiao.designpattern.factorypattern;
 
/**
 * @Description 男人类，实现人类接口
 * @Auther: 笑笑
 * @Date: 14:41 2018/10/31
 */
public class Male implements Person {
    @Override
    public void eat() {
        System.out.println("男人，是人类，要吃饭！");
    }
}

    3、创建女人‘类’

package com.xiao.designpattern.factorypattern;
 
/**
 * @Description 女人类，实现人类接口
 * @Auther: 笑笑
 * @Date: 14:43 2018/10/31
 */
public class Female implements Person{
    @Override
    public void eat() {
        System.out.println("女人，是人类，要吃饭！");
    }
}

    4、创建人类工厂类

package com.xiao.designpattern.factorypattern;
 
/**
 * @Description 人类 工厂类
 * @Auther: 笑笑
 * @Date: 14:45 2018/10/31
 */
public class PersonFactory {
 
    public Person getPerson(String personType){
        if(personType == null){
            return null;
        }
        if(personType.equalsIgnoreCase("MALE")){
            return new Male();
        }else if(personType.equalsIgnoreCase("FEMALE")){
            return new Female();
        }
        return null;
    }
}

    5、使用工厂类分别获取男人、女人对象

package com.xiao.designpattern.factorypattern;
 
/**
 * @Description 使用人类 工厂类获取 男人或女人 对象
 * @Auther: 笑笑
 * @Date: 14:48 2018/10/31
 */
public class FactoryDemo {
 
    public static void main(String[] args){
        PersonFactory  personFactory = new PersonFactory();
 
        //获取男人对象
        Person male = personFactory.getPerson("male");
        //调用eat方法
        male.eat();
 
        //获取女人对象
        Person female = personFactory.getPerson("female");
        //调用eat方法
        female.eat();
    }
}

    运行结果如下：

六、工厂方法模式

在统一的工厂接口中定义创建方法，特殊的工厂需要自己独立创建工厂，实现统一的工厂接口

package com.xiao.designpattern.factorypattern.factorymethod;
 
/**
 * @Description 创建人的统一工厂接口
 * @Auther: 笑笑
 * @Date: 21:45 2019/4/21
 */
public interface PersonFactory {
 
    Person createPerson();
}

package com.xiao.designpattern.factorypattern.factorymethod;
 
/**
 * @Description 创建男人的特殊工厂
 * @Auther: 笑笑
 * @Date: 21:46 2019/4/21
 */
public class MaleFactory implements PersonFactory {
 
    @Override
    public Person createPerson() {
        return new Male();
    }
}

package com.xiao.designpattern.factorypattern.factorymethod;
 
/**
 * @Description 创建女人的特殊工厂
 * @Auther: 笑笑
 * @Date: 21:47 2019/4/21
 */
public class FemaleFactory implements PersonFactory {
 
    @Override
    public Person createPerson() {
        return new Female();
    }
}

package com.xiao.designpattern.factorypattern.factorymethod;
 
/**
 * @Description 调用者
 * @Auther: 笑笑
 * @Date: 21:49 2019/4/21
 */
public class client {
 
    public static void main(String[] args){
        //通过男人工厂创建男人
        MaleFactory maleFactory = new MaleFactory();
        Person person = maleFactory.createPerson();
        person.eat();
 
        //通过女人工厂创建女人
        FemaleFactory femaleFactory = new FemaleFactory();
        Person person1 = femaleFactory.createPerson();
        person1.eat();
    }
}

运行结果如下:

七、抽象工厂模式实例

package com.xiao.designpattern.factorypattern.abstractfactory;
 
/**
 * @Description 创建人的工厂
 * @Auther: 笑笑
 * @Date: 22:24 2019/4/21
 */
public interface PersonFactory {
 
    Money HasMoney();
}
 
 
 

package com.xiao.designpattern.factorypattern.abstractfactory;
 
/**
 * @Description 钱接口
 * @Auther: 笑笑
 * @Date: 22:20 2019/4/21
 */
public interface Money {
    void money();
}
 
/**
 * @Description 很多钱的类
 * @Auther: 笑笑
 * @Date: 22:21 2019/4/21
 */
class ManyMoney implements Money{
    @Override
    public void money() {
        System.out.println("很多很多钱！");
    }
}
 
/**
 * @Description 很少钱的类
 * @Auther: 笑笑
 * @Date: 22:24 2019/4/21
 */
class LittleMoney implements Money{
    @Override
    public void money() {
        System.out.println("很少很少钱！");
    }
}

package com.xiao.designpattern.factorypattern.abstractfactory;
 
/**
 * @Description 穷人的工厂类
 * @Auther: 笑笑
 * @Date: 22:27 2019/4/21
 */
class PoorPersonFactory implements PersonFactory{
    @Override
    public Money HasMoney() {
        return new LittleMoney();
    }
}

 

package com.xiao.designpattern.factorypattern.abstractfactory;
 
/**
 * @Description 富人的工厂类
 * @Auther: 笑笑
 * @Date: 22:26 2019/4/21
 */
class WealthyPersonFactory implements PersonFactory{
 
    @Override
    public Money HasMoney() {
        return new ManyMoney();
    }
}

package com.xiao.designpattern.factorypattern.abstractfactory;
 
/**
 * @Description 调用者
 * @Auther: 笑笑
 * @Date: 22:29 2019/4/21
 */
public class Client {
    public static void main(String[] args){
        //通过富人的工厂类创建富人
        PersonFactory wealthyPersonFactory = new WealthyPersonFactory();
        Money money = wealthyPersonFactory.HasMoney();
        money.money();
 
        //通过穷人的工厂类创建穷人
        PersonFactory poorPersonFactory = new PoorPersonFactory();
        Money money1 = poorPersonFactory.HasMoney();
        money1.money();
    }
}

运行结果如下：