Curso 0: Fundamentos de Informática

Ejercicio Coche
En este ejercicio vamos a modelar de una manera sencilla algunos aspectos básicos del
comportamiento de un automóvil. Vamos a suponer que tenemos un único tipo de
automóvil/coche, con un consumo medio de gasolina de 6,1 l/100km (es decir, que gasta esa
cantidad de gasolina para recorrer 100 km) y un peso de 500kg sin carga de combustible.
Todos los coches de este tipo tienen un número de chasis que hace que cada vehículo sea
diferente, así como un kilometraje dependiendo de la distancia que haya recorrido a lo largo de
su vida, y una carga de combustible que se refiere a la cantidad de litros de gasolina de la que
dispone en su depósito en un momento dado.
Queremos ser capaces de calcular la autonomía que tendrán los coches de este tipo cuando
cuenten con una cantidad de combustible en su depósito; es decir, queremos saber los
kilómetros que podrá recorrer con una cantidad de combustible dada. Además, queremos
calcular el peso que tendrá el coche cuando se le aumente dicha carga de combustible
(asumiremos que el peso de la gasolina es de 850gr/l; es decir, que cada litro de gasolina que
pongamos en el vehículo hará que éste pese 850 gramos más), así como el peso del coche una
vez haya recorrido una determinada distancia en kilómetros; es decir, una vez haya consumido
los litros de gasolina necesarios para recorrer esa distancia, y que vendrá dado por su consumo
medio. Una última funcionalidad que queremos contemplar es la de ir contabilizando el
kilometraje según vaya recorriendo distancias.
Para abordar este problema utilizaremos la Programación Orientada a Objetos que, como ya
hemos visto a lo largo de este curso, ofrece una serie de mecanismos y conceptos que
permiten modelar y trasladar un problema que queremos resolver a un programa informático
capaz de ser ejecutado en un ordenador. Este paradigma de programación nos ofrece dos
herramientas básicas: la clase y el objeto.
En este problema concreto utilizaremos el concepto de clase para modelar el tipo de coche que
vamos a considerar. Las clases en Programación Orientada a Objetos nos permiten describir de
una manera abstracta los objetos de un mismo tipo. Como en el enunciado se indica que
tenemos un único tipo de coche (que pesa 500Kg en vacío y tiene un consumo medio de 6,1
l/100km), utilizaremos el concepto de clase para modelarlo, y entonces cada coche concreto
(identificado con un número de chasis diferente) será un objeto diferente de esta clase, con sus
propias características (por ej. Kilometraje, carga de combustible, etc.)
Para llegar a esta decisión de modelado tenemos que pensar en responder a la siguientes
preguntas: ¿Cuánto kilometraje tiene un coche? ¿Cuántos litros tiene en su depósito un coche?
Al tratar de responder nos damos cuenta que cada coche puede ser distinto y que habría que
responder con un “depende del coche concreto”; es decir, no para todos los coches de ese tipo
podríamos contestar lo mismo, porque no todos los coches habrán recorrido la misma cantidad
de kilómetros o tendrán exactamente los mismos litros en sus depósito en el momento en el
que queremos responder la pregunta. Estas son unas pistas que nos permiten pensar en utilizar
Curso 0: Fundamentos de Informática

el concepto de clase para modelar los coches y en el concepto de objeto para modelar cada
coche en concreto.

Figura 1. El proyecto Coche en BlueJ Figura 2. Métodos de la clase Coche

Creación de objetos
Una vez hemos decidido cómo trasladar el problema que queremos tratar a un programa
informático por medio de la Programación Orientada a Objetos, vamos a ver un ejemplo
concreto y a realizar pequeños ejercicios sobre él.
Para ello, iniciamos BlueJ y abrimos el proyecto Coche que habremos descargado previamente
del material del curso. Con este ejercicio resuelto vamos a ejecutar un programa mediante el
entorno BLUEJ que ya está implementado. Este entorno nos permite manejar de forma
interactiva y grafica un programa en Java.
Una vez abierto, nos encontraremos una ventana similar a la mostrada en la Figura 1. Como
podemos observar, aparece una única clase Coche. Como ya se ha comentado, en nuestro
problema tendremos el concepto de automóvil/coche, modelado como una clase, y los distintos
coches (cada uno de ellos con un número de chasis diferente) serán modelados como
instancias (objetos) de esa clase.
Por tanto, en este punto vamos a crear nuestro primer objeto de la clase Coche. Para ello,
situamos el ratón encima de la clase y pulsando el botón derecho vemos que nos aparecerán
las operaciones disponibles que podemos hacer con la clase (ver Figura 2). Estas operaciones
en el contexto de la Programación Orienta a Objetos se conocen como métodos de clase.
Entre otras opciones, nos aparecerá la operación new Coche(int numChasis), que nos permitirá
crear un objeto de la clase Coche. En la programación orientada objetos, a esta operación se le
denomina instanciar un objeto de una clase y al método usado se le conoce como constructor
(que deberá tener el mismo nombre que la clase). El otro método de clase disponible es el
método main(), un método especial que supone el punto en el que comienza la ejecución de
una aplicación Java, pero que ahora no nos centraremos en él.

