Java工厂模式

工厂模式就是实现创建者和调用者的分离，可以分为
（1）简单工厂模式：
也叫静态工厂模式，就是工厂类-般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。对于增加折产品无能为力!不修改代码的话,是无法扩展。
实例及代码：我要new两部手机（xiaomi,iphone）对吧，但我不直接去创建，让手机工厂（PhoneFactory）帮我来完成,首先准备一个Phone的接口：

package com.FCJ.simpleFactory;

public interface Phone {
	void phoneType();	//实现类有xiaomi,iphone
}

两部手机：

package com.FCJ.simpleFactory;
public class Iphone implements Phone{
	@Override
	public void phoneType() {
		System.out.println("苹果手机");	
	}
}

package com.FCJ.simpleFactory;
public class Xiaomi implements Phone{
	@Override
	public void phoneType() {
		System.out.println("小米手机");		
	}
}

手机工厂：

package com.FCJ.simpleFactory;

public class PhoneFactory {
//注意是静态方法，后面的客户端Client01才可以调用该方法
	public static Phone createPhone(String type) {
		if("iphone".equals(type)) {
			return new Iphone();
		}else if("xiaomi".equals(type)) {
			return new Xiaomi();
		}//开闭原则，就是增加新功能尽量不要修改原来的代码，这个else显然就修改了
		else {
			return null;
		}
	}
}

客户端：

package com.FCJ.simpleFactory;
public class Client01 {
public static void main(String[] args) {
	Phone p1 = PhoneFactory.createPhone("iphone");
	Phone p2 = PhoneFactory.createPhone("xiaomi");
	p1.phoneType();
	p2.phoneType();
}
}

（2）工厂方法模式
实例演示：
和前面的步骤一样：
一个Phone的接口：

package com.FCJ.simpleFactory;

public interface Phone {
	void phoneType();	//实现类有xiaomi,iphone
}

两部手机：

//iphone实现类
package com.FCJ.simpleFactory;
public class Iphone implements Phone{
	@Override
	public void phoneType() {
		System.out.println("苹果手机");	
	}
}

//xiaomi实现类
package com.FCJ.simpleFactory;
public class Xiaomi implements Phone{
	@Override
	public void phoneType() {
		System.out.println("小米手机");		
	}
}

PhoneFactory增加接口

package com.FCJ.simpleFactory;

public interface PhoneFactory {
	public Phone createPhone();
}

再加多一个PhoneFactor的IphoneFactory、XiaomiFactory实现类

package com.FCJ.simpleFactory;

public class IphoneFactory implements PhoneFactory{
	
	@Override
	public Phone createPhone() {
		return new Iphone();
	}
}

package com.FCJ.simpleFactory;

public class XiaomiFactory implements PhoneFactory{
	
	@Override
	public Phone createPhone() {
		// TODO Auto-generated method stub
		return new Xiaomi();
	}
}

客户端：

package com.FCJ.simpleFactory;

public class Client01 {
public static void main(String[] args) {
	Phone p1 = new IphoneFactory().createPhone();
	Phone p2 = new XiaomiFactory().createPhone();
	p1.phoneType();
	p2.phoneType();
}
}

在一般的工作中一般使用的是简单的工厂模式。
（3）抽象工厂模式
主要是创建 产品族
实例代码：

package com.FCJ.abstractFactory;
/**
 * CPU接口，以下有两个实现类，高端和低端CPU
 * @author 佳
 *
 */
public interface CPU {
	void run();
	void start();
}

class LuxuryCPU implements CPU{

	@Override
	public void run() {
		System.out.println("人上人高端机就是好，处理速度来的快");
		
	}

	@Override
	public void start() {
		System.out.println("开机启动快，可以自动启动停止");
		
	}
	
}
class LowerCPU implements CPU{

	@Override
	public void run() {
		System.out.println("处理速度的慢");
		
	}

	@Override
	public void start() {
		System.out.println("启动慢");
		
	}
	
}

package com.FCJ.abstractFactory;
/**
 * 手机的软件接口，统一有高端机和低端机的实现类
 * @author 方楚佳
 *
 */
public interface SoftWare {
	void massage();
}
class LuxurySoftWare implements SoftWare{

	@Override
	public void massage() {
		System.out.println("高端软件可以自动显示人上人");
		
	}
	
}
class LowerSoftWare implements SoftWare{

	@Override
	public void massage() {
		System.out.println("低端座椅软件不可以自动显示人上人");
		
	}
	
}

package com.FCJ.abstractFactory;
/**
 * 屏幕接口，以下同样有两个实现类
 * @author 方楚佳
 *
 */
public interface Screen {
	void light();
}
class LuxuryScreen implements Screen{

	@Override
	public void light() {
		System.out.println("高端屏幕亮色好");
		
	}

	
	
}
class LowerScreen implements Screen{

	@Override
	public void light() {
		System.out.println("低端屏幕亮色不好");
		
	}
	
}

package com.FCJ.abstractFactory;
/**
 * PhoneFactory这个接口负责创建手机的CPU，软件和屏幕
 * @author 方楚佳
 *
 */
public interface PhoneFactory {
	CPU createCPU();
	SoftWare createSoftWare();
	Screen createScreen();
	
}
//高端工厂，对应创建高端配件
class LuxuryPhoneFactory implements PhoneFactory{

	@Override
	public CPU createCPU() {
		return new LuxuryCPU();
	}

	@Override
	public SoftWare createSoftWare() {
		return new LuxurySoftWare();
	}

	@Override
	public Screen createScreen() {
		return new LuxuryScreen();
	}

	
	
	
}

//低端工厂，对应创建低端配件
class LowerPhoneFactory implements PhoneFactory{

	@Override
	public CPU createCPU() {
		return new LowerCPU();
	}

	@Override
	public SoftWare createSoftWare() {
		return new LowerSoftWare();
	}

	@Override
	public Screen createScreen() {
		return new LowerScreen();
	}

	
	
}

测试：

package com.FCJ.abstractFactory;

public class Client {
public static void main(String[] args) {
	PhoneFactory factory = new LuxuryPhoneFactory();
	CPU c = factory.createCPU();
	c.run();
	c.start();
	Screen s = factory.createScreen();
	s.light();
	SoftWare S = factory.createSoftWare();
	S.massage();
	
}
}

OCP（open-closed principle）原则：就是一个软件对扩展开发，对修改关闭，即假如要在软件中实现新的功能，增加类就可以了，不要对原来的代码进行修改。
DIP(依赖倒转原则)：针对接口编程，不要针对实现编程。
LOD（迪米特法则）：比如类，与直接的类相联系，少和不相干的发生联系。