前言

工厂模式的核心本质就是减少了我们去new对象这样子的操作，工厂模式可以分为三种，简单工厂模式，工厂方法模式，抽象工厂模式

• 简单工厂模式

简单工厂模式本质上是违背开闭原则的，简单工厂模式把实例化的操作放到统一一个类里面，让这个类去决定创建哪种对象

• 工厂方法模式

工厂方法模式我觉得就是在简单工厂模式上加了一层，这样就能保证开闭原则了

• 抽象工厂模式

抽象工厂模式其实就是工厂的工厂，也就是一个超级工厂，他提供了一个抽象的工厂接口，他是所有工厂一般化的一种形态

传统模式

假如我们有一个饼干类，顾客想要买饼干，但是饼干有很多种，比如巧克力饼干，夹心饼干，压缩饼干等等

代码实现

//客户类
public class client {
    public static void main(String[] args) {
        //买一个巧克力饼干
        Cookie cookie = new ChocolateCookies();
        cookie.eatCookie();
        //买一个夹心饼干
        cookie = new CompressedCookie();
        cookie.eatCookie();
        //买一个压缩饼干
        cookie = new SandwichCookie();
        cookie.eatCookie();
    }
}
//公共饼干接口
public interface Cookie {
    
    public void name();
 
    public void eatCookie();
 
}
 
//夹心饼干实现
public class SandwichCookie implements Cookie{
 
    @Override
    public void name() {
        System.out.println("夹心饼干");
    }
 
    @Override
    public void eatCookie() {
        System.out.println("吃掉夹心曲奇");
    }
    
}
 
//压缩饼干实现
public class CompressedCookie implements Cookie{
 
    @Override
    public void name() {
        System.out.println("压缩饼干");        
    }
 
    @Override
    public void eatCookie() {
        System.out.println("吃掉压缩饼干");        
    }
    
}
//巧克力饼干实现
public class ChocolateCookies implements Cookie{
 
    @Override
    public void name() {
        System.out.println("巧克力饼干");        
    }
 
    @Override
    public void eatCookie() {
        System.out.println("吃掉巧克力饼干");        
    }
}
//吃掉巧克力饼干
//吃掉压缩饼干
//吃掉夹心曲奇
复制代码

简单工厂模式

我们可以看到在我们的Client类里面，我们多次使用了new，去生成不同的饼干，我们可以使用简单工厂模式去优化我们的代码，其实就是我们有一个饼干工厂，我们每次去买饼干都是从工厂中拿的。

为什么说简单工厂模式不符合开闭原则呢？

在简单工厂模式中，就比如上图，我还要加一个草莓饼干，这个时候，我们需要修改饼干工厂的代码，所以不符合开闭原则。

代码实现

这里只把饼干工厂类的代码放在这里，饼干的实现类并没有改变

//客户类
public class client {
    public static void main(String[] args) {
        Cookie cookie = CookieFactory.getCookie("巧克力");
        cookie.eatCookie();
        cookie = CookieFactory.getCookie("夹心");
        cookie.eatCookie();
        cookie = CookieFactory.getCookie("压缩");
        cookie.eatCookie();
    }
}
//饼干工厂类
public class CookieFactory {
    
    public static Cookie getCookie(String cookieName){
        if("巧克力".equals(cookieName)){
            return new ChocolateCookies();
        }else if("夹心".equals(cookieName)){
            return new SandwichCookie();
        }else if("压缩".equals(cookieName)){
            return new CompressedCookie();
        }else{
            return null;
        }
 
    }
}
//吃掉巧克力饼干
//吃掉夹心曲奇
//吃掉压缩饼干
复制代码

工厂方法模式

其实我觉得工厂方法模式就是在简单工厂模式加了一层，这样就符合了开闭原则

代码实现

我们可以看到工厂方法模式的代码十分冗余，虽然他符合了开闭原则，但是我们在日常开发中很少使用它。

//客户类
public class client {
    public static void main(String[] args) {
        Cookie cookie = new ChocolateFacotry().getCookie();
        cookie.eatCookie();
        cookie = new SandwichFactory().getCookie();
        cookie.eatCookie();
        cookie = new CompressedFactory().getCookie();
        cookie.eatCookie();
    }
}
//饼干工厂
public interface FacotryMehtod {
    Cookie getCookie();
}
//夹心饼干工厂
public class SandwichFactory implements FacotryMehtod{
 