2
Curso 0: Fundamentos de Informática

Figura 3. Creación de un Figura 4: Un objeto coche1 (de la

objeto en BlueJ clase Coche) en el banco de objetos

Como podemos observar en la Figura 3, al hacer click sobre el método Coche (int numChasis)
se nos pide un nombre para la instancia (objeto), que llamamos “coche1”, así como un número
de chasis donde pondremos, por ejemplo, el número entero 123456789. Este último valor
numChasis es un parámetro de entrada al método constructor y está definido como un tipo de
dato int (número entero)1. Una vez introducido un entero como número de chasis y pulsado el
botón de aceptar se creará dicho objeto, y aparecerá a continuación en el banco de objetos de
BlueJ (Figura 4).

Ejercicio 1. Cree ahora otros dos nuevos objetos de la clase Coche en BlueJ. Llámeles
“coche2” y “coche3” e introduzca dos números enteros como valores del parámetro que
representa el número de chasis de cada uno de ellos.

Invocación de métodos
Una vez tenemos objetos en nuestro banco de objetos, podemos invocar los métodos
disponibles, aquellos que se hayan definido en la clase a la que pertenecen los objetos; es
decir, en la clase se definen las operaciones que se pueden realizar sobre todos los objetos de
dicha clase (cuando las utilicemos se dirá que estamos invocándolas). Por tanto, el objetivo de
este apartado es observar qué métodos u operaciones están definidos en la clase Coche e
invocar alguno de ellos.
Para esto, haremos click con el botón derecho del ratón sobre el objeto del que queremos
invocar el método (por ejemplo, el objeto coche1) y nos aparecerán las operaciones
disponibles. Hay que tener en cuenta que hay que hacer click sobre el objeto y no sobre la
clase, es decir, sobre los elementos que aparecen en el banco de objetos de BlueJ (ver la
Figura 5).

1
Un tipo de datos es la propiedad de un valor que determina su dominio (qué valores puede tomar), qué
operaciones se le pueden aplicar y cómo es representado internamente por el computador. Dicho de otro modo, el
tipo de una variable nos indica el conjunto de valores que puede tomar y las operaciones que pueden realizarse
con ella.

3
Curso 0: Fundamentos de Informática

Figura 5. Operaciones disponibles sobre un objeto de la clase Coche

Como podemos observar, la clase Coche tiene definidos diferentes métodos cuyo nombre nos
da una pista sobre lo que hará el método cuando sea invocado.
Si invocamos, por ejemplo, el método double getAutonomia() haciendo doble click sobre él,
veremos cómo aparecerá una ventana en la que se muestra el resultado devuelto por el
método (ver Figura 6), y que se corresponde con la autonomía que tiene el coche representado
por el objeto seleccionado. Como hasta este momento lo único que hemos hecho es crear un
objeto coche, pero no le hemos introducido carga de gasolina, el resultado de este método es
una autonomía de 0.0 kilómetros. La palabra double indica que el método nos dará la
autonomía como un tipo de dato double (un tipo de dato en coma flotante, es decir, un tipo de
datos con el cual se pueden representar números reales).

Figura 6: Ejecución del método getAutonomia() de un objeto coche

4
Curso 0: Fundamentos de Informática

Si volvemos a desplegar el menú secundario para ver las operaciones disponibles del mismo
objeto, y ahora invocamos, por ejemplo, el método getCargaCombustible(), podemos
comprobar que efectivamente la carga actual del depósito es cero.

Ejercicio 1. Ejecute ahora el método getNumChasis() en los tres los objetos que tengamos
creados. ¿Qué sucede?

Invocación de métodos con parámetros

