Los paquetes en Java son un mecanismo que encapsula un grupo de subpaquetes e interfaces de clases. Los paquetes se utilizan para:

• Evite conflictos de nombres permitiendo que existan clases con el mismo nombre en diferentes paquetes como college.staff.cse.Employee y college.staff.ee.Employee.
• Facilite la organización, la localización y el uso de interfaces de clases y otros componentes.
• Proporcione acceso controlado para miembros protegidos a los que se pueda acceder dentro del mismo paquete y por subclases. Solo se puede acceder a los miembros predeterminados (sin especificador de acceso) dentro del mismo paquete.

Al agrupar clases relacionadas en paquetes, Java promueve la encapsulación de datos, haciendo que el código sea reutilizable y más fácil de administrar. Simplemente importe la clase deseada desde un paquete para usarla en su programa.

Crear paquetes personalizados

Paso 1: Crear un directorio en el que creamos nuestros paquetes y archivos Java.

mkdir PROGRAMACIÓN

una forma completa

Paso 2: Ahora cambie el directorio y cree otra carpeta dentro de la carpeta principal.

PROGRAMACION DE CDS
mkdir JavaProgramación
cd JavaProgramación
matrices mkdir

Paso 3: Ahora cree un archivo de texto vacío y escriba el siguiente código Java y no olvide guardarlo con el mismo nombre que la clase con extensión .java (TwoPointers.java).

Clase de dos punteros.

package JavaProgramming.arrays; // Main class present inside the package  public class TwoPointers {  public static void main(String[] args) {  System.out.println('Inside the package');  } } 

Nota: No olvide agregar el nombre del paquete dentro del archivo del programa.

Paso 4: Ahora ejecute el programa con la ruta de la carpeta definida

javac srcJavaProgramaciónraysTwoPointers.java

java srcJavaProgramaciónraysTwoPointers.java

Producción:

Estructura de carpetas:

Esta es la representación visual de un paquete personalizado en Java en la siguiente imagen. Primero creamos una carpeta llamada Progamming y dentro de ella creamos un paquete Javaprogramming y luego creamos otro subpaquete que se llama matrices . Luego creamos un archivo de clase Java dentro de él que se muestra en la siguiente imagen:

Funcionamiento de paquetes Java

Estructura del directorio: Los nombres de los paquetes y las estructuras de directorios están estrechamente relacionados. Por ejemplo, si el nombre de un paquete es college.staff.cse, entonces tres directorios son personal de la universidad y cse, donde cse está dentro del personal y el personal está dentro de la universidad.

Convenciones de nomenclatura : Los nombres de los paquetes se escriben en orden inverso a los nombres de dominio, p. org.geeksforgeeks.practice. En una universidad la convención podría ser:

• universidad.tech.cse
• college.tech.ee
• universidad.historia.del.arte

Ejemplo:

cadena en matriz en c

importar java.util.*;

Aquí util es un subpaquete creado dentro del paquete java.  

Acceder a clases dentro de un paquete

En Java podemos importar clases desde un paquete usando cualquiera de los siguientes métodos:

1. Importar una clase específica :

importar java.util.Vector;

Esto importa solo la clase Vector del paquete java.util.

2. Importar todas las clases desde un paquete. :

importar java.util.*;

Esto importa todas las clases e interfaces del paquete java.util pero no incluye subpaquetes.

Ejemplo: Importar la clase Vector

