单例模式和工厂模式

最新推荐文章于 2022-12-07 18:40:38 发布

casllas

最新推荐文章于 2022-12-07 18:40:38 发布

阅读量580

点赞数

分类专栏： java 文章标签：工厂模式单例模式设计模式

java 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

出处一：http://www.cnblogs.com/ds-3579/p/5640567.html

出处二：http://blog.csdn.net/yue7603835/article/details/7459538

1.工厂模式：

　 a.概述：

工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程（new 关键字和具体的构造器）隐藏起来。用一个工厂方法来替代，对外提供的只是一个工厂方法，达到提高灵活性的目的。

b.优点：

           1.隐藏了new关键字和构造器
         2.降低了这个对象与别的类之间的耦合度，提高了程序的可扩展性。
               原因：当子类被别的类替代，或者构造器的参数发生变化的时候，只需改动工厂方法内的new即可，改动量降到了最低，而如果不用工厂模式，而是直接用new关键字的话，需要改动的地方就很多了

3.把对象的设计和实现分割开来，从而代码扩展性强、灵活性高。

c.工厂模式的使用范围：

       当遇到下面的情况时，开发人员可以考虑采用工厂模式：
     * 在编码时不能预见需要创建哪一个种类的实例。
    * 一个类使用它的子类来创建对象。
     * 开发人员不希望创建了那个类的实例以及如何创建实例的信息暴露给外部程序。
除了上面提到的例子，工厂模式的实现方式还允许有一些小小的变化，例如：
        * 基类可以是一个抽象类，在这种情况下，工厂类必须返回一个非抽象类。
   * 基类提供了一些缺省方法，只有当这些缺省方法不能满足特殊需求的情况下才能在子类中重写这些方法。

* 可以直接通过传递给工厂类的参数决定应该返回哪一个子类的实例。

d.可拓展性

    使用工厂模式，它的设计期于运行期的对象不同，这样就增强了代码的可扩展性。
        它把构造器隐藏了起来，降低了代码的耦合度，增强了代码的复用性。
        工厂模式与new的比较：如果使用new关键字的话，那么如果这个类的对象在很多的地方用到，必须要使用多次的new操作，这样容易引起代码的重复使用，如果需要改动或者替换成这个类的子类对象，那么，就需要把执行了new操作的所有地方都要改，比较麻烦。而工厂模式，因为它代替了构造器和new关键字，而且，它是使用面向接口的，所以，需要这个类的对象的时候，只需要调用这个方法就可以了，如果，需要改动或者替换成这个类的子类对象。只要修改这个工厂里面的内容，而其他的地方都不需要改动。
          工厂模式的结构是：用一个方法来代替new关键字和构造器。

工厂模式相当于创建实例对象的new，经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，工厂模式是现今最常用的模式，在Java程序系统中随处可见。

1、一般的工厂

interface Product   //这里接口只是为了保证 返回的对象可以 统一用 Product接受  
{
 void show() ;
}
class  ProductA  implements Product
{
 @Override
 public void show() {
  System.out.println("Product A!");  
 } 
}  
class  ProductB   implements Product      
{
 @Override
 public void show() {
  System.out.println("Product B");  
 } 
}
public class Factory     //作为工厂来使用 
{  
 public static Product getProduct(int product_index)
 {
  if(product_index==0)
   return new ProductA();
  if(1==product_index)
   return new ProductB() ;
  return null; 
 }
}

2、反射类型的工厂

package me.test;
interface Product   //这里接口只是为了保证 返回的对象可以 统一用 Product接受  
{
 void show() ;
}
class  ProductA  implements Product
{
 @Override
 public void show() {
  System.out.println("Product A!");  
 } 
}  
class  ProductB   implements Product      
{
 @Override
 public void show() {
  System.out.println("Product B!");  
 } 
}
public class Factory     //作为工厂来使用 
{  
 public static Product getProduct(String className) throws InstantiationException, IllegalAccessException, ClassNotFoundException
 {
  return (Product)Class.forName(className).newInstance() ;  
 }
 public static void main(String []args) throws InstantiationException, IllegalAccessException, ClassNotFoundException
 {    
  Product a=Factory.getProduct("me.test.ProductA") ;
  a.show() ;
  Product b=Factory.getProduct("me.test.ProductB") ;
  b.show() ;
  }
}

2. 单例模式：

一、单例模式的四大特征：

懒汉式：

        1。声明一个私有的，静态的本类对象，但并不在声明的时候就初始化，因此，它的值为null。
        2。私有化构造器
        3。对外提供一个全局的，共有的，静态的，唯一的方法，用来获得该实例，但注意的是：必须要手动保持线程同步（synchronized）
        4.在该方法里，判断对象是否为null，如果是null的话，表示这个类还没有被实例化，就会初始化这个对象，再返回如果不是null的话，就直接返回。

饿汉式：

        1.声明一个私有的，静态的本类对象，并在声明的时候就初始化
        2.私有构造器
        3.对外提供一个全局的，共有的，静态的，唯一的方法，用来获得该实例（饿汉式线程本身就是同步的）
        4.在该方法里，直接返回该对象即可
    从资源利用效率角度来讲，这个比懒汉式单例类稍微差些。从速度和反应时间角度来讲，则比懒汉式单例类稍好些。

二、它能解决什么问题：

它确保一个类在java虚拟机里只有一个实例，使一个类只有一个对象，整个系统共享这个对象。

三、什么时候使用懒汉式和饿汉式：

1。在使用的几率很少的情况下使用懒汉式。 --用的时候实例

2。而使用的几率很高的话就用饿汉式。--一开始就初始化实例

四、单例模式的好处：

整个系统中的所有的类共用一个实例化对象，这样可以有效的节省资源。

单例模式的目的是将类只能造一个对象出来

单例模式的主要方法是：将构造变成私有的-->做一个静态的生成对象的方法-->造一个静态的存储对象-->return 静态的对象

1、单例模式 Singleton：保证一个类只有一个实例

class  One
{
 private One(){}
    private static One instance =null ;
 public synchronized static One getInstance() 
 {  
  if(instance==null)
   instance=new One() ;
  return instance;
 }
}
public class Singleton {
 public static void main(String[] args)
 {
  Object obj1,obj2 ;
  obj1=One.getInstance() ;
  obj2=One.getInstance() ;
  System.out.println("(obj1==obk2)="+(obj1==obj2));  //结果为True证明实例唯一
 }
}

2、相比第一种方法，这种方法不需要一次次判断内置对象是否为空

class  One
{
 private One(){}
    private static One instance =new One() ;
 public  static One getInstance() 
 {  
  return instance ;
 }
}
public class Singleton {
 public static void main(String[] args)
 {
  Object obj1,obj2 ;
  obj1=One.getInstance() ;
  obj2=One.getInstance() ;
  System.out.println("(obj1==obk2)="+(obj1==obj2));  //结果为True证明实例唯一
 }
}