CS2040S Data Structures and Algorithms

Lecture Note #1

Introduction to Java
Outline
1. Java: Brief history
2. Run cycle
3. Basic program structure
4. Basic Java program elements
4.1 Primitive and Reference Types
4.2 Control Flow Statements and Logical Expressions
4.3 Basic Input (Scanner class) and Output
4.4 User defined method (class method)
4.5 Useful Java API classes – Scanner, Math, String
4.6 Essential OOP concepts for CS2040

2
1. Java: Brief History

James Gosling
1995, Sun Microsystems

Write Once, Run EverywhereTM

3
Java: Compile Once, Run Anywhere?
 Normal executable files are tied to OS/Hardware
 An executable file is usually not executable on
different platforms
 E.g: The a.out file compiled on sunfire is not
executable on your Windows computer
 Java overcomes this by running the executable
on an uniform hardware environment simulated
by software
 This is the Java Virtual Machine (JVM)
 Only need a specific JVM for a particular platform to
execute all Java bytecodes without recompilation

4
2. Run Cycle Run Cycle for Java Programs
 Writing/Editing Program vim HelloWorld.java

 Use an text editor, e.g: vim

 File must have .java extension HelloWorld.java

 Compiling Program
 Use a Java compiler, e.g.: javac javac HelloWorld.java
 Compiled binary has .class extension
 The binary is also known as
HelloWorld.class
Java Executable Bytecode
 Executing Binary
 Run on a Java Virtual Machine (JVM) java HelloWorld
 e.g.: java HelloWorld
(leave out the .class extension)
output
 Note the difference compared to C executable

5
3. Basic Structure Hello World!

import java.lang.*; // optional Java

public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
HelloWorld.java

6
3. Basic Structure Hello World! - Dissection (1/3)
import java.lang.*; // optional
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
HelloWorld.java

 The main() method (function) is enclosed in a “class”

 There may be multiple classes in a program
 There can be one and only one public class and it is the
one containing the main() method, which serves as the
starting point for the execution of the program
 Each class will be compiled into a separate XXX.class
bytecode
 “XXX” is taken from the class name (“HelloWorld” in this example)

7
3. Basic Structure Hello World! - Dissection (2/3)
import java.lang.*; // optional
public class HelloWorld { Beginners’ common
mistake:
public static void main(String[] args) {
Public class name not
System.out.println("Hello World!"); identical to program’s
file name.
}
}
HelloWorld.java

 File name must be the same as the public class name

8
3. Basic Structure Hello World! - Dissection (3/3)
import java.lang.*; // optional
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
HelloWorld.java

 To use a predefined library in Java have to import it

 Using the “import XXXXXX;” statement
 A library in Java is known as a package
 Packages are organized into hierarchical grouping
 E.g “System.out.println()” is defined in
“java.lang.System”, i.e. “lang” is a package under “java” (the
main category) and “System” is a class under “lang”
 All packages/classes under a group can be imported with a “*”
 Packages under “java.lang” are imported by default
9
4 Basic Program Elements
4.1 Primitive and Reference
Types
Identifier, Variable, Constant (1/2)
 Identifier is a name that we associate with some
program entity (class name, variable name, parameter
name, etc.)
 Java Identifier Rule:
 May consist of letters (‘a’ – ‘z’, ‘A’ – ‘Z’), digit characters
(‘0’ – ‘9’), underscore (_) and dollar sign ($)
 Cannot begin with a digit character
 Variable is used to store data in a program
 A variable must be declared with a specific data type (for
statically-typed languages and Java is such a language)
 Eg: int countDays;
double priceOfItem;

12
Identifier, Variable, Constant (2/2)
 Constant is used to represent a fixed value
 Eg: public static final int PASSING_MARK = 65;
 Keyword final indicates that the value cannot change
 Guidelines on naming
 Class name: UpperCamelCase
 Eg: Math, HelloWorld, ConvexGeometricShape
 Variable name: LowerCamelCase
 Eg: countDays, innerDiameter, numOfCoins
 Constant: All uppercase with underscore
 Eg: PI, CONVERSION_RATE, CM_PER_INCH
 Reference from old module … 
http://www.comp.nus.edu.sg/~cs1020/labs/styleguide/styleguide.html

13
Primitive and Reference Types
 Data types in Java are categorized into 2 groups
 Primitive types – byte, short, int, long, float, double,
