“If you think you can do a thing or think you can't do a thing, you're right.”

—Henry Ford

• 3.1 Introduction
• 3.2 Variables
• 3.3 Operators
• 3.4 Reserved Words
• 3.5 Input and Output
• 3.6 Loops and Selections
• 3.7 Arrays, Matrices, and Vectors
• 3.8 Reading and Writing Files
• 3.9 Methods
• 3.10 Object-Oriented Programming
• 3.11 Multithreading
• 3.12 Date, Time, Timer, and Sleep Methods
• 3.13 Executing System Commands
• 3.14 Packages and Programming on a Large Scale
• 3.15 Software Engineering
• 3.16 Deploying Java Applications
• 3.17 Summary
• 3.18 Chapter Review Questions

3.1 Introduction

This chapter introduces the basic concepts of Java programming, intended for those who have some experience in coding and familiarity with programming concepts but are new to the Java language.

3.2 Variables

Java supports eight primitive types of variables: byte, short, int, long, float, double, char, and boolean. Variable names in Java are case-sensitive and must start with a letter, an underscore, or a dollar sign ($). They cannot start with a number. After the first character, a variable name can include any combination of letters and numbers. Spaces and special symbols, such as !, "", £, %, &, *, #, @, ~, and so on, are not allowed in variable names. In Java, all variables must be declared before they can be used. To declare a variable, you will need to specify the type, leave at least one space, and then specify the variable name and a semicolon (;).

type variablename;

The following code shows the declaration and initialization of an integer variable named x:

int x;        // Declares an integer type variable called x.
x = 10;       // Initialize x

or

int x = 10;  // Declaration and Initialization

You can also declare multiple variables of the same type all in one line.

int x, y, z;             // Declares three int variables, x, y, and z.
x = 10; y = 5; z=1;      // Initialize x, y, and z

or

int x = 10, y = 5, z=1;  // Declaration and Initialization

Example 3.1A shows a simple declaration and initialization of two integer variables. Here, as explained in Chapter 2, System.out.println() is used to display the text on the screen, and println("x = " + x) displays the text "x = " and the value of the variable x on the screen. The + sign means to concatenate the text and variable. You can find more details about input and output in section 3.5.

If you want to declare the variables outside the main() method, you need to declare the variables as static, as only static variables or methods can be used in the main() method; see Example 3.1B.

Example 3.1C shows an example of the declaration and initialization of different types of variables. Please note that you will need to put f at the end of the float number to indicate that it is a float number, not a double number. Similarly, you will need to put L at the end of a type long number to indicate that it is a long number.

static final int TOTALNUMBER=120;
static final float PI=3.1415926F;

String ClassName;
ClassName = new String(); 
ClassName = "Maple Tree Class";

String ClassName = "Maple Tree Class";

t1.compareTo(t2)

t1 = t1.concat(t2)

String s1 = "Hello";
String s2 = "Hello";

s2 = s2 + " World";

StringBuffer sB = new StringBuffer("Hello");
sB.append(" World");

   //Java VAR type variable since Java 10
   var str = "Java 10";                 // infers String
   var list = new ArrayList<String>();  // infers ArrayList<String>
   var stream = list.stream();          // infers Stream<String>s

3.3 Operators

Like many other languages, Java supports a full range of standard operators, such as arithmetic operators, comparison operators, logical operators, bitwise operators, and the assignment operator. Table 3.1 summarizes them.

3.4 Reserved Words

The following is a list of Java reserved words, or keywords that you cannot use for variable names, method names, or class names.

abstract
assert
boolean
break
byte
case
catch
char
class
const
continue
default
do
double
else
enum
extends
false
final
finally
float
for
goto
if
implements
import
instanceof
int
interface
long
native
new
null
package
private
protected
public
return
short
static
strictfp
super
switch
synchronized
this
throw
throws
transient
true
try
var
void
volatile
while
widefp

3.5 Input and Output

Input and output are important in almost all applications. In Java, System.out is used to print messages on the computer screen; this is called standard output. System.in and System.console are used to read text from the keyboard; this is called standard input.

Example 3.2 demonstrates Java input and output. System.console.readline() is used to read one line from the keyboard, and whatever the user types in will be stored in a String variable named x. Next, System.out.print() is used to display the text on-screen. Finally, System.out.println() works the same way as System.out.print(), except that after displaying the text, it moves the cursor to a new line. Figure 3.1 shows how to compile and run the example and its output.

