public class MyClass {

public static void main (String[] args) {

System.out.println("Hello World");
}
}

A class should always start with an uppercase first letter.

The main Method

System.out.println()
Inside the main() method, we can use the println() method to print a line of text
to the screen

Java 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).

Java Multi-line Comments

Multi-line comments start with /* and ends with */.

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

Syntax
type variable = value;

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

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

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

Java 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).

The general rules for constructing names for variables (unique identifiers) are:

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

 Names must begin with a letter
 Names should start with a lowercase letter and it cannot contain whitespace
 Names can also begin with $ and _ (but we will not use it in this tutorial)
 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

Java Data Types

Data types are divided into two groups:

 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 size and type of variable values, and it has no
additional methods.

There are eight primitive data types in Java:

Data Type Size Description

byte 1 byte Stores whole numbers from -
128 to 127
short 2 bytes Stores whole numbers from -
32,768 to 32,767
int 4 bytes Stores whole numbers from -
2,147,483,648 to 2,147,483,647
long 8 bytes Stores whole numbers from -
9,223,372,036,854,775,808 to
9,223,372,036,854,775,807
float 4 bytes Stores fractional numbers.
Sufficient for storing 6 to 7
decimal digits
double 8 bytes Stores fractional numbers.
Sufficient for storing 15 decimal
digits
boolean 1 bit Stores true or false values
char 2 bytes Stores a single character/letter
or ASCII values
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.

Scientific Numbers
A floating point number can also be a scientific number with an "e" to indicate the
power of 10
float f1 = 35e3f;double d1 = 12E4d;

Op- 35000.0 , 120000.0

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

int myInt = 9;
double myDouble = myInt; // Automatic casting: int to double
System.out.println(myInt); // Outputs 9
System.out.println(myDouble); // Outputs 9.0

double myDouble = 9.78;

 int myInt = (int) myDouble; // Manual casting: double to int
System.out.println(myDouble); // Outputs 9.78
System.out.println(myInt); // Outputs 9

Java Operators
Operators are used to perform operations on variables and values.

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 Try it

+ Addition Adds together x+y Try it »
two values
- Subtraction Subtracts one x-y Try it »
value from
another
* Multiplication Multiplies two x*y Try it »
values
/ Division Divides one value x/y Try it »
by another
% Modulus Returns the x%y Try it »
division
remainder
++ Increment Increases the ++x Try it »
value of a variable
by 1
-- Decrement Decreases the --x
value of a variable
by 1
Java Assignment Operators
Assignment operators are used to assign values to variables.

A list of all assignment operators:

Operator Example Same As Try it

= x=5 x=5 Try it »
+= x += 3 x=x+3 Try it »
-= x -= 3 x=x-3 Try it »
*= x *= 3 x=x*3 Try it »
/= x /= 3 x=x/3 Try it »
%= x %= 3 x=x%3 Try it »
&= x &= 3 x=x&3 Try it »
|= x |= 3 x=x|3 Try it »
^= x ^= 3 x=x^3 Try it »
>>= x >>= 3 x = x >> 3 Try it »
<<= x <<= 3 x = x << 3 Try it »

Java Comparison Operators

Comparison operators are used to compare two values:

Operator Name Example Try it

== Equal to x == y Try it »
!= Not equal x != y Try it »
> Greater than x>y Try it »
< Less than x<y Try it »
>= Greater than or x >= y Try it »
equal to
<= Less than or equal x <= y Try it »
to

Java Logical Operators

Logical operators are used to determine the logic between variables or values:

Operator Name Description Example Try it

&& Logical and Returns true if x < 5 && x < 10 Try it »
both statements
are true
|| Logical or Returns true if x < 5 || x < 4 Try it »
one of the
 statements is true
! Logical not Reverse the !(x < 5 && x < 10) Try it »
result, returns
false if the result
is true

Java Bitwise Operators

Bitwise operators are used to perform binary logic with the bits of an integer or long
integer.

Operator Description Example Same as Result Decimal

