This workbook covers the basics of object-oriented programming in the Java programming language. The assumption is that the user knows nothing about programming and starts “from scratch.”

It consists of a free companion book (in PDF or EPUB formats) which you are reading right now but, more importantly, a multi-volume collection of tasks which are provided as ZIP files (extras) containing complete courses for the IntelliJ Academy plugin. Solution explanation videos are also available for more complex tasks and are sold separately.

Programming is one of those skills that is best learned through practice. That’s why you often hear and read:

No one has learned to program simply by reading books or watching tutorials. Theory is essential, but it’s necessary to “roll up your sleeves” and program what you’re learning. This means: creating your own program, doing a large number of examples, trying different solution variants, analyzing and improving other people’s programs, etc.

This is exactly the motivation behind writing this workbook. There are numerous online courses, textbooks, tutorials, and educational software that contain important lessons about programming. However, there are very few interactive task collections that allow you to solidify that knowledge through concrete programming examples and diverse tasks.

Unfortunately, most of the available task collections are part of online courses, meaning that you cannot practice programming in a real-world software development environment, but through a web-browser and online-based environments with very limited features. That’s why this workbook is provided as an addition of the IDEA IntelliJ enterprise-grade software development environment (actually, its Academy plugin), so one can get used to working in such a setting where all the features and tools available to a professional programmer are present.

You can see the “about” video here.

Here are some short introductory video tutorials regarding IntelliJ, the Academy plugin, and the Interactive Java workbook just to get you started:

1. IDEA IntelliJ installation video
   • Installation for Windows
   • Installation for Linux
2. How to load the Interactive Java workbook
3. User interface explained
4. How to load the next workbook part

All of these videos, together with the ones explaining the types of tasks (see the following text) are organized in a playlist for convenience.

Programming is learned just like most other skills: gradually, from easier to harder things. For example, when someone starts learning to play tennis, they first stand still and learn to hit the ball properly. Then they practice and repeat the same move dozens and hundreds of times until they master it. Only then do they move on to the next, more difficult lessons: serving, moving on the court, etc. Only after some time and more lessons do they tackle the most difficult things and move on to playing matches.

The tasks in this workbook are organized according to the same principle. In each chapter, a concept (or multiple concepts) is introduced in a lesson, and then that concept is explored through examples. Then, various and diverse tasks are put upon the user to practice each presented concept (see the Task types overview video):

• Theory lesson (see introductory video) - technically, not a task, but a lesson with examples in code
• Question (see introductory video) - question with multiple answers
• Code completion (see introductory video) - complete the unfinished code
• Syntax correction (see introductory video) - correct all syntax errors in code
• Code correction (see introductory video) - correct the code so it functions as expected
• “Classic” task (see introductory video) - write a solution from scratch
• Alternative solution (see introductory video) - write alternative code that produces the same result

Each subsequent chapter builds on the previous ones. Therefore, you should not “skip” lessons. There are several hundred tasks in total, they are arranged according to difficulty and are divided into three categories:

• EASY (E)
• MEDIUM (M)
• HARD (H)

Specifically, if a task is named Question 8 E, it means that it is a multiple choice question, that it is the eighth in the lesson, and that it is easy (E). Or if a task is named Code Completion 6 M, it is a task of medium difficulty (M) in which you have to complete the unfinished code, and it is the sixth such task in that lesson.

There are several things that keep this workbook interactive so you can get feedback on your task solution and help if you get stuck solving a task (Video: What happens if I cannot solve a task). A predefined solution is provided for each task, and often a hint. The user’s solution is verified by running the provided code tests. A side-by-side comparison of the predefined solution and the user’s solution is also available. What if this still is not enough, and you cannot solve the task? Solution explanation videos are provided for more complex tasks to help you learn and move along.

Solution video explanations are, at this time, sold separately, and are available via Ko-fi memberships (please see here) based on a monthly subscription.

The Interactive Java workbook consists of several parts due to the many topics and even more tasks.

NOTE: Not all parts are completed at this time, but please see the Leanpub page, for updates and purchases.

This is work in progress, so the following list is not yet final. The parts and the topics they cover are as follows:

1. Interactive Java workbook part 1 - demo + full version (COMPLETED)
   • Introduction
   • Class
   • Attribute
   • Objects, program execution and output to the screen
2. Interactive Java workbook part 2 (COMPLETED)
   • Methods and arithmetic operators
   • Constructor
   • Global variables and methods
   • Constants
   • Relationships
   • Enumerated type
3. Interactive Java workbook part 3 (COMPLETED)
   • Algorithms and control statements (commands)
   • The if statement
   • The switch statement
   • The for statement
   • The while statement
   • The do-while statement
4. Interactive Java workbook part 4 (80% COMPLETED, NOT PUBLISHED YET)
   • Introduction to arrays
   • The for-each statement
   • Algorithms for working with arrays - overview
   • Search and print array elements
   • Adding elements to an array
   • Replacing array elements
5. Interactive Java workbook part 5 (80% COMPLETED, NOT PUBLISHED YET)
   • Deleting array elements
   • Group operations on array elements
   • Array sorting
   • Working with multiple strings
   • Cumulative test 1
   • Cumulative test 2
   • Cumulative test 3
   • Cumulative test 4
   • Cumulative test 5
   • Cumulative test 6
   • Cumulative test 7
   • Cumulative test 8
6. Interactive Java workbook part 6 (50% COMPLETED, NOT PUBLISHED YET)
   • Arrays of objects
   • Working with text (String, StringBuilder)
   • Working with dates and times (LocalDate, LocalTime, LocalDateTime)
7. Interactive Java workbook part 7 (10% COMPLETED, NOT PUBLISHED YET)
   • Packages and access levels (private, public, protected, default)
   • JavaBeans specification
   • Inheritance
   • The Object class
   • Cumulative test 9
   • Cumulative test 10
   • Cumulative test 11
   • Cumulative test 12
   • Cumulative test 13
   • Cumulative test 14
   • Cumulative test 15
   • Cumulative test 16
8. Interactive Java workbook part 8 (0% COMPLETED, NOT PUBLISHED YET)
   • Abstract classes and inheritance
   • Interfaces
   • Lists in Java
   • Error handling - exceptions
9. Interactive Java workbook part 9 (0% COMPLETED, NOT PUBLISHED YET)
   • Input and output streams in Java
   • Working with the keyboard
   • Working wih textual files
   • Serialization of objects
   • Cumulative test 17
   • Cumulative test 18
   • Cumulative test 19
   • Cumulative test 20
   • Cumulative test 21
   • Cumulative test 22
   • Cumulative test 23
   • Cumulative test 24

Humans use natural language (spoken language) to communicate. Sounds, letters, words, and sentences (with the appropriate grammar) serve to convey a message. Although there are many natural languages, they are based on similar concepts.

However, what happens if we need to convey a message to a computer? Computers do not understand natural language; some form of translation is necessary.

Computers use machine language (binary language). In binary language, everything is represented using only zeros (0) and ones (1). These are the only two “letters.” This language arose due to the way hardware functions (microchips, printed circuit boards, electrical circuits, etc.). At the hardware level, zero means no electricity, and one means there is electricity.

We, humans, use the decimal system to represent numbers. This means ten digits: 0, 1, 2, 3, 4, 5, 6, 7, 8, and 9. However, computers only have “digits” 0 and 1. So, how are numbers represented in a computer?

For example, the number 0 is written as 0 in binary, and the number 1 is written as 1. However, the number 2 is represented as 10 in binary because the digit 2 does not exist in binary. The number 10 is the first number larger than 1 that can be written using only the digits 0 and 1. The number 3 is represented as 11, the number 4 as 100, the number 5 as 101, and so on.

How are letters represented in binary language? Also as numbers. Each letter is assigned a number that represents it according to the corresponding (character) table. You may have heard of the ASCII table, or UTF-8 and UTF-16?The capital letter “A” is represented as the number 65 (or 1000001 in binary),and the capital letter “B” as 66 (or 1000010), and so on. The Swedish pop band name “ABBA” would be represented as a series of four numbers: 65 66 66 65 (1000001 1000010 1000010 1000001).

If we need to give a command to the computer to add two numbers (for example, 65 and 5), it would look something like this in binary:

Let’s say we need to give the computer a more complex command: to load data from a file, search a database, and return the name of a movie, etc. For such a command, we would need to write a lot of zeros and ones. This is extremely complicated if done manually. The potential for errors is enormous.

In the past, commands were indeed written in binary code, but now a different approach is used.

Now, we use (higher) programming languages. These are intermediary languages between humans and computers. A programming language (depending on its complexity) is somewhere between a natural language and machine language. It is similar enough to a natural language so that humans can easily write commands for the computer. Also, it can be easily and quickly (automatically) translated into machine language so that the computer “understands” and executes those commands.

There are many programming languages. Some are “closer” to natural language (“higher” programming languages), while others are closer to binary language (“lower” programming languages). Some are procedural, some are functional, and some are object-oriented (Java is one of them). No programming language is perfect, and each has its advantages, disadvantages and preferred uses.

Every natural language has its grammar. Similarly, every programming language has its syntax. The syntax of a programming language is the set of symbols, reserved words, expressions, and rules that govern the proper use of the language.

In natural languages, violating grammatical rules is undesirable. However, it is often allowed in practice because your conversation partner will likely understand you. In programming languages, any violation of syntax is not allowed and leads to an inability to translate the code into machine language. These violations of syntax are called syntax errors.

Programming is the process in which a person writes commands for a computer in a programming language (always respecting its syntax). Often, the word coding is used instead of programming in casual speech.

As a result of programming, a (computer) program or (computer) application is created.

Source code is the textual record of commands in a programming language, as written by a person. It is usually saved in form of multiple textual files - source code files. Source code is often referred to simply as code.

Executable code is obtained when the commands from the source code are translated into binary language that the computer “understands.” Executable code is called so because it can be executed on the computer without any further translation.

The process (of automatic) translation of source code into binary code is called compiling. Compiling is done by a program called a compiler, and it is only possible if there are no syntax errors in the source code.

The process of running a program, i.e., executing the executable code on a computer, is called program execution or program run.

Java is an object-oriented programming language developed by Sun Microsystems, and it is now owned by the Oracle Corporation. This language is free to use and can be downloaded from the Oracle Corporation website.

One of the main features of Java is that it is a platform-independent language. This means that, by using Java, programs can be written for Windows Linux, Android, Mac OS X, or any other operating system for which there is a so-called Java Virtual Machine (JVM).

The Java Virtual Machine is specialized software that allows code written in Java to be translated into instructions for the corresponding operating system and hardware during execution (Figure 1). In this way, the same Java program can be used, completely unchanged, on any computer with any operating system (for which there is a JVM, that is). In other words, in order for a Java program to be executed, the JVM for the operating system used must be installed.

