Lesson 4	Packaging Java classes
Objective	Organize Java Classes into Packages

Organize Java Classes into Packages in Java SE 22

Organizing Java classes into packages in Java SE 22 is fundamental for managing larger projects, preventing naming conflicts, and controlling access to your code. Here's a breakdown of how to do it:

Choosing Package Names:
- Convention: Package names are typically written in lowercase and follow a reverse domain name convention.1 For example, if your company's domain is example.com and you're working on a library related to utilities, a common package name would be com.example.utils.
- Clarity: Choose names that clearly indicate the purpose and functionality of the classes within the package.
- Uniqueness: The reverse domain name convention helps ensure that your package names are globally unique, especially important for distributable libraries.
- Subpackages: You can create a hierarchy of packages using dots (e.g., com.example.utils.string, com.example.data.model).
Creating the Directory Structure:
The directory structure of your project on the file system must mirror your package structure.
- If you declare a class to be in the package com.example.utils, the corresponding .java file (and later the .class file) must reside in the following directory structure relative to your source code root:
```
com/
  example/
    utils/
	  YourClass.java
```
- The source code root is the top-level directory where you typically keep your .java files before compilation. Your development environment (IDE) or build tool will usually handle setting this up.
Declaring Packages in Your Java Files:
At the very beginning of each .java file, before any class or interface definition, you need to declare which package the class belongs to using the package keyword.
```
// In the file com/example/utils/YourClass.java
package com.example.utils;

public class YourClass {
  // ... class members ...
}
```

Compilation:
When you compile your Java code, the compiler will create the corresponding directory structure for the .class files based on the package declaration.
- Using javac from the command line:
  - Navigate to the root directory of your source code.
  - Compile the .java files. The -d option specifies the destination directory for the generated .class files. It's common to create a separate bin or out directory for this.
```
javac -d bin com/example/utils/YourClass.java
            
```
    This command will create the bin/com/example/utils/ directory (if it doesn't exist) and place the YourClass.class file inside it.
  - To compile all .java files in a directory and its subdirectories:
```
javac -d bin src/**/*.java
            
```
    (assuming your source code is in a src directory)
- Using an Integrated Development Environment (IDE):
  - IDEs like IntelliJ IDEA, Eclipse, and NetBeans handle package and directory structure management automatically. You typically create packages within the IDE's project view, and it takes care of creating the necessary directories and adding the package declarations to your files. The IDE also manages the compilation process and the output directory for .class files.
Running Your Java Code:
When running your compiled Java code, you need to ensure that the Java Virtual Machine (JVM) can find your .class files, respecting the package structure.

This is usually done by specifying the classpath.
- Using java from the command line:
  - Navigate to the directory containing the root of your compiled class hierarchy (e.g., the bin directory in the previous example).
  - Use the fully qualified name of the class (including the package name) to execute it.
```
java com.example.utils.YourClass
            
```
    You might need to explicitly set the classpath using the -cp or --class-path option if your classes depend on external libraries or if you are not running the java command from the root of your compiled output.
```
java -cp bin com.example.utils.YourClass
            
```
- Using an IDE:
  - IDEs typically manage the classpath configuration for you when you run or debug your applications.2 You usually just need to configure the main class to run.

Benefits of Using Packages:

Namespace Management: Packages prevent naming collisions between classes that might have the same name but serve different purposes.
Organization: They help organize your codebase into logical modules, making it easier to understand, maintain, and navigate.
Access Control: Packages provide a mechanism for controlling the visibility of classes and their members (using public, protected, private, and default (package-private) access modifiers). Classes within the same package have easier access to each other's members.
Reusability: Well-defined packages can be easily reused in other projects.

In summary, to organize Java classes into packages in Java SE 22:

Choose meaningful and unique package names.
Create a directory structure that mirrors your package hierarchy.
Declare the package at the top of each .java file using the package keyword.
Compile your code, ensuring the .class files are placed in the correct directory structure.
Run your code using the fully qualified class name, ensuring the classpath is correctly configured.

By following these steps, you can effectively organize your Java projects into well-structured and maintainable packages. Remember that consistent use of packages is a crucial aspect of good Java development practices.

The package statement is used to identify the package to which a class belongs. This statement must be placed at the beginning of the source code file for the class. Following is an example of a package statement:

package toys;

Placed at the beginning of a source code file for a class, this statement indicates that the class belongs to the toys package. If you wanted to include classes named finky and slinky in the toys package, you would place the above package statement at the top of the source code files for each class.
Even though the package statement must be placed at the beginning of a source file, it is okay to have comments appearing before it in the code.

Naming Java Packages

Java package names are identifiers and therefore are subjected to the same limitations imposed on naming classes, variables, methods, etc. Although this still gives you lots of freedom when naming packages, there is a package-naming scheme promoted by Sun to which you should consider adhering. Sun's naming scheme involved using the domain name of your Web site as the beginning of a package name, followed by more descriptive names that describe the set of classes you are packaging. The purpose of this scheme is to help assure that all Java classes are uniquely identified. The domain name of my Web site is thetribe.com, so a package containing my own custom animation classes might be named com.thetribe.animation. Placing my animation classes in this package guarantees uniqueness because the domain name thetribe.com is not used by anyone else. Of course, you may not even have a domain name or you may be developing classes for use in a stand-alone Java application that has no association with the Internet. In this case, the naming of your packages is less of an issue.

Naming a Java Package
With programmers worldwide writing classes and interfaces using the Java programming language, it is probable that many programmers will use the same name for different types. The compiler allows both classes to have the same name if they are in different packages. The fully qualified name of each class includes the package name. The fully qualified name of the Rectangle class in the graphics package is graphics.Rectangle, and the fully qualified name of the Rectangle class in the java.awt package is java.awt.Rectangle. This works well unless two independent programmers use the same name for their packages.

Java Classes - Quiz

Click the Quiz link below to test your knowledge of packages.
Java Classes - Quiz