设计模式-工厂模式-1

1.简单工厂模式

1.1 介绍

• 简单工厂模式属于类的创建型模式，又叫做静态工厂方法模式。
• 通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

如下图所示，调用者AppTest需要Apple或者Banana时候，不用一个一个去new，而是直接通过工厂，传递不同的值即可返回自己所需要的相关类

1.2 涉及角色

• 1.工厂（Creator)角色(FruitFactory)
  简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。
• 2.抽象（Product)角色(Fruit)
  简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
• 3.具体产品（Concrete Product)角色(Apple等)
  简单工厂模式所创建的具体实例对象

1.3 代码实现

public interface Fruit {
	/*
	 * 采集
	 */
	public void get();
}

public class Banana implements Fruit{
	public void get(){
		System.out.println("获取香蕉");
	}
}

public class Apple implements Fruit{
	public void get(){
		System.out.println("获取苹果");
	}
}

public class FruitFactory {

//	实现1
//	public static  Fruit getApple() {
//		return new Apple();
//	}
//
//	public static Fruit getBanana() {
//		return new Banana();
//	}

	//实现2
	public static Fruit getFruit(String type) throws InstantiationException, IllegalAccessException, ClassNotFoundException {

		if(type.equalsIgnoreCase("apple")) {
			return Apple.class.newInstance();

		} else if(type.equalsIgnoreCase("banana")) {
			return Banana.class.newInstance();
		} else {
			System.out.println("没有找到相关实现类");
			return null;
		}
//		Class fruit = Class.forName(type);
//		return (Fruit) fruit.newInstance();
	}
}

public class MainClass {
	public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
		//方式一
//		Apple apple = new Apple();
//		Banana banana = new Banana();
//		apple.get();
//		banana.get();

		//方式二
//		Fruit apple = FruitFactory.getApple();
//		Fruit banana = FruitFactory.getBanana();
//		apple.get();
//		banana.get();
		//方式三
		Fruit apple = FruitFactory.getFruit("Apple");
		Fruit banana = FruitFactory.getFruit("Banana");
		apple.get();
		banana.get();
		
	}
}

1.4 优缺点

• 在这个模式中，工厂类是整个模式的关键所在。它包含必要的判断逻辑，能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。用户在使用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象是如何创建以及如何组织的。有利于整个软件体系结构的优化
• 不难发现，简单工厂模式的缺点也正体现在其工厂类上，由于工厂类集中了所有实例的创建逻辑，所以”高内聚”方面做的并不好。另外，当系统中的具体产品类不断增多时，可能会出现要求工厂类也要做相应的修改，扩展性并不很好。

2.工厂方法模式

2.1 介绍

• 工厂方法模式同样属于类的创建型模式又被称为多态工厂模式。
• 工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。
• 核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口
• 这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

如图，获取需要的类，不再是FruitFactory去实现了，而是交给它的子类工厂去实现

2.2 涉及角色

• 1.抽象工厂（Creator)角色
  工方法模式的核心，任何工厂类都必须实现这个接口。
• 2.具体工厂(Concrete Creator)角色
  具体工厂类是抽象工厂的一个实现，负责实例化产品对象。
• 3.抽象（Product)角色
  工厂方法模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
• 4.具体产品（Concrete Product)角色
  工厂方法模式所创建的具体实例对象

2.3 代码实现

public class MainClass {
	public static void main(String[] args) {
		//AppleFactory
		FruitFactory ff = new AppleFactory();
		Fruit apple = ff.getFruit();
		apple.get();
		
		//BananaFactory
		FruitFactory ff2 = new BananaFactory();
		Fruit banana = ff2.getFruit();
		banana.get();
		
		//PearFactory
		FruitFactory ff3 = new PearFactory();
		Fruit pear = ff3.getFruit();
		pear.get();
	}
}

public interface FruitFactory {
	public Fruit getFruit();
}

public class AppleFactory implements FruitFactory {
	public Fruit getFruit() {
		return new Apple();
	}

}

public class PearFactory implements FruitFactory {
	public Fruit getFruit() {
		return new Pear();
	}
}

public interface Fruit {
	public void get();
}

public class Apple implements Fruit{
    @Override
    public void get() {
        System.out.println("获取苹果");
    }
}

2.4 优缺点

• 工厂方法模式与简单工厂模式在结构上的不同不是很明显。工厂方法类的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。
• 工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工厂类都有共同的接口，或者有共同的抽象父类。
• 当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好的符合了“开放-封闭”原则。
• 而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。工厂方法模式退化后可以演变成简单工厂模式。

3.抽象工厂模式

3.1 介绍

• 抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的。
• 抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，能够创建多个产品族的产品对象。

如图，这个模式不再是通过一个工厂获取一个类了，而是一个工厂可以获取多个类，比如FruitFactory这个类，表示一般性产品，而这个产品下面有两个具体产品NorthFruitFactory,SouthFruitFactory，而每一个Factory不再是只获取一个类（比如不单单是获取Apple或Banana了），而是可以获取Banana和Apple里的不同品种

3.2 涉及角色

• 1抽象工厂（Creator)角色
  搜露工厂模式的核心，包含对多个产品结构的声明，任何工厂类都必须实现这个
• 2.具体工厂（Concrete Creator)角色
  具体工厂类是抽象工厂的一个实现，负责实例化某个产品族中的产品对象。
• 3.抽象（Product)角色
  抽象模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
• 4.具体产品（Concrete Product)角色
  抽象模式所创建的具体实例对象

3.3 代码实现

部分代码

public class MainClass {
	public static void main(String[] args) {
		FruitFactory ff = new NorthFruitFactory();
		Fruit apple = ff.getApple();
		apple.get();
		
		Fruit banana = ff.getBanana();
		banana.get();
		
		FruitFactory ff2= new SouthFruitFactory();
		Fruit apple2 = ff2.getApple();
		apple2.get();
		
		Fruit banana2 = ff2.getBanana();
		banana2.get();
		
		FruitFactory ff3 = new WenshiFruitFactory();
		Fruit apple3 = ff3.getApple();
		apple3.get();
		
		Fruit banana3 = ff3.getBanana();
		banana3.get();
	}
}


public interface FruitFactory {
	//实例化Apple
	public Fruit getApple();
	//实例化Banana
	public Fruit getBanana();
}
public interface Fruit {

	public void get();
}
public abstract class Apple implements Fruit{

	public abstract void get();
}
public abstract class Banana implements Fruit{
	public abstract void get();
}

public class NorthFruitFactory implements FruitFactory {

	public Fruit getApple() {
		return new NorthApple();
	}

	public Fruit getBanana() {
		return new NorthBanana();
	}

}
public class NorthBanana extends Banana {

	public void get() {
		System.out.println("北方香蕉");
	}

}
public class NorthApple extends Apple {

	public void get() {
		System.out.println("北方苹果");
	}

}

3.4 优缺点