strategy pattern.pdf

14
Class report Page 1 of 14 CLASS ASSIGNMENT- 1 WAR PLANNING (STRATEGY PATTERN) Submitted by: Md.Mahedi Mahfuj -BIT 0207 Submitted to: Maeenul Islam Lecturer,IIT Institute of Information Technology University of Dhaka

Upload: md-mahedi-mahfuj

Post on 11-May-2015

717 views

Category:

Technology


1 download

TRANSCRIPT

Page 1: Strategy pattern.pdf

Class report

Page 1 of 14

CLASS ASSIGNMENT- 1

WAR PLANNING

(STRATEGY PATTERN)

Submitted by:

Md.Mahedi Mahfuj -BIT 0207

Submitted to:

Maeenul Islam

Lecturer,IIT

Institute of Information Technology

University of Dhaka

Page 2: Strategy pattern.pdf

Class report

Page 2 of 14

War Planning:

Introduction:

At first, we have to see what happens when a war is being undertaken in

certain circumstances, i.e. what features we have to focus on.

Actually, the war is called by the king of a certain region. He commands the

commander of the battalion under whom a huge number of soldiers are

working all the time.

Now, let’s see the entire war through technical perspectives. Before, going

through the scenario, we have to know what a client code is.

Client Code:

The part of the code that controls the behavior of the other classes is known

as the client code of those classes. As an instance,

Page 3: Strategy pattern.pdf

Class report

Page 3 of 14

War {

Main () {

Commander cm = new commander ();

Soldier s1 = new soldier ();

Soldier s2 = new soldier ();

Soldier s3 = new soldier ();

cm. AddSoldier(s1);

cm. AddSoldier(s2);

cm. AddSoldier(s3);

cm. StartWar();

}

}

So, we can see that this client code Main () can control both commanders and

soldiers. So, the Main() function here plays the role of the King.

Now, let’s see what can be in the commander part :

Commander:

Name:-

Command:-

Command();

Soldierlist;

AddSoldier(soldier s);

Soldierlist.add (s ) {

Page 4: Strategy pattern.pdf

Class report

Page 4 of 14

StartWar () {

S1.Changemode (“Aggression”);

S2.Changemode (“Defensive”);

S3.Changemode (“Aggression”);

…….

……..

……..

………

}

And, in the soldier part:

Soldier:

Name:-

Mode:-

Function:-

Fight ();

Changemode ();

…..

…..

……

Page 5: Strategy pattern.pdf

Class report

Page 5 of 14

Now, let’s see what we mostly do in such cases:

Soldier{

Changemode (String m)

{

Mode=m; //mode change

Fight ();

}

Fight ()

{

//according to mode, fight now.

If(mode=”Aggressive”)

{

…………

…………//about 1000 line code

………….

}

Else if (mode=”Defensive”)

{

………….

………….//about 1000 line code again

…………..

Page 6: Strategy pattern.pdf

Class report

Page 6 of 14

}}

Problems:

Now, let’s see what the problems are that we may face in solving in the above

mentioned way:

At first,

If we add some more fighting modes like neutral, some only carrying

foods & weapons etc then we have to add all such things in the same class

soldier. Hence, the soldier class will eventually become huge which is not

suitable for handling a good code.

Then,

If we separate the modes into distinguished classes, then another

problem will arise, ambiguity.

The modes will be described in three different functions by three

different programmers who contributed in coding the codes of three different

classes namely soldier, aggressive & defensive respectively.

Then,

If we keep the mode as string/integer , then for every change in

different fighting modes, we have to change in soldier class also which is not

expected at all.

Solution:

Let’s troubleshoot the problems mentioned above:

For solving the first problem,

We have to separate the fighting modes into

classes & then all possible changes in modes will be done in the specific

Page 7: Strategy pattern.pdf

Class report

Page 7 of 14

classes. So, The coder of soldier will not be disturbed for any change in the

fighting mode.

Class Aggressive{

}

Class Defensive{

}

Class Mode3{

}

Class ……..

……..

……..

………

In this way, we can add different modes as much as possible whenever

needed.

Now, let’s troubleshoot the second problem.

For troubleshooting that,

We have to fix a specific function & every class should be made bound to use

that specific function. For this we can declare an interface & every class should

implement that interface.

Interface Ifight {

Fight();}

Class Aggressive implements Ifight {

Fight () {

Print (“I am fighting in aggressive mode”) ;}}

Page 8: Strategy pattern.pdf

Class report

Page 8 of 14

Class Defensive implements Ifight{

Fight () {

Print (“I am fighting in defensive mode”) ;

}

Class Mode3 implements Ifight{

Fight () {

Print (“I am fighting in neutral mode”) ;

}

Class Mode4 implements Ifight{

……………

……………

……………

So, every class here is bound to use the function fight().So, three different

coders coding three different classes do not have to depend on each other.

Now,another question may come…..Why are we using an interface, not an

abstract class?

The very answer is;

In an abstract class there can be an abstract method, a defined method

and variables as well.But,here we only have to declare a function,that’s

all.So, we have no need to declare an abstract class,only an interface is

enough,i.e. minimal. For this very reason, we have used an interface

instead of using an abstract class.

Page 9: Strategy pattern.pdf

Class report

Page 9 of 14

Now,let’s fix the third problem.

If we keep modes as string/integer then such problems will arise often. So, it

is better to use the modes as object. Only then, such problems will never

happen in near future.

Like, in the commander class we can use the modes as objects.

Commander Class:

S1.Changemode (new Aggressive())

…..

…….

…….

S1.Changemode (new Defensive())

……..

……..

………

S1.Changemode (new Mode3())

………

………

………

This use of modes as object has made the code more flexible & well-

maintained.

Page 10: Strategy pattern.pdf

Class report

Page 10 of 14

Main Code Sample:

Hence, the main code should have the following structure:

War Class:

War {

Main () {

Commander cm = new commander ();

Soldier s1 = new soldier ();

Soldier s2 = new soldier ();

Soldier s3 = new soldier ();

cm. AddSoldier(s1);

cm. AddSoldier(s2);

cm. AddSoldier(s3);

cm. StartWar();

}

StartWar () {

S1.Changemode (“Aggression”);

S2.Changemode (“Defensive”);

S3.Changemode (“Aggression”);

…….

……..

……..

} }

Page 11: Strategy pattern.pdf

Class report

Page 11 of 14

Soldier Class:

Soldier{

Name:

Soldier () {

}

Changemode (Ifight fm) {

FightingMode = fm;

FightingMode.fight ();

}

Interface Ifight

{

fight ();

}

Aggressive Class:

Class Aggressive implements Ifight {

Fight () {

Print (“I am fighting in aggressive mode”) ;

}

}

Page 12: Strategy pattern.pdf

Class report

Page 12 of 14

Defensive Class:

Class Defensive implements Ifight{

Fight () {

Print (“I am fighting in defensive mode”) ;

}}

Mode3 Class:

Class Mode3 implements Ifight{

Fight () {

Print (“I am fighting in neutral mode”) ;

}}

Mode4 Class:

………

………

………

Commander Class:

S1.ChangeMode (new Aggressive())

………

………

………

S1.Changemode (new Defensive())

……..

Page 13: Strategy pattern.pdf

Class report

Page 13 of 14

……..

………

S1.Changemode (new Mode3())

………

………

In this way, we can easily diminish all the problems that we have faced earlier.

This way of solving a problem is known as “Strategy Pattern”.

……………………………………………………………………………..X…………………………………………………………………………………

Page 14: Strategy pattern.pdf

Class report

Page 14 of 14