Example 3.3 demonstrates another form of Java input and output. In this code, System.in is used to read from the keyboard. Combined with the Scanner class, it can read one line at a time from the keyboard; it can also read an integer value from the keyboard. The line

import java.util.Scanner; 

imports the java.util.Scanner library, which is needed by the Scanner class. This example first asks the user to enter a name, then reads the name from the keyboard, and finally displays the name on the screen. It also prompts for and displays the user's age. The name entered is stored in a String variable called name, and the age entered is stored in a variable named age.

In the Java input and output demonstrated in Example 3.4, System.in is used to feed into InputStreamReader and then into a BufferedReader. In Java all input and output sources are treated as streams, but the Stream type has limited functions, and it is often combined with BufferedReader. With BufferedReader, you can read one line each time from the keyboard. Integer.parseInt() is used to convert strings to integers. The throws IOException and try…catch blocks are used for handling exceptions. In Java it is mandatory to use exception handling for events such as input and output.

The try…catch block or try…catch…finally block is the classical approach to handling an exception in Java, as shown in the following pseudocode structure. The try block is used to enclose the code for doing something. One or more catch blocks are used to handle the exception. The finally block is used to enclose the code that is executed after the try block was successfully executed or a thrown exception was handled.

try {
    // do something
} 
catch (one exception) {
    //display error message
} 
catch (another exception) {
    //display error message
} 
finally {
    //do something
}

The corresponding libraries, java.io.BufferedReader, java.io.IOException, java.io., and InputStreamReader, are also imported.

Can you guess what the program in Example 3.4 will do?

3.6 Loops and Selections

There are three key ingredients that any programming language must have: sequences, loops, and selections. A sequence means statements executing sequentially, one after another. Loops and selections are control structures (or flow controls). Loops, also called iterations or iterative statements, are sets of statements that are executed repeatedly a number of times. Java supports for loops, while loops, and do loops. For example, the following for loop prints Hello World! five times:

for(i=0;i<5;i++){
    System.out.println("Hello World!");
}

Similarly, you can do the same thing using a while loop or a do loop. Both while and do loops need to define and initialize the counter variable before the loop (for example, int i=0;) and manually increase it during the loop (for example, i++). There is a subtle difference between the while loop and the do loop: the while loop checks the condition first before it runs the loop; the do loop runs the loop first and then checks the condition.

int i=0;
while(i<5){
    System.out.println("Hello World!");
    i++;
}
 
int i=0;
do{
    System.out.println("Hello World!");
    i++;
} while(i<5)

Example 3.5 uses a for loop to print all the command-line parameters. It uses args.length to get the total length of the parameters.

Selections, or conditional statements, allow your program to do different things under different conditions. Java supports the if…else conditional statement (a two-way choice), the switch conditional statement (multiple choices), and the ? operator (conditional assignment).

For example, if you want to do something when i==0 and do something else when it does not, you can write the following:

if (i==0){
…
}
else {
…
}

If you have more than two choices and want to do different things according to the value of i, you can use the switch conditional statement.

switch (i){
    case 1:
    …
    break;
    case 2:
    …
    break;
    case 3:
    …
    break;
    default:
    …
    break;
}

The ? symbol, often called the ternary operator because it takes three arguments, assigns either of two values to a variable depending on a condition. The following example assigns the value 3 to the variable y if i<0 and assigns the value 4 to y otherwise:

y=(i<0) ? 3:4;

Example 3.6 shows a simple Java program that demonstrates the use of the if…else conditional statement. Figure 3.2 shows how to compile and run the Hello1.java program and its output.

3.7 Arrays, Matrices, and ArrayLists

Arrays are important in scientific and engineering programs. In Java, you can create one-dimensional arrays, two-dimensional arrays (matrices), multidimensional arrays, and dynamic arrays (lists), which can have a dynamic set of elements, growing and shrinking during the execution of the program.

The following examples show how to declare an integer-type one-dimensional array, a float-type two-dimensional array (a matrix), and a double-type multidimensional array, respectively:

int[] x=new int[10];
 
float[][] y=new float [2][5];
 
double[][][] z=new double [5][2][3];

Alternatively, you can declare and initialize them at the same time.

int[] x={1,2,3,4,5,6,7,8,9,0};
 
float[][] y={{1.0F,1.0F,1.0F,1.0F,1.0F},{2.0F,3.0F,4.0F,5.0F,6.0F}};
 
