INTRODUCTION TO JAVA
Java is a general-purpose, object-oriented programming language that is designed to be portable, meaning it can run on multiple platforms (such as Windows, macOS, and Linux) without needing to be recompiled. Java was first released in 1995 and has since become one of the most widely used programming languages in the world, particularly for building web applications and Android mobile apps.
Java is based on the concept of a "virtual machine" (VM), which allows code to be compiled into bytecode that can be executed on any machine that has a Java Virtual Machine (JVM) installed. This makes Java programs highly portable, since they can run on any machine with a JVM, regardless of the underlying operating system or hardware.
When working with Java, it's important to understand the difference between the Java Development Kit (JDK), Java Runtime Environment (JRE), and Java Virtual Machine (JVM). In this tutorial, we'll explain each of these components and how they work together.
Java Development Kit (JDK)
The Java Development Kit (JDK) is a software development kit used to develop Java applications. It includes the Java compiler, which converts Java source code into bytecode that can be executed by the JVM. The JDK also includes various tools and libraries that are necessary for developing Java applications, such as the Java debugger, the JavaDoc tool, and the JavaFX graphics library.
The JDK is typically used by software developers who are creating Java applications from scratch. It can be downloaded and installed from the Oracle website.
Java Runtime Environment (JRE)
The Java Runtime Environment (JRE) is a software package that is used to run Java applications. It includes the Java Virtual Machine (JVM) and the Java class libraries. The JVM is responsible for executing Java bytecode, while the class libraries provide a set of pre-built Java classes and methods that can be used by Java applications.
The JRE is typically used by end users who need to run Java applications on their computers. It can be downloaded and installed from the Oracle website.
Java Virtual Machine (JVM)
The Java Virtual Machine (JVM) is a software component that is responsible for executing Java bytecode. When a Java application is compiled, it is converted into bytecode that can be executed by the JVM. The JVM is responsible for loading the bytecode into memory, interpreting the bytecode, and executing the instructions.
One of the key benefits of the JVM is that it provides a platform-independent execution environment for Java applications. Because the JVM is available on many different platforms, Java applications can be written once and run on any platform that has a compatible JVM.
ImgRef - techbeamers.com
Basics JAVA concepts
Variables and Data Types
Variables are used to store values in Java. There are several different data types in Java, including:
int: used for storing whole numbers (e.g. 10, -20, 0)
double: used for storing decimal numbers (e.g. 3.14, -2.5, 0.0)
boolean: used for storing true/false values
char: used for storing single characters (e.g. 'a', 'B', '!')
String: used for storing text (e.g. "Hello, world!")
Here's an example of how to declare and assign values to variables in Java:
int age = 30;
double height = 1.75;
boolean isStudent = true;
char firstInitial = 'J';
String name = "John";
Naming Rules
The name of a variable must start with a letter or an underscore. It can consist of letters, numbers, and underscores. Java is case sensitive, so myVariable and MyVariable are two different variables.
Declaring Variables
In Java, you need to declare a variable before using it. To declare a variable, you need to specify its data type and name. For example:
int age;
In the example above, we declared a variable named age of type int (integer). We can also assign a value to the variable when we declare it, like this:
int age = 20;
Initializing Variables
When you declare a variable, you can initialize it with a value. For example:
int age = 20;
Assigning Values to Variables
To assign a value to a variable, you need to use the assignment operator (=). For example:
int age;
age = 20;
In the example above, we first declared a variable age and then assigned a value of 20 to it.
Using Variables
You can use a variable in an expression or a statement. For example:
int age = 20;
int nextAge = age + 1;
In the example above, we declared a variable age and assigned a value of 20 to it. We then declared another variable nextAge and assigned the value of age + 1 to it. The value of nextAge is 21.
Scope of Variables
The scope of a variable is the region of the program where the variable can be accessed. In Java, the scope of a variable depends on where it is declared. A variable declared inside a method can only be used within that method. A variable declared outside of any method (in the class) is called a class variable or instance variable and can be used throughout the class.
Data Types
Java has several built-in data types that are used to represent different types of values. The data type determines the size and type of data that can be stored in a variable.
Primitive Data Types
Java has eight primitive data types, which are:
byte: 8-bit signed integer
short: 16-bit signed integer
int: 32-bit signed integer
long: 64-bit signed integer
float: 32-bit floating point
double: 64-bit floating point
boolean: true/false value
char: single 16-bit Unicode character
Reference Data Types
Java also has reference data types, which are used to refer to objects. Reference variables store the memory address of an object, not the object itself. The most common reference data types are:
String: a sequence of characters
Arrays: a collection of values of the same type
Type Casting
Type casting is the process of converting one data type to another. Java supports two types of casting: implicit and explicit. Implicit casting is done automatically by the compiler, while explicit casting requires the programmer to specify the conversion.
int age = 20;
double salary = age; // implicit casting
In the example above, we assigned the value of age (an int) to salary (a double). Since double can hold larger values than int, the conversion is done implicitly.
double salary = 2000.50;
int roundedSalary = (int) salary; // explicit casting
In the example above, we assigned the value of salary (a double) to roundedSalary (an int). Since int cannot hold decimal values, we need to explicitly cast salary to an int using the casting operator (int).
Examples
Here are some examples of declaring and using variables with different data types in Java:
// declaring and initializing integer variables
int age = 20;
int birthYear = 2003;
// declaring and initializing double variables
double salary = 2000.50;
double taxRate = 0.15;
// declaring and initializing boolean variables
boolean isStudent = true;
boolean isEmployed = false;
// declaring and initializing char variables
char gender = 'M';
char grade = 'A';
// declaring and initializing string variables
String name = "John Doe";
String address = "123 Main St.";
// declaring and initializing array variables
int[] numbers = {1, 2, 3, 4, 5};
String[] names = {"John", "Mary", "Peter"};
In the examples above, we declared and initialized variables of different data types, including int, double, boolean, char, String, and arrays. We also assigned values to the variables using literals or expressions.
Operators
Operators are symbols or keywords that perform operations on one or more operands in a Java program. Java provides a wide range of operators that can be used to perform various operations, such as arithmetic, relational, logical, assignment, and bitwise operations.
Here is a brief overview of the different types of operators in Java:
Arithmetic Operators: These operators are used to perform basic mathematical operations, such as addition, subtraction, multiplication, division, and modulus. The arithmetic operators in Java are + (addition), - (subtraction), * (multiplication), / (division), and % (modulus).
Relational Operators: These operators are used to compare two values and return a boolean result. The relational operators in Java are < (less than), > (greater than), <= (less than or equal to), >= (greater than or equal to), == (equal to), and != (not equal to).
Logical Operators: These operators are used to combine two or more boolean expressions and return a boolean result. The logical operators in Java are && (logical AND), || (logical OR), and ! (logical NOT).
Assignment Operators: These operators are used to assign values to variables. The assignment operators in Java are = (simple assignment), += (add and assign), -= (subtract and assign), *= (multiply and assign), /= (divide and assign), and %= (modulus and assign).
Bitwise Operators: These operators are used to perform bitwise operations on the binary representations of values. The bitwise operators in Java are & (bitwise AND), | (bitwise OR), ^ (bitwise XOR), ~ (bitwise complement), << (left shift), >> (right shift), and >>> (unsigned right shift).
Ternary Operator: This operator is a shorthand for an if-else statement and is used to evaluate a boolean expression and return one of two values based on the result. The ternary operator in Java is ?: (conditional operator).
Increment and Decrement Operators: These operators are used to increment or decrement the value of a variable by 1. The increment operator ++ adds 1 to the value of a variable, while the decrement operator -- subtracts 1 from the value of a variable. These operators can be used in both prefix and postfix forms. In the prefix form, the operator is placed before the variable, while in the postfix form, the operator is placed after the variable.
instanceof Operator: This operator is used to check whether an object is an instance of a particular class or interface.
Here is an example code snippet that demonstrates the use of some of these operators in Java:
int a = 5, b = 10;
int c = a + b;
boolean d = (a < b) && (c > 15);
System.out.println("c = " + c);
System.out.println("d = " + d);
In this example, we are using the arithmetic operator + to add the values of a and b, the relational operator < to compare the values of a and b, and the logical operator && to combine the two boolean expressions. The result of the addition operation is stored in the variable c, and the result of the logical operation is stored in the variable d. The output of this code would be:
c = 15
d = true
The instanceof operator returns a boolean value. Here is an example code snippet that demonstrates the use of the increment and decrement operators and the instanceof operator:
int x = 5;
int y = x++;
int z = --y;
String str = "Hello World";
boolean isString = str instanceof String;
System.out.println("x = " + x);
System.out.println("y = " + y);
System.out.println("z = " + z);
System.out.println("isString = " + isString);
In this example, we are using the postfix form of the increment operator ++ to increment the value of x by 1, and then assigning the original value of x to the variable y. We are also using the prefix form of the decrement operator -- to decrement the value of y by 1, and then assigning the new value of y to the variable z. Finally, we are using the instanceof operator to check whether the object referenced by str is an instance of the String class. The output of this code would be:
x = 6
y = 4
z = 3
isString = true
These are some of the most commonly used operators in Java. It's important to understand how they work and when to use them in order to write effective and efficient code.
Input and Output in Java
Java provides a rich set of libraries for input and output operations. In this tutorial, we will cover the basics of input and output in Java.
Input in Java: Java provides the Scanner class to read input from the console. The Scanner class provides several methods to read different types of input data such as integers, floating-point numbers, and strings.
Here is an example of how to use the Scanner class to read an integer from the console:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter an integer: ");
int num = scanner.nextInt();
System.out.println("You entered: " + num);
}
}
In this example, we first import the Scanner class from the java.util package. Then, we create a Scanner object that takes input from the console using the System.in stream. We prompt the user to enter an integer and then use the nextInt() method to read an integer from the console. Finally, we print the input to the console using the println() method.
Output in Java: Java provides the System.out stream to output data to the console. We can use the println() method to print data to the console. This method automatically adds a new line character at the end of the output.
Here is an example of how to use the println() method to output a string to the console:
public class Main {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
In this example, we simply use the println() method to print the string "Hello, World!" to the console.
Java also provides the System.err stream to output error messages. We can use the print() method to output data to the System.err stream. This method does not add a new line character at the end of the output.
Here is an example of how to use the print() method to output an error message to the console:
public class Main {
public static void main(String[] args) {
System.err.print("Error: division by zero");
}
}
In this example, we use the print() method to output the error message "Error: division by zero" to the console.
Java also provides several other classes for input and output operations, such as File, FileInputStream, FileOutputStream, and PrintWriter. These classes can be used to read and write data to files, sockets, and other data streams.
Java provides the FileInputStream and Scanner classes to read input from a file. Here is an example of how to use these classes to read integers from a file:
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try {
Scanner scanner = new Scanner(new FileInputStream(new File("input.txt")));
while (scanner.hasNextInt()) {
int num = scanner.nextInt();
System.out.println("You entered: " + num);
}
scanner.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
In this example, we create a FileInputStream object to read input from the file "input.txt". We then create a Scanner object to read integers from the FileInputStream. We use the hasNextInt() method to check if there is more input to read, and the nextInt() method to read an integer from the input. Finally, we print the integer to the console.
Writing output to a file: Java provides the FileOutputStream and PrintWriter classes to write output to a file. Here is an example of how to use these classes to write strings to a file:
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
public class Main {
public static void main(String[] args) {
try {
PrintWriter writer = new PrintWriter(new FileOutputStream(new File("output.txt")));
writer.println("Hello, World!");
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
In this example, we create a FileOutputStream object to write output to the file "output.txt". We then create a PrintWriter object to write strings to the FileOutputStream. We use the println() method to write the string "Hello, World!" to the output. Finally, we close the PrintWriter to ensure that all data is written to the file.
Reading input from the command line arguments: Java provides the args parameter in the main() method to read input from the command line arguments. Here is an example of how to use this parameter to read integers from the command line:
public class Main {
public static void main(String[] args) {
for (String arg : args) {
int num = Integer.parseInt(arg);
System.out.println("You entered: " + num);
}
}
}
In this example, we use a for loop to iterate over the command line arguments. We use the parseInt() method to convert each argument to an integer. Finally, we print the integer to the console.
Java Expressions and Blocks
Expressions and blocks are two fundamental concepts in Java programming. In this tutorial, we will cover what they are and how to use them in your Java code.
Expressions in Java: An expression is a construct in Java that represents a value or a computation. It can be a single variable, a method call, a combination of variables and operators, or even a conditional expression. Expressions can be used to initialize variables, pass arguments to methods, or make decisions in control structures.
Here are some examples of expressions in Java:
int x = 5; // variable expression
int y = x + 3; // arithmetic expression
String name = "John"; // string expression
boolean isEven = (x % 2 == 0); // conditional expression
System.out.println("Hello, " + name); // method call expressionBlocks in Java: A block is a group of statements enclosed in curly braces {}. It is used to group statements together and define a scope. A block can contain variable declarations, control structures, and method calls.
Here is an example of a block in Java:
public static void main(String[] args) {
int x = 5;
if (x > 0) {
System.out.println("x is positive");
} else {
System.out.println("x is non-positive");
}
}
In this example, we define a block using the if-else control structure. The block contains two print statements, one that is executed if the condition x > 0 is true, and another that is executed if the condition is false.
Blocks can also be used to define the scope of variables. For example, a variable declared inside a block is only accessible within that block and its sub-blocks.
public static void main(String[] args) {
int x = 5;
{
int y = 10;
System.out.println("x = " + x); // valid
System.out.println("y = " + y); // valid
}
System.out.println("x = " + x); // valid
System.out.println("y = " + y); // invalid
}
In this example, we define a block inside the main method that declares a variable y. The variable x is accessible both inside and outside the block, but the variable y is only accessible inside the block.
In conclusion, expressions and blocks are fundamental concepts in Java programming. Understanding how to use them will help you write more complex and powerful Java code.
Java Comment
In Java, comments are used to add explanations or notes to the code that are not executed by the program. Comments help other developers understand the code and its purpose, and can also serve as reminders for the code author.
Java supports two types of comments: single-line comments and multi-line comments.
Single-line comments start with two forward slashes (//) and continue until the end of the line. Everything after the // is ignored by the Java compiler.
Here is an example of a single-line comment:
// This is a single-line comment
Multi-line comments start with /* and end with */. Everything between these characters is ignored by the Java compiler, even if it spans multiple lines.
Here is an example of a multi-line comment:
/*
This is a multi-line comment
It can span multiple lines
And can contain any text or code
*/
Comments can be used to document the code, explain the purpose of a particular block of code, or disable code temporarily without deleting it. It is good practice to include comments in your code, especially when working in a team or when writing code that others will use.
Java also supports a third type of comment called the Javadoc comment, which is used to generate documentation for the code. Javadoc comments start with /** and end with */, and contain special tags that are used to generate documentation. Javadoc comments are typically used for documenting classes, methods, and variables.
Here is an example of a Javadoc comment:
/**
* This is a Javadoc comment for the MyClass class
*
* @author John Doe
* @version 1.0
*/public class MyClass {
// code goes here
}
In this example, the Javadoc comment is used to document the MyClass class and contains the author and version tags. Javadoc comments are a powerful way to document your code and make it easier for others to use and understand.
Control Structures
Control flow statements are used to control the flow of execution in a Java program. There are several different types of control flow statements in Java, including:
if/else: used to execute different code blocks depending on whether a condition is true or false
for: used to execute a block of code a specific number of times
while/do-while: used to execute a block of code repeatedly while a condition is true
switch: used to execute different code blocks depending on the value of a variable
Here's an example of how to use an if/else statement in Java:
int age = 18;
if (age >= 18) {
System.out.println("You are old enough to vote.");
} else {
System.out.println("You are not old enough to vote.");
}
Control structures in Java are used to control the flow of execution of a program. They enable you to make decisions, repeat statements, and execute statements based on conditions. In this tutorial, we will cover the three main control structures in Java: if-else statements, loops, and switch statements.
If-else statements
If-else statements are used to make decisions in Java. They enable you to execute one or more statements based on a condition. The syntax for an if-else statement is as follows:
if (condition) {
// statements to execute if condition is true
} else {
// statements to execute if condition is false
}
In the example above, the code inside the if block is executed if the condition is true, and the code inside the else block is executed if the condition is false.
Here's an example that uses if-else statements:
int x = 10;
if (x > 0) {
System.out.println("x is positive");
} else {
System.out.println("x is negative or zero");
}
In this example, if the value of x is greater than 0, the message "x is positive" is printed. Otherwise, the message "x is negative or zero" is printed.
Loops
Loops are used to repeat a block of code a certain number of times or until a condition is met. There are three types of loops in Java: for, while, and do-while loops.
For loops
For loops are used to repeat a block of code a specific number of times. The syntax for a for loop is as follows:
for (initialization; condition; update) {
// statements to execute
}
In the example above, the code inside the for loop is executed as long as the condition is true. The initialization statement is executed once before the loop starts, the update statement is executed after each iteration of the loop, and the condition is checked before each iteration of the loop.
Here's an example that uses a for loop:
for (int i = 0; i < 5; i++) {
System.out.println("Hello, world!");
}
In this example, the message "Hello, world!" is printed 5 times.
While loops
While loops are used to repeat a block of code as long as a condition is true. The syntax for a while loop is as follows:
while (condition) {
// statements to execute
}
In the example above, the code inside the while loop is executed as long as the condition is true.
Here's an example that uses a while loop:
int i = 0;
while (i < 5) {
System.out.println("Hello, world!");
i++;
}
In this example, the message "Hello, world!" is printed 5 times.
Do-while loops
Do-while loops are used to repeat a block of code at least once, and then as long as a condition is true. The syntax for a do-while loop is as follows:
do {
// statements to execute
} while (condition);
In the example above, the code inside the do block is executed at least once, and then as long as the condition is true.
Here's an example that uses a do-while loop:
int i = 0;
do {
System.out.println("Hello, world!");
i++;
} while (i < 5);
In this example, the message "Hello, world!" is printed 5 times.
Switch statements
Switch statements are used to execute one or more statements based on the value of a variable. The syntax for a switch statement is as follows:
switch (variable) {
case value1:
// statements to execute if variable equals value1break;
case value2:
// statements to execute if variable equals value2break;
default:
// statements to execute if variable does not equal any of the values
break;
}
In the example above, the code inside the case block is executed if the value of variable equals value1, and the code inside the case block is executed if the value of variable equals value2. If variable does not equal any of the values, the code inside the default block is executed.
Here's an example that uses a switch statement:
int dayOfWeek = 2;
switch (dayOfWeek) {
case 1:
System.out.println("Monday");
break;
case 2:
System.out.println("Tuesday");
break;
case 3:
System.out.println("Wednesday");
break;
case 4:
System.out.println("Thursday");
break;
case 5:
System.out.println("Friday");
break;
case 6:
System.out.println("Saturday");
break;
case 7:
System.out.println("Sunday");
break;
default:
System.out.println("Invalid day of week");
break;
}
In this example, the message "Tuesday" is printed because the value of dayOfWeek is 2.
That's it for control structures in Java! By using these control structures, you can make decisions, repeat statements, and execute statements based on conditions in your Java programs.
Break Statement
In Java, the break statement is used to immediately exit a loop or switch statement, regardless of whether the loop or switch has finished iterating through all of its elements or cases.
Here's how the break statement works:
When the break statement is encountered in a loop, it immediately exits the loop and control passes to the statement following the loop.
When the break statement is encountered in a switch statement, it immediately exits the switch and control passes to the statement following the switch.
The break statement is often used to exit a loop early when a specific condition is met. For example, in a loop that iterates over a list of numbers, the break statement could be used to exit the loop as soon as a negative number is encountered:
for (int i = 0; i < numbers.length; i++) {
if (numbers[i] < 0) {
break;
}
// do something with positive numbers
}
In this example, the break statement is used to exit the loop as soon as a negative number is encountered, regardless of whether there are still positive numbers remaining in the list.
Similarly, in a switch statement, the break statement is often used to exit the switch as soon as a matching case is found. If the break statement is not used, control will continue to the next case in the switch statement, which may not be the desired behavior.
It's important to use the break statement judiciously, as overuse or improper use can make code difficult to understand and maintain. However, when used appropriately, the break statement can be a powerful tool for controlling the flow of a loop or switch statement.
Continue Statement
In Java, the continue statement is used within loops to skip the current iteration of the loop and move on to the next iteration.
Here's how the continue statement works:
When the continue statement is encountered in a loop, it immediately skips to the next iteration of the loop.
Any remaining statements in the current iteration are skipped, and the loop proceeds with the next iteration.
If the continue statement is encountered in the last iteration of a loop, the loop terminates and control passes to the statement following the loop.
The continue statement is often used within loops to skip over certain values or conditions that meet a specific criterion. For example, in a loop that iterates over a list of numbers, the continue statement could be used to skip over any negative numbers:
for (int i = 0; i < numbers.length; i++) {
if (numbers[i] < 0) {
continue;
}
// do something with positive numbers
}
In this example, the continue statement is used to skip over any negative numbers in the numbers array and continue with the loop for positive numbers.
It's important to use the continue statement judiciously, as overuse or improper use can make code difficult to understand and maintain. However, when used appropriately, the continue statement can be a powerful tool for controlling the flow of a loop.
Thanks for reading, and happy coding!