MODULE 2:

BASIC ELEMENTS OF JAVA

Adekola Olubukola, PhD, FNCS

Tel: +234803 374 6984
adekolao@babcock.edu.ng
Module 2: BASIC ELEMENTS OF
JAVA
GENERAL OBJECTIVE
■ Content of a Java program - comment, header, keyword,
delimiter, data type, method, variable, constant.
COMMENT IN CODE
■ When you buy a device, it comes with manuals explaining how to use.
This is referred to as external documentation.
■ Writing comments in code to explain a line of code or module or some
logic is referred to as internal documentation. The main purpose of this
is readability and understandability. Comments are generally non-
executable statements which are skipped by the compiler during code
execution. Comments put in the right points of a program enhance
program readability both for the code creator or others. It is not surprising
that you revisit a function written sometimes in the past only to discover
that you find it difficult to understand the logic put in the module by
yourself to solve a particular problem. How much more difficult that
could be if the program was written by someone else called to maintain
it.
■ Comment can be placed anywhere necessary in a program
TWO COMMON TYPES OF COMMENTS
1) Single line comment:
Compound symbol // (two forward slashes) –makes anything written
after it becomes a comment till the end of the line. E.g.
// This module adds the numbers
2) Multi-line comment:
Begins with a compound symbol /* and ends with the compound
symbol */
Anything written in between this symbol is regarded as comment and
can span as many lines as possible. E.g.
/* The program output the sum of
the square*/
IDENTIFIERS
Identifiers are unique names given to different entries or elements such as
variables, constants, methods/functions, classes, etc. Some are pre-defined
while some are named by the programmers following some rules.
Rules for Creating Valid Identifier in Java:
■ Only alphabetic characters, digits and underscores(_) and dollar sign ($)
are permitted.
■ First letter must be an alphabet, underscore (_) dollar sign ($) .
■ Identifiers are case sensitive.
■ The name has no spaces in it
■ Reserved keywords must not be used as an identifier (e.g. void).
■ Functions with predefined meaning should be avoided (e.g. println)
■ Identifier length can be as long as you prefer but too long may not look
good.
a) Variable Identifiers: Names used to temporarily hold data on computer
memory. The format for variable declaration is:
■ datatype variable-name;
e.g. int number = 5; //number is a variable initially set to
5 and can be changed or updated.
b) Constant Identifiers: Names used to permanently hold constant values or
literals. These, once declared cannot be altered (i.e immutable) throughout the
execution of the program.
You can define constants in Java by using final keyword:
E.g. final double PI = 3.142; PI -->the constant identifier
This means once the value is set (or initialized), the value of the data field
cannot subsequently be changed. With this restriction, there is less need to hide
access to a data value behind a method.
Valid Variable Identifiers in Java
I. unit_cost
II. y
III. totalCost
IV. Y2
V. $uxy
VI. _tape
VII.Bottle306
To improve code readability and maintainability, a good
programming practice demands that you form identifier names that
reflect the meaning or usage of the items being named.
Invalid Variable Identifiers in Java
I. 2sum – numeric digit don’t start an identifier
II. println - word with predefined meaning is not used
III. Total Cost – having a blank space between a compound name is
invalid
IV. Y+2 – operator plus in between characters make is invalid
V. else – is a reserved word and so invalid
Keywords
Java language keywords are reserved words that define the language
and have special or predefined meaning to the compiler and, therefore,
may not be used Otherwise.
Eg.
 Super - to call the constructor of the superclass
 If - to state an alternative course of action.
 private -: to make access to a property or method hidden.
The words true, false and null are three reserved words which
technically are literal values and not keyword but they cannot be used as
identifiers.
 Other Program Elements
■ Literals: Are values assigned to identifiers. It could be integer, floating points,
Boolean, character, string etc. e.g. 5 is an integer literal in the following: int bus =
5;
■ Operators: Are symbols used to perform mathematical or logical manipulations.
These include:
a) Arithmetic Operators: e.g. + (addition), % (modulus)
b) Increment and Decrement Operators: e.g. ++ (increment)
c) Relational Operators: e.g. > ( greater than)
d) Logical Operators: e.g. && (and) Gives true when both expression are true
e) Bitwise Operators: e.g. & (binary and operator)
f) Assignment Operators: e.g. = ( assignment) right to left associativity
■ Terminators and other separators: semi colon (;) (marks the end of a code)
Method
■ A Java class is essentially made up of two members, namely,
member variables and member methods. A method is like a
function or subroutine or program module designed to perform a
specific or single well-defined task.
■ A class may contain two major types of method: the main method
and others. Remember that JAVA program execution starts from the
main method.
■ A method consists of a statement/list of statements that a program
(class) executes
■ Every (running) application must have a main method
■ The structure of main method header is as follows:
public static void main(String args[])
The Structure of a method in Java
A java method consists of a
a. Header (method signature) followed by
b. Method block (list of codes between open and close curly bracket { })
Generally, a method header takes the form:
access modifier return-type name (parameter list)
Such that:
■ Access : keywords e.g. public, private, protected or default access (obtained by
leaving off the access modifier. public- allows anyone to invoke or call the
method from anywhere, private access means no one else can invoke the method
except member of its own class. protected access allows members of the same
class and subclasses(used in implementing inheritance).
 The Structure of a method in Java
■ Modifier (or specifier) – optional: e.g. static, final, abstract, native or synchronized.
A method may not use none, one or more of these specifiers.
■ Return type: e.g. int, double. This is the data type of the value that the method
returns.
■ Return type could be one of the primitive data types or a reference.
■ Method name: Is any valid language identifier as given by the programmer.
■ Parameter list: This is comma separated list of formal parameter that receive
values from arguments passed to the method when a method is invoked. Parameters
may be empty. A parameter is a locally scoped variable declared in a method
header that temporarily comes into existence while a method is executing. A
parameter consists of a data type and an identifier
The Structure of a method in Java

//General format of a method:

Access modifier return_type Method_name([Optional Parameter list])
{
// list of code (executable statements)
}
Typical example:
public int periMtd(int para1, int para2)
{
int val;
val = 2*(para1 + para2);
return val;
}
Class
In Java, the primary unit of encapsulation is the class. A class defines the
form of an object. It specifies both the data and the code that will operate
on that data. Therefore, a class is a set of plans where we specify how an
object is built.
The code and data in a particular class are called members of that class.
The data defined by the class are referred to as member variables while
the code that operates on that data is referred to as member methods.
A class represents a set of objects that share a common structure and a
common behavior. A class simply put, defines an object. Then an object
has state, exhibits some well defined behaviours and has a unique identity
(Booch, 1995).
Class
Java format example: (Access modifier is declared for individual member)
 Access Specifier class ClassName
{
private //declaration of private member
private //declaration of private member
…
public //declaration of public member
public //declaration of public member
…
}
Class Definition- Java Typical Example:
public class Rectangle
//By convention, a class name begins with an uppercase letter.
{
//the data attributes or instance variables
private double length;
private double height;

// member method to find area

public double computeArea()
{
return length * height;
}
}
 Escape Sequence
Escape Sequence Meaning
\n newline also known as line feed
\t tab
\r carriage return
\’ single quote
\” double quote
\\ Backslash
\b backspace

These are used mostly in output statements to format display.

E.g. System.out.println(“\” Hello There\” ”);
DATA TYPES
Variables are named memory locations to store values. This means that when
you create a variable you reserve some space in memory. Hence, there is a
need to know the type of data so as to know what appropriate memory to
give to it. Data type of a variable indicates the type of data it can store and
also the type of operations that can be performed on it.
There are basically two types:
1) Primitive/Basic/Fundamental data types (bult-in)
2) Derived/User-defined/Reference types