double[][][] z={{{1,2,3},{4,5,6}},{{7,8,9},{10,11,12}},{{13,14,15},{16,17,18}},{{19,20,21},{22,23,24}},{{25,26,27},{28,29,30}}};

You can also separate the array declaration into two steps. For example, the following:

int[] x;
x=new int[10];

is exactly the same as the previous one-line declaration, but the benefit of this approach is that it will allow you to decide on the size of the array later when you run the program.

Example 3.7 shows how to create an integer-type one-dimensional array called x[] and a double-type two-dimensional array called y[][]. Figure 3.3 shows the compilation, execution, and output results of Array1.java. (Please note that as the array y[][] is randomly generated, your final output may not be the same as in Figure 3.3.) In Java, you can refer to any element of an array using its index, such as x[2] or y[0][1]. All the elements of the array must be of the same type.

A drawback of arrays is that their size is fixed when they are defined. Sometimes you need an array whose size can be changed as the program executes. You can create such an array by using Java's ArrayList class, which implements a “growable” array of objects. The following examples show how to declare dynamic arrays of String, integer, and double types. Similarly, you can also create an ArrayList of any objects.

ArrayList<String> v=new ArrayList<String>();
ArrayList<Integer> v=new ArrayList<Integer>();
ArrayList<double> v=new ArrayList<double>();

The angular braces, < >, indicate that this is a generic ArrayList. Java generic programming was introduced in Java SE 5 with the aim of reducing bugs and dealing with type-safe objects. As illustrated next, the nongeneric ArrayList example code can be compiled without any errors, but when you try to run the code, it will give a runtime error, as you are trying convert a string into an integer. In the generic ArrayList example code, <String> forces the ArrayList to contain only string values; therefore, it will generate a compilation error. In this way, generics programming makes Java code more robust and less error prone.

Here's the nongeneric ArrayList example code:

ArrayList list=new ArrayList();
list.add("hello");
Integer i = (Integer)list.get(0);

Here's the generic ArrayList example code:

ArrayList<String> list = new ArrayList<String>();
list.add("hello");
Integer i = (Integer)list.get(0);

For more information about Java generic programming, please visit these sites:

https://docs.oracle.com/javase/tutorial/java/generics/index.html

https://en.wikipedia.org/wiki/Generics_in_Java

http://tutorials.jenkov.com/java-generics/index.html

Example 3.8 shows how to create a dynamic ArrayList named list, which can grow using an add() method, as well as shrink using a remove() method. Figure 3.4 shows the compilation, execution, and output results of arraylist1.java.

3.8 Reading and Writing Files

Many applications need to read and write files. Java supports reading and writing both text and binary files, but I will cover only text files here. There are many ways in Java to read and write text files; the most basic one is by using the FileReader and FileWriter classes of the java.io package.

To use the FileWriter class to write to a text file, take the following steps:

1. Create a FileWriter object associated with the text file that you want to write.
2. Create a BufferedWriter object associated with the FileWriter object.
3. Write to the buffer.
4. Flush the buffer.
5. Close the file.

Using the BufferedWriter class for writing is optional; you can also write to a text file without using a buffer. But using a buffer, with the BufferedWriter and BufferedReader classes, can make the reading and writing process more efficient. The BufferedWriter class first bundles up several small write requests in its own internal buffer, and then when the buffer is full or the flush() method is called, it writes the whole buffer into the text file in one go. For file read and write, a try…catch block must be used to handle exceptions.

Example 3.9 shows how to write data to a text file using the FileWriter and BufferedWriter classes. It uses the args[0] parameter to get the name of the text file, which you will write data into. It will produce an error message and exit the program if no file name is provided.

To use the FileReader class to read from a text file, take the following steps:

1. Create a FileReader object associated with the text file that you want to read.
2. Create a BufferedReader object associated with the FileReader object.
3. Read from the buffer.
4. Flush the buffer.
5. Close the file.

Again, using the BufferedReader class is optional, but it does make text file reading more efficient.

Example 3.10 shows how to read data from a text file using the FileReader and BufferedReader classes.

3.9 Methods

Methods, also called functions, modules, or subroutines in other languages, allow programmers to modularize their programs and hence reduce the complexity of their software and improve its reusability. Methods normally have some input parameters, which are also called formal parameters or arguments, to carry out their specific tasks. The variables defined within a method are called local variables because they can be used only within that method. Formal parameters are also local variables.

