.饿汉式单例类
//饿汉式单例类.在类初始化时,已经自行实例化
public class Singleton1 {
//私有的默认构造子
private Singleton1() {}
//已经自行实例化
private static final Singleton1 single = new Singleton1();
//静态工厂方法
public static Singleton1 getInstance() {
return single;
}
//懒汉式单例类.在第一次调用的时候实例化
//注意,这里没有final
if (single == null) {
//对懒汉式单例的改进(错误的改进)
//实际上,只有在第一次创建对象的时候需要加锁,之后就不需要了 ,这样可以提升性能
if (instance == null) {
synchronized(instance){ //锁住当前实例对象
if(instance == null){
return instance;
错误原因：
aA、B线程同时进入了第一个if判断
bA首先进入synchronized块,由于instance为null,所以它执行instance = new Singleton();
c由于JVM内部的优化机制,JVM先画出了一些分配给Singleton实例的空白内存,并赋值给instance成员（注意此时JVM没有开始初始化这个实例）,然后A离开了synchronized块.
dB进入synchronized块,由于instance此时不是null,所以呢它马上离开了synchronized块并将结果返回给调用该方法的程序.
e此时B线程打算使用Singleton实例,却发现它没有被初始化,于是错误发生了.
正确改进（使用内部类）：
JVM内部的机制能够保证当一个类被加载的时候,这个类的加载过程是线程互斥的,JVM能够帮我们保证instance只被创建一次,
并且会保证把赋值给instance的内存初始化完毕,这样我们就不用担心上面的问题.
同时该方法也只会在第一次调用的时候使用互斥机制,这样就解决了低性能问题
public?class?Singleton?{?
/*?私有构造方法,防止被实例化?*/?
private?Singleton(){
/*?此处使用一个内部类来维护单例?*/?
private?static?class?SingletonFactory?{?
private?static?Singleton?instance?=?new?Singleton();?
/*?获取实例?*/?
public?static?Singleton?getInstance()?{?
return?SingletonFactory.instance;?
/*?如果该对象被用于序列化,可以保证对象在序列化前后保持一致?*/?
public?Object?readResolve()?{?
return?getInstance();?
其实说它完美,也不一定,如果在构造函数中抛出异常,实例将永远得不到创建,也会出错?
第二种改进：
因为我们只需要在创建类的时候进行同步,所以只要将创建和getInstance()分开,
单独为创建加synchronized关键字,也是可以的
public class Singleton {
private static Singleton instance=null;
private Singleton(){}
private static synchronized void Init(){
if(instance==null)
instance=new Singletion();
public static Singleton getInstance(){
if(instance==null){
Init();
import java.util.HashMap;
import java.util.Map;
//登记式单例类.
//类似Spring里面的方法,将类名注册,下次从里面直接获取.
static{
map.put(single.getClass().getName(), single);
//保护的默认构造子
//静态工厂方法,返还此类惟一的实例
if(name == null) {
System.out.println("name == null"◆"---name="◆name);
if(map.get(name) == null) {
try {
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
} catch (ClassNotFoundException e) {
return map.get(name);
//一个示意性的商业方法
public String about() {
return "Hello, I am RegSingleton.";
public static void main(String[] args) {
第一个
public interface RandomNumberListener {//接口
public void numberChanged(double d);
第二个
public class Consol implements RandomNumberListener{
@Override
public void numberChanged(double d) {
System.out.println(d);
第三个
public class SwingWindow
extends JFrame
implements RandomNumberListener{//观察者
private JLabel label = new JLabel();
public SwingWindow(){
this.getContentPane().add( label);
this.setVisible(true);
label.setText(String.valueOf(d));
第四个
public class RandomNumber {//业务
private double r;
private ListRandomNumberListener listeners = new ArrayListRandomNumberListener();
//添加所有观察者
public void addRandomNumberListener(RandomNumberListener lis){
listeners.add(lis);
public void random(){
r = Math.random();
//数据发生改变,通知所有的观察者
for (RandomNumberListener lis : listeners) {
lis.numberChanged(r);
第五个
public class Test {
public static void main(String[] args) throws InterruptedException{
RandomNumber rn = new RandomNumber();
SwingWindow sw = new SwingWindow();
Consol c = new Consol();
rn.addRandomNumberListener(sw);
rn.addRandomNumberListener(c);
while(true){
rn.random();
设计模式主要分三个类型:创建型、结构型和行为型.
其中创建型有：
第一段：Singleton,单例模式：保证一个类只有一个实例,并提供一个访问它的全局访问点
第二段：Abstract Factory,抽象工厂：提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们的具体类.
第三段：Factory Method,工厂方法：定义一个用于创建对象的接口,让子类决定实例化哪一个类,Factory Method使一个类的实例化延迟到了子类.
第四段：Builder,建造模式：将一个复杂对象的构建与他的表示相分离,使得同样的构建过程可以创建不同的表示.
第五段：Prototype,原型模式：用原型实例指定创建对象的种类,并且通过拷贝这些原型来创建新的对象.
行为型有：
第六段：Iterator,迭代器模式：提供一个方法顺序访问一个聚合对象的各个元素,而又不需要暴露该对象的内部表示.
第七段：Observer,观察者模式：定义对象间一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知自动更新.
第八段：Template Method,模板方法：定义一个操作中的算法的骨架,而将一些步骤延迟到子类中,TemplateMethod使得子类可以不改变一个算法的结构即可以重定义该算法得某些特定步骤.
第九段：Command,命令模式：将一个请求封装为一个对象,从而使你可以用不同的请求对客户进行参数化,对请求排队和记录请求日志,以及支持可撤销的操作.
十、State,状态模式：允许对象在其内部状态改变时改变他的行为.对象看起来似乎改变了他的类.
十第一段：Strategy,策略模式：定义一系列的算法,把他们一个个封装起来,并使他们可以互相替换,本模式使得算法可以独立于使用它们的客户.
十第二段：China of Responsibility,职责链模式：使多个对象都有机会处理请求,从而避免请求的送发者和接收者之间的耦合关系
十第三段：Mediator,中介者模式：用一个中介对象封装一些列的对象交互.
十第四段：Visitor,访问者模式：表示一个作用于某对象结构中的各元素的操作,它使你可以在不改变各元素类的前提下定义作用于这个元素的新操作.
十第五段：Interpreter,解释器模式：给定一个语言,定义他的文法的一个表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子.
十第六段：Memento,备忘录模式：在不破坏对象的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态.
结构型有：
十第七段：Composite,组合模式：将对象组合成树形结构以表示部分整体的关系,Composite使得用户对单个对象和组合对象的使用具有一致性.
十第八段：Facade,外观模式：为子系统中的一组接口提供一致的界面,fa?ade提供了一高层接口,这个接口使得子系统更容易使用.
十第九段：Proxy,代理模式：为其他对象提供一种代理以控制对这个对象的访问
二十、Adapter,适配器模式：将一类的接口转换成客户希望的另外一个接口,Adapter模式使得原本由于接口不兼容而不能一起工作那些类可以一起工作.
二十第一段：Decrator,装饰模式：动态地给一个对象增加一些额外的职责,就增加的功能来说,Decorator模式相比生成子类更加灵活.
二十第二段：Bridge,桥模式：将抽象部分与它的实现部分相分离,使他们可以独立的变化.
二十第三段：Flyweight,享元模式
祝你早日学会设计模式！
您好：
创建型
抽象工厂模式、工厂方法、建造者模式、原型模式、单态模式
结构型
适配器模式、桥接模式、组合模式、外观模式、装饰者模式、享元模式、代理模式、
行为型
责任链模式、命令模式、解释器模式、迭代模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式
常见的有七种,具体如下：单例模式、工厂模式、建造(Builder)模式、观察者模式、适配器(Adapter)模式、代理模式、装饰模式
举个例子：
通过调用getInstance()方法来创建实例.
其他不一一举例,仅供参考！希望对你有帮助
设计模式（Design Patterns）
——可复用面向对象软件的基础
设
计模式（Design
pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结.使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代
码可靠性.
毫无疑问,设计模式于己于他人于系统都是多赢的,设计模式使代码编制真正工程化,设计模式是软件工程的基石,如同大厦的一块块砖石一样.项目中合理的运用
设计模式可以完美的解决很多问题,每种模式在现在中都有相应的原理来与之对应,每一个模式描述了一个在我们周围不断重复发生的问题,以及该问题的核心解决
方案,这也是它能被广泛应用的原因.
第一段：设计模式的分类
总体来说设计模式分为三大类：
创建型模式,共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式.
结构型模式,共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式.
行为型模式,共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式.
其实还有两类：并发型模式和线程池模式.
例子：
单例模式（Singleton）
单例对象（Singleton）是一种常用的设计模式.在Java应用中,单例对象能保证在一个JVM中,该对象只有一个实例存在.这样的模式有几个好处：
①.、某些类创建比较频繁,对于一些大型的对象,这是一笔很大的系统开销.
首先我们写一个简单的单例类：
[java] view plaincopy
public class Singleton {
/* 持有私有静态实例,防止被引用,此处赋值为null,目的是实现延迟加载 */
private static Singleton instance = null;
/* 私有构造方法,防止被实例化 */
private Singleton() {
/* 静态工程方法,创建实例 */
public static Singleton getInstance() {
instance = new Singleton();
/* 如果该对象被用于序列化,可以保证对象在序列化前后保持一致 */
public Object readResolve() {
以上就是土嘎嘎小编为大家整理的java设计模式代码案例相关主题介绍,如果您觉得小编更新的文章只要能对粉丝们有用,就是我们最大的鼓励和动力,不要忘记讲本站分享给您身边的朋友哦！！