The Java installation which only includes the JVM and allows the execution of pre-written Java programs, is called a JRE (Java Runtime Environment).

However, if someone wants to create Java programs (and run them), they need to install the JDK (Java Development Kit). The JDK includes the JVM, as well as the Java compiler and the standard Java component library. The Java compiler allows the translation of the source code of a Java program into Java bytecode, which can then be executed on the JVM.

The basic process of creating and running a program in Java can be seen in the following image (Figure 2).

1. The programmer first writes the Java code (source code) and saves it in a file with the “.java” extension.
2. The next step is to compile this source code, i.e., convert it into Java bytecode. The compiler performs this step upon request and generates files with the “.class” extension.
3. Only then can the program be run (execution). When it is executed, the JVM converts the Java bytecode into executable code for the operating system and hardware, and the program begins to execute.

One of the unique features of the Java programming language — platform independence — is achieved precisely because the source code is not directly compiled into executable code but into Java bytecode, which the JVM converts into executable machine code for the specific operating system when the program is run.

The JDK contains only the basic libraries necessary for creating, compiling, and running Java programs. However, the JDK does not include any editor or integrated environment, making it extremely difficult and impractical to write Java programs without these additional tools.

For this reason, there are special classes of programs that use the JDK but add a complete graphical interface and many other tools, all aimed at making it easier and faster to create Java programs. The general term for such a program is Integrated Development Environment (IDE).

Some of the most popular IDEs for Java are:

• IntelliJ IDEA (both commercial and free versions available)
• Eclipse (free)
• Apache NetBeans (free)

Only after installing an IDE along with the JDK can you start writing Java programs. Most IDEs now include a JDK distribution as well so only an IDE installation is needed.

However, there is also an alternative. Recently, online code editors and online IDEs have become very popular, and they do not require any installation. Instead, you can work with them online through a web browser.

Some popular free online environments and editors are:

• Codiva IDE
• OnlineGDB Online Java Compiler
• W3Schools Java Compiler
• Tutorials Point Online Java Compiler
• Replit IDE (not free, but there is a free version)

The advantages of these online environments are that installation is not required and you work directly through the browser, which makes programming possible even on other devices that have a browser (smartphones, tablets, etc.). Therefore, they can be a good choice for someone just starting to learn programming, and they typically support multiple programming languages at once.

On the other hand, these online environments can cumbersome to work with - an accidental page refresh can erase your code. They are very simple and have very limited features, so they are not a good choice for creating more complex programs or applications. Some online environments only support working with a single file. Additionally, these online environments tend to be slower than standard IDEs and do not allow the use of additional Java libraries or the creation of Java applications with graphical interfaces, further limiting their usability.

This is the first theory lesson in this workbook so please see the introductory video on theory lessons if you haven’t seen it already.

• Class, definition and elements
• Layout of keys on the keyboard
• Reserved words in Java
• Comments in Java
• Convention for naming classes
• Code formatting: “breaking” code into multiple lines
• What are syntax errors and how are they marked in code
• Most common errors

A class is a general representation of a set of objects (things or phenomena) that have the same structure and behavior. A class is a simplified model of these real objects and phenomena and encompasses their:

• characteristics (attributes)
• behaviors (methods)
• relationships with other classes (relations)

Attributes, methods, and relations are called elements (members) of the class. Attributes are sometimes also called fields or properties.

Example 1

An example of a class is Car (Figure 3). The class is graphically represented by a rectangle consisting of three parts. The top part only contains the class name - Car.

The Car class has the following characteristics: brand, model, production year, and registration number. These characteristics are located in the middle part of the rectangle in the image.

Some behaviors of a car include: start, stop, accelerate, brake. These behaviors are found in the bottom part of the rectangle in the image.

In the image, these characteristics are represented by attributes, while behaviors are represented using methods. It’s important to note that this is a simplified version of a real car because a car can have many other characteristics (serial number, color…) and behaviors (turn, open door…).

It is also important to mention that the UML class diagram (Unified Modelling Language) is used here to graphically represent the Car class. This graphical notation will be used throughout the text, and more about UML can be read here.

Example 2

Another example of a class could be Person (Figure 4).

Let’s say a person has a first name, last name, and identification number, but in this example, it doesn’t have any defined behaviors.

If we consider the Car class from the previous example and the Person class, there is a certain relationship between them. A person can be the owner of a car. This relationship is represented by a relation between the classes.

Details about attributes, methods, and relations will be explained in the following lessons. For now, it’s important to see how to define a class in Java. The general format of class definition in Java is as follows:

The definition begins with the reserved word “class”, followed by the class name. This first line is the class header. The next element is an open curly brace ({). After the curly brace begins the body of the class, which contains the definitions of attributes and methods. The class definition ends with a closing curly brace (}).

Whenever multiple related statements need to be written together, a block of statements is written. A block of statements in Java begins with an open curly brace ({), followed by the desired statements, and ends with a closing curly brace (}). In other words, the body of the class, as it contains multiple related statements (definitions of attributes and methods), is written as a block of statements. When writing a block of statements, both braces must be written, meaning the block must both begin and end.

Now, if you are not that familiar with the standard keyboard layout, you are probably wondering where some special characters are placed, like the curly brackets we just mentioned - { and }. There are a lot of keyboard types out there, and a lot of keyboard layouts. Different languages can have different alphabets, hence the letters printed on the keyboard reflect this. In this workbook, we will focus on a regular keyboard with a US-English (EN-US) layout. The keyboard should look like this (Figure 5). Even if your keyboard has some different characters printed on some of its keys, it can be configured to use the EN-US layout in the language and keyboard settings in your operating system.

The special character keys are marked with ellipses in the figure (Figure 5). From top to bottom, the first line of keys are mostly numbers, where each pressed key produces a digit (1-9 and 0 towards the end), while the same key, when pressed together with the Shift key (there are two - bottom left and bottom right), produces a special character. For each key, both characters are printed on the key:

In the second keyboard row (after the P key) are positioned the bracket keys, square and curly brackets:

In the third keyboard row (after the L key) are positioned the column/semicolumn, apostrophy/quotation marks and backslash/vertical line keys:

Finally, in the fourth row (after the M key) are the less-than/comma, greater-than/dot, and question mark/slash keys:

A laptop keyboard has a similar layout, so you should also be able to find the special characters (Figure 6). Here, the | key is placed in the second keyboard row instead of the third, and all other keys have the same placement.

And what exactly are reserved words? Reserved words are words chosen (reserved) to be part of the programming language, i.e., to be used for writing its statements. Java has around 40 reserved words, some of which are:

Reserved words cannot be used as names for classes, attributes, variables, etc.

Java is a programming language in which case matters (i.e., it is “case-sensitive”). This means that class names, attribute names, method names can differ depending on whether they are written in uppercase or lowercase letters. For example, “CurrencyConverter”, “currencyconverter”, and “CURRENCYCONVERTER” are treated as completely different names.

Reserved words in Java are written exclusively in lowercase, so it’s class and not Class nor CLASS.

Currently, within the class body given as an example, there are only two comments. In general, comments are used to write a message to the person who will read or modify the source code. This can be an explanation or note that helps with better understanding of the written code. During compilation, the Java compiler ignores comments and does not interpret them as program code, so the content of the comments can be any text.

Comments in Java can be written in two ways. One variant is single-line comments. The beginning of such a comment is marked by two slashes, and the entire text must fit on one line. An example of a single-line comment is:

The other type of comment is a multi-line comment. These are used when a more detailed or longer explanation is needed. Of course, multiple single-line comments can be written, but it’s much simpler to frame the entire text as one multi-line comment. A multi-line comment starts with a slash and an asterisk (“/*”) and ends with an asterisk and a slash (“*/”):

It’s important to note that not all slashes are the same. When writing comments, only the regular slash (“/”) is used, not the backslash (“\”), which has a different meaning in Java.

Example 3

Create (define) the Car Class. This class should not have any attributes or methods. Write this fact as a single-line comment.

Example 4

Create the Person Class. This class should not have any attributes or methods. Write this fact as a multi-line comment.

It’s important to note that in Java (and in many other object-oriented programming languages), there is an unwritten rule (Java class naming convention) that class names should start with an uppercase letter and continue with lowercase letters (“Car”, not “car” nor “CAR”). If the class name consists of multiple words, then all words are written together, with the first letter of each word capitalized (“CurrencyConverter”, “BusinessCenter”). The name must not contain any spaces (this applies to the names of all other elements - attributes, methods…).

There are also rules regarding breaking statements into multiple lines (text) and blank spaces (’ ’). The basic rule in this regard is that each statement should start on a new line. Additionally, almost every statement, declaration, etc., can be written on one or more lines (text) with an arbitrary number of blank spaces, provided that breaking (moving the remainder of the statement to the next line) or adding new blank spaces can occur in places where there would normally be a blank space. The exception is breaking within a String value or a single-line comment, which cannot be done this way.

The goal of breaking statements into multiple lines is to make the code as readable as possible (for the programmer). During compilation, all unnecessary blank spaces are removed, and the code is joined into one line, followed by syntax checking, so in that sense, how the code is broken up doesn’t matter.

Example 5

Create the Chameleon Class. Write a multi-line comment in the method body stating that it is an animal. Break the code of the class in different ways and add blank spaces where allowed (several solutions are given below, with the first solution being the most readable). Open the class code and try modifying it by breaking the lines in different ways.

or

or

or

or

Usually, the source code of each class is saved in a separate file. For example, the source code of the “Car” class might be saved in a file named “Car.java”, and the “Person” class in “Person.java”. When compiled, the Java executable code will be saved in “Car.class” and “Person.class”.

However, it is possible to save the source code of multiple classes in one file. In other words, the source code for both the “Car” and “Person” classes could be saved in one file, such as “Car.java”. But when compiled, two files will still be generated: “Car.class” and “Person.class”.

Just as every natural (human) language has its own rules — grammar,
every programming language also has its own rules — syntax. If during coding the rules of the programming language are not followed, syntax errors occur, and such code cannot be compiled until these errors are corrected.

It is completely normal and expected that someone who is just learning a programming language makes many syntax errors until they master the basics of the language. Because of this, many programming environments have additional features to help identify syntax errors, fix them, and make it easier to write code in general.

In the IntelliJ environment, syntax errors are usually highlighted in red. More precisely, the environment marks them in red within the code editor, so it’s enough to look and see “if something is red“to spot the error. The file name in which the error is located (e.g., “Motorcycle.java”) will also be marked in red, as well as the commands within that file that are not written correctly.

Of course, if there are multiple errors, IntelliJ will highlight each one, and in the top-right corner of the code editor, the total number of errors in that class or file will be shown.

It is important to know that with a syntax error, there is always a message from the compiler explaining what the error is. For example, “insert ; to complete statement” (insert a semicolon at the end of the statement), “unclosed comment” (the multiline comment is not closed), etc.