Example 3.11 demonstrates the use of methods. Instead of printing out the Hello message directly, this program calls a method called printhello() to do the job. printhello() has one String type input parameter, msg. The void keyword means that there is no returned parameter for printhello(). The static keyword means that printhello() exists within the entire class. It is compulsory here, as only the static methods can be called in the main() method. The private keyword means this method can be called only within the current class.

Example 3.12 shows another example of methods. In the main() method, a Method2 class object is created first, Test test = new Test();, and then the pupAge() method is called.

test.pupAge();

In this case, the pupAge() method is called through an object-oriented approach, and therefore it does not need to be static. See the next section for more details about object-oriented programming.

In cases where you do need to return some value from a method, you need to specify what type of value will be returned. For example, the add() method shown in Example 3.13 takes in two double numbers, adds them, and returns the sum.

3.10 Object-Oriented Programming

When a problem is simple, you can just write one Java program, or one class, to solve it. But as the problems become more and more complicated, it is better to write the program using “separation of concerns” or “divide-and-conquer” approaches, that is, to write multiple classes in an object-oriented programming (OOP) fashion. OOP is a huge topic that itself can fill a whole book. But the benefits of OOP are obvious. Because it divides a big Java class into several smaller, self-contained, and reusable Java classes, it makes the code more understandable, more manageable, and less bug-prone.

In the simplest terms, OOP in Java means developing or using self-contained Java classes, which have specific attributes and certain behavior. The attributes are parameters (variables, or objects), and the behavior consists of methods (again, called functions in other languages). These parameters are used for exchanging input/output values with external programs, and the methods are for performing specific tasks. The following are the most important OOP concepts.

Tree tree;
Oak oak=new Oak();
Pine pine=new Pine();
tree=oak;
tree.getLeafShape();
tree=pine;
tree.getLeafShape();

3.11 Multithreading

To thread or not to thread, that is the question—but not for Java programmers, fortunately.

Many applications need to perform several tasks at the same time. Multithreading is a powerful way of achieving that. In software programming, a thread is an independent path of executing a task within a program. Multithreading means to execute two or more tasks, or threads, concurrently within a single program. Unlike other traditional programming languages, Java supports multithreading natively. Threads are a standard part of the Java language.

Example 3.16A shows a simple multithreading program called HelloThread0.java. The HelloThread0 class is a subclass of the Java Thread class. You need to override the run() method of the Thread class in order to specify what you want to execute in the thread. In this example, this is only one thread, which just prints a message. Once the thread object has been created, you can use the start(), yield(), join(), and stop() methods to start, hold (give other threads a chance to execute), wait until another thread completes, and stop the thread.

Example 3.16B shows a slightly more complicated version of the previous program. In this case, it has three threads, and each thread can print different messages so that you can differentiate them from each other. The message is passed into the thread through the thread constructor method. When you run the code, you will find that the threads might not appear in order. That is because they are executed independently.

Although Example 3.16A and Example 3.16B show a standard way of creating a multithreaded program, Java's single-inheritance limitation sometimes makes it much more desirable to implement the Runnable interface to achieve multithreaded programming. You also need to override the run() method in the class to specify what you want to execute in the thread. Example 3.16C shows the details.

Example 3.16D shows another simple, elegant way of implementing multithreaded programming in Java by using a Java anonymous inner class, in which you create the thread object, define the run() method, and start the thread all in one go. See the previous OOP discussion for more details on Java anonymous inner classes.

Example 3.16E shows an object-oriented approach of implementing multithreaded programming. Here a separated class called Hello4 is created, which implements the Runnable interface.

Example 3.16F also shows an object-oriented approach to implementing multithreaded programming. Here a separate class named Hello5 is created, which is a subclass of the Thread class.

Example 3.16G shows a more complicated multithreading program that does some calculations in the thread. It is based on the previous OOP multithreaded example. Figure 3.5 shows the compilation, execution, and output results.

Example 3.16H is a variation of Example 3.16A. Instead of inheriting from the Thread class, it implements the Runnable interface.

3.12 Date, Time, Timer, and Sleep Methods

You'll often need dates, times, and accurate timers in your programs. In Java, you can use the new Date().toString() method to get the date and time string, you can use the System.currentTimeMillis() method, or you can use the new Date().getTime() method to get the current time in milliseconds past midnight, January 1, 1970, UTC. You can also use the System.nanoTime() method to get the most accurate system time in nanoseconds.

Example 3.18A is a simple program that illustrates how to use the Date() class to get date and time information. Figure 3.6 shows the output result.

