1

Java Fundamentals

Learning outcomes:

- Refreshing your programming skill

- Java fundamentals

- Dissect Java programs

 Java Fundamentals

Programming:

- Data structures and algorithms need to be implemented in a

computer program

- For that, we will be using java programming language

- Your previous programming concept will be utilized too

- Java programming language will not be taught

- The following slides are to refresh your programming concepts in

terms of java.
 Java Fundamentals

Programming in java:

**Let us First dissect the example program myJavaProgram**

Things to remember:
- A java program is made of class and object
- Class (a template/recipe) is made of fields(properties) and methods
- Object (cake) is created from class
- Java is object oriented programming language
 Java Fundamentals

- A java program (class) is either a library of static methods(functions)

or a data type definition.
Components of a java program:
- Primitive data types: int, double, boolean, char, byte, long, short
- Statements: declaration, assignments, conditionals, loops, calls, and
returns
- Arrays: allow us to work with multiple values of same type
- Static methods: allow us to encapsulate and reuse code and to
develop programs
- Strings: are sequence of character
- Input/output: sets up communication between programs and outside
world
- Data abstraction: extends encapsulation and reuse to allow us to
define non-primitive data types, thus supporting OOP.
 Java Fundamentals

Variable: int myData;

Operator: + - * /
Literal: int 1; double 2.0; boolean true false; char ‘a’
Expression: int lo + (hi-lo)/2; boolean lo <= hi
Comparisons: compares two values and produce a boolean value:
equal (==), not equal (!=), less than (<), greater than or
equal (>=) etc.,
Conditional:
if(<boolean expression>) {block statements}
else {block statements}
if(<boolean expression>) {block statements}
if(<boolean expression>){block statements}
else if(<boolean expression>) {block statements}…
 Java Fundamentals

Loops: Many computations are inherently repetitive. The basic java

construct to do repetition is:
while (<boolean expression>) {<block statements>}
The break and Continue:
- The break statement, which immediately exits the loop
- The continue statement, which immediately begins the next iteration
of the loop.
For loop:
for (<initialize>; <boolean expression>; <increment/decrement>)
{
<block statements>
}
 Java Fundamentals

Initializing declaration:
- int i = 5; declaring a variable with initial value

Implicit assignments:
- Increment operator: ++i is same as i = i + 1;
- decrement operator: --i is same as i = i – 1;

Compound Operator:
- i /= 2 is same as i = i/2;
- i += 1 is same as i = i + 1;

Single-statement blocks:
- For a single statement block, the curly braces may be omitted.
 Java Fundamentals

Arrays:

- An array stores a sequence of values (elements) that are all of the

same type
- We want not only to store values but also to access each individual
value
- To refer to individual values in an array is numbering and then
indexing them
- If we have N values, they are numbered from 0 to N – 1
- We then specify one of them by using a notation a[ i ] to refer to the
ith value for any value of i from 0 to N – 1
- Being an object, we can use inbuilt fields and methods( ) associated
with this object
 Java Fundamentals

Arrays (Creating and initializing):

Making an array in a java program involves three steps:

- Declare the array name and type
- Create the array
- Initialize the array values
Examples:

double[ ] myArray; //declaration myArray[N-1]

myArray = new double [N]; //creation = ??
for(int i = 0; i < N; i++)
myArray[ i ] = 0.5; //initialization
 Java Fundamentals

Arrays (Creating and initializing):

double[ ] myArray = new double[N]; // declare & creation

int[ ] myArray = {8,7,13,56,98}; // declaration and initialization

Default array initialization:

- The default initial value is zero for numeric types and false for
boolean type.
- Once we create an array, its size is fixed
- A program can refer to the length of an array myArray with the code
myArray.length (Array is an object in java!)
 Java Fundamentals

Aliasing:
- A array name refers to the whole array: If we assign one array name
to another, then both refer to the same array.
- Example:
int[ ] myArray = new int[N];
…
int[ ] yourArray = myArray;
yourArray [ i ] = 789; //myArray [ i ] is now 789

This phenomena is called aliasing! Can lead to errors.

 Java Fundamentals

Two-dimensional array:
- A two dimensional array is an array of one dimensional array
- A M-by-N two dimensional arrays that are arrays of M rows, each an
array of length N (having N columns)
- The notation to refer a two-dimensional array is myArray[ i ][ j ]

Declaration and creation:

double [ ][ ] myArray = new double[M][N]
double [ ][ ] myArray;
myArray = new double[M][N];
for(int i = 0; i < M; i++)// Rows
for(int j = 0; j < N; j++)//Cols
myArray[ i ][ j ] = 0.0;
 Java Fundamentals

Array manipulations:
Finding the maximum:
double max = myArray[0];
for(int i = 1; i < myArray.length; i++){
if(myArray[ i ] > max)
max = myArray[ i ];}

Computing the average:

int N = myArray.length;
double sum = 0.0;
for(int i = 0; i < N; i++)
sum += myArray[ i ];
double average = sum/ N;
 Java Fundamentals

Array manipulations:
Copying:
int N = myArray.length;
double[ ] yourArray = new double[N];
for(int i = 0; i < N; i++)
yourArray[ i ] = myArray[ i ];
Reversing:
int N = myArray.length;
for(int i = 0; i < N/2; i++)
{
double temp = myArray[ i ];
myArray[ i ] = myArray[N – i -1];
myArray[N – i -1] = temp; }
 Java Fundamentals

Array manipulations:
Matrix-matrix multiplication (a[ ]*b[ ] = c[ ][ ]):

int N = a.length;
double[ ][ ] c = new double[N];
for(int i = 0; i < N; i++)
for(int j = 0; j < N; j++)
{//compute dot product of row i and column j
for(int k = 0; k < N; k++)
c[ i ][ j ] += a[ i ][ k ] * b[ k ] [ j ];
}
 Java Fundamentals

Array manipulations:
The Enhanced for Loop:
Often, you need to visit all elements of an array. The enhanced for loop
makes this process easy

double[ ] myArray = ….
double sum = 0.0;
for (double x : myArray)// x represent each element in the array
{
sum += x;
}
 Java Fundamentals

Strings:
- A string is a sequence of characters
- A literal string is a sequence of characters within double quotes,
such as, “Hello Students”
- It is non-primitive type and considered as an object
- Being an object, we can use inbuilt fields and methods( ) associated
with this object.
Concatenation:
- Java has a built-in concatenation operator(+) for String
- -Concatenating two String values is a String value, the first string
followed by the second
“Hello” + “Students” = “HelloStudents” How to “Hello Students”

“1” + “+” + “2” = “1+2”

 Java Fundamentals

Conversion:
- Two primary uses of strings:
- Convert values that we enter on a keyboard into data-type values
- Convert data-type values to values that we can read on a display

static int parseInt (String s) //convert s to an int value

static double parseDouble (String s) //convert s to double value

static String toString(int i) // convert i to a String value

static String toString(double y) // convert y to a String value
 Java Fundamentals

Input and Output:

- A java program takes input values from command-line arguments or
- From an abstract stream of characters known as the standard input
streams and
- Writes to another abstract stream of characters known as the
standard output stream
- We need to consider the interface between java and the operating
system
- By convention, both java and the operating system process the
arguments as Strings.
Commands and arguments:
In the terminal window:
Java –jar HelloWorld.jar 15 100.0 500 ENTER
 Java Fundamentals

Standard Input and Output:

- In java, the most convenient way for reading text is to use the
scanner class
Reading (inputting) values from the console:
Scanner in = new Scanner();//creating a scanner object for inputting
int x = in.nextInt(); // inputing an integer
double y = in.nextDouble(); // inputing a double value
char z = in.next().charAt(0); //inputting a char
String p = in.next();//inputting a String(word)
String p = in.nextLine(); // inputting a String(whole line)
Other useful static input methods:
static boolean isEmpty(); //true if no more values, false otherwise
static boolean hasNextLine(); //is there another line in the input stream?
 Java Fundamentals

Standard Input and Output:

- In java, the most convenient way for outputting text is to use the
System.out object

Writing values to the screen:

System.out.println (“Hello, Class”);//outputting the string Hello, Class

System.out.printf(“Sum: %8.2f\n”, sumTotal);//say, 1024.45

System.out.print(sumTotal);// outputting the value in sumTotal variable

System.out.println(); // inserting a new line

 Java Fundamentals

Input/output from/to a disk file:

- The scanner class relies on another class, File
How to do:
File inputFile = new File(“input.txt”); // creating a File object
Scanner in = new Scanner(inputFile); //creating a Scanner object
- This Scanner object reads text from the file input.txt
-You can use the following loop to process numbers in the input file
while(in.hasNextDouble())
{
double value = in.nextDouble();// Reading from “input.txt”
Process value;
}
 Java Fundamentals

Input/output from/to a disk file:

- To write output to a file, construct a PrintWriter object
How to do:
PrintWriter out = new PrintWriter(“output.txt”); // An empty file is created if not
exist, otherwise it gets emptied, if already exists
out.println(“Hello Students”);
out.printf(Sum = %8.2f%n”, sumTotal);

- PrintWriter class is an enhancement of the PrintStream class

- System.out is a PrintStream object.
- When you are done processing a file, be sure to close the Scanner or
PrintWriter:
in.close();
out.close();
 Java Fundamentals

Methods:
- A method (function in C!) is a sequence of instructions with a name
- Every java program has a method called main( ), the entry point
- Methods are called to execute its instructions
Example:
public static void main(String[ ] args)
{
double myResult = Math.pow(3,4);
……
}
- main calls the Math.pow( )
- The Math.pow method returns its results (34 = 81) back to main
- The main method resumes execution
 Java Fundamentals

Methods:
- Static methods are distinct from instance methods
- Static methods are property of class. As such they can be called by
their name or through their class name
- Instance methods must be called through their object
- A static method can call another static method
- A static method can’t access field variables
- Instance methods can access field variables
- Arguments are passed by values
- Methods name can be overloaded
- A method has a single return value but may have multiple return
statements
- A method can have side effects
 Java Fundamentals

Anatomy of a static Method:

public static double cubeVolume (double side) // signature, return type,

//argument type & value
{// body starts
double volTotal = side * side * side; // executable statement
return volTotal; // exits method and return result
}//body ends
 Java Fundamentals

Anatomy of a Java Program:

Let us dissect yet another example program myArrayProgram

 Java Fundamentals

Suggestive Reading list:

1. Java Concepts Late Objects, 3/e, Cay Horstmann

 Acknowledgements
The above slides are adopted from:

1. JavaCocepts@CayHorstmann