Java——工厂设计模式

多态：

      方法多态

         1、方法重载

          2、方法覆写

     对象多态

         3、抽象类的继承

         4、接口的实现

耦合：代码发生改变时，客户端也要做相应的调整

工厂设计模式：

1、简单工厂模式（定义一个静态方法）：创建系新类与客户端解耦

简单工厂模式：专门定义一个类用来创建其它类的实例，被创建的实例通常都具有共同的父类。 这里我们相当于是创建生产电脑的工厂，客户需要购买什么样的电脑，只要输入类型编号就可以获取该电脑。将类 的实例化交给工厂易于解耦。

把类的实例化对象交给工厂，创建的实例通常都具有共同的父类（继承抽象类/实现接口）。

概要：1. 一个抽象产品类    2. 具体产品类 （多个）  3. 一个工厂 （用于创建不同的具体类）

优点：简单易于实现，把类的实例化交给工厂,易于解耦

缺点：添加具体产品需要修改工厂违反OCP开放封闭原则

2、工厂方法模式（工厂中定义方法）：工厂方法模式是针对每个产品提供一个工厂类，在客户端中判断使用哪个工厂类去创建对象。

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

工厂方法模式是针对每个产品提供一个工厂类，在客户端中判断使用哪个工厂类去创建对象。

我们将之前的 ComputerFactory 抽象成一个接口，那么创建相应具体的工厂类去实现该接口的方法。

概要1. 一个抽象产品类    2. 多个具体产品类   3. 一个抽象工厂     4. 多个具体工厂 - 每一个具体产品对应一个具体工厂

优点：降低了代码耦合度，对象的生成交给子类去完成；实现了开放封闭原则 - 每次添加子产品 不需要修改原有代码

缺点：增加了代码量，每个具体产品都需要一个具体工厂；当增加抽象产品 也就是添加一个其他产品族 需要修改工厂 违背OCP

3、抽象工厂模式

这时候负责该工厂的产品经理说要生产新的一类产品操作系统 Mac Os 和 Windows 8，这时候就引申出了抽象工厂模式。

抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

工厂方法模式和抽象工厂模式基本类似，可以这么理解：当工厂只生产一个产品的时候，即为工厂方法模式，而工厂如果生产两个或以上的商品即变为抽象工厂模式。

我们在抽象工厂接口中新增创建系统的方法，并由实例工厂类去实现。

概要1. 多个抽象产品类 2. 具体产品类 3. 抽象工厂类 - 声明(一组)返回抽象产品的方法 4. 具体工厂类 - 生成(一组)具体产品

优点：

代码解耦

实现多个产品族(相关联产品组成的家族)，而工厂方法模式的单个产品,可以满足更多的生产需求

很好的满足OCP开放封闭原则

抽象工厂模式中我们可以定义实现不止一个接口，一个工厂也可以生成不止一个产品类 对于复杂对象的生产

相当灵活易扩展

缺点：

扩展产品族相当麻烦 而且扩展产品族会违反OCP,因为要修改所有的工厂

由于抽象工厂模式是工厂方法模式的扩展 总体的来说 很笨重

总结

简单工厂模式最大的优点就是工厂内有具体的逻辑去判断生成什么产品，将类的实例化交给了工厂，这样当

我们需要什么产品只需要修改工厂的调用而不需要去修改客户端，对于客户端来说降低了与具体产品的依赖

工厂方法模式是简单工厂的扩展，工厂方法模式把原先简单工厂中的实现那个类的逻辑判断交给了客户端，

如果像添加功能只需要修改客户和添加具体的功能，不用去修改之前的类。

抽象工厂模式进一步扩展了工厂方法模式，它把原先的工厂方法模式中只能有一个抽象产品不能添加产品族

的缺点克服了，抽象工厂模式不仅仅遵循了OCP原则，而且可以添加更多产品(抽象产品),具体工厂也不仅仅

可以生成单一产品，而是生成一组产品，抽象工厂也是声明一组产品，对应扩展更加灵活，但是要是扩展族

系就会很笨重。

JDK中用到工厂模式的典型操作：

1. Collection中的iterator方法 （集合类中的迭代器）

2. java.util包中的sql相关操作

简单工厂模式 VS 工厂方法模式：

