Introduction to Programming

The first program

Modern computer programming takes place almost with no exceptions in an Integrated Development Environment (IDE). This Development Environment includes some functionalities that help the programmer. The Development Environment does not create the program for you, but it can for example give hints of easily spotted errors in program code and helps you to understand the program structure better.

During this course we use an IDE called NetBeans. Check the guide on how to use NetBeans and the exercise robot.

Starting to program in the Development Environment

The guides on how to start programming in NetBeans are in the same place as the previous guide. In the future we will give out more guides on how to use NetBeans. The Development Environment might seem a bit confusing at first, but do not worry! NetBeans is quite easy to use in the end. You will learn the basics in 5 minutes and during this course you will continue to learn more step by step. When this course is finished you have become a true power user of NetBeans!

The program and the source code

The source code

The program consists of the source code. As a rule the computer will run the commands from top to bottom and from left to right. The source code is saved in textual format and will be executed somehow.

The commands

Properly speaking the program consists of the commands that are written in the source code. Computers execute different operations based on the commands. For example when printing a string, which means a text, on the screen the most important command is System.out.println.

System.out.println("Hello world!");

The command System.out.println prints to the screen the string given inside brackets. The ending ln is a shortening of the word line. This command prints out a line, it means that when all the characters have been printed it also prints a line break.

Compiler and interpreter

The computer does not understand the programming language we are using. We need a compiler between the source code and the computer. When we are programming using the command line interface, the command javac Hello.java will compile the Hello.java file into bytecode. That bytecode can be run using the Java interpreter. You can run the compiled program with the command java Hello, Hello being the name of your original source code file.

When we use a development environment, such as NetBeans, it takes care of compiling the source code for us. When we select the “run program” command from the interface, NetBeans compiles and executes the program. All the development environments compile the source code while a programmer writes it, so that the programmer can spot simple errors in the code before the program is executed.

How the commands are formed

Semicolon

A semicolon ; is used to separate different commands. Actually the compiler and the interpreter pay no attention to the lines in the source code, so that in theory we can write the whole program as a single line.

In the example below we will use the command System.out.print. It works like the command System.out.println, except that it will not print a line break after text.

Example of how the semicolons are used

System.out.print("Hello "); System.out.print("world");
System.out.print("!");

Hello world!

Even though neither the compiler nor the interpretor need line breaks in the source code, it is highly important to use them and divide the source code into chapters considering other people who will read the source code in the future. This course has a special emphasis on different code-writing style rules that help the readers to understand the source code.

The information that is passed to commands (parameters)

Some of the commands can behave differently depending on what information is passed to them. We can pass information to commands by using parameters. They are passed to the command by adding them inside the brackets () that follow the command name. For example, to the command System.out.print is given a text hello as a parameter like this: System.out.print("hello").

Comments

Writing comments inside the source code is a handy way to make notes for yourself and others. A comment is actually any line in the source code that begins with a double slash //. Everything written after the double slash on the same line will be interpreted as a comment.

Example of using comments

// Next we print the text "Hello world"
System.out.print("Hello world");

System.out.print(" and all the people of the world."); // We add more text to the same line.

// System.out.print("this line will not be executed, because it is commented out.");

In the example the last line introduces an especially handy usage for comments. If you want to try removing something, you do not need to really delete the line, you can just comment it out.

3.5 More about printing

As we can tell from the examples above, there are two commands for printing.

• System.out.print prints the text without the line break at the end
• System.out.println prints the text and the line break

The printed text can contain both traditional characters and special characters. The most important special character is \n, which makes a line break. There are also other special characters.

System.out.println("First\nSecond\nThird");

When executed, the example above prints :

First
Second
Third

Main program body

The body of the program named “Example” is the following.

public class Example {
  public static void main(String[] args) {
    // program code
  }
}

The program is written in a text file having the same name as the program and the ending .java. The program named “Example” has to be located in a file named Example.java.

The right place in the program body to write commands in is marked above with // program code. During the first week we use only that area in the program body. When we want the program to execute commands like printing, we need to write those commands into the program body. For example: System.out.print("Text to be printed");

public class Example {
  public static void main(String[] args) {
    System.out.print("Text to be printed");
  }
}

From now on the main program body will be omitted from the examples.

Jane Doe

Hello world!

(And all the people of the world)

    
    *
   ***
  *****
 *******
*********
    *

Variables and assignment

Variables and data types

A variable is one of the most important concepts in computer programming. A variable should be imagined as a box, into which you can store information. The information stored in a variable always has a data type. Those data types include, for example, text (String), whole numbers (int), decimal numbers (double) and truth value (boolean). A value can be assigned to a variable using the equals sign (=).

int months = 12;

In the example above we have an assignment sentence, in which we assign the value 12 to the variable named months, that is of data type whole number (int). The sentence can be read aloud as “the variable months is assigned the value 12”.

The value of the variable can be added to a string with the plus + sign as we learn in the next example.

String text = "includes text";
int wholeNumber = 123;
double decimalNumber = 3.141592653;
boolean isTrue = true;

System.out.println("The variable's type is text. Its value is " + text);
System.out.println("The variable's type is whole number. Its value is  " + wholeNumber);
System.out.println("The variable's type is decimal number. Its value is " + decimalNumber);
System.out.println("The variable's type is truth value. Its value is " + isTrue);

Printing:

The variable's type is text. Its value is includes text
The variable's type is whole number. Its value is 123
The variable's type is decimal number. Its value is 3.141592653
The variable's type is truth value. Its value is true

The variable holds its value until it is assigned a new one. Note that the variable type is written only when the variable is first introduced in the program. After that we can use the variable with its name.

int wholeNumber = 123;
System.out.println("The variable's type is whole number. Its value is  " + wholeNumber);

wholeNumber = 42;
System.out.println("The variable's type is whole number. Its value is  " + wholeNumber);

What is printed:

The variable's type is whole number. Its value is 123
The variable's type is whole number. Its value is 42

A variable's data type holds

When a variable has once been given a data type, it will never change. For example a text variable can not turn into an integer variable, and integer values cannot be assigned to that variable.

String text = "yabbadabbadoo!";
text = 42; // Does not work! :(

We can assign decimal number variables values that are whole numbers, because whole numbers are also decimal numbers.

double decimalNumber = 0.42;
decimalNumber = 1; // Does work! :)

Chickens:
3
Bacon (kg):
5.5
A tractor:
There is none!

In a nutshell:
3
5.5
There is none!

Chickens:
9000
Bacon (kg):
0.1
A tractor:
Zetor

In a nutshell:
9000
0.1
Zetor

Allowed and descriptive variable name

There are certain regulations on how we are allowed to name our variables. Even though using umlauts is allowed, it is better not to use those, because problems might arise with character encoding. Instead it is advised to change A characters with dots into regular A characters and so on.

Variable names are not allowed to include certain special characters like an exclamation mark (!). A space character is also not allowed, because it separates the command into multiple parts. It is a good idea to replace the space character using a camelCase writing style. The name camelCase comes from the word's visual form that rises in the middle like a camel's back. Notice! Variable names are always written with a lowercase first letter:

int camelCaseVariable = 7;

Variable names can contain numbers, as long as the name does not start with one. Variable names need to have at least one alphabetic letter, which means that the name cannot contain only numbers.

int 7variable = 4; // Not allowed!
int variable7 = 4; // A valid, but not descriptive variable name

Variable names need to be unique in the program. It means that we can use a name only once. We are also not allowed to use command names like System.out.print as our variable names.

int camelCase = 2;
int camelCase = 5; // Not allowed, the variable camelCase is already defined!

It is strongly recommended that a variable is named by its usage. It helps people to understand why and when the variable is used without having to find out what the variable does by reading comments or thinking hard. On this course the variable names have to be descriptive.

Good variable names

• lastDay = 20
• firstYear = 1952
• name = "Matti"

Bad or disallowed variable names

• last day of the month = 20
• 1day = 1952
• lookout! = 1910
• 1920 = 1

Calculation

The calculation operations are pretty straightforward: +, -, * and /. A more special operation is %, which is used to calculate the remainder of a division and is called modulo. The order of operations is also pretty straightforward: the operations are calculated from left to right taking the brackets into account.

int first = 2; // variable of whole number type is assigned the value 2
int second = 4; // variable of whole number type is assigned the value 4
int sum = first + second;  // variable of whole number type is assigned the value of first + second (that means 2 + 4)

System.out.println(sum); // the value of the variable sum is printed

int calcWithBrackets = (1 + 1) + 3 * (2 + 5);   // 23
int calcWithoutBrackets = 1 + 1 + 3 * 2 + 5;       // 13

The bracket example above can also be done step by step.

int calcWithBrackets = (1 + 1);
calcWithBrackets = calcWithBrackets + 3 * (2 + 5)   // 32

int calcWithoutBrackets = 1 + 1;
calcWithoutBrackets = calcWithoutBrackets + 3 * 2;
calcWithoutBrackets = calcWithoutBrackets + 5;    	// 13

Calculation operations can be executed almost anywhere in the program code.

int first = 2;
int second = 4;

System.out.println(first+second);
System.out.println(2 + second - first - second);

Floating point numbers alias decimal numbers

Division of whole numbers is a bit more tricky, as is the remainder in this context. A floating point number (decimal number) and integer (whole number) often get mixed up. If all the variables in a calculation operation are integers, the end result will also be an integer.

int result = 3 / 2;      // result is 1 (integer), because 3 and 2 are integers as well

int first = 3:
int second = 2;
double result = first / second;      // the result is again 1, because first and second are integers

The remainder is discovered using the remainder operation (% alias modulo). For example, the remainder of calculation 7 % 2 is 1.

int remainder = 7 % 2; // remainder is 1 (integer)

If either the dividend or the divider (or both!) is a floating point number (decimal number) the end result will also be a floating point number.

double whenDividentIsFloat = 3.0 / 2; //result will be: 1.5
double whenDividerIsFloat = 3 / 2.0;    //result will be: 1.5

It is possible to turn an integer into a floating point number if needed. It is done by adding a type exchange operation (double) in front of it:

int first = 3;
int second = 2;
double result1 = (double)first / second;  //result will be: 1.5

double result2 = first / (double)second;  //result will be: 1.5

double result3 = (double)(first / second);  //result will be: 1

In the last example calculation, the result is rounded incorrectly, because the calculation between the integers (first / second) is done before their types are exchanged from integers to floating point numbers.

If the quotient is assigned as a value to a variable of integer type, then the result will be an integer as well.

int quotientIntegerBecauseTypeIsInteger = 3.0 / 2; // quotient is automatically integer: 1

The next example will print “1.5”, because the dividend is transformed into a floating point number by multiplying it with a floating point number (1.0 * 3 = 3.0) before the division.

int dividend = 3;
int divider = 2;

double quotient = 1.0 * dividend / divider;
System.out.println(quotient); 

What does the following code print?

int dividend = 3;
int divider = 2;

double quotient = dividend / divider * 1.0;
System.out.println(quotinent);

There are X seconds in a year.

Concatenation or combining strings

Let us take a closer look on putting strings together with a + operator.

If the + operator is used between two strings, a new string is created. The new string includes the previous two strings combined. Notice the clever use of a space character as a part of the "variables"!

String greeting = "Hi ";
String name = "John";
String goodbye = ", and goodbye!";

String sentence = greeting + name + goodbye;

System.out.println(sentence);

Hi John, and goodbye!

If the + operator is used to combine a string and, for example, an integer, a new string is created as well. In that string the integer, let us say 2, is transformed into string (text) "2" and then combined with the original string.

System.out.println("there is an integer --> " + 2);
System.out.println( 2 + " <-- there is an integer");

What we learned earlier about the order of operations is still valid:

System.out.println("Four: " + (2+2));
System.out.println("But! Twentytwo: " + 2 + 2);

Four: 4
But! Twentytwo: 22

With this information we now possess, we can print out both text and values of variables:

int x = 10;

System.out.println("variable x has the following value: " + x);

int y = 5;
int z = 6;

System.out.println("y has the value of  " + y + " and z has the value of " + z);

This program obviously prints:

variable x has the following value: 10
y has the value of 5 and z has the value of 6

5 + 4 = 9

73457 + 12888 = 86345

2 * 8 = 16

277 * 111 = 30747

Reading user input

So far our programs have been very one-sided. Next we will learn how to read input from the user. We will use a special Scanner tool to read the user input.

Let us add the Scanner to our existing main program body. Do not worry if the main program body seems mind-bending, we will continue to program the same way we did before. The code is added to the main program body and the place for your code is marked with the comment // program code.

import java.util.Scanner;

public class ProgramBody {
  
  public static void main(String[] args) {
    Scanner reader = new Scanner(System.in);

    // program code
  }
}

Reading a string

The following code reads the user's name from the keyboard and prints a greeting:

System.out.print("What is your name? ");
String name = reader.nextLine(); // Reads a line from the user's keyboard and assigns it as a value to the variable called name

System.out.println("Hi, " + name);

What is your name? John
Hi, John