    @Override
    public Cookie getCookie() {
        return new SandwichCookie();
    }
    
}
//压缩饼干工厂
public class CompressedFactory implements FacotryMehtod{
 
    @Override
    public Cookie getCookie() {
        return new CompressedCookie();
    }
    
}
//巧克力饼干工厂
public class ChocolateFacotry implements FacotryMehtod{
 
    @Override
    public Cookie getCookie() {
        return new ChocolateCookies();
    }
    
}
复制代码

抽象工厂模式

对于抽象工厂模式，是一种一般化工厂的一种形态，就比如，联想的工厂肯定不仅仅只生产电脑，小米的工厂也不仅仅只生产电脑，他肯定还有其他的，其实我觉得抽象工厂模式更像是一种产品族的概念

就像这种，我们的抽象工厂只提供一些基本工厂的一些形态

代码实现

//客户类
public class client {
    public static void main(String[] args) {
        PhoneProduct phone = new XiaomiFactory().getPhoneProduct();//从小米工厂买手机
        phone.SendSMS();
        phone.callUp();
        PhoneProduct phone2 = new LianXiangFactory().getPhoneProduct();//从联想工厂买手机
        phone2.SendSMS();
        phone2.callUp();
        ComputerProduct computer = new XiaomiFactory().getComputerProduct();//从小米工厂买电脑
        computer.work();
        computer.game();
        ComputerProduct computer2 = new LianXiangFactory().getComputerProduct();//从联想工厂买电脑
        computer2.work();
        computer2.game();
    }
}
//统一工厂
public interface abstractFactory {
    PhoneProduct getPhoneProduct();
    ComputerProduct getComputerProduct();
}
//联想工厂
public class LianXiangFactory implements abstractFactory{
 
    @Override
    public PhoneProduct getPhoneProduct() {
        return new LianXiangPhone();
    }
 
    @Override
    public ComputerProduct getComputerProduct() {
        return new LianXiangComputer();
    }
    
}
//小米工厂
public class XiaomiFactory implements abstractFactory{
 
    @Override
    public PhoneProduct getPhoneProduct() {
        return new XiaomiPhone();
    }
 
    @Override
    public ComputerProduct getComputerProduct() {
        return new XiaomiComputer();
    }
    
}
//统一电脑接口
public interface ComputerProduct {
    void work();
    void game();
}
//统一手机接口
public interface PhoneProduct {
    void callUp();
    void SendSMS();
}
//联想电脑
public class LianXiangComputer implements ComputerProduct{
 
    @Override
    public void work() {
        System.out.println("使用联想电脑办公");        
    }
 
    @Override
    public void game() {
        System.out.println("使用联想电脑玩游戏");        
    }
    
}
//联想手机
public class LianXiangPhone implements PhoneProduct{
 
    @Override
    public void callUp() {
        System.out.println("使用联想手机打电话");
    }
 
    @Override
    public void SendSMS() {
        System.out.println("使用联想手机发短信");
    }
    
}
//小米电脑
public class XiaomiComputer implements ComputerProduct{
 
    @Override
    public void work() {
        System.out.println("使用小米电脑办公");        
    }
 
    @Override
    public void game() {
        System.out.println("使用小米电脑玩游戏");        
    }
    
}
//小米手机
public class XiaomiPhone implements PhoneProduct{
 
    @Override
    public void callUp() {
        System.out.println("使用小米手机打电话");
    }
 
    @Override
    public void SendSMS() {
        System.out.println("使用小米手机发短信");
    }
    
}
//使用小米手机发短信
//使用小米手机打电话
//使用联想手机发短信
//使用联想手机打电话
//使用小米电脑办公
//使用小米电脑玩游戏
//使用联想电脑办公
//使用联想电脑玩游戏
复制代码

总结

对于工厂模式，我们了解了三种工厂模式的实现，以及与传统模式的不同，我们可以看到的是，除了简单工厂模式，另外两种工厂模式代码十分的冗余，所以在实际的开发中，我们也是很少使用的，虽然简单工厂模式他并不满足开闭原则，但是他实现起来更方便呀，相较于传统模式，我们也不用去new一个又一个对象了，所以简单工厂模式在实际的开发用的是比较多的！