菜鸡的Java笔记 第二十九 单例设计模式

SingleCase 单例设计模式
        1.单例设计模式的特点
        2.多例设计模式的特点
    内容
    单例设计模式
        现在如果说有这么一个程序类

    class Singleton{
        private SingleCase(){} // 构造方法私有
        public void print(){
            System.out.println("***************");
        }
    }
    // 这个时候程序类给出肯动是直接实例化对象，而后调用方法
    public class SingleCase{
        public static void main(String args[]){
            Singleton inst = null;// 声明对象
            inst = new SingleCase(); // 实例化对象
            inst.print();
        }
    }

           
        在此时的 Singleton 类中一定存在有无参的构造方法，因为自动成的。
        但是构造方法虽然一般都会使用 public 声明，可是也可以使用 private 声明
        当构造方法使用 private 声明之后 程序执行就会出错
        因为此时构造方法被私有化了，所以我无法从外部进行构造方法的调用
        那么现在在保证构造方法与 print() 方法都不做任何修改的前提下，要求通过一些适当的 Singleton 变化让类外部可以得到 Singleton 类的实例化对象，并且调用 print() 方法
        于是有了以下的分析：
        分析一：现在程序的关键是在于构造方法上使用了 private （private SingleCase(){} // 构造方法私有了），那么对于 private 的特点是只能够在本类中进行访问
        那么现在换一个思路：能不能说在本类准备好一个实例化对象呢？

    class Singleton{
        Singleton instance = new Singleton
        private SingleCase(){} // 构造方法私有
        public void print(){
            System.out.println("***************");
        }
    }
    // 这个时候程序类给出肯动是直接实例化对象，而后调用方法
    public class SingleCase{
        public static void main(String args[]){
            Singleton inst = null;// 声明对象
            
        }
    }

        分析二：此时内部声明的 instance 属性属于一个普通属性，那么普通属性有一个前提：在实例化对象后才可以调用，但是现在外部无法实例化对象
        那么就考虑使用 static ，因为 static 不受到实例化对象的控制

    class Singleton{
        static Singleton instance = new Singleton
        private SingleCase(){} // 构造方法私有
        public void print(){
            System.out.println("***************");
        }
    }
    // 这个时候程序类给出肯动是直接实例化对象，而后调用方法
    public class SingleCase{
        public static void main(String args[]){
            Singleton inst = null;// 声明对象
            inst = Singleton.instance;
            inst.print();
        }
    }

        分析三：强调过只要是类中的属性都是应该进行 private 封装，所以以上代码中 instance 属性也应该进行封装
        那么一旦封装了，就必须通过方法访问，按照此时要访问的是 static 属性，并且类无法直接在外部产生实例化对象，那么就编写一个 static 方法

    class Singleton{
        private static Singleton instance = new Singleton();
        private SingleCase(){} // 构造方法私有
        public static Singleton getlnstance(){
            return instance;
        }
        public void print(){
            System.out.println("***************");
        }
    }
    // 这个时候程序类给出肯动是直接实例化对象，而后调用方法
    public class SingleCase{
        public static void main(String args[]){
            Singleton inst = null;// 声明对象
            inst = Singleton.getlnstance();
            inst.print();
        }
    }

           
        分析四：这么写代码折腾一圈最终目的还是在外部使用实例化对象调用方法，那么这种脱裤子放屁的意义在哪里？
            所以这个时候通过内存关系可以发现，不管外部有多少个对象的声明，最终所能产生的实例化对象只有一个
            也就是说本程序限制了实例化对象的产生，只维持了一个
            之所以将构造方法私有就是切断了那么自然无法产生新的实例化对象
            
        分析五：缺陷
        为了保证整个代码在操作的过程之中只会存在有唯一的一个实例化对象，并且不可更改，则可以利用 final 声明
        面试题： 请编写一个 Singleton 程序，并说明程序的主要特点    
            

    class Singleton{
        private static final Singleton INSTNCE = new Singleton();
        private SingleCase(){} // 构造方法私有
        public static Singleton getlnstance(){
    // instance = new Singleton();  这种代码的可能性还是有得 为了不让其出现 加上 final
            return INSTNCE;
        }
        public void print(){
            System.out.println("***************");
        }
    }
    // 这个时候程序类给出肯动是直接实例化对象，而后调用方法
    public class SingleCase{
        public static void main(String args[]){
            Singleton inst = null;// 声明对象
            inst = Singleton.getlnstance();
            inst.print();
        }
    }

           
        构造方法私有化，外部无法产生新的实例化对象，只能够通过类提供的 static 方法取得唯一的一个对象的引用
        对于单例设计模式有两类：饿汉式（以上的代码），懒汉式
            饿汉式：不管程序中是否有对象需要使用此类，那么此类的对象都实例化好；
            懒汉式：在第一次使用的时候才进行实例化
        范例：观察懒汉式

    class Singleton{
        private static Singleton instance;
        private SingleCase(){} // 构造方法私有了
        public static Singleton getlnstance(){
            if(instance == null){
                instance = new Singleton(); // 需要的时候进行实例化
            }
            return instance;
        }
        public void print(){
            System.out.println("***************");
        }
    }
    // 这个时候程序类给出肯动是直接实例化对象，而后调用方法
    public class SingleCase{
        public static void main(String args[]){
            Singleton inst = null;// 声明对象
            inst = Singleton.getlnstance();
            inst.print();
        }
    }

           
            这两个分类只是一个小小的概念，关键 还是将之前的单例设计模式编写熟练
                
    多例设计模式
        不管是单例设计还是多例设计，本质就一个：构造方法私有化，内部产生实例化对象，只不过单例设计只产生一个，多例设计不产生多个
        例如：现在要求描述一周时间数的类，只能够有七个对象
        例如：要求描述性别的类，只能有两个
        范例：性别的描述

    class Sex{
        public static final int MALE_CH = 1;
        public static final int FEMALE_CH = 1;
        private static final Sex MALE = NEW Sex("男");
        private static final Sex FEMALE = NEW Sex("女");
        private String title;
        private Sex(String title){
            this.title;
        }
        public static Sex getlnstance(int ch){
            switch(ch){
                case MALE_CH:
                    return MALE;
                case FEMALE_CH:
                    return FEMALE;
                dafault:
                    return null;
            }
        }
        public String toString(){
            return this.title;
        }
    }
    public class SingleCase{
        public static void main(String args[]){
            Sex sex = Sex.getlnstance(Sex.MALE_CH);
            System.out.println(sex);
        }
    }

           
            多例只是单例的一种衍生品，本质上没有区别
            
    总结
        1.对于单例设计模式，多例设计模式更希望理解它设计的出发点：限制对象产生
        2.程序的基本结构必须要记下