简单工厂&工厂模式&抽象工厂模式

工厂方法模式——定义了一个创建对象的接口，但由于子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

菜鸟教程

//====================== 简单工厂分割线 ============
class SimplePizzaFactory{
public Pizza createPizza(String type){
Pizza pizza = null;
if (type.equals("PizzaA")){
pizza = new PizzaA();
}else if (type.equals("PizzaA")){
pizza = new PizzaB();
}else if (type.equals("PizzaA")){
pizza = new PizzaC();
}
return pizza;
}
}

interface Pizza{
public void p();
}

class PizzaA implements Pizza{
public void p(){
System.out.println("PizzaA");
}
}
class PizzaB implements Pizza{
public void p(){
System.out.println("PizzaB");
}
}
class PizzaC implements Pizza{
public void p(){
System.out.println("PizzaC");
}
}

// ====================== 工厂模式分割线 ============

//	1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
//	2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
//	3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
//	4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

//	这样的好处是不用违反开闭原则了

//1)抽象工厂角色
abstract class AbFactory{
public abstract Car createBenCar();

}

//2)具体工厂角色
class Ben1Factory extends AbFactory{
public Car createBenCar(){
return new Ben1();
}
}
class Ben2Factory extends AbFactory{
public Car createBenCar(){
return new Ben2();
}
}
class Ben3Factory extends AbFactory{
public Car createBenCar(){
return new Ben3();
}
}

//3)抽象产品角色
interface Car{
void drive();
}

//4)具体产品角色
class Ben1 implements Car{
public void drive() {
System.out.println("Ben1");
}

}
class Ben2 implements Car{
public void drive() {
System.out.println("Ben2");
}
}
class Ben3 implements Car{
public void drive() {
System.out.println("Ben3");
}
}

菜鸟教程

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

工厂方法模式：创建一种产品。（例如，同一个公司）

抽象工厂：它负责创建一族产品。（例如，同一类产品）

//====================== 抽象工厂分割线 ============

abstract class ABFactory{
public abstract AA createA();
public abstract BB createB();
}
class Factory1 extends ABFactory{
public AA createA() {
return new A1();
}

public BB createB() {
return new B1();
}

}
class Factory2 extends ABFactory{
public AA createA() {
return new A2();
}

public BB createB() {
return new B2();
}

}

interface AA{
public void p();
}
interface BB{
public void p();
}

class A1 implements AA{
public void p() {
System.out.println("A1");
}
}
class A2 implements AA{
public void p() {
System.out.println("A2");
}
}
class B1 implements BB{
public void p() {
System.out.println("B1");
}
}
class B2 implements BB{
public void p() {
System.out.println("B2");
}
}