设计模式之工厂模式和抽象工厂模式

工厂模式（Factory Pattern）的意义就跟它的名字一样，在面向对象程序设计中，工厂通常是一个用来创建其他对象的对象。工厂模式根据不同的参数来实现不同的分配方案和创建对象。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。例如用工厂来创建人这个对象，如果我们需要一个男人对象，工厂就会为我们创建一个男人；如果我们需要一个女人，工厂就会为我们生产一个女人。

工厂模式通常分为：
普通工厂模式
多个工厂方法模式

静态工厂方法模式

/*
 *工厂模式： 在创建对象时不会对客户端暴露创建裸机，而是通过使用一个共同的接口来指向
 *新创建的对象。
 * 普通工厂模式：
 * 多个工厂方法模式：普通工厂模式中，如果传递的字符串出错，则不能正确创建对象，多个宫广场方法模式是
 *                  提供多个工厂方法，分别创建对象
 * 静态工厂方法模式：将多个催工厂方法模式里的方法设置为静态的，则测试或是使用时不需要创建实例，可以直接调用
 */



 interface Person{//两个类的共同接口
	public void eat();
	public void sleep();
	public void beat();
}

 class Female implements Person{
	public void eat(){
		System.out.println("Female can eat");
	}
	public void sleep(){
		System.out.println("Female can sleep");
		
	}
	public void beat(){
		System.out.println("Female can beat");
	}
}
 class Male implements Person{
	public void eat(){
		System.out.println("Male can eat");
	}
	public void sleep(){
		System.out.println("Male can sleep");
	}
	public void beat(){
		System.out.println("Male can beat");
	}
}

// class HumanFactory{//创建普通工厂类
//	public Person createHuman(String gender){
//		if(gender.equals("male")){
//			return new Male();
//		}else if(gender.equals("female")){
//			return new Female();
//		}else {
//			System.out.println("请输入正确的类型：");
//			return null;
//		}
//	}
//}
//
//public class Main {//普通工厂测试类
//	public static void main(String[] args){
//		HumanFactory factory=new HumanFactory();
//		Person male=factory.createHuman("male");
//		male.eat();
//		male.sleep();
//		male.beat();
//	}
//}
 
/*
 * 测试结果：
 * 	Male can eat
 	Male can sleep
	Male can beat 
 */

//  class HumanFactory{//创建多个工厂方法
//	 public Male createMale(){
//		 return new Male();
//	 }
//	 public Female createFemale(){
//		 return new Female();
//	 }
// }
//  public class Main{//多个工厂方法测试类
//	  public static void main(String args[]){
//		  HumanFactory factory = new HumanFactory();
//		  Person male= factory.createMale();
//		  male.eat();
//		  male.sleep();
//		  male.beat();
//	  }
//  }
//  /*
//   * 测试结果：
//   * Male can eat
//   	 Male can sleep
//  	 Male can beat 
//   */

 class HumanFactory{//静态工厂方法
	 public static Male createMale(){
		 return new Male();
	 }
	 public static Female createFemale(){
		 return new Female();
	 }
 }
 public class Main{//静态工厂方法模式测试
	 public static void main(String args[]){
		 Person male=HumanFactory.createMale();
		 male.eat();
		 male.sleep();
		 male.beat();
	 }
 }
 /*
  * 测试结果：
  * Male can eat
	Male can sleep
	Male can beat

  */

/*
 * 抽象工厂模式：
 * 工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，
 * 必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，
 * 如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，
 * 直接增加新的工厂类就可以了，不需要修改之前的代码。
 */
interface Sender{
	public void Send();
}
 class MailSender implements Sender{

	@Override
	public void Send() {
		// TODO Auto-generated method stub
		System.out.println("It's a mailSender!");
	}
	
}
 class SmsSender implements Sender{

	@Override
	public void Send() {
		// TODO Auto-generated method stub
		System.out.println("It's a SmsSender");
	}
	 
 }
 
 interface Provider{
	 public Sender produce();
 }
 
class SendMailFactory implements Provider{

	@Override
	public Sender produce() {
		// TODO Auto-generated method stub
		return new MailSender();
	}
	 
 }
 class SendSmsFactory implements Provider{

	@Override
	public Sender produce() {
		// TODO Auto-generated method stub
		return new SmsSender();
	}
	 
 }

public class Main {
	public static void main(String args[]){
		Provider provider = new SendMailFactory();
		Sender sender = provider.produce();
		sender.Send();
	}

}

/*
 * 测试结果：It's a mailSender!
 */

Reference: https://blog.csdn.net/doymm2008/article/details/13288067

设计模式之工厂模式和抽象工厂模式

猜你喜欢