(In the following example we have the program described above with the main program body included. The name of the program is Greeting. Because its name is Greeting, it has to be located in a file called Greeting.java. --When using NetBeans you can start following the original guide, but make sure to change the program name from Hello (Hello) to Greeting (Greeting).

import java.util.Scanner;

public class Greeting {

  public static void main(String[] args) {
    Scanner reader = new Scanner(System.in);

    System.out.print("Who is greeted: ");
    String nimi = reader.nextLine(); // Reads a line from the users keyboard and assigns it as a value to the variable called name

    System.out.print("Hi " + name);
  }
}

When the program above is executed, you can type the input. The output tab in NetBeans looks like this (below) when the program has finished.

run:
Who is greeted: John
Hi John
BUILD SUCCESSFUL (total time: 6 seconds)

Reading integers

Our Scanner tool is not good for reading integers, so we will use another special tool for transforming a string to an integer. Command Integer.parseInt takes as a parameter a String-type variable that contains the number the user has given and transforms it into a variable of integer type. The parameter (that means the name of the string variable) is given to the command in brackets and the command returns an integer, which will be assigned in a variable of integer type.

In practice we will join two commands together. First we read the input as a string from the user and immediately give it to the command Integer.parseInt.

System.out.print("Type an integer: ");
int number = Integer.parseInt(reader.nextLine());

System.out.println("You typed " + number);

Next we will ask the user to give us his name and age. This time the example contains the program body.

import java.util.Scanner;

public class NameAndAgeGreeting {
  public static void main(String[] args) {
    Scanner reader = new Scanner(System.in);

    System.out.print("Your name: ");
    String name = reader.nextLine();   // Reads a line from the users keyboard

    System.out.print("How old are you: ");
    int age = Integer.parseInt(reader.nextLine()); // Reads a string variable from the users keyboard and transfers it to an integer

    System.out.println("Your name is: " + name + ", and you are " + age + " years old, nice to meet you!");
  }
}

Summary

Next follows the main program body of a program that interacts with the user:

import java.util.Scanner;
public class ProgramName {
  public static void main(String[] args) {
    Scanner reader = new Scanner(System.in);

    // code to be written here
  }
}

Reading a string:

String text = reader.nextLine();

Reading an integer:

int number = Integer.parseInt(reader.nextLine());

Type a number: 6
Type another number: 2

Sum of the numbers: 8

Type a number: 3
Type another number: 2

Division: 3 / 2 = 1.5

Type the Radius: 20

Circumference of the circle: 125.66370614359172

Type a number: 20
Type another number: 14

The bigger number of the two numbers given was: 20

Type your name: Matti
Type your age: 14

Type your name: Arto
Type your age: 12

Matti and Arto are 26 years old in total.

import java.util.Scanner;
import nhlstats.NHLStatistics;

public class Mainprogram {
    public static void main(String[] args) throws Exception {
        Scanner reader = new Scanner(System.in);

        System.out.println("Top ten by points");
        NHLStatistics.sortByPoints();
        NHLStatistics.top(10);
    }
}

Top ten by points
Henrik Sedin           VAN        43 11 + 38= 49  36
Phil Kessel            TOR        41 24 + 24= 48  10
Claude Giroux          PHI        36 18 + 30= 48  16
Joffrey Lupul          TOR        41 19 + 28= 47  36
Daniel Sedin           VAN        42 18 + 29= 47  32
Steven Stamkos         TBL        40 28 + 17= 45  34
Marian Hossa           CHI        41 17 + 27= 44  14
Evgeni Malkin          PIT        33 16 + 28= 44  30
Jordan Eberle          EDM        41 17 + 26= 43   6
Jason Pominville       BUF        41 14 + 29= 43   8

NHLStatistics.sortByPoints();     // orders the players by points
NHLStatistics.sortByGoals();      // orders the players by goals
NHLStatistics.sortByAssists();    // orders the players by assists
NHLStatistics.sortByPenalties();  // orders the players by penalty minutes

NHLStatistics.searchByPlayer("Jaromir Jagr");   // prints the statistics of Jaromir Jagr
NHLStatistics.searchByPlayer("Koivu");          // prints the statistics of Mikko and Saku Koivu
NHLStatistics.searchByPlayer("Teemu");          // prints the statistics of all players named Teemu

NHLStatistics.teamStatistics("NYR");            // Statistics of New York Rangers

Selection and truth values

A selection command is needed in order to branch the program execution.

int number = 11;

if ( number > 10 ) {
  System.out.println("The number was greater than 10");
}

The condition ( number > 10 ) transforms into a truth value, so it is either true or false. The selection command if handles only truth values in the end. The condition sentence above will be read "if the number is greater than 10".

Note that after the if sentence there will be no semicolon, since the sentence continues after the condition part.

After the condition an opening brace { starts a new block. The block will be executed if the condition is true. The block ends with a closing brace }. The block can be as long as you wish.

Comparison operators are the following:

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

int number = 55;

if ( number != 0 ) {
  System.out.println("The number does not equal 0");
}

if ( number >= 1000 ) {
   System.out.println("The number was greater than or equal to 1000");  
}

A block can contain any code, such as another selection command.

int x = 45;
int number = 55;

if ( number > 0 ) {
   System.out.println("The number is positive!");
   if ( number > x ) {
     System.out.println(" and greater than the number stored in variable x"); 
     System.out.println(“ the number stored in variable x is " + x);
   }
}

The comparison operators can also be used outside the conditions. In that case the truth value will be stored in a truth value variable.

int first = 1;
int second = 3;

boolean isGreater = first > second;

In the example above the boolean (i.e. a truth value) variable isGreater now includes the truth value false.

A boolean variable can be used as a condition in a conditional sentence.

int first = 1;
int second = 3;

boolean isLesser = first < second;

if ( isLesser ) {
  System.out.println("1 is less than 3!");
}

1 is less than 3!

Code indentation

You should note that the commands in the block following the if-command (i.e. the lines that come after the { brace) should not be written at the same level as the if-command. They should be "more right", meaning that the lines will be indented. Indentation happens when you press the tabulator key, which is located to the left of q key. When the block ends with the closing brace, indentation ends as well. The closing brace } should be on the same level as the original if-command.

Using indentation is a crucial thing concerning the understandability of the computer programs. During this course and everywhere in "real life" it is required to indent the code with propriety. NetBeans helps with the correct indentation. You can easily indent your program by pressing shift, alt and f simultaneously.

else

If the truth value of the comparison is false, another alternative block can be executed in that case. To achieve that we can use the command else.

int number = 4;

if ( number > 5 ) {
  System.out.println("Your number is greater than five!");
} else {
  System.out.println("Your number is equal to or less than five!");
}

Your number is equal to or less than five!

Type a number: 5

The Number is positive.

Type a number: -2

The number is not positive.

How old are you? 12

You have not reached the age of consent yet!

How old are you? 32

You have reached the age of consent!

Type a number: 2
Number 2 is even.

Type a number: 7
Number 7 is odd.

else if

If there are over two options for the program to select, it is recommended to use the else if command. It works like the else command, but with an additional condition. Else if comes after the if command. There can be multiple else if commands.

int number = 3;

if ( number == 1 ) {
  System.out.println("The number is one.");
} else if ( number == 2 ) {
  System.out.println("The number is two.");
} else if ( number == 3 ) {
  System.out.println("The number is three!");
} else {
  System.out.println("The number is many!");
}

The number is three!

Let us read the upper example out loud. 'If number is one, print out "The number is one." otherwise if the number is two, print out "The number is two." Otherwise if the number is three, print out "The number is three!" and otherwise print out "The number is many!"

Comparing Strings

Strings alias texts cannot be compared with the equals (==) operator. There is another command for comparing strings and it is called equals. That command is always associated with the compared string.

String text = "course";

if ( text.equals("marzipan") ) {
  System.out.println("The variable text contains the text marzipan");
} else {
  System.out.println("The variable text does not contain the text marzipan");
}

The command equals is always used with the comparable string variable, "string variable dot equals text". A string variable can also be compared with another string variable.

String text = "course";
String anotherText = "horse";

if ( text.equals(anotherText) ) {
  System.out.println("The texts are the same!");
} else {
  System.out.println("The texts are not the same!");
}

When comparing strings it is crucial to check that both string variables have a value stored in them. If the variable holds no value, the program execution will end in a NullPointerException error. That means the variable has no value or it is empty (null).

Type the first number: 5
Type the second number: 3

Greater number: 5

Type the first number: 5
Type the second number: 8

Greater number: 8

Type the first number: 5
Type the second number: 5

The numbers are equal!

Type the points [0-60]: 37

Grade: 2

Type the points [0-60]: 51

Grade: 5

Logical operations

The selection clause can also be more complicated, made with logical operations. Logical operations are:

• &&conditional and (AND)
  • Both need to be true: (true1) && (true2)
• ||conditional or (OR)
  • Another or both need to be true: (true) || (false) or (true) || (true)
• !negation (not)
  • Flips the truth value: !(false)

int year = 2012;
int month = 1;

System.out.println("Courses that begin now:");

if ( year == 2012 && month == 1 ) {
  System.out.println("Introduction to Programming");
}

if ( year == 2012 && month == 3 ) {
  System.out.println("Advanced Course in Programming");
}

Courses that begin now:
Introduction to Programming

System.out.println("Is the number between 5-10: ");
int number = 7;

if ( number > 4 && number < 11 ) {
  System.out.println("YES! :)");
} else {
  System.out.println("No it was not :(")
}

Is the number between 5-10: 
YES! :)

System.out.println("Is the number either 1, 50 or 100: ");
int selection = 50;

if ( selection == 1 || selection == 50 || selection == 100 ) {
  System.out.println("Yes! :)");
} else {
  System.out.println("No it was not :(")
}

Is the number either 1, 50 or 100: 
Yes! :)

How old are you? 10
OK

How old are you? 55
OK

How old are you? -3
Impossible!

How old are you? 150
Impossible!

Type your username: alex
Type your password: mightyducks
You are now logged into the system!

Type your username: emily
Type your password: cat
You are now logged into the system!

Type your username: emily
Type your password: dog
Your username or password was invalid!

Type a year: 2011
The year is not a leap year.

Type a year: 2012
The year is a leap year.

Type a year: 1800
The year is not a leap year.

Type a year: 2000
The year is a leap year.

Introduction to repetition

A selection clause helps us make programs that act on different conditions, i.e. if the username and password match, for example the program lets the user log in and otherwise it does not.

In addition to conditions we also need repetitions, we need the program to keep asking the user to input a username and password until a matching pair is given.

The most simple repetition is eternal repetition. The following program will print out the string I know how to program! eternally or "an infinite number of times":

  while ( true ) {
    System.out.println("I know how to program!");
  }

In the above example the command while( true ) makes the whole command block (i.e. the code inside these braces {}) to be repeated infinitely.

Infinite repetition is not usually the behavior we want from a program. A repetition can be interrupted using the command break for example.

  while ( true ) {
    System.out.println("I know how to program!");

    System.out.print("Continue? (no quits)? ");
    String command = reader.nextLine();
    if ( command.equals("no") ) {
      break;
    }
  }
  System.out.println("Thank you and see you again!");

Now the repetition goes forward like this: first the program prints I know how to program! and after that the program will ask the user if it should continue. If the user answers no, the command break is executed and it stops the repetition. Now the printing command is executed and it prints Thank you and see you again!

I know how to program!
Continue? (no quits)?yeah
I know how to program!
Continue? (no quits)? jawohl
I know how to program!
Continue? (no quits)? no
Thank you and see you again!

Many different things can be done inside a repetition. Next we introduce a simple calculator. The calculator calculates based on commands that the user enters. If the command is quit, a break command will be executed and the repetition ends. After that the program asks the user to type two numbers. If the command was sum the program calculates the sum of the two numbers and prints it. If the command was difference, the program calculates the difference of the two numbers and prints it. If the command entered is something else, the program says that it does not recognize the command.

  System.out.println("welcome to the calculator");

  while ( true ) {    
    System.out.print("enter a command (sum, difference, quit): ");
    String command = reader.nextLine();
    if ( command.equals("quit") ) {
      break;
    }

    System.out.print("enter the numbers");
    int first = Integer.parseInt(reader.nextLine());
    int second = Integer.parseInt(reader.nextLine());

    if ( command.equals("sum") ) {     
      int sum = first+second;
      System.out.println( "The sum of the numbers " + sum );
    } else if ( command.equals("difference") ) {     
      int difference = first-second;
      System.out.println( "The difference of the numbers " + erotus );
    } else {     
      System.out.println( "Unknown command" );
    } 

  }
  System.out.println("thanks bye!");

Type the password: turnip
Wrong!
Type the password: rutabaga
Wrong!
Type the password: carrot
Right!

The secret is: jryy qbar!

Type the password: turnip
Wrong!

Type the password: carrot
Right!

Type the password: sweet potato
Wrong!

Type the password: turnip
Wrong!
Type the password: rutabaga
Wrong!
Type the password: carrot
Right!

Type the password: turnip
Wrong!
Type the password: rutabaga
Wrong!
Type the password: carrot
Right!

The secret is: jryy qbar!

Graph.addNumber(13.0);

    public static void main(String[] args) throws Exception {
        Scanner reader = new Scanner(System.in);

        System.out.println("NHL statistics service");
        while ( true ) {
            System.out.println("");
            System.out.print("command (points, goals, assists, penalties, player, club, quit): ");
            String command = reader.nextLine();
            
            if ( command.equals("quit")) {
                break;
            }
           
            if ( command.equals("points")) {
                // print the top ten playes sorted by points
            } else if ( command.equals("goals")) {
                // print the top ten players sorted by goals
            } else if ( command.equals("assists")) {
                //  print the top ten players sorted by assists
            } else if ( command.equals("penalties")) {
                //  print the top ten players sorted by penalties
            } else if ( command.equals("player")) {
                // ask the user first which player's statistics are needed and then print them
            } else if ( command.equals("club")) {
               // ask the user first which club's statistics are needed and then print them
               // note: when printing statistics they should be ordered by points (so that the players with the most points come in first)
            }
        }
    }

NHL statistics service

command (points, goals, assists, penalties, player, club): assists
Henrik Sedin           VAN        43 11 + 38= 49  36
Erik Karlsson          OTT        43  6 + 35= 41  24
Claude Giroux          PHI        36 18 + 30= 48  16
Pavel Datsyuk          DET        41 13 + 30= 43  10
Brian Campbell         FLA        42  3 + 30= 33   4
Daniel Sedin           VAN        42 18 + 29= 47  32
Jason Pominville       BUF        41 14 + 29= 43   8
Nicklas Backstrom      WSH        38 13 + 29= 42  22
Joffrey Lupul          TOR        41 19 + 28= 47  36
Evgeni Malkin          PIT        33 16 + 28= 44  30

command (points, goals, assists, penalties, player, club): player
which player: Jokinen
Olli Jokinen           CGY        43 12 + 21= 33  32
Jussi Jokinen          CAR        40  4 + 19= 23  30

command (points, goals, assists, penalties, player, club): club
which club: DET
Pavel Datsyuk          DET        41 13 + 30= 43  10
Johan Franzen          DET        41 16 + 20= 36  34
Valtteri Filppula      DET        40 14 + 21= 35  10
Henrik Zetterberg      DET        41  8 + 24= 32  14
// and more players

command (points, goals, assists, penalties, player, club): quit

Changing variables

Usually when we have an existing variable we want to change its value. This can be achieved using a basic assignment clause. In the next example we raise the value of the variable age by one:

int age = 1;

System.out.println( age );    // prints 1
age = age + 1;                // the new value of age is the old value of age + 1    
System.out.println( age );    // prints 2

The command age = age + 1 increments the value of the variable age by one. It is also possible to increment a variable by one this way:

int age = 1;

System.out.println( age );    // prints 1
age++;                        // means the same as age = age + 1
System.out.println( age );    // prints 2

Another example:

int length = 100;

System.out.println( length );   // prints 100
length = length - 50;    
System.out.println( length );   // prints 50
length = length * 2;
System.out.println( length );   // prints 100 
length = length / 4;
System.out.println( length );   // prints 25
length--;                       // means the same as length = length-1;
System.out.println( length );   // prints 24

Scanner reader = new Scanner(System.in);
int sum = 0;
int read;

// WRITE YOUR PROGRAM HERE
// USE ONLY 3 VARIABLES, sum, reader AND read!


System.out.println("Sum: "+sum);

Type the first number: 3
Type the second number: 6
Type the third number: 12

Sum: 21

Scanner reader = new Scanner(System.in);
int sum = 0;
while (true) {
    int read = Integer.parseInt(reader.nextLine());
    if (read == 0) {
        break;
    }

    // DO SOMETHING HERE

    System.out.println("Sum now: "+sum);
}
System.out.println("Sum in the end: "+sum);

3
Sum now: 3
2
Sum now: 5
1
Sum now: 6
1
Sum now: 7
0
Sum in the end: 7

More repetition

We have previously learned to create a repeating program with the while(true) command. Programs we have made have been repeating certain commands until they reach a break command.

A break command is not the only way to end repetition. A common structure for a repetition command is while (condition), where the condition can be any truth clause. That means the condition can be exactly like conditions for an if command.

In the following example our program prints the numbers 1, 2, …, 10. When the value of the variable number grows to be over 10, the condition of the while structure becomes false and executing the block ends.

int number = 1;

while (number < 11) {
  System.out.println(number);
  number++;    // number++ means the same as number = number + 1
}

Read the above example "as long as the variable number is less than 11, print the variable and increment it by one".

In the code above the variable number was incremented each time the block was executed. The change can be anything, meaning that the variable used in the boolean condition does not always need to be incremented, as we can see in the following example:

int number = 1024;

while (number >= 1) {
  System.out.println(number);
  number = number / 2;
}

1
2
3
(many rows of numbers here)
98
99
100

