JAVA

INTRODUCTION
 Java is a popular programming language, created in 1995.

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

What is It is used for:

Mobile applications (specially Android apps)

Java? 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 Installation
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 (cmd.exe):

If Java is installed, you will see something like

this (depending on version):
• If you do not have Java installed on your
computer, you can download it for free at
oracle.com.
• Note: Initially, 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.
Setup for Windows
• To install Java on Windows:
1.Go to "System Properties" (Can be found on Control Panel > System
and Security > System > Advanced System Settings)
2.Click on the "Environment variables" button under the "Advanced" tab
3.Then, select the "Path" variable in System variables and click on the
"Edit" button
4.Click on the "New" button and add the path where Java is installed,
followed by \bin. By default, Java is installed in C:\Program Files\
Java\jdk-11.0.1 (If nothing else was specified when you installed it).
In that case, You will have to add a new path with: C:\Program
Files\Java\jdk-11.0.1\bin
Then, click "OK", and save the settings
5.At last, open Command Prompt (cmd.exe) and type java -version to
see if Java is running on your machine
Basic Java Code
• In Java, every application begins with a class
name, and that class must match the file name.
Let's create our first Java file, called Main.java,
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:
Java Syntax
• Every line of code that runs in Java must be inside a class. In our example, we named the class
Main. A class should always start with an uppercase first letter.
• 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.

The output should be:

• 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 main. You will get
to know them bit by bit
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.
System.out.println()
• Inside the main() method, we can use the println() method to print a line of text
to the screen:

• 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 System, out and println(). 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
• You can add as many println() methods as you want. Note
that it will add a new line for each method:

• When you are working with text, it must be wrapped inside

double quotations marks "".
• If you forget the double quotes, an error occurs:
• 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:

You can also perform mathematical calculations inside the

println() method:
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).

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

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

Non-Primitive Data Types
• Non-primitive data types are called reference types because they refer to
objects.
The main difference between primitive and non-primitive data types are:
• Primitive types are predefined (already defined) in Java. Non-primitive types
are created by the programmer and is not defined by Java (except for String).
• Non-primitive types can be used to call methods to perform certain operations,
while primitive types cannot.
• A primitive type has always a value, while non-primitive types can be null.
• A primitive type starts with a lowercase letter, while non-primitive types starts
with an uppercase letter.
• Examples of non-primitive types are Strings, Arrays, Classes, Interface, etc.
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;
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
int[] myNum = {10, 20, 30, 40};
Access the Elements of an Array
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
cars[0] = "Opel";
System.out.println(cars[0]);
// Now outputs Opel instead of Volvo
Array Length
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
System.out.println(cars.length);
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 System.out.println(), but you can also
create your own methods to perform certain actions:
ExampleGet your own Java Server
Create a method inside Main:

public class Main {

static void myMethod() {
// code to be executed
}
}
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:

public class Main {

static void myMethod() {
System.out.println("I just got executed!");
}

public static void main(String[] args) {

myMethod();
}
}
A method can also be called multiple times:
public class Main {
static void myMethod() {
System.out.println("I just got executed!");
}

public static void main(String[] args) {

myMethod();
myMethod();
myMethod();
}
}
Java User Input (Scanner)
Java User Input
The Scanner class is used to get user input, and it is found in 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 Strings:
import java.util.Scanner; // Import the Scanner class

class Main {
public static void main(String[] args) {
Scanner myObj = new Scanner(System.in); // Create a Scanner object
System.out.println("Enter username");

String userName = myObj.nextLine(); // Read user input

System.out.println("Username is: " + userName); // Output user input
}
}
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

Note: If you enter wrong input (e.g. text in a numerical input), you will get an exception/error message
(like "InputMismatchException").
You can read more about exceptions and how to handle errors in the Exceptions chapter.
import java.util.Scanner;
class Main {
public static void main(String[] args)
{
Scanner myObj = new Scanner(System.in);
System.out.println("Enter name, age and salary:");
// String input
String name = myObj.nextLine();
// Numerical input
int age = myObj.nextInt();
double salary = myObj.nextDouble();
// Output input by user
System.out.println("Name: " + name);
System.out.println("Age: " + age);
System.out.println("Salary: " + salary);
}
}
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:

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:
Ex:
public class Main {
int x;
public Main(int y) {
x = y;
}
public static void main(String[] args) {
Main myObj = new Main(5);
System.out.println(myObj.x);
}
}

// Outputs 5
You can have as many parameters as you want:
//filename: Main.java
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");
System.out.println(myCar.modelYear + " " + myCar.modelName);
}
}
Java Modifiers
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 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
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 modifier. You
will learn more about packages in the
Packages chapter
protected The code is accessible in the same package
and subclasses. You will learn more about
subclasses and super classes 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 Inheritance chapter)

