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 namedclass NameOfClass { . . . }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: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 theObject
class (declared injava.lang
). So the superclass ofImaginaryNumber
isObject
because the declaration did not explicitly declare it to be something else. For information about theObject
class, see TheObject
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 ofclass NameOfClass extends SuperClassName { . . . }ImaginaryNumber
to be theNumber
class rather than theObject
class. You would write:This explicitly declares that theclass ImaginaryNumber extends Number { . . . }Number
class is the superclass ofImaginaryNumber
. (TheNumber
class is part of thejava.lang
package and is the base class for theInteger
,Float
, and other subclasses.)Declaring that
Number
is the superclass ofImaginaryNumber
implicitly declares thatImaginaryNumber
is the subclass ofNumber
. A subclass inherits variables and methods from its superclass. Creating a subclass can be as simple as including theextends
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 namedArithmetic
that defines methods namedadd
,subtract
, and so on. TheImaginaryNumber
class can declare that it implements theArithmetic
interface like this:thereby guaranteeing that it provides implementations forclass ImaginaryNumber extends Number implements Arithmetic { . . . }add
,subtract
and other methods declared by theArithmetic
interface. If any implementations for methods defined inArithmetic
are missing fromImaginaryNumber
, 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 theImaginaryNumber
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 useImaginaryNumber
, so it should be declared public:By convention, when you use thepublic class ImaginaryNumber extends Number implements Arithmetic { . . . }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: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 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 ofObject
that implements no interfaces.
Objects, Classes, and Interfaces |