Java Tutorial - 1 Introduction
Tags: java, tutorial, beginners
Published: 2021-05-24 07:02:34

Java is one of the most popular programming language right now. Java has been used in many application development especially backend development.

## Setup

This is the [guide](https://www.java.com/en/download/help/download_options.html) that can be used to install the java SDK to run the java code.

To check the java installation run this command:

```
java -version
```

## Writing the First Code

To write the java code, any IDE or text editor can be used. The IDE that commonly used are NetBeans and IntelliJ IDEA. Here it is the first code.

```java
public class MyApp {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}
```

This is the output after the code is executed:

```
Hello World!

```

Based on that code, the `System.out.println()` syntax is executed inside main method that located inside `MyApp` class. the `println()` function is used to create an output with additional white space.

Another way to create an output is using `printf()` function. This function can be used to create an output with specific format. In this example, the number and the text or a `String` is printed using `printf()` function.

```java
public class MyApp {
    public static void main(String[] args){
        // create a variable called text and number
        String text = "this is a text";
        int number = 99;

        //using %s syntax to print out the String data
        // \n syntax is used to add additional newline
        System.out.printf("The text data: %s\n",text);
        // using %d syntax to print out the int data
        System.out.printf("The number data: %d\n",number);
    }
}
```

This is the output:

```
The text data: this is a text
The number data: 99

```

To learn more about `printf()`, visit this [page](https://www.baeldung.com/java-printstream-printf).

## Adding Inputs

There are many ways to create an input in Java, one of those are using `Scanner` class that can be imported in `java.util.Scanner` package.

```java
import java.util.Scanner;

public class MyApp {
    public static void main(String[] args){
        // create a scanner
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter a number: ");
        // receive the input using nextInt() for int data
        int data = scanner.nextInt();
        // skip to the next input
        scanner.nextLine();

        System.out.print("Enter a text: ");
        // receive the input using nextLine() for String data
        // nextLine() is used to allow String input with spaces (e.g. "Hello World!")
        String textData = scanner.nextLine();

        // print out the inputted data
        System.out.println("Your entered number: " + data);
        System.out.println("Your entered text: " + textData);

    }
}

```

This is the input sample with the output:

```
Enter a number: 12
Enter a text: Sample Text
Your entered number: 12
Your entered text: Sample Text

```

## Variables

To create a variable in Java, use this syntax.

```
<modifier> <data_type> <variable_name>;
```

In this example, the variable called `number` is declared with the `int` type.

```java
// if the value isn't assigned in a variable,
// the default value is assigned
// (in this case the default value is 0)
int number;
```

This is another example of creating variable with `String` data type.

```java
// assign the value with '=' operator
String name = "firstname lastname";
// change the value
name = "another name";
```

There are another special variable called `final` and `static` variable.
The `final` variable is a variable that the value cannot be changed or known as constant. To create a constant in Java can be done by adding `final` keyword before variable declaration.

```java
// to declare a constant, use uppercase letters.
final double PI = 3.14;
```

The `static` variable is a variable that created only once in the beginning phase of program execution. When the `static` variable is defined inside a class, the variable can be accessed without creating the instance or an object of the class.

This is the example of declaring a static variable:

```java
static int number = 12;
//the static and final keyword can be used together
static final float PI = 3.14;
```

## Data Types

There are two main types of data type in Java. There are primitive data type and reference data type.
This is the list of primitive data type in Java.

| Data Type |             Value             |    Minimum Value     |     Maximum Value      |
| --------- | :---------------------------: | :------------------: | :--------------------: |
| byte      |      non-decimal number       |         -128         |          127           |
| short     |      non-decimal number       |        -32768        |         32767          |
| int       |      non-decimal number       |     -2147483648      |       2147483647       |
| long      |      non-decimal number       | -9223372036854775808 |  9223372036854775807   |
| float     |  decimal or floating number   |       1.4E-45        |      3.4028235E38      |
| double    |  decimal or floating number   |       4.9E-324       | 1.7976931348623157E308 |
| boolean   |       `true` or `false`       |          -           |           -            |
| char      | single character (alphabetic) |          -           |           -            |

The primitive data type that commonly used are `int`, `float` `char`, and `boolean`.

> Use the data type based on the value that will be assigned and consider the minimum value or maximum value that can be stored.

There are many examples of reference data type. One of those are `String` that commonly used to store alphabetical characters like username. The other example of reference data type are array, list, and a class that defined in Java.

The main difference between primitive and reference data type is the primitive data type store the real value inside the variable. Otherwise, the reference data type store the reference to the exact or real value inside the variable.

This is the illustration of primitive data type and reference data type.
![Data Type Illustrations](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/dbmol5mbrr53pskgvfm3.png)

## Operator and Modifier

In Java, there are many operators that available for number operation. The operation must be done with the same data type.

| Operator |                         Description                          |
| -------- | :----------------------------------------------------------: |
| `+`      |                        add operation                         |
| `-`      |                     substract operation                      |
| `*`      |                      multiply operation                      |
| `/`      |                      division operation                      |
| `%`      | modulo operation (get the remainder from division operation) |

This is the example of using operator in Java.

```java
public class MyApp {
    public static void main(String[] args){
        int a = 6;
        int b = 2;

        int sumResult = a + b;
        int subsResult = a - b;
        int mulResult = a * b;
        int divResult = a / b;
        int modResult = a % b;

        System.out.println("a + b = " + sumResult);
        System.out.println("a - b = " + subsResult);
        System.out.println("a * b = " + mulResult);
        System.out.println("a / b = " + divResult);
        System.out.println("a % b = " + modResult);

    }
}
```

The output:

```
a + b = 8
a - b = 4
a * b = 12
a / b = 3
a % b = 0

```

Modifier can be used to specify the scope of variable or a function inside the code. The modifier can be used before the declaration of variable or a function.

```java
// for variable, this variable can be accessed from any class
public int number = 12;

// for function, this function can be accessed only inside its own class
// function will be covered later
private int getSum(int a, int b) {}
```

The available modifiers in Java can be checked here.

| Modifier | Class | Sub Class | Package | Outside Package |
|-|-|-|-|-|
| public | ✔ | ✔ | ✔ | ✔ |
| protected | ✔ | ✔ | ✔ |  |
| private | ✔ |  |  |  |
| default | ✔ |  | ✔ |  |

The check mark (✔) represents the visibility.

## Sources

- Useful [resource](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/index.html) for learning the basics of Java.
- Learn more about static keyword [here](https://www.guru99.com/java-static-variable-methods.html#:~:text=What%20is%20Static%20Variable%20in,the%20start%20of%20the%20execution.).

I hope this article is helpful for learning the Java programming language. If you have any thoughts or comments you can write in the discussion section below.