设计模式之工厂模式

工厂模式分为三种：简单工厂、工厂模式以及抽象工厂模式

    简单工厂模式：以购买鼠标举例，我们建立一个鼠标的接口类，所有的鼠标都继承这个接口类，最后创建工厂类去生产创建的鼠标就是简单工厂模式

package easyFactory;
/**
 * 简单工厂模式
 */
//鼠标的接口类
public interface Mouse {
	
	public void product();
}

package easyFactory;
//雷蛇鼠标
public class RezerMouse implements Mouse {
	@Override
	public void product() {
		System.out.println("生产雷蛇鼠标");
	}
}

package easyFactory;
//罗技鼠标
public class LogitechMouse implements Mouse {
	@Override
	public void product() {
		System.out.println("生产罗技鼠标");
	}
}

package easyFactory;
//工厂类
public class Factory {
	//生产雷蛇
	public static Mouse Rezer() {
		return new RezerMouse();
	}
	//生产罗技
	public static Mouse Logitech() {
		return new LogitechMouse();
	}
}

package easyFactory;
//测试类
public class Test {
	public static void main(String[] args) {
		//生产雷蛇鼠标
		Mouse rezer = Factory.Rezer();
		rezer.product();
		//生产罗技鼠标
		Mouse logitech = Factory.Logitech();
		logitech.product();
	}
}

工厂模式：如果我们想要扩展鼠标的厂商，就必须修改工厂方法，这就违背了闭包的原则，工厂方法就可以避免这一问题。

    还是以购买鼠标为例，我们建立一个鼠标的接口类，所有的鼠标都继承这个接口类，随后建立一个工厂的抽象类，每生产一款鼠标建立一个工厂，继承抽象类，代码如下

package Factory;
/**
 * 工厂模式
 */
public interface Mouse {
	
	public void product();
}

package Factory;
//雷蛇鼠标
public class RezerMouse implements Mouse {
	@Override
	public void product() {
		System.out.println("生产雷蛇鼠标");
	}
}

package Factory;

public class LogitechMouse implements Mouse {
	@Override
	public void product() {
		System.out.println("生产罗技鼠标");
	}
}

package Factory;
//静态工厂类
public abstract class AbstractFactory {
	//静态方法
	public abstract Mouse getMouse();
}

package Factory;
//雷蛇工厂
public class RezerFactory extends AbstractFactory {
	@Override
	public Mouse getMouse() {
		return new RezerMouse();
	}
}

package Factory;
//罗技工厂
public class LogitechFactory extends AbstractFactory {
	@Override
	public Mouse getMouse() {
		return new LogitechMouse();
	}
}

package Factory;
/**
 * 写一个工厂调用类，方便调用
 */
public class FactoryProuct {
	//静态方法不用实例化
	public static AbstractFactory getRezer() {
		return new RezerFactory();
	}
	public static AbstractFactory getLogitech() {
		return new LogitechFactory();
	}
}

package Factory;
//测试类
public class Test {

	public static void main(String[] args) {
		//生产雷蛇鼠标
		AbstractFactory rezer = FactoryProuct.getRezer();
		rezer.getMouse().product();
		//生产罗技鼠标
		AbstractFactory logitech = FactoryProuct.getLogitech();
		logitech.getMouse().product();
	}
}

抽象工厂方法：我认为抽象工厂甚至可以和工厂方法都算作抽象工厂方法，还是以生产鼠标举例，我们在生产鼠标的同时又生产了一款键盘，雷蛇和罗技的工厂同时生产鼠标和键盘，代码如下

package abstractFactory;
//生产鼠标
public interface Mouse {
	
	public void productMouse();
}

package abstractFactory;
//生产雷蛇鼠标
public class RezerMouse implements Mouse {
	@Override
	public void productMouse() {
		System.out.println("生产雷蛇鼠标");
	}
}

package abstractFactory;
//生产罗技鼠标
public class LogitechMouse implements Mouse {
	@Override
	public void productMouse() {
		System.out.println("生产罗技鼠标");
	}
}

package abstractFactory;
//生产键盘
public interface Keyboard {
	
	public void productKeyboard();
}

package abstractFactory;
//生产雷蛇键盘
public class RezerKeyboard implements Keyboard {
	@Override
	public void productKeyboard() {
		System.out.println("生产雷蛇键盘");
	}
}

package abstractFactory;
//生产罗技键盘
public class LogitechKeyboard implements Keyboard {
	@Override
	public void productKeyboard() {
		System.out.println("生产罗技键盘");
	}
}

package abstractFactory;
/**
 * 抽象工厂方法
 */
public abstract class AbstractFactory {
	//生产鼠标
	public abstract Mouse getMouse();
	//生产键盘
	public abstract Keyboard getKeyBoard();
}

package abstractFactory;
//雷蛇工厂
public class RezerFactory extends AbstractFactory {
	@Override
	public Mouse getMouse() {
		return new RezerMouse();
	}
	@Override
	public Keyboard getKeyBoard() {
		return new RezerKeyboard();
	}
}

package abstractFactory;
//罗技工厂
public class LogitechFactory extends AbstractFactory {
	@Override
	public Mouse getMouse() {
		return new LogitechMouse();
	}
	@Override
	public Keyboard getKeyBoard() {
		return new LogitechKeyboard();
	}
}

package abstractFactory;
//写一个工厂调用类，方便调用
public class FactoryProduct {
	//静态方法不用实例化
	public static AbstractFactory Rezer() {
		return new RezerFactory();
	}
	public static AbstractFactory Logitech() {
		return new LogitechFactory();
	}
}

package abstractFactory;
//测试
public class Test {
	
	public static void main(String[] args) {
		//生产雷蛇鼠标
		AbstractFactory rezer = FactoryProduct.Rezer();
		rezer.getMouse().productMouse();
		//生产罗技键盘
		AbstractFactory logitech = FactoryProduct.Logitech();
		logitech.getKeyBoard().productKeyboard();
	}
}

工厂方法的缺点在于，如果我们要新增一项，比如新增耳麦，需要从接口开始加，这就很复杂了

转载于:https://my.oschina.net/u/3782790/blog/1635248