单态模式和简单工厂模式

《单态模式和简单工厂模式》由会员分享，可在线阅读，更多相关《单态模式和简单工厂模式（21页珍藏版）》请在装配图网上搜索。

1、单态模式和简单工厂模式单例 一个对象 模式和简单工厂模式 软件开发模式 GOF 四个人【四人组】四人帮】一、 单例模式：1. 定义：单例模式又叫 Singleton 模式。此模式的主要作用是保证在 Java 的应用程序中，一个类只有一个实例【对象】存在 。2. 使用：在项目的很多地方都会用到， 比如说数据库的连接。3. 为什么要使用单例模式？好处在于可以节省内存，因为它限制了实例的个数， 有利于 Java 垃圾回收。一个简单的类及对象，方法的调用版本一：packageclassSinglepublicvoidsay()System.out .println( 我开始说话了.);publiccl

2、assSingletonDemo publicstaticvoidmain(String args) Single single1=new Single();single1.say();Single single2=new Single();single2.say();运行结果：我开始说话了.我开始说话了.按照上面的代码，我们可以在main 方法中new 出无数个 Single 类的对象，假如现在要求在内存中只能有一个 Single 对象，该如何实现？分析：我们知道，所有类在实例化对象时都要调用构造方法，所以我们在构造方法处进行修改，将构造方法控制住。 让公有的构造方法变为私有的。classS

3、ingleprivateSingle()publicvoidsay()System.out .println( 我开始说话了.);publicclassSingletonDemo publicstaticvoidmain(String args) Single single1=new Single();single1.say();Single single2=new Single();single2.say();现在运行程序，发现运行出错。因为Single的构造方法是私有的，所以不能在外部去调用。Single类的私有构造方法只对此类内部可见，对类外是不可见的。沿此思路，继续思考：既然Singl

4、e的私有构造方法只对此类内部可见，那我们是否可以在此类内部new出一个对象供外部调用呢？版本二：packageclassSingleprivateSingle()staticSinglepublicvoidSystem.s = new Single();say()out .println( 我开始说话了.);publicclassSingletonDemo publicstaticvoidmain(String args) Single single=Single.single.say();s ;运行结果正常。分析：但我们知道，一个规范的 java 类应该封装属性，即所有的属性都应该是 pri

5、vate 修饰。则代码应为：packageclassSingleprivateSingle()privatestaticSingles = new Single();publicvoidsay()System.out .println( 我开始说话了.);publicclassSingletonDemo publicstaticvoidmain(String args) Single single=Single.s ;single.say();但运行程序报错，原因是 s 是私有变量，在外部不能找到。我们知道规范的 java 类都会私有化属性，但会为每一个属性配置公有的访问方法。版本三：私有化属

6、性，提供静态的公有的方法，可以使用类名直接调用。packageclassSingleprivateSingle()privatestaticSingles =new Single();public static Single getInstance()returns ;publicvoidSystem.say()out .println( 我开始说话了.);publicclassSingletonDemo publicstaticvoidmain(String args) Single single=Single.getInstance();single.say();分析：目前程序基本上没有问

7、题了，但我们发现， s这个引用可以指向无数个new出来的Single对象，因此应在定义Single s前加上final关键字，使程序变为下列版本：packageclassSingleprivateSingle()privatestaticfinalSingles =new Single();publicstaticSinglegetInstance()returns ;publicvoidsay()System.out .println( 我开始说话了.);publicclassSingletonDemo publicstaticvoidmain(String args) Single sin

8、gle=Single.getInstance();single.say();这样，就会保证在整个程序的运行过程中，有一个Single 的对象。至此，一个简单的单态设计模式就结束了。只会验证两个引用是否指向了同一对象？packageclassSingleprivateSingle()privatestaticfinalSingles =new Single();publicstaticreturns ;Single getInstance()publicvoidSystem.say()out .println( 我开始说话了.);publicclassSingletonDemo publicst

9、aticvoidmain(String args) Single single1=Single.Single single2=Single.getInstancegetInstance();();System.out .println(single1=single2);运行结果为：true简单工厂模式简单工厂模式又叫静态工厂模式。顾名思义，它是用来实例化目标类的静态类。packageinterfaceICar/汽车的想法有了publicvoidrun();publicvoidstop();classBenChiimplementsICarpublicvoidrun() System.out .

10、println( 奔驰启动了。 );publicvoidstop() System.out .println( 奔驰停车了。 );classFordimplementsICarpublicvoidrun() System.out .println( 福特汽车启动了.);publicvoidstop() System.out .println( 福特汽车停车了.);publicclassFactoryDemo1 publicstaticvoidmain(String args) ICar car1=new BenChi();/new Ford()car1.run();car1.stop();运行

