Question

我目前正在寻找一些代码序列化/反序列化数据的代码。

类结构看起来像这样：

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的方式不是最好的。

编写一个抽象方法来返回该类的唯一标识符感觉就像是难闻的气味。

有更好的方法来实现这个吗？

Answer 1

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

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

Answer 2

您可以使用Generics定义类。像这样：

字段

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();
}

IntField

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;
    }
}

Answer 3

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

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

重构类型代码覆盖

3 个答案: