JAVA中常用的设计模式:单例模式,工厂模式,观察者模式

1.单例模式

每个类只能创建一个实例对象

Java Singleton模式主要作用是保证在Java应用程序中,一个类Class只有一个实例存在。 使用Singleton的好处还在于可以节省内存,因为它限制了实例的个数,有利于Java垃圾回收(garbage collection)。

好处:

第一、控制资源的使用,通过线程同步来控制资源的并发访问;

第二、控制实例产生的数量,达到节约资源的目的。

第三、作为通信媒介使用,也就是数据共享,它可以在不建立直接关联的条件下,让多个不相关的两个线程或者进程之间实现通信。

应用场景:在线统计人数

public class SingleTon {

private SingleTon(){}

public static volatile SingleTon instance=null;
public static SingleTon getInstance( ){
synchronized (SingleTon.class){
if(instance==null){
instance=new SingleTon();
                             }
                }
}
return instance;
}

public String getName() {
return name;
}
public void setName(String name) {
this.name=name;
}
public void getInfo( ){
 System.out.println("name is "+name);
}
public static void main(String[] args) {

SingleTon s1 = SingleTon. getInstance( );
s1. setName( "0000" );

SingleTon s2 = SingleTon. getInstance( );
s2. setName( " 1111" );

s1. getInfo( );

s2.getInfo( );

if(s1 == s2){

System.out.println("是一个实例");}
else{
System. out. println("不是一个实例");
      }
}

synchronized 关键字,代表这个方法加锁,

相当于不管哪一个线程A每次运行到这个方法时,

都要检查有没有其它正在用这个方法的线程B(或者C D等),

有的话要等正在使用这个方法的线程B(或者C D)运行完这个方法后再运行此线程A,

没有的话,直接运行它包括两种用法:synchronized 方法和 synchronized 块

2.工厂模式

优点:

将创建实例的工作与使用实例的工作分开,使用者不必关心类对象如何创建,明确了职责。

把初始化实例时的工作放到工厂里进行,使代码更容易维护。 更符合面向对象的原则,面向接口编程,而不是面向实现编程。

缺点:

由于工厂类集中了所有产品创建逻辑,一旦不能正常工作,整个系统都要受到影响。

要新增产品类的时候,就要修改工厂类的代码,违反了开放封闭原则(对扩展的开放,对修改的关闭)。

简单工厂模式由于使用了静态工厂方法,静态方法不能被继承和重写,会造成工厂角色无法形成基于继承的等级结构。

