Transcript Notes, Part VII (Inheritance)

The complete Circle class
public class Circle {
public double x,y; // center coordinates
public double r; // radius
// the methods
public double circumference()
{ return 2*3.14*r; }
public double area() { return 3.14*r*r; }
}
1
Using the Circle class
public class TestCircle {
public static void main(String args[]) {
Circle c;
c = new Circle();
c.x = 2.0; c.y = 2.0; c.r = 5.5;
System.out.println(c.area());
}
}
2
The this keyword
this refers to the current object
In the Circle class, the following
definitions for area() are equivalent:
public double area() { return 3.14 * r * r; }
public double area() { return 3.14 * this.r * this.r; }
Using the keyword clarifies that you are
referring to a variable inside an object
3
Constructors
A constructor is a special type of
method
has the same name as the class
It is called when an object is created
new Circle(); // “calls” the Circle()
method
If no constructor is defined, a default
constructor that does nothing is
implemented
4
A constructor for the
Circle class
public class Circle {
public double x,y; // center coordinates
public double r; // radius
public Circle() {
// sets default values for x, y, and r
this.x = 0.0; this.y = 0.0; this.r = 1.0;
}
...
}
5
A constructor with
parameters
public class Circle {
…
public Circle(double x, double y, double z) {
this.x = x; this.y = y; this.r = z;
// using this is now a necessity
}
...
}
6
Using the different
constructors
Circle c, d;
c = new Circle();
// radius of circle has been set to 1.0
System.out.println(c.area());
d = new Circle(1.0,1.0,5.0);
// radius of circle has been set to 5.0
System.out.println(d.area());
7
Method Overloading
In Java, it is possible to have several
method definitions under the same name
 but the signatures should be different
Signature:
the name of the method
the number of parameters
the types of the parameters
8
Syntax Summary
Constructor without a parameter
public classname() {
*body of the constructor
}
9
Syntax Summary
 Overloading constructors
