JAVA常用设计模式(静态化调用和实例化调用的区别,编辑可见 )
2015-03-16 16:19
274 查看
用newInstance()与用new是区别的,区别在于创建对象的方式不一样,前者是使用类加载机制,后者是创建一个新类,且newInstance()只能调用无参构造函数。
最大的区别在于内存。
静态方法在程序开始时生成内存,实例方法在程序运行中生成内存,
所以静态方法可以直接调用,实例方法要先成生实例,通过实例调用方法,静态速度很快,但是多了会占内存。
任何语言都是对内存和磁盘的操作,至于是否面向对象,只是软件层的问题,底层都是一样的,只是实现方法不同。
静态内存是连续的,因为是在程序开始时就生成了,而实例申请的是离散的空间,所以当然没有静态方法快,
而且静态内存是有限制的,太多了程序会启动不了。
1.单例设计模式
所谓单例设计模式简单说就是无论程序如何运行,采用单例设计模式的类(Singleton类)永远只会有一个实例化对象产生。具体实现步骤如下:
(1)将采用单例设计模式的类的构造方法私有化(采用private修饰)。
(2)在其内部产生该类的实例化对象,并将其封装成privatestatic类型。
(3)定义一个静态方法返回该类的实例。
示例代码如下:
}
一、单例模式的介绍Singleton是一种创建型模式,指某个类采用Singleton模式,则在这个类被创建后,只可能产生一个实例供外部访问,并且提供一个全局的访问点
二、单例模式的实现
实现的方式有如下四种:
Java代码
/**
*
*单例模式的实现:饿汉式,线程安全但效率比较低
*/
publicclassSingletonTest{
privateSingletonTest(){
}
privatestaticfinalSingletonTestinstance=newSingletonTest();
publicstaticSingletonTestgetInstancei(){
returninstance;
}
}
[java]viewplaincopyprint?
/**
*
*单例模式的实现:饿汉式,线程安全但效率比较低
*/
publicclassSingletonTest{
privateSingletonTest(){
}
privatestaticfinalSingletonTestinstance=newSingletonTest();
publicstaticSingletonTestgetInstancei(){
returninstance;
}
}
2.工厂设计模式
简单工厂模式是属于创建型模式,又叫做静态工厂方法(StaticFactoryMethod)模式。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。
interfaceAnimal{publicvoidsay();}classDogimplementsAnimal{publicvoidsay(){System.out.println("A");}}classCatimplementsAnimal{publicvoidsay(){System.out.println("B");}}classFactory{//定义工厂类publicstaticAnimalgetInstance(StringclassName){Animala=null;//定义接口对象if("Cat".equals(className)){//判断是哪个子类的标记a=newCat();//通过Cat子类实例化接口}if("Dog".equals(className)){//判断是哪个子类的标记a=newDog();//通过Dog子类实例化接口}returna;}}
publicclassFactoryDemo{publicstaticvoidmain(String[]args){//TODOAuto-generatedmethodstubFactoryb=newFactory();//Animala=newAnimal();接口是不能被实例化的Animala=b.getInstance("Dog");//通过工厂获取实例a.say();//调用方法}}
3.代理设计模式
指由一个代理主题来操作真实主题,真实主题执行具体的业务操作,而代理主题负责其他相关业务的处理。比如生活中的通过代理访问网络,客户通过网络代理连接网络(具体业务),由代理服务器完成用户权限和访问限制等与上网相关的其他操作(相关业务)。
示例代码如下:
Java代码
interfaceNetwork{//定义Network接口
publicvoidbrowse();//定义浏览的抽象方法
}
classRealimplementsNetwork{//真实的上网操作
publicvoidbrowse(){//覆写抽象方法
System.out.println("上网浏览信息!");
}
}
classProxyimplementsNetwork{//代理上网
privateNetworknetwork;
publicProxy(Networknetwork){//设置代理的真实操作
this.network=network;//设置代理的子类
}
publicvoidcheck(){//身份验证操作
System.out.println("检查用户是否合法!");
}
publicvoidbrowse(){
this.check();//调用具体的代理业务操作
this.network.browse();//调用真实的上网操作
}
}
publicclassProxyDemo{
publicstaticvoidmain(Stringargs[]){
Networknet=null;//定义接口对象
net=newProxy(newReal());//实例化代理,同时传入代理的真实操作
net.browse();//调用代理的上网操作
}
}
[java]viewplaincopyprint?
interfaceNetwork{//定义Network接口
publicvoidbrowse();//定义浏览的抽象方法
}
classRealimplementsNetwork{//真实的上网操作
publicvoidbrowse(){//覆写抽象方法
System.out.println("上网浏览信息!");
}
}
classProxyimplementsNetwork{//代理上网
privateNetworknetwork;
publicProxy(Networknetwork){//设置代理的真实操作
this.network=network;//设置代理的子类
}
publicvoidcheck(){//身份验证操作
System.out.println("检查用户是否合法!");
}
publicvoidbrowse(){
this.check();//调用具体的代理业务操作
this.network.browse();//调用真实的上网操作
}
}
publicclassProxyDemo{
publicstaticvoidmain(Stringargs[]){
Networknet=null;//定义接口对象
net=newProxy(newReal());//实例化代理,同时传入代理的真实操作
net.browse();//调用代理的上网操作
}
}
interfaceNetwork{//定义Network接口
publicvoidbrowse();//定义浏览的抽象方法
}
classRealimplementsNetwork{//真实的上网操作
publicvoidbrowse(){//覆写抽象方法
System.out.println("上网浏览信息!");
}
}
classProxyimplementsNetwork{//代理上网
privateNetworknetwork;
publicProxy(Networknetwork){//设置代理的真实操作
this.network=network;//设置代理的子类
}
publicvoidcheck(){//身份验证操作
System.out.println("检查用户是否合法!");
}
publicvoidbrowse(){
this.check();//调用具体的代理业务操作
this.network.browse();//调用真实的上网操作
}
}
publicclassProxyDemo{
publicstaticvoidmain(Stringargs[]){
Networknet=null;//定义接口对象
net=newProxy(newReal());//实例化代理,同时传入代理的真实操作
net.browse();//调用代理的上网操作
}
}
4.观察者设计模式
所谓观察者模式,举个例子现在许多购房者都密切观察者房价的变化,当房价变化时,所有购房者都能观察到,以上的购房者属于观察者,这便是观察者模式。
java中可以借助Observable类和Observer接口轻松实现以上功能。当然此种模式的实现也不仅仅局限于采用这两个类。
示例代码如下:
Java代码
importjava.util.Observable;
importjava.util.Observer;
classHouseextendsObservable{
privatefloatprice;
publicvoidsetPrice(floatprice){
this.setChanged();//设置变化点
this.notifyObservers(price);//通知所有观察者价格改变
this.price=price;
}
publicfloatgetPrice(){
returnthis.price;
}
publicHouse(floatprice){
this.price=price;
}
publicStringtoString(){
return"房子价格为:"+this.price;
}
}
classHousePriceObserverimplementsObserver{
privateStringname;
publicHousePriceObserver(Stringname){
super();
this.name=name;
}
@Override
publicvoidupdate(Observableo,Objectarg){//只要改变了observable对象就调用此方法
if(arginstanceofFloat){
System.out.println(this.name+"观察的价格更改为:"
+((Float)arg).floatValue());
}
}
}
publicclassObserDeom{
publicstaticvoidmain(String[]args){
Househ=newHouse(1000000);
HousePriceObserverhpo1=newHousePriceObserver("购房者A");
HousePriceObserverhpo2=newHousePriceObserver("购房者B");
HousePriceObserverhpo3=newHousePriceObserver("购房者C");
h.addObserver(hpo1);//给房子注册观察者
h.addObserver(hpo2);//给房子注册观察者
h.addObserver(hpo3);//给房子注册观察者
System.out.println(h);//输出房子价格
//修改房子价格,会触发update(Observableo,Objectarg)方法通知购房者新的房价信息
h.setPrice(2222222);//
System.out.println(h);//再次输出房子价格
}
}
[java]viewplaincopyprint?
importjava.util.Observable;
importjava.util.Observer;
classHouseextendsObservable{
privatefloatprice;
publicvoidsetPrice(floatprice){
this.setChanged();//设置变化点
this.notifyObservers(price);//通知所有观察者价格改变
this.price=price;
}
publicfloatgetPrice(){
returnthis.price;
}
publicHouse(floatprice){
this.price=price;
}
publicStringtoString(){
return"房子价格为:"+this.price;
}
}
classHousePriceObserverimplementsObserver{
privateStringname;
publicHousePriceObserver(Stringname){
super();
this.name=name;
}
@Override
publicvoidupdate(Observableo,Objectarg){//只要改变了observable对象就调用此方法
if(arginstanceofFloat){
System.out.println(this.name+"观察的价格更改为:"
+((Float)arg).floatValue());
}
}
}
publicclassObserDeom{
publicstaticvoidmain(String[]args){
Househ=newHouse(1000000);
HousePriceObserverhpo1=newHousePriceObserver("购房者A");
HousePriceObserverhpo2=newHousePriceObserver("购房者B");
HousePriceObserverhpo3=newHousePriceObserver("购房者C");
h.addObserver(hpo1);//给房子注册观察者
h.addObserver(hpo2);//给房子注册观察者
h.addObserver(hpo3);//给房子注册观察者
System.out.println(h);//输出房子价格
//修改房子价格,会触发update(Observableo,Objectarg)方法通知购房者新的房价信息
h.setPrice(2222222);//
System.out.println(h);//再次输出房子价格
}
}
最大的区别在于内存。
静态方法在程序开始时生成内存,实例方法在程序运行中生成内存,
所以静态方法可以直接调用,实例方法要先成生实例,通过实例调用方法,静态速度很快,但是多了会占内存。
任何语言都是对内存和磁盘的操作,至于是否面向对象,只是软件层的问题,底层都是一样的,只是实现方法不同。
静态内存是连续的,因为是在程序开始时就生成了,而实例申请的是离散的空间,所以当然没有静态方法快,
而且静态内存是有限制的,太多了程序会启动不了。
1.单例设计模式
所谓单例设计模式简单说就是无论程序如何运行,采用单例设计模式的类(Singleton类)永远只会有一个实例化对象产生。具体实现步骤如下:
(1)将采用单例设计模式的类的构造方法私有化(采用private修饰)。
(2)在其内部产生该类的实例化对象,并将其封装成privatestatic类型。
(3)定义一个静态方法返回该类的实例。
示例代码如下:
}
一、单例模式的介绍Singleton是一种创建型模式,指某个类采用Singleton模式,则在这个类被创建后,只可能产生一个实例供外部访问,并且提供一个全局的访问点
二、单例模式的实现
实现的方式有如下四种:
Java代码
/**
*
*单例模式的实现:饿汉式,线程安全但效率比较低
*/
publicclassSingletonTest{
privateSingletonTest(){
}
privatestaticfinalSingletonTestinstance=newSingletonTest();
publicstaticSingletonTestgetInstancei(){
returninstance;
}
}
[java]
/**
*
*单例模式的实现:饿汉式,线程安全但效率比较低
*/
publicclassSingletonTest{
privateSingletonTest(){
}
privatestaticfinalSingletonTestinstance=newSingletonTest();
publicstaticSingletonTestgetInstancei(){
returninstance;
}
}
2.工厂设计模式
简单工厂模式是属于创建型模式,又叫做静态工厂方法(StaticFactoryMethod)模式。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。
interfaceAnimal{publicvoidsay();}classDogimplementsAnimal{publicvoidsay(){System.out.println("A");}}classCatimplementsAnimal{publicvoidsay(){System.out.println("B");}}classFactory{//定义工厂类publicstaticAnimalgetInstance(StringclassName){Animala=null;//定义接口对象if("Cat".equals(className)){//判断是哪个子类的标记a=newCat();//通过Cat子类实例化接口}if("Dog".equals(className)){//判断是哪个子类的标记a=newDog();//通过Dog子类实例化接口}returna;}}
publicclassFactoryDemo{publicstaticvoidmain(String[]args){//TODOAuto-generatedmethodstubFactoryb=newFactory();//Animala=newAnimal();接口是不能被实例化的Animala=b.getInstance("Dog");//通过工厂获取实例a.say();//调用方法}}
3.代理设计模式
指由一个代理主题来操作真实主题,真实主题执行具体的业务操作,而代理主题负责其他相关业务的处理。比如生活中的通过代理访问网络,客户通过网络代理连接网络(具体业务),由代理服务器完成用户权限和访问限制等与上网相关的其他操作(相关业务)。
示例代码如下:
Java代码
interfaceNetwork{//定义Network接口
publicvoidbrowse();//定义浏览的抽象方法
}
classRealimplementsNetwork{//真实的上网操作
publicvoidbrowse(){//覆写抽象方法
System.out.println("上网浏览信息!");
}
}
classProxyimplementsNetwork{//代理上网
privateNetworknetwork;
publicProxy(Networknetwork){//设置代理的真实操作
this.network=network;//设置代理的子类
}
publicvoidcheck(){//身份验证操作
System.out.println("检查用户是否合法!");
}
publicvoidbrowse(){
this.check();//调用具体的代理业务操作
this.network.browse();//调用真实的上网操作
}
}
publicclassProxyDemo{
publicstaticvoidmain(Stringargs[]){
Networknet=null;//定义接口对象
net=newProxy(newReal());//实例化代理,同时传入代理的真实操作
net.browse();//调用代理的上网操作
}
}
[java]
interfaceNetwork{//定义Network接口
publicvoidbrowse();//定义浏览的抽象方法
}
classRealimplementsNetwork{//真实的上网操作
publicvoidbrowse(){//覆写抽象方法
System.out.println("上网浏览信息!");
}
}
classProxyimplementsNetwork{//代理上网
privateNetworknetwork;
publicProxy(Networknetwork){//设置代理的真实操作
this.network=network;//设置代理的子类
}
publicvoidcheck(){//身份验证操作
System.out.println("检查用户是否合法!");
}
publicvoidbrowse(){
this.check();//调用具体的代理业务操作
this.network.browse();//调用真实的上网操作
}
}
publicclassProxyDemo{
publicstaticvoidmain(Stringargs[]){
Networknet=null;//定义接口对象
net=newProxy(newReal());//实例化代理,同时传入代理的真实操作
net.browse();//调用代理的上网操作
}
}
publicvoidbrowse();//定义浏览的抽象方法
}
classRealimplementsNetwork{//真实的上网操作
publicvoidbrowse(){//覆写抽象方法
System.out.println("上网浏览信息!");
}
}
classProxyimplementsNetwork{//代理上网
privateNetworknetwork;
publicProxy(Networknetwork){//设置代理的真实操作
this.network=network;//设置代理的子类
}
publicvoidcheck(){//身份验证操作
System.out.println("检查用户是否合法!");
}
publicvoidbrowse(){
this.check();//调用具体的代理业务操作
this.network.browse();//调用真实的上网操作
}
}
publicclassProxyDemo{
publicstaticvoidmain(Stringargs[]){
Networknet=null;//定义接口对象
net=newProxy(newReal());//实例化代理,同时传入代理的真实操作
net.browse();//调用代理的上网操作
}
}
4.观察者设计模式
所谓观察者模式,举个例子现在许多购房者都密切观察者房价的变化,当房价变化时,所有购房者都能观察到,以上的购房者属于观察者,这便是观察者模式。
java中可以借助Observable类和Observer接口轻松实现以上功能。当然此种模式的实现也不仅仅局限于采用这两个类。
示例代码如下:
Java代码
importjava.util.Observable;
importjava.util.Observer;
classHouseextendsObservable{
privatefloatprice;
publicvoidsetPrice(floatprice){
this.setChanged();//设置变化点
this.notifyObservers(price);//通知所有观察者价格改变
this.price=price;
}
publicfloatgetPrice(){
returnthis.price;
}
publicHouse(floatprice){
this.price=price;
}
publicStringtoString(){
return"房子价格为:"+this.price;
}
}
classHousePriceObserverimplementsObserver{
privateStringname;
publicHousePriceObserver(Stringname){
super();
this.name=name;
}
@Override
publicvoidupdate(Observableo,Objectarg){//只要改变了observable对象就调用此方法
if(arginstanceofFloat){
System.out.println(this.name+"观察的价格更改为:"
+((Float)arg).floatValue());
}
}
}
publicclassObserDeom{
publicstaticvoidmain(String[]args){
Househ=newHouse(1000000);
HousePriceObserverhpo1=newHousePriceObserver("购房者A");
HousePriceObserverhpo2=newHousePriceObserver("购房者B");
HousePriceObserverhpo3=newHousePriceObserver("购房者C");
h.addObserver(hpo1);//给房子注册观察者
h.addObserver(hpo2);//给房子注册观察者
h.addObserver(hpo3);//给房子注册观察者
System.out.println(h);//输出房子价格
//修改房子价格,会触发update(Observableo,Objectarg)方法通知购房者新的房价信息
h.setPrice(2222222);//
System.out.println(h);//再次输出房子价格
}
}
[java]
importjava.util.Observable;
importjava.util.Observer;
classHouseextendsObservable{
privatefloatprice;
publicvoidsetPrice(floatprice){
this.setChanged();//设置变化点
this.notifyObservers(price);//通知所有观察者价格改变
this.price=price;
}
publicfloatgetPrice(){
returnthis.price;
}
publicHouse(floatprice){
this.price=price;
}
publicStringtoString(){
return"房子价格为:"+this.price;
}
}
classHousePriceObserverimplementsObserver{
privateStringname;
publicHousePriceObserver(Stringname){
super();
this.name=name;
}
@Override
publicvoidupdate(Observableo,Objectarg){//只要改变了observable对象就调用此方法
if(arginstanceofFloat){
System.out.println(this.name+"观察的价格更改为:"
+((Float)arg).floatValue());
}
}
}
publicclassObserDeom{
publicstaticvoidmain(String[]args){
Househ=newHouse(1000000);
HousePriceObserverhpo1=newHousePriceObserver("购房者A");
HousePriceObserverhpo2=newHousePriceObserver("购房者B");
HousePriceObserverhpo3=newHousePriceObserver("购房者C");
h.addObserver(hpo1);//给房子注册观察者
h.addObserver(hpo2);//给房子注册观察者
h.addObserver(hpo3);//给房子注册观察者
System.out.println(h);//输出房子价格
//修改房子价格,会触发update(Observableo,Objectarg)方法通知购房者新的房价信息
h.setPrice(2222222);//
System.out.println(h);//再次输出房子价格
}
}
相关文章推荐
- Java常用的设计模式
- Java中常用设计模式总结
- Java常用设计模式
- Java常用的设计模式
- Java常用的设计模式
- java常用设计模式
- Java常用的设计模式
- java常用设计模式
- [转]Java中常用设计模式总结
- java常用设计模式
- java常用的设计模式
- java常用的设计模式
- java 23种设计模式中常用的九种
- 设计模式之-单例模式(Singleton)及java中==与equals的区别
- Java常用的设计模式
- java常用设计模式
- java常用设计模式
- Java常用的设计模式
- Java23种常用设计模式
- java常用类库续3(比较器Comparable、Comparator、观察者设计模式、正则表达式、定时调度)