Java Home
public class Main {
public static void main(String[] args) {
System.out.println("Hello World");
}}
Java Syntax
public class Main {
public static void main(String[] args) {
System.out.println("Hello World");
}}
Java Output
( Print Text )
System.out.println("Hello World!");
System.out.println("I am learning Java.");
System.out.println("It is awesome!");
( Print Numbers )
System.out.println(3);
System.out.println(358);
System.out.println(50000);
Java Comment
// This is a comment
Java Variables
In Java, there are different types of variables.
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
Display Variables
The println() method is often used to display variables. To combine both text and a
variable, use the + character:
Example
String name = "John";
System.out.println("Hello " + name);
You can also use the + character to add a variable to another variable: Example
Example
String firstName = "John ";
String lastName = "Doe";
String fullName = firstName + lastName;
System.out.println(fullName);
For numeric values, the + character works as a mathematical operator (notice that
we use int (integer) variables here):
int x = 5;
int y = 6;
System.out.println(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
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;System.out.println(x + y + z);
You can simply write:
int x = 5, y = 6, z = 50;System.out.println(x + y + z);
You can also assign the same value to multiple variables in one line:
Example
int x, y, z;
x = y = z = 50;System.out.println(x + y + z);
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). Note: It is recommended to use descriptive names in
order to create understandable and maintainable code:
Example
// Goodint 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 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 DataTypes
As explained in the previous chapter, a variable in Java must be a specified data
types.
int myNum = 5; // Integer (whole number)
float myFloatNum = 5.99f; // Floating point number
char myLetter = 'D'; // Character
boolean myBool = true; // BooleanString myText = "Hello" //
String
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,64
7
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
Byte
byte myNum = 100;
System.out.println(myNum);
Short
short myNum = 5000;
System.out.println(myNum);
Int
int myNum = 100000;
System.out.println(myNum);
Long
long myNum = 15000000000L;
System.out.println(myNum);
Float
float myNum = 5.75f;
System.out.println(myNum);
Double
double myNum = 19.99d;
System.out.println(myNum);
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:
boolean isJavaFun = true;
boolean isFishTasty = false;
System.out.println(isJavaFun); // Outputs
trueSystem.out.println(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';
System.out.println(myGrade);
Example
char myVar1 = 65, myVar2 = 66, myVar3 =
67;System.out.println(myVar1);System.out.println(myVar2);System.o
ut.println(myVar3);
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";
System.out.println(greeting);
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:
public class Main {
public static void main(String[] args) {
int myInt = 9;
double myDouble = myInt; // Automatic casting: int to double
System.out.println(myInt); // Outputs 9
System.out.println(myDouble); // Outputs 9.0
}}
Narrowing Casting
Narrowing casting must be done manually by placing the type in parentheses in
front of the value:
public class Main {
public static void main(String[] args) {
double myDouble = 9.78d;
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. In the example
below, we use the + operator to add together two values:
Example
int x = 100 + 50;
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)
Java divides the operators into the following groups:
Arithmetic operators
Assignment operators
Comparison operators
Logical operators
Bitwise operators
Operator Name Description Example
+ Addition Adds together two X+Y
values
Subtraction Subtracts one value X-Y
- from another
* Multiplication Multiplies two X*Y
values
/ Division Divides one value by X/Y
another
% Modulus Returns the division X%Y
remainder
++ Increment Increases the value ++X
of a variable by 1
-- Decrement Decreases the value --X
of a variable by 1
Java Strings
Strings are used for storing text.
A String variable contains a collection of characters surrounded by double quotes:
Example
Get your own Java Server 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:
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():
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
String Concatenation
The + operator can be used between strings to combine them. This is called
concatenation:
Example
String firstName = "John";
String lastName = "Doe";
System.out.println(firstName + " " + 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 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)
