工厂和单例模式有关了解

最新推荐文章于 2023-12-27 01:06:43 发布

s2940086379

最新推荐文章于 2023-12-27 01:06:43 发布

阅读量404

点赞数

分类专栏： java基础文章标签：工厂模式数据库多线程实例 string

本文链接：https://blog.csdn.net/s2940086379/article/details/45916017

版权

java基础专栏收录该内容

26 篇文章 0 订阅

订阅专栏

工厂模式也用了不少，MS的petshop中对数据库的访问，通过工厂模式可以达到自由切换SQL 和 Oracle 数据库。今天从代码的角度来比较工厂模式各变种。

1：简单工厂模式：其作用是实例化对象而不需要客户了解这个对象属于那个具体的子类。


using System;
using System.Collections;


public class MyClass
{
    public static void Main()
    {
        //通过参数来实例化子类。
        IVehicle vehicle = FactoryVehicle.CreateVehicle("car");
        vehicle.go();
        Console.ReadLine();    
    }
    
}


public class FactoryVehicle
{
    public static IVehicle CreateVehicle(string VehicleName)
    {
        switch(VehicleName.ToLower())
        {
            case "car":
            return new Car();
            case "boat":
            return new Boat();
            default:
            return new Car();
            
        }
    }


}
public interface IVehicle
{
    void go();
}
public class Car:IVehicle
{
    public void go()
    {
        Console.WriteLine("car");
    }
}
public class Boat:IVehicle
{
    public void go()
    {
        Console.WriteLine("boat");
    }
}

2:抽象工厂：即将工厂方法也抽象出来，由具体的子类来实例化工厂。产品创建部分和简单工厂模式相同。

using System;
using System.Collections;


public class MyClass
{
    public static void Main()
    {
        //通过定义的工厂来实例化。弊端是当产品很多时需要增加很多的工厂。代码重复。
        FactoryVehicle factory = new FactoryCar();
        IVehicle vehicle = factory.CreateVehicle();
        vehicle.go();
        Console.ReadLine();    
    }
    
}




public interface FactoryVehicle
{
     IVehicle CreateVehicle();


}


public class FactoryCar:FactoryVehicle
{
    public IVehicle CreateVehicle()
    {
        return new Car();
    }
}


public class FactoryBoat:FactoryVehicle
{
    public IVehicle CreateVehicle()
    {
        return new Boat();
    }
}


public interface IVehicle
{
    void go();
}


public class Car:IVehicle
{
    public void go()
    {
        Console.WriteLine("car");
    }
}


public class Boat:IVehicle
{
    public void go()
    {
        Console.WriteLine("boat");
    }
}

3:反射工厂模式：其实就是通过反射的方式来获得具体实例化是那个类。

using System;
using System.Collections;
using System.Reflection;


public class MyClass
{
    public static void Main()
    {
        //使用反射的方法获得实例化的类
        IVehicle vechicle = ReflectFactory.CreateVehicleByReflect("Car");
        vechicle.go();
        Console.ReadLine();    
        
    }
    
}


public class ReflectFactory
{
    public static IVehicle CreateVehicleByReflect(string typeName)
    {
        Type type = Type.GetType(typeName);
        ConstructorInfo  ci = type.GetConstructor(System.Type.EmptyTypes);;
        return (IVehicle)ci.Invoke(null);
    }
}
public class FactoryBoat:FactoryVehicle
{
    public IVehicle CreateVehicle()
    {
        return new Boat();
    }
}


public class FactoryCar:FactoryVehicle
{
    public IVehicle CreateVehicle()
    {
        return new Car();
    }
}


public interface FactoryVehicle
{
    IVehicle CreateVehicle();


}
public interface IVehicle
{
    void go();
}


public class Car:IVehicle
{
    public void go()
    {
        Console.WriteLine("car");
    }
}


public class Boat:IVehicle
{
    public void go()
    {
        Console.WriteLine("boat");
    }
}

单利模式：
package singleton;

02

03 /**

04 * @author lei

05 * 单例模式的五种写法：

06 * 1、懒汉

07 * 2、恶汉

08 * 3、静态内部类

09 * 4、枚举

10 * 5、双重校验锁

11 * 2011-9-6

12 */

13 /**

14 *五、双重校验锁，在当前的内存模型中无效

15 */


16 class LockSingleton{  


17     private volatile static LockSingleton singleton;  


18     private LockSingleton(){}  


19        


20     //详见：http://www.ibm.com/developerworks/cn/java/j-dcl.html  


21     public static LockSingleton getInstance(){  


22         if(singleton==null){  


23             synchronized(LockSingleton.class){  


24                 if(singleton==null){  


25                     singleton=new LockSingleton();  


26                 }  


27             }  


28         }  


29         return singleton;  


30     }  


31        


32 }  


33 /**

34 * 四、枚举，《Effective Java》作者推荐使用的方法，优点：不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象

35  */ 


36 enum EnumSingleton{  


37     INSTANCE;  


38     public void doSomeThing(){  


39     }  


40 }  


41 /**

42 * 三、静态内部类优点：加载时不会初始化静态变量INSTANCE，因为没有主动使用，达到Lazy loading

43 */

44 class InternalSingleton{  


45     private static class SingletonHolder{  


46         private final static  InternalSingleton INSTANCE=new InternalSingleton();  


47     }     


48     private InternalSingleton(){}  


49     public static InternalSingleton getInstance(){  


50         return SingletonHolder.INSTANCE;  


51     }  


52 }  


53 /**

54 * 二、恶汉,缺点：没有达到lazy loading的效果

55  */ 


56 class HungrySingleton{  


57     private static HungrySingleton singleton=new HungrySingleton();  


58     private HungrySingleton(){}  


59     public static HungrySingleton getInstance(){  


60         return singleton;  


61     }  


62 }  


63 /**

64 * 一、懒汉，常用的写法

65  */ 


66 class LazySingleton{  


67     private static LazySingleton singleton;  


68     private LazySingleton(){  


69     }  


70     public static LazySingleton getInstance(){  


71         if(singleton==null){  


72             singleton=new LazySingleton();  


73         }  


74         return singleton;  


75     }     


76 }