工厂方法模式:
1.抽象工厂:该方法返回一个抽象类型的产品(Factory)
2.具体工厂:实现抽象工厂返回的具体产品类型(AccessFactory,SqlFactory)
3.抽象产品:抽象产品类型,用于抽象工厂返回(dbUser)
客户端代码:
1.抽象工厂:该方法返回一个抽象类型的产品(Factory)
2.具体工厂:实现抽象工厂返回的具体产品类型(AccessFactory,SqlFactory)
3.抽象产品:抽象产品类型,用于抽象工厂返回(dbUser)
4.具体产品:实现抽象产品,用于具体产品返回(AccessUser,SqlUser)
将一切都抽象,面积接口编程,这也是依赖倒置原则的体现,
之所以面向接口编程,因为你大都使用接口的话,如 void display(List list){.....}
这个方法的话,参数为List ,而我们在调用的时候,可以为其传入 ArrayList,linkedList,等等,这样灵活性较大
还有: 如下面的例子
定义产品的抽象,如果将数据的所有操作都规划,之所以将产品抽象化的原因是如下:
我们定义一个数据库 操作user表: DbUser db = new AccessDbUser(); 我们可以操作Access数据库
过一段时间,我们想用SqLServer, 则:db = new SQLDbUser() 我们又可以操作SQLServer
而下面以前写的代码:
db.insert()
db.query()
db.delete()
db.select()
..................
等等一系列的操作都不用变,想换一个数据库,只因改了上面的一个语句,日,这太给力了......^_^
public interface DbUser {
void insert(User user);
void get(String id);
}
//由于各个数据库产品的操具体细节不同,所以将它们各自细节化
public class AccessUser implements DbUser {
@Override
public void get(String id) {
System.out.println("Access get");
}
@Override
public void insert(User user) {
System.out.println("Access insert");
}
}
public class SqlUser implements DbUser{
@Override
public void insert(User user) {
System.out.println("SQL insert");
}
@Override
public void get(String id) {
System.out.println("SQL get");
}
}
/**
*将生产产品的抽象化,这样利用多态能生产出不同的产品,如 Factory factory = new AccessFactory(),则产品Access,再 factory = new SqlserverFactory()就又能产生SQLServer
* 范型工厂方法
*
* @param <T>
*/
public interface Factory<T> {
T create();
}
public class AccessUserFactory implements Factory<AccessUser>{
@Override
public AccessUser create() {
return new AccessUser();
}
}
public class SqlUserFactory implements Factory<SqlUser> {
@Override
public SqlUser create() {
return new SqlUser();
}
}
客户端代码:
package abstractfactory;
public class Client {
public static void main(String args[]) {
User user = new User();
//这里是用<>指明了工厂的类型,但好多地方是将工厂做为一个方法传进去
Factory<SqlUser>factory = new SqlUserFactory();// 若要改成access数据库,则修改这一句就可以了
DbUser db = factory.create(); // 这样做的好处是不用再改其它代码,因为 dbUser是接口,下面的代码都不需要再改了,这就是面象接口编程的好处
db.insert(user);
db.get("1");
}
}