100
99
98
(many rows of numbers here)
3
2
1

2
4
6
(many rows of numbers here)
96
98
100

Up to what number? 3
1
2
3

Up to what number? 5
1
2
3
4
5

First: 5
Last: 8
5
6
7
8

First: 16
Last: 12

Assignment operations

Because changing the value of a variable is a very common operation, there are certain assignment operations for that in Java.

int length = 100;

lenght += 10;  // same as length = length + 10;
length -= 50;  // same as length = length - 50;

When the assignment operation is done to an existing variable, it is written as variable type of change = change, for example variable += 5. Note that you must always tell the type of the variable before you can assign any value to it. This means that when we want a new variable into use we must first introduce it. Introducing a variable is done by specifying the variable type and the name of the variable.

The following example will not work, because the type of the variable length has not been specified.

length = length + 100;   // not working!
length += 100;           // not working!

When the type is specified, the calculations start working correctly.

int length = 0;
length = length + 100;
length += 100;

// length now holds the value 200

There are also other assignment operations:

int length = 100;

length *= 10; // same as length = 10 * length; 
length /= 100; //same as length = length / 100;
length %= 3;  // same as length = length % 3;

// the variable length now holds the value 1

Many programs contain a repetition, during which the program calculates a value for the variable, so that the value depends on the repetition. The following program calculates 4*3 in a somewhat clumsy way as a sum of 3+3+3+3:

int result = 0;

int i = 0;
while ( i < 4 ) {
   result = result + 3;
   i++;   // means the same as i = i+1;
}

In the beginning result = 0. During the repetition the value of the variable is incremented by 3. And because there are 4 repetitions, the value of the variable is 3*4 in the end.

Using the assignment operator introduced before, we can achieve the same behavior also like this:

int result = 0;

int i = 0;
while ( i < 4 ) {
   result += 3;      // this is the same as result = result + 3;
   i++;             // means the same as i = i+1;
}

Until what? 3
Sum is 6   // calculated 1+2+3

Until what? 7
Sum is 28   // calculated 1+2+3+4+5+6+7

First: 3
Last: 5
The sum 12

First: 2
Last: 8
The sum is 35

Type a number: 3
Factorial is 6

Type a number: 10
Factorial is 3628800

Type a number: 3
The result is 15

Type a number: 7
The result is 255

Eternal loop

One of the classic errors in programming is to accidentally create an eternal loop. In the next example we try to print "Never again shall I program an eternal loop!" 10 times:

int i = 0;

while( i<10 ) {
  System.out.println("Never again shall I program an eternal loop!");
}

The variable i that controls how many times the block is executed starts with the value 0 and the block should be executed until i<10. But something funny happens here. Because the variable i never gets a new value after it is introduced, it will never grow and thus the boolean condition stays true forever.

while and ending

We have now made several repetition exercises, where the repetition condition looks roughly like this:

int i = 1;
while ( i < 10 ) {
  // ...
  i++;
}

In the program body above the variable i remembers how many times the while block has been executed and ending the repetition is based on checking what the value of i is.

Let us remember for a while how the repetition is stopped. The decision on ending the repetition of a code block does not need to be based on how many times the block has been executed. Next follows an example where the program asks for the user's age. If the age is not between 5 and 85 years, program prints a warning and asks for the age again. The condition for executing the while structure can be anything that produces a boolean (truth value).

System.out.println("Type your age: ");

int age = Integer.parseInt(reader.nextLine());

while( age < 5 || age  > 85 ) {   // age less than 5 OR greater than 85
  System.out.println("You are lying!");
  if ( age < 5 ) {
      System.out.println("You are so young that you cannot know how to write!");   
  } else if ( age > 85 ) {
      System.out.println("You are so old that you cannot know how to use a computer!");   
  } 

  System.out.println("Type your age again: ");
  age = Integer.parseInt(reader.nextLine();
}

System.out.println("Your age is "+ age);

The program with the same functionality could have also been done using the old faithful while(true) structure:

System.out.println("Type your age ");

while( true ) {   
  int age = Integer.parseInt(reader.nextLine());

  if ( age >= 5 && age <= 85 ) {   // age between 5 AND 85
    break;                              // ending the repetition
  }

  System.out.println("You are lying!");
  if ( age < 5 ) {
      System.out.println("You are so young that you cannot know how to write!");   
  } else {  // that means age is over 85
      System.out.println("You are so old that you cannot know how to use a computer!");   
  } 

  System.out.println("Type your age again: ");
}

System.out.println("Your age is "+ age);

Type numbers:
5
2
4
-1
Thank you and see you later!

Type numbers:
5
2
4
-1
Thank you and see you later!
The sum is 11

Type numbers:
5
2
4
-1
Thank you and see you later!
The sum is 11
How many numbers: 3

Type numbers:
5
2
4
-1
Thank you and see you later!
The sum is 11
How many numbers: 3
Average: 3.666666666666

Type numbers:
5
2
4
-1
Thank you and see you later!
The sum is 11
How many numbers: 3
Average: 3.666666666666
Even numbers: 2
Odd numbers: 1

Methods

We have now used many different commands in Java, including assignment, calculations, comparison, if structures and while structures. We have been using a "command" System.out.println() to print. We can count the maximum of two numbers with the help of the "command" Math.max(). We are also familiar with reader.nextLine(), usually seen together with Integer.parseInt().

If we take a closer look we notice that those commands differ from if and while (etc). The first difference is that after the command there are brackets () and sometimes an input for the command inside those brackets. Actually the commands ending with brackets are not called commands but methods.

Technically a method is a piece of code that can be called from different places of the program code. The line of code System.out.println("I am a parameter given to the method!") means that we call a method that actually handles the printing. After the method has been executed we go back where we called the method and continue executing. The input given to the method inside the brackets is called a method parameter.

In addition to a parameter, the method can also have a return value, for example, a familiar line of code:

int number = Integer.parseInt( reader.nextLine() );

includes two method calls. First the inner method reader.nextLine is called. That method has the integer typed by the user as a return value. Next the outer method Integer.parseInt is called. As a parameter for that method there is the string of characters that was received from the reader.nextLine method as a return value. The return value for the method Integer.parseInt is the string of characters transformed into an integer (number).

Method names also seem to include a dot, for example reader.nextLine(). Actually the method name starts after the dot, here it is nextLine(). The first part of the command that comes before the dot shows whose method is in question, here the method belongs to the reader. So we have the reader's method nextLine. Later we will learn more precisely about the method owner (or the name on the left side of the dot). An attentive reader will notice that the method System.out.println() has two dots. Here, the method name is println and System.out is the owner of the method. Roughly System.out means the computer monitor.

This far we have been using ready-made methods from Java libraries. Next we will learn how to do our own methods.

Self-written methods

This far we have been using a programming style where code is written (and read and executed) from top to bottom.

Before it was mentioned that "a method is a piece of code that can be called from different places of the program code". Ready-made methods of Java have been used since our very first program.

In addition to using these ready-made methods the programmer can write their own methods for the program to call. In the real world it is really exceptional if the program does not include any self-written methods. From now on almost every program we create during this course will include self-written methods.

The methods are written in the program body outside the main's braces ( { and } ) but still inside the outermost braces, for example like this: :

import java.util.Scanner;

public class ProgramBody {
  public static void main(String[] args) {
    Scanner reader = new Scanner(System.in);
    // program code
  }

  // self-written methods
}

Let us create a method greet.

  public static void greet() {
    System.out.println("Greetings from the world of methods!");
  }

And let us place it in the right spot.

import java.util.Scanner;

public class ProgramBody {
  public static void main(String[] args) {
    Scanner reader = new Scanner(System.in);
    // program code
  }

  // self-written methods
public static void greet() {
    System.out.println("Greetings from the world of methods!");
  }
}

In order to define a new method we need to write two things. In the first row of the method definition there is the method name, here it is greet. On the left side of the name there are definitions public static void. On the next line there is the code block, marked by the braces ({ and }) and inside it there is the method's code, or the commands that will be executed when the method is called. Our method greet only writes one line of text to the screen.

It is easy to call a self-written method. It happens by writing the method name, brackets () and a semicolon. In the next example main (or the main program) calls for our method, first once and then several times.

import java.util.Scanner;

public class ProgramBody {
  public static void main(String[] args) {
    Scanner reader = new Scanner(System.in);

    // program code
    System.out.println("Let us try if we can get to the method world:");
    greet();

    System.out.println("It seems like we can, let us try again:");
    greet(); 
    greet(); 
    greet();
  }

  // self-written methods
  public static void greet() {
    System.out.println("Greetings from the world of methods!");
  }
}

When the program is executed, we see the following output::

Let us try if we can get to the method world:
Greetings from the world of methods!
It seems like we can, let us try again:
Greetings from the world of methods!
Greetings from the world of methods!
Greetings from the world of methods!

What is noteworthy here is the execution order of the program code. The execution starts with the main program's (or main's) code lines, from top to bottom, one by one. When the code line to be executed happens to be a method call, the lines of code in the method block are executed again one by one, and when the method block ends the execution continues from the place where the method was called. To be exact, the execution continues from the next line after the original method call.

To be even more exact, the main program is also a method. When the program starts, the operation system calls for the main method. That means that the main method is the program starting point and the execution starts from the first code line of main. And the program execution ends when it reaches the end of main.

From now on when we introduce methods we will not point out that they need to be written in the right place inside the program code. For example, a method cannot be defined inside another method.

public static void main(String[] args) {
    printText();
}

public static void printText() {
    // write your code here
}

In the beginning there were the swamp, the hoe and Java.

public static void main(String[] args) {
    // ask the user how many times the text should be printed
    // use the while structure to call the printText method several times
}

public static void printText() {
    // write your code here
}

How many?
7
In the beginning there were the swamp, the hoe and Java.
In the beginning there were the swamp, the hoe and Java.
In the beginning there were the swamp, the hoe and Java.
In the beginning there were the swamp, the hoe and Java.
In the beginning there were the swamp, the hoe and Java.
In the beginning there were the swamp, the hoe and Java.
In the beginning there were the swamp, the hoe and Java.

Method parameters

We can make our methods more useful by giving some parameters to it! Parameters are variables that we can define in the first line of method inside the brackets, just after the method name. When the method is called, the parameters get their values at that point.

In the next example we define a method with a parameter, its name will be greet and its parameter will be a variable of the type String called name.

public static void greet(String name) {
  System.out.println("Hi " + name + ", greetings from the world of methods!");
}

Let us next call the greet method so that on the first try we give its parameter the value Matt and on the second try Arthur.

public static void main(String[] args) {
  greet("Matt");
  greet("Arthur");
}

Hi Matt, greetings from the world of methods!
Hi Arthur, greetings from the world of methods!

More complicated expressions can also be used as a parameter for our self-written methods, the same way we used them together with the ready-made System.out.println() method.

public static void main(String[] args) {
  String name1 = "Anne";
  String name2 = "Green";
  greet( name1 + " " + name2 );

  int age = 24;
  greet("John " + age + " years");
}

Hi Anne Green, greetings from the world of methods!
Hi John 24 years, greetings from the world of methods!

In both cases the method has only one parameter. The value for the parameter is calculated before calling the method. In the first case the parameter value comes from the String concatenation (a cool word that means putting the text together) name1 + " " + name2. The value for that concatenation is Anne Green. In the second case we get the parameter value from the String concatenation "John " + age + " years".

Many parameters

A method can be defined to have more than one parameter. In that case the parameters are always given in the same order.

public static void greet(String name, String greetingsFrom) {
  System.out.println("Hi " + name + ", greetings from " + greetingsFrom);
}

String who = "Matt";
String greetings = "Alabama";

greet(who, greetings);
greet(who, greetings + " from Nevada");

In the last greet function (or method) call the second parameter is formed by concatenating (or adding) the text “from Nevada” to the variable greetings. This is done before the actual function call.

Hi Matt, greetings from Alabama
Hi Matt, greetings from Alabama from Nevada	

Method calling another method

main is not the only one that is able to call methods. Methods can also call each other! Let us create a method greetManyTimes that greets the user many times using the help of the method greet:

public static void greet(String name) {
  System.out.println("Hi " + name + ", greetings from the world of methods!");
}

public static void greetManyTimes(String name, int times) {
  int i = 0;
  while ( i < times ) {
    greet(name);
    i++;
  }
  
}

public static void main(String[] args) {
  greetManyTimes("Anthony", 3);
  System.out.println("and");
  greetManyTimes("Martin", 2);
}

Output:

Hi Anthony, greetings from the world of methods!
Hi Anthony, greetings from the world of methods!
Hi Anthony, greetings from the world of methods!
ja
Hi Martin, greetings from the world of methods!
Hi Martin, greetings from the world of methods!

private static void printStars(int amount) {
    // you can print one star with the command
    // System.out.print("*");
    // call this command amount times
}

public static void main(String[] args) {
    printStars(5);
    printStars(3);
    printStars(9);
}

*****
***
*********

****
****
****
****

*****************
*****************
*****************

*
**
***
****

   *
  **
 ***
****

   *
  ***
 *****
*******
  ***
  ***

         *
        ***
       *****
      *******
     *********
    ***********
   *************
  ***************
 *****************
*******************
        ***
        ***

Guess a number: 73
The number is smaller, guesses made: 1
Guess a number: 22
The number is greater, guesses made: 2
Guess a number: 51
The number is greater, guesses made: 3
Guess a number: 62
The number is greater, guesses made: 4
Guess a number: 68
The number is greater, guesses made: 5
Guess a number: 71
The number is smaller, guesses made: 6
Guess a number: 70
Congratulations, your guess is correct!

Guess a number: 12
The number is greater

Guess a number: 66
The number is smaller

Guess a number: 42
Congratulations, your guess is correct!

Guess a number: 55
The number is greater
Guess a number: 85
The number is smaller
Guess a number: 77
The number is greater
Guess a number: 81
The number is greater
Guess a number: 83
Congratulations, your guess is correct!

Guess a number: 55
The number is greater, guesses made: 1
Guess a number: 85
The number is smaller, guesses made: 2
Guess a number: 77
The number is greater, guesses made: 3
Guess a number: 81
The number is greater, guesses made: 4
Guess a number: 83
Congratulations, your guess is correct!

        Scanner reader = new Scanner(System.in);
        Hangman hangman = new Hangman();
        
        System.out.println("************");
        System.out.println("* Hangman *");
        System.out.println("************");
        System.out.println("");
        printMenu();
        System.out.println("");
        
        // ADD YOUR IMPLEMENTATION HERE

	System.out.println("Thank you for playing!");

    public static void printMenu() {
        System.out.println(" * menu *");
        System.out.println("quit   - quits the game");
        System.out.println("status  - prints the game status");
        System.out.println("a single letter uses the letter as a guess");
        System.out.println("an empty line prints this menu");
    }

while (hangman.gameOn()) {
  String command = reader.nextLine();
  // ...
}

************
* Hangman *
************

 * menu *
quit   - quits the game
status - prints the game status
a single letter uses the letter as a guess
an empty line prints this menu

Type a command: 
do not quit

Type a command: 
quit
Thank you for playing!

************
* Hangman *
************

* menu *
quit   - quits the game
status - prints the game status
a single letter uses the letter as a guess
an empty line prints this menu

Type a command: 
status
You have not made any guesses yet.
Unused letters: abcdefghijklmnopqrstuvwxyz

Type a command: 
quit
Thank you for playing!

String command = reader.nextLine();

