Java 在继承中将变长参数列表更改为固定大小 要求 我需要一个多态方法 子类中的参数列表大小不同 子类中的参数可能来自不同的子类型，我希望编译器在子类中对确定的子类型执行类型检查

所以列表或数组不适合作为参数。因为它们不强制大小或确切的子类型

更多细节和示例 [代码用于说明，您可能会在其中发现编译错误。]

第一例 我需要一个基类和一个接受可变长度参数列表的方法。这使我可以有一个普通的类。例如：

abstract class baseClass{
    public abstract void serialize(Object... data);
}

class subClass3 extends baseClass{
    @Override
    public void serialize(int data1){
        //method body...
    }
}
class subClass4 extends baseClass{
    @Override
    public void serialize(int data1, double data2, String data3){
        //method body...
    }
}

现在我想创建一些特定的子类，所以我需要在子类中有固定大小的参数列表。例如，类似这样的内容（但这种语法是错误的！）：

我应该如何编写子类

第二种情况 在另一种情况下，我的子类希望显式定义参数的类型（因为这将允许编译时检查）。例如：

abstract class baseClass{
    public abstract void serialize(Object... data);
}

class subClass3 extends baseClass{
    @Override
    public void serialize(int data1){
        //method body...
    }
}
class subClass4 extends baseClass{
    @Override
    public void serialize(int data1, double data2, String data3){
        //method body...
    }
}

---

我该如何写这一条呢？

一条重要的重写规则

参数列表应与重写的参数列表完全相同 方法

请参阅其他规则

或者，您可以使用重载。类似于下面的代码，可以出现在子类中

    void test(Object data) {
// some logic here
        super.test(data);
    }

我不知道您的需求是什么，但我可能会将超类方法“参数化”，以便子类可以提供具体的实现

============================编辑===================================== 我不知道你的用例。但根据这篇文章，以下是我能想到的解决方案。请检查这是否有效

abstract class baseClass<T>{
    public abstract void serialize(T... data);
}
class subClass1 extends baseClass <String>{
    @Override
    public void serialize(String... data) {
        if(data.length>1)throw new IllegalArgumentException("Accepts only single string");
    }
}
class subClass2 extends baseClass<Integer>{
    @Override
    public void serialize(Integer... data) {
    }
}
public static void main(String[] args) {

    baseClass<String> sc1 = new subClass1();
    sc1.serialize("test");

    baseClass<Integer> sc2 = new subClass2();
    sc2.serialize(1,2);
}

抽象类基类{
公开摘要无效序列化（T…数据）；
}
类子类1扩展了基类{
@凌驾
公共void序列化（字符串…数据）{
如果（data.length>1）抛出新的IllegalArgumentException（“仅接受单个字符串”）；
}
}
类子类2扩展了基类{
@凌驾
公共void序列化（整数…数据）{
}
}
公共静态void main（字符串[]args）{
基类sc1=新的子类1（）；
sc1.序列化（“测试”）；
基类sc2=新的子类2（）；
sc2.序列化（1,2）；
}

我以前没有处理过序列化数据，但您可以这样做吗：

public abstract void serialize(Object[] data)
{
    for(Object obj : data)
    {
        //do something
    }
}

---

-Kaz

否，因为：1）对象[]与对象相同。。。2） 我需要编译时类型检查。这很重要！上面是可变长度的位，然后子类必须实现超类的所有成员。然而，基类和子类之间的构造函数将非常不同。在super中有一个“object data1”然后用更多的“object data1，object data2”扩展它不是更容易吗。如果子类是已知的扩展，那么可变长度有什么好处？“如果子类是已知的扩展，那么可变长度有什么好处？”-->因为子类有不同的参数，但是方法标题应该在所有子类中实现。我的理解是，超类（你的基类）包含所有子类所共有的成员，子类扩展了超类中存在的成员。按照您对变量构造函数的想法，所有子类都将继承数量可变的对象成员，是这样吗？你必须超级（对象…数据）才能工作，但这并没有真正的帮助。是否可能有多个超类构造函数（如果你知道它们是什么）具有不同长度的参数，尽管这在很大程度上违背了目的。1）我知道规则。2） 请参考问题中的“要求”。我已经编辑了我的帖子并提出了建议。请检查这是否有帮助。这是一个很好的尝试，但有两个缺点：1）如果参数在一个子类中有不同的类型怎么办？2） 我更喜欢编译时检查，而不是运行时检查。当然，我们可以提出其他一些好的运行时解决方案！