Detailed explanation of packages and imports in Java

1. Introduction

In Java programming, packages and imports are very important concepts. They help us better organize our code, manage project structure, resolve naming conflicts, and control access. This article will introduce in detail the relevant knowledge of packages and imports in Java, and help readers to deeply understand the practical application of these concepts through rich explanations and code examples.

2. The concept of package

(I) Definition and function of package

• definition：
  • Package is used to indicate the package where the classes, interfaces and other structures defined in the file are located. A source file can only have one declarationpackagestatement, and appears as the first statement in the Java source file. If this statement is defaulted, it is specified as a nameless package.
  • The package name belongs to an identifier and needs to meet the identifier naming rules and specifications (all lowercase) to achieve the meaning of the name. For example, a package used to handle mathematical operations can be namedmath_utils. At the same time, do not use the namepackage to avoid conflicts with package names in the Java core library.
  • The directory of the corresponding file system of the package,packageIn the statement, "." is used to indicate the level of the package, and each layer represents a layer of file directory. For example,Indicates that there is one in the file systemcomDirectory, under whichexampleDirectory, belowmyprojectDirectory, where the class files in this package are stored.
• effect：
  • Divide project levels for easy management: In large projects, packages can classify and store classes and interfaces of different functions, making the project structure clearer. For example, a class related to user management can be placed inuser_managementIn the package, put the classes related to database operations indatabase_accessIn the package.
  • Helps manage large software systems and divide classes with similar functions into the same package: For example, in the MVC (Model-View-Controller) design pattern, you can place the model class in one package, the view class in another package, and the controller class in the third package, so that the corresponding code can be easily found and maintained.
  • Resolve class naming conflict issues: If different developers or different projects define a name calledCalculatorclass, you can put them in different packages, such ascom.andcom., so that different classes can be distinguished by package names.
  • Control access rights: Packages can restrict access to classes and members. By default, only classes in the same package can directly access each other's non-private members. By using different packages, you can control which classes can access specific code, improving the security and maintainability of the code.

(II) The main packages in JDK

• langBag:
  • Contains core classes of Java language, such asString、Objectwait. These classes are the basis of Java programming and are used in almost all Java programs. For example,StringClass is used to represent strings,ObjectA class is the root class of all Java classes.
  • Code example:

String str = "Hello, World!";
(());

• netBag:
  • Provides classes and interfaces related to network programming. The classes in this package can be used to realize communication between the client and the server, processing of network protocols, etc. For example,URLClasses can be used to access network resources.SocketClasses can be used to establish network connections.
  • Code example:

import ;

public class NetworkExample {
    public static void main(String[] args) throws Exception {
        URL url = new URL("");
        // Use URL objects for network operations    }
}

• ioBag:
  • Used for input and output operations. Including file reading and writing, streaming processing, etc. For example,FileInputStreamandFileOutputStreamCan be used to read and write files,BufferedReaderandBufferedWriterIt can improve the efficiency of file reading and writing.
  • Code example:

import ;
import ;
import ;

public class IOExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("");
             FileOutputStream fos = new FileOutputStream("")) {
            int byteRead;
            while ((byteRead = ())!= -1) {
                (byteRead);
            }
        } catch (IOException e) {
            ();
        }
    }
}

• utilBag:
  • Contains various utility classes, such as collection frameworks (ArrayList、HashMapetc.), date and time processing categories, etc. The collection framework provides efficient data storage and operation methods, and date and time processing classes can easily handle date and time-related tasks.
  • Code example:

import ;
import ;

public class UtilExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        ("apple");
        ("banana");
        ("orange");
        for (String item : list) {
            (item);
        }
    }
}

• textBag:
  • Process text-related classes. For example,StringBuilderandStringBufferCan be used to efficiently splice strings,FormatterCan be used to format output.
  • Code example:

import ;

public class TextExample {
    public static void main(String[] args) {
        double number = 1234.5678;
        DecimalFormat df = new DecimalFormat("#.##");
        String formattedNumber = (number);
        (formattedNumber);
    }
}

• sqlBag:
  • Used for database access. Provides classes and interfaces related to database connection, execution of SQL statements, processing result sets, etc. For example,Connection、StatementandResultSetCan be used to interact with a database.
  • Code example:

import ;
import ;
import ;
import ;

public class SQLExample {
    public static void main(String[] args) {
        try {
            Connection connection = ("jdbc:mysql://localhost:3306/mydb", "username", "password");
            Statement statement = ();
            // Execute SQL statements        } catch (SQLException e) {
            ();
        }
    }
}

• awtBag:
  • Abstract Window Toolkit provides basic classes for building graphical user interfaces. Includes components such as windows, buttons, text boxes, etc. Although Swing and JavaFX are more commonly used to build GUIs, AWT is still the basis for Java GUI programming.
  • Code example:

import ;
import ;

public class AWTExample {
    public static void main(String[] args) {
        Frame frame = new Frame("AWT Example");
        Button button = new Button("Click me");
        (button);
        (300, 200);
        (true);
    }
}

3. The concept of import

(I) Purpose and usage of import

• Purpose: In order to use classes defined in other packages, import is required. If you don't import, you need to use the full package name and class name when using classes from other packages, which makes the code verbose and difficult to read. Through import, you can directly use class names to refer to classes in other packages to improve the readability and simplicity of the code.
• usage：
  • import package name.class name；importDeclaration is between the declaration of the package and the declaration of the class. For example, if you want to useClass, can be added in the codeimport ;. In this way, you can use it directly in subsequent codeArrayListto create objects without using the full package and class name.
  • If you need to import multiple classes, you can write them in parallel. For example:import package1.Class1; import package2.Class2;。

(II) Import of special circumstances

• If you want to importlangPackage or current package can be omittedimport. This is becauselangThe classes in the package are the core classes of the Java language and can be used directly in any Java program. For the classes in the current package, since they are in the same package, they can be accessed directly without importing.
• You can use wildcard characters to import all classes under a package, for example:import .*;, this indicates importutilAll structures under. However, it should be noted that this approach may reduce the readability and maintainability of the code, because it is not clear which classes are imported. In large projects, naming conflicts may result in unexpected import of unwanted classes, thereby increasing compile time and memory footprint.

4. Supplementary knowledge points

(I) Static import

Java also supports static imports, allowing direct import of static members (static methods and static variables). For example:import static ;, so that it can be used directly in the codestaticMethod()Without the need to call through the class name. Static imports can improve the simplicity of the code, but they should also be used with caution to avoid overuse making the code difficult to understand.

(II) Package access permissions

Access rights between classes in different packages are restricted. By default, only classes in the same package can directly access each other's non-private members. If cross-packet access is required, appropriate access modifiers (such as public, protected, etc.) are required.

• public: Can be accessed by any package class.
• protected: Can be accessed by classes and subclasses in the same package (subclasses can be in different packages).
• default(No explicit access modifier): Only accessible by classes in the same package.
• private: Only accessible by the current class.

(III) Package naming specification

In addition to all lowercase and name-ready, the naming of packages should also follow certain specifications to avoid using names that are too general or easily conflicting with other packages. For example, the inverted form of the company domain name can be used as the prefix of the package name to ensure uniqueness. For example, if the company's domain name is, you can name the package. This avoids conflicts with package names of other companies or projects, and makes it easier to identify and manage code in team collaboration or open source projects.

5. Summary

Packages and imports are indispensable concepts in Java programming. Using packages reasonably can improve the maintainability, readability and extensibility of the code, while correctly importing classes can facilitate us to use the functions in other packages in our code. In actual programming, we should follow good package naming specifications and import habits to improve the quality of our code. At the same time, understanding the relevant knowledge of package access permissions and static imports can better master the characteristics of the Java language and write more efficient and elegant code.

This is the end of this article about packages and imports in Java. For more related packages and imports in Java, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!

Latest Comments