Comparing Abstract

Classes & Interfaces

1

Comparing Abstract Classes & Interfaces

Abstract classes are similar to

interfaces

Interface
Abstract
Class

See docs.oracle.com/javase/tutorial/java/IandI/abstract.html
2

Comparing Abstract Classes & Interfaces

Abstract classes are similar to

interfaces, e.g.
They cant be instantiated

package java.util;
public abstract class
AbstractMap<K,V> ... {
...
public abstract
Set<Entry<K,V>> entrySet();
...

Comparing Abstract Classes & Interfaces

Abstract classes are similar to

interfaces, e.g.
They cant be instantiated
They can contain methods
declared without any
implementation

package java.util;
public abstract class
AbstractMap<K,V> ... {
...
public abstract
Set<Entry<K,V>> entrySet();
...

Comparing Abstract Classes & Interfaces

However, abstract classes have

additional capabilities

package java.util;
public abstract class
AbstractMap<K,V> ... {
...
volatile Set<K> keySet;
volatile Collection<V> values;
...

Comparing Abstract Classes & Interfaces

However, abstract classes have

additional capabilities, e.g.
They can define fields that are
not static nor final

package java.util;
public abstract class
AbstractMap<K,V> ... {
...
volatile Set<K> keySet;
volatile Collection<V> values;
...

Comparing Abstract Classes & Interfaces

However, abstract classes have

additional capabilities, e.g.
They can define fields that are
not static nor final
They can also define public,
protected, & private concrete
methods

package java.util;
public abstract class
AbstractMap<K,V> ... {
...
public V put(K key, V value) {
...
}
protected Object clone()
{ ... }
private static boolean eq
(Object o1, Object o2)
{ ... }
...

Comparing Abstract Classes & Interfaces

In contrast, all fields in an

interface must be public, static,
& final

public interface Comparator<T> {

int compare(T o1, T o2);
boolean equals(Object obj);
default Comparator<T>
reversed() {
return Collections.
reverseOrder(this);
}
...

Comparing Abstract Classes & Interfaces

In contrast, all fields in an

interface must be public, static,
& final
Likewise, all methods in an
interface must be public & not
implemented

public interface Comparator<T> {

int compare(T o1, T o2);
boolean equals(Object obj);
default Comparator<T>
reversed() {
return Collections.
reverseOrder(this);
}
...

Default method implementations in interfaces

is a Java 8 feature not in Android
9

Comparing Abstract Classes & Interfaces

A class can extend only one class,

whether or not it is abstract

public class HashMap<K,V>

extends AbstractMap<K,V>
implements Map<K,V>,
Cloneable,
Serializable {
...
}

10

Comparing Abstract Classes & Interfaces

A class can extend only one class, public class HashMap<K,V>

extends AbstractMap<K,V>
whether or not it is abstract
implements Map<K,V>,
Conversely, it can implement any
Cloneable,
number of interfaces
Serializable {
...
}

See javapapers.com/core-java/why-multiple-inheritance-is-not-supported-in-java
11

Importing Classes
& Creating Classes
12

Importing Classes

You can refer to any class that is

in the same package by its name

Class Arrays & Vector

are both in the
java.util package

package java.util;
public class Arrays {
public static <T> T[]
copyOf(T[] original,
int newLength) {
...
public class Vector<E> {
public Object clone() {
...
Object[] v =
Arrays.copyOf(mData,
mCount);
...

13

Importing Classes

You can refer to any class that is

in the same package by its name

Class Arrays & Vector

are both in the
java.util package

package java.util;
public class Arrays {
public static <T> T[]
copyOf(T[] original,
int newLength) {
...
public class Vector<E> {
public Object clone() {
...
Object[] v =
Arrays.copyOf(mData,
mCount);
...

14

Importing Classes

If the class that you are referring

to is not in the same package,
you have two options:

15

Importing Classes

If the class that you are referring

to is not in the same package,
you have two options:
Use the fully qualified name of
that class

package java.util.concurrent;

public class
ConcurrentHashMap<K,V>
extends
java.util.AbstractMap<K,V>
...

This hypothetical example uses

a (verbose) fully qualified name

Using fully qualified names is often considered

poor form due to verbosity
16

Importing Classes

If the class that you are referring

to is not in the same package,
you have two options:
Use the fully qualified name of
that class
Add an import statement to
import that class

package java.util.concurrent;
import java.util.AbstractMap;
...
public class
ConcurrentHashMap<K,V>
extends
AbstractMap<K,V>
...

17

Importing Classes

If the class that you are referring

to is not in the same package,
you have two options:
Use the fully qualified name of
that class
Add an import statement to
import that class

package java.util.concurrent;
import java.util.AbstractMap;
...
public class
ConcurrentHashMap<K,V>
extends
AbstractMap<K,V>
...

Note succinct
class declaration

18

Importing Classes

If the class that you are referring

to is not in the same package,
you have two options:
Use the fully qualified name of
that class
Add an import statement to
import that class
Imports follow the package
declaration

package java.util.concurrent;
import java.util.AbstractMap;
...
public class
ConcurrentHashMap<K,V>
extends
AbstractMap<K,V>
...

19

Importing Classes

If the class that you are referring

to is not in the same package,
you have two options:
Use the fully qualified name of
that class
Add an import statement to
import that class
Imports follow the package
declaration
Allow direct use of classes
defined in other packages

package java.util.concurrent;
import java.util.AbstractMap;
...
public class
ConcurrentHashMap<K,V>
extends
AbstractMap<K,V>
...

20

Overview of Java
Exception Handling
21

Java Exception Handling

Apps occasionally encounter problems that just cant be ignored

See en.wikipedia.org/wiki/Murphys_law
22

Java Exception Handling

Apps occasionally encounter problems that just cant be ignored, e.g.

Attempting to open a file
thats not available
Error
File Not
Found

23

Java Exception Handling

Apps occasionally encounter problems that just cant be ignored, e.g.

Attempting to open a file
thats not available
Error
Trying to call a method or access
a field via a null reference
NullPointer
Exception

24

Java Exception Handling

Apps occasionally encounter problems that just cant be ignored, e.g.

Attempting to open a file
thats not available
Error
Trying to call a method or access
a field via a null reference
ArrayIndex
Indexing before or after the
OutOfBounds
valid range of an array

25

Java Exception Handling

Exception handling separates

control flow paths of normal
processing versus anomalous
processing

See en.wikipedia.org/wiki/Exception_handling
26

Java Exception Handling

Java exception handling is supported

by an extensible hierarchy of classes &
a set of virtual machine mechanisms

See eskatos.wordpress.com/2009/09/30/how-is-exception-handling-implemented-in-jvms
27

Java Exception Handling

If an error condition occurs, an exception can be thrown to notify that a

problem occurred

28

Java Exception Handling

If an error condition occurs, an exception can be thrown to notify that a

problem occurred
Appropriate actions when catching
an exception include interacting with
the user, logging, or exiting the app

29

Java Exception Handling

Any code can report an

exception via throw

public class Vector<E> {

...
public Vector(int initialCapacity,
......) {
if (initialCapacity < 0)
throw new
IllegalArgumentException
("Illegal Capacity: "
+ initialCapacity);
...
}
...

See docs.oracle.com/javase/tutorial/essential/exceptions/throwing.html
30

Java Exception Handling

Any code can report an

exception via throw

public class Vector<E> {

...
public Vector(int initialCapacity,
......) {
if (initialCapacity < 0)
throw new
IllegalArgumentException
("Illegal Capacity: "
+ initialCapacity);
...
}
...

31

Java Exception Handling

Any code can report an

exception via throw

public class Vector<E> {

...
public Vector(int initialCapacity,
......) {
if (initialCapacity < 0)
throw new
IllegalArgumentException
("Illegal Capacity: "
+ initialCapacity);
...
}
...

32

Java Exception Handling

Any code can report an

exception via throw

public class Vector<E> {

...
public int lastIndexOf(Object o,
int index){
if (index >= mCount)
throw new
IndexOutOfBoundsException
(index + " >= "+ mCount);
...
}

33

Java Exception Handling

Any code can report an

exception via throw

public class Vector<E> {

...
public int lastIndexOf(Object o,
int index){
if (index >= mCount)
throw new
IndexOutOfBoundsException
(index + " >= "+ mCount);
...
}

34

Java Exception Handling

The virtual machine performs

a number of steps when an
exception is thrown

35

Java Exception Handling

The virtual machine performs
a number of steps when an
exception is thrown

method1()
calls

Call Stack

method2() throws
IOException {}
calls
method3() throws
IOException {}
calls
method4() throw
IOException {}

36

Java Exception Handling

The virtual machine performs
a number of steps when an
exception is thrown

method1()
calls

Call Stack

method2() throws
IOException {}
calls
method3() throws
IOException {}
calls
method4() throw
IOException {}

37

Java Exception Handling

The virtual machine performs
a number of steps when an
exception is thrown

method1()
calls

Call Stack

method2() throws
IOException {}
calls
method3() throws
IOException {}
calls
method4() throw
IOException {}

38

Java Exception Handling

The virtual machine performs
a number of steps when an
exception is thrown

method1()
calls

Call Stack

method2() throws
IOException {}
calls
method3() throws
IOException {}
calls
method4() throw
IOException {}

39

Java Exception Handling

The virtual machine performs
a number of steps when an
exception is thrown

method1()
calls

Call Stack

Throws
IOException

method2() throws
IOException {}
calls
method3() throws
IOException {}
calls
method4() throw
IOException {}

40

Java Exception Handling

The virtual machine performs
a number of steps when an
exception is thrown
1. Normal program execution
stops

method1()
calls

Call Stack

method2() throws
IOException {}
calls
method3() throws
IOException {}
calls
method4() throw
IOException {}

41

Java Exception Handling

The virtual machine performs
a number of steps when an
exception is thrown
1. Normal program execution
stops
2. Control then transfers to
appropriate handler

The virtual machine searches

up the runtime call stack to
find exception handler

method1()
calls

Call Stack

method2() throws
IOException {}
calls
method3() throws
IOException {}
calls
method4() throw
IOException {}

42

Java Exception Handling

The virtual machine performs
a number of steps when an
exception is thrown
1. Normal program execution
stops
2. Control then transfers to
appropriate handler

method1()
calls

Call Stack

method2() throws
IOException {}
calls
method3() throws
IOException {}
calls
method4() throw
IOException {}

43

Catches
IOException

Java Exception Handling

A try block encloses regions of

code that may throw exceptions

public class MyClass {

public MyClass() {
try {
Vector<String> v =
new Vector<>(-1);
} catch
(IllegalArgumentException e){
...
}
...

See docs.oracle.com/javase/tutorial/essential/exceptions/try.html
44

Java Exception Handling

A try block encloses regions of

code that may throw exceptions
A try block contains one or
more statements that may
throw an exception

public class MyClass {

public MyClass() {
try {
Vector<String> v =
new Vector<>(-1);
} catch
(IllegalArgumentException e){
...
}
...

See docs.oracle.com/javase/tutorial/essential/exceptions/try.html
45

Java Exception Handling

A try block encloses regions of

code that may throw exceptions
A try block contains one or
more statements that may
throw an exception

public class MyClass {

public MyClass() {
try {
Vector<String> v =
new Vector<>(-1);
} catch
(IllegalArgumentException e){
...
}
...

46

Java Exception Handling

A try block encloses regions of

code that may throw exceptions
A try block contains one or
more statements that may
throw an exception

public class MyClass {

public MyClass() {
try {
Vector<String> v =
new Vector<>(-1);
} catch
(IllegalArgumentException e){
...
}
...

47

Java Exception Handling

One or more catch blocks can

be associated with a try block

public class MyClass {

public MyClass() {
try {
Vector<String> v =
new Vector<>(-1);
} catch
(IllegalArgumentException e){
...
}
...

See docs.oracle.com/javase/tutorial/essential/exceptions/catch.html
48

Java Exception Handling

One or more catch blocks can public class MyClass {

public MyClass() {
be associated with a try block
try {
A catch block defines an
Vector<String> v =
exception handler that handles
new Vector<>(-1);
the type of exception indicated
} catch
by its argument
(IllegalArgumentException e){
...
}
...

See docs.oracle.com/javase/tutorial/essential/exceptions/catch.html
49

Java Exception Handling

One or more catch blocks can public class MyClass {

public MyClass() {
be associated with a try block
try {
A catch block defines an
Vector<String> v =
exception handler that handles
new Vector<>(-1);
the type of exception indicated
} catch
by its argument
(IllegalArgumentException e){
...
}
...

50

Java Exception Handling

One or more catch blocks can public class MyClass {

public MyClass() {
be associated with a try block
try {
A catch block defines an
Vector<String> v =
exception handler that handles
new Vector<>(-1);
the type of exception indicated
} catch
by its argument
(IllegalArgumentException e){
...
}
...

51

Java Exception Handling

A finally block always runs

when the try block exits

public class SomeClass {

...
private final ReentrantLock
lock = new ReentrantLock();
...
public void someMethod() ... {
final ReentrantLock lock
= this.lock;
lock.lock();
try {
// ...
} finally {
lock.unlock();
}
...

See docs.oracle.com/javase/tutorial/essential/exceptions/finally.html
52

Java Exception Handling

A finally block always runs

when the try block exits

Runs regardless of whether

an exception is thrown or
if the try block returns

public class SomeClass {

...
private final ReentrantLock
lock = new ReentrantLock();
...
public void someMethod() ... {
final ReentrantLock lock
= this.lock;
lock.lock();
try {
// ...
} finally {
lock.unlock();
}
...

53

Java Exception Handling

A try-with-resources try block

declares one or more resources
that are closed after block exits

public class SomeClass {

...
String readFirstLineFromFile
(String path)
throws IOException {
try (BufferedReader bufReader =
new BufferedReader
(new FileReader(path)))
{ return bufReader.readLine(); }
}
...

See docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html
54

Java Exception Handling

A try-with-resources try block

declares one or more resources
that are closed after block exits

public class SomeClass {

...
String readFirstLineFromFile
(String path)
throws IOException {
try (BufferedReader bufReader =
new BufferedReader
(new FileReader(path)))
{ return bufReader.readLine(); }
}
...

55

Java Exception Handling

A try-with-resources try block

declares one or more resources
that are closed after block exits

public class SomeClass {

...
String readFirstLineFromFile
(String path)
throws IOException {
try (BufferedReader bufReader =
new BufferedReader
(new FileReader(path)))
{ return bufReader.readLine(); }
}
...

56

Java Exception Handling

A try-with-resources try block

declares one or more resources
that are closed after block exits

public class SomeClass {

...
String readFirstLineFromFile
(String path)
throws IOException {
try (BufferedReader bufReader =
new BufferedReader
(new FileReader(path)))
{ return bufReader.readLine(); }
}
...

bufReader is automatically
closed when the block exits

57

Java Exception Handling

Java exceptions are organized
as a class hierarchy

58

Java Exception Handling

Java exceptions are organized

as a class hierarchy
Handlers can be specified for
different exception subclasses

public class MyClass {

public void aMethod() {
try { ... }
catch
(IndexOutOfBoundsException i)
{ ... }
catch
(IllegalArgumentException e)
{ ... }
}

59

Java Exception Handling

Java exceptions are organized

as a class hierarchy
Handlers can be specified for
different exception subclasses

public class MyClass {

public void aMethod() {
try { ... }
catch
(IndexOutOfBoundsException i)
{ ... }
catch
(IllegalArgumentException e)
{ ... }
}

60

Java Exception Handling

Java exceptions are organized

as a class hierarchy
Handlers can be specified for
different exception subclasses

public class MyClass {

public void aMethod() {
try { ... }
catch
(IndexOutOfBoundsException i)
{ ... }
catch
(IllegalArgumentException e)
{ ... }
}

61

Java Exception Handling

public class MyClass {

Java exceptions are organized
public void method1() {
as a class hierarchy
try { method2(); }
Handlers can be specified for
catch (SomeException e) {
different exception subclasses
// do something w/exception
e.printStackTrace();
If a handler isnt specified for
}
the exception thrown, the next
matching handler up the
public void method2()
runtime stack get called
{ method3(); }

public void method3()

{ throw new SomeException(); }
}

62

Java Exception Handling

public class MyClass {

Java exceptions are organized
public void method1() {
as a class hierarchy
try { method2(); }
Handlers can be specified for
catch (SomeException e) {
different exception subclasses
// do something w/exception
e.printStackTrace();
If a handler isnt specified for
}
the exception thrown, the next
matching handler up the
public void method2()
runtime stack get called
{ method3(); }

public void method3()

{ throw new SomeException(); }
}

63

Java Exception Handling

public class MyClass {

Java exceptions are organized
public void method1() {
as a class hierarchy
try { method2(); }
Handlers can be specified for
catch (SomeException e) {
different exception subclasses
// do something w/exception
e.printStackTrace();
If a handler isnt specified for
}
the exception thrown, the next
matching handler up the
public void method2()
runtime stack get called
{ method3(); }

public void method3()

{ throw new SomeException(); }
}

64

Java Exception Handling

public class MyClass {

Java exceptions are organized
public void method1() {
as a class hierarchy
try { method2(); }
Handlers can be specified for
catch (SomeException e) {
different exception subclasses
// do something w/exception
e.printStackTrace();
If a handler isnt specified for
}
the exception thrown, the next
matching handler up the
public void method2()
runtime stack get called
{ method3(); }

public void method3()

{ throw new SomeException(); }
}

65

Java Exception Handling

public class MyClass {

Java exceptions are organized
public void method1() {
as a class hierarchy
try { method2(); }
Handlers can be specified for
catch (SomeException e) {
different exception subclasses
// do something w/exception
e.printStackTrace();
If a handler isnt specified for
}
the exception thrown, the next
matching handler up the
public void method2()
runtime stack get called
{ method3(); }

public void method3()

{ throw new SomeException(); }
}

66

Java Exception Handling

public class MyClass {

Java exceptions are organized
public void method1() {
as a class hierarchy
try { method2(); }
Handlers can be specified for
catch (SomeException e) {
different exception subclasses
// do something w/exception
e.printStackTrace();
If a handler isnt specified for
}
the exception thrown, the next
matching handler up the
public void method2()
runtime stack get called
{ method3(); }

public void method3()

{ throw new SomeException(); }
}

67

Java Exception Handling

public class MyClass {

Java exceptions are organized
public void method1() {
as a class hierarchy
try { method2(); }
Handlers can be specified for
catch (SomeException e) {
different exception subclasses
// do something w/exception
e.printStackTrace();
If a handler isnt specified for
}
the exception thrown, the next
matching handler up the
public void method2()
runtime stack get called
{ method3(); }

public void method3()

{ throw new SomeException(); }
}

68

Java Exception Handling

public class MyClass {

Java exceptions are organized
public void method1() {
as a class hierarchy
try { method2(); }
Handlers can be specified for
catch (SomeException e) {
different exception subclasses
// do something w/exception
e.printStackTrace();
If a handler isnt specified for
}
the exception thrown, the next
matching handler up the
public void method2()
runtime stack get called
{ method3(); }

public void method3()

{ throw new SomeException(); }
}

69

Java Exception Handling

public class MyClass {

Java exceptions are organized
public void method1() {
as a class hierarchy
try { method2(); }
Handlers can be specified for
catch (SomeException e) {
different exception subclasses
// do something w/exception
e.printStackTrace();
If a handler isnt specified for
}
the exception thrown, the next
matching handler up the
public void method2()
runtime stack get called
{ method3(); }

public void method3()

{ throw new SomeException(); }
}

70

Java Exception Handling

public class MyClass {

Java exceptions are organized
public void methodA() {
as a class hierarchy
...
Handlers can be specified for
}
different exception subclasses
public void methodB() {
If a handler isnt specified for
try { methodA(); }
the exception thrown, the next
catch (Exception e) {
matching handler up the
// do something w/exception
runtime stack get called
}
To handle every possible type
}
of exception, catch Exception

See developer.android.com/reference/java/lang/Exception.html
71

Java Exception Handling

public class MyClass {

Java exceptions are organized
public void methodA() {
as a class hierarchy
...
Handlers can be specified for
}
different exception subclasses
public void methodB() {
If a handler isnt specified for
try { methodA(); }
the exception thrown, the next
catch (Throwable e) {
matching handler up the
// Every recoverable runtime
runtime stack get called
// error and exception will
To handle every possible type
// be caught
of exception, catch Exception
e.printStackTrace();
}
To hancle every possible type of
}
error, catch Throwable

See developer.android.com/reference/java/lang/Throwable.html
72

Java Exception Handling

public class MyClass {

Java exceptions are organized
public void methodA() {
as a class hierarchy
...
Handlers can be specified for
}
different exception subclasses
public void methodB() {
If a handler isnt specified for
try { methodA(); }
the exception thrown, the next
catch (Throwable t) {
matching handler up the
// Every recoverable runtime
runtime stack get called
// error and exception will
To handle every possible type
// be caught
of exception, catch Exception
t.printStackTrace();
}
To handle every possible type
}
of error, catch Throwable

See developer.android.com/reference/java/lang/Throwable.html#printStackTrace()
73

Java Exception Handling

There are two types of exceptions:

74

Java Exception Handling

There are two types of exceptions: public class Vector<E> {

Checked exceptions

Methods declaring checked

exceptions require callers to
provide an exception handler

private void writeObject

(java.io.ObjectOutputStream s)
throws java.io.IOException {
...
}
...

See en.wikibooks.org/wiki/Java_Programming/Checked_Exceptions
75

Java Exception Handling

There are two types of exceptions: public class Vector<E> {

Checked exceptions

Methods declaring checked

exceptions require callers to
provide an exception handler

private void writeObject

(java.io.ObjectOutputStream s)
throws java.io.IOException {
...
}
...

76

Java Exception Handling

There are two types of exceptions: public class Vector<E> {

Checked exceptions

Methods declaring checked

exceptions require callers to
provide an exception handler

private void writeObject

(java.io.ObjectOutputStream s)
throws java.io.IOException {
...
}
...
void method1(Vector<Integer> v
ObjectOutputStream s) {
try { v.writeObject(s); }
catch (IOException ioe) {
...
}
}
...

77

Java Exception Handling

There are two types of exceptions: public class Vector<E> {

Checked exceptions

Methods declaring checked

exceptions require callers to
provide an exception handler

private void writeObject

(java.io.ObjectOutputStream s)
throws java.io.IOException {
...
}
...
void method1(Vector<Integer> v
ObjectOutputStream s) {
try { v.writeObject(s); }
catch (IOException ioe) {
...
}
}
...

78

Java Exception Handling

There are two types of exceptions: public class MyClass {

Checked exceptions
Unchecked exceptions

Can be thrown without a

method declaring it

public void methodA(int index) {

if (index < 0)
throw new
IndexOutOfBoundsException();
...
}
public void methodB() {
try { methodA(-1); }
catch (Exception e) {
throw new
RuntimeException(e);
}
}

See docs.oracle.com/javase/tutorial/essential/exceptions/runtime.html
79

Java Exception Handling

There are two types of exceptions: public class MyClass {

Checked exceptions
Unchecked exceptions

Can be thrown without a

method declaring it

public void methodA(int index) {

if (index < 0)
throw new
IndexOutOfBoundsException();
...
}
public void methodB() {
try { methodA(-1); }
catch (Exception e) {
throw new
RuntimeException(e);
}
}

80

Java Exception Handling

There are two types of exceptions: public class MyClass {

Checked exceptions
Unchecked exceptions

Can be thrown without a

method declaring it

public void methodA(int index) {

if (index < 0)
throw new
IndexOutOfBoundsException();
...
}
public void methodB() {
try { methodA(-1); }
catch (Exception e) {
throw new
RuntimeException(e);
}
}

81

Java Exception Handling

There are two types of exceptions: public class MyClass {

Checked exceptions
Unchecked exceptions

Can be thrown without a

method declaring it

public void methodA(int index) {

if (index < 0)
throw new
IndexOutOfBoundsException();
...
}
public void methodB() {
methodA(-1);
}

82

Java Exception Handling

There are two types of exceptions: public class MyClass {

Checked exceptions
Unchecked exceptions

Can be thrown without a

method declaring it

public void methodA(int index) {

if (index < 0)
throw new
IndexOutOfBoundsException();
...
}
public void methodB() {
methodA(-1);
}

83

Java Exception Handling

There are two types of exceptions: public class MyClass {

Checked exceptions
Unchecked exceptions

Can be thrown without a

method declaring it

public void methodA(int index) {

if (index < 0)
throw new
IndexOutOfBoundsException();
...
}
public void methodB() {
try { methodA(-1); }
catch (Exception e) {
throw new
RuntimeException(e);
}
}

84

Java Exception Handling

There are two types of

exceptions:

Checked exceptions
Unchecked exceptions

Can be thrown without a

method declaring it

public class MyClass {

public void methodA(int index) {
if (index < 0)
throw new
IndexOutOfBoundsException();
...
}
public void methodB() {
try { methodA(-1); }
catch (Exception e) {
throw new
RuntimeException(e);
}
}

85

Java Exception Handling

See docs.oracle.com/javase/tutorial/essential/exceptions
86

Overview of Java
Garbage Collection
87

Java Garbage Collection

Java has garbage collection, so memory

neednt be managed explicitly

88

Java Garbage Collection

Java has garbage collection, so memory

neednt be managed explicitly
Garbage collection makes writing
most applications much easier

See en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Advantages
89

Java Garbage Collection

Java has garbage collection, so memory

neednt be managed explicitly
Garbage collection makes writing
most applications much easier
e.g., avoids dangling pointers,
double deletions, memory leaks,
etc.

Determining when to release memory is

especially hard when objects are used by
threads, processes, remote clients, etc.

90

Java Garbage Collection

Java has garbage collection, so memory

neednt be managed explicitly
Garbage collection makes writing
most applications much easier
There are disadvantages, however

See en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Disadvantages
91

Java Garbage Collection

Java has garbage collection, so memory

neednt be managed explicitly
Garbage collection makes writing
most applications much easier
There are disadvantages, however
e.g., additional overhead & nondeterminism

92

Java Garbage Collection

Java has garbage collection, so memory

neednt be managed explicitly
Garbage collection makes writing
most applications much easier
There are disadvantages, however
Modern JVMs have sophisticated
garbage collection implementations

See www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01
93