简单工厂、工厂模式、抽象工厂-优快云博客

本文链接：https://blog.youkuaiyun.com/u014371381/article/details/95193441

简单工厂

接口IUser：

public interface IUser {

	public void add();
	public void remove();
}

SqLiteUser类：

public class SqLiteUser implements IUser {

	@Override
	public void add() {
		System.out.println("SqLiteUser add");
	}

	@Override
	public void remove() {
		System.out.println("SqLiteUser remove");
	}

}

SqServerUser类：

public class SqlServerUser implements IUser {

	@Override
	public void add() {
		System.out.println("SqlServerUser add");
	}

	@Override
	public void remove() {
		System.out.println("SqlServerUser remove");
	}

}

SimpleFactory工厂类：

public class SimpleFactory {

	public IUser CreateIntance(String type) {

		switch (type) {
			case "SqLiteUser":
				return new SqLiteUser();
			case "SqlServerUser":
				return new SqlServerUser();
			default:
				break;
		}
		return null;
	}
}

运行程序：

public class testSimpleFactory {

	public static void main(String[] args) {
		SimpleFactory factory=new SimpleFactory();
		IUser user=factory.CreateIntance("SqLiteUser");
		user.add();
	}
}

简单工厂，若要增加一个新的用户，则需要对SimpleFactory进行修改，违反了开闭原则（对于扩展-->开，对于修改-->闭）。

缺点：当有新需求时，需要频繁修改工厂类，对系统的维护和扩展非常不利。

优点：只需要传参数，创建实例的过程交给工厂类。

工厂模式

Factory类：

public interface Factory {
	public  IUser CreateIntance();
}

MongondbUser类：

public class MongondbUser implements IUser {

	@Override
	public void add() {
		System.out.println("MongondbUser add");
	}

	@Override
	public void remove() {
		System.out.println("MongondbUser remove");
	}
}

MongondbFactory类：


public class MongondbFactory implements Factory {

	@Override
	public IUser CreateIntance() {
		IUser user=new MongondbUser();
		return user;
	}

}

SqLiteFactory类：

public class SqLiteFactory implements Factory {

	@Override
	public IUser CreateIntance() {
		IUser user=new SqLiteUser();
		return user;
	}
}

SqlServerFactory类：

public class SqlServerFactory implements Factory {

	@Override
	public IUser CreateIntance() {
		IUser user=new SqlServerUser();
		return user;
	}
}

运行程序：

public class testfactory {

	public static void main(String[] args) {
		
		MongondbFactory factory=new MongondbFactory();
		IUser user=factory.CreateIntance();
		user.add();	
	}
}

优点：工厂方法模式是对简单工厂模式进一步的解耦，克服了简单工厂会违背开-闭原则的缺点；

缺点：缺点是每增加一个产品类，就需要增加一个对应的工厂类，增加了额外的开发

抽象工厂

新增接口IOrder：

public interface IOrder {

	public void update();

}

对原来的SqLiteFactory、SqlServerFactory、MongondbFactory进行修改

public class MongondbFactory implements Factory {

	@Override
	public IUser CreateUserIntance() {
		IUser user=new MongondbUser();
		return user;
	}

    //新增方法 实现  
    //根据具体类返回对应的Order，SqLiteOrder、SqlServerOrder同理 
	@Override
	public IOrder CreateOrderIntance() {
		IOrder order=new MongondbOrder(); 
		return order;
	}
}

新增SqLiteOrder、SqlServerOrder、MongondbOrder类，实现IOrder接口

public class MongondbOrder implements IOrder {

	@Override
	public void update() {
		System.out.println("MongondbUser update");
	}

}
//SqlServerOrder、SqLiteOrder同理创建

运行程序：

public class testAbstractFactory {

	public static void main(String[] args) {
		
		MongondbFactory factory=new MongondbFactory();
		IUser user=factory.CreateUserIntance();
		user.add();
		
		SqlServerFactory serverFactory=new SqlServerFactory();
		IOrder serverUser=serverFactory.CreateOrderIntance();
		serverUser.update();
	}

}