State Pattern – Design Patterns in Java/J2EE

State pattern falls under the category of Behavioural patterns. Assume that we have an object and its behavior is largely dependent on the state of its internal variables. Consider the following example,

Person.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

package tips.pattern.state;
public class Person {
	private String name;
	private String character;
 
	public Person(String name, String character) {
		this.name = name;
		this.character = character;
	}
 
	public void giveMeMoney() {
		if (character.equals("GoodCharacter")) {
			System.out.println("Yes, take all my money");
		} else if (character.equals("BadCharacter")) {
			System.out.println("No, I dont have anything with me");
		} else if (character.equals("OtherCharacter")) {
			System.out.println("I will give the money tmrw");
		}
	}
}

We have modeled a Person object passing his name and a string representing his character, which may be a Good Character or Bad Character or some Other Character. If someone comes to him and asks for money by calling the Person.giveMeMoney() method, his behavior is entirely dependant on his character. Technically, his behavior is tightly coupled with the internal variable character.

The above design has one great dis-advantage. Suppose we want to add further characters that represent some other different behavior of a Person, then we end up in adding if-else clauses, which certainly is not very good from a design perspective because of changes being done in the existing code.

So, how to provide support for different characteristic behaviors for a person without making code changes? Here comes the State pattern which just do that. The State pattern mandates to model behavior as interfaces rather than representing them as Strings or some other types. For example, since character is the changing behavior for a Person, let us encapsulate it by having something like the following,

Character.java

1
2
3
4
5

package tips.pattern.state;
 
public interface Character {
	public void giveMeMoney();
}

See, we have modeled a person’s Character as an interface. Now, let us see the implementation for different characteristic feature of a person, say GoodCharacter and BadCharacter.

GoodCharacter.java

1
2
3
4
5
6
7
8

package tips.pattern.state;
 
public class GoodCharacter implements Character {
	@Override
	public void giveMeMoney() {
		System.out.println("Yes, take all my money");
	}
}

BadCharacter.java

1
2
3
4
5
6
7
8

package tips.pattern.state;
 
public class BadCharacter implements Character {
	@Override
	public void giveMeMoney() {
		System.out.println("No, I dont have anything with me");
	}
}

Now, let us see the new Person class which accepts character in the form of an interface rather than as a String. Given below is the code snippet for the same.

Person2.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

package tips.pattern.state;
 
public class Person2 {
	private String name;
	private Character character;
 
	public Person2(String name, Character character) {
		this.name = name;
		this.character = character;
	}
 
	public void giveMeMoney() {
		character.giveMeMoney();
	}
 
	public static void main(String[] args) {
		Person2 object = new Person2("John", new GoodCharacter());
		object.giveMeMoney();
		object = new Person2("John", new BadCharacter());
		object.giveMeMoney();
	}
}

Since now the character is represented as an interface, there wont be any more code changes if there is a need to add new characteristic behavior. All we need to do is to define the new character class implementing the Character interface.

Comments

comments