Java Programming Basics

Java is one of the most popular and widely used programming

language and platform. A platform is an environment that helps
to develop and run programs written in any programming
language. Java is fast, reliable and secure. From desktop to web
applications, scientific supercomputers to gaming consoles, cell
phones to the Internet, Java is used in every nook and corner.
However to become proficient in any programming
language, one Firstly needs to understand the basics of
that language.
Therefore, below are the basics of Java in the format in which it
will help you the most to get the headstart:
1. Java Environment: The programming environment of
Java consists of three components mainly:
 JDK
 JRE
 JVM
2. Java Basic Syntax : Every programming language has
its own set of rules to declare, define and work on its
components. Reading and learning about all of them
together is difficult. Therefore here is a simple task
of printing "Hello World" in Java . During this process,
major components and their syntaxes are explained
clearly.
3. Comments in Java : In a program, comments take part
in making the program become more human-readable by
placing the detail of code involved and proper use of
comments makes maintenance easier and finding bugs
easily. Comments are ignored by the compiler while
compiling the code.
4. Data Types in Java : Each variable in Java has an
associated data type. Each data type requires different
amounts of memory and has some specific operations
which can be performed over it.
5. Variables in Java : A variable is the name given to a
memory location. It is the basic unit of storage in a
program.
 6. Keywords in Java : Keywords or Reserved words are
the words in a language that are used for some internal
process or represent some predefined actions. These
words are therefore not allowed to use as variable names
or objects. Doing this will result in a compile-time error.
8. Operators in Java : Operators are the foundation of any
programming language. Thus the functionality of Java
programming language is incomplete without the use of
operators. We can define operators as symbols that help
us to perform specific mathematical and logical
computations on operands. In other words, we can say
that an operator operates the operands.
9. Decision Making (Control Statements) in
Java : Decision Making in programming is similar to
decision making in real life. In programming also we face
some situations where we want a certain block of code to
be executed when some condition is fulfilled. A
programming language uses control statements to
control the flow of execution of the program based on
certain conditions. These are used to cause the flow of
execution to advance and branch based on changes to
the state of a program.
9. Loops in Java : Looping in programming languages is a
feature which facilitates the execution of a set of
instructions/functions repeatedly while some condition
evaluates to true. Java provides three ways for executing
the loops. While all the ways provide similar basic
functionality, they differ in their syntax and condition
checking time.

What is Java?
Java is a popular programming language, created in 1995.

It is owned by Oracle, and more than 3 billion devices run Java.

It is used for:

 Mobile applications (specially Android apps)

 Desktop applications
 Web applications
  Web servers and application servers
 Games
 Database connection
 And much, much more!

Why Use Java?

 Java works on different platforms (Windows, Mac, Linux, Raspberry Pi,
etc.)
 It is one of the most popular programming languages in the world
 It has a large demand in the current job market
 It is easy to learn and simple to use
 It is open-source and free
 It is secure, fast and powerful
 It has huge community support (tens of millions of developers)
 Java is an object oriented language which gives a clear structure to
programs and allows code to be reused, lowering development costs
 As Java is close to C++ and C#, it makes it easy for programmers to
switch to Java or vice versa

Java Install
However, if you want to run Java on your own computer, follow the
instructions below.

Some PCs might have Java already installed.

To check if you have Java installed on a Windows PC, search in the start bar
for Java or type the following in Command Prompt ([Link]):

C:\Users\Your Name>java -version

If Java is installed, you will see something like this (depending on version):

java version "22.0.0" 2024-08-21 LTS

Java(TM) SE Runtime Environment 22.9 (build 22.0.0+13-LTS)
Java HotSpot(TM) 64-Bit Server VM 22.9 (build 22.0.0+13-LTS,
mixed mode)

If you do not have Java installed on your computer, you can download it
at [Link].
Note: In this tutorial, we will write Java code in a text editor. However, it is
possible to write Java in an Integrated Development Environment, such as
IntelliJ IDEA, Netbeans or Eclipse, which are particularly useful when
managing larger collections of Java files.

Java Quickstart
In Java, every application begins with a class name, and that class must
match the filename.

Let's create our first Java file, called [Link], which can be done in any text
editor (like Notepad).

The file should contain a "Hello World" message, which is written with the
following code:

[Link]

public class Main {

public static void main(String[] args) {

[Link]("Hello World");

Don't worry if you don't understand the code above - we will discuss it in
detail in later chapters. For now, focus on how to run the code above.

Save the code in Notepad as "[Link]". Open Command Prompt ([Link]),

navigate to the directory where you saved your file, and type "javac
[Link]":

C:\Users\Your Name>javac [Link]

This will compile your code. If there are no errors in the code, the command
prompt will take you to the next line. Now, type "java Main" to run the file:

C:\Users\Your Name>java Main

The output should read:

Hello World

Congratulations! You have written and executed your first Java program.

Java Syntax
In the previous chapter, we created a Java file called [Link], and we used
the following code to print "Hello World" to the screen:

[Link]

public class Main {

public static void main(String[] args) {

[Link]("Hello World");

Example explained
Every line of code that runs in Java must be inside a class. And the class
name should always start with an uppercase first letter. In our example, we
named the class Main.

Note: Java is case-sensitive: "MyClass" and "myclass" has different meaning.

The name of the java file must match the class name. When saving the file,
save it using the class name and add ".java" to the end of the filename. To
run the example above on your computer, make sure that Java is properly
installed: Go to the Get Started Chapter for how to install Java. The output
should be:

Hello World
The main Method
The main() method is required and you will see it in every Java program:

public static void main(String[] args)

Any code inside the main() method will be executed. Don't worry about the
keywords before and after it. You will get to know them bit by bit while
reading this tutorial.

For now, just remember that every Java program has a class name which
must match the filename, and that every program must contain
the main() method.

[Link]()
Inside the main() method, we can use the println() method to print a line of
text to the screen:

public static void main(String[] args) {

[Link]("Hello World");

Note: The curly braces {} marks the beginning and the end of a block of
code.

System is a built-in Java class that contains useful members, such as out,
which is short for "output". The println() method, short for "print line", is
used to print a value to the screen (or a file).

Don't worry too much about how System, out and println() works. Just know
that you need them together to print stuff to the screen.

You should also note that each code statement must end with a semicolon
(;).

Java Output / Print

Print Text
You learned from the previous chapter that you can use
the println() method to output values or print text in Java:

[Link]("Hello World!");

You can add as many println() methods as you want. Note that it will add a
new line for each method:

Example
[Link]("Hello World!");

[Link]("I am learning Java.");

[Link]("It is awesome!");

Double Quotes
Text must be wrapped inside double quotations marks "".

If you forget the double quotes, an error occurs:

Example
[Link]("This sentence will work!");

[Link](This sentence will produce an error);

The Print() Method

There is also a print() method, which is similar to println().

The only difference is that it does not insert a new line at the end of the
output:
Example
[Link]("Hello World! ");

[Link]("I will print on the same line.");

Note that we add an extra space (after "Hello World!" in the example above)
for better readability.

In this tutorial, we will only use println() as it makes the code output easier
to read.

Java Output Numbers

Print Numbers
You can also use the println() method to print numbers.

However, unlike text, we don't put numbers inside double quotes:

[Link](3);

[Link](358);

[Link](50000);

You can also perform mathematical calculations inside the println() method:

Example
[Link](3 + 3);

Example
[Link](2 * 5);

Java Comments
Java Comments
Comments can be used to explain Java code, and to make it more readable. It
can also be used to prevent execution when testing alternative code.

Single-line Comments
Single-line comments start with two forward slashes ( //).

Any text between // and the end of the line is ignored by Java (will not be
executed).

This example uses a single-line comment before a line of code:

// This is a comment

[Link]("Hello World");

This example uses a single-line comment at the end of a line of code:

Example
[Link]("Hello World"); // This is a comment

Java Variables
Java Variables
Variables are containers for storing data values.

In Java, there are different types of variables, for example:

 String - stores text, such as "Hello". String values are surrounded by

double quotes
 int - stores integers (whole numbers), without decimals, such as 123
or -123
 float - stores floating point numbers, with decimals, such as 19.99 or -
19.99
  char - stores single characters, such as 'a' or 'B'. Char values are
surrounded by single quotes
 boolean - stores values with two states: true or false

Declaring (Creating) Variables

To create a variable, you must specify the type and assign it a value:

Syntax:

type variableName = value;

Where type is one of Java's types (such as int or String),

and variableName is the name of the variable (such as x or name).
The equal sign is used to assign values to the variable.

To create a variable that should store text, look at the following example:

Example
Create a variable called name of type String and assign it the value "John".
Then we use println() to print the name variable:

String name = "John";

[Link](name);

To create a variable that should store a number, look at the following

example:

Example
Create a variable called myNum of type int and assign it the value 15:

int myNum = 15;

[Link](myNum);

You can also declare a variable without assigning the value, and assign the
value later:
Example
int myNum;

myNum = 15;

[Link](myNum);

Note that if you assign a new value to an existing variable, it will overwrite
the previous value:

Example
Change the value of myNum from 15 to 20:

int myNum = 15;

myNum = 20; // myNum is now 20

[Link](myNum);

Final Variables
If you don't want others (or yourself) to overwrite existing values, use
the final keyword (this will declare the variable as "final" or "constant",
which means unchangeable and read-only):

Example
final int myNum = 15;

myNum = 20; // will generate an error: cannot assign a value to

a final variable

Other Types
A demonstration of how to declare variables of other types:
Example
int myNum = 5;

float myFloatNum = 5.99f;

char myLetter = 'D';

boolean myBool = true;

String myText = "Hello";

Display Variables
The println() method is often used to display variables.

To combine both text and a variable, use the + character:

ExampleGet your own Java Server

String name = "John";

[Link]("Hello " + name);

You can also use the + character to add a variable to another variable:

Example
String firstName = "John ";

String lastName = "Doe";

String fullName = firstName + lastName;

[Link](fullName);

For numeric values, the + character works as a mathematical operator (notice

that we use int (integer) variables here):

Example
int x = 5;

int y = 6;
[Link](x + y); // Print the value of x + y

From the example above, you can expect:

 x stores the value 5

 y stores the value 6
 Then we use the println() method to display the value of x + y,
which is 11

Declare Many Variables

To declare more than one variable of the same type, you can use a comma-
separated list:

Example
Instead of writing:

int x = 5;

int y = 6;

int z = 50;

[Link](x + y + z);

You can simply write:

int x = 5, y = 6, z = 50;

[Link](x + y + z);

One Value to Multiple Variables

You can also assign the same value to multiple variables in one line:

Example
int x, y, z;

x = y = z = 50;
[Link](x + y + z);

Identifiers
All Java variables must be identified with unique names.

These unique names are called identifiers.

Identifiers can be short names (like x and y) or more descriptive names (age,
sum, totalVolume).

Note: It is recommended to use descriptive names in order to create

understandable and maintainable code:

Example
// Good

int minutesPerHour = 60;

// OK, but not so easy to understand what m actually is

int m = 60;

The general rules for naming variables are:

 Names can contain letters, digits, underscores, and dollar signs

 Names must begin with a letter
 Names should start with a lowercase letter, and cannot contain
whitespace
 Names can also begin with $ and _
 Names are case-sensitive ("myVar" and "myvar" are different variables)
 Reserved words (like Java keywords, such as int or boolean) cannot
be used as names

Real-Life Examples
Often in our examples, we simplify variable names to match their data type
(myInt or myNum for int types, myChar for char types, and so on). This is
done to avoid confusion.
However, for a practical example of using variables, we have created a
program that stores different data about a college student:

Example
// Student data

String studentName = "John Doe";

int studentID = 15;

int studentAge = 23;

float studentFee = 75.25f;

char studentGrade = 'B';

// Print variables

[Link]("Student name: " + studentName);

[Link]("Student id: " + studentID);

[Link]("Student age: " + studentAge);

[Link]("Student fee: " + studentFee);

[Link]("Student grade: " + studentGrade);

Calculate the Area of a

Rectangle
In this real-life example, we create a program to calculate the area of a
rectangle (by multiplying the length and width):

Example
// Create integer variables

int length = 4;
int width = 6;

int area;

// Calculate the area of a rectangle

area = length * width;

// Print variables

[Link]("Length is: " + length);

[Link]("Width is: " + width);

[Link]("Area of the rectangle is: " + area);

Java Data Types

Java Data Types
As explained in the previous chapter, a variable in Java must be a specified
data type:

ExampleGet your own Java Server

int myNum = 5; // Integer (whole number)

float myFloatNum = 5.99f; // Floating point number

char myLetter = 'D'; // Character

boolean myBool = true; // Boolean

String myText = "Hello"; // String

Try it Yourself »

Data types are divided into two groups:

Data Type Description

byte Stores whole numbers from -128 to 127

short Stores whole numbers from -32,768 to 32,767

int Stores whole numbers from -2,147,483,648 to 2,147,483,647

long Stores whole numbers from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

float Stores fractional numbers. Sufficient for storing 6 to 7 decimal digits

double Stores fractional numbers. Sufficient for storing 15 to 16 decimal digits

boolean Stores true or false values

char Stores a single character/letter or ASCII values

 Primitive data types -

includes byte, short, int, long, float, double, boolean and char
 Non-primitive data types - such as String, Arrays and Classes (you will
learn more about these in a later chapter)
Primitive Data Types
A primitive data type specifies the type of a variable and the kind of values it
can hold.

There are eight primitive data types in Java:

Numbers
Primitive number types are divided into two groups:

Integer types stores whole numbers, positive or negative (such as 123 or -

456), without decimals. Valid types are byte, short, int and long. Which
type you should use, depends on the numeric value.

Floating point types represents numbers with a fractional part, containing

one or more decimals. There are two types: float and double.

Even though there are many numeric types in Java, the most used for
numbers are int (for whole numbers) and double (for floating point
numbers). However, we will describe them all as you continue to read.

Integer Types
Byte
The byte data type can store whole numbers from -128 to 127. This can be
used instead of int or other integer types to save memory when you are
certain that the value will be within -128 and 127:

Example
byte myNum = 100;

[Link](myNum);

Short
The short data type can store whole numbers from -32768 to 32767:
Example
short myNum = 5000;

[Link](myNum);

Int
The int data type can store whole numbers from -2147483648 to
2147483647. In general, and in our tutorial, the int data type is the
preferred data type when we create variables with a numeric value.

Example
int myNum = 100000;

[Link](myNum);

Long
The long data type can store whole numbers from -9223372036854775808
to 9223372036854775807. This is used when int is not large enough to store
the value. Note that you should end the value with an "L":

Example
long myNum = 15000000000L;

[Link](myNum);

Floating Point Types

You should use a floating point type whenever you need a number with a
decimal, such as 9.99 or 3.14515.

The float and double data types can store fractional numbers. Note that
you should end the value with an "f" for floats and "d" for doubles:
Float Example
float myNum = 5.75f;

[Link](myNum);

Double Example
double myNum = 19.99d;

[Link](myNum);

Use float or double?

The precision of a floating point value indicates how many digits the value
can have after the decimal point. The precision of float is only six or seven
decimal digits, while double variables have a precision of about 16 digits.
Therefore it is safer to use double for most calculations.

Scientific Numbers
A floating point number can also be a scientific number with an "e" to
indicate the power of 10:

Example
float f1 = 35e3f;

double d1 = 12E4d;

[Link](f1);

[Link](d1);

Boolean Types
Very often in programming, you will need a data type that can only have one
of two values, like:

 YES / NO
 ON / OFF
 TRUE / FALSE
For this, Java has a boolean data type, which can only take the
values true or false:

Example
boolean isJavaFun = true;

boolean isFishTasty = false;

[Link](isJavaFun); // Outputs true

[Link](isFishTasty); // Outputs false

Characters
The char data type is used to store a single character. The character must be
surrounded by single quotes, like 'A' or 'c':

Example
char myGrade = 'B';

[Link](myGrade);

Alternatively, if you are familiar with ASCII values, you can use those to
display certain characters:

Example
char myVar1 = 65, myVar2 = 66, myVar3 = 67;

[Link](myVar1);

[Link](myVar2);

[Link](myVar3);

Tip: A list of all ASCII values can be found in our ASCII Table Reference.
Strings
The String data type is used to store a sequence of characters (text). String
values must be surrounded by double quotes:

Example
String greeting = "Hello World";

[Link](greeting);

The String type is so much used and integrated in Java, that some call it "the
special ninth type".

A String in Java is actually a non-primitive data type, because it refers to an

object. The String object has methods that are used to perform certain
operations on strings. Don't worry if you don't understand the term
"object" just yet. We will learn more about strings and objects in a later
chapter.

Real-Life Example
Here's a real-life example of using different data types, to calculate and
output the total cost of a number of items:

Example
// Create variables of different data types

int items = 50;

float costPerItem = 9.99f;

float totalCost = items * costPerItem;

char currency = '$';

// Print variables

[Link]("Number of items: " + items);

[Link]("Cost per item: " + costPerItem + currency);

[Link]("Total cost = " + totalCost + currency);

Non-Primitive Data Types

Non-primitive data types are called reference types because they refer to
objects.

The main differences between primitive and non-primitive data types are:

 Primitive types in Java are predefined and built into the language, while
non-primitive types are created by the programmer (except
for String).
 Non-primitive types can be used to call methods to perform certain
operations, whereas primitive types cannot.
 Primitive types start with a lowercase letter (like int), while non-
primitive types typically starts with an uppercase letter (like String).
 Primitive types always hold a value, whereas non-primitive types can
be null.

Java Type Casting

Type casting is when you assign a value of one primitive data type to another
type.

In Java, there are two types of casting:

 Widening Casting (automatically) - converting a smaller type to a

larger type size
byte -> short -> char -> int -> long -> float -> double

 Narrowing Casting (manually) - converting a larger type to a smaller

size type
double -> float -> long -> int -> char -> short -> byte

Widening Casting
Widening casting is done automatically when passing a smaller size type to a
larger size type:
Example
public class Main {

public static void main(String[] args) {

int myInt = 9;

double myDouble = myInt; // Automatic casting: int to double

[Link](myInt); // Outputs 9

[Link](myDouble); // Outputs 9.0

Narrowing Casting
Narrowing casting must be done manually by placing the type in
parentheses () in front of the value:

Example
public class Main {

public static void main(String[] args) {

double myDouble = 9.78d;

int myInt = (int) myDouble; // Manual casting: double to int

[Link](myDouble); // Outputs 9.78

[Link](myInt); // Outputs 9

}
Real-Life Example
Here's a real-life example of type casting where we create a program to
calculate the percentage of a user's score in relation to the maximum score
in a game.

We use type casting to make sure that the result is a floating-point value,
rather than an integer:

Example
// Set the maximum possible score in the game to 500

int maxScore = 500;

// The actual score of the user

int userScore = 423;

/* Calculate the percentage of the user's score in relation to

the maximum available score.

Convert userScore to float to make sure that the division is

accurate */

float percentage = (float) userScore / maxScore * 100.0f;

[Link]("User's percentage is " + percentage);

Java Operators
Java Operators
Operators are used to perform operations on variables and values.
 In the example below, we use the + operator to add together two values:

ExampleGet your own Java Server

int x = 100 + 50;

Try it Yourself »

Although the + operator is often used to add together two values, like in the
example above, it can also be used to add together a variable and a value, or
a variable and another variable:

Example
int sum1 = 100 + 50; // 150 (100 + 50)

int sum2 = sum1 + 250; // 400 (150 + 250)

int sum3 = sum2 + sum2; // 800 (400 + 400)

Try it Yourself »

Java divides the operators into the following groups:

 Arithmetic operators
 Assignment operators
 Comparison operators
 Logical operators
 Bitwise operators

Arithmetic Operators
Arithmetic operators are used to perform common mathematical operations.

Operator Name Description Example

+ Addition Adds together two values x+y

- Subtraction Subtracts one value from another x-y

* Multiplication Multiplies two values x*y

/ Division Divides one value by another x/y

% Modulus Returns the division remainder x%y

++ Increment Increases the value of a variable by 1 ++x

-- Decrement Decreases the value of a variable by 1 --x

Java Strings
Strings are used for storing text.

A String variable contains a collection of characters surrounded by double

quotes:

Example
Create a variable of type String and assign it a value:
String greeting = "Hello";

String Length
A String in Java is actually an object, which contain methods that can perform
certain operations on strings. For example, the length of a string can be
found with the length() method:

Example
String txt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

[Link]("The length of the txt string is: " +

[Link]());

More String Methods

There are many string methods available, for
example toUpperCase() and toLowerCase():

Example
String txt = "Hello World";

[Link]([Link]()); // Outputs "HELLO WORLD"

[Link]([Link]()); // Outputs "hello world"

Finding a Character in a String

The indexOf() method returns the index (the position) of the first occurrence
of a specified text in a string (including whitespace):

Example
String txt = "Please locate where 'locate' occurs!";

[Link]([Link]("locate")); // Outputs 7
Java counts positions from zero.
0 is the first position in a string, 1 is the second, 2 is the third ...

String Concatenation
The + operator can be used between strings to combine them. This is
called concatenation:

Example
String firstName = "John";

String lastName = "Doe";

[Link](firstName + " " + lastName);

Note that we have added an empty text (" ") to create a space between
firstName and lastName on print.

You can also use the concat() method to concatenate two strings:

Example
String firstName = "John ";

String lastName = "Doe";

[Link]([Link](lastName));

Adding Numbers and Strings

WARNING!

Java uses the + operator for both addition and concatenation.

Numbers are added. Strings are concatenated.

If you add two numbers, the result will be a number:

Example
int x = 10;

int y = 20;
 int z = x + y; // z will be 30 (an integer/number)

If you add two strings, the result will be a string concatenation:

Example
String x = "10";

String y = "20";

String z = x + y; // z will be 1020 (a String)

If you add a number and a string, the result will be a string concatenation:

Example
String x = "10";

int y = 20;

String z = x + y; // z will be 1020 (a String)

Strings - Special Characters

Because strings must be written within quotes, Java will misunderstand this
string, and generate an error:

String txt = "We are the so-called "Vikings" from the north.";

The solution to avoid this problem, is to use the backslash escape

character.

The backslash (\) escape character turns special characters into string
characters:

Escape character Result Description

\' ' Single quote

\" " Double quote

\\ \ Backslash

The sequence \" inserts a double quote in a string:

Example
String txt = "We are the so-called \"Vikings\" from the north.";

The sequence \' inserts a single quote in a string:

Example
String txt = "It\'s alright.";

The sequence \\ inserts a single backslash in a string:

Example
String txt = "The character \\ is called backslash.";

Other common escape sequences that are valid in Java are:

Code Result

\n New Line

\r Carriage Return

\t Tab
 \b Backspace

\f Form Feed

Java Math
[Link](x,y)
The [Link](x,y) method can be used to find the highest value of x and y:

Example
[Link](5, 10);

[Link](x,y)
The [Link](x,y) method can be used to find the lowest value of x and y:

Example
[Link](5, 10);

[Link](x)
The [Link](x) method returns the square root of x:
Example
[Link](64);

Java Booleans
Very often, in programming, you will need a data type that can only have one
of two values, like:

 YES / NO
 ON / OFF
 TRUE / FALSE

For this, Java has a boolean data type, which can store true or false values.

Boolean Values
A boolean type is declared with the boolean keyword and can only take the
values true or false:

Example
boolean isJavaFun = true;

boolean isFishTasty = false;

[Link](isJavaFun); // Outputs true

[Link](isFishTasty); // Outputs false

However, it is more common to return boolean values from boolean

expressions, for conditional testing (see below).

Boolean Expression
A Boolean expression returns a boolean value: true or false.
This is useful to build logic, and find answers.

For example, you can use a comparison operator, such as the greater
than (>) operator, to find out if an expression (or a variable) is true or false:

Example
int x = 10;

int y = 9;

[Link](x > y); // returns true, because 10 is higher

than 9

Or even easier:

Example
[Link](10 > 9); // returns true, because 10 is higher
than 9

In the examples below, we use the equal to (==) operator to evaluate an

expression:

Example
int x = 10;

[Link](x == 10); // returns true, because the value

of x is equal to 10

Example
[Link](10 == 15); // returns false, because 10 is not
equal to 15

Real Life Example

Let's think of a "real life example" where we need to find out if a person is old
enough to vote.
In the example below, we use the >= comparison operator to find out if the
age (25) is greater than OR equal to the voting age limit, which is set to 18:

Example
int myAge = 25;

int votingAge = 18;

[Link](myAge >= votingAge);

Cool, right? An even better approach (since we are on a roll now), would be to
wrap the code above in an if...else statement, so we can perform different
actions depending on the result:

Example
Output "Old enough to vote!" if myAge is greater than or equal to 18.
Otherwise output "Not old enough to vote.":

int myAge = 25;

int votingAge = 18;

if (myAge >= votingAge) {

[Link]("Old enough to vote!");

} else {

[Link]("Not old enough to vote.");

Booleans are the basis for all Java comparisons and conditions.

You will learn more about conditions (if...else) in the next chapter.

Java If ... Else

Java Conditions and If
Statements
You already know that Java supports the usual logical conditions from
mathematics:

 Less than: a < b

 Less than or equal to: a <= b
 Greater than: a > b
 Greater than or equal to: a >= b
 Equal to a == b
 Not Equal to: a != b

You can use these conditions to perform different actions for different
decisions.

Java has the following conditional statements:

 Use if to specify a block of code to be executed, if a specified

condition is true
 Use else to specify a block of code to be executed, if the same
condition is false
 Use else if to specify a new condition to test, if the first condition is
false
 Use switch to specify many alternative blocks of code to be executed

The if Statement
Use the if statement to specify a block of Java code to be executed if a
condition is true.

Syntax
if (condition) {

// block of code to be executed if the condition is true

}
Note that if is in lowercase letters. Uppercase letters (If or IF) will generate
an error.

In the example below, we test two values to find out if 20 is greater than 18.
If the condition is true, print some text:

Example
if (20 > 18) {

[Link]("20 is greater than 18");

We can also test variables:

Example
int x = 20;

int y = 18;

if (x > y) {

[Link]("x is greater than y");

Example explained
In the example above we use two variables, x and y, to test whether x is
greater than y (using the > operator). As x is 20, and y is 18, and we know
that 20 is greater than 18, we print to the screen that "x is greater than y".

The else Statement

Use the else statement to specify a block of code to be executed if the
condition is false.

Syntax
if (condition) {

// block of code to be executed if the condition is true

} else {

// block of code to be executed if the condition is false

Example
int time = 20;

if (time < 18) {

[Link]("Good day.");

} else {

[Link]("Good evening.");

// Outputs "Good evening."

Example explained
In the example above, time (20) is greater than 18, so the condition is false.
Because of this, we move on to the else condition and print to the screen
"Good evening". If the time was less than 18, the program would print "Good
day".

The else if Statement

Use the else if statement to specify a new condition if the first condition
is false.

Syntax
if (condition1) {

// block of code to be executed if condition1 is true

} else if (condition2) {

// block of code to be executed if the condition1 is false and

condition2 is true
} else {

// block of code to be executed if the condition1 is false and

condition2 is false

Example
int time = 22;

if (time < 10) {

[Link]("Good morning.");

} else if (time < 18) {

[Link]("Good day.");

} else {

[Link]("Good evening.");

// Outputs "Good evening."

Example explained
In the example above, time (22) is greater than 10, so the first
condition is false. The next condition, in the else if statement, is
also false, so we move on to the else condition
since condition1 and condition2 is both false - and print to the screen
"Good evening".

However, if the time was 14, our program would print "Good day."

Short Hand if...else

There is also a short-hand if else, which is known as the ternary
operator because it consists of three operands.

It can be used to replace multiple lines of code with a single line, and is most
often used to replace simple if else statements:
Syntax
variable = (condition) ? expressionTrue : expressionFalse;

Instead of writing:

Example
int time = 20;

if (time < 18) {

[Link]("Good day.");

} else {

[Link]("Good evening.");

You can simply write:

Example
int time = 20;

String result = (time < 18) ? "Good day." : "Good evening.";

[Link](result);

Real-Life Examples
This example shows how you can use if..else to "open a door" if the user
enters the correct code:

Example
int doorCode = 1337;

if (doorCode == 1337) {
 [Link]("Correct code. The door is now open.");

} else {

[Link]("Wrong code. The door remains closed.");

This example shows how you can use if..else to find out if a number is
positive or negative:

Example
int myNum = 10; // Is this a positive or negative number?

if (myNum > 0) {

[Link]("The value is a positive number.");

} else if (myNum < 0) {

[Link]("The value is a negative number.");

} else {

[Link]("The value is 0.");

Find out if a person is old enough to vote:

Example
int myAge = 25;

int votingAge = 18;

if (myAge >= votingAge) {

[Link]("Old enough to vote!");

} else {

[Link]("Not old enough to vote.");

}

Find out if a number is even or odd:

Example
int myNum = 5;

if (myNum % 2 == 0) {

[Link](myNum + " is even");

} else {

[Link](myNum + " is odd");

Java Switch
Instead of writing many if..else statements, you can use
the switch statement.

The switch statement selects one of many code blocks to be executed:

Syntax
switch(expression) {

case x:

// code block

break;

case y:

// code block

break;

default:

// code block
}

This is how it works:

 The switch expression is evaluated once.

 The value of the expression is compared with the values of each case.
 If there is a match, the associated block of code is executed.
 The break and default keywords are optional, and will be described
later in this chapter

The example below uses the weekday number to calculate the weekday
name:

Example
int day = 4;

switch (day) {

case 1:

[Link]("Monday");

break;

case 2:

[Link]("Tuesday");

break;

case 3:

[Link]("Wednesday");

break;

case 4:

[Link]("Thursday");

break;

case 5:

[Link]("Friday");

break;
 case 6:

[Link]("Saturday");

break;

case 7:

[Link]("Sunday");

break;

// Outputs "Thursday" (day 4)

The break Keyword

When Java reaches a break keyword, it breaks out of the switch block.

This will stop the execution of more code and case testing inside the block.

When a match is found, and the job is done, it's time for a break. There is no
need for more testing.

A break can save a lot of execution time because it "ignores" the execution of
all the rest of the code in the switch block.

The default Keyword

The default keyword specifies some code to run if there is no case match:

Example
int day = 4;

switch (day) {

case 6:

[Link]("Today is Saturday");
 break;

case 7:

[Link]("Today is Sunday");

break;

default:

[Link]("Looking forward to the Weekend");

// Outputs "Looking forward to the Weekend"

Note that if the default statement is used as the last statement in a switch
block, it does not need a break.

Java While Loop

Loops
Loops can execute a block of code as long as a specified condition is reached.

Loops are handy because they save time, reduce errors, and they make code
more readable.

Java While Loop

The while loop loops through a block of code as long as a specified condition
is true:

Syntax
while (condition) {

// code block to be executed

}
In the example below, the code in the loop will run, over and over again, as
long as a variable (i) is less than 5:

Example
int i = 0;

while (i < 5) {

[Link](i);

i++;

Note: Do not forget to increase the variable used in the condition, otherwise
the loop will never end!

The Do/While Loop

The do/while loop is a variant of the while loop. This loop will execute the
code block once, before checking if the condition is true, then it will repeat
the loop as long as the condition is true.

Syntax
do {

// code block to be executed

while (condition);

The example below uses a do/while loop. The loop will always be executed at
least once, even if the condition is false, because the code block is executed
before the condition is tested:

Example
int i = 0;
do {
 [Link](i);

i++;

while (i < 5);

Do not forget to increase the variable used in the condition, otherwise the
loop will never end!

Real-Life Examples
To demonstrate a practical example of the while loop, we have created a
simple "countdown" program:

Example
int countdown = 3;

while (countdown > 0) {

[Link](countdown);

countdown--;

[Link]("Happy New Year!!");

To demonstrate a practical example of the while loop combined with an if

else statement, let's say we play a game of Yatzy:

Example
Print "Yatzy!" If the dice number is 6:

int dice = 1;

while (dice <= 6) {

 if (dice < 6) {

[Link]("No Yatzy.");

} else {

[Link]("Yatzy!");

dice = dice + 1;

If the loop passes the values ranging from 1 to 5, it prints "No Yatzy".
Whenever it passes the value 6, it prints "Yatzy!".

Java For Loop

When you know exactly how many times you want to loop through a block of
code, use the for loop instead of a while loop:

Syntax
for (statement 1; statement 2; statement 3) {

// code block to be executed

Statement 1 is executed (one time) before the execution of the code block.

Statement 2 defines the condition for executing the code block.

Statement 3 is executed (every time) after the code block has been
executed.

The example below will print the numbers 0 to 4:

Example
for (int i = 0; i < 5; i++) {

[Link](i);
}

Example explained
Statement 1 sets a variable before the loop starts (int i = 0).

Statement 2 defines the condition for the loop to run (i must be less than 5).
If the condition is true, the loop will start over again, if it is false, the loop will
end.

Statement 3 increases a value (i++) each time the code block in the loop has
been executed.

Another Example
This example will only print even values between 0 and 10:

Example
for (int i = 0; i <= 10; i = i + 2) {

[Link](i);

Nested Loops
It is also possible to place a loop inside another loop. This is called a nested
loop.

The "inner loop" will be executed one time for each iteration of the "outer
loop":

Example
// Outer loop

for (int i = 1; i <= 2; i++) {

[Link]("Outer: " + i); // Executes 2 times

 // Inner loop

for (int j = 1; j <= 3; j++) {

[Link](" Inner: " + j); // Executes 6 times (2 *

3)

For-Each Loop
There is also a "for-each" loop, which is used exclusively to loop through
elements in an array (or other data sets):

Syntax
for (type variableName : arrayName) {

// code block to be executed

The following example outputs all elements in the cars array, using a "for-
each" loop:

Example
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

for (String i : cars) {

[Link](i);

Real-Life Examples
To demonstrate a practical example of the for loop, let's create a program
that counts to 100 by tens:
Example
for (int i = 0; i <= 100; i += 10) {

[Link](i);

In this example, we create a program that only print even values between 0
and 10:

Example
for (int i = 0; i <= 10; i = i + 2) {

[Link](i);

And in this example, we create a program that prints the multiplication table
for a specified number:

Example
int number = 2;

// Print the multiplication table for the number 2

for (int i = 1; i <= 10; i++) {

[Link](number + " x " + i + " = " + (number * i));

Java Break and Continue

Java Break
You have already seen the break statement used in an earlier chapter of this
tutorial. It was used to "jump out" of a switch statement.

The break statement can also be used to jump out of a loop.

This example stops the loop when i is equal to 4:

Example
for (int i = 0; i < 10; i++) {

if (i == 4) {

break;

[Link](i);

Java Continue
The continue statement breaks one iteration (in the loop), if a specified
condition occurs, and continues with the next iteration in the loop.

This example skips the value of 4:

Example
for (int i = 0; i < 10; i++) {

if (i == 4) {

continue;

[Link](i);

Break and Continue in While

Loop
You can also use break and continue in while loops:
Break Example
int i = 0;

while (i < 10) {

[Link](i);

i++;

if (i == 4) {

break;

Continue Example
int i = 0;

while (i < 10) {

if (i == 4) {

i++;

continue;

[Link](i);

i++;

Java Arrays
Arrays are used to store multiple values in a single variable, instead of
declaring separate variables for each value.

To declare an array, define the variable type with square brackets:

String[] cars;

We have now declared a variable that holds an array of strings. To insert

values to it, you can place the values in a comma-separated list, inside curly
braces:

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

To create an array of integers, you could write:

int[] myNum = {10, 20, 30, 40};

Access the Elements of an Array

You can access an array element by referring to the index number.

This statement accesses the value of the first element in cars:

Example
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

[Link](cars[0]);

// Outputs Volvo

Note: Array indexes start with 0: [0] is the first element. [1] is the second
element, etc.

Change an Array Element

To change the value of a specific element, refer to the index number:

Example
cars[0] = "Opel";
Example
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

cars[0] = "Opel";

[Link](cars[0]);

// Now outputs Opel instead of Volvo

Array Length
To find out how many elements an array has, use the length property:

Example
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

[Link]([Link]);

// Outputs 4

Loop Through an Array

You can loop through the array elements with the for loop, and use
the length property to specify how many times the loop should run.

The following example outputs all elements in the cars array:

Example
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

for (int i = 0; i < [Link]; i++) {

[Link](cars[i]);

}
Loop Through an Array with For-
Each
There is also a "for-each" loop, which is used exclusively to loop through
elements in arrays:

Syntax
for (type variable : arrayname) {

...

The following example outputs all elements in the cars array, using a "for-
each" loop:

Example
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

for (String i : cars) {

[Link](i);

The example above can be read like this: for each String element (called i -
as in index) in cars, print out the value of i.

If you compare the for loop and for-each loop, you will see that the for-
each method is easier to write, it does not require a counter (using the
length property), and it is more readable.

Real-Life Example
To demonstrate a practical example of using arrays, let's create a program
that calculates the average of different ages:

Example
// An array storing different ages
int ages[] = {20, 22, 18, 35, 48, 26, 87, 70};

float avg, sum = 0;

// Get the length of the array

int length = [Link];

// Loop through the elements of the array

for (int age : ages) {

sum += age;

// Calculate the average by dividing the sum by the length

avg = sum / length;

// Print the average

[Link]("The average age is: " + avg);

And in this example, we create a program that finds the lowest age among
different ages:

Example
// An array storing different ages

int ages[] = {20, 22, 18, 35, 48, 26, 87, 70};

// Get the length of the array

int length = [Link];

// Create a 'lowest age' variable and assign the first array
element of ages to it

int lowestAge = ages[0];

// Loop through the elements of the ages array to find the lowest
age

for (int age : ages) {

// Check if the current age is smaller than the current 'lowest

age'

if (lowestAge > age) {

// If the smaller age is found, update 'lowest age' with that

element

lowestAge = age;

// Output the value of the lowest age

[Link]("The lowest age in the array is: " +

lowestAge);

Multidimensional Arrays
A multidimensional array is an array of arrays.

Multidimensional arrays are useful when you want to store data as a tabular
form, like a table with rows and columns.

To create a two-dimensional array, add each array within its own set of curly
braces:
ExampleGet your own Java Server
int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };

myNumbers is now an array with two arrays as its elements.

Access Elements
To access the elements of the myNumbers array, specify two indexes: one
for the array, and one for the element inside that array. This example
accesses the third element (2) in the second array (1) of myNumbers:

Example
int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };

[Link](myNumbers[1][2]); // Outputs 7

Remember that: Array indexes start with 0: [0] is the first element. [1] is
the second element, etc.

Change Element Values

You can also change the value of an element:

Example
int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };

myNumbers[1][2] = 9;

[Link](myNumbers[1][2]); // Outputs 9 instead of 7

Loop Through a Multi-
Dimensional Array
You can also use a for loop inside another for loop to get the elements of a
two-dimensional array (we still have to point to the two indexes):

Example
int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };

for (int i = 0; i < [Link]; ++i) {

for (int j = 0; j < myNumbers[i].length; ++j) {

[Link](myNumbers[i][j]);

}
}

Or you could just use a for-each loop, which is considered easier to read and
write:

Example
int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };

for (int[] row : myNumbers) {

for (int i : row) {

[Link](i);

Java Methods
A method is a block of code which only runs when it is called.

You can pass data, known as parameters, into a method.

Methods are used to perform certain actions, and they are also known
as functions.

Why use methods? To reuse code: define the code once, and use it many
times.

Create a Method
A method must be declared within a class. It is defined with the name of the
method, followed by parentheses (). Java provides some pre-defined
methods, such as [Link](), but you can also create your own
methods to perform certain actions:

Example
Create a method inside Main:

public class Main {

static void myMethod() {

// code to be executed

Example Explained

 myMethod() is the name of the method

 static means that the method belongs to the Main class and not an
object of the Main class. You will learn more about objects and how to
access methods through objects later in this tutorial.
 void means that this method does not have a return value. You will
learn more about return values later in this chapter
Call a Method
To call a method in Java, write the method's name followed by two
parentheses () and a semicolon;

In the following example, myMethod() is used to print a text (the action), when
it is called:

Example
Inside main, call the myMethod() method:

public class Main {

static void myMethod() {

[Link]("I just got executed!");

public static void main(String[] args) {

myMethod();

// Outputs "I just got executed!"

A method can also be called multiple times:

Example
public class Main {

static void myMethod() {

[Link]("I just got executed!");

 }

public static void main(String[] args) {

myMethod();

myMethod();

myMethod();

// I just got executed!

// I just got executed!

// I just got executed!

Method Overloading
With method overloading, multiple methods can have the same name with
different parameters:

Example
int myMethod(int x)

float myMethod(float x)

double myMethod(double x, double y)

Consider the following example, which has two methods that add numbers of
different type:
Example
static int plusMethodInt(int x, int y) {

return x + y;

static double plusMethodDouble(double x, double y) {

return x + y;

public static void main(String[] args) {

int myNum1 = plusMethodInt(8, 5);

double myNum2 = plusMethodDouble(4.3, 6.26);

[Link]("int: " + myNum1);

[Link]("double: " + myNum2);

Instead of defining two methods that should do the same thing, it is better to
overload one.

In the example below, we overload the plusMethod method to work for

both int and double:

Example
static int plusMethod(int x, int y) {

return x + y;

static double plusMethod(double x, double y) {

 return x + y;

public static void main(String[] args) {

int myNum1 = plusMethod(8, 5);

double myNum2 = plusMethod(4.3, 6.26);

[Link]("int: " + myNum1);

[Link]("double: " + myNum2);

Note: Multiple methods can have the same name as long as the number
and/or type of parameters are different.

Java Scope
In Java, variables are only accessible inside the region they are created. This
is called scope.

Method Scope
Variables declared directly inside a method are available anywhere in the
method following the line of code in which they were declared:

Example
public class Main {

public static void main(String[] args) {

// Code here CANNOT use x

int x = 100;
 // Code here can use x

[Link](x);

Block Scope
A block of code refers to all of the code between curly braces {}.

Variables declared inside blocks of code are only accessible by the code
between the curly braces, which follows the line in which the variable was
declared:

Example
public class Main {

public static void main(String[] args) {

// Code here CANNOT use x

{ // This is a block

// Code here CANNOT use x

int x = 100;

// Code here CAN use x

[Link](x);
 } // The block ends here

// Code here CANNOT use x

A block of code may exist on its own or it can belong to

an if, while or for statement. In the case of for statements, variables
declared in the statement itself are also available inside the block's scope.

Java Recursion
Recursion is the technique of making a function call itself. This technique
provides a way to break complicated problems down into simple problems
which are easier to solve.

Recursion may be a bit difficult to understand. The best way to figure out how
it works is to experiment with it.

Recursion Example
Adding two numbers together is easy to do, but adding a range of numbers is
more complicated. In the following example, recursion is used to add a range
of numbers together by breaking it down into the simple task of adding two
numbers:

Example
Use recursion to add all of the numbers up to 10.

public class Main {

public static void main(String[] args) {

int result = sum(10);

 [Link](result);

public static int sum(int k) {

if (k > 0) {

return k + sum(k - 1);

} else {

return 0;

Example Explained
When the sum() function is called, it adds parameter k to the sum of all
numbers smaller than k and returns the result. When k becomes 0, the
function just returns 0. When running, the program follows these steps:

10 + sum(9)
10 + ( 9 + sum(8) )
10 + ( 9 + ( 8 + sum(7) ) )
...
10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + sum(0)
10 +9+8+7+6+5+4+3+2+1+0

Since the function does not call itself when k is 0, the program stops there
and returns the result

Halting Condition
Just as loops can run into the problem of infinite looping, recursive functions
can run into the problem of infinite recursion. Infinite recursion is when the
function never stops calling itself. Every recursive function should have a
halting condition, which is the condition where the function stops calling
itself. In the previous example, the halting condition is when the
parameter k becomes 0.
It is helpful to see a variety of different examples to better understand the
concept. In this example, the function adds a range of numbers between a
start and an end. The halting condition for this recursive function is
when end is not greater than start:

Example
Use recursion to add all of the numbers between 5 to 10.

public class Main {

public static void main(String[] args) {

int result = sum(5, 10);

[Link](result);

public static int sum(int start, int end) {

if (end > start) {

return end + sum(start, end - 1);

} else {

return end;

The developer should be very careful with recursion as it can be quite easy to
slip into writing a function which never terminates, or one that uses excess
amounts of memory or processor power. However, when written correctly
recursion can be a very efficient and mathematically-elegant approach to
programming.

Java - What is OOP?

OOP stands for Object-Oriented Programming.
Procedural programming is about writing procedures or methods that
perform operations on the data, while object-oriented programming is about
creating objects that contain both data and methods.

Object-oriented programming has several advantages over procedural

programming:

 OOP is faster and easier to execute

 OOP provides a clear structure for the programs
 OOP helps to keep the Java code DRY "Don't Repeat Yourself", and
makes the code easier to maintain, modify and debug
 OOP makes it possible to create full reusable applications with less
code and shorter development time

Tip: The "Don't Repeat Yourself" (DRY) principle is about reducing the
repetition of code. You should extract out the codes that are common for the
application, and place them at a single place and reuse them instead of
repeating it.

Java - What are Classes and

Objects?
Classes and objects are the two main aspects of object-oriented
programming.

Look at the following illustration to see the difference between class and
objects:

class
Fruit

objects
Apple

Banana
 Mango

Another example:

class
Car

objects
Volvo

Audi

Toyota

So, a class is a template for objects, and an object is an instance of a class.

When the individual objects are created, they inherit all the variables and
methods from the class.

Java Classes and Objects

Java is an object-oriented programming language.

Everything in Java is associated with classes and objects, along with its
attributes and methods. For example: in real life, a car is an object. The car
has attributes, such as weight and color, and methods, such as drive and
brake.

A Class is like an object constructor, or a "blueprint" for creating objects.

Create a Class
To create a class, use the keyword class:

[Link]
Create a class named "Main" with a variable x:

public class Main {

int x = 5;

Remember from the Java Syntax chapter that a class should always start with
an uppercase first letter, and that the name of the java file should match the
class name.

Create an Object
In Java, an object is created from a class. We have already created the class
named Main, so now we can use this to create objects.

To create an object of Main, specify the class name, followed by the object
name, and use the keyword new:

Example
Create an object called "myObj" and print the value of x:

public class Main {

int x = 5;

public static void main(String[] args) {

Main myObj = new Main();

[Link](myObj.x);
 }

Java Class Attributes

In the previous chapter, we used the term "variable" for x in the example (as
shown below). It is actually an attribute of the class. Or you could say that
class attributes are variables within a class:

Example
Create a class called "Main" with two attributes: x and y:

public class Main {

int x = 5;

int y = 3;

Another term for class attributes is fields.

Accessing Attributes
You can access attributes by creating an object of the class, and by using the
dot syntax (.):

The following example will create an object of the Main class, with the
name myObj. We use the x attribute on the object to print its value:

Example
Create an object called "myObj" and print the value of x:

public class Main {

int x = 5;
 public static void main(String[] args) {

Main myObj = new Main();

[Link](myObj.x);

Modify Attributes
You can also modify attribute values:

Example
Set the value of x to 40:

public class Main {

int x;

public static void main(String[] args) {

Main myObj = new Main();

myObj.x = 40;

[Link](myObj.x);

Or override existing values:

Example
Change the value of x to 25:

public class Main {

int x = 10;
 public static void main(String[] args) {

Main myObj = new Main();

myObj.x = 25; // x is now 25

[Link](myObj.x);

If you don't want the ability to override existing values, declare the attribute
as final:

Example
public class Main {

final int x = 10;

public static void main(String[] args) {

Main myObj = new Main();

myObj.x = 25; // will generate an error: cannot assign a

value to a final variable

[Link](myObj.x);

The final keyword is useful when you want a variable to always store the
same value, like PI (3.14159...).

The final keyword is called a "modifier".

Java Class Methods
You learned from the Java Methods chapter that methods are declared within
a class, and that they are used to perform certain actions:

Example
Create a method named myMethod() in Main:

public class Main {

static void myMethod() {

[Link]("Hello World!");

myMethod() prints a text (the action), when it is called. To call a method,

write the method's name followed by two parentheses () and a semicolon;

Example
Inside main, call myMethod():

public class Main {

static void myMethod() {

[Link]("Hello World!");

public static void main(String[] args) {

myMethod();

}
// Outputs "Hello World!"

Static vs. Public

You will often see Java programs that have
either static or public attributes and methods.

In the example above, we created a static method, which means that it can
be accessed without creating an object of the class, unlike public, which can
only be accessed by objects:

Example
An example to demonstrate the differences
between static and public methods:

public class Main {

// Static method

static void myStaticMethod() {

[Link]("Static methods can be called without

creating objects");

// Public method

public void myPublicMethod() {

[Link]("Public methods must be called by creating

objects");

// Main method

public static void main(String[] args) {

 myStaticMethod(); // Call the static method

// myPublicMethod(); This would compile an error

Main myObj = new Main(); // Create an object of Main

[Link](); // Call the public method on the

object

Note: You will learn more about these keywords (called modifiers) in the Java
Modifiers chapter.

Access Methods With an Object

Example
Create a Car object named myCar. Call
the fullThrottle() and speed() methods on the myCar object, and run the
program:

// Create a Main class

public class Main {

// Create a fullThrottle() method

public void fullThrottle() {

[Link]("The car is going as fast as it can!");

}
 // Create a speed() method and add a parameter

public void speed(int maxSpeed) {

[Link]("Max speed is: " + maxSpeed);

// Inside main, call the methods on the myCar object

public static void main(String[] args) {

Main myCar = new Main(); // Create a myCar object

[Link](); // Call the fullThrottle() method

[Link](200); // Call the speed() method

// The car is going as fast as it can!

// Max speed is: 200

Example explained
1) We created a custom Main class with the class keyword.

2) We created the fullThrottle() and speed() methods in the Main class.

3) The fullThrottle() method and the speed() method will print out some
text, when they are called.

4) The speed() method accepts an int parameter called maxSpeed - we will

use this in 8).

5) In order to use the Main class and its methods, we need to create
an object of the Main Class.

6) Then, go to the main() method, which you know by now is a built-in Java
method that runs your program (any code inside main is executed).
7) By using the new keyword we created an object with the name myCar.

8) Then, we call the fullThrottle() and speed() methods on

the myCar object, and run the program using the name of the object ( myCar),
followed by a dot (.), followed by the name of the method
(fullThrottle(); and speed(200);). Notice that we add an int parameter
of 200 inside the speed() method.

Remember that..
The dot (.) is used to access the object's attributes and methods.

To call a method in Java, write the method name followed by a set of

parentheses (), followed by a semicolon (;).

A class must have a matching filename (Main and [Link]).

Java Constructors
A constructor in Java is a special method that is used to initialize objects.
The constructor is called when an object of a class is created. It can be used
to set initial values for object attributes:

Example
Create a constructor:

// Create a Main class

public class Main {

int x; // Create a class attribute

// Create a class constructor for the Main class

public Main() {

x = 5; // Set the initial value for the class attribute x

public static void main(String[] args) {

 Main myObj = new Main(); // Create an object of class Main
(This will call the constructor)

[Link](myObj.x); // Print the value of x

// Outputs 5

Note that the constructor name must match the class name, and it cannot
have a return type (like void).

Also note that the constructor is called when the object is created.

All classes have constructors by default: if you do not create a class

constructor yourself, Java creates one for you. However, then you are not
able to set initial values for object attributes.

Constructor Parameters
Constructors can also take parameters, which is used to initialize attributes.

The following example adds an int y parameter to the constructor. Inside the
constructor we set x to y (x=y). When we call the constructor, we pass a
parameter to the constructor (5), which will set the value of x to 5:

Example
public class Main {

int x;

public Main(int y) {

x = y;

}
 public static void main(String[] args) {

Main myObj = new Main(5);

[Link](myObj.x);

// Outputs 5

You can have as many parameters as you want:

Example
public class Main {

int modelYear;

String modelName;

public Main(int year, String name) {

modelYear = year;

modelName = name;

public static void main(String[] args) {

Main myCar = new Main(1969, "Mustang");

[Link]([Link] + " " + [Link]);

}
// Outputs 1969 Mustang

Modifiers
By now, you are quite familiar with the public keyword that appears in almost
all of our examples:

public class Main

The public keyword is an access modifier, meaning that it is used to set the
access level for classes, attributes, methods and constructors.

We divide modifiers into two groups:

 Access Modifiers - controls the access level

 Non-Access Modifiers - do not control access level, but provides
other functionality

Access Modifiers
For classes, you can use either public or default:

Modifier Description

public The class is accessible by any other class

default The class is only accessible by classes in the same package. This is used when you don't spec
learn more about packages in the Packages chapter

For attributes, methods and constructors, you can use the one of the
following:
 Modifier Description

public The code is accessible for all classes

private The code is only accessible within the declared class

default The code is only accessible in the same package. This is used when you don't specify a mo
more about packages in the Packages chapter

protected The code is accessible in the same package and subclasses. You will learn more about subc
superclasses in the Inheritance chapter

Non-Access Modifiers
For classes, you can use either final or abstract:

Modifier Description

final The class cannot be inherited by other classes (You will learn more about inheritance in the In

abstract The class cannot be used to create objects (To access an abstract class, it must be inherited fro
will learn more about inheritance and abstraction in the Inheritance and Abstraction chapters
For attributes and methods, you can use the one of the following:

Modifier Description

final Attributes and methods cannot be overridden/modified

static Attributes and methods belongs to the class, rather than an object

abstract Can only be used in an abstract class, and can only be used on methods. The method does n
example abstract void run();. The body is provided by the subclass (inherited from). You will
abstraction in the Inheritance and Abstraction chapters

transient Attributes and methods are skipped when serializing the object containing them

synchronized Methods can only be accessed by one thread at a time

volatile The value of an attribute is not cached thread-locally, and is always read from the "main me

Final
If you don't want the ability to override existing attribute values, declare
attributes as final:

Example
public class Main {
 final int x = 10;

final double PI = 3.14;

public static void main(String[] args) {

Main myObj = new Main();

myObj.x = 50; // will generate an error: cannot assign a

value to a final variable

[Link] = 25; // will generate an error: cannot assign a

value to a final variable

[Link](myObj.x);

Static
A static method means that it can be accessed without creating an object of
the class, unlike public:

Example
An example to demonstrate the differences
between static and public methods:

public class Main {

// Static method

static void myStaticMethod() {

[Link]("Static methods can be called without

creating objects");

}
 // Public method

public void myPublicMethod() {

[Link]("Public methods must be called by creating

objects");

// Main method

public static void main(String[ ] args) {

myStaticMethod(); // Call the static method

// myPublicMethod(); This would output an error

Main myObj = new Main(); // Create an object of Main

[Link](); // Call the public method

Abstract
An abstract method belongs to an abstract class, and it does not have a
body. The body is provided by the subclass:

Example
// Code from filename: [Link]

// abstract class
abstract class Main {
 public String fname = "John";

public int age = 24;

public abstract void study(); // abstract method

// Subclass (inherit from Main)

class Student extends Main {

public int graduationYear = 2018;

public void study() { // the body of the abstract method is

provided here

[Link]("Studying all day long");

// End code from filename: [Link]

// Code from filename: [Link]

class Second {

public static void main(String[] args) {

// create an object of the Student class (which inherits

attributes and methods from Main)

Student myObj = new Student();

[Link]("Name: " + [Link]);

[Link]("Age: " + [Link]);

[Link]("Graduation Year: " +

[Link]);
 [Link](); // call abstract method
}

Encapsulation
The meaning of Encapsulation, is to make sure that "sensitive" data is
hidden from users. To achieve this, you must:

 declare class variables/attributes as private

 provide public get and set methods to access and update the value of
a private variable

Get and Set

You learned from the previous chapter that private variables can only be
accessed within the same class (an outside class has no access to it).
However, it is possible to access them if we provide
public get and set methods.

The get method returns the variable value, and the set method sets the
value.

Syntax for both is that they start with either get or set, followed by the
name of the variable, with the first letter in upper case:

Example
public class Person {

private String name; // private = restricted access

// Getter

public String getName() {

return name;

}
 // Setter

public void setName(String newName) {

[Link] = newName;

Example explained

The get method returns the value of the variable name.

The set method takes a parameter (newName) and assigns it to

the name variable. The this keyword is used to refer to the current object.

However, as the name variable is declared as private, we cannot access it

from outside this class:

Example
public class Main {

public static void main(String[] args) {

Person myObj = new Person();

[Link] = "John"; // error

[Link]([Link]); // error

If the variable was declared as public, we would expect the following

output:

John
However, as we try to access a private variable, we get an error:

[Link]: error: name has private access in Person

[Link] = "John";
^
[Link]: error: name has private access in Person
[Link]([Link]);
^
2 errors

Instead, we use the getName() and setName() methods to access and

update the variable:

Example
public class Main {

public static void main(String[] args) {

Person myObj = new Person();

[Link]("John"); // Set the value of the name variable

to "John"

[Link]([Link]());

// Outputs "John"

Why Encapsulation?
 Better control of class attributes and methods
 Class attributes can be made read-only (if you only use
the get method), or write-only (if you only use the set method)
 Flexible: the programmer can change one part of the code without
affecting other parts
 Increased security of data
Java Packages & API
A package in Java is used to group related classes. Think of it as a folder in
a file directory. We use packages to avoid name conflicts, and to write a
better maintainable code. Packages are divided into two categories:

 Built-in Packages (packages from the Java API)

 User-defined Packages (create your own packages)

Built-in Packages
The Java API is a library of prewritten classes, that are free to use, included in
the Java Development Environment.

The library contains components for managing input, database programming,

and much much more. The complete list can be found at Oracles
website: [Link]

The library is divided into packages and classes. Meaning you can either
import a single class (along with its methods and attributes), or a whole
package that contain all the classes that belong to the specified package.

To use a class or a package from the library, you need to use

the import keyword:

Syntax
import [Link]; // Import a single class

import [Link].*; // Import the whole package

Import a Class
If you find a class you want to use, for example, the Scanner class, which is
used to get user input, write the following code:

Example
import [Link];

In the example above, [Link] is a package, while Scanner is a class of

the [Link] package.

To use the Scanner class, create an object of the class and use any of the
available methods found in the Scanner class documentation. In our
example, we will use the nextLine() method, which is used to read a
complete line:

Example
Using the Scanner class to get user input:

import [Link];

class MyClass {

public static void main(String[] args) {

Scanner myObj = new Scanner([Link]);

[Link]("Enter username");

String userName = [Link]();

[Link]("Username is: " + userName);

}
Import a Package
There are many packages to choose from. In the previous example, we used
the Scanner class from the [Link] package. This package also contains
date and time facilities, random-number generator and other utility classes.

To import a whole package, end the sentence with an asterisk sign ( *). The
following example will import ALL the classes in the [Link] package:

Example
import [Link].*;

User-defined Packages
To create your own package, you need to understand that Java uses a file
system directory to store them. Just like folders on your computer:

Example
└── root
└── mypack
└── [Link]

To create a package, use the package keyword:

[Link]
package mypack;

class MyPackageClass {

public static void main(String[] args) {

[Link]("This is my package!");

Save the file as [Link], and compile it:

C:\Users\Your Name>javac [Link]

Then compile the package:

C:\Users\Your Name>javac -d . [Link]

This forces the compiler to create the "mypack" package.

The -d keyword specifies the destination for where to save the class file. You
can use any directory name, like c:/user (windows), or, if you want to keep
the package within the same directory, you can use the dot sign " .", like in
the example above.

Note: The package name should be written in lower case to avoid conflict
with class names.

When we compiled the package in the example above, a new folder was
created, called "mypack".

To run the [Link] file, write the following:

C:\Users\Your Name>java [Link]

The output will be:

This is my package!

Java Inheritance (Subclass and

Superclass)
In Java, it is possible to inherit attributes and methods from one class to
another. We group the "inheritance concept" into two categories:

 subclass (child) - the class that inherits from another class

 superclass (parent) - the class being inherited from

To inherit from a class, use the extends keyword.

In the example below, the Car class (subclass) inherits the attributes and
methods from the Vehicle class (superclass):

Example
class Vehicle {

protected String brand = "Ford"; // Vehicle attribute

 public void honk() { // Vehicle method

[Link]("Tuut, tuut!");

class Car extends Vehicle {

private String modelName = "Mustang"; // Car attribute

public static void main(String[] args) {

// Create a myCar object

Car myCar = new Car();

// Call the honk() method (from the Vehicle class) on the

myCar object

[Link]();

// Display the value of the brand attribute (from the Vehicle

class) and the value of the modelName from the Car class

[Link]([Link] + " " + [Link]);

Did you notice the protected modifier in Vehicle?

We set the brand attribute in Vehicle to a protected access modifier. If it

was set to private, the Car class would not be able to access it.
Why And When To Use "Inheritance"?
- It is useful for code reusability: reuse attributes and methods of an existing
class when you create a new class.

Tip: Also take a look at the next chapter, Polymorphism, which uses inherited
methods to perform different tasks.

The final Keyword

If you don't want other classes to inherit from a class, use
the final keyword:

If you try to access a final class, Java will generate an error:

final class Vehicle {

...

class Car extends Vehicle {

...

The output will be something like this:

[Link]: error: cannot inherit from final Vehicle

class Main extends Vehicle {
^
1 error)

Java Polymorphism
Polymorphism means "many forms", and it occurs when we have many
classes that are related to each other by inheritance.
Like we specified in the previous chapter; Inheritance lets us inherit
attributes and methods from another class. Polymorphism uses those
methods to perform different tasks. This allows us to perform a single action
in different ways.

For example, think of a superclass called Animal that has a method

called animalSound(). Subclasses of Animals could be Pigs, Cats, Dogs,
Birds - And they also have their own implementation of an animal sound (the
pig oinks, and the cat meows, etc.):

Example
class Animal {

public void animalSound() {

[Link]("The animal makes a sound");

class Pig extends Animal {

public void animalSound() {

[Link]("The pig says: wee wee");

class Dog extends Animal {

public void animalSound() {

[Link]("The dog says: bow wow");

Remember from the Inheritance chapter that we use the extends keyword to
inherit from a class.
Now we can create Pig and Dog objects and call the animalSound() method
on both of them:

Example
class Animal {

public void animalSound() {

[Link]("The animal makes a sound");

class Pig extends Animal {

public void animalSound() {

[Link]("The pig says: wee wee");

class Dog extends Animal {

public void animalSound() {

[Link]("The dog says: bow wow");

class Main {

public static void main(String[] args) {

Animal myAnimal = new Animal(); // Create a Animal object

Animal myPig = new Pig(); // Create a Pig object

 Animal myDog = new Dog(); // Create a Dog object

[Link]();

[Link]();

[Link]();

Why And When To Use "Inheritance" and

"Polymorphism"?
- It is useful for code reusability: reuse attributes and methods of an existing
class when you create a new class.

Java Inner Classes

In Java, it is also possible to nest classes (a class within a class). The purpose
of nested classes is to group classes that belong together, which makes your
code more readable and maintainable.

To access the inner class, create an object of the outer class, and then create
an object of the inner class:

Example
class OuterClass {

int x = 10;

class InnerClass {

int y = 5;

public class Main {

 public static void main(String[] args) {

OuterClass myOuter = new OuterClass();

[Link] myInner = [Link] InnerClass();

[Link](myInner.y + myOuter.x);

// Outputs 15 (5 + 10)

Private Inner Class

Unlike a "regular" class, an inner class can be private or protected. If you
don't want outside objects to access the inner class, declare the class
as private:

Example
class OuterClass {

int x = 10;

private class InnerClass {

int y = 5;

public class Main {

public static void main(String[] args) {

OuterClass myOuter = new OuterClass();

 [Link] myInner = [Link] InnerClass();

[Link](myInner.y + myOuter.x);

If you try to access a private inner class from an outside class, an error
occurs:

[Link]: error: [Link] has private access in

OuterClass
[Link] myInner = [Link] InnerClass();
^

Static Inner Class

An inner class can also be static, which means that you can access it
without creating an object of the outer class:

Example
class OuterClass {

int x = 10;

static class InnerClass {

int y = 5;

public class Main {

 public static void main(String[] args) {

[Link] myInner = new [Link]();

[Link](myInner.y);

// Outputs 5

Note: just like static attributes and methods, a static inner class does not
have access to members of the outer class.

Access Outer Class From Inner

Class
One advantage of inner classes, is that they can access attributes and
methods of the outer class:

Example
class OuterClass {

int x = 10;

class InnerClass {

public int myInnerMethod() {

return x;

}
}

public class Main {

public static void main(String[] args) {

OuterClass myOuter = new OuterClass();

[Link] myInner = [Link] InnerClass();

[Link]([Link]());

// Outputs 10

Abstract Classes and Methods

Data abstraction is the process of hiding certain details and showing only
essential information to the user.
Abstraction can be achieved with either abstract
classes or interfaces (which you will learn more about in the next chapter).

The abstract keyword is a non-access modifier, used for classes and

methods:

 Abstract class: is a restricted class that cannot be used to create

objects (to access it, it must be inherited from another class).

 Abstract method: can only be used in an abstract class, and it does

not have a body. The body is provided by the subclass (inherited from).

An abstract class can have both abstract and regular methods:

abstract class Animal {

public abstract void animalSound();

 public void sleep() {

[Link]("Zzz");

From the example above, it is not possible to create an object of the Animal
class:

Animal myObj = new Animal(); // will generate an error

To access the abstract class, it must be inherited from another class. Let's
convert the Animal class we used in the Polymorphism chapter to an abstract
class:

Remember from the Inheritance chapter that we use the extends keyword to
inherit from a class.

Example
// Abstract class

abstract class Animal {

// Abstract method (does not have a body)

public abstract void animalSound();

// Regular method

public void sleep() {

[Link]("Zzz");

// Subclass (inherit from Animal)

class Pig extends Animal {

public void animalSound() {

// The body of animalSound() is provided here

[Link]("The pig says: wee wee");

class Main {

public static void main(String[] args) {

Pig myPig = new Pig(); // Create a Pig object

[Link]();

[Link]();

Why And When To Use Abstract Classes and

Methods?
To achieve security - hide certain details and only show the important details
of an object.

Interfaces
Another way to achieve abstraction in Java, is with interfaces.
An interface is a completely "abstract class" that is used to group related
methods with empty bodies:

Example
// interface

interface Animal {

public void animalSound(); // interface method (does not have a

body)

public void run(); // interface method (does not have a body)

To access the interface methods, the interface must be "implemented" (kinda

like inherited) by another class with the implements keyword (instead
of extends). The body of the interface method is provided by the "implement"
class:

Example
// Interface

interface Animal {

public void animalSound(); // interface method (does not have a

body)

public void sleep(); // interface method (does not have a body)

// Pig "implements" the Animal interface

class Pig implements Animal {

public void animalSound() {

// The body of animalSound() is provided here

[Link]("The pig says: wee wee");

 }

public void sleep() {

// The body of sleep() is provided here

[Link]("Zzz");

class Main {

public static void main(String[] args) {

Pig myPig = new Pig(); // Create a Pig object

[Link]();

[Link]();

Notes on Interfaces:
 Like abstract classes, interfaces cannot be used to create objects (in
the example above, it is not possible to create an "Animal" object in the
MyMainClass)
 Interface methods do not have a body - the body is provided by the
"implement" class
 On implementation of an interface, you must override all of its methods
 Interface methods are by default abstract and public
 Interface attributes are by default public, static and final
 An interface cannot contain a constructor (as it cannot be used to
create objects)
Why And When To Use Interfaces?
1) To achieve security - hide certain details and only show the important
details of an object (interface).

2) Java does not support "multiple inheritance" (a class can only inherit from
one superclass). However, it can be achieved with interfaces, because the
class can implement multiple interfaces. Note: To implement multiple
interfaces, separate them with a comma

Enums
An enum is a special "class" that represents a group
of constants (unchangeable variables, like final variables).

To create an enum, use the enum keyword (instead of class or interface), and
separate the constants with a comma. Note that they should be in uppercase
letters:

ExampleGet your own Java Server

enum Level {

LOW,

MEDIUM,

HIGH

You can access enum constants with the dot syntax:

Level myVar = [Link];

Try it Yourself »

Enum is short for "enumerations", which means "specifically listed".

Enum inside a Class

You can also have an enum inside a class:
Example
public class Main {

enum Level {

LOW,

MEDIUM,

HIGH

public static void main(String[] args) {

Level myVar = [Link];

[Link](myVar);

The output will be:

MEDIUM

Try it Yourself »

Enum in a Switch Statement

Enums are often used in switch statements to check for corresponding
values:

Example
enum Level {

LOW,

MEDIUM,
 HIGH

public class Main {

public static void main(String[] args) {

Level myVar = [Link];

switch(myVar) {

case LOW:

[Link]("Low level");

break;

case MEDIUM:

[Link]("Medium level");

break;

case HIGH:

[Link]("High level");

break;

The output will be:

Medium level
Loop Through an Enum
The enum type has a values() method, which returns an array of all enum
constants. This method is useful when you want to loop through the
constants of an enum:

Example
for (Level myVar : [Link]()) {

[Link](myVar);

The output will be:

LOW
MEDIUM
HIGH

Difference between Enums and Classes

An enum can, just like a class, have attributes and methods. The only
difference is that enum constants are public, static and final (unchangeable
- cannot be overridden).

An enum cannot be used to create objects, and it cannot extend other classes
(but it can implement interfaces).

Why And When To Use Enums?

Use enums when you have values that you know aren't going to change, like
month days, days, colors, deck of cards, etc.

Java User Input

The Scanner class is used to get user input, and it is found in
the [Link] package.

To use the Scanner class, create an object of the class and use any of the
available methods found in the Scanner class documentation. In our example,
we will use the nextLine() method, which is used to read Strings:
ExampleGet your own Java Server
import [Link]; // Import the Scanner class

class Main {

public static void main(String[] args) {

Scanner myObj = new Scanner([Link]); // Create a Scanner

object

[Link]("Enter username");

String userName = [Link](); // Read user input

[Link]("Username is: " + userName); // Output

user input

If you don't know what a package is, read our Java Packages Tutorial.

Input Types
In the example above, we used the nextLine() method, which is used to read
Strings. To read other types, look at the table below:

Method Description

nextBoolean() Reads a boolean value from the user

 nextByte() Reads a byte value from the user

nextDouble() Reads a double value from the user

nextFloat() Reads a float value from the user

nextInt() Reads a int value from the user

nextLine() Reads a String value from the user

nextLong() Reads a long value from the user

nextShort() Reads a short value from the user

In the example below, we use different methods to read data of various

types:

Example
import [Link];

class Main {

public static void main(String[] args) {

Scanner myObj = new Scanner([Link]);

 [Link]("Enter name, age and salary:");

// String input

String name = [Link]();

// Numerical input

int age = [Link]();

double salary = [Link]();

// Output input by user

[Link]("Name: " + name);

[Link]("Age: " + age);

[Link]("Salary: " + salary);

Note: If you enter wrong input (e.g. text in a numerical input), you will get an
exception/error message (like "InputMismatchException").

Java Dates
Java does not have a built-in Date class, but we can import
the [Link] package to work with the date and time API. The package
includes many date and time classes. For example:

Class Description

LocalDate Represents a date (year, month, day (yyyy-MM-dd))

 LocalTime Represents a time (hour, minute, second and nanoseconds (HH-mm-ss-ns))

LocalDateTime Represents both a date and a time (yyyy-MM-dd-HH-mm-ss-ns)

DateTimeFormatter Formatter for displaying and parsing date-time objects

If you don't know what a package is, read our Java Packages Tutorial.

Display Current Date

To display the current date, import the [Link] class, and use
its now() method:

Example
import [Link]; // import the LocalDate class

public class Main {

public static void main(String[] args) {

LocalDate myObj = [Link](); // Create a date object

[Link](myObj); // Display the current date

The output will be:

2025-06-08
Display Current Time
To display the current time (hour, minute, second, and nanoseconds), import
the [Link] class, and use its now() method:

Example
import [Link]; // import the LocalTime class

public class Main {

public static void main(String[] args) {

LocalTime myObj = [Link]();

[Link](myObj);

This example displays the server's local time, which may differ from your
local time:

20:44:46.688140

Display Current Date and Time

To display the current date and time, import
the [Link] class, and use its now() method:

Example
import [Link]; // import the LocalDateTime class

public class Main {

public static void main(String[] args) {

 LocalDateTime myObj = [Link]();

[Link](myObj);

The output will be something like this:

2025-06-08T20:44:46.688726

Formatting Date and Time

The "T" in the example above is used to separate the date from the time. You
can use the DateTimeFormatter class with the ofPattern() method in the same
package to format or parse date-time objects. The following example will
remove both the "T" and nanoseconds from the date-time:

Example
import [Link]; // Import the LocalDateTime class

import [Link]; // Import the

DateTimeFormatter class

public class Main {

public static void main(String[] args) {

LocalDateTime myDateObj = [Link]();

[Link]("Before formatting: " + myDateObj);

DateTimeFormatter myFormatObj =
[Link]("dd-MM-yyyy HH:mm:ss");

String formattedDate = [Link](myFormatObj);

[Link]("After formatting: " + formattedDate);

 }

The output will be:

Before Formatting: 2025-06-08T20:44:46.688784

After Formatting: 08-06-2025 20:44:46

The ofPattern() method accepts all sorts of values, if you want to display the
date and time in a different format. For example:

Value Example

yyyy-MM-dd "1988-09-29"

dd/MM/yyyy "29/09/1988"

dd-MMM-yyyy "29-Sep-1988"

E, MMM dd yyyy "Thu, Sep 29 1988"