Post on 17-Jan-2016
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