View source for Chapter:Programming in Java - Exercises

=Exercises for the Programming in Java chapter=
== The layout of a Java program == 
===Write your first "Java class"===
Write the Small class yourself using an [[editor]] (e.g [[Editor#Atom_editor|Atom]]).
<syntaxhighlight lang="Java" line="false">
public class Small {

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

}</syntaxhighlight>
<div class="mw-collapsible mw-collapsed">
Expand using link to the right to see a hint.
<div class="mw-collapsible-content">
Hopefully, you entered the text as shown in the question (without line numbers).
</div>
</div>
Given that your class is called Small, what must be the name of the [[Programming_terms#source_code|source code]] file?
<div class="mw-collapsible mw-collapsed">
Expand using link to the right to see a hint.
<div class="mw-collapsible-content">
Since the class is called '''Small''', we must name the file '''Small'''.java . This is a text file containing code in the Java programming language. Since the language is java we use the suffix '''java''' . A Java source code file with a so called "public class" must be named the same as the "public class" - in this case Small - and have the file suffix <code>.java</code>
</div>
</div>
===Compile your first Java class===
Compile your Small class using [[Java#javac|javac]]
* What is the name of the compiler program?
* What is the argument given to the compiler?
<div class="mw-collapsible mw-collapsed">
Expand using link to the right to see a hint.
<div class="mw-collapsible-content">
We compile the file like this: 
<syntaxhighlight lang="bash">$ javac Small.java </syntaxhighlight>
The name of the compiler is '''javac'''

The argument is the file we want the compiler to compile, namely Small.java
</div>
</div>
===Execute your first Java program===
Execute your Small class using [[Java#java|java]]
* What is the name of the program executing your Java class?
* What is the argument given to that program?
<div class="mw-collapsible mw-collapsed">
Expand using link to the right to see a hint.
<div class="mw-collapsible-content">
We execute the file like this: 
<syntaxhighlight lang="bash">$ java Small </syntaxhighlight>
The name of the program is '''java'''

The argument is the class we want java to execute, namely Small . 

Note that we do not give <code>Small.class</code> as argument. We give <code>Small</code> (the class name) as argument. Given that class name, Java knows how to find the file containing that class. Of course this means you have to be in the same directory because that's where Java is looking for the <code>Small.class</code> file. 
</div>
</div>
===Make Java not know what to do===
Create a directory tmp. Enter the directory (tmp) and try to run the program again.
*''Note: This will not work!''
<div class="mw-collapsible mw-collapsed">
Expand using link to the right to see a hint.
<div class="mw-collapsible-content">
This will not work since, with the syntax used before, java can not find the class (see above). There are ways to make this work, but we will look into that another day. But if you enter the <code>tmp/</code> directory, which has no files in it, and issue the same command as above, <code>$ java Small</code> - as we explained above, Java will look for a file called <code>Small.class</code> and try to read it and execute the byte code instructions in it. But since there are no files in this directory, how could Java possibly find the <code>Small.class</code> file? You have given Java no hints on where to look!
</div>
</div>
===About the execution of your program===
Where does the execution start, in a Java program?
<div class="mw-collapsible mw-collapsed">
Expand using link to the right to see a hint.
<div class="mw-collapsible-content">
Execution always start in the "main method" (which is currently empty).
</div>
</div>
The program "Small", what does it do?
<div class="mw-collapsible mw-collapsed">
Expand using link to the right to see a hint.
<div class="mw-collapsible-content">
The program doesn't do anything, because the body (contents between <code>{</code> and <code>}</code> ) of the <code>main</code> method is empty. Where the execution starts, there are no instructions!
</div>
</div>
===Make your program actually do something===
Inside the so called "main method" (from now on, simply "the main method") add exactly the following statement (a statement is another word for "instruction"):
<code>System.out.println("I am a println statement");</code> (using your editor, and don't forget to save the file after the change!)
* Compile the Small.java file again
* Run the Small class again
* What does the program now do?
<div class="mw-collapsible mw-collapsed">
Expand using link to the right to see a hint.
<div class="mw-collapsible-content">
The source code file Small.java should now look something like this:
<syntaxhighlight lang="Java" line="false">
public class Small {

  public static void main(String[]args) {
    System.out.println("I am a println statement");
  }

}</syntaxhighlight>
The amount of white space (spaces) is not relevant, but it sure makes the program simpler to read, doesn't it?

We compile the file like this (as usual): 
<syntaxhighlight lang="bash">$ javac Small.java </syntaxhighlight>
We run the program like this (as usual): 
<syntaxhighlight lang="bash">$ java Small </syntaxhighlight>

The program, when run, will actually do something now! It will print <code>I am a println statement</code> in your terminal.
</div>
</div>
===Make your program do even more!===
After the newly added statement to the main, on the next line, add the following statement:

<code>System.out.println("This is an additional println statement!");</code>

* Compile the Small.java file again
* Run the "Small" class again
* What does the program now do?
* In what order are the statements executed when you run the program?
* Compare the order of the output lines, with the order of the statements in your code. Do they match?
<div class="mw-collapsible mw-collapsed">
Expand using link to the right to see a hint.
<div class="mw-collapsible-content">
The program will now look something like this:
<syntaxhighlight lang="Java" line="false">
public class Small {

  public static void main(String[]args) {
    System.out.println("I am a println statement");
    System.out.println("This is an additional println statement!");
  }

}</syntaxhighlight>
Again, you compile the program like this: 
<syntaxhighlight lang="bash">$ javac Small.java </syntaxhighlight>
Again, you run the program like this: 
<syntaxhighlight lang="bash">$ java Small </syntaxhighlight>
The program now outputs the following:
<source lang="Bash">
I am a println statement
This is an additional println statement!
</source>

The order of the output is the same as the order of the corresponding println statements. From this, we learn that statements are executed sequentially (in the same order as they are written in the source code, one by one).
</div>
</div>
==Optional slightly more advanced exercises==
===Making use of classes and objects===
Create a new Java source code file called TestTalker.java .

Add a main method like the one your previously wrote and put the following instructions inside the main:
<source lang="Java">
Talker myTalker = new Talker();
myTalker.talk();
</source>

Compile TestTalker.java . The compiler will complain about never having heard about the Talker "class". That's expected. Let's make the compiler shut up about this, by actually writing the Talker class.
<div class="mw-collapsible mw-collapsed">
Expand using link to the right to see a hint.
<div class="mw-collapsible-content">
Your program source code should now look like this:
<source lang="Java">
public class TestTalker {
  public static void main(String[] args) {
    Talker myTalker = new Talker();
    myTalker.talk();
  }
}
</source>
</div></div>
Enter the following in a Java source code file called Talker.java:
<source lang="Java">
public class Talker {
  public void talk() {
    System.out.println("I can talk.");
    System.out.println("This is me, talking.");
  }
}
</source>

Compile the TestTalker.java file again. Did the compiler now complain again about not finding the Talker class? It shouldn't if you have entered the source code for the Talker.java file exactly as above, and saved both files in the same directory.

Use <code>ls</code> to list the files in the current directory. Did the compilation of TestTalker.java produce a TestTalker.class file? It should have. But did it also create a Talker.class file out of the Talker.java file? It actually should have done that too. It did find the Talker.java class this time, but inside the Java source code file Talker.java . For this reason, the compiler also compiled that file. Why? Because your program in TestTalker.java made use of the Talker class. For this to work, when the program is run, there must be a compiled version of this class available for Java to read and use.

Now run the TestTalker program like this:
<source lang="Bash">
$ java TestTalker
</source>
Can you see any output?

What you did in this small extra exercise, was the following:
* You created a program which used another class, Talker
* Your program actually created an object of the type Talker (the Talker class is used as the type of the myTalker variable)
* Your program used the myTalker variable to send a message to the Talker object just created
* Your program had the effect that the Talker object, you referred to as myTalker ran the talk() "method"
* The talk() method executed the print statements
A method is a named place with code. You declared a method talk() in the Talker class. Now all objects of type Talker know how to "talk()". If you need a new Talker object, you write:
<source lang="Java">
Talker someVariable = new Talker();
</source>
Now you can use the <code>someVariable</code> "reference" for sending messages to the Talker object you created. A message must have a corresponding "method" in the code for the class of the object, in your case, the Talker class.

What goes on behind the scenes could be described as this:

When the program was run, the Java Virtual Machine (JVM) saw the instruction in the main method to create a new Talker object and save the reference to it in a variable. In order to do this, the JVM read the Talker.class file into the memory, in order to know what Talker objects can do. Next, the main method had an instruction for sending the talk() message to the Talker object via the reference. The JVM did now send this message by calling the talk() method for the object. This meant investigating the instructions in the talk() method in the Talker class and they were simply two statements for outputting some text. So that is what the JVM did next. After that, there were no more instructions in the main method, so the program terminated.

# Run main() for the TestTalker class
# Create a Talker object and store reference in myTalker
## Read the Talker class from the file system and look what the Talker object can do
## Create the object and store the reference in myTalker
# Send the message talk() to the object
## Call the talk() method
### Print a message
### Print another message
# No more instructions in main
# Terminate program

=Links=
==Where to go next==
[[Chapter:Programming in Java | Previous page (Programming in Java)]] | [[Chapter:Our first Java program|Next page (Our first Java program)]]