Transcript Note

CS 21b Intro to Computing II
Object-Oriented Programming:
Classes in Java
Object
Definition: a thing that has identity,
state, and behavior
identity: a distinguished instance of a
class
 state: collection of values for its variables
 behavior: capability to execute methods
* variables and methods are defined in a
class

Class
Definition: a collection of data (variables)
and methods that operate on that data



data/methods define the
contents/capabilities of the instances
(objects) of the class
object creation occurs with the statement
variable = new class(parameters);
classes can be viewed as factories for
objects
Class

A class is a template for an object

An object is an instance of a class
Class

All data and variables defined within a
class are called instance variables


because each instance of that class (each
object of the class) contains a copy of that
variable
Methods and variables defined within a
class are called members of that class
Two Kinds of Variables
in Java

Variables of a primitive type
e.g., int x; char c;

Variables of a reference type (class)
e.g., Button b; String s;

Conventions


Primitive types are reserved words in Java
and are indicated in all-lower-case letters
Class names: first letter usually capitalized
Variables and Values

Primitive type variables
int x;
…
x = 5;
X
X
5
Variables and References

Reference type variables
X
Button x;
…
x = new Button(“click”);
Button Object
X
“click”
The new Keyword

new Button(“click”) creates a Button
object and returns a reference (an
address) to that object that a Button
Button Object
variable could hold
X
1023
1023:
1023 is some address in memory
“click”
The Dot (“.”) Operator

Allows access to variables (primitive and
reference types) and methods of
reference type variables.

Ex.
TextField t = new TextField(10);
t.setText(“hi”);
*accessing a method using the dot operator
Method Invocation

Syntax for method invocation
object.methodName(arguments)


Method may return a value or simply
produce an effect on the object
To find out what methods are available
for a given class


javap package.name.NameOfClass
ex. Javap java.awt.Button
Strings Revisited


Strings are objects as well
String is an existing Java class


s = “Hello” is just a shorthand for
s= new String(“Hello”);
String methods



int length()
String substring(int x,int y);
no “manipulating” methods
Variables and Objects
Let Circle be a class with:
variable r that indicates its radius
method area() that computes its area



Declaration:
Circle c;
Instantiation:
c = new Circle();
Usage:
c.r = 5.5;
System.out.println(c.area());
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; }
}
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());
}
}
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
Constructors

A constructor is a special type of
method


It is called when an object is created


has the same name as the class
new Circle(); // “calls” the Circle()
method
If no constructor is defined, a default
constructor that does nothing is
implemented
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;
}
...
}
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
}
...
}
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());
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
Fill in the blanks...

Constructor without a parameter
public classname() {
*body of the constructor
}
Fill in the blanks...
Overloading constructors
public classname(type variablename) {
*body of constructor
}
public classname(
type variable-name, type variable-name) {
*body of constructor
}

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
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
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
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
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
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; }
// ...
}
Inheritance
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
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 int diameter() { return getRadius()*2;}
}
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();
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
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
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()
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();
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
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
}
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);
}…
}
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
Fill in the blanks...

Extends and Super
public class subclass extends superclass {
public subclassconstructor(...) {
super(...);
*body of constructor
}
...
}
Abstract Classes and
Interfaces
“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
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
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 methods
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();
}
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; }
}
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
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()
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
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
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
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
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
...
}
Notes on Interfaces

Interface variables can be declared



Interfaces cannot be instantiated
Interface variables may refer to objects
of classes that implement the interface


e.g., Switch s;
e.g., s = new Computer();
A class may implement several
interfaces
Multiple Inheritance

Other OO languages such as C++ allow
several superclasses for a given class


Implementation problems


not possible in Java
common members in superclasses
In Java


use interfaces
it is possible to implement several
interfaces with no “conflicts”
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
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();
Using Anonymous Classes
FunctionPlotter lp = new FunctionPlotter() {
public double f(double x) { return x; }
}
lp.plot();
// no need to explicitly define a LinePlotter class
Fill in the blanks...

Anonymous classes
abstractclassorinterface var =
new abstractclassorinterface() {
// complete the definitions of abstract
// methods here
}
The Java Event Models
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
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
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
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
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
“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
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
Who should be the Listener?

The applet


Third party


no advantage except that old jdk1.0.2 code
translates easily to this technique
clearly indicates the role of the listeners
ActiveButton


encapsulates listener-related activity
applet code easier to read