Chapter 7Classes and Methods III:

Static Methods and Variables

Lecture Slides to Accompany

An Introduction to Computer Science Using Java (2nd Edition)

byS.N. Kamin, D. Mickunas, E. Reingold

Chapter PreviewIn this chapter we will:• describe user-defined classes

– instance variables– constructors – instance methods

• present several examples of classes• discuss the concepts of mutability and

visibility• describe method overloading

Object-Oriented Programming

• OOP supports the view that programs are composed of interacting objects

• Objects are composed of– values known as attributes or instance variables– operations (actions) that can be performed on these values

know as instance methods• Messages requesting an action or value are sent to

objects• Objects respond to messages that are in their

protocols or interfaces

Objects

• Encapsulate data values within a single entity• Their behavior is often general enough to

allow reuse in a variety of situations• Often form a basis from which other objects

can be derived using a mechanism known as inheritance

• Are a type container that is stored on the system heap

• A client is program that uses an object

Client Rights

• To declare variables of the class type• To create instances of the class using constructors• To send messages to instances of the class by

invoking class instance methods• To know the class public interface

– instance method names– parameter number and types– return types

• To know the instance methods that alter (mutate) the instance

Class Rights

• To define the class public interface• To hide all the implementation details from

the client• To protect internal data from client access• To change implementation details at any

time, provided the public interface remains intact

• To change the public interface with client concurrence

Revised Class Definition

public class name { declarations of instance variables

constructor definitions

method definitions}• Every class needs one or more constructor

definitions

Revised Class Definition

• Instance variables– local data contained in class

• Method definitions– describe the class interface and how it responds to

each client message• Constructors definitions

– describe how to initialize instance variables in a new object

Constructors

• Look like regular instance methods• Never have a return type• Always have the same name as the class

name• May have parameters• Default constructors have no parameters• Constructors can be overloaded (more than

one definition in the same class)

Constructors

public class Clock {

int hour, minute; // constructor public Clock( ) { hour = 12; minute = 0; } // other methods follow …}

Using Constructors

// c1 set to 12:00Clock c1 = new Clock(); // c1 set to 8:30 c1.setHour(8);c1.setMinute(30);// c2 set to 12:00 c1 still 8:30Clock c2 = new Clock();

Overloading Constructors

• Classes can have more than one constructor

• All constructors have the same name (the class name)

• Each constructor differs from the others in either the number or types of its arguments

• new is used when using a constructor to create a new object

Overloading Constructors

• We could add the following to Clock public Clock(int h, int m) { hour = h; minute = m; }

• A client program could contain Clock c1 = new Clock(8, 20);

• Which is the same as writing Clock c1 = new Clock( ); c1.setHour(8); c1.setMinute(20);

Overloaded Clock Constructorspublic class Clock { int hour, minute; public Clock () { hour = 12; minute = 0; } public Clock (int h, int m){ hour = h; minute = m; } …}

Using Constructors

Clock c1 = new Clock( ); // c1 set to 12:00

Clock c2 = new Clock(8, 20); // c2 set to 8:20

Clock c3 = new Clock(); // c3 set to 8:20c3.setHour(8);C3/setMinute(20);

Overloading Methods

• Methods can also be overloaded• This allows different versions of the method in

the same class• Each method variant must differ from the

others by the number or types of its parameters

• Overloading allows methods with the same name to have different return types

Methods Calling Other Methods

• Methods are allowed to call other methods in the same class without specifying an explicit receiver

• This allows overloaded methods to call one another without repeating redundant code

• Example:public void display (DrawingBox d, int r) { display(d, d.getDrawableWidth()/2, d.getDrawableHeight()/2, r);}

Dot Notation

• We can also use dot notation to view instance variables of the same class that are different from the receiver

• Example:public boolean priorTo (Clock c) { return (hour < c.hour || hour == c.hour && minute < c.minute);}

this – Avoiding Variable Name Collisions

• “this” can be used to distinguish between references to instance variables and local identifiers or arguments

public void set (int hour, int minute) { int totalMinutes = (hour * 60 + minutes); this.minute = totalMinutes % 60;}

• this.minute refers to the instance variable minute not the method argument

this – Passing the Receiver as an Argument

• “this” can be used to send a message to the current receiver of the message without explicitly naming the receiver

public boolean after (Clock c) { return c.priorTo(this);}

• this is used as if it were a variable referring to the receiver of the message

this – Chaining Constructors

• “this” can be used to simplify constructor code by allowing one constructor to call another

• We can rewrite the clock constructors as:

public Clock ( ) { this(12,0);}

public Clock (int hour, int minute) { set(hour, minute);}

Visibility Qualifiers

public int x; // client creating instance o of this // class can access x by writing o.x

private int y; // no can access y directly, access // provided though class methods

• To enforce complete information hiding all instance variables should be declared using private

• The default visibility of instance variables lies between private and public (explained later in the text)

Visibility Qualifiers and Methods

• By default class methods are also accessible to some classes but not others

• Visibility qualifiers should also be used in method declarations

• Examples:

public void f( ) { // Any client using object o // can send it a message // by writing o.f( )private void g( ) { // No client can send g to // the object except another // method from this class

Visibility and UML Diagrams

• In UML diagrams – private variables and methods are

indicated using a leading minus sign as a prefix

– public variables and methods are indicates using a leading plus sign as a prefix

– a blank prefix means that the variables and methods are not annotated and will have their default visibility

Mutation

• An object can be changed by assigning a new value to one or more of its instance variables

• Example:d = new DrawingBox();c = new Clock();c.set(10, 20);c.display(d, 50, 50, 50);c.set(5, 40);

Mutability

• Transforming an object from one state to another

• Only objects can be mutated, primitive values are not (e.g. x+4 does not change x)

• Objects are only mutable if its interface includes mutating methods

Nonmutation

• Creating a new object similar to original, but including the desired change

• Note the return type is Clock, not void• Example:

public Clock set_nonmut (int hour, int Minute) { return new Clock(hour, minute);}

What would happen?

• Consider the effects on the heap if the following sequence of statements was executedClock c1 = new Clock();Clock c2 = c1;c1.set(4, 30);c2.set(5, 40);

Heap After Assigning c1 to c2

Class Association• Used to achieve certain desired

behavior• Association (or acquaintance)

– classes and objects are linked in a manner that allows the object to remain visible to clients

– classes can be linked when a client passes an object as a message argument to another object

Object Containing Reference to Another Object

UML Class Diagram for Clock-DrawingBox Association

UML Class Diagram for Clock-DrawingBox Association

Class Containment• Composition (or aggregation)

– an object of one class is constructed from objects of other classes so that only the composite object is visible to clients

– the component objects are internal to the containing object

• Aggregation is a weaker form of containment and will not be used in this text

UML Class Diagram for Clock-DrawingBox Composition

Representation Independence

• In OOP the representation of data is encapsulated, this means that the data representation may be changed without affecting the previous class behavior

• Clients should not be able to detect that a change has occurred

• Sometimes this is know as implementation independence

main

• Every Java program needs a class containing a static method called main

• Static methods (or class methods) are special methods that do not require receivers

• Static methods cannot refer to class instance variables, but can be invoked when no class instances exist

• Static methods will be discussed in more detail in Chapter 10