Import y Packages

Buenas amigos, en este tema veremos como crear "packages" y, una vez creados, utilizarlos en otras clases con la palabra clave "import".

Los "packages" sirven para agrupar las clases, lo cual permite un mejor ordenamiento y evita que puedan existir clases con nombres duplicados, ya que esto nos llevaría a un error, por lo tanto, los nombres de las clases dentro de un paquete deben ser únicos. Esto suele pasar en grandes proyectos, en los que trabajan varios programadores y puedan llegar a utilizar un mismo nombre para 2 clases distintas, solamente deben meter cada clase en un package distinto, y ya podremos tener el mismo nombre para 2 clases.



Java de por si ya posee varios packages, los cuales llamamos con la sentencia "import", esta palabra clave es la que debemos de utilizar para invocar un "package":

• import java.util.*

Cuando declaramos este "import" estamos llamando al paquete java.util, es decir, dentro del paquete "Java" existe un subpaquete "util", el asterisco (*) después de "util" significa que podemos utilizar cualquier clase dentro de ese paquete, pero si por ejemplo, sólo nos interesara utilizar una clase, Scanner, por ejemplo, haríamos lo siguiente:

• import java.util.Scanner;

de tal forma que sólo podremos utilizar esa clase del paquete "Java.util"

Ya sabemos como se invoca un "package", pero ¿cómo lo creamos?, bien, para crear un "package" hacemos lo siguiente:

• package nombrePaquete

o podemos crear un directorio en un "package" por si hubiese un gran número de clases y debemos ser más específicos en su orden:

• package nombrePaquete.subPaquete

Una cosa antes de continuar y aunque es una chorrada, debe ser entendido, si decidiéramos incluir una clase en un "package", la linea anterior de código que crea el package, debe ser SIEMPRE la primera linea de código, posteriormente deberán ir los "import", y posteriormente el resto de la clase:

• package
• import
• Clase

Si no incluyésemos la clase en un "package" la primera linea de codigo será "import", y posteriormente el resto de la clase:

• import
• Clase

Esto no es muy difícil de entender, pero si muy importante de saber.

Java posee un "package" que se importa siempre, aunque no se especifique, "Java.lang", el cual nos permite entre otras muchas cosas mostrar datos por pantalla con la sentencia "System.out.print", por lo que no nos hace falta importar el "package" para poder utilizarlo.

Al crear una clase, si no le especificamos un "package" java nos lo enviará al paquete predeterminado, con lo cual aunque no quieras, la clase irá a un paquete.

Bien, vamos a aprovechar un poco este tema y vamos a realizar un ejemplo más complejo añadiendo cosas que hemos ido viendo.

Bien, el ejemplo consiste en crear una aplicación en la que se nos pida 2 números, estos se sumarán, restarán, multiplicarán y dividirán, mostrándonos el resultado por consola.

Bien, para ello creamos un nuevo proyecto, yo lo he llamado "Operaciones", en él tengo 2 packages, uno llamado "operaciones" y el otro "resultados":

• En el package "operaciones" se encuentran las clases:
• Sumar
• Restar
• Multiplicar
• Dividir

Cada una de ellas posee lo siguiente:

• Una sentencia "package operaciones" para que sea guardado en dicho "package".
• 2 atributos, uno llamado "x" y otro llamado "i".
• Un constructor con 2 parámetros. El "super()" hace referencia a la clase "padre" Object, puesto que no he heredado de ninguna clase, java me crea una herencia por defecto a Object, que es la raíz de toda la librería de clases. Los "this" son para crear una igualdad entre los atributos que posee la clase y los que se pasan como parámetros.
• Un método(suma, resta, multiplica y divide, según proceda) en el cual se muestra por pantalla el resultado de dicha operación.

• Posteriormente tenemos un segundo "package" llamado "resultados" el cual posee la siguientes clases:

• Calcular
• IntroducirNumeros

• La clase "IntroducirNumeros" pertenece a otro paquete distinto, pero al no tener que utilizar ninguna clase del package "operaciones" no nos hace falta importarlo.
• Esta clase realiza las siguientes funciones:
• Creamos un objeto "Scanner" llamado teclado, y pedimos 2 números por consola que almacenamos en las variables "x" e "i". 
• La clase "Calcular" es la mas importante de todas, en ella vamos a centrar todas las funciones que se realizan en el resto de clases:
• La agregamos al package "resultado" como PRIMERA sentencia.
• Posteriormente importamos el package "operaciones" para poder utilizar las clases que hay en su interior.
• Heredamos de la clase "IntroducirNumeros", con esto nos aseguramos el poder utilizar los atributos y métodos que esta posee.
• public class Calcular extends IntroducirNumeros{};
• En la MAIN creamos un objeto de la clase heredada "IntroducirNumeros"(recordar que en este caso no hago acopio de "Poliformismo" ya que no hay métodos ni atributos que utilizar en la clase "Calcular", por lo tanto el utilizar "IntroducirNumeros in=new Calcular();" es solo cuestión de gustos)
• Finalmente creamos una instancia para cada clase del package "operaciones" en la cuales se realizan las operaciones matemáticas, le pasamos a los constructores de cada una de ellas los valores que hemos ingresado por teclado, como heredamos la clase "introducirNumeros" obtenemos sus atributos, o sea, "x" e "i", para obtener el valor de esos atributos solo tenemos que poner "in.x e in.i", sería como decir, "quiero el atributo "x" que está en la clase a la que pertenece este objeto"
• También os puede sorprender que escriba:
• new Sumar(in.x,in.i).suma();
• Bien esto anterior y lo siguiente son exactamente lo mismo:
• Sumas s=new Sumar(in.x,in.i);
• s.suma();
• Pero como el objeto solo lo utilizo una vez, puedo resumir un poco el código y ponerlo todo junto, así ahorramos espacio y memoria. Son pequeños detalles que poco a poco iréis adquiriendo, de todas formas cada cual puede elegir la manera más cómoda que tenga de programar, la mía es esta, aunque con el paso del tiempo seguramente iré cambiando el estilo, como en todo.

Y ya está, si alguno ha querido copiar el código y lo ejecuta, verá como se les pide 2 números y les mostrará el resultado de las operaciones por la consola de eclipse, el mostrar los resultados por pantalla me ha quedado un poco cutre, pero es que se me está haciendo un poco pesado este tema, podéis modificarlo al gusto.

Unas cosillas a tener en cuenta antes de acabar:

• Recordar los modificadores de acceso si no ponéis ninguno será visibilidad de paquete, esto quiere decir que aunque importemos un package con otras clases, si alguna de estas o alguno de sus atributos o métodos tiene visibilidad de paquete, no podrán ser ejecutados en otros paquetes, SOLO en las clases que estén en su mismo paquete.
• Una última cosa, es posible invocar una clase sin "utilizar" una importación de paquete (import), por ejemplo:
• Para utilizar la clase Scanner del paquete java.util, primero importamos y luego declaramos:
• import java.util.Scanner;
• Scanner teclado =new Scanner(System.in);
• Bien, pues esto podemos hacerlo de esta otra manera:
• java.util.Scanner teclado=new java.util.Scanner(System.in);
• De esta manera nos libramos de utilizar "import", pero para mi gusto engorrona un poco el código (es una opinión), pero es posible que lo veais en otros muchos códigos. Solo lo digo para que si lo veis, sepáis lo que significa.

Finalmente me ha salido una entrada muy extensa para lo poco que es este tema, pero hay pequeños detalles  que deben de ser explicados bien para que se pueda entender, y os puedo asegurar de que no lo he puesto todo, me dejo cosas por poner, pero tranquilos, más adelante iremos retomando conceptos y agregando nuevos, no os saturéis.

Un saludo a todos.