定义: 专门定义一个类用来负责建立其余类的实例,被建立的类一般具备共同的父类(没有也行)java
//产品类:
public interface Product {
void hasFeature();
}
//继承产品的子类A产品
public class ProductA implements Product {
public void hasFeature() {
System.out.println("A产品的特色:好看!");
}
}
//继承产品的子类B产品
public class ProductB implements Product {
public void hasFeature() {
System.out.println("B产品的特色:实用!");
}
}
复制代码
对于产品实例的建立,咱们能够建立一个工厂来负责建立他们,须要什么样的产品传入相应的产品参数spa
public class ProductFactory {
public static Product createProduct(ProductType pt) throws Exception {
switch (pt) {
case PRODUCT_A:
return new ProductA();
case PRODUCT_B:
return new ProductB();
default:
throw new Exception("请输入正确产品,才能够生产!");
}
}
}
public enum ProductType {
PRODUCT_A,
PRODUCT_B
}
//调用工厂为咱们建立对象
public class ToolUser {
public static void main(String[] args) {
try {
//根据传入的参数选择建立的产品
Product pa = ProductFactory.createProduct(ProductType.PRODUCT_A);
pa.hasFeature();
ProductB pb = (ProductB) ProductFactory.createProduct(ProductType.PRODUCT_B);
pb.hasFeature();
} catch (Exception e) {
e.printStackTrace();
}
}
}
复制代码
这种模式能够管理对象的建立,可是若是再生产一种产品C,须要改动工厂和枚举,耦合性比较大。code
定义: 建立一个生产对象的接口,让子类决定实例化哪个类。工厂方法使一个类的实例化延迟到其子类.对象
为了解决上述耦合过强的问题,咱们将工厂类变得抽象,在工厂方法模式中,核心的工厂类再也不负责全部的产品的建立,而是将具体建立的工做交给子类去作,工厂自身只提供建立产品的接口。继承
//工厂的做用就是生产产品
public interface Factory {
Product createProduct();
}
//A工厂负责生产A产品
public class ProductAFactory implements Factory {
public Product createProduct() {
return new ProductA();
}
}
//B工厂负责生产B产品
public class ProductBFactory implements Factory {
public Product createProduct() {
return new ProductB();
}
}
public class Main {
public static void main(String[] args) {
//工厂模式须要先建立相应产品工厂,再建立相应产品
ProductAFactory pa = new ProductAFactory();
pa.createProduct().hasFeature();
ProductBFactory pb = new ProductBFactory();
pb.createProduct().hasFeature();
}
}
结果:
A产品的特色:好看!
B产品的特色:实用!
复制代码
在上面的代码中,若是须要生产产品C,咱们只须要实现工厂接口,建立C工厂类便可,这遵循了开闭原则:
对扩展开放,对修改关闭接口
定义: 提供一个建立一系列相关或者相互依赖对象的接口,而无需指定他们具体的类.当一系列对象变成一种,这时就是工厂模式,能够看出工厂模式是抽象工厂模式的特例。string
工厂模式中,在工厂中生产产品,产品是须要人使用的,因此能够在工厂中不只指定生产产品,还能够指定产品使用者,咱们还能够指定产品品牌,产品发货地等一系列特性。产品
//抽象工厂,用于指定生成产品和产品使用者
public interface AbstractFactory {
//没必要指定具体的产品类型,这里符合里氏替换原则,全部接受父类型的地方也须要接受子类型
Product createProduct();
Person createPerson();
}
//A产品工厂:生成A产品 使用者为A
public class ProductAFactory implements AbstractFactory {
public Product createProduct() {
return new ProductA();
}
public Person createPerson() {
return new PersonA();
}
}
//B产品工厂:生成B产品 使用者为B
public class ProductBFactory implements AbstractFactory {
public Product createProduct() {
return new ProductB();
}
public Person createPerson() {
return new PersonB();
}
}
//使用者接口
public interface Person {
void say();
}
//A使用者
public class PersonA implements Person {
public void say() {
System.out.println("使用者A");
}
}
//B使用者
public class PersonB implements Person {
public void say() {
System.out.println("使用者B");
}
}
复制代码
接下来开始加工生产:it
public class Main {
public static void main(String[] args) {
ProductAFactory pa = new ProductAFactory();
pa.createProduct().hasFeature();
pa.createPerson().say();
ProductBFactory pb = new ProductBFactory();
pb.createProduct().hasFeature();
pb.createPerson().say();
}
}
结果:
A产品的特色:好看!
使用者A
B产品的特色:实用!
使用者B
复制代码