JAVA设计模式之工厂模式伪代码解析

左手的ㄟ右手 2022-03-18 10:20 197阅读 0赞

我们都知道一个接口可以有很多的实现子类，例如汽车，子类有宝马、梅赛德斯奔驰、大众、荣威等。如果我们需要什么子类汽车的话就得分别取实例化这些子类，而工厂模式则是提供了一个方法根据我们的需要去选这创建这些子类，例如：我们需要一辆宝马汽车，工厂则给我们创建一辆宝马汽车，需要一辆奔驰汽车，工厂则给我们创建一辆奔驰汽车等等....我们无需关注整个创建的过程。这就是**工厂模式的作用：把对象的创建和使用过程进行解耦，把对象的创建交给工厂，我们只需要调用即可。另外减少创建的重复代码，统一管理也便于维护**

**简单工厂模式伪代码：就是建立一个工厂类，分类对实现同一接口的类的创建管理**

创建一个汽车接口：

package pers.ly.learn.designModel.factory.simpleFactory;
    
    public interface Cars {
    
    }

宝马汽车：

package pers.ly.learn.designModel.factory.simpleFactory;
    
    public class Bmw implements Cars {
    
    	public Bmw() {
    		super();
    		System.out.println("汽车工厂生产了一辆宝马...");
    	}
    
    }

奔驰汽车：

package pers.ly.learn.designModel.factory.simpleFactory;
    
    public class Merceders implements Cars {
    
    	public Merceders() {
    		super();
    		System.out.println("汽车工厂生产了一辆奔驰...");
    	}
    
    }

定义一个汽车工厂：

package pers.ly.learn.designModel.factory.simpleFactory;
    
    /**
     * 简单工厂模式：
     * @author banma
     *
     */
    public class SimpleCarsFactory {
    	
    	//可以看出这种模式扩展性很差，每次新增一种品牌的车型都需要修改工厂类里面carsBuild方法的源码（新增if判断）
    	public static Cars carsBuild(String barnd) {
    		Cars cars = null;
    		if(barnd.equals("宝马")) {
    			cars = new Bmw();
    		}else if(barnd.equals("奔驰")) {
    			cars = new Merceders();
    		}else {
    			System.out.println("该车厂无法制造" + barnd + "品牌的汽车！");
    		}
    		return cars;
    	}
    	
    	//利用反射创建
    	public static Cars carsBuild(Class cla) {
    		Cars cars = null;
    		try {
    			cars = (Cars) Class.forName(cla.getName()).newInstance();
    		} catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
    			System.out.println(e.getMessage());
    		}
    		return cars;
    	}
    
    }

测试用例：

public class Tset {
    	
    	public static void main(String[] args) {
    		
    		simpleFactoryTest("宝马");
    		simpleFactoryTest("奔驰");
    		simpleFactoryTest("大众");
    		simpleFactoryTest(Bmw.class);
    		
    	}
    	
    	
    	public static void simpleFactoryTest(String brand) {
    		SimpleCarsFactory.carsBuild(brand);
    	} 
    	
    	public static void simpleFactoryTest(Class cla) {
    		SimpleCarsFactory.carsBuild(cla);
    	}
    
    }

工厂方法模式：上面简单工厂是通过一个工厂去生产多种类型的子类（车型），如果传递的参数错误，则无法正确的创建对象。而工厂方法的实现则是通过一个工厂去生产一种特定车型，无需传参了，于是每个车型都需要一个工厂。实现：定义一个工厂接口IFactory，每个具体工厂去实现这个接口

定义汽车接口：

package pers.ly.learn.designModel.factory.factoryMethod;
    
    public interface ICars {
    
    }

定义宝马类：

package pers.ly.learn.designModel.factory.factoryMethod;
    
    public class Bmw implements ICars {
    
    	public Bmw() {
    		super();
    		System.out.println("制造一辆宝马..");
    	}
    
    }

定义奔驰类：

package pers.ly.learn.designModel.factory.factoryMethod;
    
    public class Meceders implements ICars {
    	
    	public Meceders() {
    		super();
    		System.out.println("制造一辆梅赛德斯奔驰..");
    	}
    
    }

定义一个工厂接口：

package pers.ly.learn.designModel.factory.factoryMethod;
    
    public interface IFactory {
    	
    	ICars ctrateCar();
    
    }

定义制造宝马的工厂：

package pers.ly.learn.designModel.factory.factoryMethod;
    
    public class BmwFactory implements IFactory {
    
    	@Override
    	public ICars ctrateCar() {
    		
    		return new Bmw();
    	}
    
    }

定义奔驰制造工厂：

package pers.ly.learn.designModel.factory.factoryMethod;
    
    public interface IFactory {
    	
    	ICars ctrateCar();
    
    }

测试代码：

public class Tset {
    	
    	public static void main(String[] args) {
    		
    		
    		IFactory bmwFactory = new BmwFactory();
    		bmwFactory.ctrateCar();
    		
    		IFactory msdFactory = new MecedersFactory();
    		msdFactory.ctrateCar();
    		
    		
    	}
    
    }

抽象工厂模式：抽象工厂除了具有工厂方法模式的优点外，还可以用来创建一系列的其他产品，例如：自行车、摩托车等、可以在工厂类的内部对这些产品进行创建的管理约束，不需要引入一个新类（工厂类）来管理,缺点就是：新增一类，工厂类的代码需要做修改

定义一个汽车接口：

package pers.ly.learn.designModel.factory.abstractFactory;
    
    public interface ICars {
    
    }

定义宝马类：

package pers.ly.learn.designModel.factory.abstractFactory;
    
    public class BmwX5 implements ICars {
    
    	public BmwX5() {
    		super();
    		System.out.println("制造一辆BmwX5..");
    	}
    
    }

定义自行车接口：

package pers.ly.learn.designModel.factory.abstractFactory;
    
    public interface IBike {
    
    }

定义解放牌自行车类：

package pers.ly.learn.designModel.factory.abstractFactory;
    
    public class jiefangBike implements IBike {
    	
    	public jiefangBike() {
    		super();
    		System.out.println("制造一辆解放牌自行车..");
    	}
    
    }

定义工厂接口：

package pers.ly.learn.designModel.factory.abstractFactory;
    
    public interface ICarsFactory {
    	
    	ICars createCar();
    	
    	IBike createBike();
    
    }

定义工厂实现类：

package pers.ly.learn.designModel.factory.abstractFactory;
    
    public class CarFactory implements ICarsFactory {
    
    	@Override
    	public ICars createCar() {
    		return new BmwX5();
    	}
    
    	@Override
    	public IBike createBike() {
    		return new jiefangBike();
    	}
    
    }

测试代码：

public class Tset {
    	
    	public static void main(String[] args) {
    		
    		
    		abstractFactory().createCar();
    		abstractFactory().createBike();
    		
    	}
    	
    	public static ICarsFactory abstractFactory() {
    		ICarsFactory iCarsFactor = new CarFactory();
    		return iCarsFactor;
    	}
    	
    }