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;Được hỗ trợ bởi

• 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");
    }
}Được hỗ trợ bởi

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();
    }
}Được hỗ trợ bởi

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);
    }
}Được hỗ trợ bởi

package com.example.myapp;

import com.example.utils.Utility;

public class MyApp {
    public static void main(String[] args) {
        Utility.printMessage("Hello from MyApp");
    }
}Được hỗ trợ bởi

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;Được hỗ trợ bởi

• 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;Được hỗ trợ bởi

• 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Được hỗ trợ bởi

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)
      }
  }Được hỗ trợ bởi

• 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();Được hỗ trợ bởi