Lesson 3: Creating Our Own Classes

Transcription

1 Lesson 3: Creating Our Own Classes Exercise 1: Calculator class Task: Create an application that will do simple calculation (e.g. sum two variables). Comment: The use case diagram of the exercise is in the figure 1. ud Calc Calculating User (from Use Case Model) figure 1: use case diagram for calculator Figure 2 shows that apart from a descendant (CalcApp) from the Application class there is a class called Calc. The Calc class is designated to do the actual calculation. Remember, the descendant from the Application class is responsible mainly for I/O operations. The Calc class has two attributes representing two variables that will be calculated with. These attributes can be accessed using getters and setters. The only operation yet in the figure is sum(). Similar way other operations will be implemented. 1/7

2 cd CalcApp fim.utils + Application + Console + EditBox + readint(string) : int + readstring(string) : String +in fim.utils:: Application - in: EditBox - out: Console +out + print(string) : void Calc CalcApp - a: int - b: int + sum() : int property get + geta() : int + getb() : int property set + seta(int) : void + setb(int) : void figure 2: class diagram for calculator The sequence diagram in the figure 3 shows one important thing. Although, we have not declared the constructor of the class explicitly (see the figure 2 that the class Calc has no constructor), we can use an implicit constructor. The implicit constructor has the same name as is the name of the class and has no parameters. The rest of the interactions are obvious. The attentive reader might notice that the user cannot choose the operation himself. Next, we enable him to do this using menu. 2/7

3 sd Calculating Lesson3::CalcApp User main() start() Calc() Lesson3::Calc int:= readint(prompt) seta(newval) int:= readint(prompt) setb(newval) int:= sum() print(text) (from Use Case Model) figure 3: sequence diagram for calculator Exercise 2: Calculator II Task: Create a calc application that will enable the user to select the operation using menu. 3/7

4 cd CalcAppEx fim.utils + Application + AppMenu + Console + readint(string) : int + + readstring(string) EditBox : String +in fim.utils::application - in: EditBox - menu: AppMenu - out: Console +out + print(string) : void fim.utils::appmenu + add() : void + setmenuvisible(boolean) : void +menu Lesson3::CalcEx - a: int - b: int Lesson3::CalcAppEx + divide() : int + multiply() : int + subtract() : int + sum() : int property get + geta() : int + getb() : int property set + seta(int) : void + setb(int) : void figure 4: class diagram for calculator with menu In figure 4 you can see that there is another class AppMenu from the fimutils framework. The AppMenu provides method add() which can be used to add menu items into the application menu. The AppMenu class has also a method for showing the menu which is setmenuvisible(). The object from the AppMenu class is identified using menu identifier in the context of the Application class. The Application class disposes of handlemenu(int zkratka) method() in which is called whenever the user clicks a menu item (in previous diagrams not shown for simplicity reasons). The parameter of this method identifies the menu item. 4/7

5 sd CalculatingEx Lesson3::CalcAppEx fim.utils::appmenu User main() start() loop add individual menu items [for all menu items] add() show the menu create the calc object setmenuvisible(b) Calc() Lesson3::CalcEx clicking on menu item handlemenu(zkratka) alt [set variables menu item selected] readint() seta(newval) readint() setb(newval) [sum selected] int:= sum() [subtract selected] int:= subtract() [multiply selected] int:= multiply() [divide selected] int:= divide() print() (from Use Case Model) figure 5: class diagram for calculation Figure 5 depicts the object interactions in the extended calculation exercise. In start() method all the menu items are added to the menu using the add() method. Then the custom menu is made visible by calling the setmenuvisible() method with the boolean parameter set to true. By the following message the instance of the CalcEx class is created. It will not be used immediately but only after the user clicks a menu item. By clicking on the menu item the user initiates the handlemenu() method. The alternative is selected according the menu item clicked. This way the user not only asks for calculation but also for setting the variables. The result is then printed. 5/7

6 Exercise 3: Calculator with Exceptions Task: Create a calc application as in previous example but with division by zero situations handled. cd CalcAppEx2 fim.utils + Application + AppMenu + Console + readint(string) : int + + readstring(string) EditBox : String +in fim.utils::application - in: EditBox - menu: AppMenu - out: Console +out + print(string) : void fim.utils::appmenu + add() : void + setmenuvisible(boolean) : void +menu Exception + Exception(String) + getmessage() : String Lesson3::CalcAppEx Lesson3::CalcEx - a: int - b: int + Calc() : void + divide() : int + multiply() : int + subtract() : int + sum() : int property get + geta() : int + getb() : int property set + seta(int) : void + setb(int) : void figure 6: class diagram for calculator with exception Dividing by zero brings the program to the erroneous state. When such an event happens, an object from the Exception class is created and the normal flow of execution is disrupted. This is called as throwing exception. The exception object brings information about the event. The thrown exception has to be somewhere caught. An exception is caught in an exception handler. In our exercise, we will improve our calc class as follows. We will check whether the B variable is zero when dividing. If this is the case, we will throw an exception. By throwing exception in the calc class we simply say that there is a problem. But calc class does not care how the problem will be resolved. This is the responsibility of CalcApp class since it is responsible for user interactions. Thus, the CalcApp will catch such exception and tell the user what is wrong. Figure 6 shows that there is an Exception class as different from the previous example. In the divide method() of the CalcEx class there will be a simple condition that will check whether 6/7

7 the B variable does not equal to zero. If this is the case we will raise or throw the exception like this: throw new Exception( Cannot divide by zero ); Note the throw clause at the beginning of the statement. By throwing exception in a particular method you have to either surround the statement by try/catch or add the throws declaration into the method s head. Since we want to delegate the handling of the problem to other classes than is the CalcEx class we will use the second alternative. The development environments such as Eclipse will help us to do this. More information about exceptions can be found in the Java tutorial on the following address Summary After this lesson you should understand how to: use your own objects use getters and setters using menu use exceptions throw exceptions handle exceptions 7/7