从私有构造函数创建对象-eclipse/java错误？

刚刚注意到，当我创建模型时，我能够创建一个私有构造函数。。。可能java或eclipse bug只需要确认一下。我知道这有点不可能，但你自己试试吧

创建一个任意模型

//case1
public class Main {

private Main(){}
public Main(Double...doubles ){}
}

通常无法创建对象Main m=new Main（）；但是当你创建这样一个模型时：

//case2
public class Main {

private Main(){}
public Main(Double [] doubles ){}
}

无法创建对象Main m=new Main（）

这是怎么回事？如有任何解释，我将不胜感激

Java:build1.8.0_131-b11

---

Eclipse:Version:Neon.3发行版（4.6.3）应该是这样的。您可以在Java中创建私有构造函数。请看这个

应该是这样的。您可以在Java中创建私有构造函数。请看这个

这不是一个bug。在案例2中，您实际上正在创建一个私有构造函数，这意味着您不能使用不接受

args

的默认构造函数实例化

Main

的对象。只能在定义对象的同一类中使用私有构造函数构造对象

public class Main {

     private Main() {
     }

     public Main(Double[] doubles) {
     }

     public void testPrivateConstructor() {
         Main mainObjectInsideTheSameClass = new Main();
     }
 }

在案例1中，您的第二个构造函数是公共的，并且它接受可变数量的参数。因此，当您使用

Main m=new Main（）

创建对象时，实际上是在使用第二个公共构造函数，并且传递零个参数

public class Main
{
    private Main()
    {
        System.out.println("Main1");
    }

    public Main(Double[] d)
    {
        System.out.println("Main1 " + (Arrays.toString(d)));
    }

    public static void main(String[] args)
    {
        TestA testA = new TestA(); //match to TestA(Double... d) with zero args
//      TestB testB = new TestB(); //ERROR don't match to TestB(Double[] d)
        Main main = new Main(); //you can use private constructors in class
    }
}

class TestA
{
    private TestA()
    {
        System.out.println("TestA1");
    }

    public TestA(Double... d)
    {
        System.out.println("TestB2 " + (Arrays.toString(d)));
    }
}

class TestB
{
    private TestB()
    {
        System.out.println("TestB1");
    }

    public TestB(Double[] d)
    {
        System.out.println("TestB2 " + (Arrays.toString(d)));
    }
}

案例2的一个特定用例是Java中的单例模式。

---

请参阅：

这不是一个bug。在案例2中，您实际上正在创建一个私有构造函数，这意味着您不能使用不接受

args

的默认构造函数实例化

Main

的对象。只能在定义对象的同一类中使用私有构造函数构造对象

public class Main {

     private Main() {
     }

     public Main(Double[] doubles) {
     }

     public void testPrivateConstructor() {
         Main mainObjectInsideTheSameClass = new Main();
     }
 }

在案例1中，您的第二个构造函数是公共的，并且它接受可变数量的参数。因此，当您使用

Main m=new Main（）

创建对象时，实际上是在使用第二个公共构造函数，并且传递零个参数

public class Main
{
    private Main()
    {
        System.out.println("Main1");
    }

    public Main(Double[] d)
    {
        System.out.println("Main1 " + (Arrays.toString(d)));
    }

    public static void main(String[] args)
    {
        TestA testA = new TestA(); //match to TestA(Double... d) with zero args
//      TestB testB = new TestB(); //ERROR don't match to TestB(Double[] d)
        Main main = new Main(); //you can use private constructors in class
    }
}

class TestA
{
    private TestA()
    {
        System.out.println("TestA1");
    }

    public TestA(Double... d)
    {
        System.out.println("TestB2 " + (Arrays.toString(d)));
    }
}

class TestB
{
    private TestB()
    {
        System.out.println("TestB1");
    }

    public TestB(Double[] d)
    {
        System.out.println("TestB2 " + (Arrays.toString(d)));
    }
}

案例2的一个特定用例是Java中的单例模式。

