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

Question

In Java, is it possible to have two constructors of the same class with different names? For example, let's say I have the class Test , I would like to have something like this

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

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

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

Edit: I'm going to explain why I would like this.

I have a class like this, let's call it 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
    }

So I want to do a few subclasses of Class1 , but in this classes I don't need all the hashmaps of ClassContainer , I want to save space. For example, Class2 will extend Class1 but will only need hm2; Class3 will extend Class1 but will only need hm2 and hm3.

I would like a way to initialise just the necessary parts of ClassContainer to save memory. And I want to use subclasses because they share a lot of code.

Answer 1

No, a constructor must have the same class name. The closest thing you can do is inheritance:

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

No, it is not. Constructors must have the same name as the class, and must return nothing. However, their signatures can change in the amounts and types of arguments. You could do, for example the following:

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

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

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

However, it seems like you want to have inheritance (a subclass of Test called Test2 that has hsD .)

Answer 3

if you have multiple contstructors, i recommend to use a Factory class instead. Here you can add multiple static functions that are returning a new instance of this class.

This is always recommended when using multiple constructors because you can give the methods any name you want.

Answer 4

It is impossible to declare two constructors with different names. However, you can have two constructors with different parameters:

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

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

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

In the example above, exampleArg is a dummy argument that is simply meant to distinguish the two constructors.

Answer 5

You can't.

What you can do is provide static builder methods instead (which can have any names). You'll end up with multiple constructors, but you can make them private and only expose the static builders:

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

Then you can call use that like:

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

I also took the liberty to fix a couple of typos in your code: a map takes two generic arguments, it's always better to define a reference as the most abstract type possible (use Map and Set instead of HashMap / HashSet when declaring your reference types).

Answer 6

You should use inheritance. If you want to be picky, use a factory.

Regards,

Javier B.