Introduction

This is where the fun part begins! With the previous tutorials we have and idea of the core building blocks, now we start looking at the implementation of flow control, or logic if you will. The most important statement for implementing logic, in my personal experience is the If statement.

If Statement

Lets jump right into an example! The If statement works like this:

if ( true )
    System.out.println("Evaluation was true");

We have the keywork if followed by a boolean expression that, as the name states, must evaluate to a boolean. In our particular example it will always evaluate to true.

If the expression evaluates to true (which is our example, it always does) , the next statement is executed. If the expression evaluates to false, then next statement is NOT executed , and the execution flow continues after the next statement.

Now lets look at the following modification we made:

if ( false )
    System.out.println("Evaluation was true");
    System.out.println("Evaluation was true, part 2");

The if boolean evaluation is always false now, so the first statement after the if is not executed. But the second print statement will be executed, because the if statement only conditions one statement. If we only wanted to have the two println statements execute if the previous condition was true, then we need to user a block, like so:

if ( false )  {
    System.out.println("Evaluation was true");
    System.out.println("Evaluation was true, part 2");
}

This would make the two println statements execute if the evaluation is true. Because in our previous example it is false, then the two println statement would not be executed.

Until now we have been using a boolean directly to define the behavior of the if statement, which makes this code execute always in the same way and no decision be actually made.

But, like it was said because, we can place any statement inside that if condition as long as it evaluates to a boolean.

Equality Operators

For comparing primitive variables, we have these Equality Operators:

• == : Equal to
• != : Not equal to
• > : Greater than
• >= : Greater than or equal to
• < : Less than
• <= : Less than or equal to

Look at the following code snippet:

int age = 10;

if ( age < 18 ) {
    System.out.println("Price of ticket : 50" );
}

if ( age == 18 ) {
    System.out.println("Price of ticket : 100" );
}

if ( age > 18 ) {
    System.out.println("Price of ticket : 120" );
}

Very easy to understand, yes?

• If the variable age is smaller than ( < ) 18, the code will print : Price of ticket : 50
• If the variable age is equal to ( == ) 18, the code will print : Price of ticket : 100
• If the variable age is greater than ( > ) 18, the code will print : Price of ticket : 120

Nothing special, but now, lets try something else:

public static void main(String[] args) {

    String value1 = new String("good");
    String value2 = new String("good");

    if (value1 == value2) {
        System.out.println(" They are equal ");
    }

}

When we run this main method, we expected to see the program write They are equal to the console, but it produces nothing. The reason for this is that , like we said before, these operators are only to be used with Primitive Variables, and as we know, String is not a primitive type, it is an Object.

Objects are compared differently, but to fully understand the deal with Object, we must first talk about Reference Variables, which will happen in one or two tutorials. For now, lets focus on primitives and see what can be achieved with If statements .

Equality Operators are to be used with Primitive Variables. Comparing Objects with == might produce unexpected results.

Equality Operators can also be combined with boolean operators to create more complex boolean expressions.

Conditional Operators

These are some the available Conditional Operators:

• & - AND
• | - OR
• && - Conditional AND
• || - Conditional OR

Lets see them in use and understand the difference between an AND and a Conditional AND . We'll create a class for that purpose, and call it TestOperators. It will look like this:

package tutorial7;

public class TestOperators {

public void compareUsingAnd( int value1 , int value2) {

    if (  value1 >= 10 & value2 < 100 ) {
        System.out.println(" Condition is true ");
    }

}

}

What it means is, if :

• value1 >= 10 : value1 variable is Greater or Equal than 10
• & : AND
• value2 < 100: value2 variable is Less than 100

Then :

• System.out.println(" Condition is true ");

Now, on our Starter class, we create an instance of the TestOperators class and call that method like this:

public static void main(String[] args) {

    TestOperators test = new TestOperators();
    test.compareUsingAnd( 10, 50 );

}

When we run the code it produces:

 Condition is true 

Lets modify the code on the compareUsingAnd method like this :

package tutorial7;

public class TestOperators {

    public void compareUsingAnd( int value1 , int value2) {

        if (  firstComparison(value1) &   value2 < 100 ) {
            System.out.println(" Condition is true ");
        }

    }

    private boolean firstComparison(int value) {
        if ( value >= 10)
            return true;
        return false;
    }

}

It does exactly the same thing, but instead of doing the two individual comparisons inside the boolean expression, we create one method called firstComparison that performs exactly the same comparison and call that method instead. Lets just look at that method for a second :

private boolean firstComparison(int value) {
System.out.println("- Running firstComparison");

    if ( value >= 10)
        return true;

    return false;
}

From the signature of the method we know :

