Lesson 4

1
Lesson 4 Classes Objects

• Unit D1 Introduction

2
Container vs. Definition classes

• Generally, classes can be used for two purposes
• Container classes
• a collection of static methods that are not bound
  to any particular object (e.g., the main()
  method).
• These static methods usually have something in
  common
• Definition classes
• These classes define new objects, in a way that
  we will soon see.

3
Container vs. Definition Classes - Example

• The Math class is an example of the first kind.
  It is a container for math utility methods
  Math.sqrt(), Math.abs(), Math.max(), ...
• The class Turtle is an example of the second
  kind. It defines a new type of objects, Turtle
  objects.
• We will now focus on the second kind.

4
Class Abstraction

• The most important stage in writing a class is to
  get an abstraction of the class done first.
• What does an object of this type represent?
• What is its interface?
• What is its internal state?
• This means you have to know what should be the
  internal state (variables) and also the
  behavior/interface (methods) of the class before
  you start to write you class code.

5
Objects and Classes

• The relationship between Classes and Objects can
  be seen as the relationship between a
  blueprint/model and the the actual object built
  from it.
• Example Blueprint of a house (class) and the
  house (object)
• The class defines
• The type of data that will be held in an object
• The code for the methods of the object
• In order to use a class you must instantiate an
  object from it.
• This corresponds to building the house from the
  blueprint.
• There may be many objects from a single class

6
Turtle Class Abstraction

• A Turtle represents a creature moving on the
  screen with a pen attached to its tail
• The internal state of a Turtle includes
• Location on screen direction of movement tail
  up/down
• The interface of a Turtle is

Turtle() void moveForward(double units) void
moveBackward(double units) void turnLeft(double
degrees) //
7
Encapsulation

• The internal state of an object is not directly
  accessible to other parts of the program
• Other parts of the program can only access the
  object using its interface
• We say that the state is
• encapsulated or hidden
• This gives modularity
• to the program

moveForward()
. . .
. . .

• tailDown
• x,y
• direction

turnRight()
8
Clock Class Abstraction

• A Clock represents a 12-hour clock
• Its internal state includes hour, minute, second
• Its interface allows telling the clock that a
  second has elapsed, and querying the clock for
  the time

Clock(int hours, int minutes, int seconds)
void secondElapsed()
int getSeconds()
int getMinutes()
int getHours()
...
9
Using a Clock class

• Clock newYorkTime new Clock(12,59,59)
• for (int j 0 j lt 3 j)
• newYorkTime.secondElapsed()
• System.out.println(newYorkTime.getHours()
• newYorkTime.getMinutes()
• newYorkTime.getSeconds())

10
Structure of the Clock class

• The private modifier specifies an identifier that
  is only visible within the class. Usually used
  for fields.
• The public modifier specifies an identifier that
  is accessible to all other classes. Usually used
  for methods.

public class Clock private int hours,
minutes, seconds public Clock(int h, int m,
int s) public void secondElapsed()
public int getHours() public int
getMinutes() public int getSeconds()

11
Lesson 4 Classes Objects

• Unit D2 - Class Elements

12
Instance Variables

• Recall that a class must define the state of an
  object and its behavior.
• We declare state variables (variables that hold
  the state of the object) in a similar way to that
  of regular variables, only they appear outside
  methods, inside the class.
• State variables are also called instance
  variables or fields.
• Roughly speaking, the private modifier means that
  the variables are not part of the objects
  interface.

public class Clock private int hours,
minutes, seconds //
13
Constructors

• Objects must be initialized before they can be
  used.
• We must specify what is the initial state of the
  object before we can use it.
• Space for holding the object state data is only
  allocated when the object is constructed.
• We specify the way an object is initialized using
  a constructor, which is a special method which is
  invoked every time we create a new object
• The name of the constructor is always identical
  to the class name

14
Clock Constructor
public Clock(int h, int m, int s) hours
h minutes m seconds s
15
Clock constructor invoked
Clock c c new Clock(10,45,0)
C
public class Clock private int hours,
minutes,seconds public Clock(int h, int m,
int s) hours h minutes m
seconds s //
10 45 0
hours Minutes Seconds
16
Methods

