单例设计模式-23

1.补充
当有一个类定义完整之后，如果要使用这个类，肯定要通过构造方法产生实例化对象，而后进行类之中方法的调用
范例：观察一段代码
package listen;
class Singlention{
public void print() {
System.out.println("Hello World .");
}
}
public class Listena {
public static void main(String[] args) {
Singlention sin=null;//声明对象
sin=new Singlention();//实例化对象
sin.print();//对象调用类中的方法
}
}
在Singlention有默认的无参构造方法
public Singlention(){}
但是把这个构造方法的声明修改一下
private Singlention() {}


package listen;
class Singlention{
private Singlention() {}
public void print() {
System.out.println("Hello World .");
}
}
public class Listena {
public static void main(String[] args) {
Singlention sin=null;//声明对象
sin=new Singlention();//实例化对象
sin.print();//对象调用类中的方法
}
}
本程序现在使用关键字new实例化对象时候发生了错误，因为构造方法对外不可见，就是构造方法私有化了，
请问保证构造和print（）方法都不变的情况下，在Singlention类之中应该加入哪些操作，才可以让外部类取得Singlention类的实例化对象，并且调用print()方法？
分析：
1.此时的构造方法就私有化了，那么私有化的访问范围是：本类之中，即只能够在本类之中调用Singlention类的构造：在本类里面增加一个属性：
Singlention instance=new Singlention();
2.但是这个时候的instance只是一个普通属性，而普通属性只有在一个类的实例化对象产生之后才可以调用，可是Singlentio类的构造方法是私有的
，外部无法产生实例化对象，那么就必须要想办法把现在的instance这个属性变为一个不需要实例化对象控制的结构，那么自然使用static关键字
package listen;
class Singlention{
static Singlention instance=new Singlention();
private Singlention() {}
public void print() {
System.out.println("Hello World .");
}
}
public class Listena {
public static void main(String[] args) {
Singlention sin=null;//声明对象
sin=Singlention.instance;//实例化对象
sin.print();//对象调用类中的方法
}
}
3.但是对于类之中的属性都应该采用封装的形式出现，所以对于instance这个属性页一定要进行封装，那么封装之后的属性需要编写相关的setter,getter设置和取得，
按照本程序的结构，只需要一个getter即可，而且这个方法页应该不受Singlention类实例化对象的控制，可以由类名称直接调用，那么就使用static方法（static方法只能够调用static属性和方法）
package listen;
class Singlention{
private static Singlention instance=new Singlention();
private Singlention() {}
public void print() {
System.out.println("Hello World .");
}
public static Singlention getInstance() {
return instance;
}
}
public class Listena {
public static void main(String[] args) {
Singlention sin=null;//声明对象
sin=Singlention.getInstance();//实例化对象
sin.print();//对象调用类中的方法
}
}
那么此时的程序之中由于instance这个属性使用了static定义，那么就表示其是一个公共属性，而且发现所有外部取得的Singlention类的实例化对象，
不管由多少个对象，最终也只是取得了一个Singlention类实例。那么此时就达到了一个控制实例化对象产生个数的操作。
如果说现在要想控制一个实例化对象产生的个数，首先要控制构造方法调用，因为每调用一次构造方法，都会产生一个新的实例化对象，如果讲构造方法卡死了，就无法产生新的了。
在一些为了某些功能，往往只希望一个类只产生唯一的一个实例化对象。采用以上的形式。但是，要想唯一的一个，以上的代码还有问题。
将private static Singlention instance=new Singlention();加上final
private final static Singlention INSTANCE=new Singlention();
面试题：请编写Singlention（单例设计模式）程序，并说明它的主要特点？
package listen;
class Singlention{
private final static Singlention INSTANCE=new Singlention();
private Singlention() {}
public void print() {
System.out.println("Hello World .");
}
public static Singlention getInstance() {
return INSTANCE;
}
}
public class Listena {
public static void main(String[] args) {
Singlention sin=null;//声明对象
sin=Singlention.getInstance();//实例化对象
sin.print();//对象调用类中的方法
}
}
特点：类中的构造方法私有化，让外部无法调用，只能够通过类内部产生实例化对象，并且利用static方法返回。这样一来无论外部有多少个类对象声明，那么最终也只是开辟一块内存空间，只有一个实例化对象。


单例，工厂，代理（重点）
多例设计模式
例如：一周时间数的对象有七个，表示颜色基色的类只能有三个对象，性别的类只能有两个。
package listen;
class Color{
private String title;
private static final Color RED=new Color("红色");
private static final Color GREEN=new Color("录色");
private static final Color BLUE=new Color("蓝色");
private Color(String title) {
this.title=title;
}
public String toString() {
return this.title;
}
public static Color getInstance(int ch) {
switch(ch) {
case 0:
return RED;
case 1:
return GREEN;
case 2:
return BLUE;
default :
return null;
}
}
}
public class Listenb {
public static void main(String[] args) {
// TODO Auto-generated method stub
Color red=Color.getInstance(2);
System.out.println(red);
}
}
不管单还是多，本质只是一个，要想控制实例化对象产生格式，先控制构造方法。