关于java:设计模式之工厂模式

预计这个系列的文章是每篇一个设计模式，重点是为了让大家可能利用休闲工夫，比如说 5 分钟就可能比拟全面通俗易懂地理解设计模式。

前言

接下来就是手撕设计模式的环节了，设计模式自身并不难，难的是在理论状况下是否能天然地想到应用设计模式。简略来说设计模式的实质是一种思维，一种重构代码，使代码高可用的思维。

在面向对象设计（写代码）的时候个别会遵循以下几个准则，当然初学必定很难遵循，然而至多得理解是什么，而后无意识地往这个方向靠。

• 繁多职责准则： 一个类只负责具体的某一个性能，当新需要呈现的时候，最好的做法是减少一个类而不是批改原来的类。
• 开闭准则： 当开发好一个类后，这个类须要有良好的扩展性，能够通过继承和多态来增加新性能。
• 里氏替换准则： 把父类换成子类，程序不会报错，然而反过来就不行。艰深地来讲，子类可能扩大父类的性能，然而不能扭转原来父类原有的性能。
• 接口隔离准则： 客户端不应该依赖于它所不须要的接口，设计接口时尽量精简繁多。
• 依赖倒置准则： 高级模块不应该依赖低级模块，两者都给应该依赖形象；形象不应该依赖细节，细节应该依赖形象。

这些实践的货色我曾经尽可能简略地讲了

工厂及形象工厂模式

无关工厂模式有三种，简略工厂，工厂，形象工厂，通常来说，后面两者并为一项说工厂模式。

那么什么叫工厂模式呢，最简略来说，你没必要和产品打交道，你间接和工厂打交道，把 new 产品的操作交给工厂来做。

1、简略工厂模式

之所以简略，是因为它只波及到 具体工厂类，形象产品类和具体产品类，上面间接来看代码。

形象产品类：

手机

public abstract class AbstractPhone {public abstract void use();
}

具体产品类：

魅族手机和一加手机

public class Meizu extends AbstractPhone{
    @Override
    public void use() {System.out.println("正在应用魅族手机");
    }
}

public class OnePlus extends AbstractPhone {
    @Override
    public void use() {System.out.println("正在应用一加手机");
    }
}

具体工厂类：

生产手机的工厂

public class PhoneFactory {public AbstractPhone createPhone(String brand) {if(brand.equals("一加")) {return new OnePlus();
        } else if(brand.equals("魅族")) {return new Meizu();
        } else {System.out.println("没有该品牌的生产权");
            return null;
        }
    }
}

测试类：

@Test
public void test01() {
    // 新建一个工厂
    PhoneFactory factory = new PhoneFactory();            
    
    // 咱们不必要跟产品打交道，通知工厂须要一部一加手机即可
    AbstractPhone onePlus = factory.createPhone("一加");    
    onePlus.use();

    AbstractPhone meiZu = factory.createPhone("魅族");
    meiZu.use();}

以上就是简略工厂的实现形式，总结就是

1. 有个形象产品类或者接口
2. 具体产品继承或者实现形象产品
3. 具体工厂类，依据需要生产产品

UML 类图：

2、工厂模式

当初问题来了，如果这个工厂持续和小米，华为单干的话

开玩笑开玩笑，除了具体产品类须要减少，是不是也须要 批改具体工厂类，这是咱们不心愿看到的。设计好的类，最好就是不要是在减少需要的时候扭转类。

所以想到了把 生产工厂抽象化，须要减少小米，只须要增加一个小米的生产类，而不改变已有的工厂类。这样就是工厂模式。

须要 形象产品类，具体产品类，形象工厂类，具体工厂类

形象产品类：

和下面用的是一样的形象产品，这里不再赘述

具体产品：

同样是魅族和一加手机

形象工厂类：

public abstract class AbstractPhoneFactory {public abstract AbstractPhone createPhone();
}

具体工厂类：

这个例子中有两个具体工厂类，生产魅族手机的工厂和一加手机的工厂

public class OnePlusFactory extends AbstractPhoneFactory {
    @Override
    public OnePlus createPhone() {return new OnePlus();
    }
}

public class MeizuFactory extends AbstractPhoneFactory {
    @Override
    public Meizu createPhone() {return new Meizu();
    }
}

测试类：

@Test
public void test02() {OnePlusFactory onePlusFactory = new OnePlusFactory();
    onePlusFactory.createPhone().use();

    MeizuFactory meizuFactory = new MeizuFactory();
    meizuFactory.createPhone().use();

}

就算之后须要减少一个小米手机类，只须要 增加 具体产品类，具体工厂类，并不需要批改已有的类。

类图：

3、形象工厂模式

如果当初需要持续减少，然而不是减少品牌品种，而是。魅族和一加心愿更精确地找到市场定位，所以都推出了 中端手机和高端旗舰手机 来冲击市场，这时候咱们应该怎么设计呢。

这时候形象工厂类不是单纯地生产手机，而是须要生产一个产品族

产品族是以产品平台为根底，通过增加不同的共性模块，以满足不同客户个性化需要的一组相干产品。

中端手机和旗舰手机就是一个产品族。

总的来说，艰深地来讲就是魅族工厂须要生产魅族的中端手机和魅族的高端手机，一加工厂须要生产一加的中端手机和高端手机。

须要 形象工厂类，具体的形象工厂类，形象产品类，产品族具体的形象产品类，具体产品类

形象产品类：

public abstract class AbstractPhone {public abstract void use();
}

产品族具体的形象产品类：

中端手机和旗舰手机

public abstract class AbstractMiddlePhone extends AbstractPhone {
    @Override
    public abstract void use();}

public abstract class AbstractTopPhone extends AbstractPhone{public abstract void use();
}

具体产品类：

魅族的中端手机，旗舰手机；一加的中端手机，旗舰手机。

public class MeizuMiddlePhone extends AbstractMiddlePhone {
    @Override
    public void use() {System.out.println("魅族中端产品");
    }
}

public class MeizuTopPhone extends AbstractTopPhone {
    @Override
    public void use() {System.out.println("魅族高端旗舰");
    }
}

public  class OnePlusMiddlePhone extends AbstractMiddlePhone {
    @Override
    public void use() {System.out.println("一加中端产品");
    }
}

public class OnePlusTopPhone extends AbstractTopPhone {
    @Override
    public void use() {System.out.println("一加高端旗舰");
    }
}

形象工厂类：

public abstract class AbstractFactory {public abstract AbstractPhone createMiddlePhone();

    public abstract AbstractPhone createTopPhone();}

具体形象工厂类：

魅族生产工厂，一加生产工厂

public class MeizuFactory extends AbstractFactory {
    @Override
    public MeizuMiddlePhone createMiddlePhone() {return new MeizuMiddlePhone();
    }

    @Override
    public MeizuTopPhone createTopPhone() {return new MeizuTopPhone();
    }
}

public class OnePlusFactory extends AbstractFactory {
    @Override
    public OnePlusMiddlePhone createMiddlePhone() {return new OnePlusMiddlePhone();
    }

    @Override
    public OnePlusTopPhone createTopPhone() {return new OnePlusTopPhone();
    }
}

测试类：

@Test
public void test03() {OnePlusFactory onePlusFactory = new OnePlusFactory();
    MeizuFactory meizuFactory = new MeizuFactory();
    onePlusFactory.createMiddlePhone().use();
    onePlusFactory.createTopPhone().use();

    meizuFactory.createMiddlePhone().use();
    meizuFactory.createTopPhone().use();

}

类图：