Mucho Java en un sencillo tutorial (para Dummies)
Veremos algo muy importante tanto en la programación como en la vida misma, que es mantener un orden para las cosas.
El tutorial anterior empezamos el proyecto de un “proyecto_barco_en_una_botella”, para entender la idea de IDE era muy útil, pero poco jugo se puede sacar más. Tenemos el barco en un paquete, podríamos crear otro paquete para la botella, pero ¿Qué código le ponemos? Es algo estático, un barco en una botella es un adorno inanimado, la programación da el resultado de algo que tiene que moverse. Un ordenador es una herramienta para automatizar cosas que hacemos, ¡Un adorno que está en la estantería no se le puede automatizar nada!
Por eso vamos un poco más allá para entender la programación en Java. Vamos a pensar en algo que se mueva, para entenderlo mucho mejor algo que esté diseñado por los humanos, vamos por todo lo alto: un coche.
Esta es nuestra idea, fabricar un coche y que funcione.
Como programadores no nos interesa el dibujo del coche como tal o la forma, sino las funcionalidades de entrada-salida, en inglés lo veremos como Input-Output ¿Qué es esto de entrada-salida? El nombre no es que sea muy bonito ni original, pero es eso, algo que entra y algo que sale.
Vamos por partes. Pensemos en el motor del coche. Como programadores no nos podemos quedar en lo superfluo, vamos a fabricar algo que tiene funcionalidad; y para fabricar algo con funcionalidad necesitamos entender lo más profundo de cómo funciona. Por si no lo sabías antes, considéralo clase doble de programación y de mecánica automovilística básica: el motor del coche tiene pistones en el interior, supongamos que es de cuatro tiempos (más información en: http://es.wikipedia.org/wiki/Ciclo_de_cuatro_tiempos) como el siguiente -observa el Gif animado y el número que tiene cada paso. Para que el pistón de cuatro tiempos funcione sigue estos pasos:
1.Entra gasolina y oxígeno en el pistón -fíjate en el “entra”, es un Input 2. Comprime la gasolina 3. Hacen que la gasolina entre en combustión para que explote 4. Salen gases y movimiento -fíjate en el “sale”, es el Output
Ya tenemos algunas ideas para programar el coche. Para ir poco a poco empecemos.
Vamos a continuar llenando nuestra carpeta que se comporta como “maletín” de nuestros proyectos.
Si hemos cerrado Eclipse, al abrirlo veremos como nos pregunta por el espacio de trabajo que queremos usar. Por defecto se guarda el último que hemos usado, lo aceptamos o lo buscamos y aceptamos -si tienes dudas consulta el tutorial de instalación de Eclipse, en la parte donde se abre.
Anteriormente teníamos un programa muy simple llamado “proyecto_barco_en_una_botella”. Pues bien, dejemos a un lado el anterior proyecto minimizando el árbol de carpetas del proyecto y cerrando lo que tengamos abierto. Eso ya está guardado y ahí quedará, es un proyecto acabado -tristemente acabado, es apenas un par de líneas de código, pero es lo que hay.
Tendremos todo preparado para empezar a trabajar con un nuevo proyecto cuando quede del siguiente modo.
Ahora un repaso a lo básico de como crear un proyecto en Eclipse, consulta el tutorial de crear nuestro primer pyoyecto en Eclipse si hay dudas para crear un nuevo proyecto. Llamaremos al nuevo proyecto, por ejemplo, “proyecto_coche”. Luego, nos pareció bien crear dentro un par de paquetes “panel_de_conductor” -que se encargará de comunicarse con el conductor- y “piezas_internas” -que será el resto de componentes del coche que no toca el conductor directamente, como el motor, entre otros. Estos paquetes nos ha parecido bien que fueran estos para clasificar, pero cada uno puede poner los paquetes que le interesen, cuantos menos mejor, pero que esté clasificado -para programas pequeños, con un paquete y una clase nos sobra, pero aquí para que sea didáctico crearemos varios paquetes y varias clases.
La idea sería la siguiente:
Que se traduciría en Eclipse en (lo dicho, si no sabes como se han hecho estos pasos, repasa el tutorial anterior):
Ya tenemos los paquetes, ahora hay que añadirle las clases. Lo que tenemos que conseguir con nuestro programa es que tenga una parte de código que sirva para que empiece y de ahí en adelante sentencia a sentencia que vaya ejecutando.
Queremos ahora que nuestro proyecto tenga la siguiente idea:
Se nos ha ocurrido que sería interesante que la clase que se encargara de empezar con el programa esté en el paquete del conductor, ya que es el que pone la llave en el coche y al hacer contacto el coche arranca. Por tanto, en el paquete “panel_de_conductor” crearemos una clase que llamaremos “Arranque” y en el paquete “piezas_internas” crearemos otra clase llamada “Motor” (la creación de estas dos clases se deja como repaso del anterior tutorial).
Empezaremos por las piezas del coche. Por tanto, empezaremos por el motor. Para abrir la clase a editar o pulsamos doble clic en la clase dentro del paquete, o pulsamos en la pestaña de “Motor.java” en caso de que esté abierta. De cualquiera de las dos maneras iremos a parar al lugar donde tenemos que editar la clase Motor. Vemos en la siguiente imagen, señalado en un cuadro en ámbar, donde tenemos que introducir el código que hará que el motor funcione, porque de momento es una carcasa vacía.
Ahora pensemos que hace un motor: convierte algo en movimiento. Por tanto, un motor tiene movimiento. Tenemos que representar ese movimiento en nuestra clase Motor, para ello vamos a usar una variable.
Tipos de datos para una variable Una variable sirve para guardar cualquier tipo de dato, como un número, un texto, etc. Hay que entender que estamos trabajando con un ordenador, y que tiene tipos de datos simples -o primitivos- que suelen ser los más comunes:
Se tiende a utilizar otros tipos de datos simples pero no los hemos puesto por una razón: una cosa que no hay que hacer cuando se programa es aprenderse las cosas de memoria. Las cosas se buscan cuando hay que usarlas. En este caso se han explicado estas por o bien las vamos a usar en este ejemplo, o se usan muy a menudo y te las terminarás aprendiendo. Se puede decir que estas variables son las palabras de la programación que más se usan, aunque existen otras, que si tienes curiosidad puedes buscarlas muy fácilmente en internet escribiendo en un buscador: tipos de datos de Java. |
Para almacenar un valor que represente al movimiento ¿Qué tipo de variable sería recomendable usar de las vistas en el cuadro anterior? Obviamente, tendrá que ser un número: int o double. Como lo representaremos en unidades enteras, pues escogemos int.
Solo hace falta declarar la variable, pero ¿Cómo se declara?
Declarar un variable Recordamos como en el colegio nos daban en clase de matemáticas que una variable X (ojo a lo de variable) era igual a un número, como por ejemplo: X=5, donde X vale 5. La idea es idéntica, aunque en el caso del colegio, las variables podían ser igualadas a cualquier tipo de número (ojo a lo de tipo), pero a ¿qué no de texto? Sería como decir: X=“Cinco”. Como vimos en el anterior cuadro de los tipos de una variable, podría tener el tipo String y contener la variable texto. Pues bien, esto hay que indicárselo a Java, y decirle que tipo de dato va a contener nuestra variable. Para declarar una variable en Java se sigue el siguiente esquema (toda sentencia de Java lleva punto y coma al final): Un_tipo_de_dato_que_es Nombre_de_la_variable = Un_valor_del_tipo_de_dato_de_la_variable; Lo que es lo mismo que: Los dos cuadros morados es lo mismo que la manera de declarar que la variable X solo va a contener, por ejemplo enteros, la flecha es el igual, y el cuadro verde el tipo de dato que va a contener, por ejemplo 5. Así, se declararía en Java: int X = 5; Entendido esto, veamos un ejemplo de declaración para cada tipo de dato del cuadro anterior.


Para hacer las cosas fáciles llamaremos a la variable velocidad_de_rotacion_del_motor y la inicializaremos en 0. Nuestro código de la clase motor tendrá que quedar como sigue (tanto la palabra private como public lo veremos un poco más adelante en el cuadro de Nivel de visibilidad):
package piezas_internas; public class Motor { private int velocidad_de_rotacion_del_motor = 0; }
Seguramente en Eclipse te salga la variable subrayada de amarillo, ni caso. Esto es un a advertencia –lo verás como Warning en inglés. Te esta avisando que no estás usando esa variable, y es así, está sola y nadie la usa.
Hemos puesto que la velocidad de rotación del motor es cero, porque no hay nada que lo mueva, está en reposo. Esta variable marcará el estado de la velocidad de motor antes y después de funcionar el motor.
Continuamos con el motor como una carcasa. Necesitamos algo que esté dentro. El pistón del que hablamos antes estaría bien. ¿Qué sabemos del pistón? Sabemos que para funcionar requiere algo de gasolina y algo de oxígeno. Y que devuelve una fuerza para que el coche se mueva y dióxido de carbono, como solo nos interesa lo que devuelve para que funcione, despreciaremos el dióxido de carbono.
El pistón será por tanto un método, lo que quiere decir que será una pieza del motor.
De este modo, tenemos que entran unos mililitros de gasolina y de oxígeno, que estos que entren tienen que ser enteros. Además, cuando el pistón funcione, el pistón devolverá una fuerza que será otro entero. ¿Cómo hace esto? Sigamos.
Escribir para el método como lo indicamos la imagen de encima está bien, pero siempre hay que escribir delante del método el nivel de visibilidad.
Nivel de visibilidad Los métodos y las clases siempre deben de tener antepuesta una palabra que indica el nivel de visibilidad. En las variables no se pone siempre. Los niveles de visibilidad son tres (si nunca has visto esto, te recomiendo que solo leas public y private, no hagas ni caso a protected, pues hay que tener algo más de base, pero llegaremos a ello en posteriores tutoriales):


Por tanto, queremos que el pistón solo pueda ser usado por el Motor, ¿Para qué vamos a dejar que lo toque otra cosa o el conductor? ¿Para qué lo rompa?
Una cosa que nos hemos dejado en el tintero es la visibilidad de la primera variable que hemos creado velocidad_de_rotacion_del_motor, como es un estado interno del motor, es solo del motor, por tanto, también privado.
Escribimos nuestro código para que quede de la siguiente forma:
package piezas_internas; public class Motor { private int velocidad_de_rotacion_del_motor = 0; private int un_piston (int mililitros_de_gasolina, int mililitros_de_oxigeno){ int fuerza_del_piston = 0; return fuerza_del_piston; } }
Eclipse te habrá subrayado en amarillo el método. Te está diciendo que no estamos usando el pistón en ningún lado, y es cierto ¿No? El motor tiene dentro el pistón pero no lo usa en ningún lado.
Centrémonos en lo que está en el código del pistón:
private int un_piston (int mililitros_de_gasolina, int mililitros_de_oxigeno){ int fuerza_del_piston = 0; return fuerza_del_piston; }
Hemos escrito una variable interna del método que se llama fuerza_del_piston, que servirá para algo parecido a lo que hace la variable velocidad_de_rotacion_del_motor. ¡Ojo cuidao! Fijémonos en los corchetes que contienen a lo que hay en el método, la variable fuerza_del_piston solo se usará en el interior de ese método. Sin embargo, la variable velocidad_de_rotacion_del_motor se podrá usar dentro de este método o en cualquiera de la clase (Pero si es privado, ¿Cómo se va a usar?, si te haces esta pregunta aún no te has enterado bien, estamos dentro de la clase motor, es privado para los que están fuera; piensa en un motor físico de un coche cuando abres el capó, ¿está accesible para ti el pistón? No ¿Y la velocidad de rotación del motor? Sí, pero a través de la correa de transmisión, pero cuando se genera en un primer momento dentro del motor no; aún no hemos llegado a la salida del motor; puede que te aclare más lo de privado y público cuando usemos el motor, que es realmente donde se ve o no).
Otra cosa, fuerza_del_piston no hace falta ponerle nada delante para la visibilidad, porque es una variable local, y todo lo que está dentro de un método es privado y solo para ese método. Si tienes un pistón en la mano, todo lo que tenga dentro ¿a qué no es accesible de ninguna manera? Rompiéndolo si acaso, pero deja de funcionar, y al igual que en el código, si está roto no funciona.
Continuemos poniéndole lógica y funcionamiento al pistón (esto es, en el gif animado del pistón el paso 2 y 3). Supongamos lo siguiente: el pistón solo resiste si le entran menos de 30 mililitros de gasolina, sino explota. El funcionamiento va a ser muy simple, se va a multiplicar la cantidad de oxígenos por la de gasolina y lo que dé es la fuerza. Analicemos las dos frases anteriores:
Estamos tratando con una condicional en toda regla. La conversión a Java sería:
Como no íbamos a provocar un error en el programa al ser mayor o igual que 30, hemos optado por mostrar por la consola de Eclipse un mensaje simbólico de la explosión.
Nuestra clase Motor tendría que quedar de la siguiente manera:
package piezas_internas; public class Motor { private int velocidad_de_rotacion_del_motor = 0; private int un_piston (int mililitros_de_gasolina, int mililitros_de_oxigeno){ int fuerza_del_piston = 0; if (mililitros_de_gasolina<30){ fuerza_del_piston = mililitros_de_gasolina * mililitros_de_oxigeno; }else{ System.out.println("¡El pistón ha sido demasiado cargado de gasolina y ha explotado!"); } return fuerza_del_piston; } }
De esta manera, si la gasolina es menor que 30 lo que pasa es que obtenemos una fuerza del pistón que cuando llega el código a return, se devolverá fuera del método la cantidad a quien lo pida (si por ejemplo, la gasolina es 3 y el oxígeno 5, como gasolina<30 entonces la fuerza del pistón es 3×5 que es 15).
Ahora vamos conectar los circuitos del motor al pistón. Para ello tenemos que crear en la clase otro método, pero este método es especial, su visibilidad es siempre pública, nunca devuelve nada y se llama igual que la clase. Esto comúnmente se llama constructor y no método, ya que se ejecuta en el momento justo en el que se usa a la clase por primera vez.
Para este caso crearemos el constructor con una entrada para la gasolina (imagínate el motor físico con un tubo de entrada para la gasolina), el aire es el ambiental que entra por el respiradero del motor y supongamos que a cada pistón le entra 2 mililitros de oxígeno. Como el pistón devuelve la fuerza que ha obtenido, y en este caso es toda la que se transmite como velocidad de rotación al motor tendremos que:
public Motor (int mililitros_de_gasolina){ velocidad_de_rotacion_del_motor = un_piston (mililitros_de_gasolina, 2); }
Insertaremos las líneas del constructor para que quede el código de la siguiente manera (por norma general de programador, el constructor o constructores se ponen delante de todos los métodos, pero después de las variables globales):
public class Motor { private int velocidad_de_rotacion_del_motor = 0; private final int capacidad_maxima_en_mililitros_de_gasolina_para_un_piston = 30; public Motor (int mililitros_de_gasolina){ velocidad_de_rotacion_del_motor = un_piston (mililitros_de_gasolina, 2); } private int un_piston (int mililitros_de_gasolina, int mililitros_de_oxigeno){ int fuerza_del_piston = 0; if (mililitros_de_gasolina<capacidad_maxima_en_mililitros_de_gasolina_para_un_piston){ fuerza_del_piston = mililitros_de_gasolina * mililitros_de_oxigeno; }else{ System.out.println("¡El pistón ha sido demasiado cargado de gasolina y ha explotado!"); } return fuerza_del_piston; } }
Tenemos el arranque el estado del motor (velocidad_de_rotación_del_motor), tenemos el arranque del motor (Constructor), y tenemos el funcionamiento interno del motor (pistón). Si nos imaginamos el motor, nos queda donde se engancha la correa de transmisión, es decir la salida del motor.
Como repaso crearemos el método de salida de datos, ya tendríamos que saber hacer esto con lo explicado anteriormente. Creamos un nuevo método, muy sencillo, no tiene entradas, solo la salida que será la velocidad de rotación del motor, y como va a la correa de transmisión, es público para que lo puedan usar otras piezas (clases).
public int get_velocidad_de_rotacion_del_motor(){ return velocidad_de_rotacion_del_motor; }
Por norma entre los programadores, un método que devuelve algo le anteponemos “get” (quiere decir “dame”) y uno que mete algún valor en la clase se antepone “set”. En este caso no hay “set”, pues de obtener los datos se encarga el constructor de la clase.
Si lo añadimos al código total tenemos nuestra clase final Motor como:
package piezas_internas; public class Motor { private int velocidad_de_rotacion_del_motor = 0; private final int capacidad_maxima_en_mililitros_de_gasolina_para_un_piston = 30; public Motor (int mililitros_de_gasolina){ velocidad_de_rotacion_del_motor = un_piston (mililitros_de_gasolina, 2); } private int un_piston (int mililitros_de_gasolina, int mililitros_de_oxigeno){ int fuerza_del_piston = 0; if (mililitros_de_gasolina<capacidad_maxima_en_mililitros_de_gasolina_para_un_piston){ fuerza_del_piston = mililitros_de_gasolina * mililitros_de_oxigeno; }else{ System.out.println("¡El pistón ha sido demasiado cargado de gasolina y ha explotado!"); } return fuerza_del_piston; } public int get_velocidad_de_rotacion_del_motor(){ return velocidad_de_rotacion_del_motor; } }
Analicemos un momento lo que hemos hecho en esta clase:
¡Después de tanto, al fin hemos fabricado el motor!, guardamos todo para que no perdamos los cambios. Ahora solo nos queda probar esta clase.
Para ello nos vamos a editar la clase Arranque. En esta añadimos el método de arranque del programa main.
package panel_del_conductor; public class Arranque { public static void main(String[] args) { } }
TRUCO PARA CREAR AUTOMÁTICAMENTE EL MÉTODO MAIN: Para la clase que arranca el programa, cuando pulsemos en New/Class, la ventana emergente podemos marcar la casilla “public static void main(String[] args)”. Conseguimos que Eclipse nos ahorre parte del trabajo. Si estás pensando ¡Si Eclipse me hace el trabajo no aprendo!, es verdad, pero en programación tampoco hay que memorizar código, para eso están la documentación que veremos más adelante. Por tanto, si sabemos cuando pulsar esta casilla para que Eclipse lo haga solo -que tampoco añade tanto código como verás al pulsar “Finish”- ya será algo bien aprendido. Pues estamos aprendiendo no solo a programar en Java, sino a usar un IDE –y un IDE son herramientas, y esta es una que nos facilita un poco la vida. Vemos que el código que nos ha añadido Eclipse automáticamente es el siguiente. Ha añadido muchas cosas raras que de momento no explicaremos -las dejamos para un poco más adelante. Vamos a borrar todo lo que de momento nos sobra hasta dejarlo como sigue: ¿Mucho mejor no? Lo mismo que en el anterior tutorial. Ahora solo hace falta rellenar. Cuando aprendamos en un futuro próximo, veremos que lo que hemos borrado también es útil. |
Vamos a usar el motor al arrancar. ¿Cómo hacemos esto? Fácil. De la misma manera que creamos la declaración de una variable, creamos una para el motor dentro de la clase main. ¿Recuerdas lo de int X = 5? Pues igual, pero el tipo no será ninguno de los simples, sino uno compuesto que hemos creado nosotros, será Motor, es decir, la clase Motor hará de tipo de dato.
Motor mi_motor =
Aquí tenemos una cosa que se llama mi_motor, sea un X, que solo admite algo de Motor, pero que no apunta a nada. ¿Y qué valor guardamos?, pues un motor que tenemos que crear nuevo, y como el constructor que hicimos tenemos que mandarle la cantidad de gasolina, le ponemos por ejemplo 20.
Motor mi_motor = new Motor (20);
Aquí tenemos que tener clara la diferencia entre Motor que es la clase y mi_motor que es el objeto (sin darte cuenta te hemos metido en el fabuloso mundo de los objetos en un solo tutorial de programación). Una clase es por así decirlo el molde para moldear los objetos, y un objeto es un objeto valga la redundancia, si es que es blanco y en botella si se entiende. Motor es el molde y mi_motor es el objeto creado con el molde. Añadamos esta línea al código para ver que ocurre:
package panel_del_conductor; public class Arranque { public static void main(String[] args) { Motor mi_motor = new Motor (20); } }
Eclipse se queja subrayando en rojo las palabras Motor. Tranquilo, no nos hemos equivocado. Si colocamos el cursor sobre nuestro problema, Eclipse nos dirá que podemos hacer. En este caso la primera opción es la ideal, ya que hay que decirle a Java que esta clase Arranque va a usar otra clase llamada Motor. Pulsamos por tanto en la que pone “Import Motor (piezas_internas)” y solucionado.
Veremos como Eclipse automáticamente nos ha añadido una línea de importación que se llama:
import piezas_internas.Motor;
Continuamos, que ya queda nada y menos para probar lo que hemos hecho.
Debajo de la creación del objeto mi_motor creamos una variable de tipo entero que se llame velocidad_coche, que tendrá el valor que le transmita la correa de transmisión desde el mi_motor (imaginemos que tenemos el motor físico y queremos atarle la correa de transmisión a algún lado). Para llamar a un método del objeto escribimos el nombre del objeto y después un punto. Eclipse seguro que te ha puesto un montón de recomendaciones, de las cuales podemos ver una que hicimos nosotros que se llama: “get_velocidad_de_rotacion_del_motor():int – Motor” (seguro que no hace falta explicar mucho de esta línea, después de los dos puntos finales aparece int que es el valor que nos devuelve, que será la velocidad de rotación del motor; y seguido de un guion aparece Motor, que es de la clase que Eclipse está sacando este método para mostrártelo). Como curiosidad y si no entendiste lo de la visibilidad, es el único método que declaramos como público anteriormente en la clase Motor -que no es constructor- que se ve en esta lista; el privado no aparece (prueba a ir a la clase Motor para cambiar private por public, guarda y luego vuelve a la clase Arranque para volver a ver las sugerencias de Eclipse, seguro que ahora te aparece el público).
La seleccionamos, ponemos el punto y coma, y nos la habrá puesto.
int velocidad_coche = mi_motor.get_velocidad_de_rotacion_del_motor();
Para terminar, debajo de esta línea escribimos lo siguiente para que nos muestre el resultado por consola:
System.out.println("La velocidad del coche es "+velocidad_coche+" km/h");
Por lo que el código final aparece así:
package panel_del_conductor; import piezas_internas.Motor; public class Arranque { public static void main(String[] args) { Motor mi_motor = new Motor (20); int velocidad_coche = mi_motor.get_velocidad_de_rotacion_del_motor(); System.out.println("La velocidad del coche es "+velocidad_coche+" km/h"); } }
Vemos como se nos muestra por pantalla el resultado, que es 40 (20 de gasolina por 2 de oxígeno).
Nos acordamos que pusimos una condicional. Probemos a modificar el 20 del motor por un número mayor o igual que treinta, por ejemplo 100.
Correctamente si le pasamos al motor 100 de gasolina, el pistón explota. Y como ha explotado, no se habrá hecho ningún cálculo de multiplicación y por tanto, nos devolverá el valor inicial de la velocidad que era 0.
Repasemos un poco el código de lo que ha hecho para dar este resultado. Fíjate en la siguiente imagen comenzando con dar la orden al ordenador para que se ejecute y seguimos las flechas rojas.
Todo se va haciendo secuencialmente, línea a línea empezando por el método main, pero cuando se encuentra una llamada a la clase Motor saltamos al motor y al acabar continuamos. Las flechas rojas indican las llamadas a cada método y la devolución de datos de los mismos.
Si has llegado hasta aquí es que has acabado el tutorial, con lo que ¡enhorabuena! Habrás aprendido un montón de cosas de Java y Eclipse:
- Ordenar nuestros proyectos en Eclipse
- Declaración de todo tipo de variables tanto simples como complejas, globales o locales.
- Uso de métodos con valores de entrada y retorno (input y output).
- Uso de constructores.
- Uso de objetos.
- Visibilidad pública y privada.
- Condicional If-else.
- Uso de la consola de Eclipse.
- ¡Y hasta como funciona el motor de cuatro tiempos!