• To make the date object useful, we must provide
  methods that define its behavior.
• We declare methods in a similar way to the way
  the method main was declared.
• Only theres a big difference
• the main method was static, which means it wasnt
  bound to a specific object
• we want to declare instance methods, which
  operate on a specific instance of an object

17
secondElapsed() method
public void secondElapsed() if (seconds lt 59)
seconds else seconds0 if
(minutes lt 59) minutes else
minutes 0 hours hours lt 12 ? hours1
1
18
Return Types

• Methods may return values
• The return type of a method indicates the type of
  value that the method sends back to the calling
  client
• The return-type of getHours() is int. When a
  client ask for the hours read of a clock it gets
  the answer as an int value.
• A method that does not return a value (such as
  secondElapsed()) has a void return type
• The return statement specifies the value that
  should be returned, which must conform with the
  return type of the method.

19
Clock accessor methods
public int getHours() return
hours public int getMinutes() return
minutes public int getSeconds() return
seconds
20
Method Context

• The getHours() and secondElapsed() methods are
  instance methods, which means they act on a
  particular instance of the class
• They cannot be invoked out of the blue. They
  must act on a particular object
• An instance method is executed in the context of
  the object it acts upon.

• Clock c new Clock(1,2,3)
• getHours() // Error!! of which clock?
• c.getHours() // will return 1

21
ClockTest example
public class ClockTest public static void
main(String args) Clock swatch new
Clock(12,59,59) Clock seiko new
Clock(12,59,59) System.out.println(swatch.ge
tHours()) // 12 System.out.println(seiko.getH
ours()) // 12 swatch.secondElapsed()
System.out.println(swatch.getHours()) // 1
System.out.println(seiko.getHours()) // 12

22
Method Parameters

• A method can be defined to accept zero or more
  parameters
• Each parameter in the parameter list is defined
  by its type and name
• The parameters in the method definition are
  called formal parameters
• The values passed to a method when it is invoked
  are called actual parameters
• The name of the method together with the list of
  its formal parameters is called the signature of
  the method

public void setTime(int h, int m, int s)
23
Method setTime()
public void setTime(int h, int m, int s)
if ((s gt 0) (s lt 60) (m gt 0) (m
lt 60) (h gt 0) (h lt 12))
hours h minutes m seconds s
// no effect if input is illegal
24
Lesson 4 Classes Objects

• Unit D3 - Method writing details

25
Variable Scope

• Variables may be declared in
• Class state variables
• Method/constructor local variables (and
  parameters)
• Inner block of a method also local variables
• A variable is recognized throughout the block in
  which it was defined. This is called the scope
  of the variable.
• Local variables are allocated when the method is
  entered and freed when the method exits.
• The same name may be used in different scopes,
  and refer to totally different things
• If the same name is used in an outer and inner
  scope, then the inner scope definition hides
  the outer one.

26
The this reference

• When appearing inside an instance method, the
  this keyword denotes a reference to the object
  that the method is acting upon.
• The following are equivalent

public int getHours() return hours
public int getHours() return this.hours
27
Using same names for parameters and fields

• It is usually bad practice to use the same name
  for a state variable and a local variable or
  parameter.
• Exception parameters that correspond exactly to
  fields

public void setTime(int hours,
int minutes, int seconds)
if ((seconds gt 0) (seconds lt 60)
(minutes gt 0) (minutes lt 60) (hours gt
0) (hours lt 12)) this.hours
hours this.minutes minutes
this.seconds seconds // no effect if
input is illegal
28
Passing Parameters

• When a parameter is passed, a copy of the value
  is made and assigned to the formal parameter

Clock beritling new Clock(1,2,3) int lunchHour
12 breitling.setTime(lunchHour,32,14)
hours lunchHour
minutes 32
seconds 14
29
Parameters are passed by value
Clock c new Clock(1,2,3) int a
7 c.funnyGetHour(a) // still 7!!
class Clock // public void funnyGetHour(int
h) h hours
30
Passing Object parameters

