设计模式——通过简单工厂模式推出工厂方法模式

待我称王封你为后i 2023-07-23 03:59 18阅读 0赞

### 文章目录 ###

*  工厂模式简介
 *  简单工厂模式
 *  工厂方法模式

# 工厂模式简介 #

工厂模式，是通过一个工厂来进行创建对象的，我们不用去new对象了，而是直接在工厂中get对象。但是，这样做的好处是什么呢？  
**实现了解耦**，也就是把创建对象和使用对象进行了分离。  
**降低了代码的重复和错误率**，例如一个数据库工厂：可以返回一个数据库实例，可以是mysql，oracle等。这个工厂可以把数据库连接需要的用户名，地址，密码等封装好，直接返回对应的数据库对象就好。不需要调用者自己初始化，减少了调用者写错地址、密码等。调用者只负责使用，不需要管怎么去创建、初始化对象。

# 简单工厂模式 #

简单工厂模式，我们通过一个车工厂，来进行讲解，首先我们有一个车的接口，这里面有着车的共有的方法，例如每一辆车都有自己的品牌也就是name等。

public interface Car {
        public void name();
    }

这样我们可以通过不同的车来实现这个类，并重写这个方法，来获得自己车的名字，我们这里通过奥迪汽车和宝马汽车这两个类来实现。

public class AoDi implements Car {
        @Override
        public void name() {
            System.out.println("奥迪");
        }
    }

public class BaoMa implements Car {
        @Override
        public void name() {
            System.out.println("宝马");
        }
    }

有了两个车的实现类了，那么我们的工厂就可以出来了，来一个车的工厂类，用来get奥迪和宝马。

public class CarFactory {
        public static Car getAoDi() {
            return new AoDi();
        }
    
        public static Car getBenChi() {
            return new BaoMa();
        }
    }

下面进行测试

public class Main {
        public static void main(String[] args) {
            Car aoDi = CarFactory.getAoDi();
            Car BaoMa= CarFactory.getBaoMa();
     
            aoDi.name(); //奥迪
            BaoMa.name(); //宝马
        }
    }

# 工厂方法模式 #

上面的例子看似没有任何的问题，但是，当我们又来了一辆奔驰车，我们需要写一个奔驰车的类来实现车接口，这也没毛病，但是，我们还需要去修改我们的车工厂，需要在里面加上一个getBenChi()方法，对类进行修改就违背了开闭原则。所以就有了工厂方法模式，增强了程序的可扩展性。  
工厂方法模式的思想也是通过工厂来制造汽车，但是这个工厂不是一个类了，而是一个接口，用来获取汽车getCar()，奥迪、宝马、奔驰，只需要去实现该接口重写getCar()方法，来真正的制造出对应的车，相当于是奥迪小工厂来加工奥迪汽车，宝马小工厂加工宝马汽车，奔驰小工厂加工奔驰汽车。  
首先我们也是需要一个Car的接口，里面还是封装了车共有的东西。

public interface Car {
        public void name();
    }

接下来还是车去实现这些接口，这里我们先用奥迪和宝马，好体现出扩展性。

public class AoDi implements Car {
        @Override
        public void name() {
            System.out.println("奥迪");
        }
    }

public class BaoMa implements Car {
        @Override
        public void name() {
            System.out.println("宝马");
        }
    }

然后是一个车工厂，这个车工厂是一个接口，用来制造汽车（不特指某一类），只负责getCar()。

public interface CarFactory {
        public Car getCar();
    }

此时，我们的奥迪小工厂用来制造奥迪，宝马小工厂用来制造宝马，只需去实现这个接口重写getCar()方法即可。

public class AoDiFactory implements CarFactory {
        @Override
        public Car getCar() {
            return new AoDi();
        }
    }

public class BaoMaFactory implements CarFactory {
        @Override
        public Car getCar() {
            return new BaoMa();
        }
    }

那么，当我们需要某一款车对象的时候，只需创建该车工厂的对象，直接getCar就行了。

public class Main {
        public static void main(String[] args) {
            Car aoDi = new AoDiFactory().getCar();
            Car baoMa = new BaoMaFactory().getCar();
     
            aoDi.name(); //奥迪
            baoMa.name(); //宝马
        }
    }

而当我们想要扩展一辆奔驰车时，我们只需要一个奔驰类实现Car接口，然后一个宝马工厂去实现车工厂的接口即可

public class BenChi implements Car {
        @Override
        public void name() {
            System.out.println("奔驰");
        }
    }

public class BenChiFactory implements CarFactory {
        @Override
        public Car getCar() {
            return new BenChi();
        }
    }

下面进行测试

public class Main {
        public static void main(String[] args) {
            Car aoDi = new AoDiFactory().getCar();
            Car baoMa = new BaoMaFactory().getCar();
            Car benChi = new BenChiFactory().getCar();
     
            aoDi.name(); //奥迪
            baoMa.name(); //宝马
            benChi.name(); //奔驰
        }
    }

通过这么一波操作之后，我们似乎感觉，**简单工厂模式**是一个大工厂（类）里面可以制造各种各样的车，当需要扩展的时候，是对这个大工厂（类）进行扩展，需要修改具体的类。**工厂方法模式**是一个大工厂（接口）里面有很多的小工厂，各自的小工厂负责各自的事情，当需要扩展的时候，是对大工厂（接口）进行扩展。这样一来，就不用修改某一个类了，只需要实现接口就行。