Chapter 13 is about exception handling. “Exception” means a problem that occurs infrequently during the program execution, or in other words, error. (But “error” has another meaning in Java, so we stick to the term “exception” here.)

In short, exception handling means handling the possible problems that arise during the program execution. Examples of these exceptions include the ArithematicException and the InputMismatchException. Fig. 13.3 of the text book shows some of the exceptions in Java.

We use try blocks to enclose code that may throw an exception, and catch blocks to deal with exceptions that may arise. We also use the finally block to release resources whether or not an exception occurs.

Moreover, we could use the throws clause to specify that a method may throw a certain exception, and the throw clause (note: no “s” here) to explicitly throw an exception in the program code. These are helpful in writing customized code for exception handling.

Why do we use the try-catch-finally structure to handle exceptions? Because it helps to separate the problem-handling code from the main line of the program execution. This brings us a better program structure for debugging and code reuse.

Next week we will move to the last chapter in this course, and then next next week it’s your turn to show your masterpiece (project) to the rest of the class.

Share This

Please note the following Extra Consultation Hours exclusive for ISM001:

• 09:30-12:30, 8 Dec 2008 - 11 Dec 2008 @ NAB-309

If you are coming, please make revision first and try the exercises in the textbook. Thank you.

# Note: I will not be available in the morning and afternoon of  15 Dec 2008 (i.e. the few hours before the ISM001 exam). Please come to ask for help in the previous week. Thank you.

Share This

請留意 12 月份的數學救亡班，將有以下特別安排：

• 12 月 3 日（星期三）早上的數學救亡班，將改為下午 15:30-17:30 於 NAB-206 舉行。
• 由 12 月 9 日至 12 月 11 日（星期二至星期四），張真人加開三節數學救亡班，每節兩小時。時間為 14:00-16:00，地點為 NAB-113。

Share This

Chapter 10 is about polymorphism, which is another important concept associated with OOP.

Today I delivered the concept of polymorphism using my own set of example programs. The programs served to demonstrate the following:

Dynamic binding

When we call the method displayMessage() of a Student object, Java actually knows that we want to call the method of the corresponding subclasses. In other words, when a superclass variable contains a reference to a subclass object, and that reference is used to call a method, the correct subclass version of the method is called, and the programmer does not need to care about all these. This is known as dynamic binding or late binding (See p.487 of textbook) because the binding (determining which method to call) is done at run time.

Abstract classes and methods

We also looked at abstract class and methods. An abstract class provides an appropriate superclass from which other classes can inherit and thus share a common design. For example, in the classes ABSstudent and PADstudent inherited from Student, we define the displayMessage() method in Student to restrict that ABSstudent and PADstudent must use displayMessage() (and not printMessage() or any other name) to display the message. Since Student does not know what major the student is in, we cannot write any code in the displayMessage() of Student, and so we must leave it abstract. We add the keyword abstract in front of displayMessage() to make it an abstract method. We also add the keyword abstract in front of the class name because any class with one abstract method must be declared abstract as well.

Interface

Finally, we looked at the concept of interface.  An interface is like an abstract class with all the methods declared abstract. This is good if we want to share common design among unrelated classes. Any class that implements an interface must either define all the methods in the interface, or be declared abstract itself (in which case the implementation will be done by its subclasses).

Interfaces are different from abstract classes in many ways. For example, interfaces are used in place of abstract classes when there is no default implementation to inherit. Also, a class can inherit from only one superclass, but it may implement more than one interfaces. More information can be found in the textbook.

Next time we will move on to Chapter 13. It is about error handling in Java, which would be simple to understand. In contrast, in the next next class we deal with Chapter 16. It is about sorting and searching, which is difficult. So, make sure that you finish your revision as soon as possible.

Share This

http://phgod.pastebin.ca/1254164

Reference: ISM001: The Java City

Share This

Since no one is likely to take the make-up test anymore, I’m going to return the test papers to you in this week’s class. Please review all the questions (re-do if necessary) and refer to the marking scheme for the answers.

