lilian blot variable scope exceptions final word final lecture spring 2014 tpop 1
TRANSCRIPT
Lilian BlotLilian Blot
VARIABLE SCOPEEXCEPTIONSFINAL WORD
Final Lecture
Spring 2014TPOP
1
Lilian Blot
Overview
Variable Scope and Life time
Handling Errors
Java Collections API
Final Words
TPOP
2
Spring 2014
Lilian Blot
Variable Types
In a class definition, there are three kinds of variables.
instance variables: Any method in the class definition can access these variables
parameter variables: Only the method where the parameter appears can access these variables. This is how information is passed to the object.
local variables: Only the method where the parameter appears can access these variables. These variables are used to store intermediate results.
TPOP
3
Spring 2014
Lilian Blot
Scope
Related to the idea of ‘block structures’
The scope of a variable (field) is defined as the area where the variable can be seen
‘inner’ blocks can see variables declared in ‘outer’ blocks
TPOP
4
Spring 2014
Lilian Blot
Scope
TPOP
5
Spring 2014
public class TwoSides{ int side1, side2 ; public boolean testRightTriangle( int hypoteneuse ) { int side1Squared = side1 * side1 ; int side2Squared = side2 * side2 ; int hypSquared = hypoteneuse * hypoteneuse ;
return side1Squared + side2Squared == hypSquared ; }}
Code
Parameter variable
Instance variable
locale variable
Lilian Blot
Scope
We say the scope of instance variables is the entire class definition. The scope refers to the section of code where a variable can be accessed.
The scope for a parameter is simply the method body in which the parameter is located.
TPOP
6
Spring 2014
Lilian Blot
Local Variables Have No Memory
When you exit a method, both the local variables and the parameter variables disappear although, if you pass an object as a parameter, you
usually have access to the object when you exit the method.
TPOP
7
Spring 2014
Lilian Blot
Lifetime
Different kinds of variables have different lifetimes.
Parameter variables exist when the method call is made, and lasts until the method call is complete.
Local variables also have a similar lifetime. They are created when the declaration appears, and lasts until you exit the method.
Instance variables have a much longer lifetime. They are created when the object is constructed, and goes away when the object disappears. The object disappears when it is no longer being used, and when that happens, the
garbage collector gets rid of the object.
The garbage collector is a program that runs when your program runs, and looks for objects with no variables that have handles to it.
TPOP
8
Spring 2014
Lilian Blot
Scope vs. Lifetime
Scope refers to the range of code where you can access a variable. We can divide scope into method body scope Variable is accessible in method body
only (local variables, parameters) class definition scope Variable is accessible in class definition
(instance variables)Lifetime refers to the amount of time a variable (or
object) exists. We can divide lifetime into categories too: method body lifetime Exists on method body entry,
disappears on method body exit. (local variables, parameters) class definition lifetime Exists as long as object is around
(instance variables)
TPOP
9
Spring 2014
Lilian Blot
Scope
TPOP
10
Spring 2014
public class TwoSides{ int side1, side2 ; public boolean testRightTriangle( int hypoteneuse ) { if(hypotenuse >= 0){ int side1Squared = side1 * side1 ; int side2Squared = side2 * side2 ; int hypSquared = hypoteneuse * hypoteneuse ; } else: return false;
return side1Squared + side2Squared == hypSquared ; }}
Code
Parameter variable
Instance variable
locale variable
Block scope
ERROR
Lilian Blot
Be careful
What is the outcome of calling print()?
TPOP
11
Spring 2014
public class TwoSides{ int side1 = 1, side2 = 2; public void print() {
int side1 = 4;System.out.println(side1 * side2);
}}
Code
• The result is 8!• Local variable side1 is hiding instance variable
side1.
Lilian BlotLilian Blot
Handling Errors
Spring 2014TPOP
12
Lilian Blot
Main concepts to be covered
Defensive programming. Anticipating that things could go wrong.
Exception handling and throwing.
Error reporting.
TPOP
13
Spring 2014
Lilian Blot
Not always programmer error
Errors often arise from the environment: Incorrect URL entered. Network interruption.
File processing is particular error-prone: Missing files. Lack of appropriate permissions.
TPOP
14
Spring 2014
Lilian Blot
Error reporting
How to report illegal arguments?
To the user? Is there a human user? Can they solve the problem?
To the client object? Return a diagnostic value. Throw an exception.
TPOP
15
Spring 2014
Lilian Blot
Client responses
Test the return value. Attempt recovery on error. Avoid program failure.
Ignore the return value. Cannot be prevented. Likely to lead to program failure.
Exceptions are preferable.
TPOP
16
Spring 2014
Lilian Blot
Throwing an exception
TPOP
17
Spring 2014
/** * Look up a name or phone number and return the * corresponding contact details. * @param key The name or number to be looked up. * @return The details corresponding to the key, * or null if there are none matching. * @throws NullPointerException if the key is null. */public ContactDetails getDetails(String key){ if(key == null) { throw new NullPointerException( "null key in getDetails"); } return book.get(key); }
Code
Lilian Blot
Throwing an exception
An exception object is constructed: new ExceptionType("...")
The exception object is thrown: throw ...
Javadoc documentation: @throws ExceptionType reason
TPOP
18
Spring 2014
Lilian Blot
The exception class hierarchy
TPOP
19
Spring 2014
Lilian Blot
Exception categories
Checked exceptions Subclass of Exception Use for anticipated failures. Where recovery may be possible.
Unchecked exceptions Subclass of RuntimeException Use for unanticipated failures. Where recovery is unlikely.
TPOP
20
Spring 2014
Lilian Blot
The effect of an exception
The throwing method finishes prematurely.
No return value is returned.
Control does not return to the client’s point of call. So the client cannot carry on regardless.
A client may ‘catch’ an exception.
TPOP
21
Spring 2014
Lilian Blot
Unchecked exceptions
Use of these is ‘unchecked’ by the compiler.
Cause program termination if not caught.
This is the normal practice.
IllegalArgumentException is a typical example.
TPOP
22
Spring 2014
Lilian Blot
Exception handling
Checked exceptions are meant to be caught.
The compiler ensures that their use is tightly controlled. In both server and client.
Used properly, failures may be recoverable.
TPOP
23
Spring 2014
Lilian Blot
The throws clause
Methods throwing a checked exception must include a throws clause:
TPOP
24
Spring 2014
public void saveToFile(String destinationFile) throws IOException{. . .}
Code
Lilian Blot
The try statement
Clients catching an exception must protect the call with a try statement:
TPOP
25
Spring 2014
try { Protect one or more statements here.}catch(Exception e) { Report and recover from the exception here.}
Code
Lilian Blot
Catching multiple exceptions
Clients catching an exception must protect the call with a try statement:
TPOP
26
Spring 2014
try { ... ref.process(); ...}catch(EOFException e) { // Take action on an end-of-file exception. ...}catch(FileNotFoundException e) { // Take action on a file-not-found exception. ...}
Code
Lilian Blot
The finally clause
Clients catching an exception must protect the call with a try statement:
TPOP
27
Spring 2014
catch(Exception e) { Report and recover from the exception here.}finally { Perform any actions here common to whether or not an exception is thrown.}catch(FileNotFoundException e) { // Take action on a file-not-found exception. ...}
Code
Lilian Blot
The finally clause
A finally clause is executed even if a return statement is executed in the try or catch clauses.
A uncaught or propagated exception still exits via the finally clause.
TPOP
28
Spring 2014
Lilian Blot
Defining new exceptions
Extend RuntimeException for an unchecked or Exception for a checked exception.
Define new types to give better diagnostic information. Include reporting and/or recovery information.
TPOP
29
Spring 2014
Lilian Blot
Defining new exceptions
TPOP
30
Spring 2014
public class NoMatchingDetailsException extends Exception{ private String key;
public NoMatchingDetailsException(String key) { this.key = key; } public String getKey() { return key; } public String toString() { return "No details matching '" + key + "' were found."; }}
Code
Lilian Blot
Summary
Runtime errors arise for many reasons. An inappropriate client call to a server object. A server unable to fulfill a request. Programming error in client and/or server.
Runtime errors often lead to program failure.
Defensive programming anticipates errors – in both client and server.
Exceptions provide a reporting and recovery mechanism.
TPOP
31
Spring 2014
Lilian Blot
Final Words
TPOP
32
Spring 2014