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 Variablesin 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; 5

X

X

Variables and References Reference type variables

Button x; …x = new Button(“click”);

X

X

“click”

Button Object

The new Keyword new Button(“click”) creates a

Button object and returns a reference (an address) to that object that a Button variable could hold

“click”

Button Object

1023:

1023 is some address in memory

1023

X

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 fors= 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 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

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.0System.out.println(c.area());d = new Circle(1.0,1.0,5.0);// radius of circle has been set to 5.0System.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 constructorspublic classname(type variable-

name) {*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 accessto 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 Radiuspublic 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 keywordpublic class B extends A { … } objects of subclass B now have access*

to variables and methods defined in A

The EnhancedCircle classpublic 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() { public B() {

// body of constructor 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 classpublic 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

Examplepublic 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

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

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”

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 thispublic 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

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