public interface Sender{
public void Send();
}
public class MailSender implements Sender{
@0verride
public void Send( ) {
System.out.println("this is mailsender!");
}
public class SmsSender implements Sender{
@override
public void Send( ) {
System.out.println("this is sms sender!");
}
public class SenderFactory{
public Sender produce(String type){
        if("mail".equals(type)){
            return new MailSender();
        }else if("sms".equals(type)){
            return new SmsSender();
        }else {
            System.out.println("请输入正确的类型!");
            return  null;
        }
        //多工厂模式
//        public Sender produceMail(){
//            return new MailSender();
//        }
//        public Sender produceSms(){
//            return new SmsSender();
//        }
    }
}

3观察者模式

简单地说,观察者模式定义了一个一对多的依赖关系,让一个或多个观察者对象监听一个主题对象。这样一来,当被观察者状态发生改变时,需要通知相应的观察者,使这些观察者对象能够自动更新。例如:GUI中的事件处理机制采用的就是观察者模式.

//定义被观察者所具有的接口
public interface Observable {
public void register0bserve(Observer observer);//注册为一个观察者
public void remove0bserve(Observer observer);//取消观察 者
public void notifyobserves( );//通知所有观察者更新信息
}

import com . example. demo . interfaceTest . observable;
import com. example . demo. interfaceTest Observer;
gimport java.util.Vector ;
public class Cup implements Observable {
//被观察者维护的一个观察者对象列表
private Vector<observer> vector = new Vector<observer>();
private float price;
public Cup(float price) {
this.price = price;
}
public float getPrice() {
return price;
public void setPrice(float price) {
this.price = price;
notifyobserves( ); //修改价格时通知观察者
}
@override
public void register0bserve(Observer observer) {
/ /注册观察者
vector . add( observer);
}
@override
public void removeObserve(Observer observer) {
//取消观察者
vector . remove(observer);
}
@override
public void notifyObserves() {
//实现通知所有的观察者对象
for (Observer observer:vector){
observer update(price);
       }
}
package com. example. demo .interfaceTest
public interface observer {
public void update(float price);
}
package com. example . demo. test;
import com. example. demo. interfaceTestobserver:
public class Person implements Observer
private String name ;
public Person(String name ){
this.name = name ;
aoverride
public void update(float price) {
System. out. println(name+"关注的杯子的价格已更新为: "+price);
}
public static void main(String[] args) {
Cup cup
= new Cup( price: 3000);
Person p1 = new Person( name: "老哥”);
Person p2 = new Person( name:
"小弟”);
cup. registerObserve(p1);
cup. registerObserve(p2);
System. out. println("第1次修改价格");
cup. setPrice(2500);
System. out. println( "第2次修改价格" );
cup. setPrice(2000);
System. out. println("第3次修改价格");
cup. setPrice(1500);
//移除2号观察者
cup. removeObserve(p2);
System. out. println("第4次修改价格”);
cup . setPrice(1000);
}

以上就是JAVA中常用的设计模式:单例模式,工厂模式,观察者模式的详细内容,更多关于JAVA单例模式,工厂模式,观察者模式的资料请关注我们其它相关文章!

(0)

相关推荐

  • Java设计模式之装饰者模式详解和代码实例

    装饰者模式可以给已经存在的对象动态的添加能力.下面,我将会用一个简单的例子来演示一下如何在程序当中使用装饰者模式. 1.装饰者模式 让我们来假设一下,你正在寻找一个女朋友.有很多来自不同国家的女孩,比如:美国,中国,日本,法国等等,他们每个人都有不一样的个性和兴趣爱好,如果需要在程序当中模拟这么一种情况的话,假设每一个女孩就是一个Java类的话,那么就会有成千上万的类,这样子就会造成类的膨胀,而且这样的设计的可扩展性会比较差.因为如果我们需要一个新的女孩,就需要创建一个新的Java类,这实际上也

  • java 设计模式(DAO)的实例详解

    java 设计模式(DAO)的实例详解 应用场景:在Java程序中,经常需要把数据持久化,也需要获取持久化的数据,但是在进行数据持久化的过程中面临诸多问题(如:数据源不同.存储类型不同.供应商不同.访问方式不同等等),请问如何能以统一的接口进行数据持久化的操作? 其实这个我没学号(≧ ﹏ ≦).我的理解就是一个产品面向的用户不是单一的,所以我们要兼容许多情况如前面提到的数据源不同.存储类型不同.供应商不同.访问方式不同等等. ★ 解决方案 DAO的理解: 1.DAO其实是利用组合工厂模式来解决问

  • Java设计模式之责任链模式(Chain of Responsibility模式)介绍

    Chain of Responsibility定义:Chain of Responsibility(CoR) 是用一系列类(classes)试图处理一个请求request,这些类之间是一个松散的耦合,唯一共同点是在他们之间传递request.也就是说,来了一个请求,A类先处理,如果没有处理,就传递到B类处理,如果没有处理,就传递到C类处理,就这样象一个链条(chain)一样传递下去. 如何使用责任链模式 虽然这一段是如何使用CoR,但是也是演示什么是CoR. 有一个Handler接口: 复制代码

  • Java设计模式之状态模式(State模式)介绍

    State的定义:不同的状态,不同的行为:或者说,每个状态有着相应的行为. 何时使用状态模式 State模式在实际使用中比较多,适合"状态的切换".因为我们经常会使用If elseif else 进行状态切换, 如果针对状态的这样判断切换反复出现,我们就要联想到是否可以采取State模式了. 不只是根据状态,也有根据属性.如果某个对象的属性不同,对象的行为就不一样,这点在数据库系统中出现频率比较高,我们经常会在一个数据表的尾部,加上property属性含义的字段,用以标识记录中一些特殊

  • java设计模式之实现对象池模式示例分享

    ObjectPool抽象父类 复制代码 代码如下: import java.util.Iterator;import java.util.Vector; public abstract class ObjectPool<T> { private Vector<T> locked, unlocked;   // locked是已占用的对象集合,unlocked是可用对象集合 public ObjectPool() {    locked = new Vector<T>()

  • Java设计模式之模板模式(Template模式)介绍

    Template模式定义:定义一个操作中算法的骨架,将一些步骤的执行延迟到其子类中. 其实Java的抽象类本来就是Template模式,因此使用很普遍.而且很容易理解和使用,我们直接以示例开始: 复制代码 代码如下: public abstract class Benchmark { /** * 下面操作是我们希望在子类中完成 */ public abstract void benchmark(); /** * 重复执行benchmark次数 */ public final long repea

  • 实例解析观察者模式及其在Java设计模式开发中的运用

    一.观察者模式(Observer)的定义: 观察者模式又称为订阅-发布模式,在此模式中,一个目标对象管理所有相依于它的观察者对象,并且在它本身的状态改变时主动发出通知.这通常透过呼叫各观察者所提供的方法来实现.此种模式通常被用来事件处理系统. 1.观察者模式的一般结构 首先看下观察者模式的类图描述: 观察者模式的角色如下: Subject(抽象主题接口):定义了主题类中对观察者列表的一系列操作, 包括增加,删除, 通知等. Concrete Subject(具体主题类): Observer(抽象

  • 详解设计模式中的proxy代理模式及在Java程序中的实现

    一.代理模式定义 给某个对象提供一个代理对象,并由代理对象控制对于原对象的访问,即客户不直接操控原对象,而是通过代理对象间接地操控原对象. 著名的代理模式的例子就是引用计数(reference counting): 当需要一个复杂对象的多份副本时, 代理模式可以结合享元模式以减少存储器的用量.典型做法是创建一个复杂对象以及多个代理者, 每个代理者会引用到原本的对象.而作用在代理者的运算会转送到原本对象.一旦所有的代理者都不存在时, 复杂对象会被移除. 要理解代理模式很简单,其实生活当中就存在代理

  • Java设计模式之工厂模式(Factory模式)介绍

    工厂模式定义:提供创建对象的接口. 为何使用工厂模式 工厂模式是我们最常用的模式了,著名的Jive论坛,就大量使用了工厂模式,工厂模式在Java程序系统可以说是随处可见. 为什么工厂模式是如此常用?因为工厂模式就相当于创建实例对象的new,我们经常要根据类Class生成实例对象,如A a=new A() 工厂模式也是用来创建实例对象的,所以以后new时就要多个心眼,是否可以考虑实用工厂模式,虽然这样做,可能多做一些工作,但会给你系统带来更大的可扩展性和尽量少的修改量. 我们以类Sample为例,

  • Java设计模式之Iterator模式介绍

    1.首先定义一个容器Collection接口. 复制代码 代码如下: package com.njupt.zhb.learn.iterator;public interface Collection { void add(Object o); int size(); Iterator iterator();} 2.定义一个Iterator迭代器的接口 复制代码 代码如下: package com.njupt.zhb.learn.iterator;public interface Iterator

随机推荐