Java 静态法遗传

我有一个父类，它包含从db中写入和读取的方法。问题是我有一个静态方法，我想推广它。这样做的最佳实践是什么？我已经提出了一些解决方案，但都不能用静态方法

有没有办法强制childobject实现抽象方法

父类：

public class Data_object  {

    public byte[] toByteArray() throws IOException  {
        return null;
    }
    public static Data_object fromByteArray(byte[] data){
        return null
    }
}

儿童班：

public class ModelObject extends Data_object {

    public static Data_object fromByteArray(byte[] data){
        ModelObject result = new ModelObject();
        //set data from byte arrray
        return result;
    }
}

---

谢谢

继承不会以这种方式应用于静态方法。对特定类调用静态方法，如下所示：

MonkeyModelObject.fromByteArray(data)

即使从类内部执行此操作，您仍然在幕后调用特定类上的特定方法。因此，如果您重写一个静态方法，那么您只是将另一个类中具有相同名称的新方法作为子类。静态方法没有运行时选择的方法

对于您正在处理的特定情况，您似乎正在执行从/到字节数组的序列化。也许您正在序列化来自网络流的消息，或者类似的东西？我会推荐以下方法，也许这个伪代码可以启发您：

abstract class Message
{
    void write(stream)
    {
        stream.write(getMessageTypeCode());
        writeParameters(stream);
    }
    abstract int getMessageTypeCode();
    abstract void writeParameters(stream);
    abstract void readParamters(stream);
}
class ChatMessage
{
    String text;
    int getMessageTypeCode() { return 1; }
    void writeParameters(stream)
    {
        stream.write(text);
    }
    void readParameters(stream)
    {
        text = stream.read();
    }
}
class MessageDecoder
{
    Message decode(stream)
    {
        int type = stream.read();
        message = createMessage(type);
        message.readParameters(stream);
        return message;
    }
    Message createMessage(int type)
    {
        if (type == 1)
        {
            return new ChatMessage();
        }
        throw new error;
    }
}

---

继承不会以这种方式应用于静态方法。对特定类调用静态方法，如下所示：

MonkeyModelObject.fromByteArray(data)

即使从类内部执行此操作，您仍然在幕后调用特定类上的特定方法。因此，如果您重写一个静态方法，那么您只是将另一个类中具有相同名称的新方法作为子类。静态方法没有运行时选择的方法

对于您正在处理的特定情况，您似乎正在执行从/到字节数组的序列化。也许您正在序列化来自网络流的消息，或者类似的东西？我会推荐以下方法，也许这个伪代码可以启发您：

abstract class Message
{
    void write(stream)
    {
        stream.write(getMessageTypeCode());
        writeParameters(stream);
    }
    abstract int getMessageTypeCode();
    abstract void writeParameters(stream);
    abstract void readParamters(stream);
}
class ChatMessage
{
    String text;
    int getMessageTypeCode() { return 1; }
    void writeParameters(stream)
    {
        stream.write(text);
    }
    void readParameters(stream)
    {
        text = stream.read();
    }
}
class MessageDecoder
{
    Message decode(stream)
    {
        int type = stream.read();
        message = createMessage(type);
        message.readParameters(stream);
        return message;
    }
    Message createMessage(int type)
    {
        if (type == 1)
        {
            return new ChatMessage();
        }
        throw new error;
    }
}

---

Java中的静态方法不能是抽象的，也不能重写它。所以不能强制子类实现某个静态方法

唯一的解决方法是按照约定要求使用静态方法，就像附带的JavaDoc中的注释一样，并使用反射来确保在运行时或构建时，子类实现所需的静态方法

顺便说一句，这是一种常见的模式。Serializable没有定义任何方法，但其文档中提到了三种方法：

private void writeObject(java.io.ObjectOutputStream out)
   throws IOException
private void readObject(java.io.ObjectInputStream in)
   throws IOException, ClassNotFoundException;
private void readObjectNoData() 
   throws ObjectStreamException;

对象序列化框架现在使用反射来测试这些方法是否由类实现，如果是，则调用这些方法

---

但我建议在使用此策略之前先寻找其他解决方案。

Java中的静态方法不能是抽象的，也不能覆盖它。所以不能强制子类实现某个静态方法

唯一的解决方法是按照约定要求使用静态方法，就像附带的JavaDoc中的注释一样，并使用反射来确保在运行时或构建时，子类实现所需的静态方法

顺便说一句，这是一种常见的模式。Serializable没有定义任何方法，但其文档中提到了三种方法：

private void writeObject(java.io.ObjectOutputStream out)
   throws IOException
private void readObject(java.io.ObjectInputStream in)
   throws IOException, ClassNotFoundException;
private void readObjectNoData() 
   throws ObjectStreamException;

对象序列化框架现在使用反射来测试这些方法是否由类实现，如果是，则调用这些方法

---

但我建议在使用此策略之前寻找其他解决方案。

静态方法不能被覆盖。您只能通过在子类中定义一个具有相同名称和签名的方法来隐藏超类方法，但这很容易混淆，因此通常不建议这样做。原始的超类方法仍然可以被访问，例如，超类名subClassInstance.staticMethod

---

在您的情况下，最好使方法非静态。

静态方法不能被重写。您只能通过在子类中定义一个具有相同名称和签名的方法来隐藏超类方法，但这很容易混淆，因此通常不建议这样做。原始的超类方法仍然可以被访问，例如，超类名subClassInstance.staticMethod

---

在您的情况下，最好将方法设置为非静态。

为什么在这种情况下您希望方法是静态的？您不能将静态方法设置为抽象的，因为在调用它时，您需要为被调用的方法指定确切的类。你到底想实现什么？因为他还没有一个实例。他正在进行某种反序列化，其思想是：编写：object.writestream；读取：object=DataObject.readstream；在这种情况下，为什么希望方法是静态的？不能使静态方法抽象，因为在调用它时，需要为被调用的方法指定确切的类。你到底想实现什么？因为他还没有一个实例。他正在进行某种反序列化，其思想是：编写：object.writestream；读取：object=DataObject.readstream；