Java 构造结构私有化

Java 构造结构私有化

单例设计模式：（Singleton）

在一般情况下，一个类只有通过产生对象之后才可以操作这个类。

class Singleton {

public void print() {

System.out.println("Hello,world!") ;

}

}

public class TestDemo {

public static void main(String [] args) {

Singleton s = null ;  //声明对象

s = new Singleton() ; //实例化对象

s.print() ;

}

}

在Singleton类中，实际上存在构造方法【Java规定，没有定义一个构造的化，Javac编译后会自动生成一个无参构造方法】

class Singleton {

private Singlenton() { } //构造方法私有化

public void print() {

System.out.println("Hello,world!") ;

}

}

public class TestDemo {

public static void main(String [] args) {

Singleton s = null ;  //声明对象

s = new Singleton() ; //实例化对象

s.print() ;

}

}

一旦构造方法私有化，在外部将无法直接new实例化对象操作

在构造方法使用private声明，使得构造私有化，无法被外部调用（即无法实例化）；既然无法在外部调用，则可以在类的内容调用；

class Singleton {

Singleton instance = new Singleton() ; //new实例化Singleton对象

private Singlenton() {} //构造方法私有化

public void print() {

System.out.println("Hello,world!") ;

}

}

现在的instance在Singleton里面只是一个普通的类属性，而所有的普通类属性必须在类产生实例化对象之后才可以使用，但是否可以存在一种属性，可以让类属性不受Singleton类的实例化对象的控制；如果使用 static 声明 instance 属性，那么就表示可以在一个类没有产生实例化对象的时候，直接使用该属性

public class TestDemo {

public static void main(String [] args) {

Singleton s = null ;  //声明对象

s = Singleton.instance ; //直接访问static声明的类属性

s.print() ;

}

}

在类定义时，类属性需要进行封装；而一旦封装属性之后，只可以通过getter方法来实现访问属性，由此需要提供一个geter方法不受到类的new实例化控制；可以使用static属性继续声明该方法。

class Singleton {

static Singleton instance = new Singleton() ; //new实例化Singleton对象

private void Singlenton() {

return ;

} //构造方法私有化

public static Singleton getInstance() {

return instance ;

} //方法中返回了static声明不受实例化影响的类属性

public void print() {

System.out.println("Hello,world!") ;

}

}

public class TestDemo {

public static void main(String [] args) {

Singleton s = null ;  //声明对象

s = Singleton.getInstance(); //访问static声明的方法

s.print() ;

}

}

上述代码和public普通（非私有）构造的区别：

上述代码所创建的类，或者创建多个类对象，实际上创建的对象是同一个，因为同一个的那个唯一性的对象是在类中创建的，而外部调用的只不过是类中声明实例化的一个对象而已。

上述代码的意义：

如果需要控制一个类中实例化对象的产生个数，必须将构造给private私有化（锁住类中的构造方法）因为在实例化新对象的时候都要使用构造方法，如果构造方法私有化，自然无法直接产生新的实例化对象，既然只需要一个实例化对象，由此可以在类的内部定义一个公共对象，并且每一次通过static方法返回唯一的一个对象，这样外部不管是多少次的调用，最终的类只能产生唯一的对象，这样的设计属于单例设计模式。

如果在static声明的方法中，返回的不是唯一的实例化对象的类属性，而是在方法中直接返回实例化对象，结果就是，每一个返回的对象都不是唯一的；为了防止这种情况发生，可以在instance类属性定义的时候，定义为 final 属性，加上final属性后，唯一性更加强烈。

完整的单例设计模式Demo：

class Singleton {

private static  final Singleton          INSTANCE = new Singleton() ; //new实例化Singleton对象

private void Singlenton() {

return ;

} //构造方法私有化

public static Singleton getInstance() {

return INSTANCE ;

}

public void print() {

System.out.println("Hello,world!") ;

}

}

public class TestDemo {

public static void main(String [] args) {

Singleton s = null ;  //声明对象

s = Singleton.getInstance(); //访问static声明的方法

s.print() ;

}

}

单例设计模式的特点：

构造方法私有化，在类的内部定义static属性与方法，利用static方法取得本类中的实例化对象，由此，无乱外部产生多少个Singleton对象，但是本质上通过static方法获得的类实例化对象都是同一个（唯一的一个）

         核心目的：让一个在整个系统中只存在一个实例化对象

单例设计的两种形式：

饿汉式：不管是否使用；在定义static的类属性时就直接实例化对象

懒汉式：只有第一次使用的时候，才会实例化操作；在定义static类属性的时候不会实例化对象，而是在第一次调用类属性的时候，if判断类属性是否为null，为null则实例化；

多例设计模式：

多例设计模式可以让一个类产生指定多个实例化对象；例如定义一个表示一周时间数的类，这个类只有七个实例化对象；定义表示性别的类，这个类只能有两个实例对象；

定义表示性别的类：

class Sex {

private String title ;

private static final Sex MALE = new Sex("男") ;

         private static final Sex FEMALE = new Sex("女") ;

private Sex(String title) {

this.title = title ;

}

public String toString() {

return this.title ;

}

public static Sex getInstance(int ch) {

                   switch ( ch ) {

                            case 1 : return MALE ;

                            case 2 : return FEMALE ;

                            default : return null ;              

                   }

}

}

public class TestDemo {

public static void main(String [] args) {

Sex s = null ;  //声明对象

s = Sex.getInstance(2);

System.out.println(s)

}

}

多例设计模式的一个目的：

在一个类中产生多个对象，根据不同的请求，获得不同的实例化对象。

不管设计模式如何，核心就是构造方法私有化！