跳至主要内容

package Keyword in Java

The package keyword in Java is used to group related classes, interfaces, and sub-packages. It helps in organizing the code and avoiding name conflicts. Packages provide access protection and namespace management.

Usage

The package keyword is declared at the beginning of a Java source file. It defines the namespace for the classes defined in that file.

Syntax

package packageName;
  • packageName: The name of the package, which is typically written in all lowercase letters and follows the reverse domain name convention.

Examples

Example 1: Declaring a Package

package com.example.myapp;

public class MyClass {
    public void display() {
        System.out.println("Hello from MyClass");
    }
}

In this example, the class MyClass is part of the com.example.myapp package. The package declaration must be the first line in the source file.

Example 2: Importing a Package

import com.example.myapp.MyClass;

public class Main {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.display();
    }
}

Here, the MyClass from the com.example.myapp package is imported and used in the Main class. The import statement allows you to use classes from other packages.

Example 3: Package Hierarchy

package com.example.utils;

public class Utility {
    public static void printMessage(String message) {
        System.out.println(message);
    }
}
package com.example.myapp;

import com.example.utils.Utility;

public class MyApp {
    public static void main(String[] args) {
        Utility.printMessage("Hello from MyApp");
    }
}

In this example, Utility is part of the com.example.utils package, and it is imported into the com.example.myapp package. This demonstrates how packages can form a hierarchy and interact with each other.

Tips and Best Practices

  • Naming Conventions: Use meaningful package names that follow the reverse domain name convention to avoid conflicts. 
    package com.yourcompany.project.module;
  • Organize Code: Group related classes and interfaces into packages to make the codebase more manageable and understandable.
  • Access Control: Use packages to control access to classes and members. Classes within the same package can access each other's package-private members.
  • Avoid Default Package: Avoid using the default package (i.e., no package declaration) as it can lead to name conflicts and is not scalable for larger projects.
  • Documentation: Document your packages using package-info.java files to provide an overview and description of the package. 
    /**
 * Provides utility classes for the application.
 */
package com.example.utils;
  • Consistent Structure: Maintain a consistent directory structure that mirrors the package hierarchy to make the project easier to navigate. 
    src/
  com/
    example/
      myapp/
        MyApp.java
      utils/
        Utility.java

Additional Concepts

  • Static Import: Static import allows members (fields and methods) defined in a class to be used in Java code without specifying the class in which the field is defined. 
    import static java.lang.Math.*;

public class StaticImportExample {
    public static void main(String[] args) {
        System.out.println(sqrt(16)); // No need to use Math.sqrt(16)
    }
}
  • Handling Name Conflicts: If two classes have the same name but belong to different packages, you can fully qualify the class name to avoid conflicts. 
    com.example.package1.MyClass obj1 = new com.example.package1.MyClass();
com.example.package2.MyClass obj2 = new com.example.package2.MyClass();