1. 简单工厂模式
简单工厂其实不是一个设计模式,反而比较像是一种编程习惯。
我的理解:简单工厂模式只是把类实例化的方法【new()】放在了工厂类中
example:定义一个简单汽车工厂,根据客户的不同需要,生产不同的汽车。
来吧
1.定义一个汽车的接口,有一个基本的行为方法:即车是可以开的居然
public interface ICar {
//car 的行为
void driver();
}
2. 定义一个简单工厂,注意哟,这是重点。根据客户的不同需要,生产不同的汽车
public class SimpleFactory {
//创建汽车的方法
public ICar createVehicle(String type){
ICar car = null;
if("BMW".equals(type)){
car = new BMWCar();
}else if("QQ".equals(type)){
car = new QQCar();
}
return car;
}
}
3. 定义一个宝马车
/**
* 宝马车
*
*/
public class BMWCar implements ICar {
public void driver() {
System.out.println("宝马车在开啊。。。。");
}
}
4. 定义一个奇瑞QQ专门为屌丝服务
/**
* 奇瑞QQ
*
*/
public class QQCar implements ICar{
public void driver() {
System.out.println("QQ车在开啊。。。。");
}
}
5. 都准备好了,再来一个专卖店吧,专门倾听客户声音为客户服务
/**
* 售车店
*
*/
public class CarStore {
private SimpleFactory factory;//这也是重点啊。
public CarStore(SimpleFactory factory) {
this.factory = factory;
}
//我需要一辆车
public ICar orderVehicle(String type){
return factory.createVehicle(type);
}
}
6.运行看看
public class Main {
public static void main(String[] args) {
//定义一个工厂方法
SimpleFactory factory = new SimpleFactory();
//定义一个商店
CarStore carStore = new CarStore(factory);
//来一辆宝马吧
ICar bmw = carStore.orderVehicle("BMW");
bmw.driver();
//我没钱来一辆QQ吧
ICar qq = carStore.orderVehicle("QQ");
qq.driver();
}
}
以上是我理解的最简单工厂模式。
所有工厂模式都是用来封装对象的创建。
2. 抽象工厂模式
抽象工厂模式是工厂方法模式的升级版本,他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于,工厂方法模式针对的是一个产品等级结构;而抽象工厂模式则是针对的多个产品等级结构。在编程中,通常一个产品结构,表现为一个接口或者抽象类,也就是说,工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类,而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。
看例子吧
1. 抽象工厂方法
/**
* 抽象工厂的方法
*/
public abstract class AbstractFactory {
//生产Vehicle的方法
abstract ICar createVehicle(String type);
//生产airplane的方法
abstract IAirplane createAirplane(String type);
}
2. 定义一个车的接口
/**
* 汽车接口
*/
public interface ICar {
public void driver();
}
3.定义一辆宝马车
public class BMWCar implements ICar{
@Override
public void driver() {
System.out.println("宝马车在开啊。。。。");
}
}
4.定义一个QQ
/**
* 奇瑞QQ
*/
public class QQCar implements ICar{
@Override
public void driver() {
System.out.println("QQ在开。");
}
}
5.定义一个飞机的接口
/**
* 飞机接口
*/
public interface IAirplane{
public void fly();
}
6. 定义一架空军一号
/**
* 空军一号
*/
public class AirForceOne implements IAirplane{
@Override
public void fly() {
System.out.println("灰太狼的空军一号。。。");
}
}
7. 定义一个747
/**
* 747
*/
public class Airbus747 implements IAirplane{
@Override
public void fly() {
System.out.println("747在飞啊。");
}
}
8.定义一个低级工厂,继承自抽象工厂,可以生产QQ和747
/**
* 低级工厂
*/
public class LowLevelFactory extends AbstractFactory{
//只能生产QQ
ICar createVehicle() {
return new QQCar();
}
//只能生产747
IAirplane createAirplane() {
return new Airbus747();
}
}
9.定义一个高级工厂,继承自抽象工厂,可以生产bm和空车一号
/**
* 高级工厂
*/
public class HighLevelFactory extends AbstractFactory{
//可以生产bm
ICar createVehicle() {
return new BMWCar();
}
//可以生产空军一号
IAirplane createAirplane() {
return new AirForceOne();
}
}
10.运行一下
public class Main {
public static void main(String[] args) {
//高级工厂
AbstractFactory hignFactory = new HighLevelFactory();
ICar bmw = hignFactory.createVehicle();
bmw.driver();
IAirplane airplane747 = hignFactory.createAirplane();
airplane747.fly();
//低级工厂
AbstractFactory lowFactory = new LowLevelFactory();
ICar qq = lowFactory.createVehicle();
qq.driver();
IAirplane airone = lowFactory.createAirplane();
airone.fly();
}
}
我的理解:抽象工厂模式应该是有一个抽象工厂类,并且有许多继承的子工厂类。每一个类产品比方说,车,飞机,都有一个公共的接口。不同的子工厂可以组合生产不同的产品。