设计模式——工厂模式

（1）简单工厂模式

基本介绍
1) 简单工厂模式是属于创建型模式，是工厂模式的一种。
简单工厂模式是由一 个工厂对象决定创建出哪一种产品类的实例。
简单工厂模式是工厂模式家族 中最简单实用的模式
2) 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行 为(代码)
3) 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时,就会 使用到工厂模式.

public interface Shape {   //声明一个接口
	void draw();
}

public class Circle implements Shape{

	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("draw Cricle");
	}

}

public class Rectangle implements Shape{

	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("draw Rectangle");
	}

}

public class Simplefactory {
	public Shape getShape(String Type)
	{
		if(Type.equals("circle")) {
			return new Circle();
		}else if(Type.equals("rectangle"))
		{
			return new Rectangle();
		}else if(Type==null)
		{
			return null;
		}
		return null;
		
	}
}

 

public class Client {
	public static void main(String[] args) {
		Simplefactory s = new Simplefactory();
		Shape shape = s.getShape("circle");
		shape.draw();
		
	}
}

 （2）工厂方法模式

public interface Shape {
	void draw();
}

public class Rectangle implements Shape{
	public Rectangle() //将draw方法初始化
	{
		this.draw();
	}
	
	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("draw Rectangle");
	}

}

public class Circle implements Shape{
	public Circle()   //将draw方法初始化
	{
		this.draw();
	}
	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("draw Cricle");
	}

}

public class Circle implements Shape{
	public Circle()   //将draw方法初始化
	{
		this.draw();
	}
	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("draw Cricle");
	}

}

public class CircleFactory implements AbstractFactory
{

	@Override
	public Shape drawShape() {
		// TODO Auto-generated method stub
		return new Circle();
	}

}

public class RectangleFactory implements AbstractFactory{

	@Override
	public Shape drawShape() {
		// TODO Auto-generated method stub
		return new Rectangle();
	}

}

public class Client {
	public static void main(String[] args) {
		AbstractFactory s = new CircleFactory();
		AbstractFactory r = new RectangleFactory();
		s.drawShape();
		r.drawShape();
		
	}
}

  （3）抽象工厂模式

基本介绍
1) 抽象工厂模式：定义了一个interface用于创建相关或有依赖关系的对象簇，而无需 指明具体的类

2) 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。

3) 从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。

4) 将工厂抽象成两层，AbsFactory(抽象工厂) 和 具体实现的工厂子类。程序员可以 根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇， 更利于代码的维护和扩展。

 

public interface Shape {
	void draw();
}

public class Circle implements Shape{
	public Circle()   //将draw方法初始化
	{
		this.draw();
	}
	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("draw Cricle");
	}

}

public class Rectangle implements Shape{
	public Rectangle() //将draw方法初始化
	{
		this.draw();
	}
	
	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("draw Rectangle");
	}

}

 

public interface Color {
	void fill();
}

 

public class Green implements Color{
	public Green()
    {
    	this.fill();
    }
	@Override
	public void fill() {
		// TODO Auto-generated method stub
		System.out.println("Green fill");
	}

}

 

public class Red implements Color{
    public Red()
    {
    	this.fill();
    }
	@Override
	public void fill() {
		// TODO Auto-generated method stub
		System.out.println("Red fill");
	}

}

 

public interface AbstractFactory {
	Shape drawShape();
	Color drawColor();
	
}

 

public class CircleFactory implements AbstractFactory {

	@Override
	public Shape drawShape() {
		// TODO Auto-generated method stub
		return new Circle();
	}

	@Override
	public Color drawColor() {
		// TODO Auto-generated method stub
		return new Red();
	}

}

 

public class RectangleFactory implements AbstractFactory{

	@Override
	public Shape drawShape() {
		// TODO Auto-generated method stub
		return new Rectangle();
	}

	@Override
	public Color drawColor() {
		// TODO Auto-generated method stub
		return new Green();
	}

}

 

public class Client {
	public static void main(String[] args) {
		AbstractFactory s = new CircleFactory();
		AbstractFactory r = new RectangleFactory();
		s.drawShape();
		s.drawColor();
		System.out.println("----------------------------");
		r.drawShape();
		r.drawColor();
		
	}
}

 

工厂模式在JDK-Calendar 应用的源码分析——Calendar中对象的创建——简单工厂模式

public class Client {
	public static void main(String[] args) {
		Calendar cal = Calendar.getInstance();  //
	}
}

  public static Calendar getInstance()
    {
        return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));
    }

public static Calendar getInstance(TimeZone zone,
                                       Locale aLocale)
    {
        return createCalendar(zone, aLocale);
    }

    private static Calendar createCalendar(TimeZone zone,
                                           Locale aLocale)
    {
        CalendarProvider provider =
            LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
                                 .getCalendarProvider();
        if (provider != null) {
            try {
                return provider.getInstance(zone, aLocale);
            } catch (IllegalArgumentException iae) {
                // fall back to the default instantiation
            }
        }

        Calendar cal = null;

        if (aLocale.hasExtensions()) {      //运用了简单工厂模式，当需要时候就进行一个对象的创建
            String caltype = aLocale.getUnicodeLocaleType("ca");
            if (caltype != null) {
                switch (caltype) {
                case "buddhist":
                cal = new BuddhistCalendar(zone, aLocale);
                    break;
                case "japanese":
                    cal = new JapaneseImperialCalendar(zone, aLocale);
                    break;
                case "gregory":
                    cal = new GregorianCalendar(zone, aLocale);
                    break;
                }
            }
        }
        if (cal == null) {
            // If no known calendar type is explicitly specified,
            // perform the traditional way to create a Calendar:
            // create a BuddhistCalendar for th_TH locale,
            // a JapaneseImperialCalendar for ja_JP_JP locale, or
            // a GregorianCalendar for any other locales.
            // NOTE: The language, country and variant strings are interned.
            if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
                cal = new BuddhistCalendar(zone, aLocale);
            } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                       && aLocale.getCountry() == "JP") {
                cal = new JapaneseImperialCalendar(zone, aLocale);
            } else {
                cal = new GregorianCalendar(zone, aLocale);
            }
        }
        return cal;
    }

 

工厂模式小结

1) 工厂模式的意义 将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的 依赖关系的解耦。从而提高项目的扩展和维护性。

2) 三种工厂模式 (简单工厂模式、工厂方法模式、抽象工厂模式)

3) 设计模式的依赖抽象原则创建对象实例时，不要直接 new 类, 而是把这个new 类的动作放在一个工厂的方法 中，并返回。有的书上说，变量不要直接持有具体类的引用。不要让类继承具体类，而是继承抽象类或者是实现interface(接口) 不要覆盖基类中已经实现的方法。