工厂模式(简单,方法,抽象)

简单工厂

定义
简单工厂模式属于创建型模式又叫做静态工厂方法模式，是由一个工厂对象决定创建出哪一种产品类的实例。
类图

示例代码

//抽象产品
abstract class AbatractProduct {
	public abstract void printName();
}
//产品A
class ProductA extends AbatractProduct {
	public void printName() {
		System.out.println("ProductA");
	}
}
//产品B
class ProductB extends AbatractProduct {
	public void printName() {
		System.out.println("ProductB");
	}
}
//简单工厂
class Factory {
	public static AbatractProduct createProduct(String product) {
		Car c = null;
		if ("A".equalsIgnoreCase(product))
			c = new ProductA();
		else if ("B".equalsIgnoreCase(product))
			c = new ProductB();
		return c;
	}
}
//客户端
public class Client {
	public static void main(String[] args) {
		AbatractProduct product = Factory.createProduct("A");
		car.printName();
	}
}

工厂方法

定义
定义一个用于创建对象的接口，让子类决定实例化哪个类。工厂方法使一个类的实例化延迟到其子类。
类图

示例代码

//抽象产品
abstract class AbatractProduct {
	public abstract void printName();
}
//产品A
class ProductA extends AbatractProduct {
	public void printName() {
		System.out.println("ProductA");
	}
}
//产品B
class ProductB extends AbatractProduct {
	public void printName() {
		System.out.println("ProductB");
	}
} 
//抽象工厂  
abstract class AbstractFactory{  
    public abstract AbatractProduct createProduct() throws Exception;  
}  
//A工厂
class ProductAFactory extends AbstractFactory{  
    public AbatractProduct createProduct() throws Exception {  
        return new ProductA();  
    }  
}  
//B工厂
class ProductBFactory extends AbstractFactory{  
    public AbatractProduct createProduct() throws Exception {  
        return new ProductB();  
    }  
}  
//客户端
public class Client{  
    public static void main(String[] args) throws Exception {  
        AbstractFactory productAFactory = new ProductAFactory();  
        AbatractProduct productA = productAFactory.createProduct();   
        productA.printName();
    }  
}  

抽象工厂

定义
为创建一组相关或者相互依赖的对象提供一个接口，而无需指定它们的具体类。
类图

    //抽象产品A
    abstract class AbstractProductA{   
        public abstract void printName();  
    } 

    //具体产品A1
    class ProductA1 extends AbstractProductA{  
        public void printName(){  
            System.out.println("ProductA1");  
        }  
    }  
    //具体产品A2
    class ProductA2 extends AbstractProductA{  
        public void printName(){  
            System.out.println("ProductA2");  
        }  
    }  
      
    //抽象产品B
    abstract class AbstractProductB{   
        public abstract void printName();  
    } 

    //具体产品B1
    class ProductB1 extends AbstractProductB{  
        public void printName(){  
            System.out.println("ProductB1");  
        }  
    }  

    //具体产品B2
    class ProductB2 extends AbstractProductB{  
        public void printName(){  
            System.out.println("ProductB2");  
        }  
    }  
      
    //抽象工厂  
    abstract class Factory{  
        public abstract AbstractProductA createA();  
        public abstract AbstractProductB createB();  
    }  

    //具体工厂 1 系列 
    class Factory1 extends Factory{  
        public AbstractProductA createA() {  
            return new AbstractProductA1();  
        }  
        public AbstractProductB createB() {  
            return new AbstractProductB1();  
        } 
    }  

    //具体工厂 2 系列
    class Factory2 extends Factory{  
        public AbstractProductA createBenzCar() {  
            return new AbstractProductA2();  
        }  
        public AbstractProductB createBmwCar() {  
            return new AbstractProductB2();  
        }  
    }  

    //客户端
    public class Client {  
        public static void main(String[] args) throws Exception {  
            Factory factory = new Factory1();  
            AbstractProductA productA = factory.createA();  
            productA.print();  
        }  
    }