abstract The class cannot be used to 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
Java 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:
Ex:
public class Person {
private String name; // private = restricted access
// method to read variable value
public String getName() {
return name;
}
// method to write variable value
public void setName(String newName) {
this.name = newName;
}
}
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:
Ex:
public class Main {
public static void main(String[] args) {
Person myObj = new Person();
myObj.name = "John"; // error
System.out.println(myObj.name); // error
}
}
However, as we try to access a private variable, we get an error:
Instead, we use the getName() and setName() methods to access and update the variable:
public class Main {
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
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: https://docs.oracle.com/javase/8/docs/api/.
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:
• 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:
import java.util.Scanner;
Import a Package
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:
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:

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:

Then compile the package:

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:

The output will be.

Note :
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.
Java Inheritance
• 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):
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:
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.

• 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.
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.):
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");
}
}
Now we can create Pig and Dog objects and call the animalSound() method on
both of them:
class Animal {
public void animalSound() { class Main {
System.out.println("The animal makes a public static void main(String[] args) {
sound");
Animal myAnimal = new Animal(); //
} Create a Animal object
}
Animal myPig = new Pig(); // Create a
class Pig extends Animal {
Pig object
public void animalSound() {
System.out.println("The pig says: wee wee");
Animal myDog = new Dog(); // Create
a Dog object
}
} myAnimal.animalSound();
class Dog extends Animal { myPig.animalSound();
public void animalSound() { myDog.animalSound();
System.out.println("The dog says: bow wow"); }
}
}
}
Java Inner classes class OuterClass {
int x = 10;

class InnerClass {
• In Java, it is also possible int y = 5;
to nest classes (a class }
within a class). The purpose }
of nested classes is to
group classes that belong public class Main {
together, which makes your public static void main(String[] args) {
code more readable and OuterClass myOuter = new OuterClass();
maintainable. OuterClass.InnerClass myInner = myOuter.new
InnerClass();
• To access the inner class, System.out.println(myInner.y + myOuter.x);
create an object of the }
outer class, and then create }
an object of the inner class:
// Outputs 15 (5 + 10)
Private Inner Class
class OuterClass {
int x = 10;

private class InnerClass {

• Unlike a "regular" class, an inner class can
be private or protected. If you don't want int y = 5;
outside objects to access the inner class, }
declare the class as private: }
• If you try to access a private inner class
from an outside class, an error occurs: public class Main {
public static void main(String[] args) {
OuterClass myOuter = new OuterClass();
OuterClass.InnerClass myInner =
myOuter.new InnerClass();
System.out.println(myInner.y + myOuter.x);
}
}
 class OuterClass {
Static Inner Class int x = 10;

static class InnerClass {

• An inner class can also be int y = 5;
static, which means that you }
can access it without creating }
an object of the outer class:
public class Main {
• Note: just like static attributes public static void main(String[] args) {
and methods, a static inner OuterClass.InnerClass myInner = new
OuterClass.InnerClass();
class does not have access to
System.out.println(myInner.y);
members of the outer class.
}
}

// Outputs 5
Access Outer Class From Inner Class
class OuterClass {
int x = 10;

• One advantage of inner class InnerClass {

classes, is that they can public int myInnerMethod() {
access attributes and return x;

methods of the outer }

}
class: }
public class Main {
public static void main(String[] args) {
OuterClass myOuter = new OuterClass();
OuterClass.InnerClass myInner = myOuter.new
InnerClass();
System.out.println(myInner.myInnerMethod());
}
}
// Outputs 10
Java Abstraction
• 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
abstract class Animal {
methods: public abstract void
• From the example given, it is animalSound();
not possible to create an
object of the Animal class: public void sleep() {
To access the abstract class, it System.out.println("Zzz");
must be inherited from another
class. Let's convert the Animal }
class we used in
the Polymorphism chapter to }
an abstract class:
// Abstract class class Main {
abstract class Animal {
public static void main(String[] args) {
// Abstract method (does not have a body)
public abstract void animalSound(); Pig myPig = new Pig(); // Create a Pig
// Regular method
object
public void sleep() { myPig.animalSound();
System.out.println("Zzz"); myPig.sleep();
}
}
}
// Subclass (inherit from Animal) }
class Pig extends Animal {
public void animalSound() {
Why And When To Use Abstract Classes and Methods?
// The body of animalSound() is provided To achieve security - hide certain details and only show the
here important details of an object.
Note: Abstraction can also be achieved with Interfaces,
System.out.println("The pig says: wee
wee");
}
}
Java Interface Example
// interface
• Another way to achieve
abstraction in Java, is with interface Animal {
interfaces. public void animalSound(); //
interface method (does not have
• An interface is a a body)
completely "abstract class" public void run(); // interface
that is used to group related method (does not have a body)
methods with empty }
bodies:
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:
// Interface
interface Animal { class Main {
public void animalSound(); // interface method (does not have
a body) public static void main(String[] args) {
public void sleep(); // interface method (does not have a body) Pig myPig = new Pig(); // Create a Pig
} object
// Pig "implements" the Animal interface
class Pig implements Animal {
myPig.animalSound();
public void animalSound() { myPig.sleep();
// The body of animalSound() is provided here
}
System.out.println("The pig says: wee wee");
} }
public void sleep() {
// The body of sleep() is provided here
System.out.println("Zzz");
}
}