& AND - Sets 5&1 0101 & 0001 0001 1
each bit to 1 if
both bits are 1
| OR - Sets each 5|1 0101 | 0001 0101 5
bit to 1 if any
of the two bits
is 1
~ NOT - Inverts ~5 ~0101 1010 10
all the bits
^ XOR - Sets 5^1 0101 ^ 0001 0100 4
each bit to 1 if
only one of
the two bits is
1
<< Zero-fill left 9 << 1 1001 << 1 0010 2
shift - Shift left
by pushing
zeroes in from
the right and
letting the
leftmost bits
fall off
>> Signed right 9 >> 1 1001 >> 1 1100 12
shift - Shift
right by
pushing copies
of the leftmost
bit in from the
left and letting
the rightmost
bits fall off
>>> Zero-fill right 9 >>> 1 1001 >>> 1 0100 4
shift - Shift
 right by
pushing zeroes
in from the
left and letting
the rightmost
bits fall off

Java Strings
Strings are used for storing text.

A String variable contains a collection of characters surrounded by double quotes

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

String txt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

System.out.println("The length of the txt string is: " + txt.length());

More String Methods

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

Example
String txt = "Hello World";
System.out.println(txt.toUpperCase()); // Outputs "HELLO WORLD"
System.out.println(txt.toLowerCase()); // 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!";System.out.println(txt.indexOf("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:

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

Example
String firstName = "John";String lastName =
"Doe";System.out.println(firstName + " " + lastName);

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

Example
String firstName = "John ";
String lastName = "Doe";
System.out.println(firstName.concat(lastName));

Special Characters
escape characters

Escape character Result Description

\' ' Single quote
\" " Double quote
\\ \ Backslash

Six other escape sequences are valid in Java:

Code Result Try it

 \n New Line Try it »
\r Carriage Return Try it »
\t Tab Try it »
\b Backspace Try it »
\f Form Feed

All String Methods

The String class has a set of built-in methods that you can use on strings.

Method Description Return Type

charAt() Returns the character at char
the specified index
(position)
codePointAt() Returns the Unicode of int
the character at the
specified index
codePointBefore() Returns the Unicode of int
the character before the
specified index
codePointCount() Returns the Unicode in int
the specified text range
of this String
compareTo() Compares two strings int
lexicographically
compareToIgnoreCase() Compares two strings int
lexicographically, ignoring
case differences
concat() Appends a string to the String
end of another string
contains() Checks whether a string boolean
contains a sequence of
characters
contentEquals() Checks whether a string boolean
contains the exact same
sequence of characters of
the specified
CharSequence or
StringBuffer
copyValueOf() Returns a String that String
represents the characters
of the character array
endsWith() Checks whether a string boolean
ends with the specified
character(s)
equals() Compares two strings. boolean
 Returns true if the strings
are equal, and false if not
equalsIgnoreCase() Compares two strings, boolean
ignoring case
considerations
format() Returns a formatted String
string using the specified
locale, format string, and
arguments
getBytes() Encodes this String into a byte[]
sequence of bytes using
the named charset,
storing the result into a
new byte array
getChars() Copies characters from a void
string to an array of chars
hashCode() Returns the hash code of int
a string
indexOf() Returns the position of int
the first found occurrence
of specified characters in
a string
intern() Returns the index within String
this string of the first
occurrence of the
specified character,
starting the search at the
specified index
isEmpty() Checks whether a string boolean
is empty or not
lastIndexOf() Returns the position of int
the last found occurrence
of specified characters in
a string
length() Returns the length of a int
specified string
matches() Searches a string for a boolean
match against a regular
expression, and returns
the matches
offsetByCodePoints() Returns the index within int
this String that is offset
from the given index by
codePointOffset code
points
regionMatches() Tests if two string regions boolean
are equal
replace() Searches a string for a String
specified value, and
returns a new string
where the specified
values are replaced
replaceFirst() Replaces the first String
occurrence of a substring
that matches the given
regular expression with
the given replacement
replaceAll() Replaces each substring String
of this string that
matches the given
regular expression with
the given replacement
split() Splits a string into an String[]
array of substrings
startsWith() Checks whether a string boolean
starts with specified
characters
subSequence() Returns a new character CharSequence
sequence that is a
subsequence of this
sequence
substring() Extracts the characters String
from a string, beginning
at a specified start
position, and through the
specified number of
character
toCharArray() Converts this string to a char[]
new character array
toLowerCase() Converts a string to lower String
case letters
toString() Returns the value of a String
String object
toUpperCase() Converts a string to String
upper case letters
trim() Removes whitespace String
from both ends of a string
valueOf() Returns the primitive String
value of a String object
Java Math
The Java Math class has many methods that allows you to perform
mathematical tasks on numbers.

