开闭原则:OCP,open-closed principle
对修改关闭,对扩展开放。
设计模式是为了,降低耦合和提高程序的可维护性和可扩展性。
CHANGE带给我们的噩梦
面向基类编程。
1、简单工厂模式
简单工厂模式中,工厂负责生产的产品的抽象基类,也可以是接口
奔驰车的实现类
宝马车的实现类
上面是工厂负责产生的对象(工厂产品)的结构
下面是工厂类:CarFactory.java
简单工厂模式的优点:
封装对象的创建过程,根据需要(carName)创建对象.降低client和产品的耦合
缺点:工厂和产品的依赖关系比较强,如果扩展Car,比如增加奥迪车,需要修改工厂类,增加if else,工厂不符合OCP
简单工厂模式的改进:
通过类名去加载具体类,这样就降低了工厂和具体实现类的耦合。
但是这样依然需要传入具体类的类名,依然存在依赖关系
我们可以使用配置文件来 配置 描述符和类的完全限定名,从而降低耦合
properties文件
benzCar = package.BenzCar
BMWCar = package.BMWCar
对修改关闭,对扩展开放。
设计模式是为了,降低耦合和提高程序的可维护性和可扩展性。
CHANGE带给我们的噩梦
面向基类编程。
1、简单工厂模式
简单工厂模式中,工厂负责生产的产品的抽象基类,也可以是接口
/**
* abstract base class of car.工厂产品的抽象基类
*/
public abstract class Car {
abstract void drive();
}
奔驰车的实现类
/**
* BenzCar extends abstract base class Car
*/
class BenzCar extends Car {
@Override
void drive() {
System.out.print("BenzCar");
}
}
宝马车的实现类
class BMWCar extends Car {
/**
* implement base abstract method drive.
* @author pingxm
*
*/
@Override
void drive() {
System.out.print("BMWCar");
}
}
上面是工厂负责产生的对象(工厂产品)的结构
下面是工厂类:CarFactory.java
/**
* the factory that product Car
*/
public class CarFactory {
public static Car createCar(String carName)
{
if("benz".equals(carName))
return new BenzCar();
if("BMW".equals(carName))
return new BMWCar();
return null;
}
}
简单工厂模式的优点:
封装对象的创建过程,根据需要(carName)创建对象.降低client和产品的耦合
缺点:工厂和产品的依赖关系比较强,如果扩展Car,比如增加奥迪车,需要修改工厂类,增加if else,工厂不符合OCP
简单工厂模式的改进:
/**
* the factory that product Car
*/
public class CarFactory {
/**
* @return Car
*/
public static Car createCar(String carType)
{
Car car = null;
Class carClass = null ;
try {
carClass = Class.forName(carType);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
catch (Exception e) {
e.printStackTrace();
}
try {
//实际应用中可能不是简单的newInstance
//可以根据配置文件设置属性值,关系等
car = (Car)carClass.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return car;
}
}
通过类名去加载具体类,这样就降低了工厂和具体实现类的耦合。
但是这样依然需要传入具体类的类名,依然存在依赖关系
我们可以使用配置文件来 配置 描述符和类的完全限定名,从而降低耦合
properties文件
benzCar = package.BenzCar
BMWCar = package.BMWCar