Objects, Classes, and Interfaces |
At minimum, a class declaration must contain theclass
keyword and the name of the class that you are defining. Thus the simplest class declaration that you can write looks like this:For example, this code declares a new class named ImaginaryNumber:class NameOfClass { . . . }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:class ImaginaryNumber { . . . }
- 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:For example, suppose that you wanted the superclass of ImaginaryNumber to be the Number class rather than the Object class. You would write:class NameOfClass extends SuperClassName { . . . }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.)class ImaginaryNumber extends Number { . . . }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 namedadd()
,subtract()
, and so on. The ImaginaryNumber class can declare that it implements the Arithmetic interface like this:thereby guaranteeing that it provides implementations forclass ImaginaryNumber extends Number implements Arithmetic { . . . }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:By convention, thenothing.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 { ^implements
clause follows theextends
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 theclass
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:By convention, when you use thepublic class ImaginaryNumber extends Number implements Arithmetic { . . . }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:The items between [ and ] are optional. A class declaration defines the following aspects of the class:[ modifiers ] class ClassName [ extends SuperClassName ] [ implements InterfaceNames ] { . . . }Of the items in a class declaration, only the
- 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
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 |