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.

3 Mucho Java en un  solo tutorial - www.jarroba.com

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:

Tipo de Dato Descripción de los valores que puede guardar
int Guarda un número cualquiera positivo o negativo como 365 o -19, pero sin decimales. Muy utilizado, por ejemplo, para contar cosas
double Guarda un número cualquiera positivo o negativo como 365.3434 o -19.434, con decimales, la coma es un punto. Utilizado, por ejemplo, en el resultado de una división
boolean Guarda True -verdadero- o False -falso. Utilizado, por ejemplo, para activar o desactivar algo
String Guarda un texto que queramos entre comillas, por ejemplo: “Érase una vez en un lugar de la Mancha…”

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.

Tipo Ejemplo de declaración
int int contar = 34;
double double resultado_división = 2.5;
boolean boolean bombilla_encendida = True;
String String Texto_del_Quijote = “Érase una vez en un lugar de la Mancha”

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):

Tipo Significado Quien lo usa
public Público. Indica que otras clases curiosas que si quieren pueden usarlo ¡Es público! Si no se pone nada delante de una clase, método o variable, se considera público. Salvo si es una variable dentro de un método (se llama variable local), que será privado para todos salvo para el método donde esté Clases: normalmente las clases son siempre públicas. Queremos que una clase sea vista por otra Métodos: Si queremos que otras clases puedan ver el método Variables: Si queremos que otras clases puedan ver la variable
private Privado. Indica a otras clases curiosas que NO pueden usar esto, solo puede usarlo la clase en donde está Clases: NO se usa en las clases, pues una clase privada no tendría sentido. ¡No podría usarla ni siquiera Java! Métodos: Si queremos que otras clases NO puedan ver el método Variables: Si queremos que otras clases NO puedan ver la variable
protected Protegido (se usa solo en herencia; es un tipo de visibilidad avanzada, si no quieres perder el tiempo por ahora pasa de esta y vuelve cuando hayas aprendido algo de herencia en posteriores tutoriales, está aquí puesta para que estén todos los niveles de visibilidad juntos) Indica a otras clases curiosas que NO podrán usarlo si no son clases hijas del padre que tiene algo protegido (como analogía: el padre protege algo para que exclusivamente lo puedan usar sus hijos). Podrán usarlo la misma clase donde está o una clase hija Clases: Tiene sentido cuando un padre tiene una clase interna, para que pueda ser usada por las clases hijas Métodos: Si queremos que solo puedan ver el método las clases hijas Variables: Si queremos que solo puedan ver la variable las clases hijas

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");
    }

}

Pulsamos en ejecutar nuestro  código (círculo verde con la flecha, ver anterior tutorial si no recordamos).

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!
Comparte esta entrada en:
Safe Creative #1401310112503
Mucho Java en un sencillo tutorial (para Dummies) por "www.jarroba.com" esta bajo una licencia Creative Commons
Reconocimiento-NoComercial-CompartirIgual 3.0 Unported License.
Creado a partir de la obra en www.jarroba.com

37 comentarios en “Mucho Java en un sencillo tutorial (para Dummies)”

  1. Buenas! Los quiero felicitar por este articulo. Esto en el instituto lo dan en varias clases y ustedes lo han presentado de una manera excelente! Con mucha simplesa y con gran cantidad de contenido. Esta sera mi web de cabezera para continuar dando mis primeros pasos en java!

    1. Nos alegra que te haya serdo útil 🙂

      Muchos ánimos Jose con los estudios, te puedo asegurar que la programación es la mejor herramienta que se ha inventado (al menos seguro que por encima de las calculadoras de bolsillo 😀 )

  2. en la clase arranque, que quiere decir los signos + ?

    int velocidad_coche = mi_motor.get_velocidad_de_rotacion_del_motor();
    System.out.println(“La velocidad del coche es “+velocidad_coche+ km/h”);
    }

    1. los signos "+" significa que va a concatenar  la leyenda  “La velocidad del coche es “ mas lo que traiga la variable velocidad_coche mas la leyenda " km/h” para más informacion busca concatenar en java

    2. Como bien ha respondido Luis es para concatenar textos (Strings).

      Si por ejemplo, la variable tiene el valor 70:

      int velocidad_coche = 70;

      Entonces, cuando el programa llegue a la línea:

      System.out.println(“La velocidad del coche es “+velocidad_coche+ km/h”);

      Se mostrará por la consola:

      La velocidad del coche es 70 km/h

  3. Brutal el tutorial recien empiezo a estudiar un grado superior en pocos dias cual es el siguiente que me recomiendas? cual es la docuemntacion para no aprendernos el codigo de memoria xD

     

    Muchisimas felicidades por la pagina.

    1. Gracias Sergio 🙂

      La base es lo más importante en la programación, el resto de cosas es ir aprendiendo lo que necesites cuando lo necesites y aprenderás mucho.

      Lo siguiente que te recomiendo es que aprendas son estructuras de datos (Arrays, List http://jarroba.com/arraylist-en-java-ejemplos/, Maps http://jarroba.com/map-en-java-con-ejemplos/), que son muy importantes para cualquier cosa que hagas (programas de gestión de datos, videojuegos, aplicaciones de cualquier cosa etc); así como herencia (http://jarroba.com/herencia-en-la-programacion-orientada-a-objetos-ejemplo-en-java/) y polimorfismo que es muy útil (http://jarroba.com/polimorfismo-en-java-parte-i-con-ejemplos/). Luego lo que necesites, puedes echar un vistazo a los tutoriales que tenemos de Java: http://jarroba.com/?s=java

  4. Felicitaciones por el tutorial, es muy bueno! No me imagino cuánto esfuerzo y tiempo le dedicaste, pero en serio se agradece. =)

  5. Desde colombia, Un abrazo, te cuento el 21 de oct de 2015, me inscribi en un curso online y sinceramente hoy e aprendido mas que en mes y medio que llevo del curso,  espero me puedas recomedar otro ejemplo de metodos, constructor etc, para tener mas claros estas bases,  te comento que debo de crear un programa que le solicite cedula, nombre, edad y estos datos los podamos, almacenar, consultar y despues borrar segun la informacion q digite el usuario, si me puedes ayudar recomendandote un video o pagina tuya te agradeceria muchisimo.

    1. Hola Julio. Te recomiendo que eches un vistazo a nuestro catálogo de tutoriales de Java: http://jarroba.com/?s=java. Sobre todo y aparte del de Java básico te recomiendo para empezar con buen pie en Java los artículos sobre herencia, ArrayList, Map, Enumerados, Polimorfismo. Luego para lo la interfaz posiblemente quieras desarrollarla con JavaFX del que también podrás ver artículos en el link anterior

      Un abrazo muy grande para tí también y muchos ánimos con los programas a desarrollar 🙂

  6. hola, fantastica tu explicacion y muy practica. Soy un ingeniero de pruebas de software iniciandose en selenium webdriver y me ha servido  bastante esto para entender algunos conceptos.. te doy un 10

  7. Millones de gracias por este fantástico tutorial.

    Me estoy iniciando en el mundo del java y la verdad que me estais ayudando muchísimo.

    ¿Cual sería el siguente tutorial que me recomendarias para seguir aprendiendo java?

    La web esta fenomenal pero no me aclaro con el orden a seguir.

    De nuevo os felicito por toda la sabiduría que compartis, hay muucha gente que le cuesta compartir lo que sabe, o no quiere hacerlo.

    un saludo!

    1. Hola Eugenia. Este artículo nos centramos en explicar las bases de Java, luego Java es muy amplio, pero poco a poco vas asimilando todo. Por ello depende un poco lo que necesites aprender (todo lo que tenemos de java en: http://jarroba.com/?s=java). Algunos de los que te recomiendo para ir adquiriendo base son:

      Luego tenemos muchos más que dependen de las necesidades y lo que quieras aprender.

      Y muchos ánimos, ya verás como es apasionante el mundo Java 🙂

  8. Wao! Increible, entré a esta pagina de casualidad mientras googleaba y me he encontrado con una mina de oro. He entendido a la perfección este tema, se lo pasé a mi hermano quién recién está aprendiendo Java desde ayer y lo que hubiera tomado semanas o incluso un par de meses, ya lo sabe, solo queda practicar para perfeccionar.

    Muchas Gracias por todo su tiempo para brindarnos excelentes temas.

    Un gran saludo desde Perú.

    Bill Flores.

  9. Desde Santiago de Chile
    Estimados muchas gracias por tan loable ayuda que nos han brindado con este tutorial, tan claro, tan diáfano, tan fácil de aprender y de entender, lo que me era muy complicado de comprender, hoy con la ayuda de ustedes se han solucionado muchas dudas , y ya se va perdiendo el temor a esta herramienta que la miraba desde lejos, porque no tenía esa visión clara de los manejos y llamados a métodos y menos la creación de objetos, en fin muy agradecidos por su gran manejo para explicar lo difícil como simple

    Julio Cesar Buschiazzo

  10. El tutorial estuvo excelente y algunas cosas que no sabia las aprendi o las termine de entender.
    Java es uno de varios lenguajes de programacion pero la base es la logica.

    felicidades

  11. Si hubiese encontrado esto cuando empecé a estudiar programación en Java me hubiese ahorrado mucho tiempo… Excelente artículo! Principalmente por su sencillez.

  12. Excelente pagina! en mi inicio en Java tuve que realizar una operación mediante hilos y tuve que aprender java desde cero en 1 semana. Gracias a ustedes lo logre, ahora estoy por arrancar a programar en una empresa y su pagina la voy a recomendar por la calidad de información que comparten, no solo por su legibilidad, si no que sabes explicar, los felicito! Saludos desde Argentina 😀

  13. hola a todos y en especial a los creadores de el presente tutorial, mi pregunta es la siguiente

    como trabajo debo realizar con clases el control del mundial,. me explico:

    se debe permitir ver los grupos y cada equipo por grupo
    se debe permitir ingresar las fechas de los partidos y quien gano
    cada equipo sumara puntos y pasara a la siguiente ronda hasta llegar a octavos, cuartos, semifinal y final.

    la verdad estoy un poco perdido y no se como lograr hacerlo sin tener que convertir el programa en bastantes lineas de código ya que un compañero lo lleva casi terminado pero tiene mas de 1500 lineas de código me trato de explicar pero me dejo mas perdido

    si tiene un tutorial ya listo o si me pueden orientar gracias por su colaboración

  14. Es curioso, pero al igual que Chus, yo también estoy haciendo Desarrollo de aplicaciones multiplataforma) y estoy aquí por casualidad, porque buscaba unos apuntes fáciles para repasar, pero es increíble lo bien hecho que está este manual porque está mejor explicado que en clase, y viene explicado temario complejo (lo que le llamo yo a objetos, estructura y visibilidad) y quería felicitaros cuanto menos por esta explicación “milagrosa”. Porque habeis explicado lo mismo que en mi clase de programación de 6 meses en 10 entretenidos minutos de lectura.

    1. Hemos pasado por eso, de ahí que queramos cambiar un poco la forma de ver la programación: más acción y pasión 🙂

      Te animo a continuar con la multi-plataforma pues es algo con mucho futuro. Si tienes curiosidad tenemos tutoriales de Android, de iOs y de Web.

  15. Espectacular la pagina web, estoy estudiando grado superior de informática de aplicaciones multiplataforma y descubrí la pagina ayer buscando una duda que tenia y la verdad es que me encanta la pagina y me esta sirviendo de mucho, muchas gracias y directa a favoritos.

  16. Excelente explicación, al fin entiendo como llamar a un metodo de un objeto, su explicación es muy buena, les felicito

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies

ACEPTAR
Aviso de cookies