2

我目前正在寻找一段代码，它可以序列化/反序列化数据。

类结构看起来像这样：

public class Field
{
    public abstract void writeField(DataOutputStream out);

    public abstract int getFieldID();

    ...

    protected static final int INT_FIELD = 1;
    protected static final int BOOL_FIELD = 2;

    ...

    public void write(DataOutputStream out)
    {
        out.writeInt(getFieldID());
        writeField(out);
    }

    ...
}

public class IntField extends Field
{
    public int v;

    public void writeField(DataOutputStream out)
    {
        out.writeInt(v);
    }

    public int getFieldID()
    {
        return Field.INT_FIELD;
    }
}

我觉得 getFieldID 的实现方式并不是最好的。

编写一个抽象方法来返回该类的唯一标识符感觉很糟糕。

有没有更好的方法来实现这一点？

4

3 回答 3

4

在基类中列出特定于子类的常量并不是一个好主意，因为理想情况下，超类不应该知道它的子类。仅仅列出基类中的常量并不像使用它们来区分基类代码中的子类那么糟糕。

理想情况下，您应该将常量移动到它们各自的子类中。如果你不能在不破坏编译的情况下做到这一点，那么你确实偶然发现了重构的主要候选者。

于 2012-05-14T03:35:02.637 回答
4

您可以使用泛型定义一个类。像这样：

场地

import java.io.DataOutputStream;

public abstract class Field<T extends Object> {
    public abstract void writeField(DataOutputStream out);
    public abstract T getValue();
    public abstract Class<T> getFieldClass();
}

内部字段

import java.io.DataOutputStream;
import java.io.IOException;

public class IntField extends Field<Integer> {
    public Integer v;

    @Override
    public void writeField(DataOutputStream out) {
        try {
            out.writeChars(v.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public Integer getValue() {
        return v;
    }

    @Override
    public Class<Integer> getFieldClass() {
        return Integer.class;
    }
}
于 2012-05-14T07:02:18.173 回答
1

除了使用在子类中重写的超类抽象方法使用实现继承之外，还可以使类紧密耦合。

您可以拥有一个在实现类中实现的接口，其中接口中声明的所有方法都在实现类中实现。这种方法是另一种继承方式，称为接口继承。这减少了超类和子类之间的紧密耦合。

于 2012-05-14T03:34:50.280 回答