Packages and Class Visibility

1. Packages and Class Visibility The objectives of this chapter are: To understand logical class groupings using packages To explain the environment variable CLASSPATH To describe inner and anonymous classes and their uses

2. Abstraction and Class Namespaces • Because classes are an abstraction of real world objects, choosing the correct name for classes can lead to ambiguities • This is confounded when classes are taken "out of context" • One of the main purposes of packages is to provide a contextual namespace within which a class resides • A class called "Stock" may have several meanings • A class called "Stock" in the inventory package is much less ambiguous • Java provides a syntax for package names • Package names are separated by periods • Packages can contain classes or packages • The fully qualified name of a class includes its package name: • inventory.Stock indicates a class called "Stock" within the "inventory" package.

3. becomes afox.org org.afox financial.inventory.Stock org.afox.financial.inventory.Stock becomes Java and A Global Namespace • The designers of Java have proposed an Internet-wide unique package naming scheme • It includes the Internet domain name of the organization within which the package was developed. • The domain is reversed and the subdomains become packages The domain portion is prepended to any packages developed within afox.org This standard guarantees that no other organization will create a class whose name conflicts with classes developed with afox.org.

4. Putting classes in packages • To put a class into a package, one uses the "package" statement • The package statement MUST be the first line of code within the file. • It can be proceeded by comments. • If no package statement is supplied, the class is placed in the "default" package • The default package is a package with no name in file Stock.java: package org.afox.financial.inventory; public class Stock { [...]

5. Making it all work with Import • Unfortunately, the proposed naming scheme creates very long names for classes • A class which was originally named "Stock" is now named "org.afox.financial.inventory.Stock". • This makes coding difficult. It dramatically reduces code readability. • To avoid having to use the fully qualified class name for all classes, the programmer can "import" some or all of the classes from a given package • Once a class has been imported, it need only be referenced by its name. ie "Stock" instead of "org.afox.financial.inventory.Stock" // Import a single class import org.afox.financial.inventory.Stock; // Import all classes from the specified packages import org.afox.financial.inventory.*; import java.io.*; import java.net.*;

6. Notes on the import statement • Import ONLY imports public classes from the specified package • Classes which are not public cannot be referenced from outside their package. • There is no way to "import all classes except one" • import either imports a single class or all classes within the package • Note: importing has no runtime or performance implications. It is only importing a namespace so that the compiler can resolve class names. • Import statements must appear at the top of the file after the package statement and before any class or interface definitions.

7. Compiling classes with packages • Packages provide a logical namespace for classes • When compiled, the package structure is physically represented using a directory structure • The .class file for the class "org.afox.financial.inventory.Stock" will reside a the following path: org/afox/financial/inventory/Stock.class • Package names map directly to subdirectories • The programmer can specify the root of the package directory structure using the -d option with the javac compiler. javac -d /home/schock/classes Stock.java Will cause the compiler to place the .class file at: /home/schock/classes/org/afox/financial/inventory/Stock.class

8. Resolving Packages at Runtime • The Java compiler compiles .java files to .class files • Each compiled class resides within its own .class file • Classes are loaded into the virtual machine by the ClassLoader • Because of packages, .class files can now exist within a large number of directories • For performance reasons, the ClassLoader must have a quick way of resolving a fully qualified class reference to .class file. • Resolving packages to directories is simple. • However, the virtual machine must know where to find the directory structure • The ClassLoader uses an environment variable called CLASSPATH to find the directory which contains the package directories.

9. CLASSPATH • Setting the CLASSPATH has been the bane of many programmers • You never really learn how to swear until you try to set the CLASSPATH • The CLASSPATH is a variable that contains a list of directories which are separated by colons (:) • Note: Under the Windows OS, they are separated by semicolons (;) • The the ClassLoader attempts to load a class, it searches for the .class file using the CLASSPATH, Package name and class name: If CLASSPATH="/home/schock/classes:/usr/development/classes" the class loader will search for the Stock class in the following locations: /home/schock/classes/org/afox/financial/inventory/Stock.class /usr/development/classes/org/afox/financial/inventory/Stock.class

10. More on CLASSPATH • The ClassLoader searches the directories in the CLASSPATH in the order in which they are defined • When the ClassLoader finds a class, it loads it and stops searching • Place higher priority directories earlier in the CLASSPATH • If no class is found, the ClassLoader throws a NoClassDefFoundError • NOTE: .class files can be archived within .zip files or .jar files. When archived, the directory structure is preserved. CLASSPATH can ALSO contain .jar or .zip files. When the ClassLoader encounters a .jar or .zip file within the CLASSPATH, it searches through the .jar or .zip file the same way it would search in a directory. • Java applications are distributed in .jar file form.

11. .jar files • .jar files are created using the jar command • The jar command is included with the Java SDK distribution • Note: The .jar file format is the SAME as the .zip file format • See the Java SDK Documentation for the jar program. • Jar files can be defined with a main class. If a .jar file has a main class defined, it can be executed using the following command: java -jar filename.jar

12. Is CLASSPATH important at compile time? • The previous slides have shown how the ClassLoader uses CLASSPATH to find .class files at runtime. • CLASSPATH is also used by the compiler to resolve association issues • If an object sends a message to another object, the compiler must ensure that the receiving object responds to the message. • The receiving object's class must be loaded by the compiler and checked. • If the receiving objects class has already been compiled, the above process works. However, what if the class has not yet been compiled and no .class file exists? • The compiler attempts to locate the receiving object's .java file (using CLASSPATH) in an attempt to compile it. • This means your source file structure MUST ALSO match the package directory structure. • The root of your source tree MUST ALSO be within your CLASSPATH

13. Non-public classes • As noted earlier, the import statement imports public classes only • Non-public classes can be defined in different ways • nested classes (Defined within a class) • inner classes • member classes (similar to nested classes) • local classes (defined within a method) • anonymous classes (classes with no name!) • These forms of defining classes have been provided as an implementational convenience. Unfortunately, the use of these types of classes can rapidly decrease code readability. Use with care. • Nested and inner classes have a special relationship to the outer class which defines them: • Access to private variables and methods.

14. Nested Classes • Nested classes are defined WITHIN another class • They are defined using the static keyword • The nested class is defined as part of the outer class. It can only be referenced through the outer class. public class LinkedList { private static class LinkedListNode { [...] } public static class LinkedListStats { [...] } // Create an instance of the nested class LinkedListStats LinkedList.LinkedListStats x = new LinkedList.LinkedListStats(); // Illegal access to private nested class -- compiler error LinkedList.LinkedListNode y = new LinkedList.LinkedListNode();

15. Member Classes • Member classes are similar to nested classes, except they are not static. • They are used in the same manner as instance variables. public class LinkedList { public class LinkedListStats { [...] } LinkedList aList = new LinkedList(); LinkedList.LinkedListStats aStat = new aList.LinkedListStats();

16. Local Classes • Local classes are defined within a method • The scope is limited to the method • Used for small helper classes whose applicability is within the method only public class LinkedList { public void traverse() { class MyIterator extends Iterator { public void doTraversal() { [...] } } MyIterator anIterator = new MyIterator(); [...] } }

17. Anonymous inner Classes • Anonymous classes have no name • They are declared and instantiated in one step. • Used to create a quick subclass of an existing class where one or more method is overridden. public class LinkedList { private ListChangeDelegate aDelegate; public LinkedList() { aDelegate = new ListChangeDelegate(){ [ override methods here ] } } }

18. Inner classes -- .class file names • All Java classes are compiled to their own .class file • The compiler gives special names to inner class .class files • For nested, member and local classes • Outer$Inner.class • For anonymous classes • Outer$1.class • Outer$2.class • All inner class .class files contain the $ character. • To avoid confusion, it is recommended that one avoids naming classes using the $ character.

19. Non-public classes • Non-public classes do not need to be defined within another class. • They can be defined externally to a class, but within the same .java file. in file LinkedList.java: public class LinkedList { [ ... Linked List class definition and Methods ...] } class LinkedListNode { [ ... helper class definition ... ] } class LinkedListStats { [ ... another helper class definition ... ] }