if(command.length() == 1) {  // command has only one letter, so it must be a guess
  hangman.guess(command);
} 

...
Type a command: 
a
The letter a is not in the word.

Type a command: 
b
The letter b is not in the word.

Type a command: 
c
The letter c was found in the word!

Type a command: 
quit
Thank you for playing!

String winnie = "the pooh";
if(winnie.isEmpty()) {
    System.out.println("String was empty");
} else {
    System.out.println("I found something!");
}

...
Type a command: 
a
The letter a is not in the word.
 ____
 |   
 |   
 |   
 |   
/|\
Word to be guessed: ????

Type a command: 
m
The letter m was found in the word!
 ____
 |   
 |   
 |   
 |   
/|\
Word to be guessed: m???

Type a command: 
quit
Thank you for playing!

More about methods

Methods and the visibility of the variables

Let us try to change the value of a variable so that the variable is in the main program and the changing happens in a method.

// main program
public static void main(String[] args) {
  int number = 1;
  addThree();
}

// method
public static void addThree() {
  number = number + 3;
}

Unfortunately this program will not work, because the method cannot see the variable number in the main program.

This is also the case generally, the variables from the main program are not visible for methods and the other way around: methods' variables are not visible for other methods or the main program. The only way to give information to a method from outside is to use parameters.

// main program
public static void main(String[] args) {
  int number = 1;
  System.out.println("Main program variable number holds the value: " + number);
  addThree(number);
  System.out.println("Main program variable number holds the value: " + number);
}

// method
public static void addThree(int number) {
  System.out.println("Method parameter number holds the value: " + number);
  number = number + 3;
  System.out.println("Method parameter number holds the value: " + number);
}

In the program above the method addThree has a parameter number. This parameter called number is duplicated for the method to use. When the program above is executed we see the following output:

Main program variable number holds the value: 1
Method parameter number holds the value: 1
Method parameter number holds the value: 4
Main program variable number holds the value:  1

The number that we gave as a parameter to the method was copied for the method to use. If we would like to get the new value for use in our main program, the method needs to return the value.

Return values

A method can return a value. In the examples above the methods have not been returning anything. This is defined by writing void in the first line of method just before it's name.

