Previous | Next | Trail Map | Writing Java Programs | Objects, Classes, and Interfaces

The Class Declaration (1.1notes)

At minimum, a class declaration must contain the class keyword and the name of the class that you are defining. Thus the simplest class declaration that you can write looks like this: 
class NameOfClass {
    . . .
}
For example, this code declares a new class named ImaginaryNumber: 
class ImaginaryNumber {
    . . .
}
Class names must be a legal Java identifier and, by convention, begin with a capital letter. Often, a minimal class declaration such as this one is all you'll need. However, the class declaration can say more about the class. More specifically, within the class declaration you can:

Declaring a Class's Superclass

In Java, every class has a superclass. If you do not specify a superclass for your class, it is assumed to be the Object class (declared in java.lang). So the superclass of ImaginaryNumber is Object because the declaration did not explicitly declare it to be something else. For information about the Object class, see The Object Class.

To specify an object's superclass explicitly, put the keyword extends plus the name of the superclass between the name of the class that you are declaring and the curly brace that opens the class body, like this: 

class NameOfClass extends SuperClassName {
    . . .
}
For example, suppose that you wanted the superclass of ImaginaryNumber to be the Number class rather than the Object class. You would write: 
class ImaginaryNumber extends Number {
    . . .
}
This explicitly declares that the Number class is the superclass of ImaginaryNumber. (The Number class is part of the java.lang package and is the base class for the Integer, Float, and other subclasses.)

Declaring that Number is the superclass of ImaginaryNumber implicitly declares that ImaginaryNumber is the subclass of Number. A subclass inherits variables and methods from its superclass. Creating a subclass can be as simple as including the extends clause in your class declaration. However, you usually have to make other provisions in your code when subclassing a class, such as overriding methods. For more information about creating subclasses, see Subclasses, Superclasses, and Inheritance.

Listing the Interfaces Implemented by a Class

When declaring a class, you can specify which, if any, interfaces are implemented by the class. So, what's an interface? An interface declares a set of methods and constants without specifying the implementation for any of the methods. When a class claims to implement an interface, it's claiming to provide implementations for all of the methods declared in the interface.

To declare that your class implements one or more interfaces, use the keyword implements followed by a comma-delimited list of the interfaces implemented by your class. For example, imagine an interface named Arithmetic that defines methods named add, subtract, and so on. The ImaginaryNumber class can declare that it implements the Arithmetic interface like this: 

class ImaginaryNumber extends Number implements Arithmetic {
    . . .
}
thereby guaranteeing that it provides implementations for add, subtract and other methods declared by the Arithmetic interface. If any implementations for methods defined in Arithmetic are missing from ImaginaryNumber, the compiler will print an error message and refuse to compile your program: 
nothing.java:5: class ImaginaryNumber must be declared abstract.
It does not define java.lang.Number
add(java.lang.Number, java.lang.Number) from interface Arithmetic. 
class ImaginaryNumber extends Number implements Arithmetic {
      ^
By convention, the implements clause follows the extends clause if there is one.

Note that the method signatures of the methods declared in the Arithmetic interface must match the method signatures of the methods implemented in the ImaginaryNumber class. This and other information about how to create and use interfaces is in Creating and Using Interfaces.

Public, Abstract, and Final Classes

You can use one of three modifiers in your class declarations to declare that your class is public, abstract, or final. The modifiers go before the class keyword and are optional.

The public modifier declares that the class can be used by objects outside the current package. By default a class can only be used by other classes in the same package in which it is declared. You'd probably like other classes and objects to be able to use ImaginaryNumber, so it should be declared public: 

public class ImaginaryNumber extends Number implements Arithmetic {
    . . .
}
By convention, when you use the public keyword in a class declaration, make it the very first item in the declaration.

The abstract modifier declares that your class is an abstract class. An abstract class may contain abstract methods (methods with no implementation). Abstract classes are intended to be subclassed and cannot be instantiated. For a discussion about when abstract classes are appropriate and how to write them, see Writing Abstract Classes and Methods.

When you use the final modifier you declare that your class is final; that is, that your class cannot be subclassed. There are (at least) two reasons why you might want to do this: security reasons and design reasons. For further discussion of final classes, see Writing Final Classes and Methods.

Note that it doesn't make sense for a class to be both final and abstract. In other words, a class that contains unimplemented methods cannot be final. Attempting to declare a class as both final and abstract results in a compile-time error.

Summary of a Class Declaration

In summary, a class declaration looks like this: 
[ modifiers ] class ClassName [ extends SuperClassName ] [ implements InterfaceNames ] {
    . . .
}
The items between [ and ] are optional. A class declaration defines the following aspects of the class: Of the items in a class declaration, only the class keyword and the class name are required in a class declaration. The other items are optional. If you do not make an explicit declaration for the optional items, the Java compiler assumes certain defaults: a non-final, non-public, non-abstract, subclass of Object that implements no interfaces.

Previous | Next | Trail Map | Writing Java Programs | Objects, Classes, and Interfaces