Java is a high-level programming language that has been around for
two decades and is still going strong. It is object-oriented, is platform
independent, has wonderful documentation and community support, is free, and is
everywhere – the moment you install Java, a screen generally comes up which
states ‘3 billion devices run Java’.
Java and coffee - the ultimate combination
Yes, you must find the ancient scriptures of Sun Microsystems to
learn a language, a language which, unknown to many, continues to flourish in
the twenty-first century, a language so precious its priceless (in more ways
than one), a language not lost in the sands of time.
Or, instead of finding those scriptures, you may read this blog
post, which shall unravel the deep, dark mysteries which surround this
language, the language called Java.
All right, enough adventure talk, let’s begin already.
We’re going to go through some basic programming concepts in Java,
namely variables, operators, selection, iteration and jump statements. If
you’re new to programming, you’d want to read this post with hardcore
determination, while if you’ve already done some non-Java programming in the
past, I’d recommend you quickly skim through this post to get a feel of the
language. And if you’re a Java developer, how about you go through this post
and let me know about errors, if any? :) Email manasdtrivedi@gmail.com
I’ve used the idea of ‘learning by example’ in this post. If you
don’t understand the theory of a section, say, increment/decrement operators,
then go through the example code for it, look at the output, and try to figure
out the reasons for said output. Since Java is quite close to the way we speak
in English, the code is generally pretty clear. But yes, if you indeed have
queries, you’re free to email me :)
Variables
Variables are named ‘boxes’ of a certain type, which hold values
of that type. For example, a fruit box called fruitBox1 will hold
a fruit in it, say a mango, or a jackfruit. Similarly, an integer variable
called num will store an integer in it, say 7 or -9 or 0 or 17395.
The way we declare and initialize variables in Java is as shown:
datatype variableName = value;
So, an integer variable called ‘num’ is
declared and initialized with the value 3 as:
int num = 3;
Here, ‘int’ is the datatype (i.e. the type of
the variable), ‘num’ is the name of the variable, and ‘3’ is the value put into variable ‘num’. In
simple terms, int num = 3 means
we’re putting the value 3 into an integer box (integer variable)
called ‘num’.
Note that the ‘=’ sign
doesn’t mean equality i.e. int num = 3 doesn’t
mean ‘num is equal to 3’. Rather, we’re inserting 3 into the
box called ‘num’. You can perhaps imagine replacing
the ‘=’ sign with a ‘<-’ (leftward arrow) to reinforce this idea.
A variable in Java can have any name, as long as it isn’t a
keyword, doesn’t begin with a digit, and is composed of only alphabets, digits,
underscore and/or dollar sign.
There are 9 types of variables in Java:
1.
Byte variables can store values from -128 to
127.
byte var1 = 25;
2.
Short variables can store values from -32768
to 32767.
short var_2 =
5678;
3.
Integer variables can store values from
-2147483648 to 2147483647.
int var$3 =
9999999;
4.
Long variables can store values from
-9223372036854775808 to 9223372036854775807.
long _var4 =
112233445566778899.
5.
Float variables can store values from ±
1.4E-45 to ± 3.4028235E+38.
float principal =
10.0F;
Note the ‘F’ at the
end of 10.0. That denotes a float.
6.
Double variables can store values from ±
4.9E-324 to ± 1.7976931348623157E+308.
double d = 20.0;
Note that this doesn’t need a ‘D’ or similar,
as was used for floats.
7.
Character variables store characters.
char ch = ‘A’;
8.
Boolean variables can store either ‘true’ or ‘false’.
boolean b = true;
9.
String variables can store zero or more
characters, like the name of an institute.
String institute
= “NIT Karnataka, Surathkal”;
Sometimes, we may want the String variable to
be empty. In that case, we can either initialize it with null, or with “” (i.e. empty string).
String username =
null;
String str = “”;
Operators
Java has a wide variety of operators, but we’ll be looking at only
a few of them.
1.
Arithmetic operators:
+ is used
for adding two operands.
double total =
100.0, tax = 10.0;
double grandTotal
= total + tax;
Here, grandTotal will be
assigned value 110.0.
+ is also
used for concatenating strings.
String str1 =
‘IE’, str2 = ‘NITK’;
String str3 =
str1 + “-” + str2;
Here, str3 will hold
the string “IE-NITK”.
- is used
for subtracting two operands.
int x = 1, y = 2;
int z = x - y;
Here, z will
store 1 - 2 i.e. -1.
* is used
for multiplying two operands.
short s1 = 3, s2
= 4;
short s3 = s1 *
s2;
Here, s3 will
store 3 * 4 i.e. 12.
/ is used
for dividing two operands.
double z1 = 5.0 /
2.0;
Here, z1 will
store 5.0 / 2.0 i.e. 2.5.
% is used
for finding the remainder upon dividing two operands.
int op1 = 10;
int op2 = 3;
int remainder =
op1 % op2;
Here, remainder will store
the remainder upon dividing 10 by 3, i.e. 1.
Little note: ‘returns’ in this blog post means
‘is replaced by’.
For example,
int a = 3 + 4;
Here, we say 3 + 4 ‘returns’
7. This means you can effectively
‘replace’ 3 + 4 in the above line of code with 7. So,
int a = 7;
‘returns’ actually means something else in
programming, but for now, this will do.
2.
Increment/Decrement operators:
Prefix form: Follows ‘change-then-use’ rule,
i.e. ++operand or --operand first
increments/decrements the value of operand, and then
returns the changed value of operand.
Example:
int a = 2, b = 2;
int c = ++a;
int d = --b;
After execution of above statements, a will store value 3, c will store value 3, b will store value 1, d will store value 1.
Postfix form: Follows ‘use-then-change’ rule,
i.e. operand++ or operand-- returns
the current value of operand and then increments/decrements operand. Note that the ‘changed’ value isn’t
returned, the value before changing is.
Example:
int a = 2, b = 2;
int c = a++;
int d = b--;
After execution of the above statements, a will store value 3, c will store value 2, b will store value 1, d will store value 2.
3.
Relational operators:
Here and beyond, op1 means first operand, and op2 means
second operand.
op1 > op2 returns true if op1 is greater than op2, else returns false.
op1 >= op2 returns true if op1 is greater than or equal to op2, else returns false.
op1 < op2 returns true if op1 is lesser than op2, else returns false.
op1 <= op2 returns true if op1 is lesser than or equal to op2, else returns false.
op1 == op2 returns true if op1 is equal to op2, else returns false.
op1 != op2 returns true if op1 is not equal to op2, else returns false.
Example:
int x = 3, y = 2,
z = 2;
boolean b1 = x
> y;
boolean b2 = 20
< 15;
boolean b3 = y
>= z;
boolean b4 = 12
<= 10;
boolean b5 = y ==
z;
boolean b6 = 10
!= 10;
Here, variables b1, b3 and b5 will hold value true, while b2, b4 and b6 will hold value false.
4.
Logical/Conditional operators:
op1 &&
op2
returns true if both op1 and op2 are true, else
returns false, checks op2’s value only if op1 is true.
op1 || op2 returns
true if any of op1 or op2 is true, else returns false, checks op2’s value only if op1 is false.
op1 & op2 returns true if both op1 and op2 are true, else returns false, always
checks both op1 and op2’s values.
op1 | op2 returns true if any of op1 or op2 is true, else returns false, always
checks both op1 and op2’s values.
op1 ^ op2 returns true if either op1 or op2 is true, but not both, else returns false.
!op1 returns true if op1’s value is false, else returns false.
Example:
boolean b1 = (3
> 2) && (2 < 1);
boolean b2 = !b1;
boolean b3 = b1
|| b2;
boolean b4 = b1 ^
b2;
Here, b1 stores false, b2 stores true, b3 stores true, b4 stores true.
Selection statements
Selection statements allow us to choose a set of instructions for
execution based on an expression’s truth value.
1.
if statement: Statements inside the if block get executed only if the condition evaluates to true. A ‘block’ is denoted by curly brackets i.e. ‘{’ and ‘}’. All
statements present inside the curly brackets are a part of one ‘block’ of
statements.
if…else
statement: Statements inside the if block get
executed if the condition evaluates to true, else the
statements inside the else block get executed.
Example:
int x = 5, y = 5,
z = 4;
if (3 > 2) {
System.out.println(“3 is greater than
2.”);
}
if (x > y) {
System.out.println(“x is greater than
y.”);
}
else if (x <
y) {
System.out.println(“x is less than y.”);
}
else {
System.out.println(“x is equal to y.”);
}
if (y >= z) {
if (y > z) {
System.out.println(“y is greater
than z.”);
}
else {
System.out.println(“y is equal to
z.”);
}
}
else {
System.out.println(“y is less than z.”);
}
Here, the output window displays the following
output:
3 is greater than
2.
x is equal to y.
y is greater than
z.
2.
switch statement: This statement tests the
value of an expression against a list of integers or characters. Upon finding a
match, the statements associated with that integer or character is executed. If
no match is found, the statements associated with the default label (if exists) is executed. It is
generally a good idea to have a default label.
Example:
int dayOfWeek =
8;
char language =
‘J’;
switch (dayOfWeek)
{
case 1: System.out.println(“Monday”);
break;
case 2: System.out.println(“Tuesday”);
break;
case 3: System.out.println(“Wednesday”);
break;
case 4: System.out.println(“Thursday”);
break;
case 5: System.out.println(“Friday”);
break;
case 6: System.out.println(“Saturday”);
break;
case 7: System.out.println(“Sunday”);
break;
default: System.out.println(“Invalid day
of week.”);
}
switch (language)
{
case ‘C’: System.out.println(“Language
selected is C.”);
break;
case ‘+’: System.out.println(“Language
selected is C++.”);
break;
case ‘J’: System.out.println(“Language
selected is Java.”);
break;
case ‘P’: System.out.println(“Language
selected is Python.”);
break;
default: System.out.println(“Invalid language
selected.”);
}
Here, the output window displays the following
output:
Invalid day of
week.
Language selected
is Java.
Iteration statements
These statements (called ‘loops’) are used to execute a set of
instructions (the body) repeatedly as long as the value of an expression is true. These statements generally have four parts: the initialization
(where the control variable is initialized), the expression (whose truth value
decides whether the body will be executed), the updation (which updates the
control variable), and the body of the loop.
1.
for loop: The first three elements of the
loop (initialization, expression, updation) are gathered at the top of the loop
(generally). The expression is first checked, then the body is executed if the
expression is true.
Example:
for (int x = 1; x
<= 2; x++) {
System.out.println(“Value of x is ” + x +
“.”);
}
Here, x is first
initialized as 1. The expression x <= 2 is checked. It is true, so the body is executed. Now, the updation x++ takes place. x is now 2. The
expression x <= 2 is checked. It is true, so the body
is executed. Updation x++ takes place once again. x is now 3. The expression x <= 2 is checked. It is false. So, the loop is exited.
The output window displays the following
output:
Value of x is 1.
Value of x is 2.
We can also skip one or more of the three
elements at the top of the for loop. For example, for(; x <= 2; x++) {…} is perfectly legal, as long as x is declared and initialized somewhere above the loop. Note that
although the initialization expression was removed, the semicolon
wasn’t!
2.
while loop: It is pretty similar to an if statement in the sense that the body of the loop is executed if
the expression evaluates to true. The
initialization of the loop control variable (if any) is somewhere above the
loop, and the updation (if any) is generally a part of the body.
Example:
int k = 2;
while (k > 0)
{
System.out.println(“k is greater than
zero”.);
k--;
}
System.out.println(“k
is now zero.”);
Here, k is
initialized to 2. The condition k > 0 is checked. It is true, so the body is
executed. In the body, the updation k-- occurs. k becomes 1. The condition k > 0 is checked again. It is true, so the body is
executed. k-- occurs, k becomes 0. Now the condition k > 0 is checked, which returns false. So, the loop
is exited.
The output window displays the following
output:
k is greater than
0.
k is greater than
0.
k is now 0.
3.
do-while loop: Here, the loop control
expression is evaluated after the body is run, and its truth then determines
whether the body is to be executed again. The initialization (if any) is above
the loop, and the updation (if any) is generally a part of the body.
Example:
int x = 0;
do {
System.out.println(“Saluton Mondo!”);
x--;
} while (x >
0);
Here, x is
initialized with the value 0. The body is run. The updation x-- takes place, x becomes -1. Then the expression x > 0 is
tested. It is false. So, the loop is exited.
The output window displays the following
output:
Saluton Mondo!
Loops can also be nested, i.e. a loop can be written inside a
loop.
Jump statements
They are used for unconditional ‘jumping’ i.e. going to a certain
part of the code without any condition. We’ll look at two of these: break and continue.
1.
break statement: It is used to terminate
the execution of the loop. The control immediately jumps to the code after the
loop.
Example:
int x = 1;
while (x < 5)
{
System.out.println(“Incoming break
statement!”);
break;
x++;
}
System.out.println(“We’re
now outside the loop.”);
After entering the loop, the break statement is encountered, and we directly go to the statement
after the loop. The updation x++ never
occurs.
The output window displays the following
output:
Incoming break
statement!
We’re now outside
the loop.
2.
continue statement: It is used to directly go
to the next iteration of the loop, skipping any statements left to be executed
in the body.
Example:
for (int x = 1; x
<= 3; x++) {
if (x == 2) {
continue;
}
System.out.println(“x is now ” + x + “.”);
}
Here, x is
initialized to 1. The condition x <= 3 is evaluated to be true. Hence, we enter the body. x is not 2, hence the continue statement isn’t executed. ‘x is now 1.’ is printed. Updation takes place, x becomes 2. The condition x <= 3 is evaluated. It is true. So, we enter the body again. This time x is indeed 2, hence the continue statement is executed. The rest of the body
isn’t executed, we directly jump to the next iteration. Updation takes place, x becomes 3. Condition x <= 3 is yet again true. We enter
the body once again. Since x isn’t 2, the
continue statement isn’t executed. “x is now 3” is
printed. Updation: x becomes 4. Now the condition x <= 3 is false, hence we exit the loop.
The output window shows the following output:
x is now 1.
x is now 3.
Reached this far? Congratulations! You now have a very sound
knowledge of the basics of Java, which we’ll require soon.
Soon?
Yes, I’m going to write another blog post with deals with creating
interactive Java applications which have components like buttons, textfields,
and checkboxes.
Stay tuned for Episode 2 of the Intellicenter Java series!