11、结果： 奔驰启动了。奔驰停车了。分析：上面的做法有一个弊端： 现在不论是奔驰还是福特要想实例化对象， 就必须他们的父类 ICar 联系起来，这样他们之间就紧密的耦合了。我们就想，如果能像现实世界中的工厂去生产产品那就可以避免汽车的想法（接口）与某种具体型号的汽车死死绑定。下面我们就增添一个工厂类：packageinterfaceICar/汽车的想法有了publicvoidrun();publicvoidstop();classBenChiimplementsICarpublicvoidrun() System.out .println( 奔驰启动了。 );publicvoidstop() Sy

12、stem.out .println( 奔驰停车了。 );classFordimplementsICarpublicvoidrun() System.out .println( 福特汽车启动了.);publicvoidstop() System.out .println( 福特汽车停车了.);classFactory/此工厂专门为客户端实例化一个对象publicstaticICar getCarInstance()returnnew BenChi();/如果想要福特，就把这里的BenChi改为 Ford 即可publicclassFactoryDemo1 publicstaticvoidmain

13、(String args) ICar car1=Factory.getCarInstance();car1.run();car1.stop();运行结果是： 奔驰启动了。奔驰停车了。此时就已经写好了一个基本的工厂模式。但现在又有了新的问题，如果想要在 main 方法中实现可以选择的造某种类型的汽车怎么办？interface ICar/ 汽车的想法有了 public void run();public void stop();class BenChi implements ICarpublic void run() 奔驰启动了。 );public void stop() 奔驰停车了。 );cla

14、ss Ford implements ICarpublic void run() 福特汽车启动了 .);public void stop() 福特汽车停车了 .);class Factory/ 此工厂专门为客户端实例化一个对象public static ICar getCarInstance(String type)ICar car=null;if(BenChi.equals(type)car=new BenChi();if(Ford.equals(type)car=new Ford();return car;public class FactoryDemo1 public static vo

15、id main(String args) ICarcar1=Factory.getCarInstance(Ford);car1.run();car1.stop();运行结果是：福特汽车启动了.福特汽车停车了.此代码虽然可以运行出结果， 但若此时要造出一辆宝马，则会报出空指针错误。这就要求，客户端传过来的参数在工厂中必须要有与之匹配的类，这才能造出来。interface ICar/ 汽车的想法有了 public void run();public void stop();class BenChi implements ICarpublic void run() 奔驰启动了。 );public v

16、oid stop() 奔驰停车了。 );class Ford implements ICarpublic void run() 福特汽车启动了 .);public void stop() 福特汽车停车了 .);class Factory/ 此工厂专门为客户端实例化一个对象public static ICar getCarInstance(String type)ICar car=null;if(BenChi.equals(type)car=new BenChi();if(Ford.equals(type)car=new Ford();return car;public class Factor

17、yDemo1 public static void main(String args) ICarcar1=Factory.getCarInstance(Baoma);if(car1!=null)car1.run();car1.stop();else工厂造不出这种品牌的汽车 );运行结果： 工厂造不出这种品牌的汽车此种写法虽然也能实现功能，但仍会有问题，比如现在你要在不改变工厂类的基础上再增加一个丰田汽车类， 那么如何办呢？我们可以采用 java 的反射机制。interface ICar/ 汽车的想法有了 public void run();public void stop();class Be

18、nChi implements ICarpublic void run() 奔驰启动了。 );public void stop() 奔驰停车了。 );class Ford implements ICarpublic void run() 福特汽车启动了 .);public void stop() 福特汽车停车了 .);class FengTian implements ICarpublic void run() 丰田汽车启动了 .);public void stop() 丰田汽车停车了 .);class Factory/ 此工厂专门为客户端实例化一个对象public static ICar g

19、etCarInstance(String type)ICar car=null;try catch (InstantiationException e) e.printStackTrace(); catch (IllegalAccessException e) e.printStackTrace(); catch (ClassNotFoundException e) e.printStackTrace();return car;public class FactoryDemo1 public static void main(String args) ICarcar1=Factory.getCarInstance(FengTian);if(car1!=null)car1.run();car1.stop();else工厂造不出这种品牌的汽车 );运行结果是：丰田汽车启动了.丰田汽车停车了.至此，我们的程序就写的相对灵活了， 以后不论我们有哪些品牌的汽车， 在不改动工厂的前提下，我们都可以实例化出此汽车的对象。 这就是简单工厂模式。