ENDS 12/4: Get 50% off your Pro annual membership using code [CYBER23](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=CYBER23)


Learn about the Java programming language and write your first programs while practicing Java conventions.

Hello World

As we saw with comments, reading code is just as important as writing code. 

We should write code that is easy for other people to read. Those people can be co-workers, friends, or even yourself!

Java does not interpret _whitespace_, the areas of the code without syntax, but humans use whitespace to read code without difficulty.

Functionally, these two code samples are identical:

```java
System.out.println("Java");System.out.println("Lava");System.out.println("Guava");
```

```java
System.out.println("Java");

System.out.println("Lava");

System.out.println("Guava");
```

They will print the same text to the screen, but which would you prefer to read? Imagine if it was hundreds of instructions! Whitespace would be essential.

Java **does** interpret semicolons. Semicolons are used to mark the end of a _statement_, one line of code that performs a single task.

The only statements we've seen so far are `System.out.println("My message!");`. 

Let's contrast statements with the curly brace, `{}`. Curly braces mark the scope of our classes and methods. There are no semicolons at the end of a curly brace.

Semicolons and Whitespace

Java is a _compiled_ programming language, meaning the code we write in a **.java** file is transformed into _byte code_ by a [compiler](https://www.codecademy.com/resources/docs/java/compiler?page_ref=catalog) before it is executed by the Java Virtual Machine on your computer. 

A compiler is a program that translates human-friendly programming languages into other programming languages that computers can execute. 

<img src="https://content.codecademy.com/courses/learn-java/revised-2019/Java%20M1L1-%20Compilation%20Process%20ART%20409.png" alt="Steps of Java Compilation" />

Previous exercises have automatically compiled and run the files for you. Off-platform development environments can also compile and run files for you, but it's important to understand this aspect of Java development so we'll do it ourselves.

The compiling process catches mistakes **before** the computer runs our code. 

The Java compiler runs a series of checks while it transforms the code. Code that does not pass these checks will not be compiled. 

This exercise will use an interactive terminal. Codecademy has a [lesson on the command line](https://www.codecademy.com/learn/learn-the-command-line) if you'd like to learn more.

For example, with a file called `Plankton.java`, we could compile it with the terminal command: 
```
javac Plankton.java
```

A successful compilation produces a **.class** file: `Plankton.class`, that we execute with the terminal command: 
```
java Plankton
```

An unsuccessful compilation produces a list of [errors](https://www.codecademy.com/resources/docs/java/errors?page_ref=catalog). No **.class** file is made until the errors are corrected and the compile command is run again.


Compilation: Catching Errors

Compilation helped us catch an error. Now that we've corrected the file, let's walk through a successful compilation.

As a reminder, we can compile a **.java** file from the terminal with the command: 
```
javac Whales.java
```

If the file compiles successfully, this command produces an _executable_ class: **FileName.class**. Executable means we can run this program from the terminal. 

We run the executable with the command: 
```
java Whales
```
Note that we leave off the **.class** part of the filename.

Here's a full compilation cycle as an example:

```java
// within the file: Welcome.java
public class Welcome {
  public static void main(String[] args) {
    System.out.println("Welcome to Codecademy's Java course!");
  }
}
```

We have one file: **Welcome.java**. We compile with the command: 

```
javac Welcome.java
```

The terminal shows no errors, which indicates a successful compilation.

We now have two files:

1. **Welcome.java**, our original file with Java syntax.
2. **Welcome.class**, our compiled file with Java bytecode, ready to be executed by the Java Virtual Machine.

We can execute the compiled class with the command: 

```
java Welcome
``` 

The following is printed to the screen:

```
Welcome to Codecademy's Java course!
```


Compilation: Creating Executables

Let's take a closer look at this instruction from our previous program:

```java
System.out.println("Hello World");
```
Print statements output information to the screen (also referred to as the [output](https://www.codecademy.com/resources/docs/java/output?page_ref=catalog) terminal). Let's break this line of code down a little more. Don't worry if some of the terms here are new to you. We'll dive into what all of these are in much more detail later on!
* `System` is a built-in Java class that contains useful tools for our programs.
* `out` is short for "output".
* [`println`](https://www.codecademy.com/resources/docs/java/output/println?page_ref=catalog) is short for "print line". 

We can use `System.out.println()` whenever we want the program to create a new line on the screen after outputting a value:
```java
System.out.println("Hello World");
System.out.println("Today is a great day to code!");
```
After `"Hello World"` is printed, the output terminal creates a new line for the next statement to be outputted. This program will print each statement on a new line like so:
```
Hello World
Today is a great day to code!
```
We also can output information using `System.out.print()`. Notice that we're using `print()`, not `println()`. Unlike `System.out.println()`, this type of print statement outputs everything on the same line. For example:
```java
System.out.print("Hello ");
System.out.print("World");
```
The above code will have the following output:
```
Hello World
```
In this example, if you were to use `print()` or `println()` again, the new text will print immediately after `World` on the same line. It's important to remember where you left your program's "cursor". If you use `println()` the cursor is moved to the next line. If you use `print()` the cursor stays on the same line.

**Note:** Going forward after this exercise, all exercises will use `System.out.println()` to output values.  You will get to practice using `System.out.print()` statements in the Checkpoints below, however.

Print Statements

Java runs on different platforms, but programmers write it the same way. Let's explore some rules for writing Java.

In the last exercise, we saw the file `HelloWorld.java`. Java files have a **.java** extension. Some programs are one file, others are hundreds of files!

Inside `HelloWorld.java`, we had a [_class_](https://www.codecademy.com/resources/docs/java/classes?page_ref=catalog):

```java
public class HelloWorld {
  
}
```

We'll talk about classes more in the future, but for now think of them as a **single** concept. 

The `HelloWorld` concept is: Hello World Printer. Other class concepts could be: Bicycle, or: Savings Account.

We marked the domain of this concept using curly braces: `{}`. Syntax inside the curly braces is part of the class.

Each file has one primary class named after the file. Our class name: `HelloWorld` and our file name: **HelloWorld**. Every word is capitalized.

Inside the class we had a `main()` _method_ which lists our program tasks:

```java
public static void main(String[] args) {

}
``` 

Like classes, we used curly braces to mark the beginning and end of a method. 

`public`, `static`, and `void` are syntax we'll learn about in future lessons. `String[] args` is a placeholder for information we want to pass into our program. This syntax is necessary for the program to run but more advanced than we need to explore at the moment.

Our program also displayed the text `"Hello World"` on the screen. This was accomplished using a print statement: 

```java
System.out.println("Hello World");
```
We'll learn more about print statements in the next exercise!

Hello Java File!

Welcome to the world of Java programming!

Programming languages enable humans to write instructions that a computer can perform. With precise instructions, computers coordinate applications and systems that run the modern world.

[Sun Microsystems](https://en.wikipedia.org/wiki/Sun_Microsystems) released the Java programming language in 1995. Java is known for being simple, portable, secure, and robust. Though it was released over twenty years ago, Java remains one of the most popular programming languages today.

One reason people love Java is the Java Virtual Machine, which ensures the same Java code can be run on different operating systems and platforms. Sun Microsystems' slogan for Java was "write once, run everywhere".

![Java Virtual Machine running Java on three different platforms](https://content.codecademy.com/courses/learn-java/revised-2019/Java%20Module%201-%20Lesson%201-JVM%20-ART%20408.png)

Programming languages are composed of _syntax_, the specific instructions which Java understands. We write syntax in files to create _programs_, which are executed by the computer to perform the desired task.

Let's start with the universal greeting for a programming language. We'll explore the syntax in the next exercise.

Introduction to Java

Writing code is an exciting process of instructing the computer to complete fantastic tasks. 

Code is also read by people, and we want our intentions to be clear to humans just like we want our instructions to be clear to the computer.

Fortunately, we're not limited to writing syntax that performs a task. We can also write [_comments_](https://www.codecademy.com/resources/docs/java/comments?page_ref=catalog), notes to human readers of our code. These comments are not executed, so there's no need for valid syntax within a comment.

When comments are short we use the single-line syntax: `//`.

```java
// calculate customer satisfaction rating
```

When comments are long we use the multi-line syntax: `/*` and `*/`.

```java
/*
We chose to store information across multiple databases to
minimize the possibility of data loss. We'll need to be careful
to make sure it does not go out of sync!
*/
```

Another type of commenting option is the Javadoc comment which is represented by `/**` and `*/`. Javadoc comments are used to create documentation for APIs (Application Programming Interfaces). When writing Javadoc comments, remember that they will eventually be used in the documentation that your users might read, so make sure to be especially thoughtful when writing these comments.

Javadoc comments are typically written before the declaration of fields, methods, and classes (which we'll cover later in this course):
```java
/**
* The following class accomplishes the following task...
*/
```
Here's how a comment would look in a complete program:

```java
/**
* The following class shows what a comment would look like in a program.
*/
public class CommentExample {
  // I'm a comment inside the class
  public static void main(String[] args) {
    // I'm a comment inside a method
    System.out.println("This program has comments!");
  }
}
```

Comments are different from printing to the screen, when we use `System.out.println()`. These comments **won't** show up in our terminal, they're only for people who read our code in the text editor.


Commenting Code

In this lesson, we've started writing our first programs in Java.

We've also learned rules and guidelines for how to write Java programs:

* Java programs have at least one class and one `main()` method.
  * Each class represents one real-world idea.
  * The `main()` method runs the tasks of the program.
* Java comments add helpful context to human readers.
* Java has whitespace, curly braces, and semicolons.
  * Whitespace is for humans to read code easily.
  * Curly braces mark the scope of a class and method.
  * Semicolons mark the end of a statement.
* Java is a compiled language.
  * Compiling catches mistakes in our code.
  * Compilers transform code into an executable class.
