Java 名称与类名不同的构造函数

在Java中，是否可能有两个同名的同一类的构造函数？例如，假设我有一个类

Test

，我想要这样的东西

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

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

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

所以我想做一些

Class1

的子类，但是在这个类中我不需要

ClassContainer

的所有hashmap，我想节省空间。例如，Class2将扩展Class1，但只需要hm2；Class3将扩展Class1，但只需要hm2和hm3

---

我想要一种方法来初始化ClassContainer的必要部分以节省内存。我想使用子类，因为它们共享很多代码。

不，构造函数必须具有相同的类名。您可以做的最接近的事情是继承：

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

类测试{
HashMap hsI；//映射有两个类型参数
测试（）{
hsi=新的HashMap（）；
}
}
类Test2扩展了测试{
HashMap-hsD；
Test2（）{
超级（）；
hsD=新的HashMap（）；
}
}

不，不是。构造函数必须与类具有相同的名称，并且不能返回任何内容。但是，他们的签名可以改变参数的数量和类型。例如，您可以执行以下操作：

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

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

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

类测试{
HashMap-hsI；
HashMap-hsD；
测试（）{
hsi=新的HashMap（）；
}
测试（int i）{
hsi=新的HashMap（）；
hsD=新的HashMap（）；
}
}

---

但是，您似乎想要继承（名为

Test2

的

Test的子类，它具有
hsD
）
不可能用不同的名称声明两个构造函数。但是，可以有两个具有不同参数的构造函数：

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

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

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

类测试
HashMap-hsI；
HashMap-hsD；
测试（）{
hsi=新的HashMap（）；
}
Test2（字符串示例arg）{
hsi=新的HashMap（）；
hsD=新的HashMap（）；
}
}

在上面的示例中，
exampleArg
是一个伪参数，它只是用来区分两个构造函数。
您不能

您可以做的是提供静态生成器方法（可以有任何名称）。最终会有多个构造函数，但可以将它们设置为私有，并且只公开静态构造函数：

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

我还冒昧地修复了代码中的一些错误：映射包含两个通用参数，最好将引用定义为最抽象的类型（在声明引用类型时使用
map
和
Set
而不是
HashMap
/
HashSet
）.
如果您有多个contstructor，我建议改用Factory类。在这里，您可以添加多个返回此类新实例的静态函数

在使用多个构造函数时，始终建议这样做，因为您可以根据需要为方法指定任何名称。
您应该使用继承。如果你想挑剔，就去工厂

问候,

Javier B.
不。这是不可能的。如果您解释一下您试图实现的目标，这可能会有所帮助，因为它使具有不同名称的构造函数看起来是一个理想的解决方案。你想用你的代码做什么？好的，我已经编辑了原始文章，并做了更多解释。
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();