To get more control over the random number, e.g. you only want a random number
between 0 and 100, you can use the following formula:

Example
int randomNum = (int)(Math.random() * 101); // 0 to 100
System.out.println(randomNum);

All Math Methods

A list of all Math methods can be found in the table below:

Method Description Return Type

abs(x) Returns the absolute value of x double|float|int|long
acos(x) Returns the arccosine of x, in double
radians
asin(x) Returns the arcsine of x, in double
radians
atan(x) Returns the arctangent of x as a double
numeric value between -PI/2
and PI/2 radians
atan2(y,x) Returns the angle theta from double
the conversion of rectangular
coordinates (x, y) to polar
coordinates (r, theta).
cbrt(x) Returns the cube root of x double
ceil(x) Returns the value of x rounded double
up to its nearest integer
copySign(x, y) Returns the first floating point x double
with the sign of the second
floating point y
cos(x) Returns the cosine of x (x is in double
radians)
cosh(x) Returns the hyperbolic cosine of double
a double value
exp(x) Returns the value of Ex double
expm1(x) Returns ex -1 double
floor(x) Returns the value of x rounded double
 down to its nearest integer
getExponent(x) Returns the unbiased exponent int
used in x
hypot(x, y) Returns sqrt(x2 +y2) without double
intermediate overflow or
underflow
IEEEremainder(x, y) Computes the remainder double
operation on x and y as
prescribed by the IEEE 754
standard
log(x) Returns the natural logarithm double
(base E) of x
log10(x) Returns the base 10 logarithm double
of x
log1p(x) Returns the natural logarithm double
(base E) of the sum of x and 1
max(x, y) Returns the number with the double|float|int|long
highest value
min(x, y) Returns the number with the double|float|int|long
lowest value
nextAfter(x, y) Returns the floating point double|float
number adjacent to x in the
direction of y
nextUp(x) Returns the floating point value double|float
adjacent to x in the direction of
positive infinity
pow(x, y) Returns the value of x to the double
power of y
random() Returns a random number double
between 0 and 1
round(x) Returns the value of x rounded int
to its nearest integer
rint() Returns the double value that is double
closest to x and equal to a
mathematical integer
signum(x) Returns the sign of x double
sin(x) Returns the sine of x (x is in double
radians)
sinh(x) Returns the hyperbolic sine of a double
double value
sqrt(x) Returns the square root of x double
tan(x) Returns the tangent of an angle double
tanh(x) Returns the hyperbolic tangent double
of a double value
toDegrees(x) Converts an angle measured in double
radians to an approx. equivalent
angle measured in degrees
 toRadians(x) Converts an angle measured in double
degrees to an approx. angle
measured in radians
ulp(x) Returns the size of the unit of double|float
least precision (ulp) of x
Note: All Math methods are static.

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 take the values true or false.

Boolean Expression
A Boolean expression is a Java expression that returns a Boolean value: true or
false.

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

we use the equal to (==) operator to evaluate an expression

Java Conditions and If Statements

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.

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
}

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
}

Short Hand If...Else (Ternary Operator)

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. It is often used to replace simple if else statements:

Syntax
variable = (condition) ? expressionTrue : expressionFalse;

Instead of writing:

Example
int time = 20;
if (time < 18) {
System.out.println("Good day.");
} else {
System.out.println("Good evening.");
}