Spaces on memory are allocated based on the type e.g. char is 1 byte
Primitive Data Types
A primitive – type variable can store exactly one value of its declared type at a time. E.g. if
an integer variable x initially stores whole number 5 and it is later assigned whole number 9,
then x no longer carries 5 but 9.
The primitive also called simple or scalar data types are initialized by default.
The primitive Data types can be grouped into 4:
Integral – data that deal with integers( whole numbers without decimal point and characters)
this group byte, short, int, and long. All of there are signed (i.e they can store positive and
negative numbers)
Floating Point- data type that deals with decimal numbers that is numbers with fractional
precision, this group includes float and double
Boolean – data types that deal with logical values, the group includes only boolean.
Characters- data types that deal with symbols in a character set like letters and numbers
Primitive Data Types:
The following table describes the 8 primitive data types built into Java language (i.e. those that come
with your compiler):
S/ Type Type Represented Range of Value Default Usage
N Initialization
1 byte Very small integers -128 to 127 0 byte v = 2

2 short Small integers -32768 to 32767 0 short v = 2

3 int Big integers -2,147,483,648 to 2,147,483,647 0 int v = 2

4 long Very big integers -9,223,372,036,854,775,808 to 0 long v = 2

9,223,372,036,854,775,807

5 float Real numbers +/-1.4*10-45 to 3.4 * 10 38 0 float v= 2

6 double Very big real +/-4.9*10-324 to 1.8 * 10 308 0 double v =2

7 char Characters Unicode character set ‘’ char v = ‘A’

