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

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();

//        }http://

//        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 vector = new Vector();

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单例模式，工厂模式，观察者模式的资料请关注我们其它相关文章！

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。