对比.net使用Java的匿名类对工厂方法模式提供更优雅的实现

工厂模式的意图：

定义一个用户创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

结构图：

场景：

这里制造两个手机product:Nokia、Motorola，为了制造这两个Product需要使用两个Creator（Factory）来制造它们。这两个Creator都有各自的Concreator(类似生产线)。这两个手机都实现必须实现两个最基本的功能：call(打电话)、photo(拍照)。

product:

/// <summary>
    /// Product
    /// </summary>
    public abstract class Mobilephone
    {
        public abstract void Call();

        public abstract void Photo();
    }

Creator：定义 生产线必须遵守的契约(创建产品)：

/// <summary>
    /// Creator
    /// </summary>
    public interface IMobilephoneFactory
    {
        Mobilephone CreateMobilephone();
    }

ConcreateCreator：各自的生产线（用于生产不同的产品）

/// <summary>
    /// ConcreateCreator:NokiaFactory
    /// </summary>
    public class NokiaFactory:IMobilephoneFactory
    {
        public Mobilephone CreateMobilephone()
        {
            return new Nokia();
        }
    }

/// <summary>
    /// ConcreateCreator:MotorolaFactory
    /// </summary>
    public class MotorolaFactory:IMobilephoneFactory
    {
        public Mobilephone CreateMobilephone()
        {
            return new Motorola();
        }
    }

ConcreateProduct:生产产品(制造工艺)

/// <summary>
    /// Product:Nokia
    /// </summary>
    public class Nokia : Mobilephone
    {
        public override void Call()
        {
            Console.WriteLine("The Nokia's call function");
        }

        public override void Photo()
        {
            Console.WriteLine("The Nokia's Photo function");
        }
    }

/// <summary>
    /// Product:Motorola
    /// </summary>
    public class Motorola:Mobilephone
    {
        public override void Call()
        {
            Console.WriteLine("The motorola's call function");
        }

        public override void Photo()
        {
            Console.WriteLine("The motorola's Photo function");
        }
    }

下面，我们看看，如何来“制造”出product：

static void Main(string[] args)
        {
            IMobilephoneFactory factory = new MotorolaFactory();
            //create Motorola 
            Mobilephone mobilePhone = factory.CreateMobilephone();
            mobilePhone.Call();
            mobilePhone.Photo();

            factory = new NokiaFactory();
            mobilePhone = factory.CreateMobilephone();
            mobilePhone.Call();
            mobilePhone.Photo();

            Console.Read();
        }

首先，我们“指明”制造产品的工厂，然后我们使用工厂来生产出我们的产品，对于具体的制造工艺，我们没有知道的必要。

然后，我们使用了产品的功能：

可以看到，我们实现了我们的意图：定义一个用户创建对象的接口（IMobilephoneFactory ），让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

好了，以上就是Factory Method partten的一个简要实现(这个不是重点)。我们看到了要实现这样一个模式，需要大概做哪些事情。

那么，有没有稍微优雅点的实现方式呢。其实，在Java中，使用匿名类，可以有更简便的做法：

product:

/*
 * product:Mobilephone
 */
public abstract class Mobilephone {
	
	public abstract void call();
	
	public abstract void photo();
}

Creator:

/*
 * Creator
 */
public interface IMobilephoneFactory {
	Mobilephone CreateMobilephone();
}

ConcreatCreator and ConcreatProduct:下面我们能利用java里的匿名类将各自的工厂和制造流程合二为一。

public class Nokia extends Mobilephone {

	@Override
	public void call() {
		System.out.println("The Nokia's call function");
		
	}

	@Override
	public void photo() {
		System.out.println("The Nokia's Photo function");
	}
	
	private Nokia(){}
	
	public static IMobilephoneFactory factory=
		new IMobilephoneFactory() {
			
			@Override
			public Mobilephone CreateMobilephone() {
				return new Nokia();
			}
		};
	
}

public class Motorola extends Mobilephone {

	@Override
	public void call() {
		System.out.println("The Motorola's call function");
		
	}

	@Override
	public void photo() {
		System.out.println("The Motorola's Photo function");
	}
	
	private Motorola(){}
	
	public static IMobilephoneFactory factory =
		new IMobilephoneFactory() {
			
			@Override
			public Mobilephone CreateMobilephone() {
				return new Motorola();
			}
	};

}

我们看到，在提供具体的构造过程之后，使用了匿名类，提供了该制作流程的工厂。该工厂返回了这个制作流程。并且保证该制造流程只提供给工厂访问，因为构造器被设置为私有的了。这在语法上提供了更便捷和更优雅的实现，并且也体现了职责单一的面向对象原则。一个类包含了一个职责：制造出应该制造的产品，并能够以一个指定的接口(factory)对外提供服务。

下面看一下，我们怎么对外提供服务呢？

public static void mobileMaker(IMobilephoneFactory factory) {
		Mobilephone mobilephone=factory.CreateMobilephone();
		mobilephone.call();
		mobilephone.photo();
	}

我们做了一个服务器，来提供无依赖的服务：

public static void mobileServiceWith(IMobilephoneFactory factory) {
		Mobilephone mobilephone=factory.CreateMobilephone();
		mobilephone.call();
		mobilephone.photo();
	}

你只需要提供创建服务的具体工厂(ConcreateCreator),就可以为了创建该产品，并让它提供服务了：

/**
	 * @param args
	 */
	public static void main(String[] args) {
		System.out.println("nokia factory to make nokia and service:");
		//make nokia
		mobileServiceWith(Nokia.factory);
		System.out.println();
		System.out.println("motorola factory to make motorola and service:");
		//make motorola
		mobileMaker(Motorola.factory);
	}

调用结果：