8 boolean True or False Not applicable False boolean v = false
int Data Type
■ This is a set of integer numbers (eg -753, 0, 87, +430 etc) together with
the associated operators that manipulate the integer numbers, operators
are +, -, *, %, / (/- integer division and %- modulus)
■ No commas are used within an integer number
■ The modulus operator(%): a%b evaluates to the remainder of a divided
by b.
■ The value of a%b has the same sign as a (e.g, 5%2 = 1; -23%3 = -2 %
extracts the smallest digit of an integer ( e.g 32657% 10 = 7 (the unit
value of the integer
■ Integer division (/) ignore the remainder and returns the integer part of
the quotient ( eg 11/4 = 2 because the remainder 3 is ignored)
Operator and Precedence in Integer
Expressions
Java Basic Arithmetic Operators include:
Symbol Meaning
+ Addition
- Subtraction
* Multiplication
Remainder
/ operator(%)Division
Operator %(Percent), returns remainder after division. It is referred to as modulus operator. E.g. 29 %
9 = 2, 6 % 8 = 6, 10 % 2 = 0
Other behaviours:
 y = x ++; means assign the value of x to y, then increment x by 1
 y = ++x; means increment x by 1, then assign this new value to y
 y + = x means y = y +x
 Operator Precedence in Integer Expressions
■ Java applies the law of precedence(priority rule) to the operation of
integer expression in a precise sequence as below:

Precedence Associativity
High
* / % Left to right
Low
+ - Left to right
Operators of equal precedence have left to right associativity.
E.g 8 – 4 + 3 = (8 - 4) – 3 = 4 + 3 = 7
If you want an integer number to be treated as long, you need to append an L to the
literal
e.g long y = 12345678987654321L

.
Double and Float (Data Types):
■ The double data type can be expressed in two ways:
a) Decimal notation (e.g 1.735, 7.320)
b) Scientific or exponential notation ( e. g 2.3E2)

Char Data Type:

The value of type char is enclosed in single quotes to give a character literal.
Example ‘A’ = 65 in ASCII coding system while ‘B’ = 66
Some characters that are not printable are denoted using the escape sequence “\”
If you need to denote a character by its Unicode value you use the escape sequence \u
followed by its Unicode value in hexadecimal format e.g. ‘\UF95’
Computers store characters as non-negative numbers.
Char Data Type contd:
Characters refer to the set of all characters found on the standard keyboard in
addition to other characters used for displaying text in other languages apart from
English.
A character can be treated as an integer, making it possible to perform arithmetic and
make comparisons between characters using “greater than” , “less than” operators.
The char data type is an unsigned data type.
Although an ASCII value requires just one byte of storage, Java uses the Unicode
character set and allocates two bytes of memory for each character.
This allows the Unicode character set to include not only English Characters but also
characters for many other languages such as Greek, Chinese, Arabic, Japanese and
Hebrew etc.
By design ASCII is a subset of Unicode so the character A has the same code 65 in
both ASCII and Unicode.
BOOLEAN DATA TYPE
■ The boolean data type has only two values; true and
false(which are also known as the logical boolean value)
■ The primary purpose of this data type is to manipulate logical
boolean expressions.
■ The associative operators are:
■ && and
■ || or
■ ! not
■ boolean operators gives the following results from x and y as
boolean expressions:
 The Boolean Table:
X Y X&&Y X||Y !X !Y
TRUE TRUE TRUE TRUE FALSE FALSE
TRUE FALSE FALSE TRUE FALSE TRUE
FALSE TRUE FALSE TRUE TRUE FALSE
FALSE FALSE FALSE FALSE TRUE TRUE

Relational operators: ( used to create Boolean expressions)

Operator Meaning
E.g:
<  Less than • 4 >3 is true
• 4<= 10 is true
<= Less than or equal • ‘A’ > ‘B’ is false
>= Greater than • (3/2 – 5%3 !=3) is true
>= Greater than or equal
== Equal to
Operator Precedence:
PRECEDENCE ASSOCIATIVITY OPERATOR TYPE
High
! Right to left unary
*/ % Left to Right Multiplicative
+- + Left to Right Additive,
concatenation

<, <=, >, >= Left to Right Relational

==, != Left to Right Equality
&& Left to Right and (associative)
Low
|| Left to Right or (associative)

This is about which is given priority in order of execution. User or

programmer should be conscious of this for program correctness.
MIXING DATA TYPES IN A NUMERICAL EXPRESSION

■ An expression is a sequence of symbols that represents a value.

■ Example: 60 + 24 is an expression
(operand) (operator) (operand) is an expression
■ When Java evaluates a binary expression with operands of different data
types it first promotes or casts the operand of the “smaller” data type to
the data type of the other operand (this is internal casting).
■ The number of bits of each data types determines the size.
Thus char data type (16 bits) is smaller than int data type( 32 bits)
MIXING DATA TYPES IN A NUMERICAL EXPRESSION
E.g. 1:
(22 + 3.0)/4 // first operand is int data type second is double while the third is also int
Evaluated as:
(1) The integer 22 is first cast to double to give
(22.0 + 3.0)/4
25.0/4
(2) The integer 4 is cast to double to give
25.0/4.0 a floating point division
E.g. 2:
‘A’ + 1.0
Evaluated as: 65 + 1.0 (‘A’= 65 in ASCII coding System)
65.0 + 1.0 (Integer 65 is cast to 65.0)
66.0 (a floating point addition)
Derived/Reference types
All non-primitive types are reference types, so classes, which specify the
types of objects, are reference types. A class for example is a concrete data
type that specifies an object state(s) and behavior(s).
Some Examples of Reference types are:
 Note on String Type:
■ String is a reference type. By definition, it is a sequence of characters
(value is usually within a double quote) which could be a combination of
alphanumeric or special characters. E.g. “John the Baptist”.
■ Java provides a String class that allows us to use and manipulate strings.
String name; // a string declaration
name = “makinde”; // assigning an initial value
■ Alternatively, you declare a String object by calling its constructor as
follows:
■ String name = new String(“makinde”);
■ Exercise:
Make an attempt to implement the following methods in String Class:
length, charAt, substring, Concat, toUpperCase, toLowerCase,
compareTo , equals, equalsIgnoreCase, startsWith, endsWith, trim.
Strings and Concatenation Operator(+)
■ If “A” and “B” are Strings, then “A+B” evaluates to another String. This is
concatenation(joining together).
■ E.g. “Jesus is Lord” + “Everyday” results into another string “Jesus is Lord
Everyday”
■ If only one operand is a String then the other operand is first cast to a String and
the value of the expression is the concatenation of two Strings. 1234 + “is an
integer” becomes “1234 is an integer”.
Here the integer 1234 is cast to the String “1234” and the two Strings are
concatenated.
■ In Java, every primitive data type being concatenated to a String will be
automatically converted to a new String object. This simplifies the process of
working with built-in data types (such as println) and displaying or outputting
such concatenated Strings.
Exercise: Evaluate the ffg. using println: “The sum of two numbers is” + 5 + 2