Run example »

You can simply write:

Example
int time = 20;
String result = (time < 18) ? "Good day." : "Good evening.";
System.out.println(result);

Java Switch
❮ PreviousNext ❯

Java Switch Statements

Use the switch statement to select 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
int day = 4;
switch (day) {
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;
case7:
System.out.println("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.

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

The default Keyword

The default keyword specifies some code to run if there is no case match
Java While Loop
❮ PreviousNext ❯

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
}

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 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.
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.

For-Each Loop
There is also a "for-each" loop, which is used exclusively to loop through elements
in an array:

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) {
System.out.println(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.
for (int i = 0; i < 10; i++) {
if (i == 4) {
continue;
}
System.out.println(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, we can use an array literal - 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 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"};System.out.println(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:
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
cars[0] = "Opel";
System.out.println(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"};System.out.println(cars.length);// 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 < cars.length; i++) {
System.out.println(cars[i]);
}

Multidimensional Arrays
A multidimensional array is an array containing one or more arrays.
To create a two-dimensional array, add each array within its own set of curly
braces:
int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };
int x = myNumbers[1][2];
System.out.println(x); // Outputs 7

We 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
public class MyClass {
public static void main(String[] args) {
int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };
for (int i = 0; i < myNumbers.length; ++i) {
for(int j = 0; j < myNumbers[i].length; ++j) {
System.out.println(myNumbers[i][j]); }
} }}
1
2
3
4
5
6
7

Java Methods
❮ PreviousNext ❯
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 System.out.println().

 myMethod() is the name of the method

 static means that the method belongs to the MyClass class and not an
object of the MyClass 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;

A method can also be called multiple times.

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 MyClass {

static void myMethod() {
System.out.println("I just got executed!");
}
public static void main(String[] args) {
myMethod();
}
}// Outputs "I just got executed!"

Calling a method through object

Call myMethod on the object.

public class MyClass {

public void myMethod() {
System.out.println("Hello World");
}
public static void main(String[] args) {
MyClass myObj = new MyClass();
myObj.myMethod();
}
}

Java Method Parameters

Parameters and Arguments
Information can be passed to methods as parameter. Parameters act as variables
inside the method.

Parameters are specified after the method name, inside the parentheses. You can
add as many parameters as you want, just separate them with a comma.

The following example has a method that takes a String called fname as
parameter. When the method is called, we pass along a first name, which is used
inside the method to print the full name:

Example
public class MyClass {
static void myMethod(String fname) {
System.out.println(fname + " Refsnes");
}
public static void main(String[] args) {
myMethod("Liam");
myMethod("Jenny");
myMethod("Anja");
}
}// Liam Refsnes// Jenny Refsnes// Anja Refsnes

Run example »

When a parameter is passed to the method, it is called an argument. So, from

the example above:

fname is a parameter, while Liam, Jenny and Anja are arguments.

Multiple Parameters
public class MyClass {
static void myMethod(String fname, int age) {
System.out.println(fname + " is " + age);
}
public static void main(String[] args) {
myMethod("Liam", 5);
myMethod("Jenny", 8);
myMethod("Anja", 31);
}
}// Liam is 5// Jenny is 8// Anja is 31

Run example »

Note that when you are working with multiple parameters, the method call must
have the same number of arguments as there are parameters, and the arguments
must be passed in the same order.

Return Values
The void keyword, used in the examples above, indicates that the method should
not return a value. If you want the method to return a value, you can use a
primitive data type (such as int, char, etc.) instead of void, and use the return
keyword inside the method:

Example
public class MyClass {
static int myMethod(int x) {
return 5 + x;
}
public static void main(String[] args) {
System.out.println(myMethod(3));
}
}// Outputs 8 (5 + 3)

A Method with If...Else

It is common to use if...else statements inside methods:

Example
public class MyClass { /
/ Create a checkAge() method with an integer variable called age
static void checkAge(int age) {
// If age is less than 18, print "access denied"
if (age < 18) {
System.out.println("Access denied - You are not old enough!");
// If age is greater than 18, print "access granted"
}
else {
System.out.println("Access granted - You are old enough!");
}
}
public static void main(String[] args) {
checkAge(20); // Call the checkAge method and pass along an age of 20
}
}// Outputs "Access granted - You are old enough!"

Java Method Overloading

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

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 = plusMethodInt(8, 5);
double myNum2 = plusMethodDouble(4.3, 6.26);
Systemout.println("int: " + myNum1);
System.out.println("double: " + myNum2);
}

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 MyClass {
public static void main(String[] args) {
// Code here CANNOT use x
Int x = 100;
// Code here can use x
System.out.println(x);
}
}

Run example »

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 MyClass {
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
System.out.println(x);
} // The block ends here
// Code here CANNOT use x
}
}
 Run example »

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 MyClass {
public static void main(String[] args) {
int result = sum(10);
System.out.println(result);
}
public static int sum(int k) {
if (k > 0) {
return k + sum(k - 1);
}
else {
return 0;
}
 }
}

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 MyClass {
public static void main(String[] args) {
int result = sum(5, 10);
System.out.println(result);
}
public static int sum(int start, int end) {
if (end > start) {
return end + sum(start, end - 1);
}
else {
return end;
}
}
}
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/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:

MyClass.java
Create a class named "MyClass" with a variable x:

public class MyClass {

int x = 5;
}
Create an Object
In Java, an object is created from a class. We have already created the class named
MyClass, so now we can use this to create objects.

To create an object of MyClass, 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 MyClass {

int x = 5;
public static void main(String[] args) {
MyClass myObj = new MyClass();
System.out.println(myObj.x);
}
}

Multiple Objects
You can create multiple objects of one class:

Example
Create two objects of MyClass:

public class MyClass {

int x = 5;
public static void main(String[] args) {
MyClass myObj1 = new MyClass(); // Object 1
MyClass myObj2 = new MyClass(); // Object 2
System.out.println(myObj1.x);
System.out.println(myObj2.x);
}
}
Using Multiple Classes
You can also create an object of a class and access it in another class. This is often
used for better organization of classes (one class has all the attributes and
methods, while the other class holds the main() method (code to be executed)).

Remember that the name of the java file should match the class name. In this
example, we have created two files in the same directory/folder:

 MyClass.java
 OtherClass.java

MyClass.java
public class MyClass {
int x = 5;
}

OtherClass.java
class OtherClass {
public static void main(String[] args) {
MyClass myObj = new MyClass();
System.out.println(myObj.x);
}
}

When both files have been compiled:

C:\Users\Your Name>javac MyClass.java
C:\Users\Your Name>javac OtherClass.java

Run the OtherClass.java file:

C:\Users\Your Name>java OtherClass

And the output will be:

5

