JAVA中常用的设计模式：单例模式，工厂模式，观察者模式
1.单例模式
每个类只能创建一个实例对象
JavaSingleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。使用Singleton的好处还在于可以节省内存，因为它限制了实例的个数，有利于Java垃圾回收（garbagecollection）。
好处：
第一、控制资源的使用，通过线程同步来控制资源的并发访问；
第二、控制实例产生的数量，达到节约资源的目的。
第三、作为通信媒介使用，也就是数据共享，它可以在不建立直接关联的条件下，让多个不相关的两个线程或者进程之间实现通信。
应用场景：在线统计人数
publicclassSingleTon{privateSingleTon(){}
publicstaticvolatileSingleToninstance=null;
publicstaticSingleTongetInstance(){
synchronized(SingleTon.class){
if(instance==null){
instance=newSingleTon(）；
}
}
}
returninstance;
}publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicvoidgetInfo(){
System.out.println("nameis"+name);
}
publicstaticvoidmain(String[]args){SingleTons1=SingleTon.getInstance();
s1.setName("0000");SingleTons2=SingleTon.getInstance();
s2.setName("1111");s1.getInfo();
s2.getInfo();
if(s1==s2){
System.out.println("是一个实例");}
else{
System.out.println("不是一个实例");
}
}
synchronized关键字，代表这个方法加锁,
相当于不管哪一个线程A每次运行到这个方法时,
都要检查有没有其它正在用这个方法的线程B（或者CD等）,
有的话要等正在使用这个方法的线程B（或者CD）运行完这个方法后再运行此线程A,
没有的话,直接运行它包括两种用法：synchronized方法和synchronized块
2.工厂模式
优点：
将创建实例的工作与使用实例的工作分开，使用者不必关心类对象如何创建，明确了职责。
把初始化实例时的工作放到工厂里进行，使代码更容易维护。更符合面向对象的原则，面向接口编程，而不是面向实现编程。
缺点：
由于工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。
要新增产品类的时候，就要修改工厂类的代码，违反了开放封闭原则（对扩展的开放，对修改的关闭）。
简单工厂模式由于使用了静态工厂方法，静态方法不能被继承和重写，会造成工厂角色无法形成基于继承的等级结构。
publicinterfaceSender{
publicvoidSend();
}
publicclassMailSenderimplementsSender{
@0verride
publicvoidSend(){
System.out.println("thisismailsender!");
}
publicclassSmsSenderimplementsSender{
@override
publicvoidSend(){
System.out.println("thisissmssender!");
}
publicclassSenderFactory{
publicSenderproduce(Stringtype){
if("mail".equals(type)){
returnnewMailSender();
}elseif("sms".equals(type)){
returnnewSmsSender();
}else{
System.out.println("请输入正确的类型！");
return null;
}
//多工厂模式
// publicSenderproduceMail(){
// returnnewMailSender();
// }
// publicSenderproduceSms(){
// returnnewSmsSender();
// }
}
}
3观察者模式
简单地说，观察者模式定义了一个一对多的依赖关系，让一个或多个观察者对象监听一个主题对象。这样一来，当被观察者状态发生改变时，需要通知相应的观察者，使这些观察者对象能够自动更新。例如：GUI中的事件处理机制采用的就是观察者模式.
//定义被观察者所具有的接口
publicinterfaceObservable{
publicvoidregister0bserve(Observerobserver);//注册为一个观察者
publicvoidremove0bserve(Observerobserver);//取消观察者
publicvoidnotifyobserves();//通知所有观察者更新信息
}importcom.example.demo.interfaceTest.observable;
importcom.example.demo.interfaceTestObserver;
gimportjava.util.Vector;
publicclassCupimplementsObservable{
//被观察者维护的一个观察者对象列表
privateVectorvector=newVector ();
privatefloatprice;
publicCup(floatprice){
this.price=price;
}
publicfloatgetPrice(){
returnprice;
publicvoidsetPrice(floatprice){
this.price=price;
notifyobserves();//修改价格时通知观察者
}
@override
publicvoidregister0bserve(Observerobserver){
//注册观察者
vector.add(observer);
}
@override
publicvoidremoveObserve(Observerobserver){
//取消观察者
vector.remove(observer);
}
@override
publicvoidnotifyObserves(){
//实现通知所有的观察者对象
for(Observerobserver:vector){
observerupdate(price);
}
}
packagecom.example.demo.interfaceTest
publicinterfaceobserver{
publicvoidupdate(floatprice);
}
packagecom.example.demo.test;
importcom.example.demo.interfaceTestobserver:
publicclassPersonimplementsObserver
privateStringname;
publicPerson(Stringname){
this.name=name;
aoverride
publicvoidupdate(floatprice){
System.out.println(name+"关注的杯子的价格已更新为:"+price);
}
publicstaticvoidmain(String[]args){
Cupcup
=newCup(price:3000);
Personp1=newPerson(name:"老哥”);
Personp2=newPerson(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单例模式，工厂模式，观察者模式的资料请关注毛票票其它相关文章！