public classname(type variablename) {
*body of constructor
}
public classname(
type variable-name, type variable-name) {
*body of constructor
}
10
Encapsulation
A key OO concept: “Information Hiding”
Key points
The user of an object should have access
only to those methods (or data) that are
essential
Unnecessary implementation details should
be hidden from the user
In Java, use public and private
11
Access Modifiers
public
a public variable/method is available for use
outside the class it is defined in
private
a private variable/method may be used only
within the class it is defined in
12
The Circle class Revisited
public class Circle {
private double x,y; // center coordinates
private double r; // radius
// ...
}
// when using the Circle class ...
Circle c;
c.r = 1.0; // this statement is not allowed
13
Outside access
to private data
No direct access
Define (public) set and get methods
instead or initialize the data through
constructors
Why?
If you change your mind about the names
and even the types of these private data, the
code using the class need not be changed
14
Set and Get Methods
Variables/attributes in a class are often
not declared public
Instead:
define use a (public) set method to assign a
value to a variable
define a get method to retrieve that value
Consistent with encapsulation
15
Set and Get Methods for
Radius
public class Circle {
// ...
private double r; // radius
// …
public void setRadius(double r) { this.r = r; }
public double getRadius() { return this.r; }
// ...
}
16
Inheritance
17
Subclasses and
Inheritance
Inheritance:
programming language feature that allows
for the implicit definition of variables/methods
for a class through an existing class
In Java, use the extends keyword
public class B extends A { … }
objects of subclass B now have access* to
variables and methods defined in A
18
The EnhancedCircle class
public class EnhancedCircle extends Circle {
// as if area(), circumference(), setRadius() and getRadius()
// automatically defined; x,y,r are also present (but are private
// to the the Circle class)
private int color;
public void setColor(int c) { color = c; }
public void draw() { … }
public double diameter() {
return getRadius()*2; }
}
19
Using a Subclass
EnhancedCircle c;
c = new EnhancedCircle();
// Circle() constructor
// implicitly invoked
c.setColor(5);
c.setRadius(6.6);
System.out.println(c.area());
System.out.println(c.diameter());
c.draw();
20
Applets and Inheritance
Java Applets that we write extend the
Applet class (defined in package
java.applet)
Methods such as add() (for adding visual
components) are actually methods
available in the Applet class
init(), action(), and paint() are also
available but can be overridden
21
Class Hierarchy
Subclass relationship forms a hierarchy
Example: TextField class
TextField extends TextComponent which
extends Component which extends Object
Object is the topmost class in Java
Exercise (use javap):
determine where the methods setText(),
getText(), hide(), and show() are defined
22
Method Overriding
A method (with a given signature) may be
overridden in a subclass
Suppose class B extends A
let void operate() be a method defined in A
void operate() may be defined in B
objects of class A use A’s operate()
objects of class B use B’s operate()
23
Dynamic Binding
Let A be a superclass of subclasses B and
C
A variable of class A may refer to
instances of A, B, and C
Java facilitates the calling of the
appropriate method at run time
Example
A v; … v.operate();
24
Constructors and
Superclasses
Suppose B extends A
new B() calls B’s constructor
how about A’s constructor ?
Rule
the constructor of a superclass is always
invoked before the statements in the
subclass’ constructor are executed
25
super()
Used to call a superclass’ constructor
Implicitly included when not indicated
If B extends A, the following are equivalent:
public B() {
// body of constructor
}
public B() {
super();
// body of constructor
}
26
Calling a particular
Constructor
Use super with parameters if a particular
constructor should be called
Example:
public class BlueButton extends Button {
public BlueButton(String s) {
super(s); // without this, super() is called (label-less)
setBackground(Color.blue);
}…
}
27
Default Constructors
When no constructors are defined
a default constructor with no parameters is
implicitly included
If at least one constructor is defined, with
or without parameters
a default constructor will not apply
28
Syntax Summary
Extends and Super
public class subclass extends superclass {
public subclassconstructor(...) {
super(...);
*body of constructor
}
...
}
29
Abstract Classes and
Interfaces
30
“Incomplete” Classes
Objects vs “concepts”
Example: Circle and Shape
circles are shapes (Circle extends Shape)
shapes (such as circle) have area and
circumference
how are area() and circumference() defined
at the level of Shape?
Shape has incomplete definitions
31
The Shape class
One option
make area() and circumference() methods
that do nothing (perhaps return 0.0)
Circle could extend shape and then override
these methods
problems ?
Another option available in Java
abstract class
32
Abstract Class
Same as class
but it is possible to omit method bodies
syntax:
abstract before class (and method headers)
semicolon at the end of the method headers
Rules
may declare variables of abstract classes
instantiation not possible (new will not
work)
subclasses must override incomplete
33
The Shape class
public abstract class Shape {
private int color;
public void setColor(int c) { color = c; }
public abstract double circumference();
public abstract double area();
}
34
The Circle class
public class Circle extends Shape {
private double r;
…
// the compiler will complain if the ff methods are not defined
public double circumference()
{ return 2*3.14*r; }
public double area() { return 3.14*r*r; }
}
35
Using Shape and Circle
Circle c;
Shape s;
c = new Circle(); // ok
s = new Shape(); // not allowed -- Shape is abstract
s = new Circle(); // ok because Circle is a
// subclass of Shape
36
Another Example:
Function Plotter
Define an abstract class FunctionPlotter
that plots a mathematical function f()
a method plot() plots a function f() by
evaluating f() on some x values
make f() an abstract method, i.e.,
public abstract double f(double x);
Next, define classes that extend
FunctionPlotter and complete the
definition of f()
37
Function Plotter, continued
LinePlotter defines f() as follows:
public double f(double x) { return x; }
SquarePlotter defines f() as follows:
public double f(double x) { return x*x; }
Note: LinePlotter, SquarePlotter (and Circle,
in the previous example) are called
concrete classes
38
Why Use Abstract
Classes?
More robust code
no need to use “new” on anything it
shouldn’t be used on
Enforces discipline
Abstract classes cannot be instantiated;
they are meant to be extended
Anyone who extends an abstract class is
now forced to define the incomplete parts
39
Interface
None of the methods have bodies
Instance variables not allowed
Syntax
interface not class
no need to put abstract before method
headers
implements not extends on the complete
(concrete) class
40
Rules on Interfaces
May declare variables whose type is an
interface
objects that are instances of classes that
implement the interface may be referred to
by such variables
Instantiation not possible
Implementing class must define all
methods
41
Example
public interface Switch {
public void turnOn();
public void turnOff();
public boolean isOn();
}
public class Computer implements Switch {
// must define turnOn(), turnOff(), and isOn() in this class
...
}
42
Notes on Interfaces
Interface variables can be declared
e.g., Switch s;
Interfaces cannot be instantiated
Interface variables may refer to objects of
classes that implement the interface
e.g., s = new Computer();
A class may implement several interfaces
43
Multiple Inheritance
Other OO languages such as C++ allow
several superclasses for a given class
not possible in Java
Implementation problems
common members in superclasses
In Java
use interfaces
it is possible to implement several interfaces
with no “conflicts”
44
Anonymous Classes
Feature available in JDK 1.1 or higher
versions of Java
Useful when
Only one object of the concrete class needs
to be created
It is not too important to have a name for
the concrete class
45
Back to FunctionPlotter
Example
Without anonymous classes, the
LinePlotter class would look like this
public class LinePlotter extends FunctionPlotter {
public double f(double x) { return x; }
}
And then, in some main program …
LinePlotter lp = new LinePlotter();
lp.plot();
46
Using Anonymous Classes
FunctionPlotter lp = new FunctionPlotter() {
public double f(double x) { return x; }
}
lp.plot();
// no need to explicitly define a LinePlotter class
47
Syntax Summary
Anonymous classes
abstractclassorinterface var =
new abstractclassorinterface() {
// complete the definitions of abstract
// methods here
}
48
The Java Event Models
49
Event-Driven Programming
in Java
Specifying actions for events performed
on the GUI
most common example: clicking on a button
The Java Event Models
JDK 1.0.2 (deprecated)
JDK 1.1 and the new event model
50
Sample Applet:
HideAndShow
Visual objects
text field with some text
two buttons
Actions performed
hide button causes text field to disappear
show button makes text field reappear
51
JDK 1.0.2
What needs to be done
init() method: create visual components and
add them to the applet
action(): determine which button was clicked
and indicate associated action
Problems
nested if-statement in action() inefficient
code associated with visual object far from
its definition
52
Listeners and JDK 1.1
Listener
responsible for processing UI events
specifies actions that corresponds to an
event
JDK 1.1
code for listeners made explicit
need to associate a listener for every visual
object that the user interacts with
listener should implement method(s) that
specify corresponding actions
53
The Applet as the Listener
Follows JDK 1.0.2 event model
What needs to be done
init() method: as before but associate applet
as listener for both buttons
(addActionListener(this))
applet implements ActionListener interface
define actionPerformed() instead of action()
use e.getSource() instead of e.target to
distinguish between buttons pressed
Problems not addressed
54
“Third party” Listener
Different listener for each button
Listeners are separate objects
Two different definitions of
actionPerformed()
No need to distinguish between buttons
What needs to be done
create listener objects
add the objects as listeners for the buttons
use anonymous classes
55
The Button as the Listener
Create a new class (ActiveButton)
class extends Button and implements
ActionListener (contains actionPerformed())
actionPerformed() contains call to onClick()
addActionListener(this) in constructor of
class
Applet instantiates ActiveButton
onClick() or actionPerformed() is overridden
as appropriate
56
Who should be the
Listener?
The applet
no advantage except that old jdk1.0.2 code
translates easily to this technique
Third party
clearly indicates the role of the listeners
ActiveButton
encapsulates listener-related activity
applet code easier to read
57