---

请参阅：

您可以在该类的任何方法中使用私有构造函数（即使该方法是静态的）

创建

testA

使用

testA（双d）

构造函数。

Double…

varargs允许传递零个或多个参数

public class Main
{
    private Main()
    {
        System.out.println("Main1");
    }

    public Main(Double[] d)
    {
        System.out.println("Main1 " + (Arrays.toString(d)));
    }

    public static void main(String[] args)
    {
        TestA testA = new TestA(); //match to TestA(Double... d) with zero args
//      TestB testB = new TestB(); //ERROR don't match to TestB(Double[] d)
        Main main = new Main(); //you can use private constructors in class
    }
}

class TestA
{
    private TestA()
    {
        System.out.println("TestA1");
    }

    public TestA(Double... d)
    {
        System.out.println("TestB2 " + (Arrays.toString(d)));
    }
}

class TestB
{
    private TestB()
    {
        System.out.println("TestB1");
    }

    public TestB(Double[] d)
    {
        System.out.println("TestB2 " + (Arrays.toString(d)));
    }
}

输出：

---

您可以在该类的任何方法中使用私有构造函数（即使该方法是静态的）

创建

testA

使用

testA（双d）

构造函数。

Double…

varargs允许传递零个或多个参数

public class Main
{
    private Main()
    {
        System.out.println("Main1");
    }

    public Main(Double[] d)
    {
        System.out.println("Main1 " + (Arrays.toString(d)));
    }

    public static void main(String[] args)
    {
        TestA testA = new TestA(); //match to TestA(Double... d) with zero args
//      TestB testB = new TestB(); //ERROR don't match to TestB(Double[] d)
        Main main = new Main(); //you can use private constructors in class
    }
}

class TestA
{
    private TestA()
    {
        System.out.println("TestA1");
    }

    public TestA(Double... d)
    {
        System.out.println("TestB2 " + (Arrays.toString(d)));
    }
}

class TestB
{
    private TestB()
    {
        System.out.println("TestB1");
    }

    public TestB(Double[] d)
    {
        System.out.println("TestB2 " + (Arrays.toString(d)));
    }
}

输出：

---

“可能是java[sic]或eclipse[sic]bug”的可能重复-嗯，是的，你永远不会有这种情况。最好从调试工具包中永久删除该推测。这只是一厢情愿的神奇想法。可能是“可能是java[sic]或eclipse[sic]bug”的复制品-嗯，是的，你永远不会有这种情况。最好从调试工具包中永久删除该推测。那只是一厢情愿的神奇想法。我可以相信那就是关于。。。试试看，你不能通过

Main m=new Main（）创建对象。您将使用另一个构造函数并传入一个
Double
数组。您尝试了吗？创建一个像我刚写的那样的模型和另一个带有
publicstaticvoidmain（String[]args）{
的类，然后自己试试……也许这只是我的eclipse……在你的问题中，你说的是“你无法创建和对象main m=newmain（）；”这正是它应该是什么样子。那么你想说什么呢？因为在案例1中，你的第二个构造函数是公共的，并且它的参数数量可变。所以当你使用
Main m=new Main（）创建一个对象时
您实际使用的是第二个公共构造函数，并且您传递的参数为零。我可以说，这就是所有关于…尝试使用urself您无法通过
Main m=new Main（）创建对象；
。您将使用另一个构造函数并传入一个
双
数组。您是否尝试过？创建一个像我刚刚编写的那样的模型，并创建另一个带有
公共静态void main（String[]args）{
的类，然后自己尝试一下……也许这只是我的eclipse……在您的问题中，您是这么说的“您无法创建和对象Main m=new Main（）；”，这正是它应该的样子。那么您想说什么呢？因为案例1中的第二个构造函数是公共的，并且它具有可变数量的参数。所以当您使用
Main m=new Main（）创建对象时
您实际上使用的是第二个公共构造函数，并且传递的参数为零。