1.1 Classes, Packages & ImportsHomepage « Java5 Certification « 1.1 Classes, Packages & Imports
In this lesson we look at all types of class declaration and extension and how to use the package and import statements.
Lets take a look at the points outlined at the Oracle Website for this part of the certification.
- Section 1: Declarations, Initialization and Scoping
- Develop code that declares classes (including abstract and all forms of nested classes), interfaces, and enums, and includes the appropriate use of package and import statements (including static imports).
We will defer our look at interfaces and abstract classes to 1.2 Interfaces / Abstract Classes and nested classes to
1.5 Constructors / Nested Classes.
Class Declaration
Top
A class is made up of members that form a blueprint for an object and its behaviour. How a class and its members are declared impacts how and who can see what. We will look at variable declarations in 1.3 Variables & Scope and member declarations in 1.4 Overloading & Overriding. In this lesson we will focus on class declarations, the access modifiers we can use with them and the some rules for declaring classes:
Access Modifiers
The table below shows the types of access available in Java for our top-level classes.
Access modifier | Description |
---|---|
public | A top-level class may be declared with the public access modifier, and if it is the class is accessible to all other classes everywhere. |
no modifier package-private / (the default) | If a top-level class has no explicit access modifier, which is the default and is also known as package-private, it is accessible only within its own package. |
- The only access modifier that can be used with a top-level class is
public
. - Only one class can be marked as
public
per source file. - If a class within a source file is marked as
public
then the name of the source file must exactly match the name of thepublic
class (followed by the.java
extension). - A source file can include multiple non-public classes.
- If a source file contains no public class then there is no naming constraints on that source file, ie. it doesn't have to match the name of one of the non-public classes.
- Aside from access modifiers classes can also be marked with the non-access modifiers
abstract
,final
andstrictfp
. Thestrictfp
is not part of the certification and so we won't go into details. When a class is marked asabstract
it has to be subclassed; when a class is marked asfinal
it can't be subclassed, so these two modifers can never be used together. - A class can extend a maximum of one other class.
/*
Some code showing class rules
*/
class A { } // OK
private class A { } // No, can only use public access modifier with top level class
protected class A { } // No, can only use public access modifier with top level class
public class A { } // OK
public class B extends A { } // OK
public class C extends B, A { } // No, can only extend one class
abstract class D { } // OK
final class E { } // OK
abstract final class F { } // No, cannot use both abstract and final
Packages
Top
In Java we can keep libraries of related classes together using a package and this is in essence what the Java language is, a collection of packaged libraries.
- If a class is part of a package then the
package
statement must be the first line of code in a source file.
There are two major benefits to the package approach adopted by Java.
- A package provides the apparatus for us to group related classes together under the same umbrella.
- We need a way to uniquely identify classes and Java doesn't allow us to have two top-level classes with the same name, within the same namespace. By using packaging we can partition the namespace to alleviate naming conflicts.
- Within any reasonable sized system we will have classes that relate to different aspects of said system, such as the Model View Controller paradigm. Packaging allows us to separate concerns into areas such as a Model subpackage, a View subpackage and so on. This makes the whole development process easier and more manageable.
- A package is part of the Java mechanism we use to enforce Encapsulation.
- By not marking members within a package with an access modifier, we are saying that these members are package-private and can only be accessed from within this package.
- By marking members with the
protected
access modifier, we are saying that these members can only be accessed from within this package or from a subclass outside the package.
The following table shows usage of a single package
statement and an example of a multiple hierarchy package
statement.
Package Form | Example | Description |
---|---|---|
Single package | ||
package pkg; | package A; | This file is part of package A. |
Multiple package hierarchy | ||
package pkg.subPkg1.subPkg2...subPkgN; | package A.B.C; | This file is part of Package C, which is a subpackage of B, which is a subpackage of A. |
Imports
Top
Java allows us to import parts of a package, or even the whole package if required for use in our code and we do this using the import
keyword.
- If a class uses the
import
keyword to import parts or all of a package, then theimport
keyword must follow thepackage
statement if there is one, or must be the first line of code in a source file if there is nopackage
statement.
The following table shows how to import a single class
from a package and all classes from a package using the import
statement.
Import Form | Example | Description |
---|---|---|
Single class import | ||
import pkg.class; | import java.rmi.Remote; | Import the Remote class from java.rmi |
Multiple class import | ||
import pkg.subPkg1.subPkg2...subPkgN; | import java.rmi.*; | Import all java.rmi classes |
Static Imports
With the introduction of Java5 a new feature became available when using the import
statement which is commonly known as static imports. When using the import
keyword followed by
static
we can import all the static members of a class or interface.
The following table shows how to import a single static member from a package and all static members from a package using the import static
statement.
Import Static Form | Example | Description |
---|---|---|
Single static member import | ||
import static pkg.staticMember; | import static java.lang.Math.acos; | Import the acos static member from java.lang.Math |
Multiple static member import | ||
import static pkg.allStaticMembers; | import static java.lang.Math.*; | Import all java.lang.Math static members |
Related Java5 Tutorials
Objects & Classes - Class Structure and Syntax
Objects & Classes - Enumerations
OO Concepts - Abstract Classes
OO Concepts - Nested Classes
OO Concepts - Interfaces
API Contents - Packages
API Contents - Packages - Imports
API Contents - Packages - Static Imports