简说工厂模式

设计模式之工厂模式

定义

工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。 —— [ 百度百科 ]

分类

• 简单工厂
• 工厂方法
• 抽象工厂

解释说明

简单工厂

当调用方需要实例化类的对象的时候，向工厂类传递约定的参数，工厂类则根据所传参数的不同，实现动态的实例化不同的类的对象，并将其返回给调用方。

代码块

public class Test { 
    //定义实现类接口  
    interface Person{  
        public abstract void say(); 
    }  
    //具体实现 -男人类 
    class Man implements Person{
        @Override  
        public void say(){  
            System.out.println("我是男人");  
        }  
    }  
    //具体实现 -女人类
    class Woman implements Person{  
        @Override  
        public void say(){  
            System.out.println("我是女人");  
        }  
    }   
    //简单工厂  
    class SimpleFactory{  
        public Person createPerson(int type){  
            Person person = null;  
            if(type == 1){
                person = new Man();
            }
            if(type == 2){
                person = new Woman();
            }
            return person;  
        }  
    } 
    public static void main(String[] args) {
        //实例化工厂对象
        SimpleFactory factory = new Test().new SimpleFactory();
        //传递约定参数1，返回Man 对象      
        Person person = factory.createPerson(1);  
        person.say(); 
        //传递约定参数2，返回Woman 对象
        person = factory.createPerson(2); 
        person.say();  
    }
}

: 以上就是简单工厂的完整代码实例。在main方法中，当我们需要Man对象或者Woman对象时，将实例化对象的操作交给了SimpleFactory工厂类去实现。换言之也就是我们的客户端｛main方法｝只关心我需要什么对象，我把需要的条件信息（1代表man，2代表woman）传递给服务端（SimpleFactory工厂类），服务端去完成实例化对象的操作（可以是相当复杂的实例化对象操作）。这样既减轻了客户端的压力，同时也封装了不同对象实例化的过程。

工厂方法

抽象出统一的实例化对象方法，然后由不同的工厂类实现该方法，从而实例化不同的类对象

public class Test { 
    //接口  
    interface Person{  
        public abstract void say(); 
    }  
    //具体实现 -男人类 
    class Man implements Person{
        @Override  
        public void say(){  
            System.out.println("我是男人");  
        }  
    }  
    //具体实现 -女人类
    class Woman implements Person{  
        @Override  
        public void say(){  
            System.out.println("我是女人");  
        }  
    } 

    //简单工厂接口  
    interface SimpleFactory{  
        Person getPerson();  
    }

    //男人工厂类 
    class ManFactory implements SimpleFactory{
        @Override  
        public Person getPerson(){  
            return new Man(); 
        }  
    }  
    //女人工厂类
    class WomanFactory implements SimpleFactory{  
        @Override  
        public Person getPerson(){  
            return new Woman(); 
        }  
    }   

    public static void main(String[] args) {
        //实例化男人工厂类
        SimpleFactory manFactory = new Test().new ManFactory();
        Person man = manFactory.getPerson();
        man.say(); 

        //实例化女人工厂类
        SimpleFactory womanFactory = new Test().new WomanFactory();
        Person woman = womanFactory.getPerson();
        woman.say();         
    }
}

: 以上就是工厂方法完整代码实例。简单工厂其实是被归类为工厂方法中的一种特例的。从两个代码实例上来分析，两者其实是非常类似的。本人在学习过程当中认为，工厂方法其实是简单工厂的高度抽象。将简单工厂中的工厂类，进一步抽象出创建实例的接口，而简单工厂中的实例化对象方法则被演变成了实现创建实例接口的子类工厂类。看似是将实例化对象的过程复杂化了，其实我们是将实例化对象的过程不断分层，降低耦合，对扩展开放，对修改封闭从而提高了我们代码的可维护性和扩展性。