¿Paquetes en Java y cómo usarlos?

Los paquetes en Java se utilizan para agrupar clases, interfaces y subpaquetes relacionados. Usamos paquetes de Java para evitar conflictos de nombres ya que puede haber dos clases con el mismo nombre en dos paquetes diferentes. Además, la búsqueda, localización y uso de interfaces, clases, anotaciones y enumeraciones se vuelven más fáciles con los paquetes de Java.

El uso del lenguaje de programación Java para escribir software involucra numerosas clases individuales, y solo tiene sentido organizar las clases e interfaces relacionadas en paquetes. En cierto modo, puede comparar los paquetes de Java con las carpetas de una computadora que usamos para organizar varios archivos y mantener nuestro trabajo ordenado.

Esta guía discutirá los diferentes tipos de paquetes en Java y cómo usarlos.

Tipos de paquetes en Java

Los paquetes en Java se dividen en categorías en función de si el usuario los define o no. Los dos tipos de paquetes de Java son:

• Paquetes incorporados
• Paquetes definidos por el usuario

1. Paquetes incorporados

Los paquetes de Java predefinidos o incorporados vienen como parte del Kit de desarrollo de Java (JDK) y consisten en muchas clases e interfaces predefinidas que forman parte de las API de Java. Algunos de los paquetes incorporados de uso común en Java son los siguientes:

• java.io: contiene clases para admitir operaciones de entrada/salida.
• java.lang: este paquete incorporado se importa automáticamente y contiene clases de soporte de idiomas.
• java.util: contiene clases de utilidad para implementar estructuras de datos como diccionario y soporte, lista vinculada, operaciones de fecha y hora, etc.
• java.net: contiene clases que admiten operaciones de red.

Tenemos que usar la declaración de importación para importar cualquier paquete Java incorporado y usar las clases que contiene.

Un ejemplo simple para mostrar el uso de la clase ArrayList del paquete Java.util es el siguiente:

paquete Ejemplo;

importar java.util.ArrayList;

clase paquete integrado {

public static void main(String[] args) {

ArrayList<Integer> myList = new ArrayList<>(3);

miLista.add(3);

miLista.add(2);

miLista.add(1);

System.out.println(“La lista tiene los elementos: ” + miLista);

}

}

Producción:

La lista tiene los elementos: [3, 2, 1]

En el ejemplo anterior de Java.util.ArrayList, Java es el paquete de nivel superior, util es un subpaquete y ArrayList es una clase presente en el subpaquete util.

Importación de paquetes en Java

Como se muestra en el ejemplo anterior, Java tiene una declaración de importación que nos permite importar un paquete completo o usar solo ciertas interfaces y clases definidas en el paquete.

La sintaxis general de la declaración de importación es:

• importar paquete.nombre.ClassName; //Importa solo una clase determinada
• import package.name.* //Importa todo el paquete

Por ejemplo, import java.util.Date; importa solo la clase Fecha mientras que importa java.io.*; importa todo lo que contiene el paquete java.io.

Sin embargo, la declaración de importación es opcional en Java, y si queremos usar la clase o la interfaz de un paquete determinado, podemos usar su nombre completo de la siguiente manera:

clase MyClass implementa java.util.Date {

//cuerpo

}

2. Paquetes definidos por el usuario

Como se desprende del nombre, los paquetes definidos por el usuario son creados por el usuario para agrupar clases, interfaces y subpaquetes.

Creación de un paquete definido por el usuario

Para crear un paquete definido por el usuario en Java, elegiremos un nombre para nuestro paquete y usaremos el comando del paquete como declaración inicial en el archivo fuente de Java. Como ejemplo, crearemos un paquete llamado ExamplePackage usando la siguiente declaración:

paquete EjemploPaquete;

La declaración del paquete especifica el paquete al que pertenecerán las clases que definimos. Si no usamos la declaración del paquete, los nombres de las clases se colocarán en el paquete predeterminado en Java que no tiene nombre.

Aprenda cursos de desarrollo de software en línea de las mejores universidades del mundo. Obtenga programas Executive PG, programas de certificados avanzados o programas de maestría para acelerar su carrera.

Creando una clase en el paquete Java

Una vez que hemos creado el paquete, el siguiente paso es crear una clase dentro del paquete. Para esto, declararemos el nombre del paquete en la primera declaración del programa, seguido de incluir la clase como parte del paquete.

A continuación se muestra un programa simple para mostrar cómo crear una clase en un paquete Java. En el ejemplo dado, creamos una clase Calculate dentro del paquete ExamplePackage.

paquete EjemploPaquete;

clase pública Calcular {

público int añadir (int p, int q){

devuelve p+q;

}

public static void main(String args[]){

Calcular obj = nuevo Calcular();

System.out.println(obj.add(70, 12));

}

}

Salida: 82

Java almacena paquetes en directorios del sistema de archivos. Entonces, el programa anterior se guardará en un archivo como Calculate.java y se almacenará en el directorio llamado ExamplePackage. Cuando se compila el archivo, Java creará un archivo '.class' y lo almacenará en el directorio ExamplePackage.

Ahora, puede usar el paquete ExamplePackage en otro programa. Así es cómo:

importar paquete de ejemplo. Calcular;

Demostración de clase pública{

public static void main(String args[]){

Calcular obj = nuevo Calcular();

Sistema.out.println(obj.add(200, 523));

}

}

Salida: 723

En el ejemplo anterior, importamos el paquete ExamplePackage para usar la clase Calculate. Importar el paquete como ExamplePackage.Calculate importa solo la clase Calculate. Sin embargo, si tiene más de una clase dentro del paquete ExamplePackage, puede usar todas las clases del paquete usando la siguiente declaración de importación:

importar PaqueteEjemplo.*;

Crear una clase dentro de un paquete al importar otro paquete

Para crear una clase dentro de un paquete al importar otro paquete, comenzaremos declarando el nombre del paquete y luego importando el otro paquete. El siguiente ejemplo demuestra lo mismo:

paquete OtroPaquete; //Declarando un paquete

importar paquete de ejemplo. Calcular; //importando un paquete

Ejemplo de clase pública{

public static void main(String args[]){

Calcular obj = nuevo Calcular();

Sistema.out.println(obj.add(300, 700));

}

}

Salida: 1000

En el ejemplo anterior, declaramos el paquete OtroPaquete, importamos la clase Calcular del paquete EjemploPaquete y luego creamos la clase Ejemplo.

Importación de una clase usando un nombre completamente calificado

Podemos evitar la declaración de importación utilizando un nombre completo. El uso de un nombre completo hace que solo se pueda acceder a la clase declarada del paquete. Pero necesitamos usar un nombre completamente calificado cada vez que accedemos a la clase o interfaz. La importación de una clase con un nombre completo resulta útil cuando dos paquetes tienen el mismo nombre de clase.

El siguiente ejemplo ilustra lo mismo:

1. Calcular.java

paquete EjemploPaquete;

clase pública Calcular {

int público agregar (int x, int y){

devuelve x+y;

}

public static void main(String args[]){

Calcular obj = nuevo Calcular();

Sistema.out.println(obj.add(20, 50));

}

}

2. Demostración.java

paquete OtroPaquete; //Declarando un paquete

Demostración de clase pública{

public static void main(String args[]){

EjemploPaquete.Calcular obj = new EjemploPaquete.Calcular(); //Usando un nombre completamente calificado en lugar de importar

Sistema.out.println(obj.add(200, 100));

}

}

Salida: 300

En el siguiente ejemplo, hemos utilizado el nombre completo ExamplePackage.Calculate para crear el objeto en lugar de importar el paquete.

3. Subpaquetes en Java

Ahora que tenemos una idea sobre los paquetes de Java y cómo crearlos, comprendamos el concepto de subpaquetes en Java.

Un subpaquete es un paquete dentro de otro paquete y se usa para categorizar aún más el paquete. En otras palabras, si creamos un paquete multiplicar dentro del paquete EjemploPaquete, entonces multiplicar es el subpaquete. Por lo tanto, si queremos crear una clase dentro de este subpaquete multiplicado, entonces el subpaquete debe tener una declaración al principio.

El siguiente programa demuestra el concepto de un subpaquete de Java:

paquete EjemploPaquete.multiplicar; //Declarando el subpaquete

Multiplicación de clase pública {

int producto(int p, int q){

devolver p*q;

}

}

Ahora, si queremos usar la clase Multiplicación, podemos:

1. Importarlo usando la instrucción import ExamplePackage.multiply; o
2. use un nombre completo como ExamplePackage.multiply.Multiplication obj = new ExamplePackage.multiply.Multiplication();

camino a seguir

Los paquetes en Java pueden ser paquetes integrados o definidos por el usuario y son esenciales para un mejor acceso y administración del código. El concepto de paquetes Java es crucial para cualquier persona en el campo del desarrollo de software.

La certificación PG vinculada al trabajo de upGrad en ingeniería de software es un programa en línea de 5 meses que puede ayudarlo a dominar las habilidades de programación y prepararse para los roles de software. El programa se enfoca en habilidades fundamentales como Java, JavaScript, CSS3, HTML5, etc., y está especialmente diseñado para principiantes que desean aprender a programar.

Puntos destacados del programa:

• Especialización en MERN/Cloud-Native
• Más de 500 horas de contenido
• Más de 50 sesiones en vivo
• Más de 350 horas de formación práctica
• Cinco proyectos industriales
• Soporte de aprendizaje de 360 ​​grados
• Networking con expertos de la industria

Inscribirse hoy y aprende de los mejores!