Language fundamentals
Package and class declarations
A package represents a group of classes. A package statement should be the first valid statement in the source file. If there is no package statement, the classes in the source file belong to the default unnamed package, or else they belong to the named package. Only one package statement is allowed in a source file.
In a source file, there can be only one public class, and the name of the file should match that of the class. An import statement allows you to use a class directly instead of referring to it using its fully qualified name. Import statements must come after any package statement and before the class declarations, as shown below:
package com.abc; // package statement
import java.net.*; // wild card import (imports all classes in the package)
import java.util.Vector;// class import (only the given class is imported)
Nested class declarations
A nested class or inner class is a class defined inside another class. Nested classes can be non-static, method-local, anonymous, or static.
Non-static inner classes
A non-static inner class definition does not use the static keyword. It is defined within the scope of the enclosing class, as follows:
class MyClass
{
class MyInner{}
}
To instantiate a non-static inner class, you need an instance of the outer class.
A non-static inner class has access to all the members of the outer class. From inside the outer instance code, use the inner class name alone to instantiate it:
MyInner myInner = new MyInner();
From outside the outer instance code, the inner class name must be included in the outer instance:
MyClass myClass = new MyClass();
MyClass.MyInner inner = myClass.new MyInner();
Modifiers that can be applied to non-static inner classes are final, abstract, public, private, and protected.
Method local inner classes
A method local inner class can be instantiated in the method where it is defined. It can also be in a constructor, a local block, a static initializer, or an instance initializer. It cannot access the local variables of the enclosing method unless they are final. The only modifiers for such a class are abstract or final.
Anonymous inner classes
Anonymous inner classes are inner classes that have no name. They can extend a class or implement an interface. For instance:
button1.addMouseListener(new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
button1_mouseClicked(e);
}
});
This example shows an anonymous inner class. It is important to note that the class has been defined within a method argument.
Static nested classes
A static nested class is a static member of the enclosing class. It does not have access to the instance variables and methods of the class. For instance:
class MyOuter
{
static class MyNested{}
}
class Test
{
public static void main(String args[]){
MyOuter.MyNested n = new MyOuter.MyNested();
}
}
As this example shows, a static nested class does not need an instance of the outer class for instantiation.
2 comments: