--- title: Mucho Java en un sencillo tutorial (para Dummies) url: https://jarroba.com/mucho-java-en-un-sencillo-tutorial-aqui-los-dummies-se-hacen-de-oro/ author: Ramón Invarato date: 2012-04-11 modified: 2026-10-21 language: es license: CC BY-NC-SA 3.0 (https://creativecommons.org/licenses/by-nc-sa/3.0/) — attribution: "Mucho Java en un sencillo tutorial (para Dummies)", Ramón Invarato, jarroba.com categories: Lenguajes de Programación --- # Mucho Java en un sencillo tutorial (para Dummies) > Aprende Java en Eclipse creando un coche con clases Motor y Arranque: variables y tipos de datos, métodos, constructores, visibilidad, objetos y if-else. 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](https://jarroba.com/espacio-de-trabajo-para-guardar-los-proyectos-que-creemos-en-eclipse/) 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. [![Ilustración de un coche deportivo negro clásico, usado como ejemplo para entender la programación en Java](https://jarroba.com/wp-content/uploads/2012/04/1-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png)](https://jarroba.com/wp-content/uploads/2012/04/1-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png) 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: [Motor de cuatro tiempos (Wikipedia)](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: [![Animación de un motor de cuatro tiempos con el pistón y la biela, numerada por pasos](https://jarroba.com/wp-content/uploads/2012/04/2-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.gif)](https://jarroba.com/wp-content/uploads/2012/04/2-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.gif) 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](https://jarroba.com/instalar-bien-eclipse-un-ide-de-muchos/), 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](https://jarroba.com/wp-content/uploads/2012/04/3-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_1.png)](https://jarroba.com/wp-content/uploads/2012/04/3-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_1.png) Tendremos todo preparado para empezar a trabajar con un nuevo proyecto cuando quede del siguiente modo. [![Captura de Eclipse con el Package Explorer y el proyecto barco_en_una_botella, listo para un nuevo proyecto](https://jarroba.com/wp-content/uploads/2012/04/4-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png)](https://jarroba.com/wp-content/uploads/2012/04/4-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png) Ahora un repaso a lo básico de como crear un proyecto en Eclipse, consulta el [tutorial de crear nuestro primer proyecto en Eclipse](https://jarroba.com/espacio-de-trabajo-para-guardar-los-proyectos-que-creemos-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: [![Esquema del proyecto_coche con los paquetes panel_del_conductor y piezas_internas](https://jarroba.com/wp-content/uploads/2012/04/5-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png)](https://jarroba.com/wp-content/uploads/2012/04/5-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png) Que se traduciría en Eclipse en (lo dicho, si no sabes como se han hecho estos pasos, repasa el [tutorial anterior](https://jarroba.com/espacio-de-trabajo-para-guardar-los-proyectos-que-creemos-en-eclipse/)): [![Captura de Eclipse con proyecto_coche y sus paquetes panel_del_conductor y piezas_internas resaltados](https://jarroba.com/wp-content/uploads/2012/04/6-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png)](https://jarroba.com/wp-content/uploads/2012/04/6-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png) 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: [![Esquema del proyecto_coche con las clases Arranque y Motor dentro de sus paquetes](https://jarroba.com/wp-content/uploads/2012/04/7-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png)](https://jarroba.com/wp-content/uploads/2012/04/7-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png) 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](https://jarroba.com/espacio-de-trabajo-para-guardar-los-proyectos-que-creemos-en-eclipse/)). 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. [![Captura de Eclipse con la clase Motor.java abierta y en ámbar la zona donde escribir el código](https://jarroba.com/wp-content/uploads/2012/04/8-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png)](https://jarroba.com/wp-content/uploads/2012/04/8-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png) 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. | | --- | | 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…” | 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 una 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: [![Esquema de declaración de variable en Java: tipo de dato, nombre de la variable y valor al que apunta](https://jarroba.com/wp-content/uploads/2012/04/9-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png)](https://jarroba.com/wp-content/uploads/2012/04/9-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png) 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: [![Diagrama de la declaración de una variable: tipo int, nombre X, signo igual y valor 5](https://jarroba.com/wp-content/uploads/2012/04/10-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png)](https://jarroba.com/wp-content/uploads/2012/04/10-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png) 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” \| | | --- | | 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): ```java 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 una advertencia –lo verás como Warning en inglés. Te está 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. [![Esquema de un pistón como método: entran oxígeno y gasolina, sale fuerza, con la firma un_piston en Java](https://jarroba.com/wp-content/uploads/2012/04/11-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png)](https://jarroba.com/wp-content/uploads/2012/04/11-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png) 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 \| | | --- | | 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: ```java 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: ```java 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: [![Pseudocódigo del pistón: si la gasolina es menor que 30 genera fuerza, si no el pistón explota](https://jarroba.com/wp-content/uploads/2012/04/12-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png)](https://jarroba.com/wp-content/uploads/2012/04/12-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png) Estamos tratando con una condicional en toda regla. La conversión a Java sería: [![Código Java con if/else que calcula la fuerza del pistón si la gasolina es menor que 30 o muestra un mensaje de explosión](https://jarroba.com/wp-content/uploads/2012/04/13-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png)](https://jarroba.com/wp-content/uploads/2012/04/13-Mucho-Java-en-un-solo-tutorial-www.jarroba.com_.png) 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: ```java 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: ```java 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): ```java 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