设计模式--抽象工厂

设计模式--抽象工厂

抽象工厂的特点是产品不只一个，例如，这个工厂中可生产 食物 ，武器，交通工具

在抽象工厂中，可以 有产品A接口 ，产品B接口，产品C接口 等等。。。

具体看抽通过实例看抽象工厂的优势

1、首先声明一个抽象工厂：

public abstract class AbstractFactory {
	public abstract Vechile  createVechile();
	public abstract Weapon createWeapon();
	public abstract Food creatFood();
	 
}

里面包过三个产品 交通工具，武器 和食物

其次看三个接口：

public abstract class Vechile {
	public abstract void run();
}

交通工具有一个方法run;

public abstract class Weapon {
	public abstract void shoot();
}

武器中有一个方法 shoot

public abstract class Food {
    public abstract  void printName();
}

食物有一个抽象方法 printName()

 

2、抽象工厂的实现：

声明一个默认工厂和一个魔法工厂

public class DefaultFactory extends AbstractFactory {
  /*  public Car createCar(){
    	return new Car();
    }
    
    public AK47 createAk47(){
    	return new AK47();
    }
    
    public Apple creaApple(){
    	return new Apple();
    }
*/
	@Override
	public Vechile createVechile() {
		// TODO Auto-generated method stub
		return new Car();
	}

	@Override
	public Weapon createWeapon() {
		// TODO Auto-generated method stub
		return new AK47();
	}

	@Override
	public Food creatFood() {
		// TODO Auto-generated method stub
		return new Apple();
	}
}

声明一个魔法工厂：

public class MagicFactory extends AbstractFactory{
  /* public Broom createBroom(){
	   return new Broom();
   }
   
   public MagicStick CreateMagicStick(){
	   return new MagicStick();
   }
   
   public Mushroom createFood(){
	   return new Mushroom();
   }*/

	@Override
	public Vechile createVechile() {
		// TODO Auto-generated method stub
		return new Broom();
	}

	@Override
	public Weapon createWeapon() {
		// TODO Auto-generated method stub
		return new MagicStick();
	}

	@Override
	public Food creatFood() {
		// TODO Auto-generated method stub
		return new Mushroom();
	}
}

默认工厂和魔法工厂返回的产品各部一样

默认工厂的产品有三个：

交通工具：

public class Car extends Vechile {
	public void run() {
		System.out.println("run run run");
	}

}

武器：

public class AK47 extends Weapon{
   @Override
   public void shoot(){
	   System.out.println("da da da ...");
   }
   
}

食物：

public abstract class Food {
    public abstract  void printName();
}

魔法工厂的产品有三个：

交通工具扫把：

public class Broom extends Vechile {
   public void run(){
	   System.out.println("hu hu hu hu run");
   }
}

武器 魔棒：

public class MagicStick extends Weapon{

	@Override
	public void shoot() {
		// TODO Auto-generated method stub
		System.out.println("huhu hu fire");
	}

}

食物 蘑菇：

public class Mushroom extends Food{

	@Override
	public void printName() {
		System.out.println("I am a mogu");
	}

}

测试：

public class Test {

	public static void main(String[] args) {
 
	 /*  String s1 = "Monday";
	   //==和equals 的区别
	   String s2 = new String("Monday");
	   if(s1 == s2)
	   {
		   System.out.println("s1 ==s2");
	   }
	   else
	   {
		   System.out.println("�����");
	   }
	  
	   System.out.println("Hello World!");*/
		// 抽象工厂模式
		// 能否有工厂产生这一系列产品
		/*Car car = new Car();
		car.run();
		AK47 k =  new AK47();
		k.shhoot();
		Apple a = new Apple();
		a.printName();*/
		
		
		/**
		 * 抽象工厂模式  可以修改成AbstractFactory 然后里面一系列产品都变了
		 * 甚至最后写在配置文件里面，整个都变了
		 */
		//AbstractFactory f = new DefaultFactory();

		AbstractFactory f = new MagicFactory();
		Vechile c = f.createVechile();
		c.run();
		Weapon k = f.createWeapon();
		k.shoot();
		Food a = f.creatFood();
		a.printName();

	}

}

看测试类，下次要生成不同的工厂只需要修改：

AbstractFactory f = new DefaultFactory();

这个换成:

AbstractFactory f = new MagicFactory();

其他的代码不用改动，生产的产品是完全不一样的，甚至把defaultFactory ， MagicFactory 都写在配置文件中加载后，结果也是不一样的。就省了写很多代码了