Como ya vimos al llamar al constructor e instanciar los objetos de tipo coche, los métodos
pueden tener parámetros de entrada que permiten proporcionar información adicional para
ejecutar la tarea que realiza ese método.
Si volvemos a desplegar el menú secundario de un objeto coche para visualizar los métodos
disponibles para los objetos de esta clase (mostrados en la Figura 5) encontramos los
siguientes métodos:

• double getAutonomia() nos dirá cuántos Kms de autonomía tiene el coche con los
litros de gasolina de que disponga en ese momento. Como hemos visto, el valor
devuelto por este método será de tipo double.
• double getCargaCombustible() nos dirá los litros de gasolina de que disponga en ese
momento. De nuevo, este método devolverá la carga como un tipo de dato double.
• double getKilometraje() nos devuelve los kilómetros recorridos por el coche hasta
ese momento como un valor double.
• int getNumChasis() nos devuelve el número de chasis del vehículo. En este caso el
tipo de dato es int, por lo que el método devolverá el número entero que se hubiera
introducido en el constructor al instanciar el objeto.
• double getPeso() nos dirá lo que pesa el vehículo por medio de un valor double. Este
valor dependerá de la cantidad de gasolina de la que disponga en ese momento y de su
peso en vacío (sin carga de gasolina) que, en nuestro caso, es de 500 kg.
• double recorre(double km). Con este método indicamos los kilómetros que ha
recorrido un coche por medio de un valor de tipo double; es decir, el método simulará
que el coche recorre los kilómetros que se introduzcan por parámetro. Este método
tendrá que calcular y modificar el resto de los atributos, ya que al recorrer una cierta
distancia se consume una cantidad de combustible, lo que hará que la autonomía y el
peso del coche se reduzcan.
• void setCargaCombustible(double litros) nos permite introducir la carga de
gasolina en litros que indiquemos. Este método tendrá que calcular y modificar también
otros atributos, ya que al cargarse una cierta cantidad de combustible se incrementará
autonomía y el peso del coche. El parámetro de entrada a este método tiene que ser de
tipo double y la palabra void indica que el método no devuelve ningún valor.

5
Curso 0: Fundamentos de Informática

• void setCargaCombustible(double euros, double precioLitros) nos permite

introducir la carga de gasolina indicando el precio por litro (como un valor double) y la
cantidad de euros que queramos repostar (como un valor de tipo double también). Este
método, al igual que el anterior, no devuelve ningún valor pero sí modifica los valores de
los atributos autonomía y peso.

Por tanto, si ahora invocamos, por ejemplo, el método setCargaCombustible(double litros)

estaremos cargando los litros que indiquemos en el coche representado por el objeto que
hayamos seleccionado. Como se puede observar en la Figura 7, al invocar el método aparecerá
un cuadro de diálogo pidiéndonos introducir un dato: el parámetro del método. En este caso, el
dato que nos piden es de tipo double, es decir, este método requiere un parámetro que es un
número decimal para realizar la operación de carga de gasolina. Así pues, introduciremos por
ejemplo el número 20 para indicar que queremos cargar 20.0 litros de gasolina y ejecutaremos
el método pulsando “Aceptar”. Como podemos observar en la Figura 8, si ahora invocamos el
método getAutonomia(), el coche ya no tendrá la autonomía 0.0 kms. que tenía antes, sino una
autonomía de 327,86887 kms. correspondiente a los kilómetros que puede recorrer con esa
carga de combustible.

Figura 7: Diálogo para introducir el valor de un parámetro en un método

6
Curso 0: Fundamentos de Informática

Figura 8: Valor de retorno (de tipo double) de la llamada al método

getAutonomia() del objeto1.

Ejercicio 2. Pruebe a ejecutar ahora el método setCargaCombustible(double euros, double

precioLitros) sobre otro objeto diferente al anterior (por ejemplo, el objeto3) e introduzca como
parámetros 30 euros y 1.2 euros/l. A continuación invoque el método getPeso(). ¿Qué se
obtiene?
Ejercicio 3. Ahora ejecute sobre ese mismo objeto3 el método recorre(double km) sobre el
mismo objeto del ejercicio 2 e introduzca como parámetro el valor 400. A continuación invoque
de nuevo el método getPeso(). ¿Qué se obtiene?
Ejercicio 4. Pruebe a invocar el método getKilometraje() sobre ese mismo objeto. ¿Qué valor
obtiene? ¿Por qué?
Ejercicio 5. Por último, invoque el método getPeso(). ¿Qué valor tiene ahora? ¿Qué ha
cambiado?

