CSC/ECE 517 Fall 2007/wiki3 3 ab: Difference between revisions
| Line 21: | Line 21: | ||
There is an Java example of principle of Separation of responsibility. | There is an Java example of principle of Separation of responsibility. | ||
public void createCustomer(Map requestParameters) { | public void createCustomer(Map requestParameters) { | ||
| Line 34: | Line 35: | ||
customerService.save(customer); | customerService.save(customer); | ||
} | |||
The method name is create. While others viewing the the code will expect to have a create function. But instead it has three functionality, creates a customer, checks if it's already exist and then save it. It should divide these functionality into 4 methods. | The method name is create. While others viewing the the code will expect to have a create function. But instead it has three functionality, creates a customer, checks if it's already exist and then save it. It should divide these functionality into 4 methods. | ||
Revision as of 19:03, 17 November 2007
Topic
Take the principle of Separation of Responsibility and catalog the information on it available on the Web. Find good descriptions and good, concise, understandable examples. Tell which you consider the best to present to a class.
Introduction
Separation of Responsibility
In Object-Oriented Design (OOD), each individual object should have as few responsibilities as possible, ideally one responsibility per object. That is to say,
Advantage of using separation of responsibility
Principle of Separation of Responsibility
There are several principles of Separation of Responsibility [1]:
- Single Responsibility Principle (SRP). Different responsibilities should be divided among different objects, in another word, one object should have only one responsibility in ideal situation.
- Encapsulation. One class should be responsible for knowing and maintaining a set of data, even if that data is used by many other classes. In another word, Data should be kept in only one place.
- Expert pattern. The object that contains the necessary data to perform a task should be the object that manipulates the data.
- The Dry principle. Code should not be duplicated. A given functionality should be implemented only in one place in the system.
Example
Java Example
There is an Java example of principle of Separation of responsibility.
public void createCustomer(Map requestParameters) {
Customer customer = new Customer();
customer.setName = requestParameters.get("name");
//Check if a customer was already registered with that name if (customerService.getCustomerByName(customer.getName()) != null) { System.out.println("Customer already exists"); return; } customer.setShoppingCart(new ShoppingCart());
customerService.save(customer); }
The method name is create. While others viewing the the code will expect to have a create function. But instead it has three functionality, creates a customer, checks if it's already exist and then save it. It should divide these functionality into 4 methods.
- bindValidateAndSave The application method. It tells what to do rather than how's done.
- bindCustomer bind and add new shoppingCart.
- validateCustomer validate if customer exist.
- saveCustomer save customer