Question

在Java中，是否可能有两个具有不同名称的同一类的构造函数？例如，假设我有类Test，我希望有类似的东西

class Test
    HashMap<Integer,Double> hsI;
    HashMap<Double,Double> hsD;

    Test() {
        hsi = new HashMap<>();
    }

    Test2() {
        hsi = new HashMap<>();
        hsD = new HashMap<>();
    }
}

修改我要解释为什么我会这样。

我有一个这样的课程，我们称之为Class1：

public class Class1 {
private HashMap<Integer,ClassContainer> hm;

private class ClassContainer {

    ClassContainer {
    hm1 = new HashMap<>();
    hm2 = new HashMap<>();
    hm3 = new HashMap<>();
    }

    HashMap<Double,Double> hm1;
    HashMap<Double,Double> hm2;
    HashMap<Double,Double> hm3;

... //more code
    }

所以我想做一些Class1的子类，但在这个类中我不需要ClassContainer的所有哈希图，我想节省空间。例如，Class2将扩展Class1，但只需要hm2; Class3将扩展Class1，但只需要hm2和hm3。

我想初始化ClassContainer的必要部分以节省内存。我想使用子类，因为它们共享大量代码。

Answer 1

不，构造函数必须具有相同的类名。你最接近的是继承：

class Test {
   HashMap<Integer, MyObject> hsI; // a map has two type arguments

   Test() {
      hsi = new HashMap<>();
   }
}

class Test2 extends Test {
   HashMap<Double, MyObject> hsD;

   Test2() {
      super();
      hsD = new HashMap<>();
   }
}

Answer 2

不，不是。构造函数必须与类具有相同的名称，并且必须不返回任何内容。但是，它们的签名可以改变参数的数量和类型。你可以这样做，例如：

class Test {
    HashMap<Integer> hsI;
    HashMap<Double> hsD;

    Test() {
       hsi = new HashMap<>();
    }

    Test(int i) {
        hsi = new HashMap<>();
        hsD = new HashMap<>();
    }
}

但是，您似乎希望继承（名为Test的{{1}}的子类具有Test2。）

Answer 3

如果您有多个contstructors，我建议使用Factory类。在这里，您可以添加多个返回此类的新实例的静态函数。

使用多个构造函数时，始终建议使用此方法，因为您可以为方法指定所需的任何名称。

Answer 4

不可能声明两个具有不同名称的构造函数。但是，您可以使用两个具有不同参数的构造函数：

class Test 
HashMap<Integer> hsI;
HashMap<Double> hsD;

    Test() {
       hsi = new HashMap<>();
    }

    Test2(String exampleArg) {
        hsi = new HashMap<>();
        hsD = new HashMap<>();
    }
}

在上面的例子中，exampleArg是一个伪参数，只是为了区分两个构造函数。

Answer 5

你不能。

您可以做的是提供静态构建器方法（可以使用任何名称）。您最终会得到多个构造函数，但是您可以将它们设为私有，只显示静态构建器：

class Test {
    private final Set<Integer> ints;
    private final Set<Double> doubles;

    private Test(Set<Integer> ints) {
        this(ints, null);
    }
    private Test(Set<Integer> ints, Set<Double> doubles) {
        this.ints = ints;
        this.doubles = doubles;
    }

    public static Test test1() {
        return new Test(new HashSet<Integer>());
    }
    public static Test test2() {
        return new Test(new HashSet<Integer>(), new HashSet<Double>());
    }
}

然后你可以调用像：

这样的用法

Test test1 = Test.test1();
Test test2 = Test.test2();

我还冒昧地在代码中修复了一些拼写错误：map有两个泛型参数，将引用定义为最抽象的类型总是更好（使用Map和在声明引用类型时Set而不是HashMap / HashSet。

Answer 6

你应该使用继承。如果你想挑剔，请使用工厂。

问候，

Javier B.

名称与类名不同的构造方法

6 个答案: