【java设计模式】工厂模式 （工厂方法，抽象工厂，简单工厂）

首先看一下简单工厂模式：（一个抽象类，多个具体实现类，一个工厂类）

步骤一：建立接口Sender

public interface Sender {
    public void Send();
}

步骤二：建立实现类MailSender和SmsSender

public class MailSender implements Sender{

	public void Send() {
		 System.out.println("这是Mail发送方式");
	}

}

public class SmsSender implements Sender{

	public void Send() {
		System.out.println("这是SMS发送方式");
	}

}

步骤三：建立管理实现类的工厂类

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("请输入正确类型");
    			return null;
    		}
    }
}

建立测试类

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

工厂方法类（一个抽象产品类，多个具体产品实现类，一个抽象工厂类，多个具体工厂类，每个具体工厂类只能创建【一个】具体产品类的实例）

步骤一：建立 抽象产品类Sender

public interface Sender {
   public void send();
}

步骤二：建立 多个具体产品实现类MailSender 和SmsSender

public class MailSender implements Sender{

	public void send() {
		System.out.println("这是邮箱发送方式");
	}
}

public class SmsSender implements Sender{

	@Override
	public void send() {
		 System.out.println("这是短信发送方式");
	}
}

步骤三：建立  一个抽象工厂类Provider

public interface Provider {
  public Sender produce();
}

步骤四：建立具体工厂具体实现类（只能创建一个具体产品类的实例）

public class SendMailFactory implements Provider{

	@Override
	public Sender produce() {
		return new MailSender();
	}
}

public class SendSmsFactory implements Provider {

	@Override
	public Sender produce() {
		return new SmsSender();
	}
   
}

步骤五：建立测试类

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

抽象工厂模式（多个抽象产品类，多个具体产品类，一个抽象工厂类，多个具体工厂类，每个具体工厂类可以创建【多个】具体产品类的实例）

步骤一：创建一个抽象产品类。其中定义抽象产品公有的属性方法

public interface IUser {
  public void serUserName();
}

步骤二：定义抽象产品的实现类（这里有两个，一个SqlServerUser，一个AccessUser）

public class SqlServerUser implements IUser {

	public void serUserName() {
        System.out.println("我是sqlServer");		
	}
}

public class AccessUser implements IUser {

	public void serUserName() {
        System.out.println("我是AccessUser");		
	}
}

步骤三：建立抽象工厂类，里面包含各个工厂公有的方法【抽象工厂的特点：拥有多个产品的实例】

public interface IFractory {
    public void createUser(IUser user);
    public void createDepartment(IDepartment department);
}

步骤四：建立工厂实现类 AccessFactory 和SqlServerFactory 【抽象工厂的特点：拥有多个产品的实例】

public class AccessFactory implements IFractory{

	private SqlServerUser user;
	private IDepartment department;
	@Override
	public void createUser(IUser user) {
	  this.user=(SqlServerUser) user;
	}
	
	@Override
	public void createDepartment(IDepartment department) {
		this.department=department;
	}

}

public class SqlServerFactory implements IFractory{

	private SqlServerUser user;
	private IDepartment department;
	@Override
	public void createUser(IUser user) {
	  this.user=(SqlServerUser) user;
	  user.serUserName();
	}

	@Override
	public void createDepartment(IDepartment department) {
		this.department=department;
		user.serUserName();
	}

}

步骤五：建立测试类

public class Test {
   public static void main(String[] args) {
	   IUser user=new SqlServerUser();
	   IFractory factory=new SqlServerFactory();
	   factory.createUser(user);
  }
}