java 为什么有时一个类有多个构造函数
https://blog..net/qq_14989227/article/details/79550607
关于 Java 的静态工厂方法，看这一篇就够了！
https://www.jianshu.com/p/ceb5ec8f1174
单例模式？
https://bbs..net/topics/390753067
而且这种私有构造方法是怎么保证只能创建一个对象的呢？
首先回答这个问题，说白了，定义私有的构造方法就是为了防止new对象，new一个对象会在内存为其分配地址等等，所以说每次new的都是新对象，每个新new的对象都是不相同的。
单例模式只能创建一个对象，我看不出这个对象是什么时候创建的。
通过调用这个类的静态方法，返回instance变量，而instance变量在类初始化的时候就被赋值new Singleton()，所以是在类初始化的时候创建的对象。
是在Singleton.getInstance()这样调用的时候吗？那么岂不是每次使用Singleton.getInstance()都创建了一个对象
类只会初始化一次，所以每次调用静态方法得到的都是同一个对象，这就是单例。

题目：写一个只能构造一个对象的类
整理：CmdHack
时间：2010年1月24日19:47:49
 
分析：
       构造函数分为有参构造 无参构造 拷贝构造 三种方法
 
       对象又分为栈中构造对象和堆中构造对象
 
   首先来按照普通的做法写一个类如下
class OnlyObj  
{
public:
	OnlyObj();
	~OnlyObj();

};


很显然如果单单这样可以构造无数个对象   那我设想一下如果在构造函数中做一个
限制比如 构造一个对象之后  如果产生第二个对象就将其删除如何呢
一：delete this (只对堆中的对象起作用) 
二：用个静态变量做次数限制 如果产生一个对象之后再产生对象立刻调用析构函数
（如果是在栈中产生的对象  那么这个变量的生死存亡只有由系统决定即 显示
调用析构函数没有任何效果，  当然如果是在堆中产生的对象可以在析构函数
中使用delete this  显示调用析构函数可以删除对象）
所以如果构造函数属于Public 的话我们是没有办法只产生一个对象的

 


====
那么只有将构造函数的放在private:中了
那如果是private怎么来调用构造函数构造对象呢  成员函数么  当然不是了 
成员函数的调用约定是_thiscall  没有对象怎么调用呢   那只有用刚刚学过的静态成员函数（_cdecl调用约定） 没有对象也可以调用  然后再用静态成员变量来做个数限制   具体实现过程如下
// homework4.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream.h>

//写一个只能有一个实例的类。
class Only
{
private:
  //不让对象在栈中直接定义
  Only()
  {
    m_i = 0;
    m_nCount++;
  }
  Only( int i )
  {
    m_i = i;
    m_nCount++;
  }
  ~Only()
  {
    if ( m_nCount>0 )
    {
      m_nCount--;
    }
  }
  int m_i;
  static int m_nCount;
public:
  static Only* CreateObject(int i);
  static Only* CreateObject();
  void Print()
  {
    if ( this )
    {
      if ( m_nCount == 1 )
      {
        cout << this << "    " << m_i << endl;
      }
    }
  }
  void Release()
  {
     delete this;
  }
};

int Only::m_nCount = 0;

//静态成员函数，是类内的函数，可以访问私有成员/函数
Only* Only::CreateObject(int i)
{
    Only *pRet = NULL;

    if ( m_nCount == 0 )
    {
      pRet = new Only(i);
    }
    return pRet;
}
Only* Only::CreateObject()
{
    Only *pRet = NULL;

    if ( m_nCount == 0 )
    {
      pRet = new Only();
    }
    return pRet;
}
int main(int argc, char* argv[])
{
   Only* pOnly1 = Only::CreateObject();

   Only* pOnly = Only::CreateObject(10);
    
   pOnly->Print();

   pOnly->Release();

   pOnly->Print();

	 return 0;
}

单例设计模式：

单例设计模式就是保证某个类的实例有且只能有一个不能随意创建实例。例如：我们只有一个地球，地球类的实例只能创建一个。

1、为了阻止类实例的new创建，可以做一个private的构造函数。

2、既然不能从外部使用new进行实例的创建，就从类内部进行实例的创建，为此可以提供一个静态方法和一个要创建的私有全局类实例变量。

3、静态方法实现如下：

/// <summary>
    /// 单例模式
    /// </summary>
    public class SingleC
    {

// 定义一个标识确保线程同步
        private static readonly object locker = new object();
 // 定义一个静态变量来保存类的实例
        private static SingleC uniqueCInstance;
        // 定义私有构造函数这样外界不能创建该类实例
        private SingleC()
        {
        }

        /// <summary>
        /// 定义公有方法提供一个全局访问,也可以定义公有属性来提供全局访问
        /// </summary>
        /// <returns></returns>
        public static SingleC GetCInstance()
        {

if (uniqueCInstance== null)
            {
                lock (locker)
                {
            // 如果类的实例不存在则创建，否则直接返回
            if (uniqueCInstance== null)
            {
                uniqueCInstance= new SingleC();
            }
}
}
            return uniqueCInstance;
        }
    }

4、上例中使用了lock锁，防止多线程同时调动时if (uniqueCInstance== null)都可以通过，如果都可以就会有两次实例的创建动作。第一个if (uniqueCInstance== null)是为了一旦实例被创建了就不需要再使用lock阻止因多线程导致多个实例出现。

大神们不喜勿喷，仅作为自我学习笔记！！！

 

public class Test{
    private int x;
    private String s;
    public Test(int x) {
        this.x = x;
    }
    public Test(int x, String s) {
//调用自身的构造方法，这种写法只能存在于构造方法中，有且只能有一个，在此构造方法中必须写在其他语句之前
        this(x);
        this.s = s;
    }
}
1.上面注释的是我觉得大家最容易忘记的this功能
2.this就是指向当前对象了，这个容易理解和掌握
3.匿名类或内部类中要调用外部类方法，要使用：外部类名.this.方法名
4.类中可以在将自身对象作为参数时使用this。




this与static势不两立，因为static跟具体对象没关系，this就是具体对象的引用。

一个构造方法中要调用另外一个构造方法，不能通过名字来调用，必须通过this（XXX）来调用。