抽象工厂的作用:解耦合
为什么解耦合?
解耦合我简单的理解当实现新功能时,不会修改原始代码,只是新代码上迭代,易于维护,随后在博文中有具体的体现
jdk的抽象工厂模式
抽象工厂模式 (通过创造性的方法来识别工厂本身,这又可以用于创建另一个抽象/接口类型)
- javax.xml.parsers.DocumentBuilderFactory#newInstance()
- javax.xml.transform.TransformerFactory#newInstance()
- javax.xml.xpath.XPathFactory#newInstance()
1、肯定是先整出几个通用接口:一个颜色的接口,一个形状的接口
public interface Colors {
void fill();//抽象的填充方法
}
/**
* 形状类
*/
public interface Shape {
void draw();//画的抽象方法
}
2、实现接口
实现颜色
public class Blue implements Colors {
@Override
public void fill() {
System.out.println("我是蓝色");
}
}
public class Red implements Colors {
@Override
public void fill() {
System.out.println("填充红色");
}
}
public class Yellow implements Colors {
@Override
public void fill() {
System.out.println("我是黄色");
}
}
实现形状
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("我是画圆形的方法");
}
}
/**
* 矩形
*/
public class Rectangle implements Shape{
@Override
public void draw() {
System.out.println("我是画矩形的方法");
}
}
public class Square implements Shape {
@Override
public void draw() {
System.out.println("我是画正方式的方法");
}
}
3.为 Color 和 Shape 对象创建抽象类来获取工厂。 返回的是接口类型
public abstract class AbstractFactory {
public abstract Color getColor(String color);
public abstract Shape getShape(String shape) ;
}
4.实现核心代码:抽象工厂的抽象类(返回类型就是具体的工厂)
public class ShapeFactory extends AbstractFactory {
@Override
public Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase("CIRCLE")){
return new Circle();
} else if(shapeType.equalsIgnoreCase("RECTANGLE")){
return new Rectangle();
} else if(shapeType.equalsIgnoreCase("SQUARE")){
return new Square();
}
return null;
}
@Override
public Color getColor(String color) {
return null;
}
}
public class ColorFactory extends AbstractFactory {
@Override
public Shape getShape(String shapeType){
return null;
}
@Override
Color getColor(String color) {
if(color == null){
return null;
}
if(color.equalsIgnoreCase("RED")){
return new Red();
} else if(color.equalsIgnoreCase("GREEN")){
return new Green();
} else if(color.equalsIgnoreCase("BLUE")){
return new Blue();
}
return null;
}
}
5、创建一个工厂创造器/生成器类,通过传递形状或颜色信息来获取工厂。
public class FactoryProducer {
public static AbstractFactory getFactory(String choice){
if(choice.equalsIgnoreCase("SHAPE")){
return new ShapeFactory();
}else if(choice.equalsIgnoreCase("COLOR")){
return new ColorFactory();
}
return null;
}
}
6.使用 FactoryProducer 来获取 AbstractFactory,通过传递类型信息来获取实体类的对象。
public class AbstractFactoryPatternDemo {
public static void main(String[] args) {
//获取形状工厂
AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
//获取形状为 Circle 的对象
Shape shape1 = shapeFactory.getShape("CIRCLE");
//调用 Circle 的 draw 方法
shape1.draw();
//获取形状为 Rectangle 的对象
Shape shape2 = shapeFactory.getShape("RECTANGLE");
//调用 Rectangle 的 draw 方法
shape2.draw();
//获取形状为 Square 的对象
Shape shape3 = shapeFactory.getShape("SQUARE");
//调用 Square 的 draw 方法
shape3.draw();
//获取颜色工厂
AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
//获取颜色为 Red 的对象
Color color1 = colorFactory.getColor("RED");
//调用 Red 的 fill 方法
color1.fill();
//获取颜色为 Green 的对象
Color color2 = colorFactory.getColor("Green");
//调用 Green 的 fill 方法
color2.fill();
//获取颜色为 Blue 的对象
Color color3 = colorFactory.getColor("BLUE");
//调用 Blue 的 fill 方法
color3.fill();
}
}
分割线------------------------------------------------------------------------------------------------------------------------------------------------------------
这样新增一个三角形时,它会修改核心代码吗;答案是会的。。
还会新增一个if else;是不是很呆疼。虽说通过实现接口,继承抽象工厂,实现类分类,但是并没有很好的实现解耦合。。
好了,现在我们进行改造一下,既然都是实现,我们可以直接传入一个class对象通过反射进行回传数据
这样工厂实现的话就是这样了
这样的话我新增一个蓝色的话直接可以获取
但是呢这样的问题是;接口直接的类型分类不会那么明确了,我完全可以这样获取shape对象
是不是有问题了。继承分类实现接口功能就是变得模糊,这样不是很好的解耦合
于是乎我有实现这种方式:传入接口对象;进行分类信息(返回的都是泛型!!)
后台实现
实现测试
新增三角形
好了,这样就完全解耦合了
还有一个问题就是暴露接口的问题了,颜色工厂里面居然有实现shape的方法,返回时null,但是不好看
门面模式,我只让你看到我想看到的接口
OK~完美