• When an Object is a parameter, only the reference
  is passed by value. The parameter now is an
  alias of the object.

class XX // public void setMidnight(Clock
c) c.setTime(12,0,0)
class YY // XX x new XX() Clock
myClock new Clock(1,2,3) x.setMidnight(myCloc
k) // 1200
31
Example A Bank Account Object
BankAccount

• public BankAccount(long accountNumber)
• public void deposit(double amount)
• public void withdraw(double amount)
• public double getBalance()
• public void transfer(double amount,
  BankAccount targetAccount)

32
Bank Account - example
public class BankAccount private long
accountNumber private double balance
public BankAccount(long accountNumber)
this.accountNumber accountNumber balance
0 public double getBalance() return
balance // continued in the next slide...
33
Bank Account - example
public void deposit(double amount) balance
amount public void withdraw(double amount)
balance - amount public void
transfer(double amount, BankAccount
targetAccount) withdraw(amount)
targetAccount.deposit(amount)
34
Bank Account usage example
BankAccount aliceAcc new BankAccount(1398723) B
ankAccount bobAcc new BankAccount(1978394) ali
ceAcc.deposit(900) aliceAcc.transfer(700,bobAcc)
// Alices balance 200 Bobs balance 700

35
Constructor and Method Overloading

• A class can define several constructors --
  several ways to initialize an instance of this
  class
• These constructors differ by the number and/or
  type of parameters they get.
• When we construct an object, the compiler decides
  which constructor to invoke according to the
  number and types of the actual arguments
• A constructor with no parameters is called the
  default constructor
• Different methods can also use the same name as
  long as they differ in the number or type of
  parameters.
• When we invoke a method, the compiler decides
  which method to invoke according to the number
  and types of the actual arguments

36
Constructor Overloading example
public Clock(int h, int m, int s) hours h
minutes m seconds s public Clock(int
h) this(h, 0 ,0) public Clock()
this(12)
37
Lesson 4 Classes Objects

• Unit D4 - Visibility Modifiers

38
Visibility Modifiers

• We accomplish encapsulation through the
  appropriate use of visibility modifiers
• Visibility modifiers specify which parts of the
  program may see and use any particular
  class/method/field
• Information hiding is good!
• A modifier is a Java reserved word that specifies
  particular characteristics of a programming
  construct
• We've used the modifier final to define a
  constant
• Java has three visibility modifiers public,
  private, and protected
• We will discuss the protected modifier later in
  the course

39
Visibility Modifiers - Classes

• A class can be defined either with the public
  modifier or without a visibility modifier.
• If a class is declared as public it can be used
  by any other class
• If a class is declared without a visibility
  modifier it has a default visibility. This draws
  a limit to which other classes can use this class
  (classes in the same package). We will discuss
  default visibility later in the course.
• Classes that define a new type of objects, that
  are supposed to be used anywhere, should be
  declared public.

40
Visibility Modifiers - Members

• A member is a field, a method or a constructor of
  the class.
• Members of a class can be declared as private,
  protected, public or without a visibility
  modifier
• Members that are declared without a visibility
  modifier are said to have default visibility. We
  will discuss default and protected visibility
  later in the course.

private int hours int hours public int hours
41
Public Visibility

• Members that are declared as public can be
  accessed from any class that can access the class
  of the member
• We expose methods that are part of the interface
  of the class by declaring them as public
• Example the methods getHours(), secondElapsed()
  and setTime() are part of the interface of class
  Clock so we define them as public.
• We do not want to reveal the internal
  representation of the objects data. So we
  usually do not declare its state variables as
  public (encapsulation)

42
Private Visibility

• A class member that is declared as private, can
  be accessed only by code that is within the class
  of this member.
• We hide the internal implementation of the class
  by declaring its state variables and auxiliary
  methods as private.
• Data hiding is essential for encapsulation.

