1. Lesson C – 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 < 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 C – 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 object’s 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
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; }
// …
hours:
Minutes:
Seconds: 10 45

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 there’s a big difference:
the main method was static, which means it wasn’t 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 < 59) seconds++;
else {
seconds=0;
if (minutes < 59) minutes++ ;
minutes = 0;
hours = hours < 12 ? hours+1 : 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.getHours()); // 12
System.out.println(seiko.getHours()); // 12
swatch.secondElapsed();
System.out.println(swatch.getHours()); // 1 }

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 >= 0) && (s < 60) &&
(m >= 0) && (m < 60) &&
(h > 0) && (h <= 12)) {
hours = h;
minutes = m;
seconds = s; }
// no effect if input is illegal

24. Lesson C – 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 >= 0) && (seconds < 60) &&
(minutes >= 0) && (minutes < 60) &&
(hours > 0) && (hours <= 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(myClock); // 12:0:0

31. Example: A Bank Account Object
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( );
BankAccount bobAcc = new BankAccount( );
aliceAcc.deposit(900);
aliceAcc.transfer(700,bobAcc);
// Alice’s balance = 200 ; Bob’s 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 C – 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 object’s 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( );
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 other’s “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)
balance -= amount;
targetAccount.balance += amount;

46. Lesson C – 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: 1:00: :59:59. */
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 12:00:00 */
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 doesn’t 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 followed with a tag
Documentation comments text can include HTML tags.