Example 6

Consider the class Motorcycle, which contains several syntax errors (Figure 7). You can see on the left side that the file name “Motorcycle.java” is underlined in red.

The first syntax error is that the reserved word “class” is written in uppercase letters (“CLASS”). It can be seen (on the first line of code) that this word is highlighted in red, and a red line appears along the right edge, indicating that the first line of code is syntactically incorrect (Figure 7).

The second syntax error is that the multiline comment is not closed (with */). It can be seen that along the right edge of the editor, there is a red rectangle that highlights these lines of code (from the start of the comment to the end of the file) as syntactically incorrect (Figure 7).

Finally, the total number of syntax errors in that class (or file) is shown by the number two in the top-right corner of the editor (Figure 7).

Also, if the mouse cursor is placed on the syntax error, i.e., the word “CLASS”, an error description will appear: “Cannot resolve symbol ‘CLASS’”, meaning that the compiler does not recognize the word CLASS as a reserved word or as the name of a class, attribute, etc. The same text will appear if the mouse cursor is placed on the right edge of the editor, over the red line that marks the first line of code. If the mouse cursor is placed over the red rectangle that marks the syntax error due to the unclosed comment, the message “Unclosed comment” will appear.

If the syntax errors are corrected, the colors and indicators in the code editor change immediately (Figure 8).

From all of this, it can be concluded that IntelliJ’s code editor has several features related to syntax checking:

1. Syntax checking is real-time, while the programmer types the code.
2. All syntax errors are highlighted in red.
3. With each syntax error, a message from the compiler is displayed explaining what the error is.
4. There is also syntax coloring where reserved words are shown in yellow, local variables in gray, etc.

All these features are aimed at helping the programmer write and check code for syntax correctness more easily. Additionally, there is something called automatic code completion (also known as “code completion”), which helps write code faster.

When the programmer starts typing a reserved word, class name, or variable name (usually the first two or three letters), the editor suggests the completion of that word, name, etc., and it’s enough to press the “Return/Enter” key (for a new line) for that word to be inserted into the code (Figure 9). If there are multiple suggestions, the user can choose between them using the up and down arrows before pressing Enter.

Moreover, there are shortcuts that can be activated for:

1. Performing an action (e.g., Shift+F10 to run the program or Ctrl+F to search for a word within a file).
2. Adding a large chunk of code into the editor (e.g., typing “sout” and pressing “Enter” to insert the command
   “System.out.println();” — Figure 10, or typing “main” and “Enter” to insert the main method — Figure 11).

Some of the most common syntax errors related to class declarations and writing comments are:

• Incorrectly writing the reserved word class in uppercase, e.g., CLASS, Class, ClAss, etc.
• Forgetting to write an open ({) or closed brace (}) when forming the body of a class or any other block of statements.
• Writing a single-line comment with one slash (/) instead of two (//).
• Forgetting to close a multi-line comment with the asterisk and slash (*/).
• Forgetting to start a multi-line comment with the asterisk and slash (/*).
• Adding a blank space in the class name, e.g., writing My Car instead of MyCar.
• Writing comments with backslashes () instead of regular slashes (/).

Now that you have read the theory lesson, it is time for tasks. If you haven’t already, install IntelliJ with the Jetbrains Academy plugin, and load the Interactive Java workbook part 1. It is contained in the “Interactive Java workbook 1.zip” file accompanying this book.

Installation and introductory video tutorials can be found in this playlist for convenience.

Happy coding!!!

• Attributes - definition, and meaning
• Simple and complex data types in Java
• Java naming convention for attributes
• Default and initial values
• Code formatting: indentation
• Most common errors

As already mentioned, attributes represent certain characteristics (properties) of classes.
For the class Person, these might be: name, surname, gender, age, etc. These characteristics are often expressed through some number, letter, or string of characters.

Defining attributes is relatively simple and looks like this:

A data type represents a set of possible values for an attribute – integers, real numbers, letters, strings of characters, or something else.

Some of the most commonly used data types in Java are:

• int – integers, e.g., 1, -55, 0, 1000000.
• double – real numbers, e.g., 12.55, -234.77, 0.21, 6.371e6 (which is the same as 6371000.0), 6.371e-2 (which is the same as 0.06371).
• char – a single character (letter, digit, or some other character), e.g., ‘a’, ‘A’, ‘e’, ‘!’, ‘;’, ’ ’ (space), ‘4’, ‘9’.
• boolean – a logical variable, can only have the values true or false (one of these two values).
• String – a string of characters, e.g., “River”, “Pera”, “123”, “zx!”.
• LocalDateTime – date and time, e.g., 2008-12-31 10:50.

It should be noted that the double type can also receive an integer value (for example, -34), but Java will automatically convert this to a real number (i.e., decimal format -34.0) before assigning it. The reverse does not apply, i.e., if we try to assign 2.55 to an int variable, it will result in a syntax error.

According to the Java naming convention, attribute names should start with a lowercase letter:

• age
• brand
• model, etc.

If the attribute name consists of multiple words, all words are written together. The first word starts with a lowercase letter, and all other words start with uppercase letters:

• socialSecurityNumber
• firstName
• engineNumber, etc.

An important rule in Java is that all commands must end with a semicolon (;). So, the attribute declaration ends with a semicolon.

Types like int, double, char, and boolean are simple data types, while String and LocalDateTime are complex types. String is a sequence of characters, while LocalDateTime contains day, month, year, hour, minute, etc. All complex data types in Java are represented by using classes, so String and LocalDateTime are two predefined Java classes.

It is important to note that there are other simple data types, but they are not used as frequently: long (a set of integers with a range greater than the int type), short (a set of integers with a smaller range than int), and float (a set of real numbers, but with fewer decimal places than the double type).

Each variable in Java gets a default value when declared unless a different initial value is explicitly specified in the code. The default value depends on the type, so for example:

• int and other integer variables receive the default value of zero (0).
• double and other real number variables receive the default value of zero in decimal format (0.0).
• boolean variables receive false.
• All complex-type variables (any class) receive the default value of null.

Also, in Java, char values (characters) must be written in single quotation marks (e.g., ‘A’), while String values must always be written in double quotation marks. For example, “BANANA” is a String value, but “A” is also a String value (even though it contains only one letter) because it’s enclosed in double quotation marks (a char value would be ‘A’).

Example 1

Create a class called CashMachine. This class should only have the attribute “balance” representing the amount of money currently in the machine (real number).

Example 2

Create a class called Computer. This class should have the following attributes: processor speed (real number, e.g., 4.0 GHz), ram (real number, e.g., 2.0 GB), and hard disk (integer, e.g., 120 GB).

The order in which attributes are defined within the class is not important. What matters is that all necessary attributes are declared with the appropriate types and names.

Example 3

Write the code for the Computer class from the previous example in multiple ways, changing the order of the attribute declarations (multiple solutions are given).

or

or

It’s possible to assign an initial value to an attribute when defining the class. This is not the default value assigned by Java, but the programmer can provide an initial value for the attribute if necessary. The default value is assigned where the programmer hasn’t specified an initial value. The initial value is assigned to an attribute in the following way:

Example 4

Modify the Computer class from previous examples so that the initial value for the processor speed is 4.0 (GHz), ram is 16.0 (GB), and the hard disk has 500 (GB). Save the class as a new class, Computer2.

To shorten the declaration of attributes, it’s possible to combine declarations of attributes of the same type into one declaration as follows:

Or, if initial values are required for these attributes, they can be assigned like this:

Example 5

Create a class called Person. This class should have the following attributes:

• name (String, initial value “unknown”)
• surname (String, initial value “unknown”)
• height (real number, e.g., 186.5 cm)
• weight (real number, e.g., 80.5 kg)
• gender (char)

Write the code for this class in two ways:

• Without combining declarations of attributes of the same type – class Person.

• With combining declarations of attributes – class Person2.

  class Person { String name = “unknown”; String surname = “unknown”; double height; double weight; char gender; }

  class Person2 { String name = “unknown”, surname = “unknown”; double height, weight; char gender; }

It has already been mentioned that breaking commands into multiple lines and adding spaces is done to make the code more readable for the programmer – in terms of compiling, it doesn’t matter. Here, we should also mention that a typical transformation is used to increase readability: indentation of code (shifting lines of code to the right).

Code indentation, along with breaking commands into multiple lines, is part of the code formatting rules. The idea of indentation is that all code within a block of commands (e.g., the body of a class) is “shifted to the right” relative to commands outside that block (e.g., relative to the class declaration). This means that the code is not written from the left edge but is moved a few spaces to the right (usually four to eight spaces, or one tab character). The closing curly brace that marks the end of the block remains aligned with the left edge. Also, any code within the body of a method (a new block of commands) should be indented an additional 4-8 spaces compared to the method declaration, and so on. Usually, the programming environment, or more precisely its code editor, automatically handles indentation.

Example 6

Let’s take the Person class from the previous example with the attributes name, surname, height, weight, and gender. Without following the code formatting rules, this class could be written like this:

This code is less readable because everything is written in one line. If the rules for breaking commands into new lines are followed, the code becomes more readable:

This code is more readable, but each command is written at the left edge without indentation. This makes it hard to see that the attributes name, surname, height, weight, and gender are part of the block of commands that form the class body. If this class had methods (and each method has its own declaration and body forming a new block of commands), this would be even harder to notice.

If we now introduce the rules for code indentation (each command within the body of the class is indented six spaces or one tab relative to the class declaration), the code becomes even more readable – which is the ultimate goal:

Some of the most common syntax errors related to attribute declarations and assigning initial values are:

• Incorrectly writing reserved words int, double, char, boolean in uppercase, e.g., INT, DOUBLE, CHAR, etc. There are certain classes in Java that are somewhat equivalent to these simple types, so Double and Integer won’t trigger a syntax error, but the code won’t behave as expected.

• Incorrectly writing the names of predefined complex types String, LocalDateTime in lowercase, e.g., string, localdatetime, etc. These are classes, so the naming convention for classes applies: the first letter of each word is uppercase, and all words are connected.

• Forgetting to write a semicolon (;) at the end of each command.

• Writing char values with double quotation marks instead of apostrophes (e.g., “W” instead of ‘W’).

• Writing String values with apostrophes instead of double quotation marks (e.g., ‘sun’ instead of “sun”).

• Including a space in the attribute name, e.g., writing processor Speed instead of processorSpeed.

Other common errors that aren’t syntax errors, but affect the program’s functionality, include:

• Using real data types (float, double) in situations where an integer data type is appropriate (int, short, long). For example, the number of students is an integer, even though someone may declare it as a real number. Although this is not a syntax error, it may cause issues later because some operators in Java work only with integers.

Now that you have read the theory lesson, it is time for tasks. If you haven’t already, install IntelliJ with the Jetbrains Academy plugin, and load the Interactive Java workbook part 1. It is contained in the “Interactive Java workbook 1.zip” file accompanying this book.

Installation and introductory video tutorials can be found in this playlist for convenience.

Happy coding!!!

• Objects - definition, and purpose
• Executing (running) a Java program (main method)
• Printing on the screen (print and println methods)
• Most common errors

An object represents a specific instance or occurrence of a class. Therefore, a class can be defined as “a set of objects that have the same properties and behaviors”. The relationship between a class and an object is shown in the following example.

Example 1

The car represents a class because it is a general blueprint of some characteristics and behaviors that every car has (Figure 12, top).

However, “Aston Martin DB9” with a production year of 2008 and registration “A123-456” represents a specific instance of a car, i.e., an object of the car class. The relationship between the class and the object is shown in the following image (Figure 12, bottom).

In Java, objects are declared similarly to class attributes. First, the class name is mentioned, and then the name of the specific object. In this way, a variable is created that will reference a specific object. As mentioned earlier, if no initial value is assigned, every object gets the default value of null.

However, an object needs to be initialized before it can be used (make calls to its methods, change the values of its attributes, etc.). If you try to access an object without initialization, Java will report an error. Initialization is done using the “new” command as follows:

Initialization can also be done immediately during object declaration (for shorter code), similar to how initial values can be assigned to attributes:

What actually happens when an object is initialized (Figure 13)? When an object (variable) is declared, only a pointer is created that will reference the object, and it gets the default value null (upper half of Figure 13).In Java, variables that represent objects only contain the memory address of the object (where the object is located), not the object itself. This null value actually means that the pointer does not point to any memory address , i.e., the object does not yet exist.

When initialization is performed, only then a part of the computer’s memory (RAM memory) is allocated for the object and linked to the pointer. From that point on, the pointer contains the object’s memory address (lower half of Figure 13). Only then can the object be used.

It would also be interesting to explain how objects are deleted in Java (Figure 14). It is quite normal in the execution of a regular program that hundreds or thousands of objects are created (initialized) in a short period. Each of these objects occupies a part of the computer’s memory, and it often happens that many of them are no longer needed and should be deleted, i.e., removed from memory. If this is not done, memory overload can occur.

Java has a mechanism called “Garbage collection” (Figure 14) that automatically deletes unnecessary objects. An object is unnecessary if no variable or pointer points to it. In other words, it is enough to assign null to the variable (pointer) or initialize a new object through the same variable, and the old object will be automatically deleted after some time.

For a Java program to run, it must have the so-called “main” method. Methods are covered in detail in the next lesson, so only the specifics related to the main method are given here.

Similar to a class, the main method has its header (declaration), followed by a block of statements that forms the body of the main method (it starts with ‘{’ and ends with ‘}’).

The main method is written within the body of the class, and its header is always written in the same way (public static void main(String[] args)). The desired statements are written within the body of the main method (which represents a new block of statements), so it looks like this:

Each Java class can have a main method (at most one), so the program can be run from any class. Code formatting rules also apply here, so additional indentation is performed on the statements within the block of the main method. In this way, it is immediately clear which statement belongs to which part of the program, i.e., which block of statements.

Example 2

Create a class Motorcycle that has:

• Attribute makeModel.
• Attribute engineCapacity (integer).

Add a main method to the Motorcycle class and, within it, create two objects of the Motorcycle class.

Although the previous example demonstrated the rule that each class can have a main method, it is recommended that the main method be separated into its own class, which will only serve to run the program. This way, the code for running the program is separated from the code for attributes and regular methods. This can be seen in the next example.

Example 3

Create a class Motorcycle2 that has:

• Attribute makeModel.

• Attribute engineCapacity (integer).

  class Motorcycle2 { String makeModel; int engineCapacity; }

Create a class Test that contains the main method and, within it, creates two objects of the Motorcycle class, but with the objects initialized immediately during the declaration.

An object is an occurrence of a class that has specific attribute values. To change or read the values of an attribute, it must be accessed in a specific way. Access to object attributes is done through the object name and the attribute name, separated by a dot:

Example 4

Use the class Motorcycle2 from the previous example and create the class Test2 that, wihin its main method creates two objects of the Motorcycle2 class.

• The first motorcycle should be “Suzuki GS” with 500 cc engine capacity (assign these values to the first object’s attributes).

• The second motorcycle should be “Yamaha R6” with 600 cc engine capacity (assign these values to the second object’s attributes).

  class Test2 {

   1   public static void main(String[] args) {
   2       Motorcycle2 m1;
   3       Motorcycle2 m2;
   4 
   5       m1 = new Motorcycle2();
   6       m2 = new Motorcycle2();
   7 
   8       m1.makeModel = "Suzuki GS";
   9       m1.engineCapacity = 500;
  10 
  11       m2.makeModel = "Yamaha R6";
  12       m2.engineCapacity = 600;
  13   }
  

  }

In Java, commands are executed in the order in which they are written (“top to bottom”). For example, if commands for accessing attributes are written first within the main method, and object initialization follows, Java will report an error.

The previous two examples contain the main method and can be executed. However, the result of their execution will not be visible—objects will be initialized, values will be assigned to attributes, but nothing will be printed on the screen.

The command for printing on the screen (in Java, the screen is called “standard output”) is as follows:

The result of executing this command is printing (on the screen) the content inside the parentheses and moving to a new line. This content can be some text (String value written in quotation marks), the value of some attribute (or variable), or a combination of both.

If there are multiple values (e.g., a String and another number), the concatenation operator (+) is used to combine parts of the message into one whole.

Here, System is a predefined Java class representing the computer on which the program is executed and is written with an uppercase letter. Also, out is an attribute of the System class that represents the standard output (screen), and it is invoked as System.out.

The println command is actually a method of the out attribute that prints something to the screen. In the next example, it is shown exactly what this command does and how to use it.

Every time a program is executed, a special “Run” frame appears on the bottom of the IntelliJ window which shows the status of the program, and if it ended correctly (“Process finished with exit code 0”). If the program prints something on the screen, the output text is also displayed there (in the “Run” frame). This frame can be shown or hidden by clicking on the grey triangle (“Play”) button in the lower left part of the screen.

Example 5

Here are several examples of using the “println” command to print on the screen and the results that will be displayed. All examples are written in the main method of the class PrintExamples1.

Run the program with the Ctrl+F2; command or by clicking the run program icon (green triangular “Play” button)

Since this program is printing something on the screen, the “Run” frame will appear on the bottom and display the text as well as program finishing status.

Example 6

Use the Motorcycle2 class from previous examples and the Test2 class that contains the main method.

Modify the main method of the Test2 class so that it prints the values of both objects’ attributes on the screen.

One of the variants of the command for printing on the screen is the “print” command.
The only difference compared to the “println” (print-line) command is that after printing the text, the cursor does not move to the next line, and it continues printing in the same line.

Example 7

Here are a few examples of using the “print” command for printing on the screen and the results that will be displayed. All examples are entered in the main method of the PrintExamples2 class.

It is important to note something about concatenating message parts. Usually, there should be at least one space between these parts so that the text is not “stuck” together. This space can be added directly in the String value before or after the concatenation operator, or as a completely separate space if no part of the message is a text value (i.e. only numeric or boolean values).

When concatenating, if none of the message parts is a String value, the concatenation operator will be interpreted as an addition operator (the same operator is written as +) and it will print the result of the addition on the screen.

Example 8

Here are several examples of using the “println” commands for printing on the screen and the results that will be displayed, with attention paid to how the message is concatenated. The code can be found in the main method of the PrintExamples3 class.

One of the common questions that beginner programmers have is: “Why is my program not running even though it has a main method?” If there are no syntax errors, the problem is often that the program is running, but it is not printing anything to the screen. If there are no calls to the print or println methods anywhere in the program, the program will not print anything, even though it will execute normally.

Example 9

Here is an example of a program that runs normally but does not print anything to the screen. The Meal class has two attributes, and in the main method of the Test3 class an object of the Meal class is created and values are entered into its attributes.

However, neither the print nor the println method is called. Therefore, nothing will be printed when the program is run. This creates the illusion that the program is not working.

Some common syntax errors related to the declaration and initialization of objects, accessing attributes, printing to the screen, and the main method are:

• Incorrectly writing the class name when creating an object with a lowercase first letter:

  motorcycle m; // Incorrect

Instead of (correct):

• Forgetting to initialize the object before using it:

  Motorcycle m; m.make = “Honda”;

Instead of (correct):

• Incorrectly writing the class name System when calling System.out.println or System.out.print with a lowercase first letter, i.e., “system.out.println” or “system.out.print”.

• Forgetting to write parentheses when calling the println command, e.g.:

  System.out.println “some text”; // Incorrect

Instead of (correct):

• Writing String (textual) values within the println command with apostrophes instead of quotes, e.g.:

  System.out.println(‘Some text’); // Incorrect

Instead of (correct):

• Forgetting to write the + operator for concatenating message parts, e.g.:

  System.out.println(“Some text: “ temperature); // Incorrect

Instead of (correct):

• Forgetting to write double quotes at the beginning and end of each String value when concatenating multiple message parts, e.g.:

  System.out.println(“Some text: + temperature); // Incorrect

Instead of (correct):

• Incorrectly writing the declaration of the main method (reversed order of reserved words or incorrectly writing those words), e.g.:

  void static public main (String[] args); // Incorrect order

Instead of (correct):

• Forgetting to begin and/or close a new block of statements with curly braces {} after declaring the main method, or incorrectly starting and ending the body of the main method.

Other common errors that are not syntax errors, but affect the program’s behavior:

• Misjudging that the program is not working, when in fact it is executing but just not printing anything on the screen.

• Printing a message to the screen where no part of the message is a String value. In that case, the concatenation operator will be interpreted as an addition operator (even if one part of the message is a char). For example:

  // Will print 53 System.out.println(21 + 32);

  // Will print 97 because the code for the letter A is 65, so // adding 32 results in 97 System.out.println(‘A’ + 32);

Now that you have read the theory lesson, it is time for tasks. If you haven’t already, install IntelliJ with the Jetbrains Academy plugin, and load the Interactive Java workbook part 1. It is contained in the “Interactive Java workbook 1.zip” file accompanying this book.

Installation and introductory video tutorials can be found in this playlist for convenience.

Happy coding!!!

The accompanying book containing only the theory lessons is free (PDF, EPUB).

If you have finished evaluating this demo version of the Interactive Java workbook collection of tasks (tasks from the “Interactive Java workbook 1.zip” file), and you like the lessons and tasks, you may purchase the full version with all workbook parts containing all tasks.

As stated in the introduction, the Interactive Java workbook consists of several parts due to the many topics and even more tasks.

NOTE: Not all parts are completed at this time, but please see this LeanPub page, for updates and purchases. If you like this workbook, please feel free to share the link to the workbook’s page.

Once purchased, you can load the next part of the workbook (here is the how-to video).

This is work in progress, so the following list is not yet final. The parts and the topics they cover are as follows:

1. Interactive Java workbook part 1 - demo + full version (COMPLETED)

• Introduction
• Class
• Attribute
• Objects, program execution and output to the screen

2. Interactive Java workbook part 2 (COMPLETED)

• Methods and arithmetic operators
• Constructor
• Global variables and methods
• Constants
• Relationships
• Enumerated type

3. Interactive Java workbook part 3 (COMPLETED)

• Algorithms and control statements (commands)
• The if statement
• The switch statement
• The for statement
• The while statement
• The do-while statement

4. Interactive Java workbook part 4 (80% COMPLETED, NOT PUBLISHED YET)

• Introduction to arrays
• The for-each statement
• Algorithms for working with arrays - overview
• Search and print array elements
• Adding elements to an array
• Replacing array elements

5. Interactive Java workbook part 5 (80% COMPLETED, NOT PUBLISHED YET)

• Deleting array elements
• Group operations on array elements
• Array sorting
• Working with multiple strings
• Cumulative test 1
• Cumulative test 2
• Cumulative test 3
• Cumulative test 4
• Cumulative test 5
• Cumulative test 6
• Cumulative test 7
• Cumulative test 8

6. Interactive Java workbook part 6 (50% COMPLETED, NOT PUBLISHED YET)

• Arrays of objects
• Working with text (String, StringBuilder)
• Working with dates and times (LocalDate, LocalTime, LocalDateTime)

7. Interactive Java workbook part 7 (10% COMPLETED, NOT PUBLISHED YET)

• Packages and access levels (private, public, protected, default)
• JavaBeans specification
• Inheritance
• The Object class
• Cumulative test 9
• Cumulative test 10
• Cumulative test 11
• Cumulative test 12
• Cumulative test 13
• Cumulative test 14
• Cumulative test 15
• Cumulative test 16

8. Interactive Java workbook part 8 (0% COMPLETED, NOT PUBLISHED YET)

• Abstract classes and inheritance
• Interfaces
• Lists in Java
• Error handling - exceptions

9. Interactive Java workbook part 9 (0% COMPLETED, NOT PUBLISHED YET)

• Input and output streams in Java
• Working with the keyboard
• Working wih textual files
• Serialization of objects
• Cumulative test 17
• Cumulative test 18
• Cumulative test 19
• Cumulative test 20
• Cumulative test 21
• Cumulative test 22
• Cumulative test 23
• Cumulative test 24

• Methods (header, naming convention, body, return value)
• Variables
• The assignment operator (=)
• Method parameters
• Most common errors

It has already been stated that classes can have certain behaviors, and these behaviors are expressed in the form of methods. For example, methods in the “Car” class might include: start, stop, turnLeft, turnRight, etc.

Methods actually contain one or more commands that need to be executed as a whole when the method is called. Method definitions in Java are made within the body of the class as follows:

The return data type of the method, its name, and the parameters form the method header (declaration or signature), while all the code written between the curly braces (including the braces themselves) forms the method body (methods block of commands). Like any block of commands, the method body must start wit h an opening curly brace { and end with a closing curly brace }.

Methods define the behavior of the class. In addition to performing a task, a method may also return a value as a result of its execution (methods’ return value). For example, the “add” method of a “Calculator” class could return a number representing the result of an addition.

On the other hand, some methods do not have a return value. An example of such a method would be the “printName” method of the “Person” class, which simply prints the person’s name on the screen. When a method does not return any value, the return data type is void, and when it returns something, the return data type can be any simple or complex data type (int, double, char, boolean, String, LocalDateTime or any class…).

A method can have at most one return value.

The Java naming convention states that, method names are written the same way as attribute names. So, the first word starts with a lowercase letter, and if there are multiple words, the remaining ones start with an uppercase letter, i.e.:

• add
• subtract
• printName
• convertCurrency, etc.

Finally, methods can also have input values - parameters. Parameters represent the values that need to be passed to a method so it can execute correctly. For example, the “add” method of the “Calculator” class might have two numbers as parameters that need to be added. If the method has no parameters, the space between the parentheses is left empty (only “()” is written). Parameters will be explained in more detail later.

Example 1

Create the TelevisionSet class. This class should have:

• A volume attribute, which is an integer representing the current volume of the television. The initial value of this attribute is 0 (the volume is turned off).

• A currentChannel attribute, representing the channel currently being shown on the television (e.g., channel 5 is on). The initial value of this attribute is 1.

• An isOn attribute, indicating whether the television is turned on or off (TRUE if it is on, FALSE if it is off). The television is assumed to be off initially.

• A method turnOn that turns the television on (sets the “isOn” attribute to true).

• A method turnOff that turns the television off (sets the “isOn” attribute to false).

  class TelevisionSet { int volume = 0; int currentChannel = 1; boolean isOn = false;

  1   void turnOn(){
  2       isOn = true;
  3   }
  4 
  5   void turnOff(){
  6       isOn = false;
  7   }
  

  }

In this example, the TelevisionSet class has only two methods – turnOn and turnOff. The “turnOn” method has no return value because it only changes the value of the isOn attribute. Therefore, its return type is void. This method has no parameters because none are needed (it always sets the value of the attribute to true), so the space between the parentheses is empty. The body of the turnOn method contains only one command, which assigns the value true to the isOn attribute. The same applies to the turnOff method.

From the previous example, we can also observe a rule: class attributes can be directly accessed from within any method of the same class. Access is achieved, only by calling the attribute name. In other words, it is not necessary to specify the object name and the attribute name, as when accessing them from outside the class, i.e. from the main method.

Example 2

Add the following methods to the TelevisionSet class and save it as a new class TelevisionSet2:

• A method increaseVolume that increases the value of the volume attribute by one.
• A method decreaseVolume that decreases the value of the volume attribute by one.
• A method muteVolume that completely mutes the volume (sets the volume attribute to 0).

After the modification, the class code looks like this.

The increaseVolume, decreaseVolume, and muteVolume methods have no return value (they do not return anything as a result), so their return type is void. These methods have no parameters.

On the other hand, they increase/decrease current volume settings by adding/subtracting one from the current volume level and storing the new value back in the volume attribute, i.e.:

The methods provided in the previous examples do not return any value as a result. However, there are situations where it is necessary to return a value – sometimes it’s needed to return the current value of an attribute or the result of a calculation.

In those cases, the return data type is written instead of void in the method header. If the method returns an integer, the return type is int; if it returns a floating-point number, the return type is double; if it returns a string of characters, the return type is String, etc.

Additionally, within the method body, the return statement must be written to indicate the value that should be returned. Here’s an important note: when the “return” statement is executed, the method execution is terminated. In other words, any command written after the return statement will have no effect (as it will never be executed) - also, it is considered a syntax error.

Example 3

Add the following methods to the TelevisionSet2 class and save it as a new class TelevisionSet3:

• A method changeChannelUp that increases the value of the currentChannel attribute by one.
• A method changeChannelDown that decreases the value of the currentChannel attribute by one.
• A method getCurrentChannel that returns the value of the currentChannel attribute.
• A method getVolume that returns the current value of the volume attribute.
• A method isTurnedOn that returns the current value of the isOn attribute.
• A method printParameters that prints all the attribute values of the television on the screen with appropriate messages.

After all modifications, the class code looks like this.

The changeChannelUp and changeChannelDown methods do not return any value. However, the methods getCurrentChannel, getVolume, and isTurnedOn do have return values. The getCurrentChannel method is supposed to return the current value of the currentChannel attribute. Practically, this means that it returns the number of the channel currently being shown on the television (e.g., 5). Since it is an integer (the currentChannel attribute is of type int), the return type of the method will also be int. The body of the getCurrentChannel method contains only the return statement to return the value.

For example, if the following line is written in the body of this method, the method would always return the number 2:

The getVolume method is very similar to the previous one and also returns an int value representing current volume settings. However, the isTurnedOn method returns the value of the isOn attribute, so its return type is boolean.

Finally, the printParameters method only prints the values of all attributes on the screen with appropriate messages. It’s important to note that printing values on the screen is not the same as returning return values. Values printed on the screen cannot be used later (for calculations or other operations), so it is considered that the printParameters method does not actually return any value. Therefore, the return type of this method is void.

It is important to note that the return value of a method has nothing to do with whether the method prints anything to the screen. If a method has a return value, it means that it returns some number, letter, string, etc., which can be saved in a variable and used later in the program for further calculations, processing, and so on. The return type of such a method is not void. When a method only prints a value to the screen, that value is only visually displayed and cannot be retrieved or saved, further processed, etc. (the return type is void).

It is also possible for a method to do both things. For example, of the three methods shown in the following listing, the first only returns the value of the mathematical constant Pi and does not print anything to the screen, the second only prints the value of Pi to the screen and does not return it, and the third does both.

The question arises, how are methods called? It is similar to calling attributes. In order for methods to be called, an object must first be initialized, and then its method can be called using the object name (variable name) and method name separated by a dot. The difference from calling attributes is that when calling a method, brackets must always be written after the method name (even if the method has no parameters):

If a method has a return value, it is recommended to first declare a variable that will receive the method’s return value, and then call the method (though this is not required, the return value can be ignored and discarded). The variable data type must match the return data type of the method:

Before moving on to a specific example, it is necessary to clarify what a variable is and what types of variables exist.

A variable represents an identifier (name, letter, expression, etc.) that is linked to some value, and that value can change. Variables are physically represented as a place in the computer’s memory where a value can be stored. The data type of the variable determines the type of the value that can be assigned to it.

For example, a variable of type int can hold an integer value and is physically represented as part of the computer’s memory where an integer value can be stored.

Depending on where they are declared in the code, there are four types of variables:

• Local variables (or just variables) - variables declared within the method’s body.
• Attributes - variables directly belonging to objects of a class. They are defined within the body of the class.
• Global variables - variables that do not belong to individual objects of a class but are used at class level or program level.
• Parameters - variables of a method that are declared in the method’s header (represent the input values for the method). Although they are technically also local (method) variables, we will explicitly differentiate parameters from other local variables for clarity in the rest of the material.

Attributes were explained in detail in the previous lesson, and local variables and parameters will be explained in this lesson. Global variables will be covered in the following lessons.

Example 4

Use the TelevisionSet3 class from the previous example. Create a class TestTelevisionSet that creates an object of the TelevisionSet3 class and calls some of its methods. After each method call, call the printParameters method and notice the changes in the attribute values.

When calling a method that has no return value (for example, the printParameters method), the call is similar to calling an object’s attribute. The only difference is that after the method name, you must write parentheses, where the actual values for the parameters are listed. If the method has no parameters, the space between the parentheses remains empty (“()”):

Calling a method that has a return value is slightly different. This is the case with methods isTurnedOn and getCurrentChannel. The example shows that a local variable on is declared, within the main method’s body. This variable is of type boolean (the same type as the return value of the method isTurnedOn) and receives the return value of the method:

In this way, the method’s return value is not lost (it is saved in the on variable) and can be used in further program execution. This is illustrated by the following line of code from the example. The on variable is used in a print command to display whether the TV is currently on:

Also, this local variable on has limited scope and can only be used within the main method. Finally, if one looks closely, variable t (object pointer) is also a local variable declared in the main method.

In many of the previous examples and exercises, one operator has frequently been used. This is the assignment operator (=). A few examples related to this operator are given in the following listing:

Essentially, this operator allows assigning a value to a variable, attribute, or object.

On the left side, there must always be a variable (local variable, parameter, attribute…) that will receive the value from the right side of the equality sign.

On the right side of the equality sign, there can be:

• a concrete value (-34, true, “E”…),
• a variable (local, parameter, attribute…) of simple or complex data type (object),
• an expression, or
• a method call.

It is important that the data type of the left side matches the data type of the right side (e.g., it’s not possible to assign the value 23.44 to an int variable).

When the assignment operator is used in combination with attributes, variables, and methods that contain or return simple type values, the process is relatively simple. The variable on the left side always gets the value from the right side.

However, things get a bit more complicated if the operands are variables representing objects or pointers (Figure 15). Suppose the first operand is a pointer to an object (variable “object1”), and the second operand is also a pointer to some object (variable “object2”). The assignment operator assigns the contents of the variable on the right side to the variable on the left side. In this case, the memory address stored in the variable “object2” will be assigned to the variable “object1”, so both pointers will point to the same memory location, i.e., the same object. The memory location that no pointer is pointing to will soon be freed by the garbage collection mechanism.

An additional effect that occurs in this case is that now both pointers access the same memory location (the same object). This can be seen in a practical example.

Example 5

Write a class Product that has only one attribute - name, and one method printProduct that prints the value of this attribute to the screen.

Create a TestProduct class that creates two objects of the Product class with product names car and tractor and:

• Print the attribute values of both products.

• Assign the address of the first object to the second object. Print the attribute values again.

• Change the name of the second product to combine harvester and print the values again.

  class TestProduct {

   1   public static void main(String[] args) {
   2       Product p1 = new Product();
   3       Product p2 = new Product();
   4 
   5       p1.name = "car";
   6       p2.name = "tractor";
   7 
   8       p1.printProduct();
   9       p2.printProduct();
  10       //It will print:
  11       //Product name is: car
  12       //Product name is: tractor
  13 
  14       //Both variables p1 and p2 now point to the
  15       // same Product object in memory, the
  16       // one named car
  17       p2 = p1;
  18 
  19       p1.printProduct();
  20       p2.printProduct();
  21       // It will print:
  22       //Product name is: car
  23       //Product name is: car
  24 
  25       //It will change the product name
  26       // car to combine harvester
  27       p2.name = "combine harvester";
  28 
  29       p1.printProduct();
  30       p2.printProduct();
  31       // It will print:
  32       //Product name is: combine harvester
  33       //Product name is: combine harvester
  34   }
  

  }

At the moment when the variable (pointer) p2 is assigned the content of the pointer p1, both pointers will reference the same memory location, i.e., the same object. From that point on, any changes made to the object pointed to by p2 will also be “visible” to the object pointed to by p1 and vice versa.

Method parameters are values that need to be passed to the method so it can execute properly. A method can have zero, one, or more parameters, and parameters are declared in the method header in a similar way to variables (first the data type, then the parameter name).

This type of parameter is called a formal parameter (or just a parameter). If a method has more than one parameter, they are separated by commas:

Calling methods that have parameters is done by placing concrete values or variables between parentheses. When these concrete values or variables are passed as parameters, they are called arguments (real or actual parameters). When calling such a method, the number of parameters, their types, and the order must be respected, otherwise a syntax error will appear.

In other words, if a method takes two parameters of some data type, every call to that method must ensure that exactly two arguments of the corresponding data type and order are passed.

It’s also important to note that methods of one class can be (if needed) called from another method of the same class relatively simply — by calling the method’s name and passing parameters. It’s not necessary to create an object for this.

Also, the order in which methods are written in the class is not important, so a method can be called even if it’s written “below” the calling method, for example:

Example 6

Create a class CashMachine. This class should have:

• An attribute balance that represents the current amount of money in the machine (a real number). The initial value of this attribute is 5200.0 dollars.

• A method printBalance that prints the current amount of money in the machine (the value of the balance attribute) to the screen.

• A method withdrawAmount that takes as a parameter the amount of money the user wants to withdraw (a real number, e.g., 550.5) and reduces the value of the balance attribute by that amount. Then, it prints the current amount of money to the screen by calling the printBalance method.

• A method depositAmount that takes as a parameter the amount of money the user wants to deposit (a real number) and increases the value of the balance attribute by that amount. Then, it prints the current amount of money to the screen by calling the printBalance method.

• A method getBalance that returns the current amount of money in the machine (the value of the balance attribute).

  class CashMachine { double balance = 5200.0;

   1   void printBalance(){
   2       System.out.println("The current balance is: "+ balance);
   3   }
   4 
   5   //"amount" is a formal parameter
   6   void withdrawAmount(double amount){
   7       balance = balance - amount;
   8 
   9       //It is possible to call a method from the
  10       // same class within another method, if needed
  11       printBalance();
  12   }
  13 
  14   //"amount" is a formal parameter
  15   void depositAmount(double amount){
  16       balance = balance + amount;
  17 
  18       //It is possible to call a method from the
  19       // same class within another method, if needed
  20       printBalance();
  21   }
  22 
  23   double getBalance(){
  24       return balance;
  25   }
  

  }

Create a class TestCashMachine in whose main method two objects of the CashMachine class are created. In the first cash machine, you need to deposit 1002.03 dollars and print the balance before and after the deposit. You also need to withdraw 234.55 dollars from the second machine and print the balance before and after the deposit.

The methods withdrawAmount and depositAmount each have one parameter. In both cases, the parameter is a real number, so the parameter type is double. These are formal parameters because they are defined within the method header. The parameter name is always arbitrary, but it’s important to use this name within the method body when the parameter is needed. These two methods don’t return a value since they only modify the value of the balance attribute. In addition, both methods call the printBalance method to perform the printing of the balance after each deposit/withdrawal. The call is made simply by invoking the method name and passing the parameters.

In the main method of the TestCashMachine class, you can see the difference between parameters (formal parameters) and arguments (actual parameters). The formal parameter of the method depositAmount is amount, which is of type double, while the argument is the specific number or variable that is passed to the method during the call (in this case, the number 1002.03).

Method parameters can be simple data types (int, double, boolean, char), but also complex types (classes). In other words, a method can have an object as a parameter. Additionally, a method can return an object as a result.

Some of the most common syntax errors related to writing methods are:

• Forgetting to specify void as the return type in the method declaration if the method does not return a value.
• Forgetting to call the return statement in the method body when the method has a return type that is not void.
• Writing the return statement in the method body so that it’s not the last statement in that block of commands.
• Returning a value of the wrong type from the method body via the return statement (e.g., returning a double value when the method is declared to return an int).
• Forgetting to write the opening and/or closing curly braces at the start and end of the method body (command block).

  • Forgetting to write parentheses when calling a method, e.g.:

    m.turnOn;

instead of (correctly):

• Forgetting to pass arguments when calling a method with parameters, e.g.:

  m.turnOn();

instead of (correctly):

• Calling a method with the wrong order or type of arguments. For example, a method with the declaration

  double power(double number, int exponent)

should NOT be called like this:

but instead (correctly):

• Calling a method with a return value and storing that return value in a variable of the wrong type. For example, a method with the declaration

  double power(double number, int exponent)

should NOT be called like this:

but instead (correctly):

• On the left side of the assignment operator, there is no variable (but instead a method call, expression, etc.), or the left and right sides are “flipped”, e.g.:

  m.calculate(12) = x; 2 + 3.14 = a;

instead of (correctly):

Other common mistakes that are not syntax errors, but affect the program’s behavior are:

• Incorrectly calling a similarly named method – the name doesn’t match the declaration exactly (case sensitivity, etc.)
• Incorrectly calling a similarly named method with similar parameters – the order or number of parameters doesn’t match the declaration exactly.

• Arithmetic operators in Java
• Operator precedence
• Most common errors

In the Java programming language, it is possible to write various arithmetic expressions. Some of the previous examples already include the use of the addition and subtraction operators, but the complete list of arithmetic operators can be seen in the following table.

The addition, multiplication, and subtraction operators are used in a similar way as they would be in mathematics. These operators can be used with both integer and real values and variables. Java also allows the use of parentheses, so expressions like this are common:

Increment and decrement operators increase or decrease the value of an integer variable by one. They provide a shorthand for certain arithmetic expressions, so the following two sets of expressions are entirely equivalent:

Operators +=, -=, *=, /=, and %= were introduced to allow for shorter notation when new values of variables are calculated based on their existing values. Therefore, the following two sets of expressions are equivalent:

The division operators in Java are slightly more complex than they may initially seem. First, the operator for real number division and the operator for integer division are both represented by the same symbol - the forward slash (/).

Real number division is “normal division” (e.g., 11.0 / 3 = 3.66666).

Integer division, on the other hand, represents division without remainder (e.g., 11 / 3 = 3). In this case, the decimal part (the part after the decimal point 0.66666) is discarded, and the integer part is returned as the result (3).

Since both operators are written the same way, the question arises as to how the Java compiler distinguishes when to use one and when to use the other. The answer is quite simple – it checks whether the operands (numbers or variables being divided) are integers or real numbers, and applies the appropriate operator.

If both numbers are integers, integer division is used.

If at least one of the numbers is real, real number division is used.

Additionally, division by zero is not allowed, so the following expressions would cause an error:

The operator for calculating the remainder of integer division can only be used with integer values. The result represents the whole number that remains as the remainder when two integers are divided. The division and remainder operators are best explained through a few simple examples.

Example 1

The following expressions in Java will be interpreted as real number division expressions (class ArithmeticExpressions):

As seen in the last example, it is possible for unexpected results to occur during division if the wrong operator is used. The cause is always the incorrect use of the integer division operator instead of the real number division operator.

To ensure the previous expression is interpreted as real number division, it needs to be written in one of the following ways:

Here are a few examples using the operator for calculating the remainder of integer division:

This operator can be used to check if a number is even, as the remainder when divided by two will always be zero if the number is even and one if it is odd. Similarly, it can check divisibility by other numbers (the remainder is zero if the number is divisible and non-zero otherwise).

Finally, as in mathematics, not all arithmetic operators in Java have the same precedence (the order in which they are evaluated in an expression). Java has operator precedence rules which define that:

• Increment (++) and decrement (—) operators have higher precedence than all other operators.
• Multiplication (*), division (/), and remainder (%) have higher precedence than addition (+) and subtraction (-).
• In an expression where parentheses have been used, the part of the expression within the innermost parentheses will be evaluated first, and so on.
• In an expression where all operators that have been used have the same precedence and no parentheses have been used, the expression will be evaluated left to right.

In other words, if parentheses are not used in an arithmetic expression, operator precedence will be followed, for example:

Some of the most common syntax errors related to using arithmetic operators and the assignment operator are:

• The variable on the left side and the expression on the right side of the assignment operator are not of the same type, e.g.:

  int number = 12.3; int result = 35.4 - 2; int result2 = m.multiply(154.3, 122.02);

instead of (correct):

• Division by zero (zero is the divisor):

  34 / 0;

Other common mistakes that are not syntax errors, but affect program behavior:

• Incorrectly using integer division instead of real number division. This often results in (unexpected) zero:

  // The result is zero, not 0.5 12 / 24

  // The percentage of girls will be 0.0, not 50.0 int numberOfStudents = 30; int numberOfGirls = 15; double percentageOfGirls = numberOfGirls / numberOfStudents * 100.0;

instead of:

• Variable visibility (variable scope)
• Visibility conflict and reserved word this
• Most common errors

As a reminder, depending on where they are declared in the code, there are four types of variables:

• Local variables (or simply variables) – variables declared within the body of a method.
• Attributes – variables directly belonging to the objects of a class. They are defined within the body of the class.
• Global variables – variables not belonging to individual objects of a class, but used throughout the program. They are defined similarly to attributes.
• Parameters – variables of a method declared in the method’s signature (representing input values for the method). Technically, they are also local (method) variables.

To fully understand the functioning of methods, it is necessary to introduce and explain the concept of variable visibility. Variable visibility determines from which part of the program a variable can be accessed. In literature, instead of the term “variable visibility” the term variable scope is often used.

The rules defining variable scope in the Java programming language are related to variable types:

• All local variables (including parameters) are “visible” (can be accessed) only within the body of that method and nowhere else.
• All attributes of a class are always visible within the body of that class and can be accessed outside the class if not restricted (see lesson on access levels).
• Global variables can be accessed within the class body and more broadly, unless restricted (see lesson on access levels).

Example 1

Let’s say the class Calculator has:

• An attribute pi representing the corresponding mathematical constant (the value is roughly 3.14).

• A method add that takes two integers as parameters and returns the result of their addition.

• A method calculateCircleCircumference that takes the radius of a circle as a parameter and returns the circumference as the result (the formula is 2 * radius * pi).

  class Calculator { double pi = 3.14;

   1   int add(int a, int b){
   2       int result;
   3       result = a + b;
   4       return result;
   5 
   6       //Or shorter, all in one command
   7       //return a + b;
   8   }
   9 
  10   double calculateCircleCircumference(double radius){
  11       //Not allowed since a and b are local
  12       //variables visible only in the add method
  13       //System.out.println(a + b);
  14 
  15       double result;
  16       result = 2 * radius * pi;
  17       return result;
  18 
  19       //Or shorter, all in one command
  20       //return 2 * radius * pi;
  21   }
  

  }

Attribute pi is an attribute of the class Calculator, so it is visible (it can be accessed and used) within the body of any method of the Calculator class (it is used in the method body of calculateCircleCircumference).

On the other hand, variables a and b are parameters of the method add. This means they are visible (can be used and accessed) only within the body of this method. If an attempt is made to access variables a and b from the body of the method calculateCircleCircumference, a syntax error will occur.

The same applies to the parameter radius – it is visible only within the body of the calculateCircleCircumference method and nowhere else.

A quick review of the code might suggest there is a conflict because two variables named result are declared — one in the body of the first method, and the other in the body of the second method. However, this is not the case. In Java, these two variables are considered completely different because the result variable in the add method is only visible within the body of the add method, while the result variable in the calculateCircleCircumference method is only visible within the body of the calculateCircleCircumference method.

A conflict in “visibility” between parameters and attributes can arise if a method’s parameter or variable has the same name as an attribute of the class. In such cases, the reserved word this is used to distinguish the attribute from other variables. This reserved word is essentially a reference (pointer) to the object itself.

Example 2

Let’s say the class Person has:

• An attribute name

• A method setName that takes a name as a parameter and assigns this value to the attribute. The parameter is also called name.

  class Person { String name;

  1   void setName(String name){
  2       //Incorrect
  3       name = name;
  4 
  5       //Correct, use this to distinguish between
  6       //attribute and local variable
  7       //this.name = name;
  8   }
  

  }

What can first be noticed is that the assignment statement to the attribute name is very unclear. Which one is the attribute, and which is the parameter? Both are called “name”. Therefore, what is the effect of the command:

The answer is that Java will interpret both sides as the parameter, so the assignment to the attribute name will not happen. To make the method do what is needed, the reserved word this is used to refer to the attribute. After the correction, the method should look like this:

The expression on the left-hand side of the equality sign refers to the attribute name (this.name), while the expression on the right-hand side refers to the parameter name.

Some of the most common syntax errors related to variable visibility are:

• Attempting to access a local variable or parameter from a method where it is not declared (from another method or class):

  class X {

  1     void methodA(int parameterA){
  2         System.out.println(parameterA);
  3     }
  4 
  5     void methodB(){
  6         System.out.println(parameterA);
  7     }
  

  }

instead of (correct):

Other common mistakes that are not syntax errors but affect the program’s behavior include:

• Incorrectly accessing a local variable instead of an attribute — if both the attribute and the variable have the same name, and the reserved word this is not used, for example:

  class Car { String owner;

  1   void setOwner(String owner) {
  2       owner = owner;
  3   }
  

  }

  instead of (correct):

  class Car { String owner;

  1   void setOwner(String owner) {
  2       this.owner = owner;
  3   }
  

  }

• What is method overloading
• Most common errors

Attribute names within a class must be unique - two attributes cannot have the same name.

With methods, this is not the case. Namely, it is possible to write two or more methods with the same name within a class.

However, in order to distinguish between them, each of them must have a different list of parameters — whether it is the number of parameters or their type (or order, if changing the order results in a different list of parameters, for example, (int, String) vs. (String, int)). When calling a method, the method whose parameters exactly match the input values will be invoked. In this case, it is method overloading.

Furthermore, the return type of the method is not relevant for overloading. If two methods in the same class have the same name and the same list of parameters, differing only in the return type, overloading will not be possible, and Java will report a syntax error.

Example 1

Create the Calculator class that has four methods:

• A method named addIntegers that takes two integers as parameters and returns their sum (an integer).

• A method named addDecimals that takes two real numbers as parameters and returns their sum (a real number).

• A method named addIntegersThree that takes three integers as parameters and returns their sum (an integer).

• A method named addDecimalsThree that takes three real numbers as parameters and returns their sum (a real number).

  class Calculator {

   1   int addIntegers (int x, int y){
   2       int result = x+y;
   3       return result;
   4   }
   5 
   6   double addDecimals (double x, double y){
   7       double result = x+y;
   8       return result;
   9   }
  10 
  11   int addIntegersThree (int x, int y, int z){
  12       int result = x+y+z;
  13       return result;
  14   }
  15 
  16   double addDecimalsThree (double x, double y, double z){
  17       double result = x+y+z;
  18       return result;
  19   }
  

  }

It is important to note that these four methods are essentially almost identical, but they have been given different names. If there were a need to create more versions of these methods for summing, additional names would have to be added.

The following example contains the code for a different version of the Calculator class - with method overloading used.

Example 2

Create the Calculator2 class that has four overloaded methods with the same name - add:

• The first method takes two integers as parameters and returns their sum (an integer).

• The second method takes two real numbers as parameters and returns their sum (a real number).

• The third method takes three integers as parameters and returns their sum (an integer).

• The fourth method takes three real numbers as parameters and returns their sum (a real number).

  class Calculator2 {

   1   int add (int x, int y){
   2       int result = x+y;
   3       return result;
   4   }
   5 
   6   double add (double x, double y){
   7       double result = x+y;
   8       return result;
   9   }
  10 
  11   int add (int x, int y, int z){
  12       int result = x+y+z;
  13       return result;
  14   }
  15 
  16   double add (double x, double y, double z){
  17       double result = x+y+z;
  18       return result;
  19   }
  

  }

Write a TestCalculator class that calls all of these methods.

The first call to the add method activates the method that sums two real numbers and returns a real number as a result.

The second call to the add method activates the method that sums two integers and returns an integer as a result.

In the first case, real numbers were entered as parameters, and in the second case, integers.

Similarly, the next two calls activate the overloaded versions of the add method that sum three real or three integer numbers respectively and return a real or integer number as the result.

What is the purpose of method overloading? In cases where multiple similar versions of a method are needed (with the same or almost the same functionality), overloading is used so that:

• You don’t have to come up with new names for each
• version (e.g., “addIntegers”, “addReals”, “addIntegersThree”…)
• It shows the relationship between these methods through the same name.
• It makes it easier to find the most suitable version of the method that needs to be called.

Some of the most common syntax errors when writing overloaded methods include:

• Writing overloaded methods (with the same name) that do NOT differ in parameters (number, type, and/or order), but only in the return value, for example:

  int add (int a, int b){ return a + b; }

  double add (int a, int b){ return a + b; }

instead of (correctly):

• The concept of parameter passing
• Passing method parameters by value and by reference
• Most common errors

What is (method) parameter passing? It was already explained that a method has:

• Formal parameters (stated as part of the method’s header)
• Real parameters (arguments - real values passed on to the method upon method call)

Parameter passing is, commonly speaking, the way real parameters (arguments) are passed to the method upon calling the method to execute.

Why is this important? Because some programing languages automatically make copies of argument values and pass those copies to methods (thus making the “original” value intact even if the copied value changes during method execution), while others support passing the “original”, so it can be altered during method execution. Some languages support both options.

As stated, in programming languages, there are usually at least two types of ways to pass parameters to methods:

• Passing parameters by value (make and pass copy)
• Passing parameters by reference (pass original)

In the Java programming language, all parameters are passed by value (formally speaking), but this means different things depending on whether the parameter is of a primitive type or not. This can lead to confusion, making it seem like changes made to a parameter won’t affect the original value. This is explained in more detail in the following examples.

When primitive type arguments are passed to a method, the parameter is passed by value in the “expected” way. This means that the value of the argument is copied. Each time a parameter is referenced inside the method’s body, it is actually a copy of the passed argument. Therefore, changes made to the parameter during the method’s execution will not persist (since changes are made to the copy, not the original). After the method finishes, the copy is discarded.

Example 1

Let’s consider the class ParameterPassing, which has two methods:

• The method calculateSquare takes an integer as a parameter, squares it (modifies the parameter itself), and prints the result to the screen.

• The method swapNumbers takes two integers as parameters and tries to swap their values.

  class ParameterPassing {

   1   void calculateSquare(int number) {
   2       number = number * number;
   3 
   4       System.out.println("It's square is: " + number);
   5   }
   6 
   7   void swapNumbers(int a, int b) {
   8       int pom = a;
   9       a = b;
  10       b = pom;
  11   }
  

  }

And, let’s consider the TestParameterPassing class which calls both methods of the ParameterPassing class and prints the results to the screen.

When the program runs, the following values will be printed on the screen (the initial values of the variables k, x, and y remain unchanged):

It can be seen that the variable k has the same value before and after squaring, even though it was passed to the calculateSquare method. Also, neither the variables x nor y have swapped values after calling the second method. The reason is that these values were passed to the method as primitive parameters, i.e., they were passed by value.

What does passing a parameter by value actually mean, and how does it look in the computer’s memory (Figure 16)?

When the calculateSquare method is called, the value of the variable k, which is 13, is passed to the calculateSquare method as an argument. This means a new local variable number is created in the calculateSquare method, and the value 13 is stored in it — this is a copy. The squaring operation inside this method only changes the value of the variable number (the copy of the number 13), while the variable k keeps the same value. When the square is printed, the value of number, which is 169, is printed. Once the method finishes, all its local variables are discarded, including the number variable. Finally, when the value of k is printed after the square method finishes, it prints 13.

Something similar happens when the swapNumbers method is called (Figure 17). The values of the variables x and y, i.e., the numbers 22 and 15, are passed to the swapNumbers method as arguments for the formal parameters a and b. This means that new local variables a and b are created in the swapNumbers method, and the values 22 and 15 are stored in them — these are copies. Then, a new local variable temp is introduced to perform the swap. Swapping the values inside this method only changes the values of the variables a and b, while the variables x and y retain their original values. When the method execution finishes, all its local variables are discarded — variables a, b and temp. This means that the changes to the numbers are not retained. When the values of x and y are printed after the swapNumbers method finishes execution, the original values of 22 and 15 are printed (not 15 and 22 as one might expect).

If an object (a complex type) is passed to a method as an argument, the parameter is still passed by value. However, the value of the parameter in this case is the object’s address, so it would be more accurate to say that the parameter is passed by reference.

Here’s the explanation. Passing an object as an argument is done by specifying the corresponding pointer to the object — the variable. In this case, the argument’s value is copied, and since it’s a pointer, the memory address of the original object is copied. When the parameter is referenced inside the method, it accesses the object at the address that was previously copied, which is where the original object is.

The consequence of this approach is that changes made to the object passed as an argument during the method’s execution are retained after the method finishes (such as changes to the values of the object’s attributes, its relations, or calling its methods). However, changes made to the address of the passed object (within the method’s body) won’t be retained after the method finishes (such as creating a new object or replacing the address with null or another value) because the changes are made to a copy of the address, and the original pointer still holds the original address.

Example 2

Let’s consider the class Person, which has the attributes height (integer) and weight (floating-point number).

Let’s also consider the class ParameterPassing2, which has three methods:

• The first method takes a Person object as a parameter and adds 5 kilograms to the person’s existing weight (modifies the weight attribute).

• The second method takes two Person objects as parameters and swaps their places by swapping the addresses of the passed objects.

• The third method takes a Person object as a parameter and creates a new object at a new address.

  class ParameterPassing2 {

   1   void addWeight(Person person) {
   2       person.weight = person.weight + 5;
   3   }
   4 
   5   void swapPersons(Person person1, Person person2) {
   6       Person tmp = person1;
   7       person1 = person2;
   8       person2 = tmp;
   9   }
  10 
  11   void makeNewPerson(Person newPerson) {
  12       newPerson = new Person();
  13   }
  

  }

The TestParameterPassing2 class calls all three methods from ParameterPassing2 and prints the results to the screen.

When the main method of the TestParameterPassing2 class is run, the following will be printed:

The addWeight method works as expected because the person’s weight has truly been permanently changed from 95 to 100 kilograms.

Then, we see that the persons were not swapped after executing the swapPersons method. The reason is that the addresses of the entire objects cannot be swapped.

Finally, the new object created by the makeNewPerson method was not actually passed back to the variable p2 — the values for weight and height remain the same and are not changed to 0 cm and 0 kg (which would be expected for a new Person object - the default values for its int and double attributes height and weight).

What does passing a parameter by reference actually mean, and how does it look in the computer’s memory?

Based on the previous example, we can see the following (Figure 18). When the addWeight method is called and the variable p1 is passed as a parameter, the address from this variable (e.g., 450) is copied to the new local variable person in this method. The object itself is not copied; there are now two pointers pointing to the same object in memory (p1 and person). When the addWeight method is executed, it accesses the address passed (the original object) and changes the value of its weight attribute from 95 to 100. After the addWeight method finishes, the local variable person is discarded, but the object at address 450 is not deleted (since p1 still points to it). Finally, p1 retains the address 450, pointing to the same object, which now has the updated weight. When the method for printing is called, it shows that the person has a height of 196 cm and a weight of 100 kg.

A similar thing happens during the execution of the swapPersons method, but the objects will not swap places because the addresses of the passed objects cannot be swapped (Figure 19). When the method is called, the values of the parameters p1 and p2 (addresses 450 and 335) are first copied to the new local variables person1 and person2. Then, the addresses of person1 and person2 are swapped using the new local variable temp. After this swap, only the variables person1 and person2 have swapped addresses (now 335 and 450, respectively), but the variables p1 and p2 still hold their initial addresses (450 and 335). When the swapPersons method finishes, the local variables person1, person2, and temp are discarded, but p1 and p2 retain their original addresses, so the effect of this method is invalid. The objects at addresses 450 and 335 are not deleted because p1 and p2 still point to them, and the screen output will show the unchanged details for both persons.

Finally, when the makeNewPerson method is executed, a new object is created (address 620). This new object is passed to the local variable newPerson in the method, but it does not replace the reference from the p1 variable, since p1 still points to the original address 450. Therefore, the new object is discarded once the method ends, and the output on the screen does not show any changes to p1.

Finally, if the methods swapPersons and makeNewPerson should be rewritten to behave as expected, they would need to swap the values of the attributes of the input objects (first method) and return the address of the new object as the method’s return value, which should then be stored in the initial variable, while removing the parameter (second method). The modified code could look like this:

Common mistakes related to parameter passing in methods that are not syntax errors, but affect the program’s behavior are:

• Passing a primitive type variable as a parameter to a method and expecting the method to change the value of the passed variable. Since it’s working with a copy, the value remains unchanged.
• Passing a complex type (object) variable as a parameter to a method and expecting that the method will not change the attribute values of the passed variable. Since it’s working with the original object through its address, the values of its attributes will be modified.
• Passing a complex type (object) variable as a parameter to a method and expecting that a new object will be initialized within that variable. Since it’s working with the original object through its address, the initial variable (which was passed to the method) will still hold the address of the original object.

• What is a constructor - idea, declaration
• Default, no-argument, and parameterized constructors
• Most common errors

Every time it is necessary to initialize an object, the new command is used. After this reserved word, the class name is always followed by an open and close parentheses. It has already been explained that during initialization, memory space is reserved for the new object. However, after the memory space is reserved, one more thing happens: the constructor is called.

A constructor is a special method that can assign initial values to the object’s attributes during its initialization. This means the class constructor is automatically called every time the new command is used.

The constructor definition is almost the same as a method definition, with two limitations:

• The constructor’s name is always the same as the class name (if named differently, Java will not consider it a constructor, but a regular method).
• Constructors never have a return value (other than the object of that class), so the header does not include even “void.”

In previous examples, constructors were not explicitly written for the class. When a class in Java does not have an explicitly written constructor, Java automatically assigns a default constructor to it.

Upon calling, the default constructor sets the attribute values to default values for their data type (int to 0, double to 0.0, boolean to false , String to null, etc.), unless the attribute values are already set to initial values during the declaration.

If a class has an explicitly written constructor, Java does not create a default constructor.

However, in some situations, it is convenient to explicitly write a constructor because initial values can be assigned to attributes during class initialization, or some messages can be printed, etc.

Constructors are divided into two types depending on whether they have parameters or not. The first type is parameterized constructors, and the second is no-argument constructors (which include the default constructor). One default and one explicit constructor are shown in the following example.

Example 1

Create a class FoodItem with two attributes:

• name and
• caloricValue

Assign the initial value “unknown” to the first attribute, and 0.0 to the second.

Create a class FoodItem2 with two attributes:

• name and
• caloricValue

Create a constructor that assigns the initial value “unknown” to the first attribute, and 0.0 to the second.

Class FoodItem does not have an explicitly written constructor, so Java assigns a default constructor to it (it is not visible in the code), and initial values are assigned immediately upon attribute declaration.

On the other hand, class FoodItem2 has an explicitly written no-argument constructor (it has no parameters) that assigns initial values to the attributes.

First, it should be noted that, unlike a regular method, the constructor does not have a return value - it does not even use “void”, because it always returns an object of FoodItem class. The constructor header just starts with its name. Second, the constructor’s name is exactly the same as the class name (FoodItem2 - the first letter of each word is capitalized). Finally, it can be seen that the effect of executing the constructor is exactly the same as assigning initial values to attributes immediately upon their declaration.

This means that when initializing an object of class FoodItem, the default constructor, which Java automatically assigned to the class, is called, and the values are assigned to the attributes through their declaration.

When initializing an object f2 of class FoodItem2, the explicitly written no-argument constructor is called, which assigns values to the attributes.

The purpose of the constructor is to initialize an object during creation, bringing it into an initial state. However, in some cases, the constructor needs to do more than just assign initial values to attributes. This is illustrated in the following example.

Example 2

Create a class FoodItem3 with two attributes:

• name and
• caloricValue

Create a constructor that assigns the initial value “unknown” to the first attribute, 0.0 to the second, and prints a message about the initial values of the attributes on the screen.

The constructor of class FoodItem3 also prints some messages to the screen. In other words, every time an object of this class is initialized, the initial values of its attributes will be printed to the screen:

Default constructors always set attributes to default values (unless specific values are assigned during declaration). Parameterized constructors, on the other hand, can set attributes to values provided as parameters during object creation. This way, through a single constructor call, one or more attribute values can be assigned, making it much easier to use the class. This can be seen in the following example.

Example 3

Create a class Person with two attributes:

• firstName and
• lastName

Create a constructor that has two parameters, where the first contains a new value for the first name, and the second contains a new value for the last name. This constructor should assign the entered values to the attributes.

Create a class TestPerson in which an object of class Person is created and immediately assigned the values “Peter” for the first name and “Smith” for the last name through the constructor.