27、单例设计模式

系统管理员 2024-04-01 19:18 64阅读 0赞

一、什么是设计模式：

1、静态方法和属性的经典使用

2、设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。（类似于棋谱）

二、什么是单例（单个的实例）设计模式：

1、即采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例(只能有一个女朋友)，并且该类只提供一个取得其对象实例的方法

2、单例模式有两种方式：

（1）饿汉式：*（你的女朋友已经在了，但是她还不归你）*

创建了对象，但是没有用，可能造成资源的浪费

package singleton;
    public class SingleTon01 {
        public static void main(String[] args) {
            GirlFriend instance=GirlFriend.getInstance();
            System.out.println(instance);
    
            GirlFriend instance2=GirlFriend.getInstance();
            System.out.println(instance2);
    
            System.out.println(instance==instance2);
            //输出：
            //GirlFriend{name='小红红'}
            //GirlFriend{name='小红红'}
            //true
        }
    }
    class GirlFriend{
        private String name;
        //2、在类的内部直接创建一个对象，为了能在静态方法中用，要修饰为static
        private static GirlFriend gf=new GirlFriend("小红红");
        //1、为了保障我们只能创建一个GirlFriend对象，所以把构造器public-->private私有化
        private GirlFriend(String name){
            this.name=name;
        }
        //3、提供一个公共的static方法，返回gf对象
        public static GirlFriend getInstance(){
            return gf;
        }
    
        @Override
        public String toString() {
            return "GirlFriend{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

（2）懒汉式：（用时再建）

只有当用户使用getInstance时，才返回cat对象，后面再次调用时，会返回上次创建的cat对象，从而保证了单例

package singleton;
    
    public class SingleTon02 {
        public static void main(String[] args) {
            System.out.println(Cat.n1);
            //输出：99
            //并没有调用构造器
    
            Cat instance=Cat.getInstance();
            System.out.println(instance);
            //输出：
            //构造器被调用……
            //Cat{name='小可爱'}
    
            //再次调用getInstance时，cat对象不再为空
            Cat instance2=Cat.getInstance();
            System.out.println(instance2);
            //输出：Cat{name='小可爱'}
    
            System.out.println(instance==instance2);//true
        }
    }
    class Cat{
        private String name;
        public static int n1=99;
        //2、定义一个static静态属性对象
        private static Cat cat;
        //1、构造器私有化
        private Cat(String name) {
            System.out.println("构造器被调用……");
            this.name = name;
        }
        //3、提供一个public的static方法，可以返回一个Cat对象
        public static Cat getInstance(){
            if(cat==null){//如果还没有创建对象
                cat=new Cat("小可爱");
            }
            return cat;
        }
        @Override
        public String toString() {
            return "Cat{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

（3）步骤如下：

1）构造器私有化（防止直接new）

2）类的内部创建对象

3）向外暴露一个静态的公共方法

4）代码实现

（4）两者比较：

1）二者最主要的区别在于创建对象的时机不同：饿汉式是在类加载就创建了对象实例，而懒汉式是在使用时才创建

2）饿汉式不存在线程安全问题，懒汉式存在线程安全问题

3）饿汉式存在浪费资源的可能，因为如果程序员一个对象实例都没有使用，那么懒汉式创建的对象就浪费了，懒汉式是使用时才创建，就不存在这个问题

4）在我们javaSE标准类中，java.lang.Runtime就是经典的单例模式