Lecture An introduction to computer science using java (2nd Edition): Chapter 7 - S.N. Kamin, D. Mickunas, E. Reingold

Chapter 7 - Classes and methods III: Static methods and variables. In 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.

Chapter 7

Classes and Methods III:

Static Methods and Variables

Lecture Slides to Accompany

An Introduction to Computer Science

Using Java (2nd Edition)

by S.N Kamin, D Mickunas, E Reingold

Chapter Preview

In 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

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

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)

• 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 Constructors

public 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:20 c3.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

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:

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

• Objects are only mutable if its interface

includes mutating methods

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 executed

Clock 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

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