Estado de un objeto
Como ya hemos explicado previamente en este curso, el conjunto de valores que tienen los
atributos de un objeto definen lo que llamamos su estado. Es decir, en nuestro ejemplo el
estado es el número de chasis, la autonomía, la carga de combustible actual, el kilometraje, el
peso y el consumo de un determinado objeto en un momento dado.
En BlueJ podemos visualizar el estado de un objeto mediante la función inspeccionar en el
menú secundario que nos aparece al hacer click con el botón derecho sobre un objeto en el
banco de objetos. También se accede por medio de doble click sobre el icono del objeto. Si
elegimos el objeto3 y visualizamos ahora su estado obtendremos una ventana con los valores
de sus atributos (ver Figura 9).

7
Curso 0: Fundamentos de Informática

Figura 9: Ventana para visualizar el estado de un objeto en BlueJ

Como hemos comprobado, al invocar algunos métodos se modifica el valor de algunos

atributos. En nuestro ejemplo, si invocamos el método setCargaCombustible(double litros)
modificaremos el valor de los atributos autonomía y peso del coche. Lo mismo sucede al
invocar setCargaCombustible(double euros, double precioLitros) o setCargaCombustible(double
litros).

Ejercicio 6. Utilice uno de los objetos coche creados e inspeccione su estado para observar el
valor de sus atributos. A continuación, ejecute el método para añadir 10 litros de gasolina.
Vuelva a visualizar el estado del objeto. ¿Qué ha sucedido? ¿Ha cambiado algo?
Ejercicio 7. Realice los mismos pasos pero ahora haga que el coche recorra 10 km.

Valores de retorno de un método

Al visualizar los métodos disponibles en cualquiera de nuestros objetos de tipo coche, podemos
observar que éstos, o bien comienzan con la palabra void, o bien comienzan con otra palabra
reservada como double. Por ejemplo, podemos encontrar el método recorre(double km) que
empieza con void o el método getAutonomia() que empieza con la palabra double. Esto
significa que podemos tener dos tipos de métodos, los que realizan alguna operación pero no
devuelven ningún resultado (esto se indica mediante la palabra void) y los que devuelven algún
resultado (que se indica escribiendo el tipo del valor resultado devuelto).
Siguiendo con nuestro ejemplo, el método getAutonomia() devuelve un resultado y es de tipo
double (coma flotante). Sin embargo, el método recorre(double km) no devuelve nada, aunque
modifique el estado del objeto, aumentando su kilometraje, reduciendo su peso o reduciendo la
autonomía una vez recorrida la distancia que indiquemos.
Los métodos que devuelven algún resultado nos permiten obtener información de un objeto
mediante la invocación de dicho método. Por ejemplo, si queremos conocer el número de

8
Curso 0: Fundamentos de Informática

chasis que hemos asignado a un coche, podemos invocar su método getNunChasis() o si

queremos conocer el peso del coche en ese momento podemos invocar el método getPeso().

Ejercicio 8. Cree un nuevo objeto coche e invoque el método correspondiente para conocer su
peso. A continuación, ejecute el método setCargaCombustible(double litros) e introduzca una
cantidad de litros de gasolina. ¿Qué sucede?. Ejecute ahora el método recorre(double km) y
haga que el coche avance 25 kms. ¿Qué sucede?.

Código Java
Todo lo realizado hasta este punto lo hemos hecho por medio de la interfaz gráfica que nos
ofrece el programa BlueJ. Por tanto, en este punto es importante tener en cuenta que BlueJ es
un editor de código Java que nos ofrece una abstracción gráfica y que nos permite visualizar
mediante clicks de ratón el modelo que hemos creado (las clases, objetos, métodos y
atributos); un modelo que, como hemos visto, trata de representar el problema que queremos
resolver.
Sin embargo, cuando se programa en Java lo que realizamos en realidad es lo siguiente:
traducimos el modelo que hemos diseñado del problema objetivo que queremos resolver a
instrucciones en un lenguaje de programación, en nuestro caso en lenguaje Java. Es decir,
traducimos el modelo diseñado basado en clases, objetos, etc.. a código Java, y no se realiza
de manera interactiva con clicks del ratón. La interacción por medio de clicks es algo que
permite realizar BlueJ para facilitar el aprendizaje, pero en realidad esa traducción hay que
hacerla por medio de comandos o instrucciones Java de manera textual, similar a como se
escribe cualquier documento de texto, lo que pasa es que ahora será siguiendo la sintaxis y
semántica del lenguaje de programación. Es muy importante tener este aspecto muy claro.
En BlueJ podemos ver el aspecto que tienen los comandos de cada invocación a método que
realizamos gráficamente, es decir, cómo se escribe en código Java las operaciones que
realizamos al invocar o ejecutar un método de un objeto, o crear un objeto de una clase, etc.
Para ello debemos seleccionar la opción Mostrar Terminal del menú Ver de BlueJ. En ese
momento nos aparecerá otra ventana (terminal) que es donde BlueJ muestra las salidas de
texto que se produzcan en la ejecución de un programa. Esta ventana ya nos había aparecido
cuando habíamos invocado el método recorre(double km) y obteníamos una salida por pantalla
indicando el kilometraje del coche una vez recorrida la distancia indicada. A continuación, en el
menú Opciones del terminal, seleccione la opción Registro de llamadas a método. Esto nos
permitirá que todas las llamadas a métodos que realicemos sobre objetos se mostrarán
textualmente en el terminal, pudiendo ver qué aspecto tiene un comando en Java para, por
ejemplo, crear un objeto de una clase o invocar un método sobre un objeto para que recorra
una cantidad de kilómetros.

