| Objects, Classes, and Interfaces

## The Class Declaration

> 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:
> - declare what the class's superclass is
> - list the interfaces implemented by the class
> - declare whether the class is public, abstract, or final

> #### 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 Integers, Floats and other numbers.)

> > 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 class should be declared public:

> > >     public class ImaginaryNumber extends Number implements Arithmetic {
> > >         . . .
> > >     }

> > By convention, when you use the `public` keyword in a class declaration, you should 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.

> > Using the `final` modifier you can 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:
> > - modifiers declare whether the class is public, abstract, or final
> > - ClassName sets the name of the class you are declaring
> > - SuperClassName is the name of ClassName's superclass
> > - InterfaceNames is a comma-delimited list of the interfaces implemented by ClassName
> > Of the items in a class declaration, only the `class` keyword and the class name are required. The others 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).

| Objects, Classes, and Interfaces