Lecture 16 Lecture 17 Lecture 18

Lecture 16
Selections(If-else and Booleans)

COMP101: Introduction to Programming in JAVA

Morelli chapter 3, Cohoon and Davidson Chapter 5

Clare Dixon Selections(If-else and Booleans) 1 / 84

Lecture 16 Lecture 17 Lecture 18

Overview

We look further at if-else statements.

First we consider Boolean expressions and take another look
at the Boolean primitive data type and its operations.
We analyse, design and implement a program to test for
leap years.
We show how we can use if-else statements to do simple
checking of input.
We highlight some of the pitfalls when using if-else
statements.
We show how to swap the values of two variables given
some condition.

Clare Dixon Selections(If-else and Booleans) 2 / 84

Lecture 16 Lecture 17 Lecture 18

Primitive Data Type: Booleans

Type Booleans
Range values false and true.

Keyword boolean

Operators Relational operators (giving a boolean result): <, >,

==, !=, <=, >=.
Boolean operators (composing boolean values): !,
&&, ||.

Clare Dixon Selections(If-else and Booleans) 3 / 84

Lecture 16 Lecture 17 Lecture 18

Boolean Expressions

We looked at relational operators last lecture.

One can do calculations with booleans exactly in the same way as
one can do calculations with numbers.

-12 34214 + 51 2367*(-85131)

!false false || true true && (!false)

! isthe logical negation, && is the logical conjunction and || the

logical disjunction.

!(4 < a) (a <= 12) || (a % 2 == 0) (0 <= a) && (a <= 9)

Clare Dixon Selections(If-else and Booleans) 4 / 84

Lecture 16 Lecture 17 Lecture 18

Boolean Operator Tables

A B !A A && B A || B
true true false true true
true false false false true
false true true false true
false false true false false

Boolean expressions can be used in the conditions of a

selection statement (and in loops).
What is the value of the following for a=3 or a=20?

!(4 < a) (a <= 12) || (a % 2 == 0) (0 <= a) && (a <= 9)

Clare Dixon Selections(If-else and Booleans) 5 / 84

Lecture 16 Lecture 17 Lecture 18

Identification of Leap Years

Problem
Write a program which allows the input of a 4-digit year, checks
that the input is in the correct range, checks whether it is a leap
year, and outputs this information.

You should check that the input date is a positive integer or

zero not greater than 9999.

Clare Dixon Selections(If-else and Booleans) 7 / 84

Lecture 16 Lecture 17 Lecture 18

Analysis
Write a program which allows the input an
4-digit year , checks that the input is in the
correct range , checks whether it is a leap year , and
outputs this.

It isn’t clear whether we just need one class or two.

Lets follow what we have done recently and have two
classes LeapYear and LeapYearUser.
We will store the year as an attribute of LeapYear.
also needs a method to calculate whether the year is
LeapYear
leap or not.
We may also need a method to get the value of the
attribute year.
Clare Dixon Selections(If-else and Booleans) 8 / 84
Lecture 16 Lecture 17 Lecture 18

Class Diagram

LeapYear
LeapYearUser
✲
- year: integer
+isLeapYear(): boolean
+ main(String[])
+getYear(): integer

Clare Dixon Selections(If-else and Booleans) 9 / 84

Lecture 16 Lecture 17 Lecture 18

Algorithm Design
The main method has the usual task of setting up all relevant
variables, then calling the isLeapYear method and finally
displaying the result of the computation. Note we can check the
input data is not negative using an if-else statement.

METHOD main
INPUT args
OUTPUT
LOCAL DATA someYear, MIN_YEAR = 0, MAX_YEAR=9999
READ someYear from the keyboard
IF someYear >= MIN_YEAR AND someYear <= MAX_YEAR
SET up an instance myLeapYear of LeapYear using someYear
as the year of the structure
PRINT a message with the result of
calculating the whether someYear is a Leap Year. ELSE
PRINT a message saying invalid year

Clare Dixon Selections(If-else and Booleans) 10 / 84

Lecture 16 Lecture 17 Lecture 18

Operations
How can we check if a year is a leap year?

There exists a simple formula that does the job.

if the year is exactly divisible by 4 and

the year is not a century
or the year is a century that is divisible by 400
then the year is a leap year
otherwise the year is not a leap year.

÷4 ÷100 ÷400 Eg Leap

T T T 1600 YES
T T F 1700 NO
T F F 1704 YES
F F F 1705 NO

Clare Dixon Selections(If-else and Booleans) 11 / 84

