时间戳

首页 > 解决方案 > 子类化泛型 - 构造函数继承

java - 子类化泛型 - 构造函数继承

问题描述

我正在尝试为变量表示创建一个类，所以我首先创建了一个参数化基类：

public abstract class DataField<Type>
{

    public enum DataTypes
    {
        STRING,
        INT,
        FLOAT,
        TIME,
        DATE
    }

    private DataTypes type=null;
    private String name=null;
    private Type value=null;

    private DataField()
    {
    }

    public DataField(String name)
    {
        setName(name);
    }

    DataField(String name, DataTypes type)
    {
        this(name);
        setType(type);
    }

    DataField(String name, DataTypes type, Type value)
    {
        this(name, type);
        setValue(value);
    }

    public DataField(String name, Type value)
    {
        this(name);
        setValue(value);
    }
    public DataField(String name, String value)
    {
        this(name);
        setStringValue(value);
    }
    public abstract void setStringValue(String strValue);
     ...
}

然后为不同类型制作子类，定义方法：

public class DataFieldInt extends DataField<Long>
 ...
public class DataFieldBoolean extends DataField<Boolean>
 ...

等等。但是我对 String 有一个预期的问题：Generic superclas 有 2 个构造函数 DataField(String name, Type value)来设置变量的名称和值，并 DataField(String name, String value)从 String 设置变量的名称和值，将其转换为所需的类型。但是对于子类，我有一个问题 - 使用什么构造函数，因为它们都是（字符串，字符串）。所以，这段代码

public class DataFieldString extends DataField<String>
{
    public DataFieldString(String name, String value)
    {
        super(name, value);
           ...
    }

给出了一个关于模糊参考的错误如何解决？我看到的唯一方法是使用 StringBuilder 或 StringBuffer 之类的东西而不是 String，但有趣的是，有没有“本机”解决方案？

谢谢

标签： javagenericsinheritanceconstructor

解决方案

如何解决？

通过提供对编译器没有任何歧义的调用。

我看到的唯一方法是使用 StringBuilder 或 StringBuffer 之类的东西而不是 String，但有趣的是，有没有“本机”解决方案？

它会起作用，但是依靠 String 的构建器来传达不需要构建的 String 似乎也很笨拙 。

建议使用 a 的评论中的想法Factory还不错，但根据您的设计，我认为这将需要进行许多更改并使您远离实际设计：依赖于基类的类层次结构。
因为要使类之间的事情保持一致，您应该在每个子类中定义工厂。
此外，如果您将两个构造函数保留在基类中，它不会解决您的歧义问题。因此，您可能应该允许子类访问基类字段以执行构造函数逻辑。

因此，为了符合您的实际设计，我将通过引入一个包装Type和String变量的新类来解决歧义问题。
你可以在类中声明这个DataField类：

static class NameAndType<Type> {
    private String name;
    private Type value;
    public NameAndType(String name, Type value ){
       ....
    }
}

因此DataField类可以公开这两个构造函数：

public DataField(NameAndType<Type> nameAndType) {
    this(nameAndType.name);
    setValue(nameAndType.value);
}

public DataField(String name, String value) {
    this(name);
    setStringValue(value);
}

通过这种方式，您可以公开一个DataFieldString依赖于基类构造函数之一的构造函数：

public class DataFieldString extends DataField<String> {

    public DataFieldString(String name, String value) {
        super(name, value);
        //  or the other way : super(new NameAndType<>(name, value));
    }    
   ...
}

其他子类可以提出两个依赖于基类构造函数的构造函数。
例如 ：

public class DataFieldInt extends DataField<Integer> {

    public DataFieldInt(String name, Integer value) {
        super(new NameAndType<>(name, value));
    }

    public DataFieldInt(String name, String value) {
        super(name, value);
    }

    ...
}

这些NameAndType类的客户看不到复杂性/用途：

DataFieldInt dataFieldIntOne = new DataFieldInt("var1", 321);
DataFieldInt dataFieldIntTwo = new DataFieldInt("var1", "321");
DataFieldString dataFieldString = new DataFieldString("var1", "321");

推荐阅读