说能讲讲有关单例的事儿？随便讲讲，因为一点没有接触过，在此先谢过了

单例可以保证系统中只可能由该类的一个对象，而且这个对象由类自行初始化。

单例类一般可以用来抽象系统中一些共享的资源。

单例类有如下特点：

    单例类只有一个实例。

    单例类自行创建并提供这个唯一的实例。

资源管理器一般做成单例模式。譬如每台计算机可以有若干个打印机，但只能有一个打印处理器，以避免两个打印作业同时输出到打印机中。

单例模式有以下的特点：

     单例类只能有一个实例。

     单例类必须自己创建自己的惟一的实例。

    单例类必须给所有其他对象提供这一实例。

饿汉式单例类

Private static final EagerSingleton m_instance=new EagerSingleton();

         Private EagerSingleton(){}

         Public static EagerSingleton getInstance()

    {

       Return m_instance;

    }

l   在这个类被加载时，静态变量 m_Instance会被初始化，此时类的私有构造器会被调用。这时候，单例类的惟一实例就被 创建出来了。
l   Java语言中单例类的—个最重要的特点是类的构造于是私有的，从而避免外界利用构造子直接创建出任意多的实例。
l   值得指出的是，由于构造于是私有的，因此此类不能被继承。

  懒汉式单例类

Public class LazySingleton

{

       Private Static LazySingleton

              m_instance=null;

}

Private LazySingleton(){}

Synchronized public static LazySingleton

       getInstance()

{

       If(m_instance==null)

       {

       m_instance=new LazySingleton();

}

Return m_instance;

}

l  静态工场方法使用了同步化， 以处理多线程环境。
l  单从资源利用效率角度来讲， 这个比懒汉式单例类稍差些
l  从速度和反应时间角度来讲，则比懒汉式单例类稍好。
l  然而，懒汉式单例类在实例化时，必须处理好在多个线程同时首次引用此类时的访问限制问题，特别是当单例类作为资源控制器在实例化时必然涉及资源初始化．而资源初始
化很有可能耗费时问。这意味着出现多线程同时首次引用此类的几率变得较大。


在什么情况使用单例模式

使用单例模式有 一个必要条件：在一个系统要求 一个类只有—个实例时才应当使用单例模式。反过来说，如果一个类可以有几个实例共存．那么就没有必要使用单例类。

单例设计模式：解决问题的方法思想
java中有总结了23种设计模式
介绍单例设计模式：
方法一：称为【饿汉式】
1.为了避免其他程序过多创立对象，禁止该类的对象实例化；
2.在该类内部建立一个private对象
3.提供一个public方法，访问该对象

对应的代码：
1.private People(){}\\将构造函数私有化
2.private static People p1=new People();\\在类中创建一个private对象；
3.public  static People getInstance(return p1){}\\提供一个public函数访问该对象；
*/
/*
方法二：称为【懒汉式】
1.private People（）{}
2.private static People p=null;
3.public static People getInstance()
{
         if(p==null)
                {
                        Synchronized (People.class)//synchronized表示进程锁
                        {
                                if(s==null)
                                        s=new people();
                                return s;
                        }
                }
}
我觉个例子吧 看视频的时候毕老师解释的那样
class SingleDemo
{
        public static void main(String[] args)
        {
                //System.out.println("Hello World!");
                People p1=People.getInstance();
                People p2=People.getInstance();
                System.out.println(p2.getName());
                p1.setName("zhangsan");
                System.out.println(p2.getName());
                /*----------------------------*/

        }
}
class People
{
        private String name;
        public String getName()
        {
                return name;
        }
        public void setName(String name)
        {
                this.name=name;
        }
        private int age;
        private String nation;
        private People(){}
        private static People p=new People();
        public static People getInstance()
        {
                return p;
        }
}
class Student
{
        //private String name;
        private int age;
        public void setAge(int age)
        {
                this.age=age;
        }
        public int getAge()
        {
                return age;
        }
        private Student(){}
        private static Student s=new Student();
        public static Student getInstance()
        {
                return s;
        }
}
其实饿汉式和懒汉式 就是一点区别
因为都是想法设法要程序只能new一个对象，区别在于
当类加载时是否先new对象到内存堆中，
饿汉式直接加载，而懒汉式要调用到getInstance函数时才将实例对象加载到内存
注意一下：
private People（）{}
private static People p=null;
public static People getInstance()
{
         if(p==null)
                {
                        Synchronized (People.class)//synchronized表示进程锁
                        {
                                if(s==null)
                                        s=new people();
                                return s;
                        }
                }
}
这个是懒汉式，值得说的的懒汉式后面为什么要加if，还是两个呢？
这就是涉及到进程同步问题，设想一下
如果第一个进程一次推进到if（s==null）
然后处理机切换到第二个程序 也是判断if（s==null）
接着切换回去这样两个程序都能创建实例了 这就是为什么要用synchronize同步锁了
它可以防止这类情况的产生

简单说就是单例模式能够确保一个类只有一个实例。自行特供这个实例并向整个系统提供这个实例。
单例模式有两种实现方式：一种是将类的构造方法私有化，用一个私有的类变量instance保存类的实例，在加载类时，创建类的实例，并将实例赋给instance；再提供一个公有的静态方法getInstance，用于获取类的唯一实例，该方法直接返回instance。
                       另一种是将类的构造方法私有化，用一个私有的类变量instance保存类的实例，在加载类时，将null赋给instance；再提供一个公有的静态方法getInstance，用于获取类的唯一实例，该方法首先判断instance是否为null，如果为null，则创建实例对象，否则，直接返回instance。

楼上的，他都没学到单例呢，你们这回复 他能看的懂么？？

单例模式主要有3个特点： 1 单例类确保自己只有一个实例。
                        2 单例类必须自己动手创建自己的实例。
                        3 单例类必须为其他的对象提供唯一的实例。

单例有两种方式，1.饿汉式单例  2.懒汉式单例

饿汉式解释：你可以理解为 它在类加载的时候就立即创建对象，由类的加载而加载。
懒汉式解释：你可以理解为 只有需要加载的时候才加载，从来都不提前做准备。当需要对象的时候，才判断自己有没有对象，没有对象的话就立即创建一个，然后返回，如果已经有对象了，那就不在创建，直接返回了。

单例（Singleton） 是一种创建性模型,它用来确保只产生一个实例,并提供一个访问它的全局访问点.对一些类来说,保证只有一个实例是很重要的,比如有的时候,数据库连接或 Socket 连接要受到一定的限制,必须保持同一时间只能有一个连接的存在.再举个例子,集合中的 set 中不能包含重复的元素,添加到set里的对象必须是唯一的,如果重复的值添加到 set,它只接受一个实例.JDK中正式运用了Singleton模式来实现 set 的这一特性,大家可以查看java.util.Collections里的内部静态类SingletonSet的原代码.其实Singleton是最简单但也是应用最广泛的模式之一,在 JDK 中随处可见.

单例：一种设计模式，主要用来保证系统中有且只一个实例对象。

单例模式的意思就是只有一个实例。单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类