Share This

Chapter 9 is conceptual. Instead of learning the syntax of Java, we focus on one conceptual aspect of OOP — inheritance (is-a relationship) in Java. Why inheritance? One reason is code reuse. I gave an example in class using Player and BossPlayer to demonstrate the idea. A few main points are listed below to recap your memory:

1. The use of the keyword protected, and why we should use it with great care.
2. The notions superclass and subclass. (Do not just memorize these. Try to give other examples in which inheritance can help.)
3. Declaring inheritance relationship by the keyword extends.
4. Calling the constructor of the superclass using super, or the methods of the superclass using super.methodName(…).
5. The Object class from which every other class directly or indirectly inherits.

While this summary is a short one, it does not mean that Chapter 9 is easy or unimportant. In fact, Chapter 9 is short but difficult, and Chapter 10 would be long and difficult. Therefore,  please do the exercise problems in Chapter 9 to make sure that you can follow. Next time we would move on to Chapter 10 to talk about polymorphism in Java.

Share This

Here is Homework 2, an extension of the last homework. It is a difficult one because it is designed to help you prepare for the examination. Please follow the instructions and submit your work by 12 December 2008 (the Friday before final exam).

Those interested may also take a look at the works from last year: Text Fighter (homework 1), The Fighters’ Universe (homework 2).

Some example outputs:

*** Welcome to Trade or War! ***

=== Round 1 ===
City Thebes (500, 500)
City Corinth (500, 500)
BigCity Sparta (2000, 2000)
BigCity Athens (2000, 2000)

*** News: BigCity Sparta is in war with BigCity Athens!
–> BigCity Sparta (800, 0)
–> BigCity Athens (1600, 3000)

Your turn (0:Quit)(1:Trade)(2:War) –> 1

*** News: BigCity Athens trades with BigCity Sparta. Both become more wealthy.
–> BigCity Athens (1700, 3500)
–> BigCity Sparta (900, 500)

=== Round 2 ===
City Thebes (500, 500)
City Corinth (500, 500)
BigCity Sparta (900, 500)
BigCity Athens (1700, 3500)

*** News: There is an earthquake in City Thebes!
–> City Thebes (100, -500)

*** News: City Corinth trades with BigCity Athens. Both become more wealthy.
–> City Corinth (600, 1000)
–> BigCity Athens (1800, 4000)

Your turn (0:Quit)(1:Trade)(2:War) –> 2

*** News: BigCity Athens is in war with City Corinth!
–> BigCity Athens (1440, 5000)
–> City Corinth (240, -1000)

=== Round 3 ===
City Thebes (100, -500)
City Corinth (240, -1000)
BigCity Sparta (900, 500)
BigCity Athens (1440, 5000)

*** News: City Corinth trades with BigCity Sparta. Both become more wealthy.
–> City Corinth (340, -500)
–> BigCity Sparta (1000, 1000)

*** News: BigCity Sparta is in war with City Corinth!
–> BigCity Sparta (800, 2000)
–> City Corinth (136, -2500)

Your turn (0:Quit)(1:Trade)(2:War) –> 3
!!! Wrong input !!!

Your turn (0:Quit)(1:Trade)(2:War) –> a
!!! Wrong input !!!

Your turn (0:Quit)(1:Trade)(2:War) –> 2

*** News: BigCity Athens is in war with BigCity Sparta!
–> BigCity Athens (1152, 6000)
–> BigCity Sparta (320, 0)

=== Round 4 ===
City Thebes (100, -500)
City Corinth (136, -2500)
BigCity Sparta (320, 0)
BigCity Athens (1152, 6000)

*** News: There is an earthquake in City Thebes!
–> City Thebes (20, -1500)

*** News: BigCity Sparta trades with BigCity Athens. Both become more wealthy.
–> BigCity Sparta (420, 500)
–> BigCity Athens (1252, 6500)

