Chapter 7 Classes and Methods III: Static Methods and Variables

1
Chapter 7Classes and Methods IIIStatic Methods
and Variables

• Lecture Slides to Accompany
• An Introduction to Computer Science Using Java
  (2nd Edition)
• by
• S.N. Kamin, D. Mickunas, E. Reingold

2
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

3
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

4
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

5
(No Transcript)
6
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

7
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

8
Revised Class Definition

• public class name
• declarations of instance variables
• constructor definitions
• method definitions
• Every class needs one or more constructor
  definitions

9
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

10
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)

11
Constructors

• public class Clock
• int hour,
• minute
• // constructor
• public Clock( )
• hour 12
• minute 0
• // other methods follow

12
Using Constructors

• // c1 set to 1200
• Clock c1 new Clock()
• // c1 set to 830
• c1.setHour(8)
• c1.setMinute(30)
• // c2 set to 1200 c1 still 830
• Clock c2 new Clock()

13
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

14
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)

15
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

16
Using Constructors

• Clock c1 new Clock( ) // c1 set to 1200
• Clock c2 new Clock(8, 20) // c2 set to 820
• Clock c3 new Clock() // c3 set to 820
• c3.setHour(8)
• C3/setMinute(20)

17
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

18
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)

19
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 lt c.hour
• hour c.hour
• minute lt c.minute)

20
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

21
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

22
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)

23
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)

24
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

25
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

26
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)

27
(No Transcript)
28
Mutability

• Transforming an object from one state to another
• Only objects can be mutated, primitive values are
  not (e.g. x4 does not change x)
• Objects are only mutable if its interface
  includes mutating methods

29
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)

30
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)

31
Heap After Assigning c1 to c2
32
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

33
Object Containing Reference to Another Object
34
UML Class Diagram for Clock-DrawingBox
Association
35
UML Class Diagram for Clock-DrawingBox
Association
36
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

37
UML Class Diagram for Clock-DrawingBox
Composition
38
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

39
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