• It is a private method, because it just needs to be accessible from inside the TestOperators class,
• it returns a `boolean* value,
• it receives an int parameter that we simply call value.

First it prints "- Running firstComparison", just so we know the method was called.

Then, if the value provided is Greater or Equal to 10, it returns true and the method finishs (a method finishes after the return statement).

If the value is NOT Greater or Equal to 10, then it does not return true;, so it continues executing, and returns false.

We run our program and it produces:

- Running firstComparison
 Condition is true 

So firstComparison evaluated to true, and value2 < 100 also evaluated to true.

Now, as an exercise and because we need it to continue the rest of the tutorial, create a method called secondComparison and do the same thing we did with firstComparison.

The end result should look like this :

package tutorial7;

public class TestOperators {

    public void compareUsingAnd( int value1 , int value2) {

        if (  firstComparison(value1)  &  secondComparision(value2) ) {
            System.out.println(" Condition is true ");
        }

    }

    private boolean firstComparison(int value) {
        System.out.println("- Running firstComparison");

        if ( value >= 10)
            return true;
        return false;
    }

    private boolean secondComparision(int value) {
        System.out.println("- Running secondComparision");

        if ( value < 100)
            return true;
        return false;
    }
}

Running the previous main method will produce:

- Running firstComparison
- Running secondComparision
 Condition is true 

With these two methods we can see when the evaluations are made, and it is easier to explain concepts.

Lets modify the main method to call the compareUsingAnd method with values 1 and 50:

public static void main(String[] args) {

    TestOperators test = new TestOperators();
    test.compareUsingAnd( 1, 50 );

}

We compile and run this code and get:

- Running firstComparison
- Running secondComparision

As you can see, this time around there was no "Condition is true" being printed, and the reason is, if you follow the code, method firstComparison evaluates to false even tho secondComparision evaluates to true, and because :

false AND true = false

which is essencially what this mean :

if (  false  &  true ) {
    System.out.println(" Condition is true ");
}

The condition of the if is not meet, and the println statement is not executed.

If you have any doubts why false AND true = false then please check Wikipedia - Truth Tables. It is essential to have an understanding of logic operations of this kind.

Notice that because the first evaluation ( the firstComparison method) evaluates to false! Because we are using an AND, the if condition could never be satisfied, no matter what secondComparision evaluates to.

In an AND boolean operation , both arguments must be true for the result to be true

So :

• false AND false = false
• true AND false = false
• false AND true = false

Only:

• true AND true = true

Lets modify the compareUsingAnd method on the TestOperators class to this :

public void compareUsingAnd( int value1 , int value2) {

    if (  firstComparison(value1) && secondComparision(value2) ) {
        System.out.println(" Condition is true ");
    }

}

The only difference was changing & to && , so using Conditional AND instead of AND .

Compiling and running this new version produces the following:

- Running firstComparison

So, as you can see, secondComparision was never called.

This is the difference between AND and Conditional AND . The AND operator ( & ) evaluates both side of the AND before doing the boolean operation . The Conditional AND ( && ) first evaluates the first part , and only if the second part is necessary for the boolean operation, does it ever gets evaluated.

In our last example, because the first part evaluated to false , it is unnecessary to evaluate the second part.

Now, using && is not more or less correct that & . They are different , have different behaviors, and a programmer needs to be aware of this. Most of the time && is used, but there could be particular use-cases that require & instead of && .

OR and Conditional OR work exactly in the same way. OR ( | ) will evaluate both side of the boolean operation before evaluating the OR expression, while the Conditional OR ( || ) evaluates the first side, and only evaluates the second if necessary.

Else

Again, we'll modify the compareUsingAnd method like this :

public void compareUsingAnd( int value1 , int value2) {

    if (  firstComparison(value1) && secondComparision(value2) ) {
        System.out.println(" Condition is true ");
    } else
        System.out.println(" Condition is false ");

    System.out.println(" Finished ");
}

Notice the else keyword. This keyword is used together with If statements, to execute something when the if evaluation is not meet.

Compiling and running this code will produce :

- Running firstComparison
 Condition is false 
 Finished 

As like before, only the statement after the else keyword is execute. If the programmer wants to execute more statements in case the evaluation fails, then a block ( { } ) must be used, like this :

    if (  firstComparison(value1) && secondComparision(value2) ) {
        System.out.println(" Condition is true ");
    } else {
        System.out.println(" Condition is false ");
        System.out.println(" Condition is false ");
    }

Which would print the same thing twice..... just to demonstrate the block.

If Statements are binary, the expression evaluates either to true or false and there are only two paths of execution.

To allow for more paths of execution we could chain If Else Statements and create something like this:

    if ( age < 18) {
        System.out.println(" underage ");
    } else {

        if (age < 70) {
            System.out.println(" adult ");
        } else {
            System.out.println(" elder ");
        }

    }

This is completely valid, and commonly done.

Not

Also, there is a wait to invert a boolean. Lets look at the following code :

if ( age < 18) {
    System.out.println(" underage ");
} 

This is equivalent to :

if ( ! age >= 18) {
    System.out.println(" underage ");
} 

Notice the ! operator, that inverts the result of the age >= 18 expression.

So, if we have age defined like int age = 5 ; , this is how the evaluation would be evaluated :

1. Replacing we get : if ( ! 5 >= 18 )
2. 5 >= 18 is evaluated first , resulting in false , because 5 is not Getter nor Equal to 18.
3. we would then have : if ( ! false )
4. !false is true , because the ! changes the boolean value ( this is what it does )
5. we have : if ( true )

Is this making sense?

In fact, to demonstrate this better, look at the following code :

boolean value = true;
System.out.println("Value is : " + value);

Executing this would produce :

Value is : true

Now, modifying the code like this :

boolean value = !true;
System.out.println("Value is : " + value);

Would produce :

Value is : false

So, as you can see, the ! operator just inverts the boolean.

There are many many other ways to control the flow of execution of a program, If Statements are one , another is the Switch Statement , which is not used as much as the If Statement but is also important to know.

Switch Statement

The Switch statement works a bit differently from the If Statement. The switch statement also takes an expression, but this expression must evaluate to byte, short, char, int, String.

Lets look at the following example:

int value = 1 ;

switch ( value ) {

    case 1:
        System.out.println("Detected");
        System.out.println("Value is 1");
        break;

}

If we were to execute this code, the result would be :

Detected
Value is 1

So what this does is:

1. switch ( value) : the switch take the value the expression evaluates to. In this case the expression is just a value that evaluates to int.

2. The value of the expression gets compared with all the case options available.

3. Because the evaluation of the expression is 1 and there is a case that matches that case 1: , everything after that is executed until a break; is found.

Very simple!

Look at this modified version of the previous code:

int value = 2 ;

switch (value) {
    case 1:
        System.out.println("Detected");
        System.out.println("Value is 1");
        break;
    case 2:
        System.out.println("Detected");
        System.out.println("Value is 2");
        break;
    case 3:
        System.out.println("Detected");
        System.out.println("Value is 3");
        break;
}

In this example we modified the value the expression evaluates to, and we added a few other cases.

Compiling and executing this will produce :

Detected
Value is 2

There is also a special catch, which is the default case, which can be used to execute in case the expression does not evaluate to any of the other cases :

int value = 5 ;

switch (value) {
    case 1:
        System.out.println("Detected");
        System.out.println("Value is 1");
        break;
    case 2:
        System.out.println("Detected");
        System.out.println("Value is 2");
        break;
    case 3 :
        System.out.println("Detected");
        System.out.println("Value is 3");
        break;
    default:
        System.out.println("Nothing Detected");
        break;
}

Compiling and executing this will produce :

Nothing Detected

Very easy, yes ? But now , just out of curiosity, lets remove all the breaks; from the code. Give a look at this:

int value = 2 ;

switch (value) {

    case 1:
        System.out.println("Detected");
        System.out.println("Value is 1");
        //break;
    case 2:
        System.out.println("Detected");
        System.out.println("Value is 2");
        //break;
    case 3 :
        System.out.println("Detected");
        System.out.println("Value is 3");
        //break;
    default:
        System.out.println("Nothing Detected");
        //break;
}

Executing would produce :

Detected
Value is 2
Detected
Value is 3
Nothing Detected

Because value is now 2, it does not match the first case, but it matches case 2, so it starts executing until it finds the break; statement, which does not exist, so it executes until the end of the Switch statement.

It is very important to remember that, if a case matches, execution will be until a break; is reached, or the Switch body ends.

Wrapping up

So, with this basic knowledge of Flow Control, you are ready to try out a few exercises, just to get some practice in solving some small problems, and getting used to writing code. Check the first exercises section before going for the next Tutorial!

References

• Wikipedia - Truth Tables
• Oracle Java Documentation - the switch statement

Introduction

At this point we have all the knowledge we need to create Classes, methods, variables, instances of Objects, call methods, etc. These are the basic building blocks of any program made in Java.

In the last tutorial we finished with the following phrase:

Wouldn't it be nice to be able to have a list of Person objects stored in someway, instead of having to programmatically define a variable for each of the objects we create?

Well, lets look at Arrays then!

Arrays

For this Tutorial we will create another project with IntelliJ called "BeginnerJava6" , or just another empty folder named "BeginnerJava6" where we'll store our code. Create a package called "tutorial6", and we'll write all our code inside this package.

Lets create a class caller Starter with a main method:

package tutorial6;

public class Starter {
    public static void main(String[] args) {

    }
}

All very simple until now.

Lets talk Arrays

We'll kick it off with an example of an Array:

int[] listOfInts = new int[10];

What is an Array? In Java, the simplest way of describing an array is: a structure that stores values. These structure have a few properties that are very important to understand :

• They are of fixed size

So, an array has a fixed size that is defined when the array is created. In our example of listOfInts, it is a structure that can take 10 elements : new int[10]

• It is typed

Which means that they store elements of a specific type. This specific type is defined also when the array is created. In our example it stores int values.

• It is ordered

This means that the elements have a specific position on the array, and that adding or removing elements, does not change the position or the remaining elements in the array.

These are a few examples of other types of arrays:

• float[] listOfFloats = new float[10]; - An array of floats of size 10
• double[] listOfDoubles = new double[50]; - An array of doubles of size 50
• String[] listOfStrings = new String[9000]; - An array of Strings of size 9000

As you can see, the notation is quite simple! First the programmer defines the type of array it wants to work with, and a name for that array:

• int[] listOfInts : This is the declaration part of the statement on our first example

Then the programmer instantiates the array, using the new keyword, like it was an object, but instead of using the ( ) to pass arguments to a constructor, the programmer uses [ ] with the size of the array he need to create :

• new int[10] : This is the instantiation part of the statement, where the size of the array is specified

Lets create an array of ints inside the main method of the Starter class:

package tutorial6;

public class Starter {

    public static void main(String[] args) {

        int[] listOfInts = new int[10];

    }

}

A few things to take notice, and recapping from the last tutorials :

• the listOfInts variable is of Method Level Scope
• because it is of Method Level Scope , it only exist inside that method
• and because it is of Method Level Scope it does not have an Access Modifier
• inside the main method we create the array variable and instantiate it with a size of 10
• it does nothing else

Everything is making sense, yes?

Very easy, give it a compile and run it. If it does absolutely nothing, that means that it is good.

Accessing values of an Array

To access the values inside the array we do : arrayName[ POSITION ] where POSITION is the index of the array we want to access.

The index of an array is an int always starts at 0 and ends at size-1 of the size defined at its instantiation.

Lets modify the main method of the Starter class to print all the elements of the array we are creating:

public static void main(String[] args) {

    int[] listOfInts = new int[10];

    System.out.println("Value at index 0 : " + listOfInts[0] );
    System.out.println("Value at index 1 : " + listOfInts[1] );
    System.out.println("Value at index 2 : " + listOfInts[2] );
    System.out.println("Value at index 3 : " + listOfInts[3] );
    System.out.println("Value at index 4 : " + listOfInts[4] );
    System.out.println("Value at index 5 : " + listOfInts[5] );
    System.out.println("Value at index 6 : " + listOfInts[6] );
    System.out.println("Value at index 7 : " + listOfInts[7] );
    System.out.println("Value at index 8 : " + listOfInts[8] );
    System.out.println("Value at index 9 : " + listOfInts[9] );

}

Compile and run it. The result should be something like this:

Value at index 0 : 0
Value at index 1 : 0
Value at index 2 : 0
Value at index 3 : 0
Value at index 4 : 0
Value at index 5 : 0
Value at index 6 : 0
Value at index 7 : 0
Value at index 8 : 0
Value at index 9 : 0

Notice that all elements of the array are filled with 0s, this is an important detail to know about arrays, they are initialized with with default values of the type of array they are, hence:

• int[] ints = new int[10] : all elements will be 0
• double[] doubles = new doubles[10] : all elements will be 0.0

If the array was an array of objects, then the default value of each element would be null, which is to mean that the position is empty and has no object. We'll see more about what null means when looking at Reference Variables. Some examples :

• User[] users = new Users[10] : all elements will be null
• String[] strings = new String[10] : all elements will be null

Give it a try and see the results yourself.

Now we can read the elements in the array positions, but what about setting those values?

Setting values of elements

To set the value of a particular element of an array we use the same notation as before: arrayName[ POSITION ] where POSITION is the index of the array we want to access, and then we assign the value using the = operator, like so:

listOfInts[5] = 1000;

This last statement will assign the value of 1000 to the element on the 6st position! Yes, 6st position, remember that the index starts at 0, and 0 is the first position of the array.

As an exercise, modify the main method to first assign values to all elements of the array and then print them out.

The end result should be something like this:

public static void main(String[] args) {

    int[] listOfInts = new int[10];

    listOfInts[0] = 199;
    listOfInts[1] = 9349;
    listOfInts[2] = 9229;
    listOfInts[3] = 11243;
    listOfInts[4] = 952;
    listOfInts[5] = 13;
    listOfInts[6] = 422;
    listOfInts[7] = 4239;
    listOfInts[8] = 527;
    listOfInts[9] = 874;


    System.out.println("Value at index 0 : " + listOfInts[0] );
    System.out.println("Value at index 1 : " + listOfInts[1] );
    System.out.println("Value at index 2 : " + listOfInts[2] );
    System.out.println("Value at index 3 : " + listOfInts[3] );
    System.out.println("Value at index 4 : " + listOfInts[4] );
    System.out.println("Value at index 5 : " + listOfInts[5] );
    System.out.println("Value at index 6 : " + listOfInts[6] );
    System.out.println("Value at index 7 : " + listOfInts[7] );
    System.out.println("Value at index 8 : " + listOfInts[8] );
    System.out.println("Value at index 9 : " + listOfInts[9] );

}

And running this last example will produce:

Value at index 0 : 199
Value at index 1 : 9349
Value at index 2 : 9229
Value at index 3 : 11243
Value at index 4 : 952
Value at index 5 : 13
Value at index 6 : 422
Value at index 7 : 4239
Value at index 8 : 527
Value at index 9 : 874

There is another way to set the values of an array, which is to assign the values when initializing the array.

Initing with values

In some cases, when we create an array we already know what values we want to place in it, and in those cases it makes a lot more sense to just set those values during instantiation, instead of instantiating an array with a specific size and then writing some more code to insert the values in their correct positions.

This is done in the following way:

int[] listOfInts = new int[]{ 111,222,333,444,555,666,777,888,999,1000 };

This small example will create an array of ints called listOfInts, with a size of 10although it is not specified directly, and with the following ints 111,222,333,444,555,666,777,888,999,1000 in their ordered position.

Notice that by using this notation :

• The size of the array is specified indirectly , it is the size of parameters provided.
• The order of the values will be the corresponding index, starting with 0

As an exercise, modify the main method to assign values during instantiation of the array, and print those values out.

The end main method should look something like this:

public static void main(String[] args) {

    int[] listOfInts = new int[]{ 111,222,333,444,555,666,777,888,999,1000 };

    System.out.println("Value at index 0 : " + listOfInts[0] );
    System.out.println("Value at index 1 : " + listOfInts[1] );
    System.out.println("Value at index 2 : " + listOfInts[2] );
    System.out.println("Value at index 3 : " + listOfInts[3] );
    System.out.println("Value at index 4 : " + listOfInts[4] );
    System.out.println("Value at index 5 : " + listOfInts[5] );
    System.out.println("Value at index 6 : " + listOfInts[6] );
    System.out.println("Value at index 7 : " + listOfInts[7] );
    System.out.println("Value at index 8 : " + listOfInts[8] );
    System.out.println("Value at index 9 : " + listOfInts[9] );

}

Executing this last main method will produce:

Value at index 0 : 111
Value at index 1 : 222
Value at index 2 : 333
Value at index 3 : 444
Value at index 4 : 555
Value at index 5 : 666
Value at index 6 : 777
Value at index 7 : 888
Value at index 8 : 999
Value at index 9 : 1000

What is the size of this array?

Another really important detail of working with arrays, is getting the size of an array. In our examples thus far we created the arrays, we know the sizes, we know what they contain, but this might not always be the case.

To get the size of an array we access the length public int variable that exists on all arrays, because arrays are objects (remember, if a variable is not of a primitive type, it is an object) :

listOfInts.length;

As an exercise, modify the main method we have been working with, and after printing all the values print also the size of the array.

The end result could look like this:

public static void main(String[] args) {

    int[] listOfInts = new int[]{ 111,222,333,444,555,666,777,888,999,1000 };

    System.out.println("Value at index 0 : " + listOfInts[0] );
    System.out.println("Value at index 1 : " + listOfInts[1] );
    System.out.println("Value at index 2 : " + listOfInts[2] );
    System.out.println("Value at index 3 : " + listOfInts[3] );
    System.out.println("Value at index 4 : " + listOfInts[4] );
    System.out.println("Value at index 5 : " + listOfInts[5] );
    System.out.println("Value at index 6 : " + listOfInts[6] );
    System.out.println("Value at index 7 : " + listOfInts[7] );
    System.out.println("Value at index 8 : " + listOfInts[8] );
    System.out.println("Value at index 9 : " + listOfInts[9] );

    int size = listOfInts.length;
    System.out.println("Size of array is : " + size);

}

Notice that in this bit of code, this particular section :

int size = listOfInts.length;
System.out.println("Size of array is : " + size);

Could be rewritten as:

System.out.println("Size of array is : " + listOfInts.length);

Which would avoid creating another variable and assigning a value to that variable.

If you have been trying these exercises, and writing code as you are learning it, you probably already tried to access an element of an array using an index that is larger than the size of the array itself. If you did, then you got an error. Lets look at that now.

Accessing using invalid index

Like it was said in the beginning of this tutorial, an array has a fixed size, and it's index goes from 0 to size-1, so what happens when we use an index that is smaller than 0 or bigger than size-1?

Lets modify the main method to try it out:

public static void main(String[] args) {

    int[] listOfInts = new int[10];
    System.out.println("Value at index 0 : " + listOfInts[-1] );

}

Compiling this code will produce no errors.

Running the compiled code will generate an exception:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: -1
    at tutorial6.Starter.main(Starter.java:7)

The same is true for trying to set a value with an invalid index:

int[] listOfInts = new int[10];
listOfInts[20] = 1000;

This will also produce an exception:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 20
at tutorial6.Starter.main(Starter.java:7)

One way to avoid these exceptions, of type ArrayIndexOutOfBoundsException, if to verify before if the index we are about to use is smaller or equal to the size of the array, and also larger than 0. We'll see how to do that on the next tutorial.

If you feel ready, the next Tutorial : Tutorial 6 - Flow Control

References

• Java 8 API Specification

Introduction

In this tutorial we'll finally look at Packages to organize our code, and also at Access Modifiers that will allow us to restrict access to parts of our Classes.

By this point you show have an understanding of how to create a new Class, create new objects of a class type, create variables and know that there are primitive types. If you don't, the please check the Tutorial 3 - Variables and Tutorial 4 - Classes, Constructors and Methods .

So, if you have IntelliJ Community Edition installed and would like to use it, just open it up and Create a New Project, of Java type, and select no other libraries nor Frameworks. Call it "BeginnerJava5". If you are using a text editor, just create a new Folder somewhere on your disc and call it "BeginnerJava5".

We'll develop a very rudimentary system that creates and stores data on Persons, much like we did on the previous tutorial. We'll do it from scratch, and now learn about Packages in Java.

Lets start with creating a class called Starter, so using IntelliJ on the left tree find the "src" folder, right click in it and select "new" -> "Java Class" . If you are using a the text editor, create a file called "Starter.java" on the root of the folder you previously created.

public class Starter {
}

This is our Starter class. Lets create a main method and make it print out something:

public class Starter {

    public static void main(String[] args) {
        System.out.println("Starting program");
    }

}

Compile it and run it. If you are using IntelliJ simply press Ctrl+Shift-F10.

Everything should be fine to this point.

Now we'll go and implement the User class, but before we do, lets think a little about how we want to organize our Classes. For a project so small as this one it wouldn't be a problem to have all Classes in the same place, but imagine for a project that will have tens or hundreds or thousands of Classes? Having a large project with all its classes in the same place would be a nightmare to manage, and work with.

There is the concept of Packages in Java, which allows the programmers to organize their classes in a tree like fashion.

Packages

Every project in Java should have its package, the exception being that the project will never ever be used again in any sort of productive way. Lets call this a rule.

Because we are programming a Person management system, and because we want to do it right, well create a package for this project. We'll call it tutorials.personmanagement .

There is a naming convention as to what the package name of a software or library should be and what rules should be follow:

• Package names are in all lowercase
• If the project is developed by a company, organization, or person that has an internet domain, the reverse of the domain is used to start the name of the package.

For example, if this was a project developed by JBay Solutions and this project is a Printing Money Software, then because JBay Solutions has the domain jbaysolutions.com the package could be called for example:

• com.jbaysolutions.printingmoney
• com.jbaysolutions.printmoneysoftware
• com.jbaysolutions.lib.printingmoney

There is a bit of freedom to choose the name of the package, but its goal is to avoid conflicts! By following these rules, it is very unlikely that you'll find conflicts of Classes with the same name, inside packages with the same name, in different libraries.

So, our package is going to be called tutorials.personmanagement.

If you are using IntelliJ just right-click on the "src" folder on the Project tree on the right, and select "new" -> "Package" . Just type in : tutorials.personmanagement .

If you are using the text editor, then just go to the folder of the project, and create a folder named "tutorials" and then inside that folder create another folder called "personmanagement" .

So now we have the Package for the project, we'll start with the creation of the Person class, inside the tutorials.personmanagement package . Just go ahead and create the Person class, with no methods and no variables.

If you use IntelliJ it should look like this:

package tutorials.personmanagement;

public class Person {
}

If you created the Class in a normal Text Editor, then you are probably missing the first line:

package tutorials.personmanagement;

Because this Person class "belongs" to a package, not only must the file be created inside that specific folder, the first statement of that Class must be the definition of the package it belongs to.

This would also be correct, because the Comments and Blank lines obviously don't count as statements:

// This is a comment

/*
 This is also a comment 
*/

package tutorials.personmanagement;

public class Person {
}

For our software, a Person will have the following attributes:

• A Name - String
• An Age - int
• A Salary - double

Lets implement this class then, with the Getter and Setter methods for all the properties, and also create 2 constructors, one that takes all 3 parameters and one that takes just the Name and Age, because under aged people will not have a salary.

We should end up with a class somewhat like this :

package tutorials.personmanagement;

public class Person {

    String name;
    int age;
    double salary;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

Notice that in this class we have two constructors. This is valid, because the constructors have different signatures.

Likewise we could have several methods with the exact same name, as long as input paramenters part of the signature is different. This is called method overloading , or in our particular case here, constructor overloading.

Overloading

Lets think about this "Overloading" thing for a second.

We have two Constructors like this:

• public Person(String name, int age, double salary)
• public Person(String name, int age)

Why is this allowed? The simple reason is : you call them in different ways!

Because you call them in different ways, the JVM, when it is executing, will know exactly which constructor to use based on the input you provide.

As an example, imagine you will be creating a Person object with the following code:

Person person = new Person( "Rui", 35 );

The JVM knows that you are trying to call a constructor that takes as input a String and an int in this particular order. It will then look at the class Person and see if there is a Constructor that matches this. It finds it and uses it:

• public Person(String name, int age)

It will not be able to use the other Constructor :

• public Person(String name, int age, double salary)

Likewise, if we try to create a Person object with the following code:

Person person = new Person( "Rui", 35 , 1000.0 );

It will only be able to use the second constructor.

Overloading works exactly in the same way for methods.

Also, if we look at one of the constructor, we will notice that the names of the parameters provided are exactly the same as the names of the Class level variables:

String name;
int age;
double salary;

public Person(String name, int age) {
    this.name = name;
    this.age = age;
}

These are effectively two different variables, one that has a Class Level Scope, and one that has a Method Level Scope (check the previous Tutorial to understand more about variables scope Here) .

This is legal, because they are defined in different scopes.

But now, because we can access two variables with the same name from inside the method (or constructor in our case), there has to be a way to unequivocally specify which variable we are referring to, hence the use of the keyword this .

this Keyword

From inside a method, the keyword this is used to reference the Object the method belong to. In this particular case, inside the constructor, the this.name specifies unequivocally that we are referring to the String name variable defined outside the method.

If we have this Constructor instead:

String name;
int age;
double salary;

public Person(String name, int age) {
    name = name;
    age = age;
}

Because we are not using the this keyword, then we will be referring to the String name variable that is passed as argument, and therefore we would not be affecting any of the Class Level variables that exist on the class.

Notice also that on the Setter methods of the class, we also use the same name for the input argument as we use for the Class variables, and therefore we need to use the this keyword:

public void setName(String name) {
    this.name = name;
}

Also, keep in mind that the following method would be valid and would accomplish the same result as the previous method:

public void setName(String newName) {
    this.name = newName;
}

In this particular case the use of the this keyword is redundant, because there is no ambiguity as to which variables we are referring to, but it is legal and correct non the less.

Lets continue with the code.

Continuing

On our Starter class, which does not have a package, we only have the main method, which is at this point printing a String. Lets modify the main method to now create an object o type Person:

public class Starter {

    public static void main(String[] args) {
        System.out.println("Starting program");        
        Person person = new Person("Rui", 35);
    }

}

If you are using IntelliJ or any other IDE, the source code should be showing some errors. This is because the Starter doesn't know what Person is, nor where it is. We must import the Class to let Starter know that when we refer to Person we are talking about a specific class:

import tutorials.personmanagement.Person;

public class Starter {

    public static void main(String[] args) {
        System.out.println("Starting program");

        Person person = new Person("Rui", 35);
    }

}

As you can see, in the first line of this class, we added an import statement:

import tutorials.personmanagement.Person;

This is how it works: If a programmer is writing some code in a Class that uses other Classes, then, if the other Classes are not in the same exact Package, the programmer needs to import either the specific class, or everything inside the Package of the other classes:

• import tutorials.personmanagement.Person; : Importing specific class
• import tutorials.personmanagement.* ; : Importing every class inside this package

Usually a programmer will import only the Class that is needed, unless there are several Classes inside a package that are going to all be needed, and in that case, the programmer imports all the Classes inside a Package using the * notation.

Why is this important?

Imagine for a second that you are developing a big project that has a visual component that draws Squares on the screen, and a computational side that calculates areas of Squares. You will possibily have two classes called Square on two different packages :

• com.project.render.Square
• com.project.area.Square

When writting the code, depending of which part the programmer is now coding, he will need to import a different Square class. This gets even more tricky when a project uses libraries that were developed by a 3rd party, and you don't know all the names of all the classes that exist inside that 3rd party library.

The import statements are always placed between the Package statement and the beginning of the class

Like this:

package com.project;

import com.project.render.Square;

public class Example {
    [ETC ETC ETC]
}

If the specific class you will need to import stuff into does not belong to a Package, then the import statements should be the first statements of the file. (Obviously not counting the comments)

Compile and run what you have until now, and see if the import works ( Ctrl+Shift+F10 or Shift+F10 on IntelliJ) .

Calling methods from anywhere

In the previous part of this tutorial we created a Person class, and a Starter class where we create an instance of Person with some values. Lets now modify the Person object that was created and change the value of the name variable for that object, and lets also modify the Person class to add a method for printing the values of the variables. We'll start with the method of the Person class:

public void printData() {
    System.out.println("Value for name is : " + name);
    System.out.println("Value for age is : " + age);
    System.out.println("Value for salary is : " + salary);
}

Very simple, like we did on the previous tutorials.

Now, lets modify the main method on the Starter class, to modify the name property of the object and also print out the values of the object afterwards:

public static void main(String[] args) {
    System.out.println("Starting program");

    Person person = new Person("Rui", 35);
    person.setName("Super Rui");
    person.printData();
}

Compiling and running it we get :

Starting program
Value for name is : Super Rui
Value for age is : 35
Value for salary is : 0.0

The first thing to notice here is that the Constructor used for creating the Person object was the Constructor that only takes in String name and int age , and therefore salary was never ever set! But when we print, the value of salary is 0.0.

This is because, for Class Level Scope primitive typed variables (yes... all these names we have just learned), when not assigned, they take their default value, which for a double is 0.0.

The second thing to notice is that the change of the name was done through a Setter method, which is correct, but is not enforced here, which is bad. We'll see how to enforce that in a minute with Access Modifiers.

For our example of a Person Management System, we want that every time that a Person is created or properties are modified on a Person object, the Software shows some Logs. To do this, we will implement a method on the Person class that prints a provided message. We'll call that method logToConsole and we define it like this :

public void logToConsole(String message) {
    System.out.println("PERSON LOG - " + message);
}

So, every time this method is called with a message, it will writen to the console with a PERSON LOG - prefix.

Now, we'll modify every Setter method on the Person class to call this method before changing the value of a variable. We'll also modify the Constructors to call this method when they are called.

The final *Person class should look something like this now:

package tutorials.personmanagement;

public class Person {

    String name;
    int age;
    double salary;

    public Person(String name, int age) {
        logToConsole("Creating Person with name: " + name + " age: " + age);

        this.name = name;
        this.age = age;
    }

    public Person(String name, int age, double salary) {
        logToConsole("Creating Person with name: " + name + " age: " + age + " salary: " +salary);

        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public void logToConsole(String message) {
        System.out.println("PERSON LOG - " + message);
    }

    public void printData() {
        System.out.println("Value for name is : " + name);
        System.out.println("Value for age is : " + age);
        System.out.println("Value for salary is : " + salary);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        logToConsole("name modified to: " + name );

        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        logToConsole("age modified to: " + age);

        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        logToConsole("salary modified to: " + salary );

        this.salary = salary;
    }
}

Looking, for example, at the setName method we have:

public void setName(String name) {
    logToConsole("name modified to: " + name );

    this.name = name;
}

Which mean that before assigning the provided name value to the class variable name , we call the method logToConsole and print the value out.

Compiling the project now and running it will return something like this:

Starting program
PERSON LOG - Creating Person with name: Rui age: 35
PERSON LOG - name modified to: Super Rui
Value for name is : Super Rui
Value for age is : 35
Value for salary is : 0.0

Notice that we have 2 LOGs on the output. The first which corresponds to the Constructor , which should the values used on the creation of the Person object, and the second one which if for the call of the setName method.

Lets say now that we are very sneaky and lets try to call the logToConsole method from the main method in this way :

public static void main(String[] args) {
    System.out.println("Starting program");

    Person person = new Person("Rui", 35);
    person.setName("Super Rui");

    person.logToConsole("name modified to: MEGA MEGA RUI");

    person.printData();
}

When we compile and run it we get:

Starting program
PERSON LOG - Creating Person with name: Rui age: 35
PERSON LOG - name modified to: Super Rui
PERSON LOG - name modified to: MEGA MEGA RUI
Value for name is : Super Rui
Value for age is : 35
Value for salary is : 0.0

We now have 3 LOGs on the output, we have the third LOG saying that the name was modified to "MEGA MEGA RUI" but when we call the printData method, we see that the value for name is still "Super Rui". We understand why, because we called the logToConsole function, which simply prints things to the console, and not the setName Setter Method which also prints things (through the use of logToConsole) but also modifies the value of the name variable. We know this, but other users, that might be looking at the LOGs will not get this, and will wonder why the name was not modified.

The reason why this can happen is because everyone can call logToConsole.

Problems can even be worst, for example, with the salary variable. Imagine that the Setter method for Salary has some other code that calculates Taxes, and other things that are related to money. It would be a very big security issue if a programmer would modify the value of the salary of a person directly without using the Setter method, or print LOGs saying that the salary was modified, but nothing was actually changed on the Person object in question.

Enter the Access Modifiers.

Access Modifiers

Since the first tutorial of this series, every method and class we created started with the public keyword. This is the Access Modifier of the Class or Method, which in all our examples was public, which is the least restrictive Access Modifier that there is.

There are in total 4 Access Modifiers:

• public
• protected
• no modifier (package-protected)
• private

Public

A method that is public is a method that can be called from anywhere in the code. You can call it from inside the same class, from a different class in the same package, from a different class on a different package, etc. The same goes for Class Level Scope variables, you can access these variables from anywhere.

Private

A method that is private is a method can can only be called from the same Class where it is declared. The same goes for Class Level Scope variables, these can only be accessed from inside the same Class where they are declared.

Package-Protected

The package-protected is a modifier which does not have a specific name, but is usually referred to as the Package-Protected access modifier, or Package Level access modifier, which is when a method or a variable have no Access Modifier defined. An example is :

public class Person {

    String name;  // <-- Package-Protected Access Modifier
    int age;  // <-- Package-Protected Access Modifier
    double salary;  // <-- Package-Protected Access Modifier

}

These three Class Level Scope variables have the Package-protected access modifier , because they don't have an Access Modifier defined.

What this means is that these variables can be accessed directly only from the Class they are declared in, or from other Class that belong to the same package.

Protected

The protected Access Modifier is almost the same as the Package Access Modifier ( or "no modifier" ) , which means that the method or variable can be accessed from Classes that belong to the same package, but also from Subclasses even if they are in other packages. What is a Subclass? Well get back to this in a few tutorials, but it is nothing to worry about.

All these Access Modifiers can be applied Methods and Class Level Scope Variables.

As for Classes, they can only be "public" or "Package level" . Private and protected make no sense to Classes, and therefore cannot be used.

Using Access Modifiers

Looking at our Person Class, we see that we have 3 variables that are package-protected:

String name;
int age;
double salary;

It makes no sense to have them as Package-Protected because they are only meaningful to the Object they belong to. Also, because they have Getter and Setter methods, it makes no sense to allow them to be accessed and modified from outside of this Class. We should make them private, like so:

public class Person {

    private String name;
    private int age;
    private double salary;

What about the methods? The Getter and Setter methods, because we want to be able to access them from other classes, even outside of the package this class belongs to, we leave them as public.

What about the logToConsole method? Because we only want this method to be called from inside the Person class, and avoid other developers ruining the LOGs we produce, we'll make the method private :

private void logToConsole(String message) {
    System.out.println("PERSON LOG - " + message);
}

Making this change to the logToConsole method will make calling it from the main method at Starter illegal and will generate an error if we try to Compile. Try it and see for yourself (really, try it) .

Lets now remove the call to logToConsole method from the main method (or comment it out), and give it a compile and run.

public static void main(String[] args) {
    System.out.println("Starting program");

    Person person = new Person("Rui", 35);
    person.setName("Super Rui");

    //person.logToConsole("name modified to: MEGA MEGA RUI");  

    person.printData();
}

What about Constructors?

Constructors are like methods and therefore can have any Access Modifier, even the "private" modifier. You'll see examples of it later on.

What about Method Level Scope Variables?

Method Level Scope Variables don't have an Access Modifier, because they are only accessible from inside the specific method they are created in. Also, it wouldn't make any sense to have them have an Access Modifier because they only exist during the execution of the method they belong to, and after the method execution they stop existing.

Many objects

As an exercise, lets now modify the main method to make it create 2 objects of type Person , using the two different Constructors we have, and then print the data on both the objects using the printData method.

If should look something like this :

public static void main(String[] args) {
    System.out.println("Starting program");

    Person person = new Person("Rui", 35);
    person.setName("Super Rui");

    Person person2 = new Person("Miguel", 90, 500.0);

    person.printData();
    person2.printData();
}

Compile and run it. The result should look like:

Starting program
PERSON LOG - Creating Person with name: Rui age: 35
PERSON LOG - name modified to: Super Rui
PERSON LOG - Creating Person with name: Miguel age: 90 salary: 500.0
Value for name is : Super Rui
Value for age is : 35
Value for salary is : 0.0
Value for name is : Miguel
Value for age is : 90
Value for salary is : 500.0

Wouldn't it be nice to be able to have a list of Person objects stored in someway, instead of having to programmatically define a variable for each of the objects we create? Yes , and we'll look into of doing it in the next tutorial.

Further Reading :

• Primitive Types in details

Lets jump to the next Tutorial : Tutorial 6 - Arrays

Introduction

In the previous tutorials we dabbed into Primitive variables, did a few operations with them, nothing special or exciting.

In this tutorial however, we'll now look at Objects and Reference Variables, and we'll start with understanding the Scope of variables.

Variables Scope

In our previous examples, the ones shown in the previous tutorial, all our variables were defined and used inside a method. What this means is that those variables are only available inside that method, they are created and erased and recreated with each time that method is executed.

Look at the next Class:

public class Scope {

    int classVariable = 1;

    public void methodNumber1() {

        int methodVariable1 = 2 ;

    }

    public void methodNumber2() {

        int methodVariable2 = 3 ;

    }
}

There are a total of 3 variables defined in this Class.

• classVariable: This variable can be accessed from anywhere inside the Class and it can be accessed from inside any of the methods inside that Class. Just as a side note, this is called a variable with Class Level Scope.

• methodVariable1 and methodVariable2 : These variables can be accessed only from inside the methods they are defined in. In fact, they don't exist outside of the execution of their method, and therefore, methodNumber2 cannot access (read, write... print) methodVariable1, because that variable is only defined inside methodNumber1. This is called having Method Level Scope.

The names Class Level Scope and Method Level Scope are not really important to know, but what they imply is. methodVariable1 and methodVariable2 exist only inside their respective methods. They could even have the exact same name, it wouldn't matter, they don't exist outside of the methods.

Code indentation (writing code in an organized way, like we have been doing so far) really helps a lot to understand the scope of variables.

Classes and Objects

To explain the concept of Objects and Classes, we'll implement a very rudimentary system that creates and stores Users and some attributes of each of the Users, and then prints out a listing of this information, formatted in some particular way.

Because we know we will be storing Users, and those users have attributes, we know that the best way to organize this information would be to have a "template" for what a user should have. We'll start with the creation of a User class.

Create a new file called User.java inside an empty folder that will be used for this tutorial, and write the code for the class:

public class User {

}

This Class, as it is, will store absolutely nothing, and it has no methods defined, so in practice it will do nothing.

Lets say that our Users will all have a name and an age:

public class User {

    String name;
    int age;

}

So this class can now be used to store two pieces of data :

• a name, of type String
• an age, of type int

But let us discuss it a bit further.

As we saw in the previous tutorial, and int is a primitive type that uses 32bits. It can be a number that goes as high as 2^31-1, so it is very unlikely (if not biologically impossible) that someone will ever be that age. We could actually use a byte to store the age of the User, it would save memory (if that is a concern) .

We'll choose to continue using an int, for no particular reason.

We also have a variable named name of type String. String is a very particular type, it is not a primitive (it is in a way a collection of chars) but can be declared like a primitive, and also some operators work on it ( like the + operator, when we concatenate Strings). We'll talk about String in a second.

Another difference from what we have been doing so far, is that there is no main method on this class. This means that you cannot execute this class, and therefore the main method must exist in another class, if the project is to be executed.

Without closing the User.java file, create another file, right next to the User.java file, and call it "LessonExecution3.java" . This will be the Class that starts the program, and will make use of the User class. Create the LessonExecution3 class and create a main method in it. It should look like this:

public class LessonExecution3 {

    public static void main(String[] args) {

    }

}

Now, lets create a User and store it, we'll specify the name and the age of the user, and then, we will print that data:

public static void main(String[] args) {
    User user = new User();
    user.name = "Rui";
    user.age = 35;

    System.out.println( "User Name: " + user.name );
    System.out.println( "User Age: " + user.age );
}

Compile and run both files like this:

javac User.java LessonExecution3.java
java  LessonExecution3

The output should be something like:

User Name: Rui
User Age: 35

Lets look at the inside of the main method we have just created inside the LessonExecution3 class.

We start with the statement:

User user = new User();

We know that User is a class, and therefore what we are doing here is creating a variable of that Type, and assigning a newly created Object of that type to the variable:

• User user : creating a variable of type User
• new User() : creating an Object of type User
• User user = new User() : Assigning the object to the variable.

When creating an object, the notation is always new Object , with emphasis on the word new .

So. after we create and assign an Object of type User to the variable named user, we access the variables inside that object using the . (dot) notation:

user.name = "Rui";
user.age = 35;

Notice that when we access the variables inside the newly created object, we use name of the variable of the object, and the name of the variable inside that object. Looking at user.name we can break it down like this:

• user : the name of the variable , not the name of the Class!
• name : the name of the variable inside that particular object!

Remember, we don't do something like User.name because User is the name of the Class, and the Class, like we said before is just a template for objects to be created.

After we access the variables to assign them values, we perform the System.out.println() statements, where we access the variables inside the particular Object and print those values out.

This works, but lets make it better!

Creating Methods

Now, the printing of data of the User object is being done on the main method, which is not very wise if one wants to print the contents of several User objects, because it would mean that there would have to be as many System.out.println as twice the number of User objects created.

A method that prints this same data could be easily created. Lets do it.

Go to the User class source code file, and modify it to look like this :

public class User {

    String name;
    int age;

    public void printData() {
        System.out.println( "User Name: " + name );
        System.out.println( "User Age: " + age );
    }

}

In this updated version of the User class, we have now a method called printData that :

• returns nothing : void
• receives nothing : ()
• performs some System.out.println() statements inside.

Notice that when we do the printing inside this method, we access the variables directly, without using the dot notation. This is because :

• the scope of those variables makes them accessible from that method
• Also, the variable User user does not exist on this class, it is only accessible from the LessonExecution3 class, inside the main method.

Now the main method of LessonExecution3 must be modified to call the method printData instead of having the two System.out.println statements. We do it like this:

public class LessonExecution3 {

    public static void main(String[] args) {
        User user = new User();
        user.name = "Rui";
        user.age = 35;

        user.printData();  // <------------
    }

}

On this new version, the System.out.println statements were removed, and replaced by the user.printData() statement, which has inside some other System.out.println statements. We call the method by using the variable of the object we want to access, and using the dot notation specify the method we want to execute. In this particular case, because printData receives no arguments, we place the ( ) with nothing inside the brackets.

Setter Methods

But we can improve this code a lot still. When we declare the user variable and instantiate it, we then access the variables inside that object to assign values to them. This is actually a bad practice.

Instead of accessing the variables directly, we should be using methods to both set values of these variables and to get the values of these variables.

We'll now implement a method to set the variable name. We call methods that specifically set values for variables Setter Methods, and a modified version of the User class with a setter method for the name variable can be seen next:

public class User {

    String name;
    int age;

    public void printData() {
        System.out.println( "User Name: " + name );
        System.out.println( "User Age: " + age );
    }

    /*
    Setter method for the name variable
    */
    public void setName(String newname) {
        name = newname ;
    }

}

There is now a method with the signature like public void setName(String newname), which means:

• the method receives only one argument, which we call newname
• the method return nothing : void

Then, inside the method, we set the Class Variable name with the value of the received variable newname , like this : name = newname ; . Simple yes?

But having this Setter method does not stop programmers from accessing the variable name directly and modifying it! It is just another way to modify the Class variable.

There is a way to make it impossible for a user to access the variable directly, which the use of Access Modifiers, and we'll see about it on the next Tutorial.

Now lets modify the main method inside LessonExecution3 to use the setter method for name instead of accessing it directly:

public static void main(String[] args) {
    User user = new User();
    user.setName( "Rui" );   //   <-------- Using setter method for name
    user.age = 35;    //  <-------- Accessing age variable directly

    user.printData();
}

Because the setName method requires a String parameter as input, the method is called with the value to be assigned to that parameter inside the () brackets, like this: ( "value" ) .

If, for example, the required parameter was a number, of type int , then calling the method and providing a String as argument would make the program not compile.

Now, do exactly the same thing to the variable age . Create a setter method and modify the main method to call the setter method for age instead of accessing it directly.

The resulting User class should look something like this :

public class User {

    String name;
    int age;

    public void printData() {
        System.out.println( "User Name: " + name );
        System.out.println( "User Age: " + age );
    }

    /*
      Setter method for the name variable
    */
    public void setName(String newname) {
        name = newname ;
    }

    /*
      Setter method for the age variable
    */
    public void setAge(int newage) {
        age = newage ;
    }

}

Notice that we have started putting comments before the methods, explaining what they will be doing.

And then the main method should look like this:

public static void main(String[] args) {
    User user = new User();
    user.setName( "Rui" );
    user.setAge( 35 );

    user.printData();
}

Now that we already made 3 methods, including two that are setter methods, it makes sense to create also the getter methods for those variables!

Getter Methods

Getter methods are just what their name say, they are methods to get values of specific variables.

For example, from looking to our class User to get the values of both name and age variable a programmer would need to access them directly. This is not desired, accessing variables from other classes directly is a bad practice, and therefore we need a way to access the values of those variables.

Accessing variables from other classes directly is a bad practice

To create a getter method for the variable name, we need to write a method whose signature should look like this: public String getName() , which means:

• the method returns one String : String
• the method does not require any parameters ; ( )

Now the question is, how does one make a method return a value? Simple, we use the return keyword :

/*
  Getter method for the Name variable
*/
public String getName() {
    return name;
}

So, if somewhere on our code, from outside of the User class, we would like to get the value of name of a particular object, we can now instead use this getter method. Lets exemplify using our main method inside of LessonExecution3 :

public static void main(String[] args) {
    User user = new User();
    user.setName( "Rui" );
    user.setAge( 35 );

    user.printData();

    // ---- Testing the getter method ----
    String valueFromObject = user.getName();
    System.out.println("Testing getter method : "  + valueFromObject );
}

Modify your classes accordingly, compile and give it a run. The output should look something like :

User Name: Rui
User Age: 35
Testing getter method : Rui

Now, as an exercise implement a getter method for the age variable, that returns an int and test the getter method on the main method, like we did before.

The resulting User class should look like this:

public class User {

    String name;
    int age;

    public void printData() {
        System.out.println( "User Name: " + name );
        System.out.println( "User Age: " + age );
    }

    /*
      Setter method for the name variable
    */
    public void setName(String newname) {
        name = newname ;
    }

    /*
     Getter method for the name variable
    */
    public String getName() {
        return name;
    }

    /*
      Setter method for the age variable
    */
    public void setAge(int newage) {
        age = newage ;
    }

    /*
    Getter method for the age variable
    */
    public int getAge() {
        return age;
    }

}

And the resulting LessonExecution3 class should look like this:

public class LessonExecution3 {

    public static void main(String[] args) {
        User user = new User();
        user.setName( "Rui" );
        user.setAge( 35 );

        user.printData();

        String valueFromObject = user.getName();
        System.out.println("Testing getter name method : "  + valueFromObject );

        int ageFromObject = user.getAge();
        System.out.println("Testing getter age method : "  + ageFromObject );

    }

}

But we can still make it better!

If we look at the previous code, to create a User object with complete information (with name and age) we must do it in 3 different statements!

If we accept that a User must always have a name and age , then this code will not do it, because we are not forcing these to be defined at creation, which means that if someone creates a User object and then forgets to call the setters for name and age, the User object would not have these variables defined.

For this, there is a special kind of method, which is called a Constructor that can only be called at the creation of the object.

Constructor

A Constructor is a method that does not return anything, and has the exact same name as the Class and is called during instantiation of the new Object.

Each class must have at least one Constructor, but if none is provided, one is created automatically, called the default constructor, which takes 0 parameters and does absolutely nothing.

In the previous version of the code, the User class has no constructor, which mean that one is created automatically (behind the scenes), which is equivalent to this :

public class User {

    /*
     The Default Constructor
    */
    public User() {

    }

    String name;
    int age;

    [ ETC ETC ETC ] 
}

And when in the main method we were doing:

User user = new User();

the new User() is actually saying : create a new object of type User, using the "no arguments" Constructor.

As you can see, the constructor :

public User() {

}

• Has no return type defined, because it is a constructor
• Has the same name as the Class

A class can have multiple Constructors, as long as they have different signatures, which in this particular case means that each different Constructor must have different types of parameters that they take as input (or the number of parameters vary). For example, having these constructors all on the same class would be acceptable:

• public User()
• public User(String newname)
• public User(String newname, int age)
• public User(int age, String newname)

Having a class with all these constructors would be illegal:

• public User()
• public User(String firstname)
• public User(String surname)

Because the last two Constructors are identical.

So, recapping, if no Constructor is defined, then one is automatically created, that takes no arguments, and does absolutely nothing. And if one Constructor is specified, then the automatic "no arguments" constructor is not created.

Getting back to our code, because we decided that there would make no sense to have User objects without name and age, we'll create a Constructor that must receive both these parameters, and we delete the "no arguments" Constructor if there is one:

public class User {

    String name;
    int age;

    public User(String newname, int newage) {
        name = newname;
        age = newage;
    }

    [ETC ETC ETC]

}

At this point we have a User class that has only one constructor, and that constructor must take 2 arguments, the newname String and the newage int.

If you tried to compile now you would get an error like this :

LessonExecution3.java:4: error: constructor User in class User cannot be applied to given types;
        User user = new User();
                    ^
  required: String,int
  found: no arguments
  reason: actual and formal argument lists differ in length
  1 error

This happens because we are creating the user object using a constructor that does not exist! Remember, before we had no Constructor defined, and because of that one automatic one was created. Now there is one, and because there is only one, we must use that constructor!

We must now modify the main method to make use of that constructor:

public static void main(String[] args) {
    User user = new User("Rui" , 35);
    user.setName( "Rui" );
    user.setAge( 35 );

    user.printData();

    String valueFromObject = user.getName();
    System.out.println("Testing getter name method : "  + valueFromObject );

    int ageFromObject = user.getAge();
    System.out.println("Testing getter age method : "  + ageFromObject );

}

Notice that now we are creating the object using new User("Rui" , 35); , which tells us that we are using the Constructor that takes one String and one int, in that particular order.

Afterwards we have :

user.setName( "Rui" );
user.setAge( 35 );

This is unnecessary, because the values are already being set in the Constructor. Lets remove that, and we end up with :

public static void main(String[] args) {
    User user = new User("Rui" , 35);

    user.printData();

    String valueFromObject = user.getName();
    System.out.println("Testing getter name method : "  + valueFromObject );

    int ageFromObject = user.getAge();
    System.out.println("Testing getter age method : "  + ageFromObject );

}

Compile everything now and run it, to verify that the values are being set correctly:

User Name: Rui
User Age: 35
Testing getter name method : Rui
Testing getter age method : 35

Exercise

As an exercise, create another constructor on the User class, that takes an int and a String, is this new order and create another object of type User in a variable called user2 , using the new Constructor, and call the printData method on that object!

The code for the User class should end up looking like this:

public class User {

    String name;
    int age;

    public User(String newname, int newage) {
        name = newname;
        age = newage;
    }

    public User(int newage, String newname) {
        name = newname;
        age = newage;
    }

    public void printData() {
        System.out.println( "User Name: " + name );
        System.out.println( "User Age: " + age );
    }

    [ETC ETC ETC]

}

And the code for the LessonExecution3 should look something like this:

public class LessonExecution3 {

    public static void main(String[] args) {
        User user = new User("Rui" , 35);

        user.printData();

        User user2 = new User(99, "Old Man");

        user2.printData();

        String valueFromObject = user.getName();
        System.out.println("Testing getter name method : "  + valueFromObject );

        int ageFromObject = user.getAge();
        System.out.println("Testing getter age method : "  + ageFromObject );

    }

}

At this point you should know how to implement methods and constructors , create new classes , and create instances of those classes (creating new Objects of the class type). All of this speaks to the absolute basic mechanics of Object-Oriented programming.

There are a few more considerations to know about methods, that you might have figured out already, but we'll put it in writing.

What else about Methods?

A method can have both input and output at the same time. Look at this valid method, which is totally unrelated to the code we have been producing:

public int sumTwoNumbers(int number1 , int number2) {
    return number1 + number2 ;
}

This method is completely acceptable, and valid. It receives two ints and returns the sum of those ints .

Variables that are declared inside the method cannot be accessed outside of that method:

public void  testFunction ( ) {
    int specialNumber;   // <--- Declared
    specialNumber = 20 ;  // <--- Assigned

    specialNumber = specialNumber + 10 ; 

    System.out.println("Value now is : "  + specialNumber); // <-- will print 30

    // HERE 
}

In the previous example, each time the method testFunction is executed, a variable is created called specialNumber, and just before the method finishes, this variable stops existing. Remember, those variables only exist inside the method!

Now, if the declaration is outside of the method, in the Class:

int specialNumber;   // <--- Declared

public void  testFunction ( ) {

    specialNumber = 20 ; 
    specialNumber = specialNumber + 10 ; 

    System.out.println("Value now is : "  + specialNumber); // <-- will print 30

}

in this case, the variable specialNumber will exist for each object , and can be accessed from any method on that Class.

And that is it for this tutorial! In the next tutorial we will look into Packages and Access Modifiers, like the keyword public that we have been using.

Lets go, next Tutorial: Tutorial 5 - Packages and Access Modifiers

Introduction

On the previous tutorial we made a really simple program, with just one Class and one Method. There was no data stored, no calculations done, etc.

In this tutorial we will look into storing data and doing something with that data. We'll talk about variables, primitives and Objects, and we'll make a really simple calculator to add 2 numbers! Yes, exciting!

My first Variable

First, we open our favorite text editor and create a new class called Lesson2 with an empty main method. If you have been following the tutorials, try and do it by yourself, or just simply copy the following code onto the editor and save the file as Lesson2.java (remember, java is Case Sensitive).

public class Lesson2 {
    public static void main(String[] args) {

    }
}

You can now compile it and run it. It should give you no errors and print absolutely nothing.

Make the main method now print the "Hello World" phrase, like it was done on the previous tutorial, and we should end up with something like this:

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

Compile and run it again. It should be printing "Hello World"! Remember, every time you modify the Source Code you must compile the code again, and only then will you be able to run it with the new changes.

Lets modify this code now to have a variable and have that code print the value of the variable:

public class Lesson2 {

    public static void main(String[] args) {
        int firstVariable = 5;
        System.out.println("Value is: " + firstVariable);
    }

}

The first change you notice is the int firstVariable = 5; . This is a variable named firstVariable , it is of type int (integer) and has a value of 5.

This is how you declare a variable in Java: You explicitly define the Type of the variable and give it a name. Optionally you can also define a value, like we did there, but this is not mandatory.

The second change is the print that we are now doing: System.out.println("Value is: " + firstVariable); . The program will now print "Value is: " and concatenate the value of the firstValue using the operator +.

Compile and run it. It should have printed : Value is: 5

So, the first variable, which is named firstVariable is of type int (which stands for integer), but what is an int and what other types are there?

Primitive Variables

int is what is called a Primitive type and there are 7 other primitive types. Here is a complete list, with a very simple description of what they are:

• short : a type of whole number, that can go from -32768 to 32767. (it is 16bit signed)
• int : a type of whole number, that can go from -2^31 to (2^31)-1. (it is 32bit signed)
• long : a type of whole number, that can go from -2^63 to (2^63)-1. (it is 64bit signed)
• float : a type of floating point number, therefore can have decimals (it is 32bit single precision)
• double : a type of floating point number, therefore can have decimals (it is 64bit double precision)
• boolean : a type that only allows 2 values : true or false.
• char : a single character (16 bit)
• byte : a type of whole number, that can go from -128 to 127. (it is 8bit signed)

Before you get too nervous about all this jibber jabber, lets start by saying that only about 3 or 4 of these are used really regularly and these are : int, long, double and boolean . That is not to mean that you don't need to know about the other ones, you do, and you will use some of them, but for learning purposes we'll focus on these 4 for now.

What is a Primitive Variable? There are two types of Variables, those that are of a Primitive type (therefore of one of these 8 types) or those that are Reference Variable. We'll see Reference Variables later, lets write some code first!

Lets modify the Lesson2 class and create variables for these types:

public static void main(String[] args) {
    short shortVariable = 1;
    System.out.println("shortVariable is: " + shortVariable);

    int intVariable = 2;
    System.out.println("intVariable is: " + intVariable);

    long longVariable = 3;
    System.out.println("longVariable is: " + longVariable);

    float floatVariable = 4.1f;
    System.out.println("floatVariable is: " + floatVariable);

    double doubleVariable = 5.1;
    System.out.println("doubleVariable is: " + doubleVariable);

    boolean booleanVariable = true;
    System.out.println("booleanVariable is: " + booleanVariable);

    char charVariable = 'x';
    System.out.println("charVariable is: " + charVariable);    

    byte byteVariable = 8;    
    System.out.println("byteVariable is: " + byteVariable);    
}

Now compile and run it. You should be getting an output like:

shortVariable is: 1
intVariable is: 2
longVariable is: 3
floatVariable is: 4.1
doubleVariable is: 5.1
booleanVariable is: true
charVariable is: x
byteVariable is: 8

Notice the notation used to define these variables:

• float floatVariable = 4.1f ;

We placed an "f" after the number. When you define a value of a float typed variable, you must write the letter "f" after the number, to let the compiler know (when you decide to compile the code) that you understand that you are using a small floating-point type, and therefore know that you will not have a lot of precision on that number.

• boolean booleanVariable = true ;

When defining a value for a boolean typed variable, there are only 2 choices: true or false .

• char charVariable = 'x' ;

When defining a value for a char typed variable, the character must be enclosed inside ' and only one character. Char is a bit special, it is 16 bits, exactly the same as the short type... and are interchangeable. We'll get a chance to see it later.

Now that we have a basic knowledge of the primitive variable types, lets do some operations on those.

Some Operator Action and Strings!

Now that we know how to define and assign values to primitive variables, lets modify the code again, and have only two variables of type int defined inside the main method. We'll call them number1 and number2 and will assign them the values 50 and 2. Try doing it yourself!

It should end up looking like this:

public static void main(String[] args) {

    // Variable of type int called number1 and number2
    int number1 = 50;
    int number2 = 2;

}

If you compile and run it now, it should produce no output. Also, notice that now we have a comment on the source code, before the definition of the variables. This is one of the two ways of writing comments, by placing // everything thing written to the right of this will be considered a comment and ignored by the compiler.

Lets now create another variable, named sumOfNumbers, which will contain the sum of number1 and number2, and lets print the result to the console:

public static void main(String[] args) {

    // Variables of type int called number1 and number2
    int number1 = 50;
    int number2 = 2;

    int sumOfNumbers = number1 + number2;

    System.out.println( sumOfNumbers );

}

Compile it and give it a run. It should have printed the result : 52

There are many other operators, like - for subtraction, / for division, * for multiplication, % for modulus. There are also Compound Operators and Equality Operator, which we'll see very soon.

Experiment with those operators to see what happens, create a few more variables with the result of these operators applied to variables number1 and number2 and print those values out. Check the following code:

public static void main(String[] args) {

    // Variables of type int called number1 and number2
    int number1 = 50;
    int number2 = 2;

    int sumOfNumbers = number1 + number2;
    System.out.println( "Sum: " + sumOfNumbers );

    int subtractionOfNumbers = number1 - number2;
    System.out.println( "Subtraction: " + subtractionOfNumbers );

    int divisionOfNumbers = number1 / number2;
    System.out.println( "Division: " +divisionOfNumbers );

    /*
        For the Multiplication, we'll do something different
    */

    int multiplicationOfNumbers;
    multiplicationOfNumbers = number1 * number2;
    System.out.println( "Multiplication: " + multiplicationOfNumbers );

}

Compile and run!

In this piece of code we can see a few new things:

• We have a new type of comment : /* comment */ . This type of comment can span several lines, it begins with /* and ends with */ . Everything in between those is ignored by the compiler

• We create an int typed variable called multiplicationOfNumbers but we do not assign any value to it. Then, on the next statement, we assign the value with the result of the multiplication of number1 and number2.

• We modified every "print" statement, to now print a String (like "Multiplication: ") with the value of specific variables.

Notice that we have been using the + operator since the beginning of the tutorials to concatenate a String ( something inside " ) and values of primitive variables. Keep in mind that the Add operator, when applied to primitives calculates the addition of the values of the two variables. When applied to one or more Strings, it performs concatenation.

On the next Tutorial we'll talk about Constructors and Methods.

When you feel ready: Tutorial 4 - Classes, Constructors and Methods

Introduction

To start this great journey, we'll use the typical "Hello World" program. Yes, it is not very exciting, not very motivational, but before we start running we must learn how to walk.

At this point you should have the JDK installed, and a text editor available. If you have no idea what a JDK is, then you should go and check the previous tutorial: Tutorial 1 - Introduction (The Absolute Basics)

Open your favorite (or available) text editor and lets start!

Hello World

Just for this example, we'll use a normal text editor instead of IntelliJ. This is just to show you how you compile java code. In the next tutorials we'll start making use of IntelliJ Community Edition, which makes it a lot simpler to compile and run your projects. But don't skip this bit, you should really know how to compile and run your code by hand!

Grab the text editor, start a new file and copy this bit of code into it:

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

After you copied this, create an empty folder, which we will be using for this particular tutorial, and save the file with the name Lesson1.java. Java is a case sensitive language, so copy the code exactly the wait it was presented before and save the file with that precise name. We'll get more into that, don't worry.

There should now be a Folder on your system, with just one file named Lesson1.java .

Remember: Java is a case sensitive language

Open a command prompt if you are in windows (type cmd.exe in the "Run" option on the Windows Start Button) , or a Shell if you are in a Unix based system and go to that Folder.

JAVA and JAVAC

To compile the Lesson1 program we are making, which simply prints "Hello World", we must first compile it! To compile we use the Java Compiler (JAVAC).

On the command prompt or shell, inside the folder where the Lesson1.java file exists, type in:

javac

If a sea of text just flashed by, then the JDK is correctly installed and you can proceed to the next step. If on the other hand there was an error message like : javac: command not found , then the JDK is not correctly installed and you should check the previous tutorial before proceeding.

On the command prompt or shell, type in:

javac Lesson1.java

If everything went right, you should now have exactly 2 files inside that folder:

• Lesson1.java - The source code
• Lesson1.class - The Compiled Java Bytecode

Now in that same command prompt or shell, type in:

java Lesson1

It should print out "Hello World"! Congratulations, this is your first program in Java! It doesn't do much, but it is a start! Lets look at the source code and understand what it all means.

Looking at the Code

As it was said in the previous tutorial, Java is a Object Oriented (OO) language, and that means that our program is structured in Objects that may or may not have data inside, and may or may not have code inside.

A Class

When a programmer writes a file like this:

public class Lesson1{

} 

The programmer is in fact creating a Class , which you can think of as a Template for Objects, with the name Lesson1.

Because our "Hello World" program is really small, it only has one Class, but if it was more complex it could have many many many more Classes.

From that code public class Lesson1 , we know that we are creating a Class named Lesson1, and that Class is Public. We'll forget about the Public bit for now, but we'll get back to it once we look at Access Modifiers in the Tutorial 5 - Packages and Access Modifiers .

A Method

Then, inside the Lesson1 class (which is the bit between { and }, we have:

public static void main(String[] args) {

}

This is a Method, and it is called "main". We'll break it down:

• public : like in the class, it will be talked about in the next tutorial
• static : we'll also forget about this for the moment, we'll get back to it in a few tutorials
• void : this means that the method does not return anything.
• main : the name of the method we are creating
• (String[] args) : the arguments the method receives, in this case it is an Array of Strings, called args.

This part of the method public static void main(String[] args) is called the Signature of the method. Obviously all methods will have a signature, where:

• the name of the method is specified,
• the arguments it receives are specified,
• what it returns is specified

This method, named "main", with a signature as described before, is a very important method! It is the method that the JVM (Java Virtual Machine) will grab and execute, and therefore this is where a program starts its execution.

Notice that the class named Lesson1 starts with a capital letter. Now notice that the main method start with a lowercase letter. This was not something random that just happened to be this way, it was on purpose. Although there is no technical reason why this is so, it is a convention, and every Java programmer knows this and will do it this way. We will adhere to it :

Names of classes start with Capital letters

Names of methods start with Lower case letters

Names of variables start with Lower case letters (except for some exceptions well see later)

Inside the method we find:

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

In simple terms it is a Statement that prints a line with "Hello World" to the console (or command prompt, or shell) .

In sightly more complex term (which you don't need to completely understand now, and will be explained later on) we are calling a method called println that exists inside a variable called out , that exists inside a System object. We know this because of the naming conventions, and it will all make a lot more sense really soon.

So, what do we know up to this point?

• A Class is a template for Objects
• A Class name always starts with a Capital Level
• A Method has a signature that defines the input and output
• A Method is named with a starting lowercase letter
• A Class is compiled using the Java Compiler javac
• A Compiled program is run using the Java Virtual Machine: java

Next we'll talk about variables and just a little bit more OO theory. We are about to start the good stuff!

Exercises

To get a bit more practice, consider doing the following exercise:

1. Create a class named Exercise1 that prints "My First Exercise" when it is executed.

Next tutorial: Tutorial 3 - Variables

Introduction

Java is not a difficult language to learn, even if you are a complete beginner. There are a few concept however that we must get out of the way in order to get started.

In this tutorial we will cover the absolute basics of Java and programming in general, so if you already know what Java is, what a development kit is, you have a JDK installed and ready to run, then go ahead and Skip to the next tutorial.

What is Java?

Java is two things: it is both an Object-Oriented Programming language and a Platform.

Object-Oriented Programming (OO) Language .

When writing code, or programming, a programmer writes that code using a specific syntax and grammar that he and other programmers understand called the Programming Language. In the particular case of Java, it is an Object-Oriented programming language, which means that it is based around the notion of Objects that may have data inside and also may contain code instructions (like methods).

Object-Oriented programming is one of several programming paradigms, but there are others, like Functional Programming (like Lisp and Haskell) , Logic Programming (like Prolog), etc. It is simply a set of concepts and rules on how to structure an idea or problem.

So, when we say that Java is an Object Oriented Programming Language, we are just expressing the way that code is structured, and what is the expected behavior of that code. This will be covered more indepth in the next tutorials of this series, while writing some code and getting some hands-on experience.

But Java is also a Platform,

Platform

When someone makes a program in Java, for it to be executable it needs to be compiled. Compiling code is basically translating the human readable source code, which is the writing the programmer does, into a "format" that the computer can make sense of. This is called compiling to Native code, and it has the following particularities:

• Code compiled natively is usually faster, at least at startup
• Code compiled natively is architecture and OS specific (must be compiled independently for each OS : windows, Linux, etc)
• Code compiled natively do require an interpreter.

Java in particular (and some other languages as well) is an interpreted programming language, which means that the Java Source code is compiled into intermediate "format", and then for it is run, the computer must have an interpreter. In Java this is called Compiling to Java bytecode, and has the following particularities:

• Java Bytecode requires an interpreter to be installed ( Java must be installed on the running machine)
• Java Bytecode is not architecture or OS specific. It can run in any arch. or Os that has an interpreter

So, when we talk about Java there is this distinction, it is a programming language, but also a Platform (or runtime environment).

Development Kit

To start programming in Java, the first thing that a programmer needs is the Java Development Kit (also known as JDK) and to run a program made in Java, a user needs the Java Runtime Environment (also known as JRE).

The JDK has the compiler, and all utilities needed to transform Java Source Code into Java Bytecode, and also brings a JRE inside so the developer can run the application he is coding. As a developer you'll only need to install the JDK on your computer.

The JRE has the interpreter, that is called the Java Virtual Machine (or JVM for short). We'll talk more about the particularities of the JVM as we move along.

So, to get the JDK you can go to the Oracle JDK 8 Download Page . We are looking for the Java SE Development Kit 8u73 . Download the version for your platform and follow all the steps to install it.

Once the JDK is installer, you'll need an editor to write the Source Code for the projects you'll be programming.

IDE

Any text editor will do, you can code Java using the Windows Notepad, or linux Vi if you want. But sometimes it is helpful to have an editor that can verify straight away the syntax you are using to program, and warn you of any errors you might have made. It is also useful to have a text editor that writes some boilerplate code that you don't want to be writing all the time, and that allows for the code to be compiled automatically from inside the editor, to save time and for convenience. These are called Integrated Development Environments, or IDEs for short.

There are many many IDEs for Java, like NetBeans, Eclipse, etc etc etc.

For the first tutorials there is no need for a fancy IDE. We could use a simple text editor and everything would be fine.

Some recommended text editors are :

• Textpad for Windows
• Sublime Text for Win, Linux and Mac
• Geany for Linux

But don't get lost in the choice of text editor. It really makes no difference, you can do it with Notepad.

After the first beginner tutorials, the IDE that will be used is IntelliJ Community Edition . Any other can be used, but the examples will be made using IntelliJ. There is a Community Edition of IntelliJ that is free, and that is the one that will be used on the tutorials.

Next Steps

Before the next tutorial you should:

• install the specified JDK.
• install a text editor , an IDE (or decide to use notepad or something for now)

Once you are ready, next tutorial: Tutorial 2 - Hello World