Paquetes en java y como usarlos

Un paquete, como su nombre indica, es un paquete (grupo) de clases, interfaces y otros paquetes. En java usamos paquetes para organizar nuestras clases e interfaces. Tenemos dos tipos de paquetes en Java: paquetes integrados y paquetes que podemos crear (también conocido como paquete definido por el usuario). En esta guía aprenderemos qué son los paquetes, qué paquetes definidos por el usuario están en java y cómo usarlos.

En java tenemos varios paquetes integrados, por ejemplo, cuando necesitamos la entrada del usuario, importamos un paquete como este:

import java.util.Scanner

Aquí:
→ Java es un paquete de nivel superior
→ util es un paquete secundario
→ y Escáner es una clase presente en el subpaquete util.

Antes de ver cómo crear un paquete definido por el usuario en Java, veamos los beneficios de usar un paquete.

Ventajas de usar un paquete en Java

Estas son las razones por las que debería utilizar paquetes en Java:

• Reutilización: Mientras desarrollamos un proyecto en Java, a menudo escuchamos que hay pocas cosas que escribimos una y otra vez en nuestro código. Usando paquetes, puede crear cosas así en forma de clases dentro de un paquete y siempre que necesite realizar la misma tarea, simplemente importe ese paquete y use la clase.
• Mejor organizacion: Nuevamente, en grandes proyectos de Java donde tenemos varios cientos de clases, siempre es necesario agrupar tipos similares de clases en un nombre de paquete significativo para que pueda organizar mejor su proyecto y cuando necesite algo, pueda ubicarlo rápidamente y usarlo. , que mejora la eficiencia.
• Conflictos de nombres: Podemos definir dos clases con el mismo nombre en diferentes paquetes para evitar conflictos de nombres, podemos usar paquetes

Tipos de paquetes en Java

Como se mencionó al principio de esta guía, tenemos dos tipos de paquetes en java.
1) Paquete definido por el usuario: el paquete que creamos se llama paquete definido por el usuario.
2) Paquete integrado: paquetes ya definidos como java.io. *, java.lang. * Etc. Se conocen como paquetes integrados.

Ya hemos hablado de los paquetes integrados, analicemos los paquetes definidos por el usuario con la ayuda de ejemplos.

Ejemplo 1: paquetes de Java

He creado una clase Calculator dentro de un nombre de paquete letmecalculate. Para crear una clase dentro de un paquete, declare el nombre del paquete en la primera declaración de su programa. Una clase solo puede tener una declaración de paquete.
Archivo Calculator.java creado dentro de un paquete letmecalculate

package letmecalculate;

public class Calculator {
   public int add(int a, int b){
	return a+b;
   }
   public static void main(String args[]){
	Calculator obj = new Calculator();
	System.out.println(obj.add(10, 20));
   }
}

Ahora veamos cómo usar este paquete en otro programa.

import letmecalculate.Calculator;
public class Demo{
   public static void main(String args[]){
	Calculator obj = new Calculator();
	System.out.println(obj.add(100, 200));
   }
}

Para usar la clase Calculadora, importé el paquete letmecalculate. En el programa anterior importé el paquete como letmecalculate.Calculator, esto solo importa la clase Calculadora. Sin embargo, si tiene varias clases dentro del paquete letmecalculate para que pueda importar el paquete así, para usar todas las clases de este paquete.

import letmecalculate.*;

Ejemplo 2: crear una clase dentro de un paquete al importar otro paquete

Como hemos visto, tanto la declaración del paquete como la importación del paquete deben ser la primera declaración en su programa java. Veamos cuál debería ser el orden cuando creamos una clase dentro de un paquete mientras importamos otro paquete.

//Declaring a package
package anotherpackage;
//importing a package
import letmecalculate.Calculator;
public class Example{
   public static void main(String args[]){
	Calculator obj = new Calculator();
	System.out.println(obj.add(100, 200));
   }
}

Entonces, el orden en este caso debería ser:
→ declaración del paquete
→ importación de paquetes

Ejemplo 3: uso de un nombre completo al importar una clase

Puede utilizar un nombre completo para evitar la declaración de importación. Veamos un ejemplo para entender esto:
Calculator.java

package letmecalculate;
public class Calculator {
   public int add(int a, int b){
	return a+b;
   }
   public static void main(String args[]){
	Calculator obj = new Calculator();
	System.out.println(obj.add(10, 20));
   }
}

Example.java

//Declaring a package
package anotherpackage;
public class Example{
   public static void main(String args[]){
        //Using fully qualified name instead of import
	letmecalculate.Calculator obj = 
		new letmecalculate.Calculator();
	System.out.println(obj.add(100, 200));
   }
}

En la clase Example, en lugar de importar el paquete, utilicé el nombre completo completo como package_name.class_name para crear su objeto. También puede leer: Importación estática en Java

Paquetes secundarios en Java

Un paquete dentro de otro paquete se conoce como paquete secundario. Por ejemplo, si creo un paquete dentro del paquete letmecalculate, se llamará paquete secundario.

Digamos que he creado otro paquete dentro letmecalculate y el nombre del subpaquete es multiply. Entonces, si creo una clase en este subpaquete, debería tener esta declaración de paquete al principio:

package letmecalculate.multiply;

Multiplication.java

package letmecalculate.multiply;
public class Multiplication {
	int product(int a, int b){
		return a*b;
	}
}

Ahora, si necesito usar esta clase de multiplicación, necesito importar el paquete de esta manera:

import letmecalculate.multiply;

o puedo usar un nombre completo como este:

letmecalculate.multiply.Multiplication obj = 
     new letmecalculate.multiply.Multiplication();

Puntos para recordar:

1. A veces puede ocurrir un conflicto de nombre de clase. Por ejemplo: digamos que tenemos dos paquetes abcpackage es xyzpackage y ambos paquetes tienen una clase con el mismo nombre, déjalo ser JavaExample.java. Ahora suponga que una clase importa estos dos paquetes así:

import abcpackage.*;
import xyzpackage.*;

Esto generará un error de compilación. Para evitar tales errores, debe utilizar el método de nombre completo que he mostrado anteriormente. Por ejemplo

abcpackage.JavaExample obj = new abcpackage.JavaExample();
xyzpackage.JavaExample obj2 = new xyzpackage.JavaExample();

De esta manera, puede evitar declaraciones de importación de paquetes y evitar ese error de conflicto de nombres.

2. Ya lo he discutido anteriormente, permítanme mencionarlo nuevamente aquí. Si creamos una clase dentro de un paquete mientras importamos otro paquete, la declaración del paquete debe ser la primera declaración, seguida de la importación del paquete. Por ejemplo:

package abcpackage;
import xyzpackage.*;

3. Una clase solo puede tener una declaración de paquete, pero puede tener más de una declaración de importación de paquete. Por ejemplo:

package abcpackage; //This should be one
import xyzpackage;
import anotherpackage;
import anything;

4. Importación de comodines como paquete. * Debe usarse con cuidado al trabajar con bolsas inferiores. Por ejemplo: digamos: tenemos un paquete a B C y dentro de ese paquete tenemos otro paquete foo, ahora foo es un subpaquete.

las clases dentro de abc son: Ejemplo 1, Ejemplo 2, Ejemplo 3
las clases dentro de foo son: Demo1, Demo2

Entonces, si importa el paquete a B C usando caracteres comodín como este:

import abc.*;

Por lo tanto, solo importará las clases Example1, Example2 y Example3, pero no importará las clases de subpaquete.

Para importar las clases del subpaquete es necesario importar de esta forma:

import abc.foo.*;

Esto importará Demo1 y Demo2 pero no importará Example1, Example2 y Example3.

Entonces, para importar todas las clases presentes en el paquete y subpaquete, necesitamos usar dos declaraciones de importación como esta:

import abc.*;
import abc.foo.*;