The LocalDateTime() class, which belongs to the java.time.* package, provides the most useful date and time functions, such as getYear(), getMonth(), getDayofMonth(), and getDayofWeek(). You can also display the date and time using a certain format.

Example 3.18B is a simple program that illustrates how to use the LocalDateTime() class to get date and time information. Figure 3.7 shows the output result.

The timer() class, also from the java.util package, provides the most accurate timer function, which you can set up using the schedule() method. Any class that you want to run in the timer must be a subclass of TimerEvent(), and it must override the run() method.

Example 3.19A is a simple timer program, which runs every 1000 ms (one second). It uses the System.currentTimeMillis() class to get the current time in milliseconds. From the output in Figure 3.8, you can see that the timer is accurate, with about 1 ms to 2 ms error. This is comparable to other programming languages.

However, many people prefer using ScheduledExecutorService instead of Timer, as it's much more flexible—you don't have to worry about the timer blocking the rest of your program, and it handles exceptions better. Example 3.19B shows a simple ScheduledExecutorService example, which repeatedly executes a printing task, starting at 0 seconds and repeating every 10 ms.

Example 3.19C shows another version of the previous ScheduledExecutorService program. This time, the task is defined separately and uses a count variable to count how many times the task has been executed. It waits for five seconds first and then repeats the task every second. In addition to running the task repeatedly, you can run the task just once. To do so, just uncomment the last two lines, and comment out the ses.scheduleAtFixedRate() line.

Delay, or sleep, is also a useful function in many applications. In Java, you can use the Thread.sleep() class to implement a delay. Example 3.20 is a simple program that prints a message, delays for 5,000 milliseconds (5 seconds), and then prints another message. Figure 3.9 shows the output result.

Example 3.21 is a variation of the previous program. By combining sleep() with the System.currentTimeMillis() class, you can display how many milliseconds the program has delayed or slept.

3.13 Executing System Commands

In Java, it is possible to run other applications in your operating system. This allows you to run, or to call, system programs and command-line programs from your Java program.

Example 3.22 is a simple program that illustrates how to use the Runtime.getRuntime().exec() class to get and execute the Windows Notepad.exe program. Figure 3.10 shows the output result.

Example 3.23 shows another program that uses the Runtime.getRuntime().exec() class to execute the Windows command-line command dir C:\. The cmd.exe program is the Windows console (or terminal) command, and /C is the flag of cmd.exe, which says that the Windows console should carry out the command specified by String and then terminate. Figure 3.11 shows the output result.

3.14 Packages and Programming on a Large Scale

For simple, small-scale Java applications, you can just write a few Java programs and put them in the save directory without needing to worry about directory structures. But for large-scale applications, a key part is to create reusable software components; therefore, directory structures become important. Java packages provide such a mechanism for organizing reusable Java classes and interfaces into different directory structures.

Example 3.24A and Example 3.24B show how to create a reusable Java class in a Java package and how to call this class. The reusable Java class is called SpecialFunctions.java (Example 3.24A). The program to test this special function is called SFTest1.java (Example 3.24B). To create a reusable Java class in a package, you need these two steps:

1. Define a public class, like so:

    public class SpecialFunctions

2. Define a package name, like so:

    package biz.biox

The package name also specifies the subdirectory that this Java class must belong to. In this example, if the current directory is H:ProjectA, then SpecialFunctions.java must be in H:ProjectAiziox, and the SFTest1.java file must be in the H:ProjectA directory, as shown here:

     H:ProjectA
     |----------- SFTest1.java
     |---------->iz
     |-------------->iox
     |-------------------- SpecialFunctions.java
 

To compile the SpecialFunctions.java program from a current directory of H:ProjectA, enter the following command, as shown in Figure 3.12:

H:ProjectA> javac .izioxSpecialFunctions.java

SFTest1.java in Example 3.24B shows how to use the SpecialFunctions.java class in the biz.biox package. Make sure to add the following line at the beginning of the file:

import biz.biox.SpecialFunctions;

Type in the following commands to compile and run the SFTest1.java program. Figure 3.13 shows the output results.

H:ProjectA> javac SFTest1.java
H:ProjectA> java  SFTest1

3.15 Software Engineering

Writing software is like making commercial products—quality is absolutely paramount. But how can you guarantee software quality? The answer is through software engineering. This concept means you should develop your software using a systematic engineering approach and write your code in a good programming style.

Using a systematic engineering approach means you should not simply go to your computer and start typing in code whenever you want to write a program. Instead, you should always follow the software development cycle; that is, you should design first and then write the code.