Lecture 16 Lecture 17 Lecture 18

The method isLeapYear

The pseudocode for isLeapYear can be easily derived from this

description:
METHO isLeapYear
D none (it uses LeapYear attribute year)
INPUT boolean
OUTPU year is divisible by 4 AND
T it is not divisible by 100 OR
IF the year is divisible by both 100 AN 400
RETUR true D
ELSEN
RETUR false
N

Clare Dixon Selections(If-else and Booleans) 13 / 84

Lecture 16 Lecture 17 Lecture 18

Implementation:LeapYear
/**
* LeapYear.java, Based on code by Michele Zito
* Edited by Clare Dixon June 2010
**/
public class LeapYear {
// attributes
private int year;
// constructors
public LeapYear(int y) {
year = y;
}
// methods
public boolean isLeapYear() {
if (((year% 4 == 0) && (year % 100 != 0)) || ((year %
100 == 0) && (year % 400 == 0))) return true;
else
return false;
}
public int getYear() {
return year;
}

} Clare Dixon Selections(If-else and Booleans) 14 / 84

Lecture 16 Lecture 17 Lecture 18

Implementation:LeapYearUser
/** LeapYearUser.java
* July 2010 Clare Dixon **/
import java.util.Scanner;

public class LeapYearUser {

public static void main(String [] args) { Scanner input =
new Scanner(System.in); int myYear;
final int MIN_YEAR = 0;
final int MAX_YEAR = 9999;

System.out.print("What’s the year? ");

myYear = input.nextInt();
if ((myYear >= MIN_YEAR) && (myYear <= MAX_YEAR)) { LeapYear
someLeapYear = new LeapYear(myYear); System.out.print("The year " +
someLeapYear.getYear());
if (someLeapYear.isLeapYear())
System.out.println(" is a leap year.");
else
System.out.println(" is not a leap year.");
}
else
System.out.println(" Not a valid year.");
} Clare Dixon Selections(If-else and Booleans) 15 / 84
Lecture 16 Lecture 17 Lecture 18

Testing: Path Testing

Path Testing: LeapYearUser We should take a positive, negative
and zero integer as well as values 9999 and a value greater
than 9999 to test paths in the outer if statement of LeapYearUser.
Test Case Expected Result
Input Year
-10 Wrong type of input
-1 Wrong type of input
0 Is Leap Year
10 Is not a Leap Year Is
9999 not a Leap Year
10000 Wrong type of input

Path Testing: isLeapYear()

Test Case Expected Result Reason

Input Year
1600 Is Leap Year Divisible by 400
1700 Is not Leap Year Divisible by 100 but not by 400
1704 Is Leap Year Divisible by 4 but not by 100 or 400
1705 Is not Leap Year Not divisible by 4, 100 or 400

Clare Dixon Selections(If-else and Booleans) 16 / 84

Lecture 16 Lecture 17 Lecture 18

Output

$ java LeapYearUser
What’s the year? -10
Not a valid year.

$ java LeapYearUser
What’s the year? -1
Not a valid year.

$ java LeapYearUser
What’s the year? 0
The year 0 is a leap year.

$ java LeapYearUser
What’s the year? 10
The year 10 is not a leap year.

$ java LeapYearUser
What’s the year? 9999
The year 9999 is not a leap year.

Clare Dixon Selections(If-else and Booleans) 17 / 84

Lecture 16 Lecture 17 Lecture 18

Output

$ java LeapYearUser
What’s the year? 10000
Not a valid year.

$ java LeapYearUser
What’s the year? 1600
The year 1600 is a leap year.

$ java LeapYearUser
What’s the year? 1700
The year 1700 is not a leap year.

$ java LeapYearUser
What’s the year? 1704
The year 1704 is a leap year.

$ java LeapYearUser
What’s the year? 1705
The year 1705 is not a leap year.

Clare Dixon Selections(If-else and Booleans) 18 / 84

Lecture 16 Lecture 17 Lecture 18

Meaning of if-else Statements

What will the following code snippet do?

if (myValue > 0)
if (myValue % 2 == 0)
System.out.println("The number is positive and even");
else
System.out.println(" Not positive.");

Clare Dixon Selections(If-else and Booleans) 19 / 84

Lecture 16 Lecture 17 Lecture 18

Swapping Two Values

A common task in programming is to swap the values of two

variables if the second is smaller that the first.
IF b < a
swap the values of a and b

The following is incorrect (for example take a = 13 and b = 10).

Why?
if (b < a) {
b = a;
a = b;
}

Clare Dixon Selections(If-else and Booleans) 22 / 84

Lecture 16 Lecture 17 Lecture 18

Swapping Two Values

We must introduce a temporary variable to store the value of b.
Again take a = 13 and b = 10.
if (b < a) {
int tmp = b;
b = a;
a = tmp;
}
13 10
a b original values for a and b

(int) (int)

a b tmp tmp = b;
13 10 10
b is evaluated and its value assigned to tmp
(int) (int) (int)

b = a;
a 13 b 13 tmp 10
a is evaluated and its value assigned to b
(int) (int) (int)

a = tmp;
a 10 b 13 tmp 10
tmp is evaluated and its value assigned to a
(int) (int) (int)

Clare Dixon Selections(If-else and Booleans) 24 / 84

Lecture 16 Lecture 17 Lecture 18

Summary

First we looked at the Boolean primitive data type, its

operations and Boolean expressions.
We showed how to detect leap years using if-else
statements.
We showed how to do simple checking of input using
if-else statements.
We looked at how to swap the values of two variables
given some condition.

Clare Dixon Selections(If-else and Booleans) 25 / 84

Lecture 16 Lecture 17 Lecture 18

Lecture 17
Selections: Switch

COMP101: Introduction to Programming in JAVA

Morelli chapter 6, Cohoon and Davidson Chapter 5

Clare Dixon Selections: Switch 26 / 84

Lecture 16 Lecture 17 Lecture 18

Overview

In this lecture we consider the Java switch statement.

This is another type of selection statement.
After giving the details of this we add to the class
considering leap years we looked at last lecture to a date
validation class.

Clare Dixon Selections: Switch 27 / 84

Lecture 16 Lecture 17 Lecture 18

Switch
If a selection is based on the values of some expression, that
can be compared (easily/correctly) then a switch statement
may be used instead of a nested if-else.

General format of a switch statement.

switch ( expression ) {
case constant-expression :
statements
break;
case constant-expression :
statements
break;
...
default :
statements
}

Clare Dixon Selections: Switch 28 / 84

Lecture 16 Lecture 17 Lecture 18

What Type of Expression Can Be Used?

switch ( expression ) {
case constant-expression :
statements
break;
...
}
What type of expression can be used in Switch statements?
char, byte, short, int (and their wrapper classes that can be
used to convert primitive types into objects) but not long;
enumerated types (a type with an explicit list of values
available from Java 5) can be used;
Strings can also be used (from Java 7).
Note that real numbers i.e., float or double cannot be used
because of their accuracy eg when compared.
Booleans only have two cases anyway so an if-statement can be
used instead.
Clare Dixon Selections: Switch 29 / 84
Lecture 16 Lecture 17 Lecture 18

Semantics of Switch Statements

The default clause is optional as are the break statements but

removing the break statement may have undesired
consequences.
1 The expression is evaluated.
2 Control passes to the statements following the case label whose
value equals the expression, or, if no cases apply, to the default
case.
3 Beginning at the selected label or at the default, all of the
statements up to the first of either a break statement or the end
of the switch are executed.
If the break statements are missing, the switch will execute all
the statements following the label that matches the expression.

Clare Dixon Selections: Switch 30 / 84

Lecture 16 Lecture 17 Lecture 18

Switch Example

int number = input.nextInt();

// Process number using a case statement

switch (number) {
case 0:
System.out.println("Number is 0");
break;
case 1:
System.out.println("Number is 1");
break;
case 2: case 3: case 4:
System.out.println("Number is 2, 3 or 4");
break;
default:
System.out.println("Number is less than 0" +
" or greater than 4");
}

What happens if number is 1 or 7? What happens if we remove

the break statements and allow the same input?
Clare Dixon Selections: Switch 31 / 84
Lecture 16 Lecture 17 Lecture 18

Switch Example: Remarks

switch (number) {
case 0:
System.out.println("Number is 0");
break;
case 1:
System.out.println("Number is 1");
break;
case 2: case 3: case 4:
System.out.println("Number is 2, 3 or 4");
break;
default:
System.out.println("Number is less than 0" +
" or greater than 4");
}

Note how several cases can be grouped together

case 2: case 3: case 4:.

The default can be put anywhere in the switch statement. Here if it is

put earlier it would need an accompanying break statement to have
the same meaning.
Clare Dixon Selections: Switch 33 / 84
Lecture 16 Lecture 17 Lecture 18

Case Study: Validation of Dates including Leap Years

Problem
We want to write a program that validates a date. The format of
the date DDMMYYYY is a single integer representing day,
month, and year. The single integer is split into individual
integers representing DD, MM, and YYYY. The program checks
that the number of months in a year should not exceed 12, and
that the number of days in each month has not been exceeded. The
program also reports on leap years.

Clare Dixon Selections: Switch 34 / 84

Lecture 16 Lecture 17 Lecture 18

Class Analysis

Problem. We want to write a program that validates a date .

The format of the date DDMMYYYY is a single integer
representing day , month , and year . The single integer is
split into individual integers representing DD, MM, and YYYY.
The program checks that the number of months in a year
should not exceed 12, and that the number of days in each
month has not been exceeded. The program also reports on
leap years.

Note the largest integer is 2,147,483,647 which is bigger than

the 8 digits we require for input.

Clare Dixon Selections: Switch 35 / 84

Lecture 16 Lecture 17 Lecture 18

Class Analysis

We start assuming that DateUser (corresponding to the

word program) and Date are classes.
month(an integer between 1 and 12), day (an integer in an
appropriate range depending on the value of month and on
whether year is a leap year), and year (from 0 to 9999) would
then be attributes of Date.
We recognise three operations in the system: the setting up of
the Date’s attributes, the validation of the date (the class
constructor should probably have responsibility for these), and
the checking for leap years (which we have already done)
again Date should have responsibility for that.

Clare Dixon Selections: Switch 36 / 84

Lecture 16 Lecture 17 Lecture 18

Class Diagram

Date
- day: int
DateUser - month: int
✲ - year: int
+ main(String[]) -validateDate():
+isValid(): boolean
+isLeapYear(): boolean

Clare Dixon Selections: Switch 37 / 84

Lecture 16 Lecture 17 Lecture 18

Algorithm Design
What tasks need to be done?
Splitting the DDMMYYYY into parts relating to the day,
month, year.
Checking whether the year is a leap year.
Checking the month value is between 1 and 12.
Checking that the number of days is not greater than that
allowed for that month.
It is often useful to think of test cases at the design stage.
Are the following are valid dates? Why?
-03112011 0 13132012
03112011 32112011 28022011
29022011 28022012 29022012

Clare Dixon Selections: Switch 38 / 84

Lecture 16 Lecture 17 Lecture 18

Splitting the DDMMYYYY into parts

We can use use a combination of / (integer division) and %
(remainder) to obtain the days, months and years separately.
Consider an input date rawDate
1 Divide rawDate by 1,000,000 (using ”integer division”) to
obtain the day.
2 Divide the remainder of rawDate/1,000,000 by 10,000 to
obtain the month.
3 Calculate the remainder of rawDate/10,000 to obtain the
year.
Example, given rawDate=24,092,010 (24-09-2010):
day = 24, 092, 010/1, 000, 000 = 24
month = (24, 092, 010 % 1, 000, 000)/10, 000 =
92, 010/10, 000 = 9
year = 24, 092, 010 % 10, 000 = 2010

Clare Dixon Selections: Switch 39 / 84

Lecture 16 Lecture 17 Lecture 18

Setting up Date’s Attributes

METHOD Date (Constructor)

INPUT rawDate (an integer)
OUTPUT
SET day to rawDate divided by 1,000,000
SET month to the result of dividing by 10,000
the remainder of rawDate divided by 1,000,000
SET year to the remainder of rawDate divided by 10,000
CALL validateDate

Clare Dixon Selections: Switch 40 / 84

Lecture 16 Lecture 17 Lecture 18

Implementation of Date

/**
* Date - validates dates of the form DDMMYYYY
* Michele Zito
* Edited by Clare Dixon September 2010
**/
public class Date {
// attributes private int
day; private int month;
private int year;

// constructor
public Date(int rawDate) {
// split rowDate into month, day, and year
day = rawDate / 1000000;
month = (rawDate % 1000000) / 10000;
year = rawDate % 10000;
validateDate();
}
.........

Clare Dixon Selections: Switch 41 / 84

Lecture 16 Lecture 17 Lecture 18

Date validation

The validation of the date has a three-part solution.

The first part is to validate a month as an integer in the range
{1, 2, . . . , 12}. If the month is treated as the value of a switch
expression, with case labels occurring for each of the twelve
months, then should a month not be in the range 1 to 12, the
error can be trapped as the default value.
The second part involves the checking for leap years, which
can be done calling the isLeapYear method.
The third part of the solution involves the calculation of the
number of days in a month (this depends on the value of months, and
whether year is a leap year or not).

Clare Dixon Selections: Switch 42 / 84

Lecture 16 Lecture 17 Lecture 18

Pseudocode for validateDate()

METHOD validateDate
INPUT
OUTPUT
LOCAL numberOfDays OF
DATA 7, 8, 10, or 12:
CASE month
1, numberOfDays
3, 5, is 31
4, 6, 9, or 11:
numberOfDays is 30
2:
IF it is a leap year
numberOfDays is 29
ELSE
numberOfDays is 28
OTHERS:
set day, month, year to error values
check day against numberOfDays

Clare Dixon Selections: Switch 43 / 84

Lecture 16 Lecture 17 Lecture 18

Implementation of Date

private void validateDate() {

int numberOfDays = 0;
// sets numberOfDays depending on month and
// whether it’s a leap year
switch (month) {
case 1 : case 3 : case 5 : case 7 : case 8 : case 10 : case 12
numberOfDays = 31;
break;
case 4 : case 6 : case 9 : case 11 :
numberOfDays = 30;
break;
case 2 :
if (isLeapYear())
numberOfDays = 29;
else
numberOfDays = 28;
break;

Clare Dixon Selections: Switch 44 / 84

Lecture 16 Lecture 17 Lecture 18

Implementation of Date (cont)

default :
day = 0;
month = 0;
year = -1;
break;
}

// check day against numberOfDays

if (day> numberOfDays) {
day = 0;
month = 0;
year = -1;
}
}

Unfortunately validateDate() has a bug in it. Can you spot it?

Clare Dixon Selections: Switch 45 / 84

Lecture 16 Lecture 17 Lecture 18

Constructors

We can now build clever constructors.

Constructors don’t have to just take some parameters and

assign them to the attributes.

We can check the validity of our data (not just date!) For
instance with a simple if statement we can discard values
outside a certain range.

Our programs become more robust.

Clare Dixon Selections: Switch 46 / 84

Lecture 16 Lecture 17 Lecture 18

Implementation of isValid and isLeapYear

The design and implementation for isLeapYear is exactly the

same as previously.
In the constructor if we have an invalid date we have assigned
year to be -1 so to implement isValid all we need to do is check for
this.

public boolean isValid() {

return (year != -1);
}

Clare Dixon Selections: Switch 47 / 84

Lecture 16 Lecture 17 Lecture 18

DateUser
/*
* DateUser by Michele Zito
* Edited by Clare Dixon Sep 2010
*/
import java.util.Scanner;

public class DateUser {

public static void main(String [] args) {

Date date;
Scanner input = new Scanner(System.in); System.out.print("Input a date in the
format DDMMYYYY ");
date = new Date(input.nextInt());
if (date.isValid()) {
System.out.print("It is a valid date and the year is");
if (!date.isLeapYear())
System.out.print("n’t");
System.out.println(" a leap year");
}
else
System.out.println("Invalid date!");
}
} Clare Dixon Selections: Switch 48 / 84
Lecture 16 Lecture 17 Lecture 18

Testing

We have only one input.

Arithmetic Testing eg -10121970, 0, 10121970
Path Testing: there are 13 cases (including the default) to
test each which may have either the correct or incorrect
number of days.
We should also test cases with inputs that aren’t 8 digits.
The isLeapYear method should also be tested (but we have
already done that).

Clare Dixon Selections: Switch 49 / 84

Lecture 16 Lecture 17 Lecture 18

Testing

Test Case Expected Result

Input Integer
-10121970 invalid date -
0 invalid date -
10121970 valid date not leap
32012011 invalid date -
31012011 valid date not leap
29022011 invalid date -
28022011 valid date not leap
29022012 valid date leap
30022012 invalid date -
... . . . invalid ...
123456789 date invalid -
date -
3

Clare Dixon Selections: Switch 50 / 84

Lecture 16 Lecture 17 Lecture 18

Output
$ java DateUser
Input a date in the format DDMMYYYY -
Invalid date! 10121970
$ java DateUser
Input a date in the format DDMMYYYY
Invalid date! 0
$ java DateUser
Input a date in the format DDMMYYYY 10121970
It is a valid date and the year isn’t a leap year
$ java DateUser
Input a date in the format DDMMYYYY
Invalid date! 32012011
$ java DateUser
Input a date in the format DDMMYYYY 31012011
It is a valid date and the year isn’t a leap year
$ java DateUser
Input a date in the format
DDMMYYYY
Invalid date! 29022011
$ java DateUser
Input a date in the format
DDMMYYYY 28022011
It is a valid date and the
year isn’t a leap year
$ java DateUser
Input a date in the format DDMMY
Clare Dixon YYY 29022012
Selections: Switch 51 / 84
Lecture 16 Lecture 17 Lecture 18

Summary

In this lecture we looked at the syntax and semantics of the

Java switch statement.
Experiment with switch statements with and without using
break.

Next we designed and implemented a date validation class.

We used a more complex constructor than we have
previously to break the input down into the three
components (day, month, year) and also to validate the
date.

Clare Dixon Selections: Switch 54 / 84

Lecture 16 Lecture 17 Lecture 18

Lecture 18
Aggregation

COMP101: Introduction to Programming in JAVA

Clare Dixon Aggregation 55 / 84

Lecture 16 Lecture 17 Lecture 18

Overview

So far we have considered simple object associations eg

where one object sends a message to another (using Java
methods), or one object creates another object.
In this lecture we will look at another type of association
also known as an aggregation.
This models the has-a relationship where one object of
class has attributes whose values are objects of another
class.
We will also introduce the this keyword.

Clare Dixon Aggregation 56 / 84

Lecture 16 Lecture 17 Lecture 18

“Has–a” Relationships

Aggregation is a strong form of association in which an

aggregate class is made of components. These are part of the
aggregate.

Aggregation IS NOT inheritance! A car has four wheels, but a

wheel is not a special type of car! Examples are as follows.
An aeroplane is made up of a fuselage, wings, engines,
landing gear, flaps, and so on.
A delivery contains one or more packages.
A lecture group consists of a number of students.
A student record consists of the student name, address and
ID.

Clare Dixon Aggregation 57 / 84

Lecture 16 Lecture 17 Lecture 18

Examples of Aggregation We’ve Already Seen

System
PrintStream + out: PrintStream InputStream
✛ + in: InputStream ✲
....

For dealing with output we have seen that out (a “screen

object”) is an instance of a class called PrintStream which is an
attribute of the class System.
For dealing with input we call Scanner with a parameter
System.in. “in” is an instance of the class InputStream which is an
attribute of the class System.
A class with a String attribute eg private String firstName; is another
example of an attribute which has values that are from
another class.
Clare Dixon Aggregation 58 / 84
Lecture 16 Lecture 17 Lecture 18

Example

Consider a class that represents information about a student,

including their name and address, studentID etc.

Name has two parts: first name and last name.

Address has a city, postcode and country.

To make the design more modular and to allow us to re-use

name and address in different classes we implement these as three
classes Student, Name and Address.

The class Student has attributes which are objects of Name and
Address.

Clare Dixon Aggregation 59 / 84

Lecture 16 Lecture 17 Lecture 18

Class Diagram for Student

Student Address
Name
- name: Name - city: String
- firstName: String
✛ - address: Address ✲ - postcode: String
- lastName: String
- studentID: String - country: String

Note the associations with String have not been represented.

Clare Dixon Aggregation 60 / 84

Lecture 16 Lecture 17 Lecture 18

Outline Name Class

public class Name {

// attributes
private String firstName;
private String lastName;

// constructors
public Name(String first, String last) {
firstName = first;
lastName = last;
}

.....

Clare Dixon Aggregation 61 / 84

Lecture 16 Lecture 17 Lecture 18

Outline Address Class

public class Address {

// attributes
private String city; private String
postcode; private String country;

// constructors
public Address(String theCity, String thePostcode, String theCountry) {
city = theCity;
postcode = thePostcode;
country = theCountry;
}
....

Clare Dixon Aggregation 62 / 84

Lecture 16 Lecture 17 Lecture 18

Outline Student Class

public class Student {

// attributes private Name name;
private Address address;
private String studentID;

// constructors
public Student(String first, String last, String theCity, String thePostcode, String
theCountry,String studID) {
name = new Name(first, last);
address = new Address(theCity, thePostcode, theCountry);
studentID = studID;
}
......
}

Note that the constructor for Student calls the constructors for
Name and Address to instantiate the name andaddress attributes.

Clare Dixon Aggregation 63 / 84

Lecture 16 Lecture 17 Lecture 18

Example Problem: Cylinder Calculation

Problem
Produce a program that calculates the surface area and volume of a
cylinder given its radius and height. Assume that the radius and
height are input by the user as double precision floating point
numbers.

Surface Area of a cylinder

= (2 x AreaOfEnd) + (AreaOfSide)
radius
= (2 x π x radius 2 ) + (height x CircumferenceOfEnd)
= (2 x π x radius2 ) + (height x 2 x π x radius)
height
Volume of a cylinder
= AreaOfEnd x height
= (π x radius2 ) x height

Clare Dixon Aggregation 64 / 84

Lecture 16 Lecture 17 Lecture 18

Cylinder Class Analysis and Design (1)

We will create a Cylinder class and a CylinderUser class

which will create a cylinder.
It looks like we need attributes radius and height.

We need behaviours to calculate the surfaceArea and to

calculate volume using formulae on the last lines of the
previous page.

Cylinder
CylinderUser - radius: double
✲ - height: double
+ main(String[]) +volume(): double
+surfaceArea(): double

Clare Dixon Aggregation 65 / 84

Lecture 16 Lecture 17 Lecture 18

Cylinder Class Analysis and Design (2)

However we have previously developed a Circle class

which has radius as an attribute and calculates its area and
circumference.

Hence we will re-use this class and have attributes

cylinderEnd (a Circle) and height.
This has the advantages of:
re-use and modularity; divide
and conquer; maintenance and
debugging.

Clare Dixon Aggregation 66 / 84

Lecture 16 Lecture 17 Lecture 18

Cylinder

radius

height

Surface Area of a cylinder

= (2 x AreaOfEnd ) + (height x CircumferenceOfEnd )

Volume of a cylinder
= AreaOfEnd x height
Clare Dixon Aggregation 67 / 84
Lecture 16 Lecture 17 Lecture 18

Class Diagram (2)

Circle
- radius: double
+circumference(): double
+area(): double
✻

Cylinder
CylinderUser - cylinderEnd: Circle
✲ - height: double
+ main(String[]) +volume(): double
+surfaceArea(): double
Note that the interface to Cylinder doesn’t change so
application programs don’t need to know which version has
been implemented.
Clare Dixon Aggregation 68 / 84
Lecture 16 Lecture 17 Lecture 18

Algorithm Design
The main method has the usual task of setting up all relevant
variables, then calling the surfaceArea and volume methods
and finally displaying the result of the computation.
METHOD main
INPUT args
OUTPUT
LOCAL DATA myRadius, myHeight
READ myRadius and myHeight from the keyboard
IF both are non-negative values
SET up an instance myCylinder of Cylinder using
myHeight and an instance of Circle using myRadius
PRINT a message including the result of
calculating the surfaceArea and volume of myCylinder
ELSE
PRINT a message saying the input was negative
As the calculations for surfaceArea and volume are one line we
omit pseudocode for these.
Clare Dixon Aggregation 69 / 84
Lecture 16 Lecture 17 Lecture 18

Implementation: Cylinder

/**
* Cylinder.java - calculates the volume and surface area of a cylinder
* September 2010
* Clare Dixon
**/
public class Cylinder {
// attributes
private Circle cylinderEnd;
private double height;

// constructors
public Cylinder(double r, double h) { cylinderEnd
= new Circle(r); height = h;
}

Clare Dixon Aggregation 70 / 84

Lecture 16 Lecture 17 Lecture 18

Implementation: Cylinder

// methods
public double volume() {
//volume of a cylinder is a * height where
//a is the area of the circle
return cylinderEnd.area() height; *
}

public double surfaceArea() {

//surface areas is 2a + (height * c) where
//a is area of the circle
//and c is the circumference
return (2 cylinderEnd.area())
* +
(height cylinderEnd.circumference());
*
}
}

Clare Dixon Aggregation 71 / 84

Lecture 16 Lecture 17 Lecture 18

Implementation: CylinderUser

/**
* CylinderUser.java - gets input data radius and height and
* creates a Cylinder to calculate surface area and volume
* September 2010
* Clare Dixon
**/
import java.util.Scanner;

public class CylinderUser {

public static void main(String [] args) { Cylinder
myCylinder;
Scanner input = new Scanner(System.in);
double myRadius;
double myHeight;

Clare Dixon Aggregation 72 / 84

Lecture 16 Lecture 17 Lecture 18

Implementation: CylinderUser

System.out.print("What’s the radius of the end of the " +

"cylinder? ");
myRadius = input.nextDouble();
System.out.print("What’s the height of the cylinder? ");
myHeight = input.nextDouble();
if (myRadius >= 0 && myHeight >= 0) {
myCylinder = new Cylinder(myRadius,myHeight);
System.out.println("Surface Area = " +
myCylinder.surfaceArea());
System.out.println("Volume = " + myCylinder.volume());
}
else
System.out.println("Negative value input: exiting.");
}
}

How could we improve this?

Clare Dixon Aggregation 73 / 84

Lecture 16 Lecture 17 Lecture 18

Remarks

This design allows us to re-use the Circle class we have

already developed.
To calculate the volume and surface area we can call
methods circumference() and area() to help us.
Recall the interface of an object is its public methods and
variables eg here surfaceArea() and volume().
Even if we change how we implement Cylinder (eg using our
two different design choices) as the instance variables have
been declared private this is hidden and it doesn’t affect the
interface of Cylinder.

Clare Dixon Aggregation 75 / 84

Lecture 16 Lecture 17 Lecture 18

Testing

1 Arithmetic Testing Test using all possible combinations of

negative, positive and zero input values for the radius and
height.
2 Path Testing To test the two paths in the if statement. As this
just involves a check that both input values are greater than
or equal to zero this will have been already checked by the
Arithmetic Testing.

Clare Dixon Aggregation 76 / 84

Lecture 16 Lecture 17 Lecture 18

Testing

Test Case Expected Result

Radius Height Area Volume
0.0 0.0 0.0 0.0
0.0 10.0 0.0 0.0
0.0 -10.0 Negative input msg Negative input msg
2.5 0.0 39.2699 0.0
2.5 10.0 196.3495 196.3495
2.5 -10.0 Negative input msg Negative input msg
-2.5 0.0 Negative input msg Negative input msg
-2.5 10.0 Negative input msg Negative input msg
-2.5 -10.0 Negative input msg Negative input msg

Clare Dixon Aggregation 77 / 84

Lecture 16 Lecture 17 Lecture 18

Testing Output
$ java CylinderUser
What’s the radius of the end of the cylinder? 0.0
What’s the height of the cylinder? 0.0
Surface Area = 0.0
Volume = 0.0

$ java CylinderUser
What’s the radius of the end of the cylinder? 0.0
What’s the height of the cylinder? 10.0
Surface Area = 0.0
Volume = 0.0

$ java CylinderUser
What’s the radius of the end of the cylinder? 0.0
What’s the height of the cylinder? -10.0
Negative value input: exiting.

$ java CylinderUser
What’s the radius of the end of the cylinder? 2.5
What’s the height of the cylinder? 0.0
Surface Area = 39.269908169872416
Volume = 0.0
Clare Dixon Aggregation 78 / 84
Lecture 16 Lecture 17 Lecture 18

Testing Output(Cont)

$ java CylinderUser
What’s the radius of the end of the cylinder? 2.5
What’s the height of the cylinder? 10.0
Surface Area = 196.34954084936209
Volume = 196.34954084936209

$ java CylinderUser
What’s the radius of the end of the cylinder? 2.5
What’s the height of the cylinder? -10.0
Negative value input: exiting.

etc

Clare Dixon Aggregation 79 / 84

Lecture 16 Lecture 17 Lecture 18

Swimming Pool Revisited

We could revisit some of our previous classes and do

something similar.
Recall the design for SwimmingPool.

SwimmingPool
- RATEOFFLOW: double = 50.0
SwimmingPoolUser - UNITCAPACITY: double = 1000.0
✲ - length: double
+ main(String[]) - width: double
- depth: double
+timeToFill(): double

How could we do something similar?

Clare Dixon Aggregation 80 / 84

Lecture 16 Lecture 17 Lecture 18

An Aside: the this keyword

Next we briefly mention the Java keyword this.

The Java keyword this is a reference to the object that uses it.

In a constructor this references the object under construction.

In a method this references the object being manipulated.

Clare Dixon Aggregation 82 / 84

Lecture 16 Lecture 17 Lecture 18

The this Keyword in Constructors

Recall the constructor for the Rectangle class.

// Constructor method
public Rectangle(int l, int w) {
length = l;
width = w;
}

It could be encoded as follows.

// Constructor method
public Rectangle(int length, int width) {
this.length = length;
this.width = width;
}

Inside the constructor length and width are local copies of

length and width. To refer to the attribute length we need to use the
keyword this, i.e. this.length refers to length which is an attribute of the
current object.
Clare Dixon Aggregation 83 / 84
Lecture 16 Lecture 17 Lecture 18

Summary

We looked at using objects as attributes of other objects.

This is a type of association also known as an aggregation
which models the has-a relationship.
Doing this has the advantage of modularity and re-use.
We considered an example of calculating the surface area and
volume of a cylinder where we could use a previously
defined Circle class as one of the attributes.
We briefly introduced the this keyword.

Clare Dixon Aggregation 84 / 84