Car.java
public class Car { public void fullThrottle() { System.out.println("The
car is going as fast as it can!"); } public void speed(int maxSpeed) {
System.out.println("Max speed is: " + maxSpeed); }}
OtherClass.java
class OtherClass { public static void main(String[] args) { Car myCar =
new Car(); // Create a myCar object myCar.fullThrottle(); // Call
the fullThrottle() method myCar.speed(200); // Call the speed()
method }}

When both files have been compiled:

C:\Users\Your Name>javac Car.java
C:\Users\Your Name>javac OtherClass.java

Run the OtherClass.java file:

C:\Users\Your Name>java OtherClass

And the output will be:

The car is going as fast as it can!
Max speed is: 200

Run example »

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 "MyClass" with two attributes: x and y:

public class MyClass {

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 MyClass 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 MyClass {

int x = 5;
public static void main(String[] args) {
MyClass myObj = new MyClass();
System.out.println(myObj.x);
}
}

Modify Attributes
You can also modify attribute values:

Example
Set the value of x to 40:

public class MyClass {

int x=5;
public static void main(String[] args) {
MyClass myObj = new MyClass();
myObj.x = 40; // now x is 40
System.out.println(myObj.x);
}
}

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

Example
public class MyClass {
final int x = 10;
public static void main(String[] args) {
MyClass myObj = new MyClass();
 myObj.x = 25; // will generate an error: cannot assign a value to a final
variable
System.out.println(myObj.x);
}
}

Multiple Attributes
You can specify as many attributes as you want:

Example
public class Person {
String fname = "John";
String lname = "Doe";
int age = 24;
public static void main(String[] args) {
Person myObj = new Person();
System.out.println("Name: " + myObj.fname + " " + myObj.lname);
System.out.println("Age: " + myObj.age);
}
}

Static vs. Non-Static

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 MyClass { // Static methodstatic void myStaticMethod() {

System.out.println("Static methods can be called without creating objects");
} // Public method public void myPublicMethod() {
System.out.println("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
MyClass myObj = new MyClass(); // Create an object of MyClass
myObj.myPublicMethod(); // Call the public method on the object }}

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 Car classpublic class Car { // Create a fullThrottle() method

public void fullThrottle() { System.out.println("The car is going as fast
as it can!"); } // Create a speed() method and add a parameter public void
speed(int maxSpeed) { System.out.println("Max speed is: " + maxSpeed); }
// Inside main, call the methods on the myCar object public static void
main(String[] args) { Car myCar = new Car(); // Create a myCar object
myCar.fullThrottle(); // Call the fullThrottle() method
myCar.speed(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 Car class with the class keyword.

2) We created the fullThrottle() and speed() methods in the Car 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 Car class and its methods, we need to create an object of
the Car 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 a Car 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 (Car and Car.java).

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 MyClass classpublic class MyClass { int x; // Create a class
attribute // Create a class constructor for the MyClass class public
MyClass() { x = 5; // Set the initial value for the class attribute x }
public static void main(String[] args) { MyClass myObj = new MyClass(); //
Create an object of class MyClass (This will call the constructor)
System.out.println(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 MyClass { int x; public MyClass(int y) { x = y; } public
static void main(String[] args) { MyClass myObj = new MyClass(5);
System.out.println(myObj.x); }}// Outputs 5
You can have as many parameters as you want:

Example
public class Car { int modelYear; String modelName; public Car(int year,
String name) { modelYear = year; modelName = name; } public static
void main(String[] args) { Car myCar = new Car(1969, "Mustang");
System.out.println(myCar.modelYear + " " + myCar.modelName); }}// Outputs
1969 Mustang

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

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 Try it

public The class is accessible by any Try it »
other class
default The class is only accessible by Try it »
classes in the same package.
This is used when you don't
specify a modifier. You will learn
more about packages in the
Packages chapter
For attributes, methods and constructors, you can use the one of the following:

Modifier Description Try it

public The code is accessible for all Try it »
classes
 private The code is only accessible Try it »
within the declared class
default The code is only accessible in Try it »
the same package. This is used
when you don't specify a
modifier. You will learn more
about packages in the Packages
chapter
protected The code is accessible in the Try it »
same package and subclasses.
You will learn more about
subclasses and superclasses in
the Inheritance chapter

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

Modifier Description Try it

final The class cannot be inherited by Try it »
other classes (You will learn
more about inheritance in the
Inheritance chapter)
abstract The class cannot be used to Try it »
create objects (To access an
abstract class, it must be
inherited from another class.
You 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 not
have a body, for example abstract void run();.
The body is provided by the subclass (inherited
from). You will learn more about inheritance and
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
memory"

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

Example
public class MyClass { final int x = 10; final double PI = 3.14; public
static void main(String[] args) { MyClass myObj = new MyClass();
myObj.x = 50; // will generate an error: cannot assign a value to a final
variable myObj.PI = 25; // will generate an error: cannot assign a value
to a final variable System.out.println(myObj.x); }}

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: Person.java// abstract class
abstract class Person { public String fname = "John"; public int age = 24;
public abstract void study(); // abstract method}// Subclass (inherit from
Person)class Student extends Person { public int graduationYear = 2018;
public void study() { // the body of the abstract method is provided here
System.out.println("Studying all day long"); }}// End code from filename:
Person.java// Code from filename: MyClass.javaclass MyClass { public static
void main(String[] args) { // create an object of the Student class (which
inherits attributes and methods from Person) Student myObj = new
Student(); System.out.println("Name: " + myObj.fname);
System.out.println("Age: " + myObj.age); System.out.println("Graduation
Year: " + myObj.graduationYear); myObj.study(); // call abstract method
}}
Name: John
Age: 24
Graduation Year: 2018
Studying all day long
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) { this.name = 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 MyClass { public static void main(String[] args) { Person
myObj = new Person(); myObj.name = "John"; // error
System.out.println(myObj.name); // 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:

MyClass.java:4: error: name has private access in Person
myObj.name = "John";
^
MyClass.java:5: error: name has private access in Person
System.out.println(myObj.name);
^
2 errors

Instead, we use the getName() and setName() methods to acccess and update the
variable:

Example
public class MyClass { public static void main(String[] args) { Person
myObj = new Person(); myObj.setName("John"); // Set the value of the name
variable to "John" System.out.println(myObj.getName()); }}// 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 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 package.name.Class; // Import a single class
import package.name.*; // 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 java.util.Scanner;

In the example above, java.util is a package, while Scanner is a class of the

java.util 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 java.util.Scanner;class MyClass { public static void main(String[]

args) { Scanner myObj = new Scanner(System.in);
System.out.println("Enter username"); String userName = myObj.nextLine();
System.out.println("Username is: " + userName); }}

Import a Package
There are many packages to choose from. In the previous example, we used the
Scanner class from the java.util 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 java.util package:
Example
import java.util.*;

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 └── MyPackageClass.java

To create a package, use the package keyword:

MyPackageClass.java
package mypack;class MyPackageClass { public static void main(String[] args)
{ System.out.println("This is my package!"); }}

Save the file as MyPackageClass.java, and compile it:

C:\Users\Your Name>javac MyPackageClass.java

Then compile the package:

C:\Users\Your Name>javac -d . MyPackageClass.java

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 MyPackageClass.java file, write the following:

C:\Users\Your Name>java mypack.MyPackageClass

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
System.out.println("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
myCar.honk(); // Display the value of the brand attribute (from the
Vehicle class) and the value of the modelName from the Car class
System.out.println(myCar.brand + " " + myCar.modelName); }}

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.

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:

Car.java:8: error: cannot inherit from final Vehicle
class Car 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.):

Remember from the Inheritance 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() { System.out.println("The animal
makes a sound"); }}class Pig extends Animal { public void animalSound() {
System.out.println("The pig says: wee wee"); }}class Dog extends Animal {
public void animalSound() { System.out.println("The dog says: bow wow");
}}class MyMainClass { 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 myAnimal.animalSound(); myPig.animalSound();
myDog.animalSound(); }}

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 MyMainClass { public static void main(String[] args) { OuterClass
myOuter = new OuterClass(); OuterClass.InnerClass myInner = myOuter.new
InnerClass(); System.out.println(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 MyMainClass { public static void main(String[] args) {
OuterClass myOuter = new OuterClass(); OuterClass.InnerClass myInner =
myOuter.new InnerClass(); System.out.println(myInner.y + myOuter.x); }}

If you try to access a private inner class from an outside class (MyMainClass), an
error occurs:
MyMainClass.java:12: error: OuterClass.InnerClass has private access in
OuterClass
OuterClass.InnerClass myInner = myOuter.new 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 MyMainClass { public static void main(String[] args) {
OuterClass.InnerClass myInner = new OuterClass.InnerClass();
System.out.println(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 MyMainClass { public
static void main(String[] args) { OuterClass myOuter = new OuterClass();
OuterClass.InnerClass myInner = myOuter.new InnerClass();
System.out.println(myInner.myInnerMethod()); }}// Outputs 10

Run example »

Run example »

Run example »