工厂设计模式(重点)
- 简单工厂模式
缺点:添加具体产品需要修改工厂,违反OCP开闭原则。
专门定义一个类,用来创建其他类的实例,被创建的实例通常都具有共同的父类。
代码:
package com.irilia.FactoryDesignPattern;
import java.util.Scanner;
/*1.一个抽象产品类(接口:用来生产产品)
2.具体产品类
3.工厂* */
interface Computer{
void printComputer();
}
class MacBookComputer implements Computer{
@Override
public void printComputer() {
System.out.println("This is a MacBookComputer");
}
}
class SurfaceBookCmputer implements Computer{
@Override
public void printComputer() {
System.out.println("This is a SurfaceBookCmputer");
}
}
class Factory{
public static Computer MakeComputer(String type){
Computer computer = null;
if(type.equals("macbookComputer")){
computer = new MacBookComputer();
}else if(type.equals("surfaceBookComputer")){
computer = new SurfaceBookCmputer();
}
return computer;
}
}
//客户端
public class SimpleFactory {
public void buyComputer(Computer computer){
computer.printComputer();
}
public static void main(String[] args) {
SimpleFactory simpleFactory = new SimpleFactory();
Scanner in = new Scanner(System.in);
String type = in.nextLine();
simpleFactory.buyComputer(Factory.MakeComputer(type));
}
}
- 工厂方法模式
缺点:当有新的产品族时,就违反OCP开闭原则
- 一个抽象产品
- 多个具体产品
- 一个抽象工厂
- 多个具体工厂
工厂方法模式是针对每个产品提供一个工厂类,在客户端中判断使用哪个工厂类去创建对象。
简单工厂模式里如果要新加类就要打开工厂修改,如果一公司想往新的方向发展,就必须要在工厂里创建更多的生产类实例化,所以将工厂也抽象,这样如果有产品的改动,只要新加工厂就可以了。
代码:
package com.irilia.FactoryDesignPattern;
interface Computer2{
void printComputer();
}
class MacBookComputer2 implements Computer2{
@Override
public void printComputer() {
System.out.println("This is a MacBookComputer");
}
}
class SurfaceBookCmputer2 implements Computer2{
@Override
public void printComputer() {
System.out.println("This is a SurfaceBookCmputer");
}
}
interface Factory2{
Computer2 creatComputer();
}
class MSFactory implements Factory2{
@Override
public Computer2 creatComputer() {
return new SurfaceBookCmputer2();
}
}
class AppleFactory implements Factory2{
@Override
public Computer2 creatComputer() {
return new MacBookComputer2();
}
}
public class FactoryMethod {
public void buyComputer2(Computer2 computer2{
computer2.printComputer();
}
public static void main(String[] args) {
FactoryMethod factoryMethod = new FactoryMethod();
Factory2 factory2 = new AppleFactory();
Computer2 computer2 = factory2.creatComputer();
factoryMethod.buyComputer2(computer2);
}
}
- 抽象工厂模式
缺点:扩展产品族时违反OCP原则
- 多个产品抽象类
- 多个具体产品类
- 抽象工厂类(声明一组返回抽象产品的方法)
- 具体工厂类(生成一组具体产品)
package com.irilia.FactoryDesignPattern;
/** 1.多个产品抽象类*
2.多个具体的产品类*
3.工厂业务组抽象类*
4.具体工厂业务组类*/
//卖电脑,卖处理器
interface Computer3 {
void printComputer3();
}
interface OperatingSystem{
void printOperatingSystem();
}
//电脑的具体类
class MacBookCumputer implements Computer3{
@Override
public void printComputer3() {
System.out.println("This is a MacBookComputer");
}
}
class SurfaceBookComputer implements Computer3{
@Override
public void printComputer3() {
System.out.println("This is a SurfaceBookComputer");
}
}
//处理器的具体类
class Windows8System implements OperatingSystem{
@Override
public void printOperatingSystem() {
System.out.println("This is a Windows8System");
}
}
class MacOsSystem implements OperatingSystem{
@Override
public void printOperatingSystem() {
System.out.println("This is a MacOsSystem");
}
}
//抽象工厂的业务组
interface ProductionFactory{
Computer3 creatComputer3();
OperatingSystem creatOperation();
}
//具体工厂的业务组
class AppleFactory2 implements ProductionFactory{
@Override
public Computer3 creatComputer3() {
return new MacBookCumputer();
}
@Override
public OperatingSystem creatOperation() {
return new MacOsSystem();
}
}
class MSFactory2 implements ProductionFactory{
@Override
public Computer3 creatComputer3() {
return new SurfaceBookComputer();
}
@Override
public OperatingSystem creatOperation() {
return new Windows8System();
}
}
public class AbstractFactory {
public void buyComputer(Computer3 computer3,OperatingSystem
operatingSystem){
computer3.printComputer3();
operatingSystem.printOperatingSystem();
}
public static void main(String[] args) {
AbstractFactory abstractFactory = new AbstractFactory();
ProductionFactory productionFactory = new AppleFactory2();
Computer3 computer3 = productionFactory.creatComputer3();
OperatingSystem operatingSystem = productionFactory.creatOperation();
abstractFactory.buyComputer(computer3,operatingSystem);
}
}