工厂模式

工厂方法模式：

　　工厂方法模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

工厂模式：简单工厂，工厂方法模式，抽象工厂模式

简单工厂模式：
1、定义操作接口

1 public interface Operation {
2 
3     double getResult(double a, double b);
4 }

2、定义具体操作类，实现操作接口中的方法

1 public class Add implements Operation{
2 
3     @Override
4     public double getResult(double a, double b) {
5         return a + b;
6     }
7 
8 }

1 public class Sub implements Operation{
2 
3     @Override
4     public double getResult(double a, double b) {
5         return a - b;
6     }
7 
8 }

1 public class Mul implements Operation {
2 
3     @Override
4     public double getResult(double a, double b) {
5         return a * b;
6     }
7 
8 }

1 public class Div implements Operation {
2 
3     @Override
4     public double getResult(double a, double b) {
5         return a / b;
6     }
7 
8 }

1 public class Mod implements Operation {
2 
3     @Override
4     public double getResult(double a, double b) {
5         return a % b;
6     }
7 
8 }

3、定义简单工厂类

 1 public class SimpleFactory {
 2     public static Operation createOperation(String name) {
 3         Operation opt = null;
 4         switch (name) {
 5         case "+":
 6             opt = new Add();
 7             break;
 8         case "-":
 9             opt = new Sub();
10             break;
11         case "*":
12             opt = new Mul();
13             break;
14         case "/":
15             opt = new Div();
16             break;
17         case "%":
18             opt = new Mod();
19             break;
20         }
21         return opt;
22     }
23 }

4、测试

 1 public class FactoryTest {
 2 
 3     public static void main(String[] args) {
 4         Operation add = SimpleFactory.createOperation("+");
 5         Operation sub = SimpleFactory.createOperation("-");
 6         Operation mul = SimpleFactory.createOperation("*");
 7         Operation div = SimpleFactory.createOperation("/");
 8         Operation mod = SimpleFactory.createOperation("%");
 9         System.out.println(add.getResult(1, 2));
10         System.out.println(sub.getResult(100, 2));
11         System.out.println(mul.getResult(100, 2));
12         System.out.println(div.getResult(100, 2));
13         System.out.println(mod.getResult(100, 2));
14     }
15 
16 }

　　我们无需提供具体的子类类名，只需要提供一个字符串即可得到相应的实例对象。这样的话，当子类的类名更换或者增加子类时我们都无需修改客户端代码，只需要在简单工厂类上增加一个分支判断代码即可。

优点：使用这种模式，我们在生成工厂的时候可以加一些业务代码，如日志、判断业务等，这时候可以直接在switch case中加上去就行了

缺点：如果需要在方法里写很多与对象创建有关的业务代码，而且需要的创建的对象还不少的话，我们要在这个简单工厂类里编写很多个方法，每个方法里都得写很多相应的业务代码，而每次增加子类或者删除子类对象的创建都需要打开这简单工厂类来进行修改。这会导致这个简单工厂类很庞大臃肿、耦合性高，而且增加、删除某个子类对象的创建都需要打开简单工厂类来进行修改代码也违反了开-闭原则。

工厂方法模式：
1、定义操作接口

1 public interface Operation {
2     double getResult(double a, double b);
3 }

2、定义具体操作类，实现操作接口中的方法

1 public class Add implements Operation{
2 
3     @Override
4     public double getResult(double a, double b) {
5         return a + b;
6     }
7 
8 }

1 public class Sub implements Operation{
2 
3     @Override
4     public double getResult(double a, double b) {
5         return a - b;
6     }
7 
8 }

1 public class Mul implements Operation {
2 
3     @Override
4     public double getResult(double a, double b) {
5         return a * b;
6     }
7 
8 }

1 public class Div implements Operation {
2 
3     @Override
4     public double getResult(double a, double b) {
5         return a / b;
6     }
7 
8 }

1 public class Mod implements Operation {
2 
3     @Override
4     public double getResult(double a, double b) {
5         return a % b;
6     }
7 
8 }

3、定义工厂接口

1 public interface Factory {
2     Operation createOperation();
3 }

4、定义具体的工厂类，实现工厂接口中的方法

1 public class AddFactory implements Factory{
2 
3     @Override
4     public Operation createOperation() {
5         return new Add();
6     }
7 
8 }

1 public class SubFactory implements Factory {
2 
3     @Override
4     public Operation createOperation() {
5         return new Sub();
6     }
7 
8 }

1 public class MulFactory implements Factory {
2 
3     @Override
4     public Operation createOperation() {
5         return new Mul();
6     }
7 
8 }

1 public class DivFactory implements Factory {
2 
3     @Override
4     public Operation createOperation() {
5         return new Div();
6     }
7 
8 }

1 public class ModFactory implements Factory {
2 
3     @Override
4     public Operation createOperation() {
5         return new Mod();
6     }
7 
8 }

5、测试

 1 public class FactoryTest {
 2 
 3     public static void main(String[] args) {
 4         Factory add = null, sub = null, mul = null, div = null, mod = null;
 5         try {
 6             add = (Factory) Class.forName("com.sl.factory.AddFactory").newInstance();
 7             sub = (Factory) Class.forName("com.sl.factory.SubFactory").newInstance();
 8             mul = (Factory) Class.forName("com.sl.factory.MulFactory").newInstance();
 9             div = (Factory) Class.forName("com.sl.factory.DivFactory").newInstance();
10             mod = (Factory) Class.forName("com.sl.factory.ModFactory").newInstance();
11         } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
12             e.printStackTrace();
13         }
14         System.out.println(add.createOperation().getResult(1, 2));
15         System.out.println(sub.createOperation().getResult(100, 2));
16         System.out.println(mul.createOperation().getResult(100, 2));
17         System.out.println(div.createOperation().getResult(100, 2));
18         System.out.println(mod.createOperation().getResult(100, 2));
19     }
20 
21 }

抽象工厂模式:
1、定义多个操作接口

 1 public class Login {
 2     private Integer id;
 3     private String name;
 4     private String passwd;
 5     public Integer getId() {
 6         return id;
 7     }
 8     public void setId(Integer id) {
 9         this.id = id;
10     }
11     public String getName() {
12         return name;
13     }
14     public void setName(String name) {
15         this.name = name;
16     }
17     public String getPasswd() {
18         return passwd;
19     }
20     public void setPasswd(String passwd) {
21         this.passwd = passwd;
22     }
23 }

 1 public class User {
 2     private Integer id;
 3     private String name;
 4     
 5     
 6     public Integer getId() {
 7         return id;
 8     }
 9     public void setId(Integer id) {
10         this.id = id;
11     }
12     public String getName() {
13         return name;
14     }
15     public void setName(String name) {
16         this.name = name;
17     }
18     
19 }

1 public interface ILogin {
2     
3     public void insert(Login login);
4     public Login getLogin(int id);
5     
6 }

1 public interface IUser {
2     public void insert(User user);
3     public User getUser(int id);
4 }

2、定义具体操作类，实现操作接口中的方法

 1 public class MysqlILogin implements ILogin{
 2 
 3     @Override
 4     public void insert(Login login) {
 5         System.out.println("insert user data to mysql login-databasse!");
 6     }
 7 
 8     @Override
 9     public Login getLogin(int id) {
10         System.out.println("mysql: login单查id = " + id + "的用户");
11         return null;
12     }
13 
14 }

 1 public class OracleILogin implements ILogin {
 2 
 3     @Override
 4     public void insert(Login login) {
 5         System.out.println("insert user data to oracle login-databasse!");
 6     }
 7 
 8     @Override
 9     public Login getLogin(int id) {
10         System.out.println("oracle: login单查id = " + id + "的用户");
11         return null;
12     }
13 
14 }

 1 public class MysqlIUser implements IUser {
 2 
 3     @Override
 4     public void insert(User user) {
 5         System.out.println("insert user data to mysql databasse!");
 6     }
 7 
 8     @Override
 9     public User getUser(int id) {
10         System.out.println("mysql: 单查id = " + id + "的用户");
11         return null;
12     }
13 
14 }

 1 public class OracleIUser implements IUser {
 2 
 3     @Override
 4     public void insert(User user) {
 5         System.out.println("insert user data to oracle databasse!");
 6     }
 7 
 8     @Override
 9     public User getUser(int id) {
10         System.out.println("oracle: 单查id = " + id + "的用户");
11         return null;
12     }
13 
14 }

3、定义工厂接口

1 public interface SqlFactory {
2     IUser createIUser();
3     ILogin createILogin();
4 }

4、定义具体的工厂类，实现工厂接口中的方法

 1 public class MysqlFactory implements SqlFactory {
 2 
 3     @Override
 4     public IUser createIUser() {
 5         return new MysqlIUser();
 6     }
 7 
 8     @Override
 9     public ILogin createILogin() {
10         return new MysqlILogin();
11     }
12 
13 }

 1 public class OracleFactory implements SqlFactory {
 2 
 3     @Override
 4     public IUser createIUser() {
 5         return new OracleIUser();
 6     }
 7 
 8     @Override
 9     public ILogin createILogin() {
10         return new OracleILogin();
11     }
12 
13 }

5、测试

 1 public class FactoryTest {
 2 
 3     public static void main(String[] args) {
 4         SqlFactory factory = new MysqlFactory();
 5         ILogin login = factory.createILogin();
 6         login.insert(new Login());
 7         IUser iUser = factory.createIUser();
 8         iUser.getUser(0);
 9         SqlFactory factory1 = new OracleFactory();
10         ILogin login1 = factory1.createILogin();
11         login1.insert(new Login());
12     }
13 
14 }