Question

我正在学习Desgin模式，并在HERE中遇到了非常奇怪的例子。如果我们上课了：

public abstract class AbstractFactory {
abstract Color getColor(String color);
abstract Shape getShape(String shape) ;
}

我们可以看到，它有两种创建对象的方法：颜色和形状。这个类是抽象的，所以我们必须创建这个的具体实现，所以我们假设我们有：

public class ShapeFactory extends AbstractFactory {

@Override
public Shape getShape(String shapeType){

// I skip implementation to keep post brief

}

@Override
Color getColor(String color) {
  return null; // It's useless method in this class!
}
}

和第二次实施：

public class ColorFactory extends AbstractFactory {

@Override
public Shape getShape(String shapeType){
  return null; // It's useless method in this class!
}

@Override
Color getColor(String color) {

// I skip implementation to keep post brief

}
}

这就是我的问题，在这两种情况下（具体工厂）都有一种完全没用的方法并且不存在，但是当我们创建AbstractFactory类时，我们必须实现这两种方法。编程在不需要它的类中创建无用的方法不是不好的做法吗？它应该以网站建议的其他方式完成吗？

Answer 1

@ Michael213 - 您的具体实现不正确。他们肯定不遵循抽象工厂模式。抽象工厂谈论产品系列。抽象工厂样本（我的假设）将看起来像下面的代码。你只使用一种方法的例子就是滥用模式，很快就会崩溃。

我已经回答了类似的问题，请同时查看What are the real benefits of using the Abstract Factory in the following example, instead of the factory method?

    public abstract class AbstractFactory {
        abstract Color getColor(String color);
        abstract Shape getShape(String shape) ;
    }
    /**
     * CONCRETE FACTORY1
     */
    class HighResolutionFactory extends AbstractFactory{
        Color getColor(String color){
            return new HighResolutionColor();
        }
        Shape getShape(String shape){
            return new HighResolutionShape();
        }
    }

    /**
     * CONCRETE FACTORY2
     */
    class LowResolutionFactory extends AbstractFactory{
        Color getColor(String color){
            return new LowResolutionColor();
        }
        Shape getShape(String shape){
            return new LowResolutionShape();
        }
    }
    class Color{} // ABSTRACT PRODUCT 1
    class Shape{} // ABSTRACT PRODUCT 2
    class HighResolutionColor extends Color{}// CONCRETE PRODUCT1 FACT 1
    class HighResolutionShape extends Shape{}// CONCRETE PRODUCT2 FACT 1
    class LowResolutionColor extends Color{}//...
    class LowResolutionShape extends Shape{}

Answer 2

是的，那个教程似乎并不是最好的。虽然它仍然是一种工厂设计模式，但它并不理想。

Answer 3

AbstractFactory错了。您不必考虑生产不同物体的工厂。为每种不同的类型制作单独的工厂是正确的。

public class Capitalize {
    public static String capitalize(String string) {
        StringBuilder builder = new StringBuilder(string.length());

        boolean capitalizeNext = true;
        for (int i = 0; i < string.length(); i++) {
            char c = string.charAt(i);

            if (capitalizeNext && Character.isLetter(c)) {
                c = Character.toUpperCase(c);
                capitalizeNext = false;
            } else if (Character.isWhitespace(c)) {
                capitalizeNext = true;
            }

            builder.append(c);
        }
        return builder.toString();
    }

    //input words and print the result
    public static void main(String[] args){
        String str = "the simpson series";
        String total = capitalize(str);
        System.out.println(total);
    }   
}

抽象工厂模式 - 未使用的代码

3 个答案: