CSC/ECE 517 Fall 2010/ch7 7b jn

Information Expert Pattern

INTRODUCTION

There is always a problem of assuming which object should be given a responsibility and this is where information expert pattern comes into play. we assign responsibilities to classes during the design phase and information expert helps us decide which responsibility should be given to a class.

Information Expert is defined as : Assign a responsibility to the information expert; the class that has the information necessary to fulfill the responsibility.

we need to analyze how much effect Information expert causes to cohesion and coupling before deciding the pattern for the class.

PATTERN

A pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice

In a nutshell, the principle of Information Expert is to assign responsibilities and to look at a given responsibility, determine the information needed to fulfill it, and then determine where that information is stored.Then, Information Expert will lead to placing the responsibility on the class with the most information required to fulfill it.

GRASP

GRASP stands for General Responsibility Assignment Software Pattern Describe fundamental principles of object design and responsibility and is expressed in patterns. Information Expert in one of the five GRASP Patterns, viz. Creator, Information Expert, Low Coupling, Controller and High Cohesion.

RESPONSIBILITY DRIVEN DESIGN (RDD)

• A way of thinking about OOD:

1. Responsibilities
2. Roles
3. Collaborations

• Common responsibility categories:

1. Doing:
   1. Doing something itself:
      1. Creating and object or doing a calculation
   2. Initiating action in other objects
   3. Controlling and coordinating activities in other objects
2. Knowing:
   1. Knowing about private data
   2. Knowing about related objects
   3. Knowing about things it can derive or calculate
   4. Bigger responsibilities may take several classes

• Guideline:

1. Domain model helps with “knowing”
2. Interaction diagrams help with “doing”

Example

Monopoly

   import java.util.ArrayList;
   public class Board 
   {
     ArrayList<Square> squares = new ArrayList<Square>();
     //....
     public Square getSquareInfo(int position)
     {
       //.....
       return null;
     } 
   }

   public class Dice 
   {
     private int dice1;
     private int dice2;
 
     public int getFaceValue()
     {
       dice1 = (int)(1+(Math.random()*6));
       dice2 = (int)(1+(Math.random()*6));
       return dice1+dice2;
     }
   }

   public class Monopoly 
   {
     Square current,previous;
     int facevalue;
     int rollDice()
     {
       facevalue = (new Dice()).getFaceValue();
       return facevalue;
     }
     public Square movePlayer(int facevalue,Square prev)
     {
       // move player to appropriate square
       return null;
     }
     //other methods	
     public void Play(Player p1,Player p2)
     {
       //....
     }
     public static void main(String args[])
     {
       Player p1 = new Player();
       Player p2 = new Player();
       Monopoly monopoly = new Monopoly();
       monopoly.Play(p1, p2);
     }
    }

    import java.util.ArrayList;
    public class Player 
    {
       ArrayList<Property> propertyOwned = new ArrayList<Property>();
       ArrayList<Property> propertyMortgage = new ArrayList<Property>();
       void buyProperty()
       {
         //...
       }
       void MortgageProperty()
       {
          //...
       }	
     }

   public class Property 
   {
     Square InSquare;
     String Name;
     int Price;
     int PriceOfHotel;
     int PriceOfHouse;
     int MortgageValue;
      //....
     int MvalueOfHouse;
     int MvalueOfHotel;
     int HousesBuilt;
     int HotelsBuilt;
     Player Owner;
     int getPrice()
     {
       return Price;
     }
     String getName()
     {
       return Name;
     }
     public int calculateMontgageValue()
     {
       return	MortgageValue + (HousesBuilt*PriceOfHouse)+(HotelsBuilt*PriceOfHotel);
     }
   }

   public class Square 
   {
     Property property;
     int position;	
   }