**定义**：为创建一组相关或相互依赖的对象提供一个接口，而且无须指定他们的具体类。
我的理解:抽象工厂模式是工厂模式的升级，它针对多个业务品种，业务分类时通过抽象工厂模式来解决。
就好比工厂中的流水线工作一样。
**一个例子**：
还是继续女娲造人的故事，女娲在制造出白人、黑人、黄种人之后，又想创造出男人和女人。那么如何来解决这个需求呢？
**解决方案**:
1、定义一个接口Human，提供getSkin()，talk(),getSex()方法。
2、使用抽象类继承自Human,分别实现不同肤色人的共有方法。
3、各种肤色的人拥有男性和女性类。
4、定义一个创建工厂接口，创建男性和女性工厂的类来实现不同种类的男性和女性的创建
工厂模式只要你知道创建工厂的类及方法，就能创造出一个与之无关的其他类，而不必去管它具体是怎么创建出来的。
~~~
public class HumanTest {
public static void main(String[] args) {
System.out.println("--------女性工厂-------------------");
FemaleYellowHuman femaleYellow = (FemaleYellowHuman) new FemaleFactory().createYellowHuman();
femaleYellow.getSex();
femaleYellow.getSkin();
femaleYellow.talk();
System.out.println("--------男性工厂---------------");
MaleYellowHuman maleYellow = (MaleYellowHuman) new MaleFactory().createYellowHuman();
maleYellow.getSex();
maleYellow.getSkin();
maleYellow.talk();
}
}
interface Human{
//获取肤色
void getSkin();
//说话语言
void talk();
//性别
void getSex();
}
abstract class AbstractBlack implements Human{
public void getSkin(){
System.out.println("我是黑人,拥有黑色的皮肤...");
}
@Override
public void talk() {
System.out.println("我是黑人,说的是非洲语...");
}
}
abstract class AbstractYellow implements Human{
public void getSkin(){
System.out.println("我是黄种人,拥有黄色的皮肤...");
}
@Override
public void talk() {
System.out.println("我是黄种人,说的是汉语...");
}
}
abstract class AbstractWhite implements Human{
public void getSkin(){
System.out.println("我是白种人,拥有白色的皮肤...");
}
@Override
public void talk() {
System.out.println("我是白种人,说的是英语...");
}
}
class FemaleBlackHuman extends AbstractBlack{
@Override
public void getSex() {
System.out.println("我是非洲女人...");
}
}
class MaleBlackHuman extends AbstractBlack{
@Override
public void getSex() {
System.out.println("我是非洲男人...");
}
}
class FemaleYellowHuman extends AbstractYellow{
@Override
public void getSex() {
System.out.println("我是中国女人...");
}
}
class MaleYellowHuman extends AbstractYellow{
@Override
public void getSex() {
System.out.println("我是中国男人...");
}
}
class FemaleWhiteHuman extends AbstractWhite{
@Override
public void getSex() {
System.out.println("我是美国女人...");
}
}
class MaleWhiteHuman extends AbstractWhite{
@Override
public void getSex() {
System.out.println("我是美国男人...");
}
}
interface HumanFactory{
//创建黑人
Human createBlackHuman();
//创建黄种人
Human createYellowHuman();
//创建白人
Human createWhiteHuman();
}
class FemaleFactory implements HumanFactory{
@Override
public Human createBlackHuman() {
// TODO Auto-generated method stub
return new FemaleBlackHuman();
}
@Override
public Human createYellowHuman() {
// TODO Auto-generated method stub
return new FemaleYellowHuman();
}
@Override
public Human createWhiteHuman() {
// TODO Auto-generated method stub
return new FemaleWhiteHuman();
}
}
class MaleFactory implements HumanFactory{
@Override
public Human createBlackHuman() {
// TODO Auto-generated method stub
return new MaleBlackHuman();
}
@Override
public Human createYellowHuman() {
// TODO Auto-generated method stub
return new MaleYellowHuman();
}
@Override
public Human createWhiteHuman() {
// TODO Auto-generated method stub
return new MaleWhiteHuman();
}
}
~~~
**抽象类的通用模式**;
UML类图:
说明：抽象工厂模式具有很好的封装性，它的一般模式是:一个接口，多个抽象类，N个实现类。
他的产品族扩展比较困难，但是产品的等级易扩展。
~~~
public class AbstractFactoryTest {
public static void main(String[] args) {
System.out.println("---------等级1，的A,B两个产品-------------");
IProduct c1 = new Creator1();
ProductA1 pa1 = (ProductA1) c1.createA();
ProductB1 pb1 = (ProductB1) c1.createB();
pa1.Method();
pb1.Method();
System.out.println("---------等级2，的A,B两个产品-------------");
IProduct c2 = new Creator2();
ProductA2 pa2 = (ProductA2) c2.createA();
ProductB2 pb2 = (ProductB2) c2.createB();
pa2.Method();
pb2.Method();
}
}
interface IProduct{
AbstractProductA createA();
AbstractProductB createB();
}
abstract class AbstractProductA{
public void shareMethod(){
System.out.println("生产产品所共有的方法....");
}
//生产产品不同的方法
public abstract void Method();
}
abstract class AbstractProductB{
public void shareMethod(){
System.out.println("生产产品所共有的方法....");
}
//生产产品不同的方法
public abstract void Method();
}
class ProductA1 extends AbstractProductA{
@Override
public void Method() {
System.out.println("生产产品---A1---的方法 ....");
}
}
class ProductB1 extends AbstractProductB{
@Override
public void Method() {
System.out.println("生产产品---B1---的方法 ....");
}
}
class ProductA2 extends AbstractProductA{
@Override
public void Method() {
System.out.println("生产产品---A2---的方法 ....");
}
}
class ProductB2 extends AbstractProductB{
@Override
public void Method() {
System.out.println("生产产品---B2---的方法 ....");
}
}
class Creator1 implements IProduct{
//生产等级1产品A
@Override
public AbstractProductA createA() {
// TODO Auto-generated method stub
return new ProductA1();
}
//生产等级1产品B
@Override
public AbstractProductB createB() {
// TODO Auto-generated method stub
return new ProductB1();
}
}
class Creator2 implements IProduct{
//生产等级1产品A
@Override
public AbstractProductA createA() {
// TODO Auto-generated method stub
return new ProductA2();
}
//生产等级1产品B
@Override
public AbstractProductB createB() {
// TODO Auto-generated method stub
return new ProductB2();
}
}
~~~
- 前言
- 6大设计原则(一)---单一职责原则
- 6大设计原则(二)---里氏替换原则
- 6大设计原则(三)---依赖倒置原则
- 6大设计模式(四)----接口隔离原则
- 6大设计原则(五)---迪米特法则
- 6大设计原则(六)---开闭原则。
- 设计模式(一)---单例模式
- 设计模式(二)---工厂方法模式
- 设计模式(三)---抽象工厂模式
- 设计模式(四)---模板方法模式
- 设计模式(五)---建造者模式
- 设计模式(六)---代理模式
- 设计模式(七)---原型模式
- 设计模式(八)---中介者模式
- 设计模式(九)---命令模式
- 设计模式(十)---责任链模式
- 设计模式(十一)---装饰模式
- 设计模式(十二)---策略模式
- 设计模式(十三)---适配器模式
- 设计模式(十四)---迭代器模式
- 设计模式(十五)---组合模式
- 设计模式(十六)---观察者模式
- 设计模式(十七)---门面模式
- 设计模式(十八)---备忘录模式
- 设计模式(十八)---访问者模式
- 设计模式(二十)---状态模式
- 设计模式(二十二)---享元模式
- 设计模式(二十三)---桥梁模式