public static void addThree() {
  ...

When defining a method that returns a value we also have to define the type of the return value. We can define the return value type by writing it just before the method name. Next we have a method that always returns the number 10 (that is of type int). Returning happens via the command return:

public static int alwaysReturnTen() {
  return 10;
}

We have to catch the return value and store it into a variable so that we can use it later:

public static void main(String[] args) {
  int number = alwaysReturnTen();

  System.out.println( "method returned the number " + number );
}

The method return value is assigned to a variable of int type just like any other integer. The return value can also be part of any sentence:

double number = 4 * alwaysReturnTen() + (alwaysReturnTen() / 2) - 8;

System.out.println( "calculation total " + number );

Every variable type we have seen this far can be used as return values:

public static void methodThatReturnsNothing() {
  // method body
}

public static int methodThatReturnsInteger() {
  // method body, needs a return statement
}

public static String methodThatReturnsText() {
  // method body, needs a return statement
}

public static double methodThatReturnsFloatingpoint() {
  // method body, needs a return statement
}

If the method is defined to have a return value, it also has to return a value. The following method is wrong:

public static String wrongMethod() {
  System.out.println("I tell you that I will return a String but I do not!");
}

In the following example we define a method for calculating a sum. After that we use the method to calculate 2 + 7. The return value (that is returned after the method call) is assigned to a variable called sumNumbers.

public static int sum(int first, int second) {
  return first + second;
}

Method call:

int sumNumbers = sum(2, 7);
// sumNumbers now holds the value 9

Let us expand the example program so that the user types the numbers.

public static void main(String[] args) {
  Scanner reader = new Scanner(System.in);

  System.out.print("Type the first number: ");
  int first = Integer.parseInt( reader.nextLine() );

  System.out.print("Type the second number: ");
  int second = Integer.parseInt( reader.nextLine() );

  System.out.print("Total: " + sum(first,second) );
}

public static int sum(int first, int second) {
  return first + second;
}

As we can see, the method return value does not always need to be assigned to a variable. It can also act as a part of the printing command just like any other int value.

In the next example we call the method sum using integers that we get as return values from the method sum.

int first = 3;
int second = 2;

sum(sum(1, 2), sum(first, second));
// 1) the inner methods are executed:
//    sum(1, 2) = 3   and sum(first, second) = 5
// 2) the outer method is executed:
//    sum(3, 5) = 8 

The method's own variables

The following method calculates the average of the numbers the method gets as parameters. The method uses helper variables sum and average. The method's own variables can be introduced just like any other variables.

public static double average(int number1, int number2, int number3) {

  int sum = number1 + number2 + number3;
  double average = sum / 3.0;

  return average;
}

Screencast aiheesta: TODO

public static int sum(int number1, int number2, int number3, int number4) {
    // write program code here
    // remember that the method needs a return in the end
}

public static void main(String[] args) {
    int answer = sum(4, 3, 6, 1);
    System.out.println("sum: " + answer);
}

sum: 14

public static int least(int number1, int number2) {
    // write program code here
    // do not print anything inside the method
   
    // method needs a return in the end
}

public static void main(String[] args) {
    int answer =  least(2, 7);
    System.out.println("Least: " + answer);
}

Least: 2

public static int greatest(int number1, int number2, int number3) {
    // write your code here
}

public static void main(String[] args) {
    int answer =  greatest(2, 7, 3);
    System.out.println("Greatest: " + answer);
}

Greatest: 7

public static double average(int number1, int number2, int number3, int number4) {
    // write your code here
}

public static void main(String[] args) {
    double answer = average(4, 3, 6, 1);
    System.out.println("average: " + answer);
}

average: 3.5

Strings of characters

In this section we take a closer look at Java's strings of characters, which are called Strings. We have already used variables of String type when printing and learned how to compare Strings. Comparing two strings happens by calling the string's equals() method.

String animal = "Dog";

if( animal.equals("Dog") ) {
    System.out.println(animal + " says bow-wow");
} else if ( animal.equals("Cat") ) {
    System.out.println(cat + " says meow meow");
}

It is possible to ask the string how many characters long it is by writing .length() after its name. In other words we are calling its method called length().

String banana = "banana";
String cucumber = "cucumber";
String together = banana + cucumber;

System.out.println("The length of banana is " + banana.length());
System.out.println("The length of  cucumber is " + cucumber.length());
System.out.println("The word " + together + " length is " + together.length());

In the above code the method length() is called for three different strings. The call banana.length() calls only the method that gives the length of the string banana, while cucumber.length() calls the method that gives the length of the string cucumber etc. The left part before the dot says whose method is called.

Java has a special data type called char to be used for characters. A char variable can store one character. A string variable can give its characters by location when the charAt() method is used. Note that counting the characters starts from zero!

String word = "Supercalifragilisticexpialidocious";

char character = word.charAt(3);
System.out.println("The 4th character of the word is " + character); //prints "e"

The characters in a string are numbered (ot more technically speaking strings are indexed) starting from 0. Because of that we can reach the last character in a string from the number (or index) "the length of the word minus one", or word.charAt(word.length()-1). The following example will make the program crash, because we are trying to get a character from an index that does not exist.

char character = word.charAt(word.length());

Type your name: Paul
Number of characters: 4

Type your name: Catherine
Number of characters: 9

Type your name: Paul
First character: P

Type your name: Catherine
First character: C

Type your name: Paul
Last character: l

Type your name: Catherine
Last character: e

Type your name: Paul
1. character: P
2. character: a
3. character: u

Type your name: me

Type your name: Paul
1. character: P
2. character: a
3. character: u
4. character: l

Type your name: Catherine
1. character: C
2. character: a
3. character: t
4. character: h
5. character: e
6. character: r
7. character: i
8. character: n
9. character: e

Type your name: Paul
In reverse order: luaP

Type your name: Catherine
In reverse order: enirehtaC

Other methods for strings

In many cases we want to read only a specific part of a string. A method in the String class called substring makes this possible. It can be used in two ways:

String word = "Supercalifragilisticexpialidocious";
System.out.println(word.substring(14)); //prints "listicexpialidocious"
System.out.println(word.substring(9,20)); //prints "fragilistic"

We can store the return value in a variable, because the return value of the substring method is of String type.

String book = "Mary Poppins";
String endpart = book.substring(5);
System.out.println("Harry " + endpart); // prints "Harry Poppins"

Methods in the String class also make it possible to search for a specific word in the text. For example, the word "or" can be found in the word "Horse". A method called indexOf() searches for the word given as a parameter in a string. If the word is found, it returns the starting index (or the place, remember that the numbering starts from 0!) of the word. If the word is not found, the method returns the value -1.

String word = "aesthetically";

int index = word.indexOf("tic"); // index value will be 1
System.out.println(word.substring(index)); //prints "tically"

index = word.indexOf("ally"); //index value will be 9
System.out.println(word.substring(index)); //prints "ally"

index = word.indexOf("book"); // string "aesthetically" does not include "book" 
System.out.println(index); //prints -1
System.out.println(word.substring(index)); //error!

Screencast aiheesta: TODO

Type a word: example
Length of the first part: 4
Result: exam

Type a word: example
Length of the first part: 6
Result: exampl

Type a word: example
Length of the end part: 4
Result: mple

Type a word: esimerkki
Length of the end part: 6
Result: xample

Type the first word: glitter
Type the second word: litter
The word 'litter' is found in the word 'glitter'. 

Type the first word: glitter
Type the second word: clean
The word 'clean' is not found in the word 'glitter'. 

public static String reverse(String text) {
    // write your code here
}

public static void main(String[] args) {
    System.out.print("Type in your text: ");
    String text = reader.nextLine();
    System.out.println("In reverse order: " + reverse(text));
}

  String help = "";

  // ...
  // adding a character to the help variable
  help = help + character;

Type a text: example
elpmaxe

Object

Strings and integers for example have some differences. Integers are "just values", they can be used in calculations and they can be printed to the screen:

int x = 1;
int y = 3;

y = 3*x + t;

System.out.println( "value of y now: " + y );

Strings are a bit "cleverer" and they know how long they are for example:

String word1 = "Programming";
String word2 = "Java";

System.out.println( "String "+ word1 +" length: " + word1.length() );

System.out.println( "String "+ word2 +" length: " + word2.length() );

Program output:

String Programming length: 11
String Java length: 4

We can determine the length by calling the String method length(). Strings have other methods as well. Integers (or whole numbers, variables of type int) have no methods at all. They do not "know" anything.

Strings are objects, or "something that has methods and a value". Later we will see many other objects as well.

As we can see in the previous example, an object's methods are called by adding a dot and a method call after the object name:

word1.length()    // String object name is word1 and its method length() is called
word2.length()    // String object name is word2 and its method length() is called

The method call is made explicitly to the object. In the above example we have two objects and first we call the length() method of the String object word1 and then do the same for the object word2.

Our old friend reader is also an object:

  Scanner reader = new Scanner(System.in);

String banana = new String("Banana");
String carrot = "carrot";

Both of the commands above create a new String object. Using the new command when creating String objects is rare.

The object "type" is called a class. The class of character strings is called String and the class of readers is called Scanner. Later we learn much more about classes and objects.

ArrayList or an "object container"

It often happens during programming that we would like to keep for example many different strings in the memory. A very bad idea would be to define a variable for each of them: :

String word1;
String word2;
String word3;
// ...
String word10;

This would be a good-for-nothing solution and the reasons for it do not even need justification --think about this approach and make the word count to be a hundred or even a thousand!

Just like other modern programming languages, Java gives us different tools to keep many objects neatly in our program. Now we take a closer look at ArrayList, which is probably the most used object container in Java.

The following lines of code take into use an ArrayList that specifically holds objects of String type. Then a couple of strings are stored into the list.

import java.util.ArrayList;

public class ListProgram {

    public static void main(String[] args) {
        ArrayList<String> wordList = new ArrayList<String>();

        wordList.add("First");
        wordList.add("Second");
    }
}

In the above main program method the first row creates a new ArrayList called wordList that can be used as a container for String variables. The type of the ArrayList is ArrayList<String>, which means the ArrayList is specifically for storing Strings. The list is created using the command new ArrayList<String>();.

Note: for getting the ArrayList working, the program needs to have it imported. That happens by writing at the beginning of the program either import java.util.ArrayList; or import java.util.*;

When the list is created, two strings are added by calling the list method add. The list will not run out of space, so theoretically the list can contain any number of Strings (as long as they fit in the "machines" memory.

Internally an ArrayList is -- as its name suggests -- a list. The added strings automatically go to the end of the ArrayList.

ArrayList methods

ArrayList provides us with many useful methods:

    public static void main(String[] args) {
        ArrayList<String> teachers = new ArrayList<String>();

        teachers.add("Anthony");
        teachers.add("Barto");
        teachers.add("Paul");
        teachers.add("John");
        teachers.add("Martin");
        teachers.add("Matt");

        System.out.println("the number of teachers " + teachers.size() );

        System.out.println("first teacher on the list " + teachers.get(0));
        System.out.println("third teacher on the list " + teachers.get(2));
       
        teachers.remove("Barto");

        if ( teachers.contains("Barto") ) {
            System.out.println("Barto is on the teachers list");
        } else {
            System.out.println("Barto is not on the teachers list");
        }
    }

First a string list is created and then 6 names added to it. size tells us the amount of strings on the list. Note: when the method is called, the call should have the following formatting: teachers.size(). First comes the object name, then follows a dot and after that comes the method name.

The strings will be on the list in the order in which they were added to it. With the method get(i) we get the value from the index (place) i on the list. The list items indexing (place numbering) starts from 0. That means the first added string will be found at the index 0, second at the index 1 and so on.

We can remove strings from the list using the method remove. The method can be used in two ways. The first way, remove("characters") removes the string of characters given as a parameter. The second way, remove(3) removes the 4th String from the list.

At the end of the example the method contains is called. That method is used for asking the list if it contains the string of characters given as a parameter. If it does, the method returns the value true.

Program output:

the number of teachers 6
first teacher on the list Anthony
third teacher on the list Paul
Barto is not on the teachers list

Note! Methods remove and contains assume that the objects stored in the ArrayList do have an equals method. We will get back to this later in the course.

Going through an ArrayList

In the following example 4 names are added to the list and then the whole list is printed:

    public static void main(String[] args) {
        ArrayList<String> teachers = new ArrayList<String>();

        teachers.add("Anthony");
        teachers.add("Paul");
        teachers.add("John");
        teachers.add("Martin");
	
        System.out.println( teachers.get(0) );
        System.out.println( teachers.get(1) );
        System.out.println( teachers.get(2) );
        System.out.println( teachers.get(3) );
}

This solution works, but is really clumsy. What if there were more items on the list? Or less? What if we would not know how many items there are?

First we create a temporary version:

    public static void main(String[] args) {
        ArrayList<String> teachers = new ArrayList<String>();

        teachers.add("Anthony");
        teachers.add("Paul");
        teachers.add("John");
        teachers.add("Martin");
        teachers.add("Matt");
	
        int place = 0;
        System.out.println( teachers.get(place) );
        place++;  
        System.out.println( teachers.get(place) );  // place = 1
        place++;
        System.out.println( teachers.get(place) );  // place = 2
        place++;
        System.out.println( teachers.get(place) );  // place = 3
}

Using our old friend the while command we can increment the variable place by one until it gets too big:

    public static void main(String[] args) {
        ArrayList<String> teachers = new ArrayList<String>();

        teachers.add("Anthony");
        teachers.add("Paul");
        teachers.add("John");
        teachers.add("Martin");
        teachers.add("Matt");

        int place = 0;
        while ( place < teachers.size() )  // do you remember why place <= teachers.size() does not work?
            System.out.println( teachers.get(place) );
            place++;
        }
}

Now the printing works regardless of the number of items on the list.

Using a while repetition sentence and "self indexing" the list places is not usually the best way to go through a list. A much more recommendable way is to use the for-each repetition described below.

for-each

Even though usually the command is referred to as for-each, the real name of the command is only for. There are two versions of for, the traditional and the "for-each". The later is used now.

Going through ArrayList items with for-each is like child's play:

    public static void main(String[] args) {
        ArrayList<String> teachers = new ArrayList<String>();

        teachers.add("Anthony");
        teachers.add("Paul");
        teachers.add("John");
        teachers.add("Martin");
        teachers.add("Matt");

        for (String teacher : teachers) {
            System.out.println( teacher );
        }
}

As we can see, the list indexes can be ignored if we go through the list content "automatically".

In the code block of the for command (inside { }) a variable teacher is used. It is defined in the for row, on the left side of the colon. What happens there is that every item on the list teachers becomes the value of the variable teacher, one by one. It means that when for is entered, the first teacher is Anthony, second execution of for makes the teacher be Paul etc.

Even though the for command might seem a bit strange at first, you should definitely get used to using it!

Screencast aiheesta: TODO

ArrayList<String> words = new ArrayList<String>();

Type a word: Mozart
Type a word: Schubert
Type a word: Bach
Type a word: Sibelius
Type a word: Liszt
Type a word:
You typed the following words:
Mozart
Schubert
Bach
Sibelius
Liszt

String word = reader.nextLine();

if ( word.isEmpty() ) {  // could also be: word.equals("")
   // word was empty, meaning that the user only pressed enter
}

ArrayList<String> words = new ArrayList<String>();

Type a word: carrot
Type a word: celery
Type a word: turnip
Type a word: rutabaga
Type a word: celery
You gave twice the word celery

Ordering, reversing and shuffling a list

Items on an ArrayList are easy to order by size. Ordering by size means an alphabetic order when the list is of String type. Ordering happens like this::

    public static void main(String[] args) {
        ArrayList<String> teachers = new ArrayList<String>();

        // ...

        Collections.sort(teachers);

        for (String teacher : teachers) {
            System.out.println( teacher );
        }
    }

Output:

Anthony
Barto
John
Martin
Matt
Paul

We give the list as a parameter for the method Collections.sort. The import line import java.util.Collections; or import java.util.*; needs to be at the beginning of the program in order to get Collections tools working in our program.

Collections also includes other useful methods:

• shuffle shuffles the list items, can be useful for example in games
• reverse reverses the list item order

Type a word: Mozart
Type a word: Schubert
Type a word: Bach
Type a word: Sibelius
Type a word: Liszt
Type a word:
You typed the following words:
Liszt
Sibelius
Bach
Schubert
Mozart

Type a word: Mozart
Type a word: Schubert
Type a word: Bach
Type a word: Sibelius
Type a word: Liszt
Type a word:
You typed the following words:
Bach
Liszt
Mozart
Schubert
Sibelius

ArrayList as a parameter for a method

ArrayList can be given to a method as a parameter:

    public static void print(ArrayList<String> list) {
        for (String word : list) {
            System.out.println( word );
        }
    }

    public static void main(String[] args) {           
        ArrayList<String> list = new ArrayList<String>();  
        list.add("Java");
        list.add("Python");
        list.add("Ruby");
        list.add("C++");
        
        print(list);         
    }

The type of the parameter is defined to be an ArrayList of String variables the same way a String ArrayList is defined:

Note that the name of the parameter can be anything:

    public static void print(ArrayList<String> printed) {
        for (String word : printed) {
            System.out.println( word );
        }
    }

    public static void main(String[] args) { 
        ArrayList<String> programmingLanguages = new ArrayList<String>();  
        programmingLanguages.add("Java");
        programmingLanguages.add("Python");
        programmingLanguages.add("Ruby");
        programmingLanguages.add("C++");
        
        ArrayList<String> countries = new ArrayList<String>();
        countries.add("Finland");
        countries.add("Sweden");
        countries.add("Norway");
        
        print(programmingLanguages);    // method is given the list programmingLanguages
 as a parameter
        
       print(countries);                 //  method is given the list countries as a parameter
    }

The program now includes two lists, programmingLanguages and countries. First the printing method is given the list programmingLanguages. The method print internally refers to the list given as a parameter with the name printed! Next the printing method is given the list countries. Now again the method uses the name printed referring to the parameter list.

 
ArrayList<String> list = new ArrayList<String>(); 
lista.add("Hallo"); 
lista.add("Ciao"); 
lista.add("Hello"); 
System.out.println("There are this many items on the list:"); 
System.out.println(countItems(list)); 

 
There are this many items on the list: 
3 

Inside the method it is possible to influence the items on the parameter list. In the following example the method removeFirst --as the name suggests-- removes the first string from the list. What would happen if the list was empty?

    public static void print(ArrayList<String> printed) {
        for (String word : printed) {
            System.out.println( word );
        }
    }
    
    public static void removeFirst(ArrayList<String> list) {
        list.remove(0);  // removes the first item (indexed 0)
    }

   public static void main(String[] args) {
        ArrayList<String> programmingLanguages = new ArrayList<String>();  
        programmingLanguages.add("Pascal");
        programmingLanguages.add("Java");
        programmingLanguages.add("Python");
        programmingLanguages.add("Ruby");
        programmingLanguages.add("C++");
        

        print(programmingLanguages);   
        
        removeFirst(programmingLanguages);
        
        System.out.println();  // prints an empty line
        
       print(programmingLanguages);      
    }

Output:

Pascal
Java
Python
Ruby
C++

Java
Python
Ruby
C++

Similarly a method could, for example, add more strings to the list it got as a parameter.

ArrayList<String> brothers = new ArrayList<String>();
brothers.add("Dick");
brothers.add("Henry");
brothers.add("Michael");
brothers.add("Bob");

System.out.println("brothers:");
System.out.println(brothers);

// sorting brothers
brothers.sort();

// removing the last item
removeLast(brothers);

System.out.println(brothers);

brothers:
[Dick, Henry, Michael, Bob]
[Bob, Dick, Henry]

As we can tell from the example above, an ArrayList can be printed as it is. The print formatting is not usually what is sought after and we are forced to handle the printing ourself with the help of the for command, for example.

Numbers in an ArrayList

ArrayLists can be used to store any type of values. If the stored variables are of integer type, there are a couple of details to remember. An integer ArrayList is defined like this: ArrayList<Integer>, instead of writing int you must write Integer.

The method remove does not work like expected when the list consists of int numbers::

 
    public static void main(String[] args) { 
        ArrayList<Integer> numbers = new ArrayList<Integer>(); 

        numbers.add(4); 
        numbers.add(8); 

        // tries to remove the number from the index 4, does not work as expected!
        numbers.remove(4); 

        // this removes the number 4 from the list
        numbers.remove( Integer.valueOf(4) ); 

numbers.remove(4) tries to remove the item in the index 4 from the list. There are only 2 items on the list, so that the command results in an error. We must use a slightly more complicated form if the number 4 needs to be removed: numbers.remove( Integer.valueOf(4) );

ArrayLists can also be used to store doubles (i.e. decimal numbers) and characters (i.e. char variables). The lists can be defined like this:

 
        ArrayList<Double> doubles = new ArrayList<Double>(); 
        ArrayList<Character> characters = new ArrayList<Character>(); 

 
public static int sum(ArrayList<Integer> list) { 
    // write your code here
} 

public static void main(String[] args) { 
    ArrayList<Integer> list = new ArrayList<Integer>(); 
    list.add(3); 
    list.add(2); 
    list.add(7); 
    list.add(2); 

    System.out.println("The sum: " + sum(list)); 

    list.add(10); 

    System.out.println("the sum: " + sum(list)); 
} 

 
The sum: 14 
The sum: 24 

 
public static double average(ArrayList<Integer> list) { 
    // write your code here
} 

public static void main(String[] args) { 
    ArrayList<Integer> list = new ArrayList<Integer>(); 
    list.add(3); 
    list.add(2); 
    list.add(7); 
    list.add(2); 

    System.out.println("The average is: " + average(list)); 
} 

 
The average is: 3.5 

ArrayList as a method's return value

ArrayList can also be returned from a method as a return value. In the next example a method creates an ArrayList, adds three integers in the list and then returns the list. Pay attention to how the main program assigns the list returned by the method as a value into a variable that has the same type as the return value list:

 
public class Main { 

    public static ArrayList<Integer> addNumbersToList(int num1, int num2, int num3){ 
        ArrayList<Integer> list = new ArrayList<Integer>(); 
        
        list.add(num1); 
        list.add(num2); 
        list.add(num3); 
        
        return list; 
    } 
    
    public static void main(String[] args) { 
        ArrayList<Integer> numbers = addNumbersToList(3, 5, 2); 
        
        for (int number : numbers) { 
            System.out.println( number ); 
        } 
    } 
} 

 
public static ArrayList<Integer> lengths(ArrayList<String> list) { 
    // write your code here
} 

public static void main(String[] args) { 
    ArrayList<String> list = new ArrayList<String>(); 
    list.add("Hallo"); 
    list.add("Moi"); 
    list.add("Benvenuto!"); 
    list.add("badger badger badger badger"); 
    ArrayList<Integer> lengths = lengths(list); 

    System.out.println("The lengths of the Strings: " + lengths); 
} 

 
The lengths of the Strings: [3, 3, 10, 27] 

 
public static int greatest(ArrayList<Integer> list) { 
    // write your code here
} 

public static void main(String[] args) { 
    ArrayList<Integer> list = new ArrayList<Integer>(); 
    list.add(3); 
    list.add(2); 
    list.add(7); 
    list.add(2); 

    System.out.println("The greatest number is: " + greatest(list)); 
} 

 
The greatest number is: 7 

 
public static double variance(ArrayList<Integer> list) { 
    // write your code here
} 

public static void main(String[] args) { 
    ArrayList<Integer> list = new ArrayList<Integer>(); 
    list.add(3); 
    list.add(2); 
    list.add(7); 
    list.add(2); 

    System.out.println("The variance is: " + variance(list)); 
} 

 
The variance is: 5.666667 

Using truth values

A variable of truth value type (i.e. boolean can only have two values: true or false. Here is an example on how to use boolean variables:

 
        int num1 = 1; 
        int num2 = 5; 

        boolean firstGreater = true; 

        if (num1 <= num2) { 
            firstGreater = false; 
        } 

        if (firstGreater==true) { 
            System.out.println("num1 is greater"); 
        } else { 
            System.out.println("num1 was not greater"); 
        } 

First we assign the truth value variable firstGreater the value true. The first if sentence checks whether num1 is less or equal to num2. If it is, we change the value of firstGreater to be false. The later if sentence selects what it prints based on the truth value.

As a matter of fact using a truth value in a conditional sentence is easier than described in the previous example. We can also write the second if sentence like this:

 
        if (firstGreater) {  // means the same as firstGreater==true 
            System.out.println("num1 was greater"); 
        } else { 
            System.out.println("num1 was not greater"); 
        } 

If we want to check if the boolean variable holds the value true, we do not need to write ==true, writing just the name of the variable is enough!

If we want to check if the boolean variable holds the value false, we can check that using a negation operation (i.e. an exclamation mark:

 
        if (!firstGreater) {  // means the same as firstGreater==false 
            System.out.println("num1 was not greater"); 
        } else { 
            System.out.println("num1 was greater"); 
        } 

A method that returns a truth value

Truth values come in especially handy when we want to write methods that check for validity. Let us create a method that checks if the list it gets as a parameter includes only positive numbers (here 0 is considered positive). The method returns the information as a boolean (i.e. truth value).

 
    public static boolean allPositive(ArrayList<Integer> numbers) { 
        boolean noNegative = true; 

        for (int number : numbers) { 
            if (number < 0) { 
                noNegative = false; 
            } 
        } 

        // if one of the numbers on the list had a value that was under 0, noNegatives becomes false.

        return noNegative; 
    } 

The method has a boolean helper variable called noNegative. First we assign the helper variable the value true. The method checks all numbers on the list one by one. If at least one number is less than 0, we assign the helper variable the value false. In the end the method returns the value of the helper variable. If no negative numbers were found, it has the value true, otherwise it has the value false.

The method is used like this:

 
    public static void main(String[] args) { 

        ArrayList<Integer> numbers = new ArrayList<Integer>(); 
        numbers.add(3); 
        numbers.add(1); 
        numbers.add(-1); 

        boolean result = allPositive(numbers); 

        if (result) {  // means the same as result == true 
            System.out.println("all numbers are positive"); 
        } else { 
            System.out.println("there is at least one negative number"); 
        } 
    } 

Usually it is not necessary to store the answer into a variable. We can write the method call directly as the condition:

 
        ArrayList<Integer> numbers = new ArrayList<Integer>(); 
        numbers.add(4); 
        numbers.add(7); 
        numbers.add(12); 
        numbers.add(9); 

        if (allPositive(numbers)) { 
            System.out.println("all numbers are positive"); 
        } else { 
            System.out.println("there is at least one negative number"); 
        } 
    } 

The command return and the ending of a method

The execution of a method is stopped immediately when a command called return is executed. Using that information to our advantage we can write the allPositive method a bit more clearly.

 
    public static boolean allPositive(ArrayList<Integer> numbers) { 
        for (int number : numbers) { 
            if (number < 0) { 
                return false; 
            } 
        } 

        // if the execution reached this far, no negative numbers were found
        // so we return true
        return true; 
    } 
} 

When we are going through the list of numbers and we find a negative number, we can exit the method by returning false. If there are no negative numbers on the list, we get to the end and therefore can return true. We have now gotten rid of the helper variable inside the method!

 
public static boolean moreThanOnce(ArrayList<Integer> list, int number) { 
    // write your code here
} 

public static void main(String[] args) { 
    ArrayList<Integer> list = new ArrayList<Integer>(); 
    list.add(3); 
    list.add(2); 
    list.add(7); 
    list.add(2); 

    System.out.println("Type a number: "); 
    int number = Integer.parseInt(reader.nextLine()); 
    if (moreThanOnce(numbers, number)) { 
        System.out.println(number + " appears more than once."); 
    } else { 
        System.out.println(number + " does not appear more than once."); 
    } 
} 

 
Type a number: 2 
2  appears more than once

 
Type a number: 3 
3 does not appear more than once. 

 
public static boolean palindrome(String text) { 
    // write your code here
} 

public static void main(String[] args) { 
    Scanner reader = new Scanner(System.in); 
   
    System.out.println("Type a text: "); 
    String text = reader.nextLine();    
    if (palindrome(text)) { 
	   System.out.println("The text is a palindrome!"); 
    } else { 
	   System.out.println("The text is not a palindrome!"); 
    } 
} 

 
Type a text: madam 
The text is a palindrome!

 
Type a word: example 
The text is not a palindrome!

Methods and the copying of parameters

Let us focus on a couple of details concerning methods.

In section 15 there was an example, in which we tried to change the value of a main program variable inside a method.

 
public static void main(String[] args) { 
  int number = 1; 
  addThree(); 
  System.out.println("Main program variable number holds the value: " + number); 
} 

public static void addThree() { 
  number = number + 3; 
} 

This program of ours does not work, because the method cannot access the main program variable number.

That is because main program variables are not visible to the methods. And more generally: no method variable is visible to other methods. Because the main program main is also a method, this holds for the main program as well. The only way to give information to a method is to use parameters.

Let us try to fix the above example by passing the main program variable number to the method as a parameter.

 
public static void main(String[] args) { 
  int number = 1; 
  addThree(number); 
  System.out.println(number);  // prints 1, the value did not change
} 

public static addThree(int number) { 
  number = number + 3; 
} 

The program still does not work the way we want. The method parameters are different variables than the ones introduced in the main program. In the previous example the method increments a variable with the same name as the main program variable. The parameter has the same name, but is not the same as the main program variable number.

When a parameter is given to a method, the value of the parameter is copied into a new variable and that new variable is the one the method uses. In the example above the variable number that was given to the method addThree as a parameter will be copied and then the copy is actually handed out to the method to use. The method uses only a copy of the variable from the main program, not the original variable. The main program variable number stays unchanged.

We can imagine that the main program method main and the method addThree both work in their own parts of the computer memory. In the picture below there is a "box" for the value of the variable number of the main method. When the method is called, a new "box" named number will be created and the main method variable number's value will be copied into it. In this example the number is 1. Both variables that are called number are separate, therefore when the method addThree changes the value of its own variable called number it does not affect the variable number in the main program.

The picture below will demonstrate what happens.

The method can still naturally pass information to the caller, that happens by using a return value (i.e. using a return command to return a variable with a value). We can get the previous example to work by changing the code a little bit:

 
public static void main(String[] args) { 
  int number = 1; 
  number = addThreeAndReturn(number); 

  System.out.println(number);  // prints 4, because number has the method return value as its value        
} 

public static int addThreeAndReturn(int number) { 
  number = number + 3; 
 
  return number; 
} 

The method still uses the copy of the main program variable number. In the main program we assign the variable number the method return value as a new value, so that we can get the change to take effect in the main program. Note that the name of the method variable plays no role here. The code works exactly the same regardless of the names. Here follows an example:

 
public static void main(String[] args) { 
  int number = 1; 
  number = addThreeAndReturn(number); 

  System.out.println(number);            
} 

public static int addThreeAndReturn(int incremented) { 
  incremented = incremented + 3; 

  return incremented; 
} 

We found out that the parameters in methods are different variables than the variables introduced in the method call. Only the parameter value gets copied from the caller to the method.

Unfortunately it is not that simple. If a method gets an ArrayList as a parameter, the method sees the original list and all the changes the method makes will take effect everywhere.

 
    public static void removeFirst(ArrayList<Integer> list) { 
        list.remove(0); // removes the number from index 0
    }  

 
    ArrayList<Integer> numbers = new ArrayList<Integer>(); 
    numbers.add(4); 
    numbers.add(3); 
    numbers.add(7); 
    numbers.add(3); 
        
    System.out.println(numbers); // prints [4,3,7,3] 
        
    removeFirst(numbers); 

    System.out.println(numbers); // prints [3,7,3] 

Unlike a parameter of int type, a list will not be copied and therefore the method makes changes to the original list given as a parameter.

The picture below will clarify the example. ArrayList does not live in an imagined "box" like an int. The variable name in the example numbers is only a reference that refers to the place where the ArrayList is. One way to visualize this is that an ArrayList is connected with a wire. The name of the ArrayList is a "wire", and the list itself is located "in the other end of the wire". When we give the ArrayList to a method as a parameter we actually give the method a wire, and when the method uses its parameter it finds the original list at the other end of it. Actually the main program and the method do have separate wires, but both wires have the same original list at the end of them and all the changes will be made directly to the original list. During and after this week we will find out that many things in Java are "connected with a wire".

Note that again the parameter name inside the method can be anything. It does not need to be the same as the name in the main program (or other method that calls it). In the example above the method uses the name list but the method caller sees the same list with a different name, numbers.

But why does the value of the parameter get copied and the original variable stay intact when the parameter is of int type but the original list is given to the method when the parameter is of ArrayList type? In Java only the values of primitive data types (which are int, double, char, boolean and a couple of others that we have not yet discussed) get copied to the method. When the method parameters are of other types only the references are copied to the method. A reference is like a "wire", therefore the method can access the list using it directly. The variables that are not of primitive data types are of reference data types and are "wired" just like the ArrayList in the previous example. The method is given to the wire and the method can access the parameter directly.

 
    ArrayList<Integer> list1= new ArrayList<Integer>(); 
    ArrayList<Integer> list2= new ArrayList<Integer>();  
    
    list1.add(4); 
    list1.add(3); 
    
    list2.add(5); 
    list2.add(10); 
    list2.add(7); 
    
    combine(list1, list2); 
    
    System.out.println(list1); // prints [4, 3, 5, 10, 7] 

    System.out.println(list2); // prints [5, 10, 7] 

Instructions on code-writing and problem solving

One of the leading software developers, Kent Beck, has said:

• "Any fool can write code that a computer can understand. Good programmers write code that humans can understand."
• "I'm not a great programmer, I'm just good programmer with great habits."

We are now, at the latest, taking the first steps towards that goal.

Well indented and "breathing" code

Let us take a look at a code that first adds numbers to a list and then prints the list items. After that all instances of a certain number are removed from the list and the list gets printed.

First we write the code badly and without indentations:

 
public static void main(String[] args) { 
ArrayList<Integer> numbers = new ArrayList<Integer>(); 
numbers.add(4); 
numbers.add(3); 
numbers.add(7); 
numbers.add(3); 
System.out.println("The numbers in the beginning:"); 
for (int number : numbers) { 
System.out.println(number); 
} 
while (numbers.contains(Integer.valueOf(3))) { 
numbers.remove(Integer.valueOf(3)); 
} 
System.out.println("The numbers after removal:"); 
for (int number : numbers) { 
System.out.println(number); 
} 

Even though the unindented code works, it is unpleasant to read. Let us indent the code (you can get NetBeans to auto-indent your code by pressing alt+shift+f) and separate logical parts with line breaks:

 
    public static void main(String[] args) { 
        ArrayList<Integer> numbers = new ArrayList<Integer>(); 
        numbers.add(4); 
        numbers.add(3); 
        numbers.add(7); 
        numbers.add(3); 
        
        System.out.println("The numbers in the beginning:"); 
        
        // here we print numbers 
        for (int number : numbers) { 
            System.out.println(number); 
        } 
        
        // checks if the list contains the number 3 
        while (numbers.contains(Integer.valueOf(3))) { 
            numbers.remove(Integer.valueOf(3));  // if yes, it is removed
        } 
        // we use a while structure to get all the threes removed!
        
        System.out.println("The numbers after removal:"); 
        
         // here we print numbers
        for (int number : numbers) { 
            System.out.println(number); 
        } 

Now the code starts to make sense. For example, the printing and the number removal are two logical parts, therefore they are separated with line breaks. The code is airy and reading the code is much more pleasant.

There are even comments in the code to help the reader understand what happens where!

Getting rid of copy-paste with methods

The original sin of a programmer is to create copy-paste code, which means using the same code in multiple places by copy-pasting it around. In our example the printing of the list is done twice. The code that handles the printing part should be separated as its own method and then call the method from the main program:

    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<Integer>();
        numbers.add(4);
        numbers.add(3);
        numbers.add(7);
        numbers.add(3);
        
        System.out.println("The numbers in the beginning:");

        // here we print numbers
        print(numbers);
        
        while (numbers.contains(Integer.valueOf(3))) {
            numbers.remove(Integer.valueOf(3));
        }
        
        System.out.println("The numbers after removal:");
        
        // here we print numbers
        print(numbers);
    }

    public static void print(ArrayList<Integer> numbers) {
        for (int number : numbers) {
            System.out.println( number );
        }
    }

Slicing separate tasks into methods with descriptive names

The code has become even more easy to read. A distinctively separate entity, the printing of the list is now a method that is easy to understand. By defining a new method the readability of the main program has improved. Pay attention to the descriptive name of the method: the name says exactly what the method does. Next we can remove the advising comments here we print numbers , because the method name speaks for itself.

There is still room for improvements in the program. The main program still looks a bit messy, since there is an "unaesthetic" code line that directly manipulates the list, in between the neat method calls. Let us turn also that unaesthetic piece of code into a method:

    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<Integer>();
        numbers.add(4);
        numbers.add(3);
        numbers.add(7);
        numbers.add(3);
        
        System.out.println("The numbers in the beginning:");
        print(numbers);
        
        remove(numbers, 3);
        
        System.out.println("The numbers after removal:");
        print(numbers);
    }

    public static void print(ArrayList<Integer> numbers) {
        for (int number : numbers) {
            System.out.println( number );
        }
    }

    public static void remove(ArrayList<Integer> numbers, int removed) {
        while (numbers.contains(Integer.valueOf(removed))) {
            numbers.remove(Integer.valueOf(removed));
        }
    }

In the example above we created a new descriptively named method out of a separate logical entity, i.e. removing all the instances of a certain number. The resulting main program is now very understandable - almost like natural language. Both methods are very simple and easy to understand as well.

Kent Beck might be proud of what we have accomplished. The code is easy to understand, easy to modify and does not include any copy-paste.

Object-oriented programming

Before we begin, here's a little intro to object-oriented programming.

In procedural programming - which is the way of programming we've been studying so far - a program is divided in to smaller parts, methods. A method works as a separate part of a program and it can be called from anywhere in the program. When a method is called, execution of the program moves to the beginning of the called method. After execution of the method is done, the program will continue from where the method was called.

In object oriented programming, just like in procedural programming, we attempt to divide a program into smaller parts. In object-oriented programming the small parts are objects. Each separate object has its own individual responsibility; an object contains a related group of information and functionality. Object-oriented programs consist of multiple objects which together define how the program works.

Object

We've used many of the ready-made objects in Java already. For example, ArrayLists are objects. Each separate list consists of information related to it; that is, the state of the object. Functionality is also contained in the list objects: the methods by which the state of the object can be altered. As an example there's two ArrayList objects in the following piece of code, cities and countries :

    public static void main(String[] args) {
        ArrayList<String> cities = new ArrayList<String>();
        ArrayList<String> countries = new ArrayList<String>();

        countries.add("Finland");
        countries.add("Germany");
        countries.add("Netherlands");

        cities.add("Berliini");
        cities.add("Nijmegen");
        cities.add("Turku");
        cities.add("Helsinki");
        
        System.out.println("number of countries " + countries.size() );
        System.out.println("number of cities " + cities.size() );
    }

Both the countries object and the cities object live a life of their own. The state of each is not related to the state of the other. For example, the state of the countries object consists of the Strings "Finland", "Germany" and "Netherlands" that are on the list, probably also the information of how many countries are in the list.

When doing a method call related to an object (for example, countries.add("Finland");), the name of the object whose method is being called goes to the left side of the period and to the right side goes the name of the method itself. When asking how many Strings the countries list has we will call countries.size(), so we are calling the method size of the object countries. What the method returns depends on the state of the object in question, other objects don't affect the execution of the method in any way.

We've used the command new many times already. For example the creation of a list (ArrayList) and the creation of a reader (Scanner) have happened with the command new. The reason is that both of these are classes from which the object is created. in Java, objects are always created with new, except in a few cases.

One of the cases where you don't always need to use new is in the construction of Strings. The familiar way to create a String is actually an abbreviated way of using new. A String can also be created with new just like any other object:

        String text = "some text";       // abbreviated way of creating a String
        String anotherText = new String("more text");  

Cases in which Java's ready-made parts call new out of sight of the programmer also exist.

Class

It is clear that all objects aren't similar to one another. For example, ArrayList objects differ drastically from String objects. All ArrayLists have the same methods code>add, contains, remove, size, ... and respectively all String objects have the same methods (substring, length, charAt, ...). Arraylist and String objects don't have the same methods because they're different types of objects.

The type of a certain group of objects is called a class. ArrayList is a class, so are String, Scanner, and so forth. Objects on the other hand are instances of classes.

Objects of the same class all have the same methods and a similar state. For example, the state of an ArrayList object consists of elements inserted to the list while the state of a String object consists of a string of characters.

Class and its objects

Class defines what kind of objects it has:

• what methods the object has
• what the state of the object is, or in other words, what kind of attributes the object has

A class describes the "blueprint" of the objects that are made out of it.

Lets take an analogy from the world outside of computers: the blueprints of a house. The blueprints define how the building is to be built and in that way dictate the shape and size of it. The blueprints are the class, they define the general characteristics of the objects created out of that class:

Individual objects, the houses in our analogy, are made from that same blueprint. They are instances of the same class. The state of individual objects, the attributes, can vary (color of the walls, the building material of the roof, doors, windowsills, etc...). Here's one instance of a House object:

An object is always created from its class by calling the method - the constructor - that creates the object with the command new. For example, a new instance is created from the class Scanner by calling new Scanner(..):

    Scanner reader = new Scanner(System.in);

Constructors take parameters the way any other method does.

Account bartosAccount = new Account("Barto's account",100.00);
Account bartosSwissAccount = new Account("Barto's account in Switzerland",1000000.00);

System.out.println("Initial state");
System.out.println(bartosAccount);
System.out.println(bartosSwissAccount);

bartosAccount.withdrawal(20);
System.out.println("Barto's account balance is now: "+bartosAccount.balance());
bartosSwissAccount.deposit(200);
System.out.println("Barto's Swiss account balance is now: "+bartosSwissAccount.balance());

System.out.println("Final state");
System.out.println(bartosAccount);
System.out.println(bartosSwissAccount);

Defining your own class - object variables

A class is defined to serve some meaningful whole. Often a "meaningful whole" represents something from the real world. If a computer program needs to handle personal data it could be sensible to define a separate class Person which then holds methods and attributes related to an individual.

Let us go ahead and assume that we have a project frame with an empty main program:

public class Main {

    public static void main(String[] args) {       
    }

}

We will create a new class in our project. In NetBeans this can be done in projects on the left, from the right click menu select new, java class. We'll name the class in the dialog that pops up.

Just like with variables and methods the name of the class should always be as descriptive as possible. Sometimes as a project progresses a class might transform into something different in order meet the programmer's needs. In situations like this it's possible to rename your class with ease (see the NetBeans guide).

Lets create a class named Person. The class will exist in its own Person.java file. So since the main program is in its own file the program now consists of two files total. At first the class will be empty:

public class Person {

}

The class has to define what methods and attributes the objects created from the class will have. Let us decide that each person has a name and an age. It feels natural to represent the name as a String and the age as an integer. Let us add this to our schematics:

public class Person {
    private String name;
    private int age;
}

Above we defined that all instances created from the Person class have a name and an age. Defining the attributes happens a little like how it happens with normal variables. In this case though there's the keyword private in front of them. This means that name and age won't show outside of the object, but instead are hidden within it. Hiding things within an object is called encapsulation.

Variables defined within a class are called object variables, object fields or object attributes. A beloved child has many names.

So, we've defined the schematics -- the class -- for the person object. All person objects have the variables name and age. The 'state' of the objects is determined by the values that have been set to its variables.

Defining your own class - constructor, or "formatting the state"

When an object is created its starting state is defined at the same time. Self-defined objects are created for the most part in the same way as ready-made objects (ArrayLists for example) are created. Objects are created with the new command. When creating an object it'd be handy to be able to set the values of some of the variables of the object.

    public static void main(String[] args) {
        Person bob = new Person("Bob");
        // ...
    }

This can be achieved by defining the object creating method, the constructor. The constructor for the Person class that creates a new Person object has been defined in the following. In the constructor the person that is being created gets 0 as its age and its name it gets from the parameter of the constructor.

public class Person {
    private String name;
    private int age;

    public Person(String initialName) {
        this.age = 0;
        this.name = initialName;       
    }
}

The constructor always has the same name as the class. In the code above, the class is Person and the constructor is public Person(String initialName). The value the constructor receives as a parameter is in parentheses after the name of the constructor. You can imagine the constructor as a method that Java runs when an object is created with the command new Person("Bob"); Whenever an object is created from a class, the constructor of that class is called.

A few notes: within the constructor there's a command this.age = 0. With it we set a value of this particular object; we set the internal variable age of "this" object. Another command is this.name = initialName;, again we give the internal variable name the String that is defined in the constructor. The variables age and name show in the constructor and elsewhere in the object automatically. They are referred to with the this prefix. Due to the private modifier the variables can't be seen from outside the object.

One more thing: if the programmer doesn't create a constructor for the class, Java will automatically create a default one for it. A default constructor is a constructor that does nothing. So if you for some reason don't need a constructor you don't need to write one.

Class definition - methods

We already know how to create and initialize objects. However, objects are useless if they cannot do anything, so objects should have methods. Let us add to Person class a method that prints the object to screen:

public class Person {
    private String name;
    private int age;

    public Person(String nameAtStart) {
        this.age = 0;
        this.name = nameAtStart;       
    }

    public void printPerson() {
        System.out.println(this.name + ", age " + this.age + " years");
    }
}

As seen, the method is written within the class. The method name is prefixed with public void since it is assumed that users of the object should be capable of using the method and the method should not return anything. With objects the keyword static is not used in method definitions. Next week we will clarify the reason behind that.

Inside the method printPerson there is a single line of code that uses the object variables name and age. The prefix this is used to emphasize that we are referring to the name and age of this object. All the object variables are visible from all the methods of the object.

Let us create three persons and ask them to print themselves:

public class Main {

    public static void main(String[] args) {
        Person pekka = new Person("Pekka");
        Person brian = new Person("Brian");
        Person martin = new Person("Martin");

        pekka.printPerson();
        brian.printPerson();
        martin.printPerson();
    }
}

The output is:

Pekka, age 0 years
Brian, age 0 years
Martin, age 0 years

More methods

Let us create a method that can be used to increase the age of a person by one:

public class Person {
    // ...

    public void becomeOlder() {
        this.age++;;    // same as this.age = this.age + 1;
    }
}

As expected, the method is written inside the class Person. The method increases the value of object variable age by one.

Let us call the method and see what happens:

public class Main {

    public static void main(String[] args) {
        Person pekka = new Person("Pekka");
        Person andrew = new Person("Andrew");

        pekka.printPerson();
        andrew.printPerson();

        System.out.println("");

        pekka.becomeOlder();
        pekka.becomeOlder();

        pekka.printPerson();
        andrew.printPerson();
    }
}

Output:

Pekka, age 0 years
Andrew, age 0 years

Pekka, age 2 years
Andrew, age 0 years

When born, both objects have age 0 due to the line this.age = 0; in the constructor. Method becomeOlder of object pekka is called twice. As the output shows, this causes the age of pekka to increase by two. It should be noted that when the method becomeOlder is called to object pekka, the other object andrew is not touched at all and he remains at age 0. So the state of an object is independent of the other objects!

Also the object methods can return a value to the caller of the method. Let us define a method that can be used to ask for the age of a person:

public class Person {
    // ...

    public int getAge() {
        return this.age;
    }
}

Now the void in the method definition is replaced with int since the value the method returns has the type integer. The following example demonstrates how the value returned by a method can be used:

public class Main {

    public static void main(String[] args) {
        Person pekka = new Person("Pekka");
        Person andrew = new Person("Andrew");

        pekka.becomeOlder();
        pekka.becomeOlder();

        andrew.becomeOlder();

        System.out.println( "Age of Pekka: "+pekka.getAge() );
        System.out.println( "Age of Andrew: "+andrew.getAge() );

        int total = pekka.getAge() + andrew.getAge();

        System.out.println( "Pekka and Andrew total of "+total+ " years old" );
    }
}

Output:

Age of Pekka: 2
Age of Andrew: 1 

Pekka and Andrew total of 3 years old

Multiplier threeMultiplier = new Multiplier(3);
System.out.println("threeMultiplier.multiply(2): " + threeMultiplier.multiply(2));

Kertoja fourMultiplier = new Multiplier(4);
System.out.println("fourMultiplier.multiply(2): " + fourMultiplier.multiply(2));

System.out.println("threeMultiplier.multiply(1): " + threeMultiplier.multiply(1));
System.out.println("fourMultiplier.multiply(1): " + fourMultiplier.multiply(1));

threeMultiplier.multiply(2): 6
fourMultiplier.multiply(2): 8
threeMultiplier.multiply(1): 3
fourMultiplier.multiply(1): 4

public class DecreasingCounter {
    private int value;   // object variable that remembers the value of the counter
    
    public DecreasingCounter(int valueAtStart) {
        this.value = valueAtStart;
    }

    public void printValue() {
        System.out.println("value: " + this.value);  
    }

    public void decrease() {
        // write here the code that decrements the value of counter by one
    }
    
    // and here the rest of the methods
}

public class Main {
    public static void main(String[] args) {
        DecreasingCounter counter = new DecreasingCounter(10);
        
        counter.printValue();
        
        counter.decrease();
        counter.printValue();

        counter.decrease();
        counter.printValue();
    }
}

value: 10
value: 9
value: 8

public class Main {
    public static void main(String[] args) {
        DecreasingCounter counter = new DecreasingCounter(2);
        
        counter.printValue();
        
        counter.decrease();
        counter.printValue();

        counter.decrease();
        counter.printValue();

        counter.decrease();
        counter.printValue();
    }
}

value: 2
value: 1
value: 0
value: 0

public class Main {
    public static void main(String[] args) {
        DecreasingCounter counter = new DecreasingCounter(100);
        
        counter.printValue();
        
        counter.reset();
        counter.printValue();

        counter.decrease();
        counter.printValue();
    }
}

value: 100
value: 0
value: 0

public class Main {
    public static void main(String[] args) {
        DecreasingCounter counter = new DecreasingCounter(100);
        
        counter.printValue();
        
        counter.decrease();
        counter.printValue();

        counter.decrease();
        counter.printValue();

        counter.zero();
        counter.printValue();

        counter.setInitial();
        counter.printValue();
    }
}

value: 100
value: 99
value: 98
value: 0
value: 100

import java.util.ArrayList;

public class Menu {

    private ArrayList<String> meals;

    public Menu() {
        this.meals = new ArrayList<String>();
    }

    // Implement the methods here
}

Hamburger
Fish'n'Chips
Sauerkraut

The Person class grows

Let us get back to working on the Person class. The current version of the class looks like this:

public class Person {
    private String name;
    private int age;

    public Person(String initialName) {
        this.age = 0;
        this.name = initialName;      
    }

    public void printPerson() {
        System.out.println(this.name + ", age " + this.age + " years");
    }

    public void becomeOlder() {
        this.age = this.age + 1;
    }
}

Let us create a method for person, with which we can figure out if a person is an adult. The method returns a boolean -- either true or false:

public class Person {
    // ...

    public boolean isAdult(){
        if ( this.age < 18 ) {
            return false;
        }

        return true;
    }

   /*
      note that the method could also be written like this:
  
      public boolean isAdult(){
        return this.age >= 18;
      }
   */
}

Lets test it:

    public static void main(String[] args) {
        Person bob = new Person("Bob");
        Person andy = new Person("Andy");

        int i = 0;
        while ( i < 30 ) {
            bob.becomeOlder();
            i++;
        }

        andy.becomeOlder();

        System.out.println("");

        if ( andy.isAdult() ) {
            System.out.print("adult: ");
            andy.printPerson();
        } else {
            System.out.print("minor: ");
            andy.printPerson();
        }

        if ( bob.isAdult() ) {
            System.out.print("adult: ");
            bob.printPerson();
        } else {
            System.out.print("minor: ");
            bob.printPerson();
        }
    }

minor: Andy, age 1 years
adult: bob, age 30 years

Let us tune up the solution a little further. Now a person can only be printed so that in addition to the name, the age also gets printed out. In some cases we might only want the name of the object. Let us tailor up a method for the purpose:

public class Person {
    // ...

    public String getName() {
        return this.name;
    }
}

The method getName returns the object variable name to its caller. The name of the method might seem a little odd (or not). In Java it is considered the 'correct' way to name an object-variable-returning method in this manner; as getVariableName. Methods like these are often called 'getters'.

Let us edit the main program to use the new 'getter':

    public static void main(String[] args) {
        Person bob = new Person("bob");
        Person andy = new Person("andy");

        int i = 0;
        while ( i < 30 ) {
            bob.becomeOlder();
            i++;
        }

        andy.becomeOlder();

        System.out.println("");

        if ( andy.isAdult() ) {
            System.out.println( andy.getName() + " is an adult" );
        } else {
            System.out.println( andy.getName() + " is a minor" );
        }

        if ( bob.isAdult() ) {
            System.out.println( bob.getName() + " is an adult" );
        } else {
            System.out.println( bob.getName() + " is a minor" );
        }
    }

The print is starting to look pretty clean:

andy is a minor
bob is an adult

toString

We've been partially guilty of a bad programming style; we've created a method with which the object is printed, the printPerson one. The recommended way of doing this is by defining a method that returns a "character string representation" of the object. In Java a method returning a String representation is always called toString. Let us define this method for person:

public class Person {
    // ...

    public String toString() {
        return this.name + ", age " + this.age + " years";
    }
}

The method toString works just like printPerson, but instead of printing it returns the string representation, so the calls to the method can be used for printing at will.

The method is used in a slightly surprising way:

    public static void main(String[] args) {
        Person bob = new Person("Bob");
        Person andy = new Person("Andy");

        int i = 0;
        while ( i < 30 ) {
            bob.becomeOlder();
            i++;
        }

        andy.becomeOlder();

        System.out.println( andy ); // same as System.out.println( andy.toString() ); 
        System.out.println( bob ); // same as System.out.println( bob.toString() ); 
    }

The principle is, that System.out.println-method requests the string representation of an object and then prints it. The string representation returning toString-method doesn't have to be written, since Java adds it automatically. When the programmer writes:

        System.out.println( andy );      

Java completes the call during runtime to the format:

        System.out.println( andy.toString() );

This means that an object gets asked for it's string representation. The string representation the object returns gets printed out normally with the System.out.println-command.

We can get rid of the obsolete printObject-method.

public class LyyraCard {
    private double balance;

    public LyyraCard(double balanceAtStart) {
        // write code here
    }

    public String toString() {
        // write code here
    }
}

public class Main {
    public static void main(String[] args) {
        LyyraCard card = new LyyraCard(50);
        System.out.println(card);
    }
}

The card has 50.0 euros

    public void payEconomical() {
        // write code here
    }

    public void payGourmet() {
        // write code here
    }

public class Main {
    public static void main(String[] args) {
        LyyraCard card = new LyyraCard(50);
        System.out.println(card);

        card.payEconomical();
        System.out.println(card);

        card.payGourmet();
        card.payEconomical();
        System.out.println(card);
    }
}

The card has 50.0 euros
The card has 47.5 euros
The card has 41.0 euros

public class Main {
    public static void main(String[] args) {
        LyyraCard card = new LyyraCard(5);
        System.out.println(card);

        card.payGourmet();
        System.out.println(card);

        card.payGourmet();
        System.out.println(card);
    }
}

The card has 5.0 euros
The card has 1.0 euros
The card has 1.0 euros

    public void loadMoney(double amount) {
        // write code here
    }

public class Main {
    public static void main(String[] args) {
        LyyraCard card = new LyyraCard(10);
        System.out.println(card);

        card.loadMoney(15);
        System.out.println(card);

        card.loadMoney(10);
        System.out.println(card);

        card.loadMoney(200);
        System.out.println(card);
    }
}

The card has 10.0 euros
The card has 25.0 euros
The card has 35.0 euros
The card has 150.0 euros

public class Main {
    public static void main(String[] args) {
        LyyraCard card = new LyyraCard(10);
        System.out.println(card);
        card.loadMoney(-15);
        System.out.println(card);
    }
}

The card has 10.0 euros
The card has 10.0 euros

public class Main {
    public static void main(String[] args) {
        LyyraCard cardPekka = new LyyraCard(20);
        LyyraCard cardBrian = new LyyraCard(30);

        // write code here
    }
}

Pekka: The card has 16.0 euros
Brian: The card has 27.5 euros
Pekka: The card has 36.0 euros
Brian: The card has 23.5 euros
Pekka: The card has 31.0 euros
Brian: The card has 73.5 euros

More methods

Let us continue with the class Person. We would be interested in knowing the body mass index of a person. To calculate that information we need to know height and weight of persons. We add for both the height and the weight object variables and methods that can be used to assign the variables a value. After those are in place, we can add also the method that counts the body mass index. Class after the changes (only the parts affected by the change shown):

   public class Person {
    private String name;
    private int age;
    private int weight;
    private int height;

    public Person(String initialName) {
        this.age = 0;
        this.name = initialName;    
        this.weight = 0;
        this.height = 0;  
    }

    public void setHeight(int newHeight) {
        this.height = newHeight;
    }

    public void setWeight(int newWeight) {
        this.weight = newWeight;
    }

    public double bodyMassIndex(){
        double heightDividedByZero = this.height / 100.0;
        return this.weight / ( heightDividedByZero * heightDividedByZero );
    }

    // ...
}      

We added object variables height and weight and methods setHeight and setWeight that can be used to give values to the variables. In naming of the methods we follow the Java convention to call a method that just sets a variable a new value setVariableName, this type of methods are usually called setter methods.

The new methods in use:

    public static void main(String[] args) {
        Person matti = new Henkilo("Matti");
        Person john = new Henkilo("John");

        matti.setHeight(180);
        matti.setWeight(86);
        
        john.setHeight(175);
        john.setWeight(64);
        
        System.out.println( matti.getName() + ", body mass index: " + matti.bodyMassIndex() );
        System.out.println( john.getName() + ", body mass index: " + john.bodyMassIndex() );

Output:

Matti, body mass index: on 26.54320987654321
John, body mass index: on 20.897959183673468

Object variable and parameter with identical name

In above the method setHeight assigns the objec variable height the value of the parameter newHeight:

    public void setHeight(int newHeight) {
        this.height = newHeight;
    }

Parameter could also be named identically with the object variable:

    public void setHeight(int height) {
        this.height = height;
    }

Now the name height menans the parameter height and the identically named object variable is referred with this.height. The following would not work since the object variable height is not referred at all in the code:

    public void setHeight(int height) {
        // DOES NOT WORK!
        height = height; 
        // this just assigns the value of the parameter to the parameter itself
    }

Contolling the number of decimals when printing a float

The number of decimals in last output was far too high, two decimals would be enough. One technique to control how a float number is printed is to use the command String.format.

If value is float, the command String.value( "%.2f", value ) returns a string where the value is rounded to contain 2 decimals. The number between dot and f defines the amount of decimals shown.

So after changing the code to the following:

    System.out.println( matti.getName() + ", body mass index: " + String.format( "%.2f", matti.bodyMassIndex() ) );
    System.out.println( john.getName() + ", body mass index: " + String.format( "%.2f", john.bodyMassIndex() ) );

The output is:

Matti,  body mass index: 26,54
John,  body mass index: 20,90

Method String.format is perhaps not the most flexible way that Java provides for formatting float values but it is simple to use and suits well to our purposes.

public class BoundedCounter {
    private int value;
    private int upperLimit;

    public BoundedCounter(int upperLimit) {
        // write code here
    }

    public void next() {
        // write code here
    }

    public String toString() {
        // write code here
    }
}

public class Main {
    public static void main(String[] args) {
        BoundedCounter counter = new BoundedCounter(4);
        System.out.println("Value at start: " + counter );

        int i = 0; 
        while ( i < 10) {
            counter.next();
            System.out.println("Value: " + counter );
            i++;
        }
    }
}

Value at start: 0
Value: 1
Value: 2
Value: 3
Value: 4
Value: 0
Value: 1
Value: 2
Value: 3
Value: 4
Value: 0

public class Main {
    public static void main(String[] args) {
        BoundedCounter counter = new BoundedCounter(14);
        System.out.println("Value at start: " + counter );

        int i = 0; 
        while ( i < 16){
            counter.next();
            System.out.println("value: " + counter );
            i++; 
        }
    }
}

value at start: 00
value: 01
value: 02
value: 03
value: 04
value: 05
value: 06
value: 07
value: 08
value: 09
value: 10
value: 11
value: 12
value: 13
value: 14
value: 00
value: 01

    public int getValue() {
        // write here code that returns the value
    }

public class Main {
    public static void main(String[] args) {
        BoundedCounter minutes = new BoundedCounter(59);
        BoundedCounter hours = new BoundedCounter(23);     

        int i = 0;
        while ( i < 121 ) {
            System.out.println( hours + ":" + minutes);   // the current time printed
            // advance minutes
            // if minutes become zero, advance hours
            i++;
        }
    }
}

00:00
00:01
...
00:59
01:00
01:01
01:02
...
01:59
02:00

public class Main {
    public static void main(String[] args)  {
        Scanner lukija = new Scanner(System.in);
        BoundedCounter seconds = new BoundedCounter(59);
        BoundedCounter minutes = new BoundedCounter(59);
        BoundedCounter hours = new BoundedCounter(23);

        System.out.print("seconds: ");
        int s = // ask the initial value of seconds from the user
        System.out.print("minutes: ");
        int m = // ask the initial value of minutes from the user
        System.out.print("hours: ");
        int h = // ask the initial value of hours from the user

        seconds.setValue(s);
        minutes.setValue(m);
        hours.setValue(h);

        int i = 0;
        while ( i < 121 ) {
          // like in previous but seconds taken into account
         i++;
        }

    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        BoundedCounter seconds = new BoundedCounter(59);
        BoundedCounter minutes = new BoundedCounter(59);
        BoundedCounter hours = new BoundedCounter(23);

        seconds.setValue(50);
        minutes.setValue(59);
        hours.setValue(23);

        while ( true ) {
            System.out.println( hours + ":" + minutes + ":" + seconds );
            Thread.sleep(1000);
            // put here the logic to advance your clock by one second
        }
    }
}

Important notes regarding the use of objects. Make sure to read these.

Object oriented programming is mostly about turning concepts in to their own entirities, or in other words forming abstractions. One might think that it's pointless to create an object that only holds one number in it, and that the same could be achieved with simple int variables. This is not the case. If a clock consists of just 3 int variables that are then increased, the program loses some human readability. It becomes more difficult to "see" what the program is about. Earlier in the material we mentioned the advice of the renown programmer Kent Beck: "Any fool can write code that a computer can understand. Good programmers write code that humans can understand", since a hand of a clock is actually it's own clearly definable concept, it is a good idea to create it it's own class - BoundedCounter - for the sake of human readability.

Turning a concept in to a class of it's own is a good idea for a lot of reasons. Firstly some details (ie. when the counter makes a full round) can be hidden inside the class (abstracted). Instead of writing an if-clause and an assignment operation, it is enough that the user of the counter calls the descriptively named method next(). In addition to clocks the created counter might be good for being used as a building block for other projects too, so a class made from a clear concept can be very versatile. Another huge advantage we gain by writing code this way is that when the details of the mechanics are hidden they can be changed if need be.

We established that a clock contains three hands, it consists of three concepts. Actually the clock itself is a concept too and next week we'll make the class Clock, so we can create distinct Clock objects. Clock will be an object of which functionality is based on "simpler" objects, the hands. This is the grand idea of object oriented programming: a program is built out of small, clearly defined co-operating objects.

Now we'll take some careful first steps in the object world. Towards the end of the course, objects will start to come to you naturally and the idea of programs being built out of small, well defined, co-operating pieces - which at this point might feel incomprehensible - will become something you'll take for granted.

Calling other methods within object

Objects can call also in's own methods. Let us assume we'd like to include body mass index in the string representation of the person objects. Instead of calculationg the body mass index in toString method, a better idea is to call the method bodyMassInded from the Jos esim. halutaan, että toString-metodin palauttama merkkijonoesitys kertoisi myös henkilön painoindeksin, kannattaa istä kutsua olion omaa metodia toString method:

    public String toString() {
        return this.name + ", age " + this.age + " years, my body mass index is " + this.bodyMassIndex();
    }

As can be seen, object can call it's own method by prefixing the method name with this and dot. The this is not necessary, so also the below works:

    public String toString() {
        return this.name + ", age " + this.age + " years, my body mass index is " + bodyMassIndex();
    }

Nyt on aika harjoitella lisää yksinkertaisten olioiden tekemistä käytännössä:

public class NumberStatistics {
    private int amountOfNumbers;

    public NumberStatistics() {
        // initialize here the object variable amountOfNumbers
    }
    
    public void addNumber(int number) {
        // code here
    }

    public int amountOfnumbers() {
        // code here
    }
}

public class Main {
   public static void main(String[] args) {
      NumberStatistics stats = new NumberStatistics();
      stats.addnumber(3);
      stats.addnumber(5);
      stats.addnumber(1);
      stats.addnumber(2);
      System.out.println("Amount: " + stats.amountOfNumbers());
    }
}

Amount: 4

public class NumberStatistics {
    private int amountOfNumbers;
    private int sum;

    public NumberStatistics() {
        // initialize here the object variable amountOfNumbers
    }
    
    public void addnumber(int luku) {
        // code here
    }

    public int amountOfNumbers() {
        // code here
    }

    public int sum() {
        // code here
    }

    public double average() {
        // code here
    }
}

public class Main {
    public static void main(String[] args) {
        NumberStatistics stats = new NumberStatistics();
        stats.addnumber(3);
        stats.addnumber(5);
        stats.addnumber(1);
        stats.addnumber(2);
        System.out.println("Amount: " + stats.amountOfNumbers());
        System.out.println("sum: " + stats.sum());
        System.out.println("average: " + stats.average());
    }
}

Amount: 4
sum: 11
average: 2.75

Type numbers:
4
2
5
4
-1
sum: 15

Type numbers:
4
2
5
2
-1
sum: 13
sum of even: 8
sum of odd: 5

Randomness

When programming you may occasionally need to simulate random events. Situations such as the unpredictability of weather, or surpising moves on the AI's part in a computer game can often be simulated with random number generators, running on a computer. In Java there is a ready-made class Random, which you can use in the following way:

import java.util.Random;

public class Randomizing {
    public static void main(String[] args) {
        Random randomizer = new Random(); // creates a random number generator
        int i = 0;

        while (i < 10) {
            // Generates and prints out a new random number on each round of the loop
            System.out.println(randomizer.nextInt(10)); 
            i++;
        }
    }
}

In the code above you first create an instance of the class Random, with the keyword new -- exactly as when creating objects implementing other classes. An object of type Random has the method nextInt, to which you can give an integer value as a parameter. The method returns a random integer within the range 0..(the integer given as parameter- 1).

The printout of this program could be as follows:

2
2
4
3
4
5
6
0
7
8

We will need floating point numbers for example when dealing with probability calculations. In computing probabilities are usually calculated with figures within the range [0..1]. An object of the class Random can return random floating point numbers with the method nextDouble. Let's consider the following probabilities of weather conditions:

• Sleet with the probability 0.1 (10%)
• Snow with the probability 0.3 (30%)
• Sunny with the probability 0.6 (60%)

Using the estimates above, let's create a weather forecaster.

import java.util.ArrayList;
import java.util.Random;

public class WeatherForecaster {
    private Random random;

    public WeatherForecaster() {
        this.random = new Random();
    } 

    public String forecastWeather() {
        double probability = this.random.nextDouble();

        if (probability <= 0.1) {
            return "Sleet";
        } else if (probability <= 0.4) { // 0.1 + 0.3
            return "Snow";
        } else { // the rest, 1.0 - 0.4 = 0.6
            return "Sunny";
        } 
    }

    public int forecastTemperature() {
        return (int) ( 4 * this.random.nextGaussian() - 3 ); 
    }
}

The method forecastTemperature is interesting in many ways. Within this method we are calling the method this.random.nextGaussian(), just like any other time we've called a method in the previous examples. Interestingly, this method of the class Random returns a figure in normal distribution (if you have no interest in the different varieties of random figures, that's okay!).

    public int forecastTemperature() {
        return (int) ( 4 * this.random.nextGaussian() - 3 ); 
    }

In the expression above, just as interesting is the section (int). This part of the expression changes the bracketed floating point number into an integer value. A corresponding method transforms integer values into floating point numbers: (double) integer. This is called an explicit type conversion.

Let's create a class with a main method that uses the class WeatherForecaster.

public class Program {

    public static void main(String[] args) {
        WeatherForecaster forecaster = new WeatherForecaster();
        
        // Use a list to help you organise things 
        ArrayList<String> days = new ArrayList<String>();
        Collections.addAll(days, "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun");

        System.out.println("Weather forecast for the next week:");
        for(String day : days) {
            String weatherForecast = forecaster.forecastWeather();
            int temperatureForecast = forecaster.forecastTemperature(); 

            System.out.println(day + ": " + weatherForecast + " " + temperatureForecast + " degrees.");
        }
    }
}

The printout from this program could be as follows:

Weather forecast for the next week:
Mon: Snow 1 degrees.
Tue: Snow 1 degrees.
Wed: Sunny -2 degrees.
Thu: Sunny 0 degrees.
Fri: Snow -3 degrees.
Sat: Snow -3 degrees.
Sun: Sunny -5 degrees.

import java.util.Random;

public class Dice {
    private Random random;
    private int numberOfSides;

    public Dice(){
        random = new Random();   
    }

    public int roll( {
		  // we'll get a random number in the range 1-numberOfSides<
    }
}

public class Program {
    public static void main(String[] args) {
        Dice dice = new Dice(6);

        int i = 0;
        while ( i < 10 ) {
            System.out.println( dice.roll() );
            i++;
        }
    }
}

1
6
3
5
3
3
2
2
6
1

import java.util.Random;

public class PasswordRandomizer {
    // Define the variables here

    public PasswordRandomizer(int length) {
        // Format the variable here
    }

    public String createPassword() {
      // Write the code here which returns the new password
    }
}

public
class Program {
    public static void main(String[] args) {
        PasswordRandomizer randomizer = new PasswordRandomizer(13);
        System.out.println("Password: " + randomizer.createPassword());
        System.out.println("Password: " + randomizer.createPassword());
        System.out.println("Password: " + randomizer.createPassword());
        System.out.println("Password: " + randomizer.createPassword());
    }
}

Password: mcllsoompezvs
Password: urcxboisknkme
Password: dzaccatonjcqu
Password: bpqmedlbqaopq

int number = 17;
char symbol = "abcdefghijklmnopqrstuvxyz".charAt(number);

import java.util.ArrayList;
import java.util.Random;

public class LotteryNumbers {
    private ArrayList<Integert> numbers;

    public LotteryNumbers() {
        // We'll format a list for the numbers
        this.numbers = new ArrayList<Integert>();
        // Draw numbers as LotteryNumbers is created
        this.drawNumbers();
    }

    public ArrayList<Integert> numbers() {
        return this.numbers;
    }

    public void drawNumbers() {
        // Write the number drawing here using the method containsNumber()
    }

    public boolean containsNumber(int number) {
        // Test here if the number is already in the drawn numbers
    }
}

import java.util.ArrayList;

public class Program {
    public static void main(String[] args) {
        LotteryNumbers lotteryNumbers = new LotteryNumbers();
        ArrayList<Integert> lotteryNumbers = lotteryNumbers.numbers();

        System.out.println("Lottery numbers:");
        for (int number : lotteryNumbers) {
            System.out.print(number + " ");
        }
        System.out.println("");
    }
}

Lottery numbers:
3 5 10 14 15 27 37

Lottery numbers:
2 9 11 18 23 32 34

public class HangmanLogic {

    private String word;
    private String guessedLetters;
    private int numberOfFaults;

    public HangmanLogic(String sana) {
        this.word = word.toUpperCase();
        this.guessedLetters = "";
        this.numberOfFaults = 0;
    }

    public int numberOfFaults() {
        return this.numberOfFaults;
    }

    public String guessedLetters() {
        return this.guessedLetters;
    }
    
    public int losingFaultAmount() {
        return 12;
    }

    public void guessLetter(String letter) {
        // program here the functionality for making a guess

        // if the letter has already been guessed, nothing happens

        // it the word does not contains the guessed letter, number of faults increase
        // the letter is added among the already guessed letters
    }

    public String hiddenWord() {
        // program here the functionality for building the hidden word

        // create the hidden word by interating through this.word letter by letter
        // if the letter in turn is within the guessed words, put it in to the hidden word
        // if the letter is not among guessed, replace it with _ in the hidden word 

        // return the hidden word at the end
        
        return "";
    }
}

  HangmanLogic l = new HangmanLogic("kissa");
  System.out.println("guessing: A, D, S, F, D");
  l.guessLetter("A");   // correct
  l.guessLetter("D");   // wrong
  l.guessLetter("S");   // correct
  l.guessLetter("F");   // wrong
  l.guessLetter("D");   // This should not have effect in number of faults since D was already guessed
  System.out.println("guessed letters: "+l.guessedLetters());
  System.out.println("number of faults: "+l.numberOfFaults());

guessing: A, D, S, F, D
guessed letters: ADSF
number of faults: 2

char c = 'a';
String aString = "" + c;

HangmanLogic l = new HangmanLogic("kissa");
System.out.println("word is: "+l.hiddenWord());

System.out.println("guessing: A, D, S, F, D");
l.guessLetter("A");
l.guessLetter("D");
l.guessLetter("S");
l.guessLetter("F");
l.guessLetter("D");
System.out.println("guessed letters: "+l.guessedLetters());
System.out.println("number of faults: "+l.numberOfFaults());
System.out.println("word now: "+l.hiddenWord());

word is: _____
guessing: A, D, S, F, D
guessed letters: ADSF
number of faults: 2
word now: __SSA

        HangmanLogic logic = new HangmanLogic("parameter");
        HangmanUI game = new HangmanUI(logic);
        game.start();