Ejercicio 9. Cree ahora un nuevo objeto de la clase Coche como hasta ahora, invoque su
método setCargaCombustible(double euros, double precioLitros) e introduzca como valores 50

9
Curso 0: Fundamentos de Informática

euros y 1.1 euros/litro. Invoque ahora el método recorre(double km) e introduzca 499 kms.
¿Qué se muestra en la ventana del terminal?

Figura 10: Salida en el terminal de BlueJ de la invocación de métodos del Ejercicio 9.

Como podemos observar en la Figura 10, la secuencia de crear un objeto de la clase Coche, e
invocar alguno de sus métodos, se traduce en código Java a los siguientes comandos textuales,
además de un mensaje por texto indicando el kilometraje del coche:

Coche coche5 = new Coche(1111222333);

[Link](50, 1.1);
[Link](499);

Viendo este código podemos observar los siguiente:

• Todas las instrucciones en Java terminan con un punto y coma.
• Al crear un objeto de una clase con el constructor (en nuestro caso, el método Coche(int
numChasis)), éste se almacena mediante el símbolo “=” en lo que se conoce como
variable. Las variables son un espacio de memoria en el que guardamos un determinado
valor (o dato); en este caso un objeto. En esta expresión se indica con la parte derecha
que se crea un nuevo objeto con un número de chasis 1111222333 y en la parte
izquierda se indica que se almacenará en una variable coche5 de la clase Coche.
• Para invocar métodos de un objeto, lo que se hace es escribir el identificador del objeto
(en nuestro caso coche5) seguido de un punto y el nombre del método que se quiere
invocar, seguido de unos paréntesis con el valor de los parámetros que hay que pasar al
método, si es que ese método requiere parámetros, como es el caso de los dos métodos
que hemos invocado.

BlueJ también nos permite ejecutar instrucciones de manera textual, en lugar de gráficamente.
Para ello, debemos elegir la opción Mostrar Bloc de Código del menú Ver de BlueJ. Entonces
nos aparecerá un nuevo panel junto al banco de objetos en la propia ventana de BlueJ (ver
Figura 11). En este panel podemos escribir código textual Java, es decir, instrucciones textuales
que se ejecutarán teniendo en cuenta nuestro modelo. Debemos escribir la instrucción que

10
Curso 0: Fundamentos de Informática

queramos ejecutar, teniendo en cuenta los aspectos enumerados anteriormente, y presionar la

tecla ENTER. En ese momento se ejecutará la instrucción introducida siempre que sea correcta.

Figura 11: Panel Bloc de Código en BlueJ y salida correspondiente por la ventana de terminal

Ejercicio 10. A continuación, ejecute la misma secuencia de código que en el ejercicio

anterior, pero mediante el panel de código escribiendo las instrucciones textuales. El código
Java que debe escribir es exactamente el mismo que el visualizado en el terminal
anteriormente. Es decir, crear un coche, cargar 50 euros de gasolina a 1.1 euros/l y hacerle
que recorra 499 kms.
Ejercicio 11. Ahora escriba en el panel de código las instrucciones necesarias para crear otro
nuevo objeto con nombre miCoche, con número de chasis 77777777, cárguele 45 litros de
gasolina y haga que recorra 150 kms.

Código fuente de una clase