对于简单工厂模式而言，创建对象的逻辑判断放在了工厂类中，客户不感知具体的类，但是其违背了开闭原则，如果要增加新的具体类，就必须修改工厂类。对于工厂方法模式而言，是通过扩展来新增具体类的，符合开闭原则，但是在客户端就必须要感知到具体的工厂类，也就是将判断逻辑由简单工厂的工厂类挪到客户端。工厂方法横向扩展很方便，假如该工厂又有新的产品 Macbook Air 要生产，那么只需要创建相应的工厂类和产品类去实现抽象工厂接口和抽象产品接口即可，而不用去修改原有已经存在的代码。

	public class Factory{
		public static void main(String[] args){
			Client client = new Client();
			client.buy(new Mac());
			client.buy(new Dell());
		}
	}
	
	class Client{
		public void buy(Computer computer){
			computer.printComputer();
		}
	}
	
	interface Computer{
		void printComputer();
	}
	
	class Mac implements Computer{
		public void printComputer(){
			System.out.println("这是一台Mac"); }
	
	class Dell implements Computer{
		public void printComputer(){
			System.out.println("这是一台Dell");
		}
	}

 

这个代码耦合度高，要新加电脑类型时，客户端也要发生改变------->简单工厂模式

一、简单工厂模式

	public class Factory{
		public void buy(Computer computer){
			if(computer==null){
				return;
			}
			computer.printComputer();
		}
		public static void main(String[] args){
			Factory  client = new Factory();
			client.buy(SimpleComputerFacyory.getInstance("mac"));
			client.buy(SimpleComputerFacyory.getInstance("dell"));
			client.buy(SimpleComputerFacyory.getInstance(""));
		}
	}
	
	class SimpleComputerFacyory{
		public static Computer getInstance(String type){
			switch(type){
				case "mac":
					return new Mac();
				case "dell":
					return new Dell();
				default:
					System.out.println("meiyouzhegeleixing ");
					return null;
			}
		}
	}
	
	interface Computer{
		void printComputer();
	}
	
	class Mac implements Computer{
		public void printComputer(){
			System.out.println("这是一台Mac");
		}
	}
	
	class Dell implements Computer{
		public void printComputer(){
			System.out.println("这是一台Dell");
		}
	}

 

二、工厂方法模式

	public class Factory{
		public static void main(String[] args){
			Client client = new Client();
			MacFactory macFactory = new MacFactory();
			Computer computer = macFactory.createComputer();
			client.buy(computer);
		}
	}
	class Client{
		public void buy(Computer computer){
			if(computer==null){
				return;
			}
			computer.printComputer();
		}
	}
	
	interface Computer{
		void printComputer();
	}
	interface MethodComputerFactory{
		Computer createComputer();
	}
	
	class Mac implements Computer{
		public void printComputer(){
			System.out.println("这是一台Mac");
		}
	}
	class MacFactory implements MethodComputerFactory{
		public Computer createComputer(){
			return new Mac();
		}
	}
	
	class Dell implements Computer{
		public void printComputer(){
			System.out.println("这是一台Dell");
		}
	}
	class DellFactory implements MethodComputerFactory{
		public Computer createComputer(){
			return new Dell();
		}
	}

 

三、抽象工厂模式

interface ISubject { 
    public void buyComputer() ; // 核心功能是买电脑 
}
class RealSubject implements ISubject { 
    public void buyComputer() { 
        System.out.println("买一台外星人电脑") ; 
    } 
}
class ProxySubject implements ISubject { 
    private ISubject subject ; // 真正的操作业务 
    public ProxySubject(ISubject subject) { 
        this.subject = subject ; 
    }
    public void produceComputer() { 
        System.out.println("1.生产外星人电脑") ; 
    }
    public void afterSale() { 
        System.out.println("3.外星人电脑售后团队") ; 
    }
    public void buyComputer() { 
        this.produceComputer() ; // 真实操作前的准备 
        this.subject.buyComputer() ; // 调用真实业务 
        this.afterSale() ; // 操作后的收尾 
    } 
}
class Factory { 
    public static ISubject getInstance(){ 
        return new ProxySubject(new RealSubject()) ; 
    } 
}
public class Test{ 
    public static void main(String[] args) { 
        ISubject subject = Factory.getInstance() ; 
        subject.buyComputer() ; 
    } 
}

反射的工厂模式：增加新的子类，不用改代码，（简单工厂）：新增一个子类时，用用修改工厂的代码，实现了开闭原则

public class FactoryAndReflect {
    public static void main(String[] args) {
        Factory.getInstance("reflect.WaterMelon").eat();
    }
}

class Factory{
    public static IFruit getInstance(String fruitName) {
        IFruit fruit = null;
        Class<?> cla = null;
        try {
            cla = Class.forName(fruitName);
            try {
                fruit = (IFruit) cla.newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        return fruit;
    }
}

interface IFruit{
    void eat();
}

class Apple implements IFruit {

    @Override
    public void eat() {
        System.out.println("eat an apple");
    }
}

class Orange implements IFruit {

    @Override
    public void eat() {
        System.out.println("eat an Orange");
    }
}

class WaterMelon implements IFruit {

    @Override
    public void eat() {
        System.out.println("eat a WaterMelon");
    }
}