57. @param tag /** * Changes the current time to hour:minute:second
hours The new hour value.
minutes The new minutes value.
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. @return /** * Returns the current hour
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: 01:00: :59:59. */
public class Clock {
private static final int SECONDS_IN_12H = 12*60*60;
private int secondsFromZero;
* Constructs a Clock: Sets the clock to the
* specified time.
public Clock(int hours, int minutes, int seconds){
secondsFromZero = ((hours%12) * 3600
+ minutes * 60 + seconds); }

64. Example of new Clock implementation - page 2
/**
* Constructs a Clock: Sets the clock to 12:00:00 */
public Clock(){
secondsFromZero=0; }
* Advances this clock by 1 second.
public void secondElapsed() {
secondsFromZero = (secondsFromZero+1) %
SECONDS_IN_12H;
//…

65. Example of new Clock implementation - page 3
/**
* Returns the current hour
The current hour (between 1 and 12). */
public void getHour() {
int h = secondsFromZero/3600;
return h > 0 ? h : 12 ; }
// all the others can be written in the same way

66. Lesson C – Classes & Objects
Unit D6 – Contract based design

67. The API is a contract
If the user upholds all the requirements of the API then the object will do as promised.
“user” = the programmer of a class that uses our class
If!!
Usually the requirements from the user are certain restrictions on the parameters or on the timing of calls: pre-conditions.
Usually the requirements from the current class are properties of the values returned or of state that the object is left in – post-conditions.

68. Clock preconditions public class Clock { // … /**
* Constructs a Clock initialized to the
* specified time.
* Preconditions: 0 < hours <= 12
* <= seconds, minutes < 60 */
public Clock(int hours, int minutes, int seconds){ }

69. Bank Account - preconditions
public class BankAccount {
public double getBalance() {
// … }
/**
* Withdraws the amount from this account.
* Precondition: amount <= getBalance() */
public void withdraw(double amount) {
balance -= amount;

70. What to do if the pre-conditions are not met?
Contract-based Design
It’s not my problem
It’s a logical error of the user code
Anyway, I can’t recover from that error
“Never test your preconditions”
Defensive Programming
I should maintain integrity of my state
Helps catch bugs
Pre-condition validation is part of my responsibilities

71. Assertions State declaratively that something should be true
Documentation
Catch Logical errors
Failure means a logical error in the code
We can tell the compiler whether to really check assertions
Maybe turn off assertion checking after the program is fully tested.
/**
* Withdraws the amount from this account.
* Precondition: amount <= getBalance() */
public void withdraw(double amount) {
assert amount < balance : “Over draft error”;
balance -= amount; }

72. Verifying post-conditions
public void secondElapsed() {
if (seconds < 59) seconds++;
else {
seconds=0;
if (minutes < 59) minutes++ ;
minutes = 0;
hours = hours < 12 ? hours+1 : 1; }
assert hours>0 && hours<=12 && minutes>=0 &&
minutes<60 && seconds>=0 && seconds<60;

73. Other uses of assertions -- Invariants
Invariants: Conditions that must always hold at certain points
Loop invariants
Class invariants
The conditions 0<hour<=12 must always hold after any Clock method terminates
// compute x/y :
z=x; r=0;
While (z>y) {
assert r*x+z==y;
z = z-y;
r++; }

74. What assertions are not
Not a replacement for “If”
Asserted conditions must always be true
Not a way to handle exceptions
Not a way to check user input
Programmer must deal with problems
Scanner s = new Scanner(System.in);
System.out.println(“Enter grade:”);
int g = s.nextInt();
assert g >= 0; // NO!
If (g < 0) {
System.out.println(“Treating negative number as 0”);
g=0; }
//...

75. Preconditions in Java
For historical reasons the convention in Java is not to use assertions for pre-condition checked, but rather the “exception mechanism”.
Allows the caller to recover
/**
* Withdraws the amount from this account.
* Precondition: amount <= getBalance() */
public void withdraw(double amount) {
if (amount > balance )
throw new IllegalArgumentException();
balance -= amount; }

76. Lesson C – Classes & Objects
Unit D7 - Static and Auxiliary Methods

77. 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 isn’t meant to define new type of objects. It is just used as a library for utilities that are related in some way.

78. 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) { … }
// ...

79. 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)

80. 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;

81. Static Methods and Instance Variables
cannot reference instance variables (e.g. - access instance variable when an object doesn’t 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.

82. 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.

83. 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 j=0 ; j<days ; j++)
balance *= rate; }
private double interestRate() {
return (balance>100000) ? 0.06 : 0.05;

84. Division into Methods – Printing primes
public class PrintPrimes {
public static void main(String[] args) {
for(j = 2 ; j < 1000 ; j++){
if (isPrime(j))
System.out.println(j); }
private static boolean isPrime(int n){
for(int j=2 ; j < n ; j++)
if (n%j == 0)
return false;
return true;

85. Lesson C – Classes & Objects
Unit D8 – Unit tests

86. Software Testing Software never just works perfectly.
There are always many logical bugs in implementation and in specification.
The earlier you catch a bug, the easier it is to fix.
Software testing is the process of validating and verifying that a software program/application/product meets the requirements that guided its design and development and works as expected.
Testing is an Art and Science and Engineering
Lowest level of testing is “Unit testing”: testing a single basic unit of software – a class.

87. Unit tests
For each class you write, there should be a test class to test it.
In most cases the programmer who wrote the class also writes the unit test for it. Others can add tests.
An extreme philosophy is to write the unit test before you write the implementation of the class.
You can iterate: add tests + add functionality to class
Testing environments can run tests automatically after every change.
Buzz words: agile programming, extreme programming

88. TestClock Class TestClock { public static void main(String[] args) {
testConstruction();
testSecondElapsed();
// … }
public static void testConstruction() {
Clock c = new Clock(7, 23, 45);
int h = c.getHours();
if ( h != 7)
System.out.println(“Basic test failed:” +
“getHours() returned “ + h + “ instead of 7”)
// also for minutes, seconds

89. TestClock (2) public static void testSecondElapsed() {
Clock c = new Clock(7, 59, 58);
int h, m ,s;
c.secondElapsed();
h=c.getHour(); m=c.getMinute(); s=c.setSecond();
if ( h != 7 || m != 59 || s != 59)
System.out.println(“SecElapsed test fail (1):”
+ “returned “ + h + “:” + m + “:” + s);
if ( h != 8 || m != 0 || s != 0)
System.out.println(“SecElapsed test fail (2):”
// …

90. TestClock (3) for (int i=0 ; i< 5*60*60 ; i++) c.secondElapsed();
if ( h != 1 || m != 0 || s != 0)
System.out.println(“SecElapsed test fail (3):”
+ “returned “ + h + “:” + m + “:” + s);
// … }

91. What to test? Tests are open ended – you can never test everything
In principle:
Test every method
Test anything that you think is tricky
Test anything where you encountered a bug
The more the merrier
Tests should remain simple
Conceptually
Not require too many resources

92. Testing Frameworks -- JUnit
public class ClockTest extends TestCase {
Clock c;
public void setUp() {
c = new Clock(1,2,3); }
public void testConstruction()
int h = c.getHours();
assertEquals(“Error in hours after Construction”, 1, h);

93. Lesson C – Classes & Objects