43
Illegal Access - example
// Example of illegal access class
BankAccountTest public static void
main(String args) BankAccount victim
new BankAccount(2398742) victim.balance
victim.balance - 500 // this will not
compile!
public class BankAccount private long
accountNumber private double balance //

44
Encapsulation not Among Instances of Same Class

• Encapsulation is to protect the programmers and
  is thus between the code of different classes
• Sometimes object instances of the same class need
  to access each others guts (e.g., for state
  copying - if we want to create an identical
  instance of an object we have)
• Example
• from within a BankAccount object, any private
  member of a different BankAccount object can be
  accessed.

45
Encapsulation - example
public void transfer(double amount,
BankAccount targetAccount)
withdraw(amount) targetAccount.deposit(amount)
// alternative version (valid, but not so
nice) public void transfer(double amount,
BankAccount targetAccount)
balance - amount targetAccount.balance
amount
46
Lesson 4 Classes Objects

• Unit D5 - API documentation

47
API Documentation

• Your classes are often intended to be used by
  other programmers
• Programmers that use your class are not
  interested in the way it is implemented. They
  want to use it as a whole and are only interested
  in what it does and how to use it.
• API (Application Programmer Interface)
  documentation is a description of the interface
  of the class intended for the application
  programmer who wants to use it.
• To use the class, we need not (and should not)
  look at the code. All that is needed is the class
  API.

48
API Documentation

• The JDK contains a special tool for the
  generation of API documentation for your classes,
  called javadoc.
• Any documentation which is part of the interface
  begins with / (double asterick) and ends with
  /
• javadoc takes as input Java programs and
  automatically generates documentation using
• the public/protected method signatures
• the documentation comments (enclosed by /
  /).
• The output is an HTML file which can be viewed by
  an internet browser.

49
Clock API Documentation
/ A clock represents a point of time in a 12
hour period within a precision of seconds.
Its range 10000 -- 125959. / public
class Clock private int hours private int
minutes private int seconds /
Constructs a Clock Sets the clock to the
specified time. / public Clock(int hours,
int minutes, int seconds) //
50
Clock API Documentation cont.
/ Constructs a Clock Sets the clock to
120000 / public Clock()
this(12,0,0) / Advances this clock
by 1 second. / public void secondElapsed()
// //
51
Javadoc Process
javadoc
.java file
.html file
View using a browser
52
Clock javadoc - page 1
53
Clock javadoc - page 2
54
What should you comment?

• You should put a documentation comment for the
  class itself and for any member of the class
  which is part of its interface.
• All public constructors and methods should have
  documentation comments.
• Private methods are not part of the interface of
  the class, thus javadoc skips them. (But you
  should still comment them for internal purposes.)
• In the rare cases that there are public fields,
  they should have documentation comments.

55
API Documentation

• Remember that documentation comments are written
  for programmers who use your class as a whole.
  They should describe only
• What the class does,
• How to use it.
• Documentation comments should not describe how a
  class is implemented.
• Documentation comments should be
• Short and descriptive,
• Written in a simple language (ENGLISH),
• Accurate.
• Assume that the reader doesnt know anything
  about your class

56
API Documentation Tags

• Documentation comments can also include tagged
  paragraphs that give a standard way to document
  several features of the interface such as method
  parameters, return values, etc.
• A tagged paragraph begins with the symbol _at_
  followed with a tag keywords. Tags _at_see,
  _at_author, _at_version, _at_param, _at_return, _at_exception.
• Documentation comments text can include HTML tags.

57
_at_param tag
/ Changes the current time to
hourminutesecond _at_param hours The new hour
value. _at_param minutes The new minutes
value. _at_param seconds The new seconds value.
/ public void setTime(int hours,
int minutes, int
seconds) this.hours hours
this.minutes minutes this.seconds
seconds
58
setTime generated javadoc
59
_at_return
/ Returns the current hour _at_return The
current hour (between 1 and 12). / public
void getHour() return hours
60
getHour javadoc
61
Naming

• The names you use for your class and for its
  public methods are part of the class API.
