Professional Documents
Culture Documents
Java Lab Manual: Al-Quds University
Java Lab Manual: Al-Quds University
5. Under operation field, write public_html and click on MkDir button, by doing this,
you are creating a folder named public_html, this is the folder in which you will put
your web pages.
6. Click on public_html to open it. It is now the current working directory.
7. Inside public_html, create another folder called lab1.
After preparing your Webdisk, you are ready to create a web page and upload it, to create a simple
HTML page, follow the following steps:
1. Start the notepad from Start --> All Programs --> Accessories --> Notepad (or simply type
notepad in the run dialog Start --> Run)
2. Enter the following text:
<html>
<body>
<h1> This is a Major Heading </h1>
<ul>
<li> List item one
<li> List item two
</ul>
</body>
</html>
3. Save your file as index.html
4. Back to Webdisk, under upload field, browse for your file (index.html) and click on Upload
to upload your file to the server, make sure to upload it inside lab1 folder.
5. Using browser, confirm page at http://mail.alquds.edu/~s999/lab1 (where s999 should be
replaced by your student profile login id).
The table that resulted from the above code is shown in figure 1.1 below.
To link two pages together, we user the Hyperlink, to create a Hyperlink to another HTML page,
use the following syntax:
Exercises
1. Create a page named index.html and upload it to “lab1” folder in your public_html
directory.
2. Modify index.html by adding
a. A table,
b. A Hyperlink to university's homepage (http://www.alquds.edu), and
c. At least one image.
Introduction to Java
Objectives:
● Introduce programming languages.
● Introduce Java programming language.
● Show how to set up your system environment for Java development.
● Write, compile and run your first Java application "Hello World".
After downloading the installation file (about 60 MB) you are ready to start the installation process.
Follow the following procedure to prepare your machine.
Step 1: Double click on jdk-1_5_0_06-windows-i586-p.exe icon, the setup wizard appears as in
figure 2.2.
Select I accept the terms in the license agreement and click on Next. Custom setup dialog appears as
in figure 2.3.
It is advisable that you change the installation path by clicking on Change button and selecting the
path "C:\jdk" as installation directory. After you have done changing the path, click on Next to start
the installation and wait until its done. When installation is complete, click on Finish to terminate
installation wizard.
To add new environment variable, click on New button in User Variables field, note that you may
not modify system variables unless you have administrator privileges. Once you click on New
button, variable addition dialog appears as in figure 2.6.
In Variable name field enter the name of your variable, in Variable value field enter the value of the
variable then click on OK. You need to add two variables to use with JDSK:
● PATH: points to bin directory in JSDK home directory (e. g. c:\jdk\bin)
● CLASSPATH: points to the folder in which you will create you Java programs (e. g.
c:\Documents and Settings\Student\Desktop\java).
Your computer is ready now to be used for Java development.
To write a new Java program using the notepad, enter the command notepad filename. For
instance, we will write a class named HelloWorld, so we will use the command notepad
HelloWorld.java (Figure 2.8). Note that we use a .java extension for all Java source files, and we
always use upper case characters in the beginning of a class name. After starting the notepad, it will
In the notepad, write the following code (always keep in mind that Java is case-sensitive language,
for example if you typed Class instead of class the compiler will report a syntax error)
//HelloWorld.java
/* This is my first java program.
*/
class HelloWorld{
public static void main(String[] args){
System.out.println("Hello World!");
System.out.println("How r u 2day?");
}//end of main method
}//end of class
When you are done with code writing, save the file and exit notepad.
Your source code file is now ready for compilation, to compile a Java source code file, use the
command javac filename. In our example, javac HelloWorld.java. If everything is alright, the
compiler will terminate without any messages and go back to command prompt as shown in figure
2.9. After compilation, if you run dir command, you will notice that the compiler generated a new
file called HelloWorld.class, this is the binary file JVM will execute. To run you application, use
the command java ClassName , for our program, we will use java HelloWorld, if everything is
alright, you shall see the program output on the screen.
Notice that some lines in the program begin with //, these are called comments, compiler does not
read comments, so whatever your write in them it will not affect the functionality of your program,
the notations /* and */ declare the beginning and ending of a block of comments, so we call them
multi-line comments.
Lab Extras
Batch files are common in executing a series of shell commands, for example,
you can write a batch file to create and delete folder instantly, by writing the
appropriate commands in the notepad and saving the file with .bat extension. The file
will look like the following:
MD MyFolder
RD MyFolder
Note that we put each command in separate line. You can create a Java program that
runs everywhere by putting it together with a batch file that does the following steps:
1. Adds the current folder to CLASSPATH by using the command
SET CLASSPATH=.
2. Compiles the .java file.
3. Executes the program.
Try to write a batch file that holds your name and runs a Java program that types your
name on the command line. Add PAUSE command at the end of the batch file in order
to freeze the screen after program execution to be able to see the results.
Programming IDE
Languages
Java ● NetBeans
● Forte for Java
● Borland JBuilder
C/C++ ● Microsoft Visual Studio
● Borland C++
PHP/JSP/ASP ● Macromedia Dreamweaver
ASP.NET ● Microsoft Visual Studio .NET
● Sharp Develop
We can notice from table above that we have various brands of IDEs, since we are interested
in Java programming language in this course, we will focus on its IDEs. NetBeans is the best
offered IDE for us as Java learners, because it is free compared to JBuilder, more advanced
and stable compared to Forte. So lets start having a look at NetBeans.
To use NetBeans for writing and running your Java programs, Follow these steps:
1. Create a new project by going to File > New Project, or by clicking on New Project
button on the toolbar; all programs written using NetBeans must be included in
projects to be able to be compiled and run. Project creation is a simple process consists
of two steps. First step is defining project category and type. In our case, we leave
the default settings, that is, General category and Java Application type. Second step
is specifying project name and main class.
2. After creating a project, you are ready to start coding, on the project explorer you
will see a tree that has the project name you specified as root. Project is split into four
folders: Source packages, Test packages, Libraries and Test libraries. Source
packages is the folder containing the source code files (.java files) and hence it is the
folder we are interested in. Source code is usually split into packages, so we can group
classes of related functionality together. Once you create a project, a default package
that holds project name is created.
3. In the code editor, you will see the created Main class, with its main method already
coded, so you need just to start programming.
4. In the main method, try to write some statements you've learned from session 1, after
you are done, you may compile and run the program by selecting Run > Run main
project, pressing F6 key on the keyboard, or clicking Run button on the toolbar
5. The output window appears at the bottom of the IDE and shows the outputs of
compilation and running processes.
To show how debugging works, make a small test by following the procedure below:
1. Write the HelloWorld program from session 1.
2. Add a break point in the second line (System.out.println("How r u
2day?");).
3. Debug the program by pressing F5 key on the keyboard or by clicking on Debug
button on the toolbar.
4. Observe the output of the program, what do you notice?
5. Notice that when debugger reaches a break point, it turns to green, this means that this
is the next statement will be executed, as we put a break point on the second line, the
statement is not executed until we select to continue, this can be done by pressing Ctrl
+F5 or by clicking on Continue button on the toolbar.
6. To stop debugging, press Sift+F5 on the keyboard, or click on Stop button on the
toolbar.
1. System.out.println("Hellow")
2. system.out.println("Hello");
3. System.out.println("Hello);
4. class Hello World{
5. Class HelloWorld{
6. public Static void main(string[] args){
OK, let's start with statement 1, what is wrong with it? Clearly Hello don't have "w" at the end
of it! However, this is not the error we are looking for, we are looking for violation of Java
language rules not English language rules. As we know, each statement in Java should be
terminated with semicolon ";" which is absent in our case. The message the compiler will
generate in this case is "';' expected", error message also includes the line in which
error exists as shown in figure 3.3.
In statement 2, you can notice that system is written in lower case, as we've learned before,
Java is case sensitive, and as System is a class in Java, it starts with upper case letter. The
message you will see in this case is "Cannot find symbol". This message means the
keyword or member name you are calling is not recognized as valid one. The most common
reason for this error is a spelling mistake.
In statement 3 , the error message is "unclosed string literal", because the
opening double quotation (") does not have a matching closing one.
In statement 4, the error is that the given class name is not valid, as class name cannot have
spaces according to naming conventions in Java (as we shall see in next session). The error
message in this case is "'{' expected", the compiler assumes that class name finishes
when it finds space, after the space it is expecting the opening bracket "{".
In statement 5, the message generated is "class or interface expected", it is clear
that class keyword must start with lower case letter as all keywords in Java do so.
In statement 6, the message generated is "<identifier> expected", because Static
is not a valid keyword. Notice that in this statements we have another error which is
"cannot find symbol" because string is written mistakenly in lower case, but it will
not be detected until first error is fixed because it appears first.
Run-Time errors appear when program run, the compiler cannot detect them because there are
no errors or rules violations. First category of run-time errors is exceptions, exception is a non
expected error happens while executing a code, an example of exceptions is
Exercises
1. Create a project using NetBeans called MyFirstProject, and type a program to print
your name and student ID each in separate line using only one println statement.
2. What is the error message expected from each of the following statements? (Also
show if there is more than one error, and mention which one is detected first)
1. System.out.println(Hello World!);
2. System.out.pint("How are you?");
3. public static void main(String[] args);{
4. class My Class{
5. public static void main(String() args){
6. System.out.Print ln("Hi man!");
7. System.out.print('What's up');
8. System.out.println("I wonder where is the error?\m");
Lab Extras
You can add a new class to your default package and make it the default class to be
run instead of Main class. To do this, right-click package in the project explorer, open Add
menu and select Java Class from the list. Enter new class name and click OK to see your
newly added class. Note that the Main class is still open and you can navigate between two
class using tabs above source editor.
To make your new class the default one (that is, it will run when you run the project), right-
click the project icon (Java cup) in the project explorer and select Properties from the menu.
This will open up Project Properties dialog. From the tree on the left, select Run category,
and type your class name in place of Main in Main Class text field. Be ware not to delete
package name mistakenly.
Now type a main method in your new class and put some code in it, run the project and you
will see the result. You may also run a non-default class by right-clicking it in the project
explorer and selecting run or using Shift + F6 keys while opening its code in the editor.
datatype variableName;
Data type is one of primitive data types shown in table 4.1, variable name is a valid Java
In addition to previous conditions, we have some optional conventions but they are highly
recommended to follow them in order to stay up with the global standards of Java. One of
these conventions is to start class name (and each fragment in the name if it has more than
one) with an upper-case letter like ClassName and MyFirstJavaClass. We will be
talking about conventions as they appear. Here are some examples of declaring data types:
int anInt;
double d;
float average;
boolean done;
long x1, x2, x3;
As you can see, the first part is a primitive data type from table 4.1, and the second type is a
valid name. You can notice from the last statement that we can define several variables of the
same type by using commas ',' between names on the following format:
A notable naming conventions in Java is the one we've used in the first statement, a variable
name should start with a small letter, and each following fragment with a capital letter like
variableName and averageOfMarks.
So whats next? We have to assign some values in the variables we have just declared. Value
and variable must be of the same type, for example, you cannot store 7.34 in a variable of
type int (unless you convert). Table 4.2 shows examples of values and their appropriate
data types.
variable = value;
int x;
x = 10;
Assignment can be done in the same statement in which we declare the variable
We have seen assignment before, and we know that is stores the value of right operand on the
variable on the left operand. Addition, subtraction, multiplication and division operations
generate expressions, an expression is a series of calculations that produces a single value.
Here are some examples of expression:
We have some shortcuts with binary operations, for example, expression a = a + b, could
be written in the form a += b, this way is valid for other operations as table 4.4 illustrates.
Expression Shortcut
a = a + b a += b
a = a - b a -= b
a = a * b a *= b
a = a / b a /= b
a = a % b a %= b
a = a + 1 a++, ++a
a = a – 1 a--, --a
Table 4.4: shortcuts of expressions
The difference between a++ and ++a is the value of the expression itself; at the end, both of
them increment the value of a by one, but the value of a++ when evaluated is the original
value of a, and the value of ++a is the incremented value. The following example shows the
difference.
int a, b, c;
a = b = c = 1;
a = ++b + c;
System.out.println("a = " + a + ", b = " + b + ", c = " + c);
b = a++ - 1;
System.out.println("a = " + a + ", b = " + b + ", c = " + c);
c = a + a++ + --b + b;
System.out.println("a = " + a + ", b = " + b + ", c = " + c);
If you compile and run the above program, you should see the following output:
a = 3, b = 2, c = 1
a = 4, b = 2, c = 1
a = 5, b = 1, c = 10
Discussing the difference between && and &, and | and ||, when we use && or ||, op2 is not
evaluated when the value of the whole expression could be determined by the value of op1 and the
operation. For example, true || false expression does not evaluate the second operand,
because the logical OR between true and any other boolean expression is always true, similarly,
false && true does not evaluate the second operand because logical AND between false
and any other boolean expression is always false.
In addition to these operations, there are also comparison operations which we apply to numerical
variables to get boolean results, table 4.6 shows comparison operations.
The following example evaluates some boolean expressions and prints their results.
Once again, we have used concatenation to convert the whole output to string, the next section
focuses more on conversion.
i = 1;
f = 4.4f;
d = 5.5;
d = i;
i = (int)f;
f = (float)d;
Another way to convert between variables is using some defined methods that converts between
variables. One of them is a well known method that converts a String to integer which is
Integer.parseInt() method, the following example shows how to use it.
String s = "115";
int x = Integer.parseInt(s);
x++;
System.out.println(x); //prints 116
int x = 10;
String s = "x equals " + x;
In the above code, the value of x which is 10 is converted from integer to string and concatenated
with the previous string "x equals ".
Promotion also occurs when an expression of values from different types is evaluated. In general,
promotion converts all operands to the largest data type among them. The following code shows an
example.
int x = 10;
double d = 12.5;
float f = 1.5f;
If you run the above code, you will see the output “The result is 18.33333333”. The expression was
evaluated as the following:
1. The value of f is converted to double and d/f is evaluated, clearly, the result is of type
double.
2. The value of x is converted to double and added to the previous expression.
3. The whole expression is evaluated to type double And stored in result.
Expression: expressions are evaluated in runtime to generate a single value, for example,
the expression 1 + 3 – 5 evaluate at runtime and generate a final value of -1.
Methods: Some methods returns a value of certain type, one of them is the previously
discussed parseInteger() method which returns an integer generated from some string.
Lab Extras
Some variables are declared using final keyword, final means that the value remains
constant at the time of execution and it is assigned during compile time. The value of a final
variable cannot be modified once it is assigned. The final keyword is used before specifying data
type in variable declaration.
It is important to realize that you can assign a value to a final variable only once. You can only
assign the value in the same statement in which you define the variable, so the following statements
are invalid.
As you can see, the naming convention of final variables is to use upper letters and underscores "_".
The highlighted part is the most important tag in out page, <applet> tag tells the browser where
to add the Applet, code property specifies the name of the class from which the Applet should be
loaded. Saying it again, the name of the class, not the name of the file, so don't add the extension
.class to the name.
When you open the web page, and everything is alright, you'll get the result shown in figure 5.1
below.
(0, 0) x+
(50, 25)
y+
(getWidth(),
getHeight())
Figure 5.2: Coordinations of Applet
As you can see, the upper-left corner has the coordinates (0, 0). The value of x increases from left to
right, and the value of y increases from up to down. So to locate the point (50, 25), start from the
upper-left corner and take 50 pixels to right then 25 pixels downward. To get the width of the whole
Applet, call getWidth() method, to get the height of the whole Applet, call getHeight()
method.
Exercises
1. Write the HelloApplet class and compile it.
2. Create a web page to run HelloApplet.
3. Create a new folder in your public_html folder on Webdisk named lab2 and upload
HelloApplet.class and the web page into it.
4. Run your Applet from the web.
if(condition){
//statement(s) to be executed if the condition is true
}
int x = 5;
if(x > 0){
System.out.println("x is positive");
}
else{
System.out.println("x is negative");
}
Notice that we use else block to enclose statements that we want to perform if the condition is
NOT met. The problem of the above statement is that 0 is considered negative. To solve this
problem, we can use >= operator instead of >, but if we wish to detect 0 itself, we can use nested
if statement inside the block of else as follows:
int x = 5;
if(x > 0){
System.out.println("x is positive");
}
else{
if(x == 0){
System.out.println("x is zero");
}
Using technique like on in the above example may make the code more complex and harder to
understand, instead, we can use else-if statement, by which we can check unlimited number of
condition, and making decision for each one separately. The format of if-else statement is the
following:
int x = 5;
Using else before each if statement means that if one of the conditions is met no other condition will
be checked.
Before using BufferedReader, be sure to import the library which contain this class, this library
is called java.io, in order to import it, we use import statement as follows.
import java.io.*;
By using character * here we identify that we import all classes in this library. import statements
are used before class definition.
To use BufferedReader class, you need to deal with the exception it throws through
readLine() method which is IOException, for instance, we will do this by changing the
definition of main() method to throw that exception.
Butting it all together, a simple program that reads user name and prints it on screen.
class ReadFromUser{
public static void main(String[] args)
throws IOException{
String userName;
BufferedReader in;
in = new BufferedReader(
new InputStreamReader(System.in));
The above code asks the user to enter his name, reads the input using readLine() method which
returns a String value that represents user input from keyboard, then concatenates it with
"Welcome" and prints it on the screen.
import java.io.*;
class Numbers{
public static void main(String[] args)
throws IOException{
BufferedReader in;
in = new BufferedReader(
new InputStreamReader(System.in));
int x;
String userInput;
x = Integer.parseInt(userInput);
if(x == 0){
System.out.println("zero");
}
//x is positive
else if(x > 0){
As you can see, we converted the String we read from user to integer because it is easier to
compare, another reason may lead us to this conversion, is that switch-case statement accepts
only integers and numerical values or characters, and it cannot accept strings. The following section
covers switch-case statement.
switch(variable){
case value_1:
//Statement(s) to be executed if
//variable = value_1
break;
case value_2:
//Statement(s) to be executed if
//variable = value_2
break;
.
.
.
case value_n:
As you can see, we put some variable in switch then follow it by several case blocks. Execution
goes through cases one by one comparing each one with the value of the variable specified in
switch statement, then executes it and all cases that follows, unless we use break keyword to
avoid the execution from expanding to unwanted statements. The following example shows how to
use switch-case statement.
import java.io.*;
class SwitchCaseDemo{
public static void main(String[] args)
throws IOException{
BufferedReader in;
in = new BufferedReader(
new InputStreamReader(System.in));
int choice;
choice = Integer.parseInt(in.readLine());
switch(choice){
case 1:
System.out.print("Enter your name: ");
String name = in.readLine();
System.out.println("Welcome " + name");
break;
case 2:
System.out.print("Enter your age: ");
String age = in.readLine();
System.out.println("You are " + age);
break;
case 3:
System.exit(0);
}//End switch
}//End main
}//End class
The following code shows how cases are executed, the following program enters all cases.
You can notice that the value of x meets the first case only, but all three cases are executed, this
states that switch-case statement does not automatically exit after one a case value is met. So
the output of the previous code is the following:
x = 1
x = 2
x = 3
To prevent such behavior, use break statement after the end of each case, which exits the whole
switch block.
A special case that is executed without checking the value of the variable is called default case, we
use default keyword instead of case keyword to specify the default case. Because we usually
use break after each case, default block is executed when the value of the variable did not match
any of specified cases value. To see how this works, add a default case to our previous
SwitchCaseDemo class (shown in boldface) and try to enter any value other than 1, 2 and 3.
switch(choice){
case 1:
System.out.print("Enter your name: ");
String name = in.readLine();
System.out.println("Welcome " + name");
break;
case 2:
System.out.print("Enter your age: ");
String age = in.readLine();
System.out.println("You are " + age);
break;
case 3:
System.exit(0);
default:
//User did not enter 1, 2 or 3
System.out.println("Invalid choice");
}//End switch
2. The sum is 7
3. Write a program that asks the user to enter two numerical values (integers) and then select
an operation (addition, subtraction, multiplication and division) then prints the result based
on operation selected. The code below shows examples of the output (text shown in
boldface is supposed to be user input).
1. Addition (+).
2. Subtraction (-).
3. Multiplication (*).
4. Division (/).
The result is 8
Lab Extras
There is an easier way to read from user, which depends on showing a dialog box for the
user and let him enter his input in a text box inside that dialog. To use this input dialog we import
the library called javax.swing, this library contains classes that deal with GUI. What we
interested in among the classes of this library is a class called JOptionPane and a method inside
it called showInputDialog(). The following example shows how to use this technique to read
from user.
import javax.swing.*;
class EasyRead{
You can notice here that we do not declare any objects and no exceptions to throw. An easy and
straight forward method. The output of the above code is a dialog box like the image 7.1.
If user clicks OK the input is read and returned as String, if he click Cancel dialog box closes
without returning any input entered.
Decision-Tree Applet
Objectives:
● Adding user controls to Applets.
● Handling events of user controls.
● Reading and writing values to user controls.
● Including external packages.
The second step is to declare the controls variables. These controls have data types just like
primitive data types discussed in session 3 but their initialization is slightly different. For example,
if we want to add a button and a text field to our Applet, we use code like the following.
Button b;
TextField t;
Notice that these types start with upper-case letter, unlike primitive data types. It is important to
realize that you need to declare these variables outside init(), in other words, they should be
declared directly inside the class body.
Up to now, we have just declared these controls, this means that we have reserved the variables
names for them, but they does not actually exist. The initialization step is the one which makes
them really exist. It is advisable that you initialize these controls at the beginning of init()
method.
As the above code shows, we use the new keyword to initialize the controls. The statement that
follows new keyword is a call to the constructor, which is a special type of methods written
specifically to initialize objects. Don't bother yourself with it now.
The string we pass to Button constructor is the text we want to appear on it. Similarly, the text we
pass to TextField constructor is the default text that will appear in it.
We have now declared and initialized controls, the step left is to add these controls to the Applet.
Although these controls are declared inside Applet's class, they are not graphically added hence not
yet visible to the user. To make them visible, we add them to the Applet using add() method.
Code below shows a full example.
//Step 1: import
import java.awt.*;
import java.applet.Applet;
Next, we need to alter the definition of our class, in addition to being Applet, our class should now
serve as ActionListener, that is, being able to handle actions raised by controls (mainly
buttons). So the definition of the class will be the following.
public class MyApp extends Applet implements ActionListener
Notice the addition (implements ActionListener) at the end of the class definition. This
addition requires you to write a new method called actionPerformed().
public void actionPerformed(ActionEvent e){
One thing left, letting the current Applet be the event handler for buttons we have added, this is
achieve by calling addActionListener() from button's object.
//Assume that Button b is already defined...
b.addActionListener(this);
Your Applet is ready now for event handling, but how? When user clicks on a button, the method
actionPerformed() is executed. The following code shows how can you decide which button
was clicked (modified version of SimpleApplet). Modifications are shown in boldface.
//Step 1: import
import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
You can also use a control name Label to add text labels to the Applet.
Label l = new Label("Some text");
add(l);
Button Job
Set Reg Sets register int field to 0
Set Accum Sets accumulator int field to 0
Add Sums the values in register and
accumulator and leaves the result in
accumulator
Power Raises accumulator value to the power
of the value of register leaving the result
in accumulator
Lab Extras
You can specify the width of text field by providing the number of columns in the constructor. For
example, the following code creates a text field with 20 columns width.
TextField t = new TextField(20);
TextArea a = new TextArea(20, 20; //Text field with multiple lines
while(condition){
//Statement(s) to execute as long as condition is true.
//Also known as loop body.
}
class Loops{
public static void main(String[] args){
1
2
It is clear that the value of x affected the execution of the loop, as you can derive from the output,
the condition is true until x reaches 11. We can also use break to exit the loop.
int x = 1;
while(true){ //infinite loop
System.out.println(x);
if(x == 10){
break;
}
}
using break in the above code exits the loop when x = 10.
The do-while loop like while loop uses boolean expression to determine whether or not go to
next iteration. The difference between it and while loop is the sequence of execution, do-while
loop body appears before the condition, this implies that even if the condition is false, the loop will
execute at least one time. The format of the do-while loop is the following.
do{
//Loop body
}while(condition);
if we repeat the last example using do-while, the code will look like this:
int x = 1;
do{
System.out.println(x++);
}while(x <= 10);
The output will be the same of previous example. So how can we clearly see the difference?
Consider the following two loops.
//while //do-while
int x = 0; int x = 0;
To better understand the concept of for loop, write and execute the following program.
class ForLoopDemo{
public static void main(String[] args){
Another example of for loop is the program that prints out the results of multiplications from 1 to
12.
class MultiplicationTable{
public static void main(String[] args){
In the above example, we used nested loops, that is, a loop inside the body of another loop, we can
use as many levels of nesting as we need. Be ware that when we use nested loops, the inner loop
executes until the end in one iteration of the outer loop, because the whole inner loop is one
statement in the body of outer loop.
Combining loops and conditional statements, we can build powerful applications that do complex
jobs. For instance, we will create a program that determines whether a given number is a prime or
not.
import javax.swing.*;
class Prime{
public static void main(String[] args){
int x;
String userInput;
userInput=JOptionPane.showInputDialog("Enter a number");
x = Integer.parseInt(userInput);
//1, 2 and 3 are prime numbers
if(x == 1 || x == 2 || x == 3){
System.out.println(x + " is prime");
}
//All even numbers > 2 are not prime
else if(x % 2 == 0){
System.out.println(x + " is not prime");
}else{
//We have to check using division remainder
//we initially suppose that x is prime
boolean prime = true;
//No number has factor greater than it's half
for(int i = 3; i <= x / 2; i++){
if(x % i == 0){
//We have found a factor
//so x is not prime
prime = false;
break;
}
}
if(prime){
System.out.println(x + " is prime");
}
else{
System.out.println(x + " is not prime");
}
To get more familiar, try to understand the following program that keeps reading numbers (integers)
from user until input is 0, then prints average, sum, maximum and minimum.
import java.io.*;
class Numbers{
public static void main(String[] args) throws IOException{
int min, max, x, sum = 0, count = 0;
boolean firstNumber = true;
BufferedReader in =
new BufferedReader(
new InputStreamReader(System.in));
while(true){
System.out.print("Enter a number: ");
x = Integer.parseInt(in.readLine());
if(firstNumber){
min = max = x;
firstNumber = false;
}
sum += x;
count++;
}
In the previous code, x has scope inside and outside if block, while y is only visible inside if
block, if you try to call y from outside if block, you will get error message "Cannot resolve
symbol".
int x = -3;
if(x < 0){
int y = x * -1;
}
System.out.println("Absolute value of " + x + " is " + y); //Error
Variable scope extends from outer block to inner blocks regardless of the number of levels, but not
vise-versa.
//Visible: None
for(int i = 1; i <= 12; i++){
//Visible: i
int k = i * j;
System.out.println(i + " * " + j + " = " + k);
}
//Visible: i
}
//Visible: None
Exercises
1. Write a program that reads 10 numbers from the user then prints out how many positive
numbers and negative numbers user has entered (consider 0 a positive number).
2. Modify calculation program in session 4 exercise 3 by adding the following question at the
end of the program:
If user selects yes (by entering 1), program will ask him again to enter new two numbers and
select operation, if user selects no (by entering 2), program exits. Use appropriate loop to
accomplish this.
3. Write a program that asks the user to enter certain number, after that asks him to enter
Lab Extras
We use continue keyword to skip some statements inside loop body and start new
iteration, consider the following program that prints out factors of 30.
As you can see, when 30 is not divisible by i, we use continue to jump to the next iteration
without executing the next line that prints the output.
As Figure 9.1 shows, the size of an array is fixed, we will refer to array maximum size as array
length, it is also clear that indices of an array are zero-based, that is, they start from 0 to length – 1;
for example, the array shown in Figure 9.1 has a length of 10 (stores up to 10 elements), and the last
index is 9.
DataType[] arrayName;
To initialize the array, use new keyword and specify the length.
If you try to access an index out of the range of array (greater or equals array length) JVM will
throw an IndexOutOfRangeException.
Another technique to declare an array is to directly provide its members between brackets { and },
separated using commas ','.
It is common to deal with arrays using for loop, we can use length property to determine the
length of the array. The following code stores multiples of 3 in an array then prints them from
greater to smaller.
The following example stores names and numbers of n students and performs search.
import javax.swing.*;
class Students{
public static void main(String[] args){
int[] numbers;
String[] names;
String input =
JOptionPane.showInputDialog("Enter number of students");
/* Now we have all numbers and names, index will bind two
arrays together, that is, student in index 5 has his name
in names[5] and his number stored in numbers[5] */
if(!found){
JoptionPane.showMessageDialog(null, "Not found");
}
input =
JoptionPane.showInputDialog("Search again? Y/N");
}while(!input.equalsIgnoreCase("N"));
}
}
DataType[][] arrayName;
arrayName = new DataType[rows][columns]
//Print array
for(int i = 0; i < x.length; i++){
for(int j = 0; j < x[i].length; j++){
System.out.print(x[i][j] + " ");
}
System.out.println("");
}
You can see from the previous example that we deal with each element in the array as array itself,
for example, we call x[i].length, this means that x[i] is an array of integers that may has its
own length, because it is not necessary that all rows have the same number of columns. The
following example shows that.
int[][] a = {
{0}, //a[0]
{0, 1}, //a[1]
{0, 1, 2}, //a[2]
{0, 1, 2, 3} //a[3]
};
0
0 1
0 1 2
0 1 2 3
As you can see, we filled the array above with sub-arrays. Two dimensional arrays are common in
representing matrices, for example, we can write a program that adds two matrices (remember that
matrices must have same number of rows and same number of columns when it comes to addition).
import javax.swing.*;
class Matrices{
public static void main(String[] args){
String input;
int rows, columns;
input =
JOptioPane.showInputDialog("Enter number of columns");
columns = Integer.parseInt(input);
String s = "Al-Quds";
for(int i = 0; i < s.length(); i++){
System.out.println(s.charAt(i));
}
Be ware of the difference between strings and arrays when accessing length; length in arrays is a
variable so we call it without brackets, but in string, length() is a method so we call it with
brackets. charAt() method simply returns the character contained in the provided zero-based
index within the string, for example, calling charAt(3) in the previous example returns 'Q'.
The following example counts how many spaces there are in certain string.
Exercises
1. Write a program that reads 10 integers from the user and then prints them out in reverse
order.
2. Write a program that reads names and marks of 10 students then prints the names of the
4 7 1 8
3 8 9 5
User input
1 3 4 5
8 1 5 6
Sum 16 19 19 24
Figure 9.2 (Exercise 3)
Lab Extras
You may have noticed that when we declare the main method we specify an array of strings
String[] args. This array stores command-line arguments and it could be used as input
method in addition to input methods we discussed earlier.
To see how it works, first we should know how to provide command line arguments, when we run a
class we use the following command.
The arguments we provide after class name are stored in args array, the number of arguments
determine the length of the array, notice that arguments are separated by spaces. The following
example shows how to read numbers from command line and print their sum.
class QuickSum{
public static void main(String[] args){
int sum = 0;
java QuickSum 3 4 6 2
sum = 15
In NetBeans IDE, you can add command line arguments by opening project properties, selecting
"run" node from properties tree on the left, then entering arguments in "Arguments" field separated
by spaces.
One thing left, which is adding data to this table. Each row in the table will take a common index in
all arrays, for example, we represent the first row by setting the following.
It is possible now to search inside this table, for example, to find the cars manufactured in year
2000, we can do something like this.
for(int i = 0; i < model.length; i++){
if(model[i] == 2000){
System.out.println(vendor[i] + " - " + color[i]);
}
}
In a similar way, we can search by color or by vendor. Additionally, we can update table data by
updating arrays contents. For example, the following code sets all cars colors to red.
for(int i = 0; i < color.length; i++){
color[i] = "Red";
}
Exercises
1. Write Java Applet that implements cars table. Your applet should have three buttons, a text
field and a text area (TextArea class is like TextField but have multiple lines). It
should look like figure 10.2 below. The following table shows how should this Applet
behave.
Button Behavior
Vendor Performs search using car's vendor and gives full details
about each matching car in the text area
Model Similar to “By Vendor”, but performs search using model
Color Similar to “By Vendor”, but performs search using color
}
}
The object g is used to draw on the Applet, for example, we can draw a line from the upper-left to
lower-right corners of the Applet. This example is shown in the code below. Result is shown in
figure 11.1 (in the next page).
import java.awt.*;
import java.applet.Applet;
The weakness of paint() method is that it is called automatically each time Applet repaints, so
you cannot control which graphics should be drawn at runtime. To solve this problem, we obtain
Graphics object from any other method using getGraphics() method.
The following example draws a circle at the upper-left corner of the Applet with the specified
radius. Notice how do we use drawOval() method.
import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
TextField value;
Button draw;
Exercises
1. Write a Java Applet that has 5 int fields, named x1, x2, y1, y2 and radius. Add two
buttons to your Applet named “line” and “circle”. The behavior of these buttons should be
as shown in table 11.3 below.
Button Functionality
Line Draws line from (x1, y1) to (x2, y2)
Circle Draws circle centered on (x1, y1) and has the radius
of the value entered in radius text field
Table 11.3
Figure 11.4 shows how should your Applet look like.
Methods
Objectives
● Introducing method structure.
● Writing and calling methods.
● Understanding return types and void methods.
● Differentiating between passing by value and passing by reference.
Using static keyword is not part of the format and there are more options for definition, but right
now, and as we will be calling our methods from the main method, we will use static in method
definition.
The contents of method definition are the following:
● static: because we will be calling our methods from the main method which is static, we
shall define our methods as static.
● Return type: data type of the value this method will return, for example,
Integer.parseInt() method returns integer data type, and println method does
not return any thing, so we call it void method. To define a void method, use void keyword
instead of return type in definition.
● Method name: the name we will use to call our method, this name must be a valid variable
name (we discussed naming rules earlier). The naming convention for method name is like
variable name; first word starts with lower case letter, and rest of words start with upper
case letters.
● List of parameters: method parameters provide an interface for providing input to method,
those parameters are variables specified by data type and name, separated by commas.
Method could take zero to infinity parameters, for example, println method takes one
parameter as string and prints that string on the console.
● Method body: statements of the method, these statements are executed when method is
called.
● return: when a method has return type (not void), we have to terminate it using return
keyword followed by the variable, value or expression that represents the value method
should return.
class Addition{
public static void main(String[] args){
int x = 5;
int y = 7;
sum(x, y);
}
Technique 2: method returns integer that contains the sum of two numbers.
class Addition{
public static void main(String[] args){
int x = 5;
int y = 7;
This time we specified integer as return type of the method, so we call it and assign the return value
to a new variable z, similar to parameter copying, the value of c returned from the method is copied
in z.
The advantage of returning the value is that gives programmer more options to do with the result
In the above example, sum is called 3 times, first time with 2 and 3 so it returns 5, second time with
1 and 6 so it returns 7, and the third time with the result of two previous calls 5 and 7 so it returns
12 which is the final result that is stored in z.
Lets have a look at more complex methods, and more useful ones. In the next example, we will try
to simplify the process of reading input by putting all of its steps in a single method with single call.
import java.io.*;
class ReadingSimplifier{
public static void main(String[] args){
String name = readString("Enter your name:");
int age = readInt("Enter your age:");
return "";
}
You can see how we simplified reading from user by putting all necessary statements in a method
called readString that takes a string as parameter, this string is the message that will be
displayed for the user as input prompt, readString also returns a string that represents the value
entered by user. We use try and catch instead of throwing the exception, this eases code writing
by handling the exception so we no more need to declare our methods to throw it.
The second method we used is called readNumber, it takes a string to display for the user, passes
it to readString and get the value returned from it, then converts the returned value to integer
and returns it.
//main
{
int x = 0;
add(x);
System.out.println(x);
}
If you compile and run the code above, the output you will see is 0, because the value of x was
copied into i, then the value of i was incremented, but x itself had never affected, because we did
not pass x, rather we passed its value.
On the other hand, all objects in Java are passed by reference, that is, the object itself is passed to
the method. A common example of objects passed by reference is passing an array object. Consider
the following code.
//main
{
int[] a = {0, 1};
add(a);
System.out.println(a[0]);
}
If you compile and run the above code, the output is 1. Because arrays are passes by reference, any
change we make on the array x inside add method is reflected on array a, because a and x are two
references to the same object.
12.4 Recursion
We can write a method that calls itself, these methods are called recursive methods, a
recursive method calls itself with different parameters to do certain job. For example, consider the
following method that calculates the factorial of a given integer n.
As you can see, we build recursive methods using a base case and a recursive call, the base case is
the condition at which we stop the recursion. In the above code, for example, the base case is when
n is equal to 0 or 1, both numbers have the factorial 1. The recursive call is executed if the base
case is not reached yet (i.e. there are more recursive calls until job is done), in case of factorial, we
build our recursive call using the mathematical fact which states that n! = n (n – 1)!, so we
return n multiplied by the factorial of n – 1. For example, if we tried to get the factorial of 4, the
execution of the method will flow like this:
1. (n = 4) Is 4 = 0 or 4 = 1? No, so return 4 * (4 – 1)! (recursive call)
2. (n = 3) Is 3 = 0 or 3 = 1? No, so return 3 * (3 – 1)! (recursive call)
3. (n = 2) Is 2 = 0 or 2 = 1? No, so return 2 * (2 – 1)! (recursive call)
4. (n = 1) Is 1 = 0 or 1 = 1? Yes, so return 1 (base case)
5. 1 is returned to the previous call and multiplied by 2
6. The result of multiplication (2) is returned to the previous call and multiplied by 3
7. The result of multiplication (6) is returned to the previous call and multiplied by 4
8. The result of multiplication (24) is returned by the method as final result.
Exercises
1. Write a method named maxPosition that takes an array of integers as array and returns
the index of the maximum element in the array.
2. Write a method named countChar that takes two parameters: a string and a character,
then returns an integer representing number of occurrences of the character in the string.
3. Write a method named average that takes array of doubles as parameter then returns the
average of the values inside the array. Sum calculation process should also be included in
method called sum that takes the array as parameter and returns the sum of its elements.
4. Write a void method called reverse that takes a string as parameter and prints it in reverse
order and inverted letter case, for example if the input is "Java", the output should be
"AVAj".
Hint: use integer values of characters to determine upper and lower cases.
5. You will be given a lab on recursion on separate sheet and you have to solve it.
Attributes: Behavior:
● Engine No. ● Move forward.
● Chassis No. ● Move backwards.
● Color. ● Steer right.
● Manufacturer. ● Steer left.
● Model name. ● Shift up.
● Manufacturing year. ● Shift down.
● Transmission (Automatic, Normal) ● Start engine.
● Number of wheels. ● Stop moving.
● Stop engine.
We define this set of attributes and behavior in a class called Car, after creating this class, we can
define several objects of this class, that is, the class defines common properties among all cars, and
each object represents different car, so we may have, for example, objects like these:
1. Car A: Color: red, Manufacturer: Nissan, Man. year: 1998, Transmission: Normal.
2. Car B: Color: black, Number of wheels: 6.
3. A.Start engine, A.Move forward and so on.
By the same way, we can represent any real-life object or any other object at any field, like circles
and triangles in representation of geometrical shapes.
class Circle{
//Radius is enough to determine all circle attributes
public double radius;
//Methods
public double getRadius(){
return radius;
}
The above class contained members declared using public keyword, this keyword means that the
member is accessible from outside the class, that is, when we declare an object from the class
Circle, we can access all public members, even if we declare the object outside Circle class.
You can also notice a method that holds the same name of the class and does not has a return value,
actually, we call it constructor, constructors are used to determine the initial values necessary to
build objects and are used after new keyword in declaration, for example, when declaring a
Circle object, we need to specify the radius of that circle, because all circle measurements are
based on the radius, so we write a constructor that takes radius as double. If we don't write a
constructor for our class, Java creates a default constructor that takes no parameters, but once we
write a constructor, the default constructor is no more available.
To declare a Circle object, we use something similar to variable declaration.
As shown above, declaring objects is straight forward, all you have to do is to specify class name
from which you create the object followed by object name, then you initialize the object using new
keyword followed by a constructor with necessary parameters.
When we call a member from the object, we use dot '.' to access the members then specify
member name. As we declared radius to be public, we can access it just like any other members to
change the radius after declaration.
For now, these properties are enough for us. The following example clearly explains the difference
between public and private members:
class A{
private int value = 10;
class B{
public static void main(String[] args){
A a = new A();
System.out.println(a.value); //Error, value is private
}
}
Trying to access private member from outside the class reports compile-time error.
It is a common practice in Object-Oriented that we declare members that store values as private and
create set and get methods to access them, set methods are called mutators, and get methods are
called accessors.
In the above example, we can use accessors and mutators methods o access the value stored in class
A as the following:
class B{
public static void main(String[] args){
A a = new A();
a.setValue(33); //Changes the value by mutator method
System.out.println(a.getValue()); //prints 33
The following example shows the difference between static and non-static variables:
class StaticTest{
private static int a;
private int b;
public StaticTest(){
a = 0; b = 0;
}
//Accessors
public static int getA(){ return a; }
public int getB(){ return b; }
//Mutators
public static void setA(int newA){ a = newA; }
public void setB(int newB){ b = newB; }
}
class Main{
public static void main(String[] args){
StaticTest s1 = new StaticTest();
StaticTest s2 = new StaticTest();
System.out.println("s1 values:");
System.out.println("a =" + s1.getA() + ", b =" + s2.getB());
System.out.println("s2 values:");
System.out.println("a =" + s2.getA() + ", b =" + s2.getB());
s1.setA(5);
s1.setB(3);
System.out.println("\ns1 values:");
System.out.println("a =" + s1.getA() + ", b =" + s2.getB());
System.out.println("s2 values:");
System.out.println("a =" + s2.getA() + ", b =" + s2.getB());
}
}
Compiling and running the above code shows the following output:
s1 values:
a =0, b =0
s2 values:
a =0, b =0
So what can be concluded from the output? The value of b is different for each object, changing
the value of b in object s1 did not affect the value of b in s2, which is not the situation with a,
because changing the value of a in s1 had its effect in a when called from s2, thats because static
members are shred among all objects as stated, variable a and methods related to it could be called
from the class name directly as shown below:
StaticTest.setA(13);
System.out.println(s1.getA() + " " + s2.getA());
In the above code, println method will print 13 two times. Remember to declare static methods
when dealing with static variables, back to StaticTest class definition, for example, you can
notice that getA and setA methods are declared static.
class Rectangle{
private double height, width;
public Rectangle(){
height = width = 1;
}
}
As the above example illustrates, we have three constructors having the same name, when we call a
constructor after new keyword, depending on parameters we specify a matching constructor is
selected.
It is important to realize that discriminating between constructors and methods holding the same
name are:
1. Number of parameters.
2. Order of parameters.
3. Types of parameters.
So it is important to know that parameter name has nothing to do with overloading, the following
example shows this.
To better understand classes and objects, lets analyze a well-known statement we've been using
repeatedly:
System.out.println("Hello World");
System is a name of a class, inside System class, there is a public and static member (object) of
class PrintWriter, the name of this object is out. Inside PrintWriter class, there is a
public, non-static method called println that has several overloads.
Exercises
1. Write a class that represents triangle named Triangle, the class must have the following
members:
○ private double height;//Height
○ private double base;//Base length
○ public Triangle(double h, double b);//Constructor
○ public void setHeight(double x);//Sets height
○ public double getHeight();//Gets height
○ public void setBase(double x);//Sets base length
○ public double getBase();//Gets base length
○ public double getArea();//Returns the area of the triangle
2. Write a class Employee that represents an employee of some organization, the class should
contain the following members:
○ private int id;//Employee id
○ private String name;//Employee name
○ private int type;//1 = employee, 2 = manager
Lab Extras
When we wish to specify a member from the class, we can use this keyword, this refers
to the current object of the class. For example, to discriminate between local and global variables in
a class that have the same name, we use this to specify which one in in the scope of whole class.
class Square{
private int sideLength;
public Square(int sideLength){
this.sideLength = sideLength;
}
As you can see, we have two variables called sideLength, one is global for the whole class and
it is where we store the value, and other is local for the constructor (or method), when we call
this., we are returning back to the scope of the class, so if we are to specify any member after
this, it has to be a global member.
Another use of this keyword is to call a constructor from within another constructor, this itself
represents the call, so what you have to do is to pass parameters to this just like the way you pass
them to any constructor. This technique is common when writing default constructor that does not
require user to specify parameters.
class Vector{
private double length;
private double angle;
public Vector(){
/* Calling the previous constructor,
If you need to specify additional statements in the constructor from which you are calling another
constructor, these statements should be specified after this call, in other words, when using this
to call another constructor, it should be in the first statement.
import java.io.*;
class ReadFromUser{
public static void main(String[] args) throws IOException{
.
.
.
}
}
If we wish to write a method that simplifies reading from user, you may want to declare it to throw
IOException.
import java.io.*;
class ReadFromUser{
public static void main(String[] args) throws IOException{
String in = read("Enter your name: ");
}
In the previous code, if an exception occurs in readLine() method, this exception is thrown as it
try{
//Statement(s) that may throw exceptions
}catch(Exception e){
//Statement(s) to handle exception.
}
For example, we can place readLine() method which throws IOException in a try-catch
block as the following.
When we are expecting more than one exception, we can use several catch blocks, each one for
different type of exceptions. For example, when reading a string using BufferedReader and
converting it to integer, you can expect two different exceptions: IOException and
NumberFormatException which occurs when the provided string cannot be converted to
integer.
To use your custom exception, declare an object of it and throw that object using throw keyword.
It is optional to declare the method containing throw statement with throws keyword.
In the following example, the program reads student id, this id should be of length 7 and consists
only of digits, otherwise it throws an exception.
Import javax.swing.*;
class StudentsData{
public static void main(String[] args){
String id, name;
try{
verfyID(id);
}
catch(InvalidIDException e){
JoptionPane.showMessageDialog(null, e.toString());
}
try{
Long.parseLong(id);
}
catch(Exception err){
throw
new InvalidIDException("ID can contain only digits");
}
}
}
Exercises
1. Write a program that count how many prime numbers between minimum and maximum
values provided by user. If minimum value is greater than or equal to maximum value, the
program should throw a InvalidRange exception and handle it to display a message to
the user on the following format:Invalid range: minimum is greater than or equal to
maximum. For example, if the user provided 10 as maximum and 20 as minimum, the
message should be: Invalid range: 20 is greater than or equal to 10.
Lab Extras
In order to access the exception from the class it uses, there is an important aspect one should be
aware of which is packaging, packaging means putting two or more classes in the same package by
stating package name before declaring class (and also exceptions). When two classes are in the
same package, it is possible to access any one of them from the other, for example, if we have a
class named Student that represents a student, another class named Main to run a program that
manages student information, and a third class called StudentDataException that represent
any errors in student information, we can access Student and StudentDataException
classes from Main class and define several objects of it if we use the following statement before
each class declaration:
package studentinfo;
In NetBeans IDE, there is no need to manually write the above statement, by adding new class to
any package of your project, that class is automatically declared as a part of that package. Figure
14.1 shows packages and classes in NetBeans IDE project explorer.
To access a class from its package we simply provide package name followed by dot '.' then
desired class name. For example, we can access Main class show in Figure 14.1 by calling it in the
following statement:
linkedlist.Main