设计模式（一）工厂模式（创建型）

 简单工厂模式

     一个抽象产品类，可以派生出多个具体产品类；

     一个具体工厂类，可以创建多个具体产品的实例。

       抽象产品类定义

public abstract class Sender {
	
	void send(){
		
	};

}

       具体产品类定义

    邮件产品类

public class MailSender extends Sender{
	
	public void send(){
	  System.out.println("Mail Sender!");	
	}
}

    短信产品类

public class SmsSender extends Sender{
	
	public void send(){
		  System.out.println("Sms Sender!");	
	}

}

    简单工厂类

public class SimpleFactory {
	
	public static MailSender createMailSender(){
		return new MailSender();
	}
	
	public static SmsSender createSmsSender(){
		return new SmsSender();
	}

}

        测试类

public class SimpleFactoryTest {

	public static void main(String[] args) {
		Sender mailSender = SimpleFactory.createMailSender();
		mailSender.send();
		
		Sender smsSender = SimpleFactory.createSmsSender();
		smsSender.send();
	}

}

     工厂方法模式

         一个抽象产品类，可以派生出多个具体产品类；

         一个抽象工厂类，可以派生出多个具体工厂类；

         每个具体工厂类只能创建一个具体产品类的实例。

         抽象产品类定义

public abstract class Fruit {
	
	void print(){
		
	};

}

        具体产品类定义

public class Apple extends Fruit{
	
	public void print(){
		System.out.println("apple");
	}

}

public class Pear extends Fruit{
	
	public void print(){
		System.out.println("pear");
	}

}

    工厂方法抽象类定义

public abstract class Factory {
	
	abstract Fruit create();

}

    工厂方法具体工厂类定义：

public class AppleFactory extends Factory{
	
	public Fruit create(){
		return new Apple();
	}

}

public class PearFactory extends Factory{
	
	public Fruit create(){
		return new Pear();
	}

}

      测试类

public class MethodFactoryTest {
	
	public static void main(String[] args) {
		Factory appleFactory = new AppleFactory();
		Fruit apple = appleFactory.create();
		apple.print();
		
		Factory pearFactory = new PearFactory();
		Fruit pear = pearFactory.create();
		pear.print();
	}

}

       

     抽象工厂模式

       多个抽象产品类，每个抽象产品类可以派生出多个具体的产品类；

       一个抽象工厂类，可以派生出多个具体工厂类；

       每个具体工厂类可以创建多个具体产品类的实例。

     抽象产品类定义

public abstract class Fruit {
	
	void print(){
		
	};

}

public abstract class Car {

	void print(){
		
	};
	
}

     具体产品类定义

public class Apple extends Fruit{
	
	public void print(){
		System.out.println("apple");
	}

}

public class Pear  extends Fruit{
	
	public void print(){
		System.out.println("pear");
	}

}

public class Bmw extends Car{
	
	public void print(){
		System.out.println("bmw");
	}

}

public class Buick extends Car{
	
	public void print(){
		System.out.println("buick");
	}

}

     抽象工厂抽象类定义

public abstract class AbstractFactory {
	
	abstract Fruit createFruit();
	
	abstract Car createCar();

}

    抽象工厂具体工厂类定义

public class BmwAppleFactory extends AbstractFactory{
	
    public Fruit createFruit(){
    	return new Apple();
    }
	
    public Car createCar(){
    	return new Bmw();
    }

}

public class BuickPearFactory extends AbstractFactory{
	
	public Fruit createFruit(){
    	return new Pear();
    }
	
    public Car createCar(){
    	return new Buick();
    }

}

     测试类

public class AbstractFactoryTest {
	
	public static void main(String[] args) {
		AbstractFactory bmwAppleFactory = new BmwAppleFactory();
		Car car1 = bmwAppleFactory.createCar();
		Fruit fruit1 = bmwAppleFactory.createFruit();
		car1.print();
		fruit1.print();
		
		AbstractFactory buickPearFactory = new BuickPearFactory();
		Car car2 = buickPearFactory.createCar();
		Fruit fruit2 = buickPearFactory.createFruit();
		car2.print();
		fruit2.print();
	}

}

      工厂方法和抽象工厂的区别：

         工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。

         工厂方法模式的具体工厂类只能创建一个具体产品的实例，而抽象工厂模式可以创建多个。