请大神讲一下什么叫单例设计模式，最好举个例子，谢谢

单例设计模式学前基础视屏有讲啊你可以去看看，第一阶段，第六天的最后两个视频就是说单例设计模式的

http://www.itheima.com/main/service/javacourse.shtml    在下面的那个没有基础的学习方案中

单例模式就是用的private，如果不用private，外面程序可以new多个对象，那就不是单例了

当有private时，如果new的话直接报错，利用getInstance获取两次都是同一个对象，地址值一样：

1.     public class Test5 {
   
2.             public static void main(String[] args) {
   
3.                     System.out.println(Single.getInstance());
   
4.                     System.out.println(Single.getInstance());
   
5.                     }
   
6.             }
   
7.     class Single
   
8.     {
   
9.             private Single(){}
   
10.             private static Single s = null;
    
11.             public static Single getInstance()
    
12.             {
    
13.                     if(s==null)
    
14.                             s = new Single();
    
15.                     return s;
    
16.             }
    
17.     }
    
18.     /*结果如下：
    
19.     com.itheima.Single@290fbc
    
20.     com.itheima.Single@290fbc
    
21.     * */

复制代码

编写一个延迟加载的单例设计模式


public class Test8{
   
        static class People{
                private String name;
                private String sex;
                private int age;
                //构造方法私有化，只能子在本类中对此类进行实例对象，
                //在其他的类中不能对类进行实例化，然后通过创建方法返回在本类中实例的对象。这就是单例设计模式。
                private People(String name,String sex,int age)
                {
                        super();
                        this.name=name;
                        this.sex=sex;
                        this.age=age;
                }
               
                public People()
                {
                       
                }
                        public static People p=null;
                        //首先给声明一个对象，，但是实例化，给其一个空值。
            public static People getPeople(){
                    synchronized (People.class){
                            if(p==null){
                                    p=new People();
                                    //在方法中对声明的对象，进行实例化，在判断条件成立的前提下。只要类一加载，
                                    //对象不会实例化，必须调用获得对象的方法才能实例化此对象，这就是延迟加载。
                            }
                    }
                    return p;
            }
            public String toString()
            {  
                    return "姓名："+name+"      性别： "+sex+"      年龄： "+age;  
            }
        }
       
        public static void main(String[] args)
        {  
            
                People p1=People.getPeople();  
                People p2=People.getPeople();  
                People p3=People.getPeople();  
            
                p1=new People("王五","男",22);
                p2=new People("赵敏","女",20);
                p3=new People("张三","男",21);
            
            
            
                System.out.println(p1);   
                System.out.println(p2);  
                System.out.println(p3);  
   
        }  
}

保证对象唯一性。

一共三步：
1.将构造函数私有化。
2.在类中创建一个本类对象。
3.提供一个方法可以获取该对象

一句话, 在类内部建立自己的对象且提供对外访问的方法

单例简单来说就是无法直接创建对象

java模式之单例模式:
单例模式确保一个类只有一个实例，自行提供这个实例并向整个系统提供这个实例。
特点:
1，一个类只能有一个实例
2，自己创建这个实例
3，整个系统都要使用这个实例
例: 在下面的对象图中，有一个"单例对象"，而"客户甲"、"客户乙" 和"客户丙"是单例对象的三个客户对象。可以看到，所有的客户对象共享一个单例对象。而且从单例对象到自身的连接线可以看出，单例对象持有对自己的引用。

Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。在很多操作中，比如建立目录 数据库连接都需要这样的单线程操作。一些资源管理器常常设计成单例模式。
外部资源:譬如每台计算机可以有若干个打印机，但只能有一个Printer Spooler,以避免两个打印作业同时输出到打印机中。每台计算机可以有若干个通信端口，系统应当集中管理这些通信端口，以避免一个通信端口被两个请求同时调用。内部资源，譬如，大多数的软件都有一个(甚至多个)属性文件存放系统配置。这样的系统应当由一个对象来管理这些属性文件。

一个例子:Windows 回收站。
在整个视窗系统中，回收站只能有一个实例，整个系统都使用这个惟一的实例，而且回收站自行提供自己的实例。因此，回收站是单例模式的应用。

两种形式:
1，饿汉式单例类
public class Singleton {

private Singleton(){}

//在自己内部定义自己一个实例，是不是很奇怪?
//注意这是private 只供内部调用

private static Singleton instance = new Singleton();

//这里提供了一个供外部访问本class的静态方法，可以直接访问
public static Singleton getInstance() {
return instance;
}
}

2，懒汉式单例类

public class Singleton {

private static Singleton instance = null;

public static synchronized Singleton getInstance() {

//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次

//使用时生成实例，提高了效率!
if (instance==null)
instance=new Singleton();
return instance; }

}

第二中形式是lazy initialization，也就是说第一次调用时初始Singleton，以后就不用再生成了。

8l说的最简单易懂，11l说的详细，lz看看吧

正解都在里面有。

只允许创建一个对象，所有人都是在对这个对象进行操作

多看视频

楼主，被版主发现问这种基础视频里边讲得很清楚的问题可能扣分的哦~~~，去复习一下视频吧

学习一下

想让对象保持唯一。
私有构造方法后在内部创建对象，并用一个该类引用指向这个对象。
对外提供的方法是返回该引用变量，等同于返回该对象的内存地址。

具体例子就不知道了，先这么理解

分享快乐 赞一个

看视频学习