Programar significa trasladar un modelo del problema que queremos resolver a un conjunto de
instrucciones interpretables por un ordenador, utilizando para ello un lenguaje de
programación, que seguirá un paradigma concreto y nos ofrecerá un conjunto de abstracciones
y herramientas para ello. Java, el lenguaje de programación que estamos usando, sigue el
paradigma de la Programación Orientada a Objetos; por tanto, ofrece como herramientas las
abstracciones de clases, objetos, métodos y atributos. De este modo, programar significa
escribir el conjunto de instrucciones que nos permitan definir una clase, con sus métodos y
atributos, así como definir las instrucciones necesarias para resolver el problema que queremos
resolver en términos de objetos e interacciones entre ellos.
Por tanto, el código fuente de una clase será el conjunto de instrucciones que definan la
estructura de esa clase (los atributos o campos, junto a sus valores) y su comportamiento (los
métodos y qué sucederá cuando se invoquen cada uno de ellos) que tendrán cada objeto que
se cree de dicha clase.

11
Curso 0: Fundamentos de Informática

En BlueJ podemos visualizar el código fuente de una clase. Para ello, podemos hacer doble click
sobre el icono que representa la clase en el interfaz de BlueJ, o bien con el menú secundario
que aparece haciendo click con el botón derecho del ratón en una clase y eligiendo la opción
Abrir editor. En ese momento se abrirá una nueva ventana donde se muestra el código fuente.

Ejercicio 12. Visualice el código fuente de la clase Coche. ¿Qué le aparece? ¿Le aparece una
ventana como la mostrada en la Figura 12?
Ejercicio 13. Con los conocimientos adquiridos hasta ahora, trate de identificar en el código
fuente qué instrucciones definen los atributos o campos de una clase y cuáles los métodos de
la clase.

NOTA: lo que se encuentra detrás de los símbolos “//” son comentarios. Los comentarios en
Java, o en cualquier otro lenguaje de programación, son una gran herramienta para
documentar nuestro código y hacer nuestros programas más entendibles por otros. Es una
parte del código que no se interpreta por parte del compilador o intérprete, según el lenguaje
de programación que se esté considerando.

12
Curso 0: Fundamentos de Informática

Figura 12: Editor de BlueJ con el código fuente de la clase Coche

13
Curso 0: Fundamentos de Informática

Si sobre este código fuente de la clase Coche se introduce cualquier modificación habrá que
compilar nuevamente la clase. En nuestro ejemplo, si realiza alguna modificación sobre la clase
Coche (por ejemplo, modifique el valor del peso del automóvil) y cierra el editor, observará
como la clase Coche en el interfaz de BlueJ aparece ahora con unas bandas. Esto lo que indica
es que dicha clase ha sido modificada y es necesario volver a compilarla. Para ello, puede
pinchar sobre la propia opción disponible en la ventana de BlueJ o con el botón derecho en la
propia clase elegir la opción Compilar. Una vez compilada, si todo es correcto, pueden volver a
crearse objetos, invocar métodos, etc.

Estructura del código fuente de una clase

Si observamos el código fuente de la clase seremos capaces de identificar los conceptos que
hemos aprendido hasta ahora. Podemos ver cómo se define una clase en Java, o cómo se
definen sus atributos y métodos. A continuación, vamos a ver a grandes rasgos los detalles
principales de estas definiciones.
El código de una clase Java puede dividirse en dos partes principales: un envoltorio exterior,
donde aparece el nombre de la clase y una parte interna, delimitada por unas llaves de
apertura y cierre, donde está definida toda la estructura de la clase:

public class Coche {

Lo que hemos llamado envoltorio exterior de la clase contiene básicamente la definición de la

misma, proporcionando el nombre de la clase (o identificador). En Java por convenio los
nombres de la clase siempre se definen como palabras que empiezan por una letra mayúscula;
de este modo podemos diferenciar una clase de un objeto, que suelen definirse con palabras
empezando en minúscula) o una variable o atributo (lo mismo que los identificadores de
objetos).
Pero el nombre de la clase (Coche) no está solo en ese envoltorio exterior, también aparecen
las palabras public y class. Estas tipo de palabras son lo que se conoce como palabras
reservadas del lenguaje. Forman parte del vocabulario propio del lenguaje y tienen su propio
significado. En este caso significan que lo que vamos a definir es una clase y que será pública.
En este curso cero no profundizaremos más en el significado de que una clase sea pública, ya
que será ampliamente tratado en la asignatura de Fundamentos de la Informática.
Por otro lado, en lo que hemos llamado parte interna de la definición de la clase es donde
definimos los atributos y los métodos que tendrán todos los objetos de la clase que estamos
definiendo. Por convección también, normalmente se definen primero los atributos de la clase,
a continuación, el método especial denominado constructor, que es el encargado de crear los
objetos de la clase y, por último, los métodos de la clase:

14
Curso 0: Fundamentos de Informática

public class Coche {

//ATRIBUTOS
[...]

//CONSTRUCTORES
[...]

//MÉTODOS
[...]
}

Ahora ya sí podemos analizar el código fuente de nuestra clase Coche, y podremos identificar la
definición de los atributos de la clase, que serán los siguientes:

private int numChasis;

private double autonomia;
private double cargaCombustible;
private double kilometraje;
private double peso;
static double consumo = 6.1;

NÓTESE que por claridad se han eliminado los comentarios del código fuente.

Como podemos observar, toda definición de atributo termina con un punto y coma, al igual que
las sentencias Java que habíamos visto anteriormente, empieza con la palabra private o static,
y está seguida del tipo del atributo y del nombre o identificador que elijamos. Las palabras
private, static y los tipos también son palabras reservadas de Java, mientras que el nombre de
los atributos lo elegimos nosotros. Por convención siempre empiezan en minúscula y por una
letra.
En este punto es importante indicar que el atributo consumo se ha definido como static, a
diferencia del resto que son private, porque es un atributo de clase, es decir, que tiene el
mismo valor en todos los objetos de una clase. Igual que el resto de atributos de esta clase
pueden tomar diferentes valores dependiendo del objeto, si un atributo es static su valor no
puede variar en objetos de una misma clase. Como vimos al plantear el problema, lo que define
el tipo de coche que estamos modelando es su consumo medio y su peso en vacío. Por tanto,
todas las instancias de esta clase tendrán el mismo valor de consumo medio. En el caso del
peso en vacío por simplicidad se ha definido como private y su valor se ha establecido en la
inicialización realizada en el constructor. En este curso cero no profundizaremos más en ello, ya
que será tratado ampliamente en la asignatura de Fundamentos de la Informática.
Si nos vamos desplazando hacia abajo en el código identificaremos la definición de los métodos
de la clase, donde primero encontraremos la definición del constructor:

15
Curso 0: Fundamentos de Informática

public Coche(int numeroChasis) {

[Link] = numeroChasis;
[Link] = 0;
[Link] = 0;
[Link] = 0;
[Link] = 500;
}

En este caso vemos que el método es público y que, como ya hemos comentado, el nombre del
constructor coincide con el de la clase. En su código interno podemos observar que al crearse
un nuevo objeto de la clase coche lo que se hace es asignar como número de chasis el número
que se le pasa al constructor por defecto y se inicializan la autonomía, la carga de combustible
y el kilometraje a cero. Además se inicializa a 500 el peso en Kgs. Del coche en vacío.
Más adelante encontramos primero los métodos get() para el acceso al valor de los atributos:

public float getAutonomia() {

return [Link];
}

public float getCargaCombustible() {

return [Link];
}

public int getNumChasis() {

return [Link];
}

public float getPeso() {

return [Link];
}

public float getKilometraje() {

return [Link];
}

Si analizamos estas definiciones nos daremos cuenta que se parecen a la propia definición de la
clase. Tienen también una cabecera donde se define si el método devuelve algo o no (en este
caso double o int), seguido del nombre del método y entre llaves si requiere parámetros de
entrada o no, y cuáles. A continuación, encontraremos una parte interna entre llaves, donde se
define el comportamiento del método, es decir, qué instrucciones se van a llevar a cabo cuando
se invoque o ejecute ese método en un objeto. Ahí aparecerán el conjunto de instrucciones que
se ejecutarán al invocar el método. Por último, encontramos la palabra reservada return que
indica la variable a devolver (y que se pone justo a continuación del return).
A continuación encontramos los métodos set() de modificación de atributos:

public void setKilometrajeACero(){

[Link] = 0;
}

16
Curso 0: Fundamentos de Informática

En este primer caso no se devuelve ningún valor y simplemente se modifica el atributo de clase
kilometraje y se establece a cero. La palabra reservada this sirve para indicar que se trata de
un atributo de la clase. Se verá en detalle en la asignatura de Fundamentos de Informática.
Si nos fijamos en los dos siguiente métodos set:

public void setCargaCombustible(float litros) {

[Link] += (litros/[Link])*100;
[Link] += litros;
[Link] += 0.85f * [Link];
}

public void setCargaCombustible(int euros,float precioLitro) {

float litros = euros/precioLitro;
[Link] += (litros/[Link])*100;
[Link] += litros;
[Link] += (0.85f * [Link]);
}

En este caso se trata, de nuevo, de métodos que no devuelven ningún valor porque han sido
definidos con la palabra reservada void antes del nombre del método y los parámetros de
entrada. Vemos también que el interior de los métodos se llevan a cabo una serie de
operaciones que están relacionadas con el cálculo y modificación de parámetros de la clase.
Recordemos que cuando se carga combustible aumenta la autonomía del coche y su peso.
Por último, podemos ver el método recorre(float km), que tampoco devuelve ningún valor, pero
en el que podemos observar la lógica por la cual se establece que en caso de que no haya
suficiente gasolina como para recorrer la cantidad de kilómetros introducida como parámetro
del método, solo recorrerá los que le permita la gasolina de la que dispone. Además, actualiza
el kilometraje, la autonomía, la carga de gasolina y el peso del coche.

A continuación realice los siguientes ejercicios que son considerados avanzados:

Ejercicio 15. Edite el código fuente de la clase Coche para añadirle dos nuevos atributos
llamados “marca” y “modelo”, ambos de tipo String (cadena de caracteres).
Ejercicio 16. Ahora cree los métodos get() y set(), de acceso y modificación, para los nuevos
atributos definidos en el ejercicio anterior.
Ejercicio 17. Compile la clase con los cambios efectuados y cree un nuevo coche e invoque los
nuevos métodos creados, asignando una marca y modelo al coche e inspeccione el estado del
objeto para ver si se ha realizado correctamente. A continuación, ejecute el método encargado
de devolver el modelo para comprobar nuevamente si es correcto.

17
Curso 0: Fundamentos de Informática

Ejercicio 18. Cree un nuevo constructor que tenga como parámetro de entrada un
kilometraje.
Ejercicio 19. Una vez creados los nuevos métodos, compile la clase y cree dos nuevos objetos
coche usando los dos constructores posibles, uno con cada uno. Compruebe en cada caso el
estado de los objetos y revise que el kilometraje en cada caso es el correcto.

RESUMEN
A lo largo de este ejercicio resuelto hemos ido explorando el uso del editor BlueJ, así como de
los conceptos básicos de la Programación Orientada a Objetos con Java: clase, objeto,
métodos y atributos.
Hemos aprendido que con las clases podemos modelar el problema que queremos resolver, ya
que nos permiten representar el concepto general de las cosas que queremos modelar en
nuestro programa, mientras que los objetos representan instancias concretas de una clase. De
este modo podemos tener múltiples objetos de una determinada clase, como en nuestro
ejemplo teníamos múltiples coches del único tipo Coche que consideramos (caracterizado por
un determinado peso en vacío y un gasto medio).
Otra cosa que hemos aprendido con este ejemplo guiado es que los objetos disponen de un
estado, que no es otra cosa que el conjunto de atributos y sus valores en un instante de tiempo
dado.
También hemos visto que las clases disponen de métodos que utilizamos para modelar su
comportamiento, y que podemos encontrar dos tipos distintos de métodos: los que modifican el
estado del objeto y los que nos permiten obtener información sobre el propio estado del objeto.
Las modificaciones en el estado del objeto se realizan cuando se ejecutan las instrucciones del
método que se le invoca.
Hemos visto también que cada método puede tener parámetros de entrada y que cada
parámetro se define como de un tipo de dato (String, float, int,…). Además, hemos visto que
los métodos pueden devolver o no un resultado de algún tipo. Entre los tipos de métodos que
hemos estudiado hay que destacar al constructor, que es el que se ejecuta cuando creamos
objetos de la clase e inicializa el estado del objeto. Se ha mostrado también algún ejemplo de
instrucciones, como por ejemplo las necesarias para calcular la autonomía del vehículo.
Otra cosa que hemos aprendido a lo largo de este ejemplo es que los objetos almacenan los
datos en atributos o campos, y que también tienen un tipo. También hemos visto que el valor
de los atributos de un objeto en cada momento representa su estado.
Por último, hemos comprobado que programar en el paradigma de la Programación Orientada
a Objetos consiste en escribir la definición de una o más clases, y que típicamente una clase
Java constará de la definición de sus atributos y métodos.

18