import java.util.Vector; public class Geeks {    public Geeks() {    // java.util.Vector is imported We are able to access it directly in our code.  Vector v = new Vector();    java.util.ArrayList l = new java.util.ArrayList();  l.add(3);  l.add(5);  l.add(7);    System.out.println(l);  }  public static void main(String[] args) {      new Geeks();  } } 

[3 5 7] 

Nota:

• Usando el paquete de importación.*; importa todas las clases de un paquete, pero no las clases de sus subpaquetes.
• Cuando dos paquetes tienen clases con el mismo nombre (por ejemplo, java.util.Date y my.package.Date), utilice el nombre completo para evitar conflictos:

importar java.util.Fecha;

importar mi.paquete.Fecha;

Tipos de paquetes Java

• Paquetes incorporados
• Paquetes definidos por el usuario

1. Paquetes integrados

Estos paquetes constan de una gran cantidad de clases que forman parte de Java. API Algunos de los paquetes integrados comúnmente utilizados son:

• java.lang : Contiene clases de soporte de lenguaje (por ejemplo, clases que definen operaciones matemáticas de tipos de datos primitivos). Este paquete se importa automáticamente.
• java.io: Contiene clases para soportar operaciones de entrada/salida.
• java.util : Contiene clases de utilidad que implementan estructuras de datos como el diccionario de listas vinculadas y soporte; para operaciones de fecha/hora.
• java.applet: Contiene clases para crear Applets.
• java.aut: Contiene clases para implementar los componentes de las interfaces gráficas de usuario (como botones, menús, etc.). 6)
• java.net: Contiene clases para soportar operaciones de redes.

2. Paquetes definidos por el usuario

Estos son los paquetes que define el usuario.

1. Cree el paquete:

Primero creamos un directorio myPackage (el nombre debe ser el mismo que el nombre del paquete). Luego cree MyClass dentro del directorio con la primera declaración siendo los nombres de los paquetes.

Ejemplo:

package myPackage; public class MyClass {  public void getNames(String s)  {   System.out.println(s);   } } 

2. Utilice la clase en el programa:

Ahora usaremos el Mi clase clase en nuestro programa.

 import myPackage.MyClass; public class Geeks {  public static void main(String args[]) {     // Initializing the String variable with a value   String s = 'GeeksforGeeks';    // Creating an instance of class MyClass in the package.  MyClass o = new MyClass();    o.getNames(s);  } } 

Nota: MyClass.java debe guardarse dentro del directorio myPackage ya que es parte del paquete.  

Importación estática en Java

Static Import en Java trata de simplificar el acceso a miembros estáticos y lo separa de la discusión más amplia de paquetes definidos por el usuario.

Importación estática es una característica introducida en el lenguaje de programación Java (versiones 5 y superiores) que permite que los miembros (campos y métodos) definidos en una clase sean públicos estático para ser utilizado en código Java sin especificar la clase en la que se define el campo.

df.loc

Ejemplo:

import static java.lang.System.*; class Geeks {  public static void main(String args[]) {    // We don't need to use 'System.out' as imported using static.  out.println('GeeksforGeeks');  } } 

GeeksforGeeks 

Manejo de conflictos de nombres

Cuando dos paquetes contienen una clase con el mismo nombre (por ejemplo, java.util.Date y java.sql.Date), especifique el nombre completo del paquete para evitar conflictos.

importar java.util.*;
importar java.sql.*;
//Y luego usamos la clase Date y obtendremos un error en tiempo de compilación:
Fecha de hoy; //ERROR-- java.util.Date o java.sql.Date?

El compilador no podrá determinar qué clase de fecha queremos. Este problema se puede resolver utilizando una declaración de importación específica:

importar java.util.Fecha;
importar java.sql.*;

Si necesitamos ambas clases de Fecha, entonces debemos usar un nombre de paquete completo cada vez que declaramos un nuevo objeto de esa clase. Por ejemplo:

java.util.Date deadLine = nuevo java.util.Date();
java.sql.Date hoy = nuevo java.sql.Date();

javafx

Estructura de directorio y CLASSPATH

Los nombres de los paquetes corresponden a una estructura de directorios. Por ejemplo, una clase Círculo en el paquete com.zzz.project1.subproject2 se almacena como:

$BASE_DIR/com/zzz/project1/subproject2/Circle.class

• Aquí $BASE_DIR representa el directorio base del paquete.
• El 'punto' en el nombre del paquete corresponde a un subdirectorio del sistema de archivos.
• El directorio base ( $BASE_DIR ) podría ubicarse en cualquier parte del sistema de archivos.
• Por lo tanto, se debe informar al compilador y al tiempo de ejecución de Java sobre la ubicación de $BASE_DIR para ubicar las clases.
• Se logra mediante una variable de entorno llamada RUTA DE CLASES .
• CLASSPATH es similar a otra variable de entorno PATH que utiliza el shell de comandos para buscar programas ejecutables.

Configuración de CLASSPATH

CLASSPATH se puede configurar de cualquiera de las siguientes maneras:

• CLASSPATH se puede configurar permanentemente en el entorno. Los pasos en Windows son

Vaya al Panel de control -> Sistema -> Avanzado -> Variables de entorno.

• Seleccione 'Variables del sistema' para aplicar CLASSPATH para todos los usuarios del sistema.
• Seleccione 'Variables de usuario' para aplicarlo solo para el usuario que ha iniciado sesión actualmente.
• Editar o crear CLASSPATH: si CLASSPATH ya existe, selecciónelo y haga clic en 'Editar' o si no existe, haga clic en 'Nuevo'
• Ingrese los detalles de CLASSPATH: En el campo 'Nombre de variable' ingrese: 'CLASSPATH' En el campo 'Valor de variable' ingrese los directorios y archivos JAR separados por punto y coma.
• En el campo 'Valor de variable' ingrese los directorios y archivos JAR separados por punto y coma. Ejemplo:

.c:javaprojectclasses;d:tomcatlibservlet-api.jar

• El punto (.) representa el directorio de trabajo actual.
• Para verificar la configuración actual de CLASSPATH, emita el siguiente comando:

> ESTABLECER RUTA DE CLASES

CLASSPATH se puede configurar temporalmente para esa sesión de shell CMD en particular emitiendo el siguiente comando:

> SET CLASSPATH=.;c:javaprojectclasses;d:tomcatlibservlet-api.jar

En lugar de utilizar la variable de entorno CLASSPATH, también puede utilizar la opción de línea de comandos -classpath o -cp de los comandos javac y java, por ejemplo.

> java –classpath c:javaprojectclasses com.abc.project1.subproject2.MyClass3

Ilustración de paquetes definidos por el usuario:  Creando nuestro primer paquete: Nombre de archivo – ClassOne.java

package package_name; public class ClassOne {  public void methodClassOne()  {  System.out.println('Hello there its ClassOne');  } } 

Creando nuestro segundo paquete: Nombre de archivo – ClassTwo.java

package package_one; public class ClassTwo {  public void methodClassTwo()  {  System.out.println('Hello there i am ClassTwo');  } } 

Haciendo uso de ambos paquetes creados: Nombre del archivo – Testing.java

import package_name.ClassOne; import package_one.ClassTwo; public class Testing {  public static void main(String[] args)  {  ClassTwo a = new ClassTwo();  ClassOne b = new ClassOne();  a.methodClassTwo();  b.methodClassOne();  } } 

Ahora echemos un vistazo a la estructura de directorios de los paquetes y del archivo de clase de prueba:

Modificadores de acceso en el contexto de paquetes

• Público: Miembros con elpublicSe puede acceder al modificador desde cualquier lugar, independientemente de si la clase de acceso está en el mismo paquete o no. .
• Protegido: Se puede acceder a los miembros con el modificador protected dentro del mismo paquete en subclases
• Por defecto: Solo se puede acceder a los miembros sin modificador dentro del mismo paquete
• Privado: Miembros con elprivateEl modificador solo es accesible dentro de la misma clase. No pueden acceder a ellos clases de las mismas subclases de paquete o de paquetes diferentes.