• Good descriptive naming are crucial for a clear
  API.
• General rules about naming
• Follow the Java conventions
• Use descriptive names
• Do not use abbreviations!
• Make names long enough, not unnecessary long
• Consist of words in English with no abbreviations
• Use a dictionary
• Read the style guidelines!

62
Changing the Implementation of a Class

• Encapsulation allows us to change an
  implementation of a class without affecting other
  parts of the program.
• Without encapsulation changes to implementation
  might break the program - many changes
• Why would we want to change the implementation?
• Different implementations have different
  tradeoffs (e.g., space conservation, efficiency
  etc.)
• Example a time instance in the day can be
  represented by the number of seconds since
  midnight
• Assume we want to change the implementation of
  the clock - what is involved in the process?

63
Example of new Clock implementation - page 1
/ A clock represents a point of time in a 12
hour period within a precision of seconds.
Its range 010000 -- 125959. / public
class Clock private static final int
SECONDS_IN_12H 126060 private int
secondsFromZero / Constructs a Clock
Sets the clock to the specified time. /
public Clock(int hours, int minutes, int
seconds) secondsFromZero ((hours12)
3600 minutes 60 seconds)
64
Example of new Clock implementation - page 2
/ Constructs a Clock Sets the clock to
120000 / public Clock()
secondsFromZero0 / Advances this
clock by 1 second. / public void
secondElapsed() secondsFromZero
(secondsFromZero1)
SECONDS_IN_12H //
65
Example of new Clock implementation - page 3
/ Returns the current hour _at_return The
current hour (between 1 and 12). / public
void getHour() int h
secondsFromZero/3600 return h gt 0 ? h 12
// all the others can be written in
the same way
66
Lesson 4 Classes Objects

• Unit D6 - Applet Methods Graphic Objects

67
Applet Methods

• We saw in earlier applets the use the of the
  paint method to draw the content of the of the
  applet on the screen.
• An applet has several other methods that perform
  specific duties.
• Because the applets are specifically designed to
  work with web browsers, some particular applet
  methods are designed around that concept.

public void paint(Graphics g)
68
Some Applet Methods
public void init()

• Initializes the applet. Called just after the
  applet is loaded.
• Starts the applet. Called just after the applet
  is made active.
• Stops the applet. Called just after the applet is
  made inactive.
• Destroys the applet. Called when when the browser
  is exited.

public void start()
public void stop()
public void destroy()
69
Init, start, stop, and destroy.

• The init method is executed once when the applet
  is first loaded, such as when the browser or the
  applet viewer initially view the applet.
• This is the place to to initialize the applets
  environment and permanent data.
• The start/stop methods of an applet are called
  when the applet becomes active/inactive.
• For example, after we use a browser to initially
  load an applet start is called. When we leave the
  page, the applet becomes inactive and stop is
  called. If we return to that page the applet
  becomes active again and start is called.

init
start
stop
destroy
70
Objects with Graphic representation

• Many programs are graphic
• Many objects in such programs correspond to
  graphic objects on the screen this is good
  programming practice.
• Such a graphic object will know how to draw
  itself on the screen

71
LineUp Applet
72
The Lineup programs

• The LineUp applet, shown in the previous slide
  shows 4 stick figures of different heights and
  colors.
• It uses a StickFigure class that represents a
  stick figure of a certain height, color, and
  location.
• The applet creates 4 StickFigure objects, of
  varying color and random height.
• The StickFigure objects are instantiated in the
  init method of the applet, so they are created
  once when the applet is loaded.
• The paint method of LineUp simply requests that
  the stick figures draw themselves.

73
StickFigure - 1
import java.awt. public class StickFigure
private int baseX private int baseY private
Color color private int height public
StickFigure(int center, int bottom, Color
shade, int size) baseX center baseY
bottom color shade height size
74
StickFigure - 2
public void draw(Graphics page) int top
baseY height page.setColor(color)
//head page.drawOval(baseX-10,top,20,20)
//trunk page.drawLine(baseX,top20,baseX,bas
eY-30) page.drawLine(baseX,baseY-30,baseX-15,
baseY) //legs page.drawLine(baseX,baseY-3
0,baseX15,baseY) //arms
page.drawLine(baseX,baseY-70,baseX-25,baseY-70)
page.drawLine(baseX,baseY-70,baseX20,baseY-85)

