Writing your first class

Written Explanation

One class, one file

Up to now your programs were a single class with a main method. A class that models something from the real world is usually a separate file, and Java has a firm rule for it: a public class must live in a file whose name is the class name plus .java. The class Account goes in Account.java.

public class Account {
    String owner;
    String number;
    double balance;
}

If the names do not match, the compiler refuses. Here the same class sits in a file called Acct.java:

Acct.java:1: error: class Account is public, should be declared in a file named Account.java
public class Account {
       ^
1 error

The usual layout is one class per file, all files in the same folder (or the same package of your IDE project). The class with main is just another class; it is often called Main.

Naming classes

By convention, a class name is a noun that starts with a capital letter, and each new word also starts with a capital: Account, BankStatement, ShoppingCart. This is called UpperCamelCase (or PascalCase). The compiler does not enforce it, but every Java developer expects it, so a class called account looks like a mistake. Variables and fields, in contrast, start with a lower-case letter (balance, accountNumber).

Fields

A field is a variable declared directly inside the class, outside every method. It is the state from the previous module, written as code. A field declaration has a type and a name, just like a local variable:

String owner;     // text
String number;    // text, such as "A-1"
double balance;   // a number with a fractional part

Money as double is a shortcut for this module so we can focus on classes. It is not a good way to store money, because double cannot represent many decimal amounts exactly. A better approach comes later in the course.

The class only declares the fields. It does not hold any values itself, just as the architect's drawing is not a house. Values exist only after you build an object.

Building an object and using the dot

You build an object with new. According to the Java tutorial, new allocates memory for a new object and returns a reference to it. You will look at references properly in Lesson 4. For now, read this line as "make one account and call it a":

Account a = new Account();

The dot reaches into the object: a.owner = "Ana"; assigns that object's owner, and a.owner reads it. Notice what you write: a variable name, a dot, a field name. You never write Account.owner to reach an object's data, because the class is only the blueprint.

Each object has its own copy

Every object gets its own set of instance fields. If you build two accounts, there are two owner values, two number values, and two balance values, and changing one account does not touch the other. This is the difference between a class (one definition) and objects (many copies of the state), and it will come back in Lesson 5, when we meet the one kind of field that is not copied per object.

Default values

What happens if you build an object and never set a field? Java fills fields with a default value:

null means "no object here". The Java tutorial adds that relying on these defaults is generally considered poor style, so in the next lesson we will write constructors that set every field deliberately.

Defaults apply to fields only. A local variable, one declared inside a method, never gets a default. Using one before assigning it is a compile-time error: "variable might not have been initialized". Do not mix up the two.