public class DanLiMoShi {
// 单例设计模式：保证一个类只有一个对象，提供一个访问他的全局访问点
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// 使用类名 调用方法，获取对象实例
Ehanshi s1 = Ehanshi.getInstence();
System.out.println(s1.print());
Lanhanshi l1=Lanhanshi.getInstance1();
l1.print1();
}
}
// 饿汉式
// 饿汉式呢，饿得慌，一出来就new对象
class Ehanshi {
// 在自己内部定义自己一个实例
// 注意这是private 只供内部调用
private static Ehanshi e = new Ehanshi();
// 如上面所述，将构造函数设置为私有
private Ehanshi() {
}
// 静态工厂方法，提供了一个供外部访问得到对象的静态方法:共有的
public static Ehanshi getInstence() {
return e;
}
public String print() {
return "饿汉式------单例设计模式";
}
}
// 懒汉式----就是懒啊，，啥时候用就啥时候实例化
class Lanhanshi {
private static Lanhanshi l = null;
private Lanhanshi() {
}
public static Lanhanshi getInstance1() {
if (l == null) {
l = new Lanhanshi();
}
return l;
}
public void print1(){
System.out.println("懒汉式----------单例设计模式");
}
}
举例分析
package com.vince.lei;
public class ShiLi_046 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("创建皇帝1对象");
Emperor emperor1 = Emperor.getInstance();
emperor1.print();
System.out.println("创建皇帝2对象");
Emperor emperor2 = Emperor.getInstance();
emperor2.print();
System.out.println("创建皇帝3对象");
Emperor emperor3 = Emperor.getInstance();
emperor3.print();
System.out.println("-----------------------------");
System.out.println("创建皇帝对象");
Em em1 = Em.getInstance1();
System.out.println(em1.print1());
}
}
// 饿汉式----实现
class Emperor {
private static Emperor emperor = new Emperor();// 实例化Emperor类的对象
private Emperor() { // 构造函数私有化
}
// 对象的引用变量实例化：对象实例化
public static Emperor getInstance() {
return emperor;
}
public void print() {
System.out.println("我是皇帝：明日科技");
}
}
// 懒汉式-----太懒了，，你说怎么办呢
// 哈哈
class Em {
private static Em em = null; // 声明Em类对象的引用变量
private Em() {
}
public static Em getInstance1() {
if (em == null) {
em = new Em(); // 实例化对象
}
return em;
}
public String print1() {
return "我是皇帝：明日科技";
}
}
package com.vince.shejimoshi;
//单例设计模式：保证一个类只有一个实例，并且提供一个访问该类的全局访问点（就是一个静态方法）
//使用单例设计模式目的：控制一个类只有一个实例对象
//1.懒汉式(在多线程访问的时候会出现安全问题) 不建议使用
//2.饿汉式------建议使用
public class DanLiLianXi {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// 通过类名.静态方法 获取对象
System.out.println(" 饿汉式-----饿得慌啊");
Emperor em = Emperor.getInstance();
em.print();
System.out.println(" 懒汉式-----懒啊，什么时候需要，我就什么时候创建");
Emperor1 em1=Emperor1.getInstance1();
em1.print();
}
}
// 饿汉式-----饿得慌啊
class Emperor {
// 懒汉式---饿得慌呢--一出来就new 对象实例
private static Emperor emperor = new Emperor();
// 构造函数私有化
private Emperor() {
}
// 提供给外部访问该类的静态方法获取该类的对象
public static Emperor getInstance() {
return emperor;
}
// 定义一个方法，，输出点啥呢
public void print() {
System.out.println("我是汉武帝，，哈哈");
}
}
// 懒汉式-----懒啊，什么时候需要，我就什么时候创建
class Emperor1 {
private static Emperor1 emperor1 = null;
private Emperor1() {
}
public static Emperor1 getInstance1() {
if (emperor1 == null) {
emperor1 = new Emperor1();// 创建对象啊
}
return emperor1;
}
// 定义一个方法，，输出点啥呢
public void print() {
System.out.println("我是邦大帝，，哇哈哈");
}
}
