Java Basics

To create a new Java Class:

src → New → Java Class

Printing Hello World

Shortcut for print -> sout = System.out.println()

public class Hello {

public static void main(String[] args){

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

Data types

󾠮Whole Number Data Types: [4 types]

Declaring a number variable
data type + variable name + (optional) value

Java Basics 1
 int myFirstNumber = 5; // -> expression

Getting the minimum and maximum value of a Data Type

Int

int myMinIntValue = Integer.MIN_VALUE;

int myMaxIntValue = Integer.MAX_VALUE;

System.out.println("Integer Minimum Value = " + myMinIntValue);

System.out.println("Integer Maximum Value = " + myMaxIntValue);

Size of Primitive Types and Width

Primitive Types

Data Type Bits Width

Byte 8 8

Short 16 16
Int 32 32

Minimum and Maximum values

Min & Max value of Data Types

Data Type Min Max

Int -2147483648 2147483647

Byte -128 127

Short -32768 32767
Long -9223372036854776000 9223372036854776000

Casting in Java
data type → variable name = (data type/ CAST) value

Java Basics 2
 The value of [myTotal] = 2 which is of the type int

int myTotal = 20 / 10

But the value of [myNewByteValue] will return an error since it's

value is of the type int instead of byte

byte myMaxByteValue = Byte.MAX_VALUE;

byte myNewByteValue = (myMinByteValue / 2);

To solve this issue we must specify the type of the value as well
using Casting

byte myNewByteValue = (byte) (myMinByteValue / 2);

So the retuned type of the value must be of the same type as the
variable

󾠯 Decimal-Point Number Data Types [4

Types]
Decimal Point numbers are used when we need extra precision.

There are 2 Primitive Types in Java → Float

(single precision number) and Double (
double precision number)

Java Basics 3
 Float & Double

Data Type Bits Width

Float 32 32

Double 64 64

Declaring float & double variables

float myFloatValue = 5.25f; // f - float
double myDoubleValue = 5.25d; // d - double

Division using int , float & double (most used)

int myIntValue = 5 / 3; // 1
float myFloatValue = 5f / 3f; // 1.6666666
double myDoubleValue = 5d / 3d; // 1.6666666666666667

The int will return 1 because int only return a whole number

The float will return a decimal point number

The double will return a more precise decimal point number

Primitive data types: char & bool

Char can store only one character

Also stores unicode charactrers ( takes 2 bits ) [https://unicode-table.com/en/]

// Regular Characters
char myChar = 'D';
char myChar = 'DD'; // will retun an error since DD is more than one character

// Unicode Characters // output D

char myUnicodeChar = '\u0044';

Java Basics 4
 Strings
Strings are immutable

Strings are a Class in Java

Java do not convert a string to a number [ "10" =! 10] and

it will concatenate the result

String + int = stringint

string + double = stringdouble
and so on...

String laststring = "10";

int myInt = 50;
laststring = laststring + myInt; // 1050

double doubleNumber = 120.47d;

laststring = laststring + doubleNumber; 1050120.47

The if statements in Java

Example: no curly brackets

if(isAlien == false)
System.out.println("It is not alien!");

Example: with curly brackets

Java Basics 5
 int newValue = 50;
if(newValue == 50) {
System.out.println("This is an error");
}

Ternary Operator
boolean wasCar = isCar ? true : false;
If isCar = true then wasCar = true, else wasCar = false

boolean isCar = true

boolean wasCar = isCar ? true : false;
if(wasCar) {
System.out.println("wasCar is true");
}

Methods inside methods

Let's create a score calculator:
We have 4 variables ( 1 boolean & 3 int )

Each variable has a defined value

boolean gameOver = true;

int score = 800;
int levelCompleted = 5;
int bonus = 100;

Then we have an if statement that will calculate our finalScore

The code block inside the if statement gets executed only if the parameter
gameOver is true

If gameOver is true , the finalScore will be calculated and printed

Printed value is: Your final score was 2300

Java Basics 6
 public class Main {

public static void main(String[] args) {

boolean gameOver = true;
int score = 800;
int levelCompleted = 5;
int bonus = 100;

if(gameOver){
int finalScore = score + (levelCompleted * bonus);
finalScore += 1000;
System.out.println("Your final score was " + finalScore);
}
}
}

Now if we want to add a second score, levelCompleted and bonus and print out
the finalScore we can use the existing variables, assign them new values
and then duplicate the if statement.
Remember that when we will assign new values to already defined variables we
will not specify their data types again ( no boolean & int ) since we do not want
to declare the variables again, but to assign new values to them.
Whitch is called code duplication and it IS NOT a good practice.

Imagine if we want to add 50 new game results. We will end with 1000 lines of
duplicated code. That's a nono.

We will use the example below as an NOT LIKE THIS example

public class Main {

public static void main(String[] args) {

boolean gameOver = true;
int score = 800;
int levelCompleted = 5;
int bonus = 100;

if(gameOver){
int finalScore = score + (levelCompleted * bonus);
finalScore += 1000;
System.out.println("Your final score was " + finalScore);
}

score = 10000;
levelCompleted = 8;
bonus = 200;

if(gameOver){
int finalScore = score + (levelCompleted * bonus);
System.out.println("Your final score was " + finalScore);

Java Basics 7
 }
}
}

Duplicate code is bad, so let's see how we can create an method that
we can reuse in order to add as many new values we want without
duplicating existing code.

Step #1
We will work inside the public class Main {}

public class Main {

// our code will go here
}

Step #2
We will define the values inside the main method by calling a new method inside
here that will perform the calculation

public static void main(String[] args) {

// the calculation result will be printed from here
}

Step #3
Now we will create a new method that will calculate our finalPrice

public static void calculateScore(// we will need to pass some parameters here) {
}

Step #4

Java Basics 8
 Now let's pass some parameters inside the () so we can use those parameters to
create the if statement and calculate the finalPrice

This way we can always change the way the finalScore is calculated (adding
1000 extra points, etc) and we can do it in only one place. We will not need to
make the change inside all the places where the code was duplicated.

public static void calculateScore(boolean gameOver, int score, int levelCompleted, int bonus) {
}

Step #5
Now that we have the needed parameters let's use them inside the if statement
and calculate the finalPrice

public static void calculateScore(boolean gameOver, int score, int levelCompleted, int bonus) {
if (gameOver) {
int finalScore = score + (levelCompleted * bonus);
finalScore += 2000;
System.out.println("Your final score was " + finalScore);
}
}

Now we can call the calculateScore() method inside our

main() method, and we can do this in 2 ways

Final step - 1st way

Inside the main() method we can call the calculateScore() method and directly
pass in the values we need

public static void main(String[] args) {

calculateScore(true, 800, 5, 100); // 1st score
calculateScore(true, 10000, 8, 200); // 2nd score
}

Final step - 2nd way

Java Basics 9
 For the second way we will define the variables and then use the variable names
as arguments

public static void main(String[] args) {

// 1st player's score
boolean gameOver = true;
int score = 800;
int levelCompleted = 5;
int bonus = 100;

calculateScore(gameOver, score, levelCompleted, bonus);

// 2nd player's score

score = 10000;
levelCompleted = 8;
bonus = 200;

calculateScore(gameOver, score, levelCompleted, bonus);

Useful shortcut psvm =

public static void main(String[] args) {

Method Overloading
Guide to Overloading Methods in Java
Java defines a method as a unit of the tasks that a class can perform.
And proper programming practice encourages us to ensure a method
does one thing and one thing only. It is also normal to have one
https://stackabuse.com/guide-to-overloading-methods-in-java

In Java we can have multiple methods with the same

name.

Java Basics 10
 But in order to do that every method needs to have it's
unique signature.

#1 The original method - 2 parameters [String, int]

public static int calculateScore(String playerName, int score){

System.out.println("Player " + playerName + " scored " + score + " points");
return score * 1000;
}

#2 A new method with the same name - 2 parameters[int,

int]

public static int calculateScore(int age, int score){

System.out.println("Player is " + age + " years old and he scored "
+ score + " points");
return score * 1000;
}

#3 A new method with the same name - 1 parameter [int]

public static int calculateScore(int score){

System.out.println("Unnamed player scored " + score + " points");
return score * 1000;
}

#4 A new method with the same name - 0 parameters

public static int calculateScore(){

System.out.println("No player name, no player score.");
return 0;
}

Java Basics 11
 As we can see above, all methods have the same name,
but they have have a different number and type of
parameters.

Control Slow Statements

Switch , For, While & do-while

Switch - same as always

We can also combine multiple cases that will return/print the same
thing [case 3: case 4: case 5:]

int switchValue = 3;

switch (switchValue) {
case 1:
System.out.println("Value was 1");
break;

case 2:
System.out.println("Value was 2");
break;

case 3: case 4: case 5:

System.out.println("Was a 3 or 4 or 5");
System.out.println("Actually was " + switchValue);
break;

default:
System.out.println("Was not 1 or 2");
break;
}

While

Java Basics 12
 Here we will create a loop that outputs all the even numbers in a
range

int number → represents the starting point

int finishNumber → represents the end point
So while the number is ≤ finishNumber increase the number by 1 (number++)
If during its increase, the number becomes an odd number(ex 5,7,9, etc.) we use
[continue] to skip the odd number and continue increasing it.
The way [continue] works is like this:

The number is increased and printed while number ≤ finishNumber is true

If the number is not even(ex. 5) , continue will skip the printing and go back to
(number <= finishNumber)

If (number <= finishNumber) is evaluated as true, it's gonna increase the number(ex
ro 6) and check if it's even, if it is, then it' gonna print it and do the same thing untill
(number <= finishNumber) will be evaluated as false

The while loop example

int number = 4;
int finishNumber = 20;

while (number <= finishNumber){

number++;
if(!isEvenNumber(number)){
continue;
}
System.out.println("Even number " + number);
}

Method checking if number is even or odd

public static boolean isEvenNumber(int number) {

return number % 2 == 0;
}

Java Basics 13
Java Basics 14