一般对于构造函数都是public的，但是加了private进行私有化，它的作用、意义是什么呢？我觉得public也挺好的呀

这个很好理解的！

举个例子：
在商场里的衣服，对所有的客户来说都是 public
想试穿就试穿，对吧！
可是，你付过款以后， 这个衣服对你来说就是给它加了 private
其他想买这款衣服的人想试穿你买的这个衣服，
是不是可以很随意的试穿？肯定不是吧！

同样道理，一个函数，前面 加了 private  就是说这是私有的！

存在便是有道理。。

如果只有一个构造方法，并且用了private修饰，则不能用new+构造函数来创建对象

当然限于在本类以外new哈~

让我们不能轻易new对象.想new对象就必须通过你定义的类中的方法new,下面是列子

1. class WonderfulClass
   
2. 
   
3. {
   
4. 
   
5. public:
   
6. 
   
7. static WonderfulClass* makeAnObject()
   
8. 
   
9. {
   
10. 
    
11. // 创建一个WonderfulClass对象并返回其指针
    
12. 
    
13. return (new WonderfulClass);
    
14. 
    
15. }
    
16. 
    
17. private:
    
18. 
    
19. WonderfulClass() { }
    
20. 
    
21. };
    
22. 
    
23. int main()
    
24. 
    
25. {
    
26. 
    
27. WonderfulClass *p = WonderfulClass::makeAnObject();
    
28. 
    
29. ... // 使用*p
    
30. 
    
31. delete p;  // Not neccesary here, but it's a good habit.
    
32. 
    
33. return 0;
    
34. 
    
35. }
    
36. 
    
37. 如果想要new对象的话就可以利用类中自己定义的静态方法...呵呵
    

复制代码

为了防止其他程序过多建立本类对象，比如毕老师讲的单例设计模式，你再去看看

1. class Single
   
2. {
   
3. 
   
4. 
   
5.         private  Single(){}
   
6. 
   
7.         private static Single s = new Single();
   
8. 
   
9.         public static  Single getInstance()
   
10.         {
    
11.                 return s;
    
12.         }
    
13. }
    
14. 
    
15. 
    
16. class SingleDemo
    
17. {
    
18.         public static void main(String[] args)
    
19.         {
    
20.                 Single s1 = Single.getInstance();
    
21.                 Single s2 = Single.getInstance();
    
22.                                System.out.println(s1==s2);//其实s1和s2指向的都是同一个对象
    
23. 
    
24. 
    

复制代码

构造函数，先不说其它，就字面意思，就是说：勾画建造的函数。
在类中，构造函数 所做的事情就是初始化这个类（对象）。
比方说：
一个银行账户的类，这个对象，在新建的时候，帐号金额初始化=0；
如果，这个初始化的函数（也就是构造函数），如果不私有化，
那其他人可以随意更改，这样那个程序员不小心修改了，初始化=10000000。
这样银行就要出问题了。

如果私有化了：
构造函数都私有化了，你还能直接创建这个对象吗？
这样就可以起到一个作用，限制别人随意的创建对象！

私有的话，就是不让new 对象了，只能调用getIntance() 方法。
参考单例设计模式
class Single{
        private int num;
        public void setNum(int num){
                this.num = num;
        }
        
        public int getNum(int num){
                return num;
        }
        
        private Single(){}
        
        private static Single s=new Single();
        
        public static Single getIntance(){
                return s;
        }
}
public class SingleDemo {

        

        /**
         * @param args
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                //Single ss = Single.getIntance();
                //Single s1 = new Single();
                //Single s2 = new Single();
                //s1.setNum(30);
                //System.out.println(s2.getNum(0));
                Single s1 = Single.getIntance();
                Single s2 = Single.getIntance();
                s1.setNum(23);
                System.out.println(s2.getNum(0));
        }

}

构造函数私有化主要是为了防止外部随意的创建本类对象
我所了解的有两个方面
1、这个类中都是静态方法 静态变量  根本不需要new对象 即可以直接调用
2、这个类只希望自己这一生  只被创建对象一次 即单例设计模式
class Single{
              //懒汉式
        private Single(){}
        
        private static Single s=null        
        public static Single getIntance(){
        if(s==null){
         synchronized{
        if(s==null)
                return s;
                        }
                    }
        }
}
比如说一个命令行的颜色配置 当你背景配置成红色  以后再打开命令行的时候  命令一直都是红色 即系统中就这一个对象 你使用的自始至终都是这一个对象

单例设计模式的应用，构造函数私有化