April 3, 2007

Chapter 17 topics & Aloha to Java

Chapter 18 - parameter passing

Chapter 19 - Prolog

Chapter 17

Exceptions and exception handling

• Java Exception class
• Worth reading
  • The Essence of OOP using Java, Exception Handling by Richard G. Baldwin
    • (print version)

  Introduction

  Stated simply, the exception-handling capability of Java makes it possible for you to:

  • Monitor for exceptional conditions within your program
  • Transfer control to special exception-handling code (which you design) if an exceptional condition occurs

  The basic concept

  This is accomplished using the keywords: try, catch, throw, throws, and finally.  The basic concept is as follows:

  • You try to execute the statements contained within a block of code. (A block of code is a group of one or more statements surrounded by braces.)If you detect an exceptional condition within that block, you throw an exception object of a specific type.You catch and process the exception object using code that you have designed.
  • You optionally execute a block of code, designated by finally, which needs to be executed whether or not an exception occurs.  (Code in the finally block is normally used to perform some type of cleanup.)

  • Example programs
  • Excep11.java
  • Excep12.java
  • Excep13.java
  • Excep14.java
  • Exceptions in Java. The full story of exceptions in the Java language and virtual machine by Bill Venners (print version)
    • When a method encounters an abnormal condition (an exception condition) that it can't handle itself, it may throw an exception. Throwing an exception is like throwing a beeping, flashing red ball to indicate there is a problem that can't be handled where it occurred. Somewhere, you hope, this ball will be caught and the problem will be dealt with. Exceptions are caught by handlers positioned along the thread's method invocation stack. If the calling method isn't prepared to catch the exception, it throws the exception up to its calling method, and so on. If one of the threads of your program throws an exception that isn't caught by any method along the method invocation stack, that thread will expire. When you program in Java, you must position catchers (the exception handlers) strategically, so your program will catch and handle all exceptions from which you want your program to recover.

  • class VirtualCafe {
        public static void serveCustomer(VirtualPerson cust,
            CoffeeCup cup) {
            try {
                cust.drinkCoffee(cup);
                System.out.println("Coffee is just right.");
            }
            catch (TemperatureException e) {
                // This catches TooColdException, TooHotException,
                // as well as TemperatureException.
                System.out.println("Coffee is too cold or too hot.");
                // Deal with an irate customer...
            }
            // THIS WON'T COMPILE, BECAUSE THIS catch clause
            // WILL NEVER BE REACHED.
            catch (TooColdException e) {
                System.out.println("Coffee is too cold.");
            }
        }
    }
    // In Source Packet in file except/ex4/VirtualCafe.java
    // This class compiles fine.
    class VirtualCafe {
        public static void serveCustomer(VirtualPerson cust,
            CoffeeCup cup) {
            try {
                cust.drinkCoffee(cup);
                System.out.println("Coffee is just right.");
            }
            catch (TooColdException e) {
                System.out.println("Coffee is too cold.");
                // Deal with an irate customer...
            }
            catch (TemperatureException e) {
                // This catches TooHotException as well
                // as TemperatureException.
                System.out.println(
                    "There's temperature trouble in this coffee.");
                // Deal with an irate customer...
            }
        }
    }
             

Chapter 18

Parameter passing methods

• By value
• By result
  • void plus(int a, int b, by-result int c)
    { c = a+ b; }
• By value-result
  • void plus(int a, b, by-value-result int c)
    { c = a+ b;}
• By reference
  • void sigsum(by-reference int n, by-reference int ans){
    ans = 0;
    int i = 1;
    while( i <= n ) ans += i++;
    }
  • int f() {
    int x,y;
    x = 10;
    sigsum(x,y);
    return y;
    }
    what if we made the call sigsum(x,x)?
• By Macro Expansion
  • For passing parameters by macro expansion, the body of the macro is evaluated in the caller's context. Each actual parameter is evaluated on every use of the corresponding formal paramter, in the context of that occurrence of that formal parameter (which is itsel in the caller's context).
• By Name
  • For passing parameters by name, each actual parameter is evaluated in the caller's context, on every use of the corresponding formal paramter.

Prolog

• The implementation of Prolog used in the book is SWI-Prolog from the University of Amsterdam. You can download it from the SWI-Prolog web site. 

• Take a look at http://www.csupomona.edu/~jrfisher/www/prolog_tutorial/contents.html Prolog tutorial.
  • 2.2 Two Factorial Definitions
  • 2.6 Tree data and relations
• Prepare answers to the exercises, the same way we did for ML, except that each section will work on and present answers separately. Additionally, prepare answers to the exercises at the end of each section 3 or higher of prolog tutorials

 

 

---

This work is licensed under a Creative Commons License.
Ernest Ackermann Department of Computer Science, Mary Washington College
CPSC 401 | CPSC 470S

---

Bibliographic Information: