2. En Java, es posible agrupar varias clases en una estructura llamada paquete . Un paquete no es más que un conjunto de clases e interfaces relacionadas, generalmente entre sí de alguna manera. En los paquetes las clases son únicas, comparadas con las de otros paquetes, y permiten controlar el acceso. Esto es, los paquetes proporcionan una forma de ocultar clases, evitando que otros programas o paquetes accedan a clases que son de uso exclusivo de una aplicación determinada. Paquetes
3.
4. Declaración de Paquetes Los paquetes se declaran utilizando la palabra reservada package seguida del nombre del paquete. Esta sentencia debe estar al comienzo del fichero fuente. Concretamente debe ser la primera sentencia ejecutable del código Java, package nombre_del_paquete ; Public class nombre_de_la_clase { … .Bloque de sentencias…. } La inclusión de nuevas clases en el paquete es simple, se ha de colocar la misma sentencia al comienzo de los ficheros que contengan la declaración de las clases. Cada uno de los ficheros que contengan clases pertenecientes a un mismo paquete, deben incluir la misma sentencia package , y solamente puede haber una sentencia package por fichero. La sentencia package colocada el comienzo de un fichero fuente afectará a todas las clases que se declaren en ese fichero. El nombre de los ficheros u archivos será el mismo de la clase principal.
5. Declaración de SubPaquetes package nombre_paquete . nombre_subpaquete ; public class nombre_de_la_clase { ...Bloque de sentencias… } Los subpaquetes se declaran utilizando la palabra reservada package seguida del nombre del paquete, un punto (.) y seguido el nombre del subpaquete. Esta sentencia debe estar al comienzo del fichero fuente. Concretamente debe ser la primera sentencia ejecutable del código Java, Los subpaquetes son paquetes derivados de los paquetes principales, El nombre de los ficheros u archivos será el mismo de la clase principal.
6. Palabra Reservada import La palabra reservada import se utiliza para importar clases desde algún otro paquete o subpaquete. import paquete . sub_paquete . nombre_clase / * ; paquete es el nombre de un paquete de alto nivel, sub_paquete es el nombre de un paquete opcional contenido en el paquete exterior separado por un punto (.). No hay ningún límite práctico a la profundidad de la jerarquía de paquetes. nombre_clase el nombre de la clase especifica a importar o un asterisco (*) que indica que el compilador Java debería buscar este paquete completo. Ejemplos import java . util . Date ; import java . io . * ;
7. Ejemplo: clase1.java package paquete1 ; <--------------- declaración del paquete “ paquete1 ” class clase1 <--------------- declaración de la clase “ clase1 ” { String nombre; <-------------- declaración de variables int edad; <-------------- declaración de variables clase1(String nombre,int edad) { this.nombre=nombre; this.edad=edad; } String dame_nombre() { Bloque de sentencias return nombre; } int dame_edad() { return edad; } }
8. package paquete1 ; <--------------- declaración del paquete “ paquete1 ” class clase2 <--------------- declaración de la clase “ clase2 ” { String direccion; <-------------- declaración de variables String estado; <-------------- declaración de variables clase2(String direccion, String estado) { this.direccion=direccion; this.estado=estado; } String dame_direccion() { Bloque de Sentencias return direccion; } String dame_estado() { return estado; } } clase2.java
9. package paquete1 ; <--------------- declaración del paquete “ paquete1 ” import paquete1 . clase1 .*; <------- llamado a todas las clases de clase1 perteneciente a paquete1 import paquete1 . clase2 .*; <------- llamado a todas las clases de clase2 perteneciente a paquete1 class Final <--------------- declaración de la clase “Final” { static void imprimeUsuario ( clase1 usr , clase2 usr1 ) <------ creación del método { que imprime datos System.out.println ("Nombre: " + usr . dame_nombre() ); System.out.println ("Edad: " + usr . dame_edad() ); System.out.println ("Dirección: " + usr1 . dame_direccion() ); System.out.println ("Estado: " + usr1 . dame_estado() ); } public static void main (String[] args) { clase1 obj1 = new clase1("Juan",21); clase2 obj2 = new clase2("Valentín Amador #136","San Luis Potosí"); imprimeUsuario (obj1, obj2); } } Final.java
10. Nombre: Juan Edad: 21 Dirección: Valentín Amador #136 Estado: San Luis Potosí Salida en Pantalla:
11. Ejemplo de subPaquete: package paquete1 . paquete2 ; <------ Declaracion del subpaquete paquete2 class clase3 <------ declaracion de la clase “ clase3 ” { double peso; <-------------- declaración de variables double estatura; <-------------- declaración de variables clase3(double peso, double estatura) { this.estatura=estatura; this.peso=peso; } double dame_peso() { Bloque de sentencias return peso; } double dame_estatura() { return estatura; } } clase3.java
12. package paquete1 . paquete2 ; <------- Declaracion del subpaquete paquete2 import paquete1 . paquete2 . clase3 .*; <------- llamado a todas las clases de clase3 perteneciente a paquete2 class Final1 <--------------- declaración de la clase “Final1” { static void imprimeUsuario ( clase3 usr ) { System.out.println("Peso: " + usr. dame_peso() ); System.out.println("Estatura: " + usr. dame_estatura() ); } public static void main (String[] args) { clase3 obj1=new clase3(88.3,1.82); imprimeUsuario (obj1); } } Final1.java
