设计模式

工厂模式

普通工厂模式

--- 发送邮件和短信
- 接口
public interface Sender{
	public void Send();
}




- 实现类
public class MailSender implements Sender{
	@Override
	public void Send(){
		System.out.println("MailSender Method");
	}
}
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
public class SmsSender implements Sender{
	@Override
	public void Send(){
		System.out.println("SmsSender Method");
	}
}




- 工厂类
public class SendFactory{
	public Sender produce(String type){
		if("mail".equals(type)){
			return new MailSender();
		}else if("sms".equals(type)){
			return new SmsSender();
		}else{
			System.out.println("Please input right type!");
		}
	}
}




- 测试类
public class FactoryTest{
	public static void main(String[] args){
			SendFactory factory=new SendFactory();
			Sender sender=factory.produce("sms");
			sender.Send();
	}
}

== 普通工厂缺点是传错值就无法产生对象 ==

多个工厂方法模式

1. 多个工厂方法模式是对普通工厂方法模式的 == 改进 ==

2. 普通工厂方法模式中,如果传递的字符串出错,则不能创建对象

    - SendFactory类
    public class SendFactory{
    		public Sender produceMail(){
    				return new MailSender();
    		}
    
    		public Sender produceSms(){
    				return new SmsSender();
    		}
    }
    
    
    
    
    - 测试类
    public class FactoryTest{
    		public static void main(String[] args){
    				SendFactory factory=new SendFactory();
    				Sender sender=factory.produceMail();
    				sender.Send();
    		}
    }
   

静态工厂方法模式

将多个工厂方法模式中的方法设置为静态方法, == 不需要创建实例 ,直接调用即可==

		- SendFactory
	public class SendFactory{
			public static Sender produceMail(){
					return new MailSender();
			}
	
			public static Sender produceSms(){
					return new SmsSender();
			}
	}
	
	
	
	
	- FactoryTest
	public class FActoryTest{
			public static void main(String[] args){
					Sender sender=SenderFactory.produceMail();
					sender.Send();
			}
	}

总结

	工厂模式适合出现大量的产品需要创建,并且具有共同的接口,可以通过工厂方法模式创建:
	1. 普通工厂模式: 如果传入字符串有误,就不能创建对象
	2. 静态工厂方法模式相对于多个工厂方法模式 ,不需要实例化工厂类
	3. **大多数情况下,采用静态工厂方法模式**

抽象工厂模式(Abstract Factory)

1. 工厂方法模式问题: 类的创建依赖工厂类.如果想要扩展程序,必须对工厂类进行修改,者违背了闭包原则
2. 抽象工厂模式: 创建多个工厂类,一旦需要增加新的功能,直接增加工厂类就可以,不需要修改之前的工厂类

当工厂的规模一定的时候，现在想增加工人的时候，你的办法是什么？

当然是增加一个工厂啦，这些工厂当然都属于我的企业。

所以。。。抽象工厂出来了

- Sender
public interface Sender{
		public void Sender();
}



- 两个实现类
  - MailSender 
public class MailSender implements Sender {
		@Override
		public void Send(){
				System.out.println("This is MailSender!");
		}
}



  - SmsSender
public class SmsSender implements Sender{
		@Override
		public void Send(){
				System.out.println("This is SmsSender!");
		}
}



- 两个工厂类
  - 工厂类接口:
public interface Provider{
		public Sender produce();
}
  - SendMailFactory
public class SendMailFactory implements Provider{
		@Override
		public Sender produce(){
				return new MailSender();
		}
}
  - SendSmsFactory
public class SendSmsFactory implements Provider{
		@Override
		public Sender produce(){
				return new SmsSender();
		}
}




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

         如果需要增加一个功能,例如:发及时信息
              1. 只需做一个实现类, 实现Sender接口
              2.  做一个工厂类, 实现Provider接口
**工人要实现统一的标准所以要实现同一个接口，工厂也要实现同一个的标准所以要实现统一的接口**

如果一个工厂已经有了一些业务，想要在扩大业务必须将工厂进行拓宽；
现在的想法是去吞并一个这样业务的企业，都变成我的工厂；
这样工厂就变多了