Factory design pattern in java
来源:互联网 发布:搜狗推广账户怎么优化 编辑:程序博客网 时间:2024/05/17 03:47
What is the most usual method of creating an instance of a class in java? Most people will answer this question: “using new keyword“. Well, it is considered old fashioned now. Lets see how??
If object creation code is spread in whole application, and if you need to change the process of object creation then you need to go in each and every place to make necessary changes. After finishing this article, while writing your application, consider using factory pattern.
In my previous post, “Singleton design pattern in java“, we discussed various ways to create an instance of a class such that there can not exist another instance of same class in same JVM.
In this post, i will demonstrate another creational pattern, i.e. Factory pattern, for creating instances for your classes. Factory, as name suggest, is a place to create some different products which are somehow similar in features yet divided in categories.
In java also, factory pattern is used to create instances of different classes of same type.
1 Background information
This pattern introduces loose coupling between classes which is the most important principle one should consider and apply while designing the application architecture. Loose coupling can be introduced in application architecture by programming against abstract entities rather than concrete implementations. This not only makes our architecture more flexible but also less fragile.
A picture is worth thousand words. Lets see how a factory implementation will look like.
Above class diagram depicts a common scenario using example of car factory which is able to build 3 types of cars i.e. small, sedan and luxury. Building a car requires many steps from allocating accessories to final makeup. These steps can be written in programming as methods and should be called while creating an instance of a specific car type.
If we are unfortunate then we will create instances of car types (e.g. SmallCar) in our application classes and thus we will expose the car building logic to outside world and this is certainly not good. It also prevents us in making changes to car making process because code in not centralized, and making changes in all composing classes seems not feasible.
2 Implementation
So far we have seen the classes need to be designed for making a CarFactory. Lets hit the keyboard now and start composing our classes.
CarType.java will hold the types of car and will provide car types to all other classes
package designPatterns.creational.factory;public enum CarType { SMALL, SEDAN, LUXURY}
Car.java is parent class of all car instances and it will also contain the common logic applicable in car making of all types.
package designPatterns.creational.factory;public abstract class Car { public Car(CarType model) { this.model = model; arrangeParts(); } private void arrangeParts() { // Do one time processing here } // Do subclass level processing in this method protected abstract void construct(); private CarType model = null; public CarType getModel() { return model; } public void setModel(CarType model) { this.model = model; }}
LuxuryCar.java is concrete implementation of car type LUXURY
package designPatterns.creational.factory;public class LuxuryCar extends Car { LuxuryCar() { super(CarType.LUXURY); construct(); } @Override protected void construct() { System.out.println("Building luxury car"); // add accessories }}
SmallCar.java is concrete implementation of car type SMALL
package designPatterns.creational.factory;
public class SmallCar extends Car { SmallCar() { super(CarType.SMALL); construct(); } @Override protected void construct() { System.out.println("Building small car"); // add accessories }}
SedanCar.java is concrete implementation of car type SEDAN
package designPatterns.creational.factory;public class SedanCar extends Car { SedanCar() { super(CarType.SEDAN); construct(); } @Override protected void construct() { System.out.println("Building sedan car"); // add accessories }}
CarFactory.java is our main class implemented using factory pattern. It instantiates a car instance only after determining its type.
package designPatterns.creational.factory;public class CarFactory { public static Car buildCar(CarType model) { Car car = null; switch (model) { case SMALL: car = new SmallCar(); break; case SEDAN: car = new SedanCar(); break; case LUXURY: car = new LuxuryCar(); break; default: // throw some exception break; } return car; }}
In TestFactoryPattern.java, we will test our factory code. Lets run this class.
package designPatterns.creational.factory;public class TestFactoryPattern { public static void main(String[] args) { System.out.println(CarFactory.buildCar(CarType.SMALL)); System.out.println(CarFactory.buildCar(CarType.SEDAN)); System.out.println(CarFactory.buildCar(CarType.LUXURY)); }}Output:Building small cardesignPatterns.creational.factory.SmallCar@7c230be4Building sedan cardesignPatterns.creational.factory.SedanCar@60e1e567Building luxury cardesignPatterns.creational.factory.LuxuryCar@e9bfee2
As you can see, factory is able to return any type of car instance it is requested for. It will help us in making any kind of changes in car making process without even touching the composing classes i.e. classes using CarFactory.
3 Advantages of factory pattern
By now, you should be able to count the main advantages of using factory pattern. Lets note down:
The creation of an object precludes its reuse without significant
duplication of code. The creation of an objectrequires access to information or resources that should not be
contained within the composing class. The lifetimemanagement of the generated objects must be centralized to ensure a
consistent behavior within the application.
4 Final notes
Factory pattern is most suitable where there is some complex object creation steps are involved. To ensure that these steps are centralized and not exposed to composing classes, factory pattern should be used. We can see many examples of factory pattern in JDK itself e.g.
- java.sql.DriverManager#getConnection()
- java.net.URL#openConnection()
- java.lang.Class#newInstance()
- java.lang.Class#forName()
I hope, I have included enough information to make this post informative. If you still have some doubt, please leave a comment. I will be happy to discuss with you.
Happy Learning !!
转载自 http://howtodoinjava.com
- Factory design pattern in java
- Java Design Pattern: Factory
- Java Design Pattern: Abstract Factory
- java design pattern (1. Factory Method pattern)
- Design Pattern --- Factory Pattern
- Design Pattern - Factory Pattern
- Design Pattern - Factory Pattern
- Builder design pattern in java
- Prototype design pattern in Java
- Design Pattern 2-Factory
- [Design Pattern]:Factory
- The Factory Design Pattern
- Design Pattern Abstract Factory
- Design Pattern Factory Method
- Design Pattern :Simple Factory
- Design pattern:Factory Method
- Design Pattern:Abstract Factory
- Design pattern-Factory method
- JQuery WebCam 网页拍照配置 保存服务端
- HDU 4500 模拟 (类似于种子填充)
- some code about intent
- CALayer 详解(转载)
- 二分图
- Factory design pattern in java
- ARM汇编程序---通过ARM汇编调用C语言函数实现累加
- Java基础——面向对象+(匿名)对象+封装(修饰符权限)+变量+构造函数+This关键字
- Java web基础总结五之—— HttpServletRequest与HttpServletResponse
- Spark导入eclipse
- 限制字符串输入——正则表达式(VB.NET)
- java外观模式
- JS原型与原型链终极详解
- tomcat user 配置