Java设计模式之------工厂模式

 介绍：Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

分类：

1）简单工厂模式（Simple Factory） 
2）工厂方法模式（Factory Method） 
3）抽象工厂模式（Abstract Factory）

简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。

简单工厂

只有一个工厂，根据用户要的需求产出对应的产品。下面用手机来举例

// 先定义一个手机接口
public interface Phone {
	public void getPhone();
}

// 然后具体的手机实现这个接口
// 华为
public class HuaWei implements Phone {
	@Override
	public void getPhone() {
		System.out.println("HuaWei手机");
	}
}

// Vivo
public class Vivo implements Phone {
	@Override
	public void getPhone() {
		System.out.println("vivo手机");
	}
}

// 创建手机工厂
public class PhoneFactory {
	public Phone productPhone(String name) {
		if ("Vivo".equals(name)) {
			return new Vivo();
		} else if ("HuaWei".equals(name)) {
			return new HuaWei();
		} else {
			System.out.println("请输入正确的类型");
			return null;
		}
	}
}
// 测试
public class TestPhone {
	public static void main(String[] args) {
		PhoneFactory p = new PhoneFactory();
		Phone phone = p.productPhone("Viv1o");
		phone.getPhone();
		Phone phone2 = p.productPhone("HuaWei");
		phone2.getPhone();
	}
}

简单工厂有个不好的地方就是，当手机类型增加的时候，就需要修改代码，所以就有了工厂方法模式。

工厂方法模式

// 定义一个手机抽象类
public abstract class Phone {
	public abstract void prodouct();
}

// 定义一个工厂接口
public interface Factory {
	public abstract Phone creatPhone();
}

// vivo
public class Vivo extends Phone {
	@Override
	public void prodouct() {
		System.out.println("Vivo");
	}
}
// Vivo工厂
public class VivoFactory implements Factory {
	@Override
	public Phone creatPhone() {
		return new Vivo();
	}
}
// HuaWei
public class HuaWei extends Phone {
	@Override
	public void prodouct() {
		System.out.println("华为手机");
	}
}
// HuaWei工厂
public class HuaWeiFactory implements Factory{
	@Override
	public Phone creatPhone() {
		return new HuaWei();
	}
}

// 测试
public class Test {
	public static void main(String[] args) {
		HuaWeiFactory h = new HuaWeiFactory();
		h.creatPhone().prodouct();

		VivoFactory v = new VivoFactory();
		v.creatPhone().prodouct();
	}
}

抽象工厂

        抽象工厂模式为创建一组对象提供了一种解决方案。与工厂方法模式相比，抽象工厂模式中的具体工厂不只是创建一种产品，它负责创建一族产品。

继续拿手机来说，现在vivo不仅要生产手机，还要生产耳机

// 手机接口
public interface Phone {
	public void getPhone();
}

// 耳机接口
public interface EarPhone {
	public void getEarPhone();
}

// 工厂
public interface Factory {
	public Phone createPhone();
	
	public EarPhone createEarPhone();
}

// Vivo手机
public class VivoPhone implements Phone {
	@Override
	public void getPhone() {
		System.out.println("Vivo手机");
	}
}
// Vivo耳机
public class VivoEarPhone implements EarPhone{
	@Override
	public void getEarPhone() {
		System.out.println("Vivo耳机");
	}
}
// Vivo工厂
public class VivoFactory implements Factory {
	@Override
	public Phone createPhone() {
		return new VivoPhone();
	}

	@Override
	public EarPhone createEarPhone() {
		return new VivoEarPhone();
	}
}
// 测试类
public class Test {
	public static void main(String[] args) {
		VivoFactory factory = new VivoFactory();
		factory.createPhone().getPhone();
		factory.createEarPhone().getEarPhone();
	}
}

如果想生产其他的东西，只需要添加就行了