*** News: There is an earthquake in BigCity Sparta!
–> BigCity Sparta (84, -500)

Your turn (0:Quit)(1:Trade)(2:War) –> 2

*** News: BigCity Athens is in war with City Thebes!
–> BigCity Athens (501, 4500)
–> City Thebes (16, -500)

=== Round 5 ===
City Thebes (16, -500)
City Corinth (136, -2500)
BigCity Sparta (84, -500)
BigCity Athens (501, 4500)

*** News: BigCity Sparta is in war with City Corinth!
–> BigCity Sparta (34, -2500)
–> City Corinth (109, -1500)

Your turn (0:Quit)(1:Trade)(2:War) –> 2

*** News: BigCity Athens is in war with BigCity Sparta!
–> BigCity Athens (401, 5500)
–> BigCity Sparta (14, -4500)

=== Round 6 ===
City Thebes (16, -500)
City Corinth (109, -1500)
BigCity Sparta (14, -4500)
BigCity Athens (401, 5500)

*** News: BigCity Sparta is in war with City Corinth!
–> BigCity Sparta (12, -3500)
–> City Corinth (44, -3500)

Your turn (0:Quit)(1:Trade)(2:War) –> 2

*** News: BigCity Athens is in war with BigCity Sparta!
–> BigCity Athens (321, 6500)
–> BigCity Sparta (5, -5500)

*** News: There is no more citizen in BigCity Sparta! Game over.

=== Game Statistics ===
City Thebes (16, -500)
City Corinth (44, -3500)
BigCity Sparta (5, -5500)
BigCity Athens (321, 6500)

Share This

http://spreadsheets.google.com/pub?key=pphZ19OUg832mijAbsOKTWA

Share This

Today’s class is a “turning point” in the course, meaning that if you do not work hard then there is no way to turn back and pass this course, because we will enter the advanced level of Java programming starting from Chapter 8.

To start with, I spent half of the class demonstrating how to write a TimeConfig class that sets and displays time in various formats. I then went through the examples of Chapter 8 one by one, emphasizing the following key points:

1. The Time1 class in Fig. 8.1 was just another example of how to design and build a class. In particular, I re-emphasized the use of set- and get-methods to modify and display the instance variables of the class.
2. Other techniques included the use of the this reference to refer to the current object’s members (Section 8.4), and the overloading of constructors (Section 8.5).
3. I mentioned the Garbage Collector (GC) in Java, which is a facility to release unused memories automatically. The garbage collector attempts to reclaim memory no longer used by the objects of the Java program.
4. I also told you about the old days without automatic garbage collection. In C/C++, for example, it is the  programmers’ responsibility to release the memory manually, or otherwise it may cause a  memory leak, which explains why some computer programs hang after running for a long time. Due to GC in Java, a Java programmer usually does not need to care about  garbage collection. In Fig. 8.13, we looked at how to manipulate with the GC in Java.
5. One shortcoming of the use of GC is that, even if we invoke the GC by System.gc(), it is not guaranteed when the GC will collect the garbage. For this reason, people doing scientific computation (e.g. me) would prefer C/C++ to Java when the program is computationally expensive (i.e. something that requires gigabytes of RAM and weeks of running time).
6. One more point to note about this example is the use of static class members in the counting of Employee objects. The Math class is another well-known example that uses static class members.
7. The keyword static can also be used with import. In Fig. 8.14, we used import static java.lang.Math.*; so as to call the sqrt method by sqrt(900.0) instead of Math.sqrt(900.0). Note however that this can sometimes make your program difficult to debug, so use with care.
8. A final point to note in Chapter 8 is that, to declare a constant in Java, we use the keyword final (instead of const in C/C++).

Chapter 9 is about inheritance (is-a relationship) in Java, which will be very difficult.

Another Bad news: Homework 2 is on the way and would be released in the coming week (I’m drafting it in Google Docs). The homework would force you to review the second half of the course. Trust me, this will be good for your exam.

Share This