La declaración de importación en Java es útil para tomar una clase o todas las clases visibles para un programa especificado en un paquete , con la ayuda de una sola declaración. Es bastante beneficioso ya que el programador no necesita escribir la definición de clase completa. Por lo tanto, mejora la legibilidad del programa.
Este artículo se centra en las declaraciones de importación utilizadas en los programas Java y sus alternativas.
Sintaxis 1:
import package1[.package2].(*);
Aquí,
- paquete1: paquete de nivel superior
- paquete2: paquete de nivel subordinado bajo paquete1
- *: Importar todas las clases
Sintaxis 2:
import package1[.package2].(myClass);
Aquí,
- paquete1: paquete de nivel superior
- paquete2: paquete de nivel subordinado bajo el paquete de nivel superior
- myClass: Importar solo myClass
Nota: Podemos importar una clase o podemos importar todas las clases especificadas en el paquete.
Para entender por qué necesitamos hacer visible una clase o clases, consideremos un programa Java sin el uso de una declaración de importación:
Código fuente:
Java
// Java program to demonstrate the
// working of a program
// without any import statement
class GFG {
// Main method
public static void main(String[] args)
{
// Declaring an ArrayList of String type
ArrayList<String> arrayList
= new ArrayList<String>();
// Adding elements in the ArrayList
arrayList.add("Geeks");
arrayList.add("For");
arrayList.add("Geeks");
// Print the ArrayList
System.out.println("ArrayList: " + arrayList);
}
}
Compilemos el programa anterior:
Veredicto del compilador:
prog.java:11: error: cannot find symbol
ArrayList<String> arrayList
^
symbol: class ArrayList
location: class GFG
prog.java:12: error: cannot find symbol
= new ArrayList<String>();
^
symbol: class ArrayList
location: class GFG
2 errors
Descripción de la compilación: Obtenemos el error en tiempo de compilación. El compilador Javac no pudo encontrar la clase ArrayList en el programa. La clase ArrayList es parte del paquete java.util . Por lo tanto, debemos incluir la clase ArrayList definida en el paquete Java.util en nuestro programa.
Las siguientes son tres formas de hacer referencia a una clase externa o a todas las clases externas especificadas en un paquete:
1. Nombre completo:
La declaración de importación es opcional y podemos usar el nombre completo de la clase para referirnos a una clase o paquete en el programa. Este método le dice al compilador que la clase está definida bajo un paquete en particular, y queremos usar esa clase o clases en nuestro programa. Cada vez que queramos usar un miembro de datos o una función miembro definida en la clase, debemos referirnos a él usando un nombre completo. Aumenta el tamaño del código de nuestro programa y, por lo tanto, lo hace menos legible. Esta es la única desventaja de este método.
Ejemplo : a continuación se muestra la implementación utilizando un nombre completo para la clase ArrayList definida en el paquete Java.util:
Java
// Java program to demonstrate the working of a program
// using fully-qualified name or without the use of import
// statement
class GFG {
// Main method
public static void main(String[] args)
{
// Using fully-qualified name
// Declaring an ArrayList of String type
java.util.ArrayList<String> arrayList
= new java.util.ArrayList<String>();
// Adding elements in the ArrayList
arrayList.add("Geeks");
arrayList.add("For");
arrayList.add("Geeks");
// Print the ArrayList
System.out.println("ArrayList: " + arrayList);
}
}
ArrayList: [Geeks, For, Geeks]
2. Declaración de importación:
Una declaración de importación le dice al compilador la ruta de una clase o el paquete completo. Es diferente a «#include» en C++, que incluye todo el código en el programa. La declaración de importación le dice al compilador que queremos usar una clase (o clases) que está definida en un paquete. Es bastante útil y se recomienda sobre el método de «nombre completo», ya que reduce el tamaño total del código y mejora la legibilidad del código fuente.
A continuación se muestra la implementación para ilustrar cómo podemos importar una clase a nuestro programa:
Java
// Java program to demonstrate the
// working of import statement
// Importing ArrayList class specified
// under java.util package
import java.util.ArrayList;
class GFG {
// Main method
public static void main(String[] args)
{
// Declaring an ArrayList of String type
ArrayList<String> arrayList
= new ArrayList<String>();
// Adding elements in the ArrayList
arrayList.add("Geeks");
arrayList.add("For");
arrayList.add("Geeks");
// Print the ArrayList
System.out.println("ArrayList: " + arrayList);
}
}
ArrayList: [Geeks, For, Geeks]
A continuación se muestra la implementación para ilustrar cómo podemos importar todas las clases a nuestro programa:
Código fuente:
Java
// Java program to demonstrate the
// working of import statement
// Importing all classes specified under java.util package
import java.util.*;
class GFG {
// Static function to print array elements
public static void print(int array[])
{
System.out.print("Array: [ ");
for (int i = 0; i < 5; i++)
System.out.print(array[i] + " ");
System.out.print("]");
}
// main method
public static void main(String[] args)
{
// Declaring an ArrayList of String type
ArrayList<String> arrayList
= new ArrayList<String>();
// Adding elements in the ArrayList
arrayList.add("Geeks");
arrayList.add("For");
arrayList.add("Geeks");
// Declaring an array of integers
int array[] = { 10, 3, 5, 11, 20 };
// sort function defined under Arrays class
Arrays.sort(array);
// Print the ArrayList
System.out.println("ArrayList: " + arrayList);
// Calling print() function
print(array);
}
}
ArrayList: [Geeks, For, Geeks] Array: [ 3 5 10 11 20 ]
Veamos ahora el funcionamiento de la declaración de importación creando nuestro paquete personalizado y una clase dentro de él. Podemos incluir la siguiente declaración antes de todas las definiciones de clase para agrupar un programa en un paquete.
Sintaxis:
package myPackage;
Aquí,
- myPackage: Nombre del paquete
A continuación se muestra la implementación para ilustrar cómo podemos importar una clase creando nuestro paquete personalizado:
Java
// Statement to create a package
package CustomPackage;
// Public class
public class ComputerScienceDepartment {
String name;
int marks;
// user defined constructor method
public ComputerScienceDepartment(String studentName,
int studentMarks)
{
// Assigning values to data
// members with the help of
// values passed to the constructor
name = studentName;
marks = studentMarks;
}
// Display method to display student's information
public void display()
{
System.out.println("Name: " + name + '\n'
+ "Marks : " + marks + '\n'
+ "Department: "
+ "Computer Science" + '\n');
}
}
Hemos creado el archivo fuente Java anterior localmente en nuestro sistema y lo hemos guardado como ComputerScienceDepartment.java :
Compilemos ahora el programa usando el compilador javac y agréguelo como un paquete a través del símbolo del sistema,
javac ComputerScienceDepartment.java javac -d . ComputerScienceDepartment.java
Descripción de la compilación: como puede ver en la imagen de arriba, se genera la carpeta CustomPackage, que contiene el archivo de código de bytes ComputerScienceDepartment.class . Este archivo es posteriormente ejecutado por un intérprete de Java (JVM). Ahora el paquete está listo y podemos crear otro programa e importar este paquete al programa.
A continuación se muestra el código fuente que incluye/importa la clase ComputerScienceDepartment definida en CustomPackage en el programa:
Java
// Import the public class defined under
// the created package (CustomPackage)
import CustomPackage.ComputerScienceDepartment;
class GeeksforGeeks {
// main method
public static void main(String args[])
{
// Initializing a variable by passing name
// and marks of the student as an argument to
// the constructor
ComputerScienceDepartment student1
= new ComputerScienceDepartment("Geeks", 97);
// Using display() method defined under
// ComputerScienceDepartment class to print sudent1
// information
student1
.display(); // you may also call the display()
// Initializing another variable by passing name
// and marks of the student as an argument to
// the constructor
ComputerScienceDepartment student2
= new ComputerScienceDepartment("GeeksforGeeks",
100);
// Using display() method defined under
// ComputerScienceDepartment class to print sudent2
// information
student2
.display(); // you may also call the display()
}
}
Hemos creado el archivo fuente de Java anterior localmente en nuestro sistema y lo hemos guardado como GeeksforGeeks.java :
Compilemos ahora el programa usando el compilador javac y ejecútelo a través del símbolo del sistema,
javac GeeksforGeeks.java java GeeksforGeeks
Producción:
3. Declaración de importación estática :
Mediante el uso de declaraciones de importación estáticas en Java, podemos acceder a miembros de datos o funciones de miembros de una clase directamente sin el uso de un nombre completo.
A continuación se muestra la implementación en la que accedemos al método abs() en la clase Math sin ningún uso de declaración de importación estática y utilizando un nombre completo:
Java
// Java program to illustrate the working
// of static import statement
class GFG {
// Main method
public static void main(String[] args)
{
// Initializing two variables of integer type
int number1 = 10;
int number2 = 20;
// Using fully-qualified name to access
// abs() method - Math.abs()
System.out.println(
"Absolute difference of number1 and number2 is: "
+ Math.abs(number1 - number2));
}
}
Absolute difference of number1 and number2 is: 10
A continuación se muestra la implementación utilizando una declaración de importación estática.
Java
// Java program to illustrate the working
// of static import statement
// Import static statement
import static java.lang.Math.*;
class GFG {
// Main method
public static void main(String[] args)
{
// Initializing two variables of integer type
int number1 = 10;
int number2 = 20;
// Directly accessing abs() method without using
// fully-qualified name
System.out.println(
"Absolute difference of number1 and number2 is: "
+ abs(number1 - number2));
}
}
Absolute difference of number1 and number2 is: 10
ventajas:
- Las declaraciones de importación ayudan a reducir el tamaño del código y, por lo tanto, ahorran mucho tiempo.
- Mejora la legibilidad de nuestro código.
- Es bastante útil al manejar grandes proyectos.
- Se pueden utilizar para combinar la funcionalidad de varias clases en una sola.