Good programming style means the software source code should be well structured, with correct indentations and sufficient comments. You also need to give your classes, methods, and variables meaningful names. Writing programs in good programming style will make programs easy to manage, modify, and debug, as well as less error-prone.

Begin
    Define double x
    Create a SpecialFunctions object sf 
    Print the heading: "Number  Erf  Erfc ExpErfc"
    For each integer i in 1 to 10:
       x=(i-5)/10.0;
       Print x, sf.erf(x), sf.erfc(x), sf.ExpErfc(x)
    End of loop
End

/*
 This is a multiple line 
 comment
*/

/**
 * This is a multiple line 
 * comment
 */

doubleAmbientTemperature 
dblAmbientTemperature 
dAmbientT

strPlotTitle          //A String variable that stores the plot title
bolDeviceOn           //A boolean variable that stores a true or false value for 
                      //representing the on/off status of a device
intNumberOfPoints     //An integer variable that stores the total number of 
                      //points

getCurrentDirectory()      //A method that returns the current directory
setCurrentDirectory()      //A method that sets the current directory
toString()                 //A method that returns a string representing                              the object
FileReader()               //A class that reads character files
FileWriter()               //A class that writes character files

3.16 Deploying Java Applications

For Linux/Unix users, there may seem nothing wrong with compiling and running Java programs through the text mode terminal or console, as you've done so far. But for Windows users, who have been used to graphical interfaces and a mouse, opening a text mode Windows command prompt to type in commands such as java HelloWorld to run a Java program is not very appealing. Therefore, in this section you will first look at several different ways of creating an executable Java program, which can be run with just a double mouse click. Then you will see how to deploy Java applications.

3.16.1 Using a Windows Batch File

The simplest way to compile and run Java code is to use a Windows batch file. You can use Notepad++ or any other text editor to create the batch file. Figure 3.14 shows an example of creating a Windows batch file called Oop1run.bat to compile and run the previous Oop1.java program. It has three lines of commands: the first line is to compile the code, the second line is to run the code, and the third line, the pause command, is to hold the screen so that you can observe the results. Once the batch file is created, all you need to do is double-click the file to compile and run the program, as shown in Figure 3.15. This approach is simple, quick, and efficient.

3.16.2 Using an Executable JAR File

Java technologies support the concept of executable JAR files, which means you can create a JAR (which is a Java archive, the equivalent of a zipped file) that can run when it's double-clicked.

To create an executable JAR file, you must first create a mainClass manifest file, which contains two lines specifying where mainClass is to be found in the JAR file. In this example, the mainClass file is named Oop1.mf, and the following is its content:

Main-Class: Oop1
Class-Path: Oop1.jar

Now you can create an executable JAR file by typing in the following command in a Windows command prompt window:

jar cmf Oop1.mf Oop1.jar *.class

This combines all the Java classes (*.class) to create an executable JAR file called Oop1.jar.

To run this JAR file, just type the following:

java -jar Oop1.jar

You can also double-click the Oop1.jar file to run it. Figure 3.16 shows the content of the Oop1.mf file and the corresponding Oop1.jar file.

3.16.3 Using Microsoft Visual Studio

You can also use Microsoft Visual Studio to write a simple Windows command prompt program to compile and run Java programs using system calls. Microsoft Visual Studio is a popular software development tool in the industry, and you can use it to create an installation package easily. Figure 3.17 shows an example of creating a Microsoft Visual Studio C# program to use the System.Diagnostic.Process.Start() class to execute the javac Oop1.java command to compile the Java program and to execute the java Oop1 command to run the Java program.

3.17 Summary

This chapter provided a basic introduction to Java programming. Topics included variables, operators, reserved words, input and output, loops and selections, arrays, matrices and vectors, file read and write, object-oriented programming, multithreading, methods, dates and times, system commands, software engineering, and deployment.

This chapter lays the foundation for the coming chapters; it is important especially when you are new to Java programming. The variables, operators, and control structures such as loops and selections are the fundamental building blocks of the Java programming language. You will see them used throughout the book. Arrays and lists are useful for storing complex user data. The file read and write tools allow programs to read information from a file and save information into a file. OOP is one of the main features of the Java language, and all the example programs in this book use OOP in one way or another. Multithreaded programming is also crucial for many networking applications, as different threads are needed to handle different connections. It is good practice to develop Java software programs using a systematic, engineering approach. If you want to distribute your Java program to others, it is best to package your program in an installation package.

3.18 Chapter Review Questions