الاستيراد وتعارض الأسماء

Written Explanation

What an import is

An import is a naming shortcut, nothing more. The Java Language Specification describes imports as letting code use simple names for types from other packages, where otherwise it would need fully qualified names. An import does not copy code, does not run anything and does not decide what is compiled. If you wrote java.util.List everywhere instead, the program would behave identically.

Imports go after the package line and before the class:

package com.example.app;

import com.example.bank.Account;
import java.util.List;

public class Main { }

Each import line names one class by its full name and ends with a semicolon. This form is called a single-type import.

Three cases where you need no import

1. The class is in the same package. All classes of one package see each other by simple name. In our test, Printer and Statement both live in com.example.bank, so Printer uses Statement with no import.
2. The class is in java.lang. The JLS says every file behaves as if it began with import java.lang.*;. That is why String, Object, Math and System work with no import.
3. You write the fully qualified name. java.util.List<String> names = ... needs no import line, because there is nothing to shorten.

Everything else needs an import (or a full name): List, ArrayList, Scanner, and every class of your own that lives in a different package.

The wildcard import

The second form is the on-demand import, written with *:

import java.util.*;

It makes all the accessible classes directly in java.util available by simple name. Points to know:

• It does not import sub-packages. import java.util.*; gives you List, but not anything from java.util.concurrent. Hierarchy in names has no special meaning to Java: the JLS says there is no access relationship between oliver.twist and oliver.
• It does not make the program bigger or slower. It is only a name lookup rule for the compiler.
• It can create ambiguity, as the next section shows.

Most teams prefer explicit single-type imports in real code: a reader sees exactly which classes a file depends on, and a new class added to a wildcard-imported package cannot silently clash with yours. Your IDE can add and tidy imports for you (the menu names vary by IDE, so check its help for "organize imports" or similar).

Name clashes

Two different packages may contain classes with the same simple name. The standard library has java.util.Date and java.sql.Date. If both are in play in one file, Date alone is ambiguous. There are three situations.

Situation 1: two wildcard imports.

import java.util.*;
import java.sql.*;
// ... Date d = new Date(0L);

The compiler refuses at the point of use:

error: reference to Date is ambiguous
  both class java.sql.Date in java.sql and class java.util.Date in java.util match

Situation 2: two single-type imports of the same simple name.

import java.util.Date;
import java.sql.Date;

error: a type with the same simple name is already defined by the single-type-import of Date

The JLS says two single-type imports of the same simple name from different types are an error.

Situation 3: the fix. Import one class and write the other with its full name:

import java.util.Date;

java.sql.Date day = new java.sql.Date(0L);

Choose the class you use most as the imported one. The full name is always legal, wherever the class is accessible.

A single-type import also wins over a wildcard import of the same simple name, so import java.util.Date; together with import java.sql.*; resolves Date to java.util.Date. Do not lean on that. Explicit is easier to read.

Imports and visibility are separate

An import never grants access. A class you import must also be accessible. A class that is not public can only be used inside its own package, even with an import line. The next lesson is about that rule.

Two limits to remember

• Each file has its own imports. They do not carry over to other files, even in the same package.
• You cannot import a package alone. import java.util; is an error. You import a class (java.util.List) or all classes (java.util.*).