Question

我有一个工厂让你创造一些不同类型的东西。每件事物的价值来自不同的来源，并且具有不同的类型。我希望类使用者使用单个getValue（）和setValue（）接口，以便在基类中执行一些重要的工作。我也想要子类能够处理一些不同的参数类型。目前，我正在做一些类型识别jiggery-pokery（参见Thing2）来处理不同类型。有更好的方法吗？

我的问题：我在这里做对了吗？

abstract class Thing {

    public static Thing thingFactoryCreationary(byte iClass) {
        // let's assume this is more sophisticated in real life.
        return iClass==1 ? new Thing1() : new Thing2();
    }

    final public Object getValue() {
        myImportantWorkFunction();
        return _getValue();
    }

    final public void setValue(Object oValue) {
        myImportantWorkFunction();
        _setValue(oValue);
    }

    private void myImportantWorkFunction() {
        // save the world here.
    }        

    abstract protected Object _getValue();
    abstract protected void _setValue(Object oValue);
}

class Thing1 extends Thing {
    private String msMyStringPropertyValue;
    protected String _getValue() {
        return msMyStringPropertyValue;
    }
    protected void _setValue(Object oValue) {
        msMyStringPropertyValue = oValue.toString();
    }
}

class Thing2 extends Thing {

    protected InputStream _getValue() {
        return new FileInputStream("/some/file/descriptor");
    }

    protected void _setValue(Object oValue) {
        InputStream oInStream = null;            
        if (InputStream.class.isInstance(oValue)) {
            oInStream =(InputStream)oValue;
        } else {
            if (File.class.isInstance(oValue)) {
                oInStream = new FileInputStream((File)oValue);
            } else {
                oInStream = new ByteArrayInputStream(oValue.toString().getBytes("UTF-8"));                
            }                                       
        }
        FileOutputStream oOutStream = new FileOutputStream("/some/file/descriptor");
        myFileStreamCopyFunction(oInStream, oOutStream);
    }

    private void myFileStreamCopyFunction(InputStream oInStream, OutputStream oOutStream) {
        // reading and writing is fundamental.
    }

}

谢谢。

Answer 1

是的，这是一个好方法。也许您可以使用泛型指定接受的类型：

public abstract class Thing<S, G> {
    private G value;
    public void setValue(S object);
    public G getValue();
}
public class Thing1 extends Thing<String, String> {..}
public class Thing2 extends Thing<ResourceHolder, String> {..}

ResourceHolder是一个简单的bean，包含InputStream和File的getter和setter。 S和G代表setter和getter - 您指定了您希望设置的内容，以及客户在调用get时所期望的内容

因此每个子类只能处理一种类型的值，但该类型可以包含多个选项。这样，您可以使用简单的null检查，而不是反思。

使用单个基类接口处理子类中的不同参数类型

1 个答案: