简单工厂模式~

我们以生产手机作为应用场景展开讲解！

手机是一个抽象的概念，它包含很多的品牌，例如华为，苹果，小米等等，因此我们可将其抽象为一个接口，如下所示：

public interface tel {
    void produce();
}
1
2
3

苹果手机作为手机的实现类之一实现手机的接口：

public class appleTel implements tel{
    @Override
    public void produce() {
        System.out.println("苹果手机");
    }
}
1
2
3
4
5
6

华为手机也是如此

public class huaweiTel implements tel{
    @Override
    public void produce() {
        System.out.println("华为手机");
    }
}
1
2
3
4
5
6

客户端代码：

public class test {
    public static void main(String[] args) {
    	//生产苹果手机---创建对应的实例对象
        tel tel=new appleTel();
        tel.produce();
        //生产华为手机---创建对应的实例对象
        tel tel1=new huaweiTel();
        tel1.produce();
    }
}
1
2
3
4
5
6
7
8
9
10

如上所示为客户端，每生产一个产品就要实现创建实现类的实例化对象，这种方式既包含对象的创建也包含对象的实现，其耦合度很高，为了将对象的创建与使用分离，隐藏具体实现细节，提高代码的灵活性，我们引入了工厂模式

如下所示我们创建工厂类：

它的作用是将对象的创建逻辑封装起来，其中我们通过if-else语句对客户端传递的参数进行判断，创建对应的实现类的实例化对象，

public class telfactory {
    public tel create(String name){
        if(name.equals("华为")){
            return new huaweiTel();
        } else if(name.equals("苹果")){
            return new appleTel();
        }else {
            return null;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

客户端代码修改如下所示：

与上述相比，我们将具体对象的创建过程隐藏在工厂类中，客户端只需关心所需对象的接口，而无需关心具体的实现细节。这样可以保护对象的具体实现细节，提高代码的安全性。

public class test {
    public static void main(String[] args) {
        //工厂模式---只需要创建工程类的实例化对象，其实现类的对象创建过程在工厂类中完成
        telfactory telfactory=new telfactory();
        telfactory.create("苹果").produce();
        telfactory.create("华为").produce();
    }
}
1
2
3
4
5
6
7
8

上述我们是在工厂类中通过if-else语句进行判断后创建对应的实现类实例化对象，这种方式有很多缺点，它不符合开闭原则，假设未来我们有了更多的实现类，那么必须修改工厂类中的if-else，代码的灵活性并不高。

对此，我们可以再进行优化，在工厂类中我们的判断逻辑不在具体到每个实现类上，而是只需要判断客户端给定的类名通过反射创建的实例对象是否可以上转型成我们的接口类型。

public class telfactory {
    public tel create(String classname) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
    //根据在客户端给定的类名，返回一个Class对象，该对象表示与客户端指定类名对应的类，再调用newInstance()，创建该类的一个实例对象。再将其通过上转型转化为tel接口类型
        if(!(null==classname||"".equals(classname))) {
            return (tel) Class.forName(classname).newInstance();
        }
        return null;
    }
}
1
2
3
4
5
6
7
8
9

客户端只需要指定类名，但是需要注意传入的必须是全类名

public class test {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        telfactory telfactory=new telfactory();
        //传入全类名，以便通过反射创建对应的实现类的实例化对象
        telfactory.create("com.wjr.demo1.telFactory.appleTel").produce();
        telfactory.create("com.wjr.demo1.telFactory.huaweiTel").produce();
    }
}
1
2
3
4
5
6
7
8

上述对工厂类中的代码进行了优化，但客户端需要传入的是字符串的全类名，而且只有当运行之后我们才知道传入的类名是否有问题，这显然不利于我们测试，因此我们可以修改客户端传入的参数类型，通过泛型限定，限定传入的类必须为实现当前接口，假设我们在客户端传入的类不符合，编译器也会及时的报错，以便我们修改和检查

public class telfactory {
    public tel create(Class <? extends tel> clazz) throws ClassNotFoundException, InstantiationException, IllegalAccessException {//通过泛型限定传入的类型必须是tel的实现类
        if(!(null==clazz||"".equals(clazz))) {
            return clazz.newInstance();
        }
        return null;
    }
}
1
2
3
4
5
6
7
8

public class test {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        telfactory telfactory=new telfactory();
        telfactory.create(com.wjr.demo1.telFactory.appleTel.class).produce();
        telfactory.create(com.wjr.demo1.telFactory.huaweiTel.class).produce();
    }
}
1
2
3
4
5
6
7