75
LineUp - code

• import java.applet.Applet
• import java.awt.
• public class LineUp extends Applet
• private final int APPLET_WIDTH 400
• private final int APPLET_HEIGHT 150
• private final int HEIGHT_MIN 100
• private final int VARIANCE 30
• private StickFigure figure1, figure2,
• figure3, figure4

76
LineUp - code
public void init () int h1, h2, h3, h4
// heights of figures h1
(int)(Math.random() VARIANCE) HEIGHT_MIN
h2 (int)(Math.random() VARIANCE)
HEIGHT_MIN h3 (int)(Math.random()
VARIANCE) HEIGHT_MIN h4
(int)(Math.random() VARIANCE) HEIGHT_MIN
figure1 new StickFigure(100,150,Color.red,h1)
figure2 new StickFigure(150,150,Color.cyan,h
2) figure3 new StickFigure(200,150,Color.gr
een,h3) figure4 new StickFigure(250,150,Col
or.yellow,h4) setBackground(Color.black)
setSize(APPLET_WIDTH, APPLET_HEIGHT)
77
LineUp - code

• public void paint (Graphics page)
• figure1.draw(page)
• figure2.draw(page)
• figure3.draw(page)
• figure4.draw(page)

78
Lesson 4 Classes Objects

• Unit D7 - Static and Auxiliary Methods

79
The Static Modifier

• The static modifier can be applied to variables
  or methods
• It associates a variable or method with the class
  rather than an object
• Methods that are declared as static do not act
  upon any particular object. They just encapsulate
  a given task, a given algorithm.
• We can write a class that is a collection of
  static methods. Such a class isnt meant to
  define new type of objects. It is just used as a
  library for utilities that are related in some
  way.

80
Example - a Math Class
/ A library of mathematical methods.
/ public class Math / Computes the
trigonometric sine of an angle. / public
static double sin(double x) /
Computes the logarithm of a given number. /
public static double log(double x) // ...
81
Static Variables

• A variable that is declared static is associated
  with the class itself and not with an instance of
  it.
• Static variables are also called class variables.
• We use static variables to store information that
  is not associated with a given object, but is
  relevant to the class.
• We have already seen such usage - constants of a
  class (final static)

82
Static Variables - Example
public class BankAccount private long
accountNumber private double balance
private static int numberOfAccounts 0
public BankAccount() this.accountNumber
numberOfAccounts this.balance 0
public static int getNumberOfAccounts
return numberOfAccounts
83
Static Methods and Instance Variables

• Static methods
• cannot reference instance variables (e.g. -
  access instance variable when an object doesnt
  exist)
• can reference static variables or local variables
  (within the method)
• this has no meaning inside a static method, thus
  its use inside a static method is not allowed.
• Instance methods can access static variables.

84
Division Into Methods

• Complicated tasks or tasks that occur often
  within a class should be wrapped in a method
• If you can clearly define the task, you should
  probably make it a method.
• This results in a readable and manageable code
• This is very helpful when implementing
  algorithms, or when we need helper methods in
  classes.

85
Division into methods interest calculation
public class BankAccount final static int
DAYS_IN_YEAR 365 public void
earnDailyInterest(int days) double rate 1
interestRate()/DAYS_IN_YEAR for(int j0
jltdays j) balance rate
private double interestRate() return
(balancegt100000) ? 0.06 0.05
86
Division into Methods Printing primes
public class PrintPrimes public static void
main(String args) for(j 2 j lt 1000
j) if (isPrime(j))
System.out.println(j) private static
boolean isPrime(int n) for(int j2 j lt n
j) if (nj 0) return
false return true
87
Lesson 4 Classes Objects