char, boolean
 Variable of primitive type “store” a value of the same type as the
variable in the stack (fast memory access)
 Reference types – any class in Java
 Variable of reference type do not store a value of the same type
as the reference but rather the “memory address” of a value
(more accurately an object) of the reference type in the heap
(slower memory access)
 This memory address is also know as a reference/pointer
 In order to create/instantiate an object of the reference type we
have to use the “new” keyword (will see this later)

14
 Primitive Numeric Data Types
 Summary of numeric data types (primitive types) in Java:
Type Size Range
Name (#bytes)
byte 1 -27 to 27-1
Integer Data

short 2 -215 to 215-1

Types

int 4 -231 to 231-1

long 8 -263 to 263-1
char 2 0 to 216-1 (all unicode characters)
Point Data

float 4 Negative: -3.4028235E+38 to -1.4E-45

Floating-

Types

Positive: 1.4E-45 to 3.4028235E+38

double 8 Negative: -1.7976931348623157E+308 to -4.9E-324
Positive: 4.9E-324 to 1.7976931348623157E+308

 Usually you will use int for integers and double for floating-point
numbers
 char can be considered an integer data type as each character is
associated with an integer ASCII value
15
Numeric Operators
() Parentheses Grouping Left-to-right
++, -- Postfix incrementor/decrementor Right-to-left
Higher Precedence

++, -- Prefix incrementor/decrementor Right-to-left

+, - Unary +, -
*, /, % Multiplication, Division, Left-to-right
Remainder of division
+, - Addition, Subtraction Left-to-right
= Assignment Operator Right-to-left
+= -= *= /= %= Shorthand Operators

 Evaluation of numeric expression:

 Determine grouping using precedence
 Use associativity to differentiate operators of same precedence
 Data type conversion is performed for operands with different
data type

16
Numeric Data Type Conversion
 When operands of an operation have differing types:
1. If one of the operands is double, convert the other to double
2. Otherwise, if one of them is float, convert the other to float
3. Otherwise, if one of them is long, convert the other to long
4. Otherwise, convert both into int

 When value is assigned to a variable of differing types:

 Widening (Promotion):
 Value has a smaller range compared to the variable
 Converted automatically
 Narrowing (Demotion):
 Value has a larger range compared to the variable
 Explicit type casting is needed

17
Data Type Conversion
 Conversion mistake:
double d;
int i; What’s the mistake? How
do you correct it?
i = 31415;
d = i / 10000;

Q: What is assigned to d? Ans: 3

The (int) d expression is
 Type casting: known as type casting
double d; Syntax:
int i;
(datatype) value
d = 3.14159;
i = (int) d; // i is assigned 3
Effect:
Q: What is assigned to i if d contains value is converted explicitly to
3.987 instead? Ans: Still 3 (decimal part the data type stated if possible.
is truncated, not rounded)
18
Reference Types: Wrapper Classes (1/2)
 Reference based counterparts of primitive data types
 Sometimes we need the reference equivalent of these
primitive data types
Primitive Wrapper class
 These are called data type
wrapper classes – one int Integer

wrapper class long Long

corresponding to each float Float

primitive data type double Double

char Character
boolean Boolean
and others…

19
Instantiating/creating an object
 Since the wrapper classes are a reference type, after
declaring a variable of the wrapper class type we still have
to instantiate/create an object of the class to use it

 To instantiate/create an object of a class we need to use

the new keyword eg
Integer i = new Integer(13);

Declaration of an Instantiating an Integer

Integer reference object with the value 13
variable using the Integer constructor

20
Schematic view of primitive vs reference type in
memory
 Eg int i = 7

i
7

 Eg Integer j = new Integer(12)

j
12

21
Reference Types: Wrapper Classes (2/2)
 We may convert a primitive type value to its corresponding
object. Example: between int and Integer:
 int x = 9;
Integer y = new Integer(x);
System.out.println("Value in y = " + y.intValue());

 Wrapper classes offer methods to perform conversion

between types
 Example: conversion between string and integer:
 int num = Integer.valueOf("28");
 num contains 28 after the above statement

 String str = Integer.toString(567);

 str contains “567” after the above statement

 Look up the Java API documentation and explore the

wrapper classes on your own
22
Autoboxing/unboxing (1/2)
 The following statement invokes autoboxing
Integer intObj = 7;

 An Integer object is expected on the RHS of the assignment

statement, but 7 of primitive type int is accepted.
 Autoboxing is the automatic conversion that the Java
compiler makes between the primitive types and their
corresponding wrapper classes
 The primitive value 7 is converted to an object of Integer
 The Java compiler applies autoboxing when a primitive
value is:
 Passed as a parameter to a method that expects an object of the
corresponding wrapper class
 Assigned to a variable of the corresponding wrapper class

23
Autoboxing/unboxing (2/2)
 Converting an object of a wrapper type (e.g.:
Integer) to its corresponding primitive (e.g: int)
value is called unboxing.
 The Java compiler applies unboxing when an object of
a wrapper class is:
 Passed as a parameter to a method that expects a value of the
corresponding primitive type
 Assigned to a variable of the corresponding primitive type
int i = new Integer(5); // unboxing
Integer intObj = 7; // autoboxing i = 5
System.out.println("i = " + i); intObj = 7
System.out.println("intObj = " + intObj);

*Note that the standard way to instantiate an object of any wrapper

class is to use autoboxing instead of the new keyword

24
Arrays in Java (1)
 An array in Java is a reference type
 You need to “new” an array instantiate an
array object
 An array can store either primitive values or
objects (more precisely the references
pointing to them)

25
Arrays in Java (2)
 Declaring an array is as follows
<type> [] identifier;
e.g float [] height;
declares an array of floating point values

 To declare multiple dimensional arrays simply

include as many [] as there are dimensions
e.g a 2 dimensional floating point array
float [][] weight;

26
 Arrays in Java (3)
 To instantiate a height array of size say 10 and a weight
array of size 10x10
height = new float[10];
weight = new float[10][10];
or simply
float [] height = new float[10];
float [] weight = new float[10][10];

 To access and modify the value at a particular index in

height say 3 or in weight at say 0,1 (can only do this after
array object is created
height[3] = 10.2;
weight[0][1] = 1001.1;
27
Arrays in Java (4)
 To initialize a height array with 5 values, and a
weight array with 2x2 values

float [] height = {1.0,2.0,3.0,4.0,5.0}

float [][] weight = {{10.1,10.2},{10.3,10.4}}
1st row 2nd row
 Note that Java uses 0-based indexing

28
Schematic view of array in memory (1)
 E.g int [] height = {1,2,3}

height
1 2 3

 E.g Integer[] heightObj = new Integer[3];

heightObj All the Integer references
null null null
in heightObj is initialized
to null

A reference type variable not pointing to any

object is assigned null
29
Schematic view of array in memory (2)
 E.g
Integer[] height = new Integer[3];
height[0] = 3;
height[1] = 4;
height[2] = 5;
heightObj

3 4 5

30
Problem 1: Adding 2 fractions
 Write a simple Java program FractionV1.Java:
𝑎𝑎 𝑐𝑐
 Given 2 fractions +
𝑏𝑏 𝑑𝑑

 Print out the resulting fraction from the addition

 For the time being, you can hard code the 2

fractions instead of reading it from user

31
P1: Adding 2 fractions
FractionV1.java
public class FractionV1 {

public static void main(String[] args) {

int a,b,c,d,newNum,newDenom;

a = 1; Output:
b = 2; New Fraction = 10/8
c = 3;
d = 4;
newDenom = b*d;
newNum = a*d+c*b;
System.out.println("New Fraction = "+newNum+"/"+newDenom);
}
}
 Notes:
 10/8 is not the simplest form but it will suffice here
 “+” in the printing statement
 Concatenate operator, to combine strings into a single string
 Variable values will be converted to string automatically
 There is another printing statement, System.out.print(), which does not
include newline at the end of line
32
4.2 Control Statements

Program Execution Flow

Boolean Data Type
 Java provides a boolean data type
 Store boolean value true or false, which are keywords
in Java
 Boolean expression evaluates to either true or false
SYNTAX

boolean variable;

boolean isEven;
int input;
// code to read input from user omitted
if (input % 2 == 0)
Example

isEven = true; Equivalent:

else isEven = (input % 2 == 0);
isEven = false;
if (isEven)
System.out.println("Input is even!");

34
Boolean Operators

Operators Description
< less than
Operands are variables /
> larger than values that can be
Operators
Relational

compared directly.
<= less than or equal
>= larger than or equal Examples:

== Equal X < Y
1 >= 4
!= not equal
&& and Operands are boolean
Operators

variables/expressions.
Logical

|| or
! Examples:
not
(X < Y) && (Y < Z)
^ exclusive-or (!isEven)

35
Selection Statements
if (a > b) {  if-else statement
...  else-part is optional
}
else {
 Condition:
...  Must be a boolean expression
}  Unlike C, integer values are NOT valid

switch (a) {  switch-case statement

case 1:
 Expression in switch() must evaluate
...
to a value of char, byte, short or
break;
case 2: int type
case 3:  break: stop the fall-through execution
...  default: catch all unmatched cases;
default:
may be optional
}

36
Repetition Statements
 Valid conditions:
while (a > b) {
... //body  Must be a boolean expression
}  while : check condition before
executing body
do {  do-while: execute body before
... //body condition checking
} while (a > b);

 A: initialization (e.g. i = 0)
for (A; B; C) {  B: condition (e.g. i < 10)
... //body  C: update (e.g. i++)
}
 Any of the above can be empty
 Execution order:
 A, B, body, C, B, body, C, …
37
4.3 Basic Input/Output

Interacting with the outside world

Reading input: The Scanner Class
PACKAGE

import java.util.Scanner;

//Declaration of Scanner "variable"

Scanner scVar = new Scanner(System.in);

//Functionality provided
scVar.nextInt(); Read an integer value from
SYNTAX

source System.in

Read a double value from

scVar.nextDouble(); source System.in

...... Other data types, to be covered

later

39
P2: Reading Input for 2 Fractions
import java.util.*; // or import java.util.Scanner;

public class FractionV2 {

public static void main(String[] args) {

int a,b,c,d,newNum,newDenom;
Scanner sc = new Scanner(System.in);

System.out.print("Enter 2 Fractions to be added: ");

a = sc.nextInt();
b = sc.nextInt();
c = sc.nextInt();
d = sc.nextInt();

newDenom = b*d;
newNum = a*d+c*b;
System.out.println("New Fraction = "+newNum+"/"+newDenom);
}
}
FractionV2.java

40
P2: Reading Input - Key Points (1/3)
import java.util.*; // or import java.util.Scanner;

public class FractionV2 {

public static void main(String[] args) {

int a,b,c,d,newNum,newDenom;
Scanner sc = new Scanner(System.in);

//rest of code omitted

}
}
FractionV2.java

 Declares a variable “sc” of Scanner type

 The initialization “new Scanner(System.in)”
 Constructs a Scanner object (discuss more about object later)
 Attaches it to the standard input “System.in” (the keyboard)
 sc will receive input from this source
 Scanner can attach to various input sources; this is one typical usage

41
P2: Reading Input - Key Points (2/3)
import java.util.*; // or import java.util.Scanner;

public class FractionV2 {

public static void main(String[] args) {

int a,b,c,d,newNum,newDenom;
Scanner sc = new Scanner(System.in);

System.out.print("Enter 2 Fractions to be added: ");

a = sc.nextInt();

// rest of code omitted

}
} FractionV2.java
 After proper initialization, scanner object provide functionality to read
input from the input source
 nextInt() in sc.nextInt() works like a function (method in
Java) that returns an integer value read interactively (in this case
input from keyboard)
 In general the Scanner object sc converts the input into the
appropriate data type and returns it
42
P2: Reading Input - Key Points (3/3)
 Typically, only one Scanner object is needed,
even if many input values are to be read.
 The same Scanner object can be used to call the
relevant methods to read input values

43
Writing Output: The Standard Output
 System.out is the predefined output device
 Refers to the monitor/screen of your computer

//Functionality provided
System.out.print( output_string );
SYNTAX

System.out.println( output_string );

System.out.printf( format_string, [items] );

Output:
System.out.print("ABC"); ABCDEF
System.out.println("DEF"); GHI
System.out.println("GHI"); Very C-like 3.142

System.out.printf("Very C-like %.3f\n", 3.14159);

44
Writing Output: printf()
 Java introduces printf() in Java 1.5
 Very similar to the C version
 The format string contains normal characters and a
number of specifiers
 Specifier starts with a percent sign (%)
 Value of the appropriate type must be supplied for each specifier
 Common specifiers and modifiers:
%d for integer value
%f for double floating-point value %[-][W].[P]type

SYNTAX
%s for string
-: For left alignment
%b for boolean value W: For width
%c for character value P: For precision

45
P3: Add 2 fractions and output the new
fraction in simplest form
 New requirement: Given the new fraction we
want to express it in it’s simplest form
e.g 1: Simplest form of 2/3 is 2/3 itself
e.g 2: Simpest form of 10/8 is 5/4

 Write FractionV3.java to:

1. Ask the user for the 2 fractions to be added
2. Calculate the new fraction
3. Simplify the new fraction
4. Output the new fraction
46
Solution: Using GCD

1. Compute GCD of numerator and denominator

2. Divide numerator and denominator by GCD
3. Output fraction with the new numerator and
denominator

47
P3 Solution
import java.util.*; // using * in import statement

public class FractionV3 {

public static void main(String[] args) {
// everything up to computation of newNum and newDenom as
// in FractionV2

int rem,e,f;

e = newNum;
f = newDenom;
while (f > 0) {
rem = e%f;
e = f;
f = rem;
} // GCD is the value of e after while loop stops
newNum /= e;
newDenom /= e;
System.out.println("New Fraction = "+newNum+"/"+newDenom);
}
}
FractionV3.java

48
4.4 User defined method
(class method)

Reusable and independent code units

P4: Writing a class method for gcd
 In FractionV3, we see that computing gcd is a useful
function can be used in many mathematical
problems
 In possible further extensions to our Fraction
program, it is good not to have to keep re-writing
that portion of code
 This can be achieved by writing a user defined
method for gcd (like the System.out.println method)
in Java called a static/class method
 Denoted by the “static” keyword before return data type
 Another type of method, known as instance method will
be covered later

50
P4: Writing a class method for gcd
public class FractionV4 { FractionV4.java

// Returns GCD of e and f

// Pre-cond: e and f must be > 0
public static int gcd(int e, int f) {
int rem;
while (f > 0) {
rem = e%f;
e = f;
f = rem;
}
return e;
}
public static void main(String[] args) {
// everything before computing gcd as in FractionV3

int divisor = gcd(newNum,newDenom);

newNum /= divisor;
newDenom /= divisor;
System.out.printf("New Fraction = "+newNum+"/"+newDenom);
}
}
51
Method Parameter Passing
 All parameters in Java are passed by value (as
in C/Python/Javascript (for primitives) ):
 A copy of the actual argument is created upon method
invocation
 The method parameter and its corresponding actual
argument are two independent variables

 In order to let a method modify the actual

argument, a reference data type is needed

52
4.5 Useful Java API classes –
Scanner, Math, String

Let’s look at the Java API (Application

Programming Interface)
Java Programmer

API Specification
http://docs.oracle.com
/javase/8/docs/api/

54
 Scanner Class: Reading Inputs
 API documentation
 http://docs.oracle.com/javase/8/docs/api/java/util/Scanner.html
 For reading input Note Java naming convention
 Import java.util.Scanner Method names – lowerCamelCase

next()
nextDouble()
nextInt()
nextLine()
…
hasNext()
hasNextDouble()
hasNextInt()
hasNextLine()
…
55
 String Class: Representation in Text
 API documentation
 http://docs.oracle.com/javase/8/docs/api/java/lang/String.html
 Import java.lang.String (optional)
 Ubiquitous; Has a rich set of methods
charAt()
concat()
equals()
indexOf()
lastIndexOf()
length()
toLowerCase()
toUpperCase()
substring()
trim()
And many more…

56
 String Class: Demo (1/2)
public class TestString { TestString.java
public static void main(String[] args) {
String text = new String("I'm studying CS2040.");
// or String text = "I'm studying CS2040.";

System.out.println("text: " + text);

System.out.println("text.length() = " + text.length());
System.out.println("text.charAt(5) = " + text.charAt(5));
System.out.println("text.substring(5,8) = " +
text.substring(5,8));
System.out.println("text.indexOf(\"in\") = " +
text.indexOf("in"));
String newText = text + "How about you?";
newText = newText.toUpperCase();
System.out.println("newText: " + newText);
if (text.equals(newText))
System.out.println("text and newText are equal.");
else
System.out.println("text and newText are not equal.");
}
}

57
 String Class: Demo (2/2)
Outputs Explanations
text: I'm studying CS2040.
length() returns the length (number of
text.length() = 20 characters) in text
charAt(5) returns the character at
text.charAt(5) = t position 5 in text

text.substring(5,8) = tud substring(5,8) returns the substring

in text from position 5 (‘t’) through
position 7 (‘d’).  Take note

text.indexOf("in") = 9 indexOf("in") returns the starting

position of "in" in text.

newText = newText.toUppercase()
converts characters in newText to uppercase.
The + operator is
newText: I'M STUDYING CS2040.HOW ABOUT YOU? string concatenation.

equals() compares two String objects.

text and newText are not equal. Do not use ==. (To be explained later.)
58
 String Class: Comparing strings
 As strings are objects, do not use == if you want to
check if two strings contain the same text
 Use the equals() method provided in the String class
instead
Scanner sc = new Scanner(System.in);
System.out.println("Enter 2 identical strings:");
String str1 = sc.nextLine();
String str2 = sc.nextLine(); Enter 2 identical …
Hello world!
System.out.println(str1 == str2); Hello world!
System.out.println(str1.equals(str2)); false
true

59
 String Class: Immutable class
 String objects once created are immutable, that is you
cannot change the content of the object
 This is why you see that all operations which “changes”
the string actually returns a new string
 Not taking this into consideration can result in
inefficient string processing
 For mutable strings you can look up StringBuilder in
the Java API
 There are other immutable classes in Java API
including all the primitive wrapper classes

60
Sequence and Subsequence
 A sequence is any enumerated collection of
items in which repetition is allowed.
 For example a sequence of integers <1,3,5,9,10>
 A String can be considered a sequence of characters

 A subsequence is a possibly non-contiguous

sequence of characters in a sequence. Relative
ordering of items in subsequence is maintained
e.g <snCS> in "I'm studying CS2040."
e.g <tud> in "I'm studying CS2040."
e.g <1,5,9> in <1,3,5,9,10>
61
 Math Class: Performing Computation
 API documentation
 http://docs.oracle.com/javase/8/docs/api/java/lang/Math.html
 Import java.lang.Math (optional)
abs()
ceil()
floor()
hypot()
max()
min()
pow()
random()
sqrt()
And many more…

2 class attributes
(constants):
E and PI

62
 Math Class: Demo
Enter 3 values: 3.2 9.6 5.8
import java.util.*; pow(3.20,9.60) = 70703.317
public class TestMath2 { Largest = 9.6
public static void main(String[] args) {
Generating 5 random values:
Scanner sc = new Scanner(System.in);
0.874782725744965
System.out.print("Enter 3 values:0.948361014412348
");
double num1 = sc.nextDouble(); 0.8968816217113053
double num2 = sc.nextDouble(); 0.028525690859603103
double num3 = sc.nextDouble(); 0.5846509364262972
System.out.printf("pow(%.2f,%.2f) = %.3f\n",
num1, num2, Math.pow(num1,num2));
System.out.println("Largest = " +
Math.max(Math.max(num1,num2), num3));
System.out.println("Generating 5 random values:");
for (int i=0; i<5; i++)
System.out.println(Math.random());
}
}
TestMath.java
63
4.6 Essential OOP Concepts for
CS2040

What makes Java object-oriented?

OOP in java Classes/objects (1)
 OOP or object oriented programming solves
computational problem by modeling entities
of the problems as classes/objects
 Class == blueprint/mold
 Object == actual entity instantiated from a
class

65
Encapsulation in Java Class
 Encapsulation
 Bundling data and associated functionalities
 Hide internal details and restricting access

66
Data in a java Class (1)
 Data in a java Class is represented by
attributes/variables that you declare outside
of the methods but within the class
 Instance Attribute  Each created instance/object
of a class has it’s own copy of the instance
attribute
 Class Attribute  Associated with the class, and
is shared by all objects created from the class
 Usually used to denote constants or in some rare cases
global variables (e.g keeping a count of the number of
objects created for a class)

67
Data in a java Class (2)
 Declaring Attributes in Java
 Instance Attribute  Similar to declaring any
variable but it should be outside of any method in
the class, e.g class Circle {
public int radius;

…
}

 Class Attribute  Add the keyword static in front

of the variable, e.g class Circle {
public static int NUM_CIRCLE=0;

…
}

 *for the purpose of this course prefix all attribute

declaration/method declaration with public
68
Functionality in java Class (1)
 Functionality in a java Class is represented
by methods
 Instance methods  methods that can be called
via an object of the associated class e.g nextInt()
method of scanner
 Class methods  methods that can be called via
the class itself (there is no need to create an
object to call it)

Note: Variables that you declare in methods are not

attributes but local variables
69
Functionality in java Class (2)
 Declaring methods in Java
 Instance methods  similar to how functions are
declared in other languages, except here all return
values, and method parameters must have the type
declared (if no return value it must be declared as
class Circle {
void) e.g …

public void updateRadius(int rad){

radius = rad;
}
}

 Class methods  like class attributes, prefix the

method declaration with keyword static like the gcd
method in the FractionV4 class
 Note that you cannot use instance attributes in class methods!
70
Simple design guidelines (1)
 Instance attribute  Something that is
associated with a specific object e.g in a Circle
class, radius should be an instance attribute

 Class attribute  Usually represent a constant

value that is shared by all objects of the class
e.g in a Circle class, PI should be a class
attribute, or some attribute shared by all objects,
e.g NUM_CIRCLE which represent total circle
objects created

71
Simple design guidelines (2)
 Instance method  Method which needs to
operate on the instance attributes in an object

 Class method  Method which does/should

not operate on any instance attributes in an
object (eg gcd method in our Fraction class)

 For this course we are not so concerned

about design as long as the code works ….
(don’t tell your CS2030 lecturer…)

72
Fraction class  OOP design (1)
 Make the Fraction class actually represent a
fraction (1)
 Make the numerator, denominator as instance
attributes
 Make instance methods to access/modify the
numerator/denominator (also know as
accessor/mutator methods)
 Make gcd a class method (not really associated with a
specific fraction)

73
Fraction class  OOP design (2)
 Make the Fraction class actually represent a
fraction (2)
 The addition operation can be made either a class or
instance method
 Class method if you do not modify the attributes of the object
but merely return a new Fraction that is the result of the
addition (pass both fractions into add method)
 Instance method if you modify the attributes of an object after
perform addition with another Fraction object  we will
implement this one

74
FractionOOPV1 class (1)
class FractionOOPV1 {
public int num, denom; Instance attributes

public int getNum() { return num; }

public int getDenom() { return denom; }
public void setNum(int iNum) {num = iNum;}
public void setDenom(int iDenom) {denom = iDenom;}
public static int gcd(int e, int f) {
int rem;
Instance methods
while (f > 0) {
rem = e%f;
e = f;
f = rem;
}
return e;
}
// instance method add -> takes in another fraction add to this fraction
//and modify it
public void add(FractionOOPV1 iFrac) {
num = num*iFrac.getDenom()+denom*iFrac.getNum();
denom = denom*iFrac.getDenom();
int divisor = gcd(num,denom);
num /= divisor;
denom /= divisor;
}
}
FractionOOPV1.java 75
FractionOOPV1 class (2)
 Note there is no more public in front of the
class, as FractionOOPV1 no longer contains
the main method
 FractionOOPV1 is now known as a service
class

76
Overloading methods
 Methods in a class can be overloaded
 Having multiple methods with the same name but
different parameters
 The correct method will be called based on what
arguments are supplied for the parameters

 You see method overloading a lot in the Java

API as shown earlier

 e.g in our FractionOOPV1 class we can have an

overloaded add method which simply takes in 2
arguments, the numerator and denominator
77
FractionOOPV1 class (3) FractionOOPV1.java
class FractionOOPV1 {
…

//instance method add -> takes in another fraction add to this fraction
//and modify it
public void add(FractionOOPV1 iFrac) {
num = num*iFrac.getDenom()+denom*iFrac.getNum();
denom = denom*iFrac.getDenom();
int divisor = gcd(num,denom);
num /= divisor;
denom /= divisor;
}

//overloaded add method -> takes in a numerator and denominator instead of

//a fraction object
public void add(int iNum, int iDenom) {
num = num*iDenom+denom*iNum;
denom = denom*iDenom;
int divisor = gcd(num,denom);
num /= divisor;
denom /= divisor;
}
}

However we still have no way to create a

Fraction object !
78
Constructor
 To instantiate/create an object of a class, the
class must provide a constructor (it is basically a
special method)
 Each class has one or more constructors
 Default constructor has no parameter and is
automatically generated by compiler if class designer
does not provide any constructor.
 Non-default constructors are added by class designer
 Constructors can be overloaded
 Main use of providing your own custom
constructor is to initialize the attributes of the
object properly
79
FractionOOPV1 Constructor
class FractionOOPV1 {
public int num, denom;

public FractionOOPV1(int iNum, int iDenom) {

num = iNum;
denom = iDenom;
}

}
FractionOOPV1.java

 A Java constructor has no return type and it

must be the same as the class

80
Fraction class  OOP design (3)
 FractionOOPV1 is now called a service class
(like the classes in the Java API)
 It can be used by anyone who has access to
your Fraction class whenever they need to
represent fractions
 Now in order to test out or make use of our
FractionOOPV1 class we have to create a
client class
 This is the public class with the main method

81
TestFractionOOPV1 client class V1
 A client class we can create is as follows

public class TestFractionOOPV1 {

public static void main(String args[]) {

FractionOOPV1 f1 = new FractionOOPV1(1,2);
FractionOOPV1 f2 = new FractionOOPV1(3,4);
f1.add(f2);
System.out.println(f1.getNum()+”/”+f1.getDenom());
f1.add(4,5);
System.out.println(f1.getNum()+”/”+f1.getDenom());
}
}
TestFractionOOPV1.java

 Actually the client class should not worry about

formatting of the fraction to be printed,as it should be
taken care of by the FractionOOPV1 class itself

82
Overriding methods
 All classes in Java “inherit” from the Object
class
 One method inherited is the toString method
which returns a string representation of the
object for output/printing purposes
 However in order to be useful you will have to
override the method (provide your own
implementation to format your object as a
string nicely)

83
Overriding the toString method
class FractionOOPV1 { FractionOOPV1.java

public String toString() {

return num+”/”+denom;
}
}

 Note that the method header must be the

same as the method header in Object class
(check the Java API)

84
TestFractionOOPV1 client class V2
 The client class can now be updated as follows

public class TestFractionOOPV1 {

public static void main(String args[]) {

FractionOOPV1 f1 = new FractionOOPV1(1,2);
FractionOOPV1 f2 = new FractionOOPV1(3,4);
f1.add(f2);
System.out.println(f1);
f1.add(4,5);
System.out.println(f1);
}
}
TestFractionOOPV1.java

85
Finishing touches
 Usually we don’t just perform 1 addition
operation
 We can be given a list of addition operations
 The input would be then be
 First the number of addition operations N
 Followed by N addition operations (given N number of
fraction pairs to add)

86
Finished TestFractionOOPV1
public class TestFractionOOPV1 {

public static void main(String args[]) {

Scanner sc = new Scanner(System.in);
int numAdd = sc.nextInt();

for (int i=0; i < numAdd; i++) {

FractionOOPV1 f1 = new FractionOOPV1(sc.nextInt(),sc.nextInt());
FractionOOPV1 f2 = new FractionOOPV1(sc.nextInt(),sc.nextInt());
f1.add(f2);
System.out.println(f1);
}
}
}
TestFractionOOPV1.java

 Note that FractionOOPV1 and

TestFractionOOPV1 need not be in a separate
file each, in fact we want you to write all your
service and client classes in one file (file name
will be the client class name)
87
 Extra: “this” reference (1)
 What if the parameter of a method (or a local variable in
a method) has the same name as an instance attribute?
public void setNum(int num) {
num = num; These methods will not
}
work, because num
public void setDenom(int denom) { and denom here refer
denom = denom; to the parameters, not
} the instance attributes
(overshadowing).
public void setNum(int iNum) {
num = iNum;
}
The original code:
public void setRadius(int iDenom) {
denom = iDenom;
}

88
 Extra: “this” reference (2)
 The “this” reference is used to solve the problem in
the preceding example where parameter name is
identical to attribute name
public void setNum(int num) {

}
num = num; 
public void setDenom(int denom) {
denom = denom;
}

public void setNum(int num) {

this.num = num;

} parameters
attributes
public void setDenom(int denom) {
this.denom = denom;
}
89
 “this” reference (3)
// b1 & b2 are FractionOOPV1 objects
b1.setNum(2);
 A common confusion: b2.setNum(3);
 How does the method “know” which “object”
it is communicating with? (There could be
many objects created from that class.) b1 num
2
 Whenever a method is called, this denom

 a reference to the calling object is set

automatically
 Named “this” in Java, meaning “this b2 num
particular object” 3

denom

 All attributes/methods are then

accessed implicitly through this
reference (only need to explicitly use
this for ambiguous cases)
90
End of file