Fundamentos de

programación en Java

Jorge Martínez Ladrón de Guevara

Editorial EME

ISBN 978-84-96285-36-2
Contenido
1. Introducción a Java .................................... 1
Los lenguajes de programación ..........................1
Historia de Java ..................................................2
La plataforma de Java ........................................3
Entornos de desarrollo para Java .......................4
El proceso de edición y compilación....................5
La codificación de programas Java .....................6
El proceso de desarrollo de software ..................6
2. Estructura de un programa Java................. 9
La estructura de un programa Java ....................9
Los elementos de un programa Java.................13
Comentarios......................................................................... 14
Identificadores...................................................................... 14
Variables y valores ................................................................ 15
Tipos primitivos .................................................................... 17
Literales .............................................................................. 18
Operadores .......................................................................... 19
Expresiones.......................................................................... 21
Expresiones aritmético-lógicas ................................................ 22
Conversión de tipos ............................................................... 22
Las palabras reservadas de Java ............................................. 23

3. Clases y objetos........................................ 25
Clases ...............................................................26
Los elementos de una clase ..............................27
Atributos.............................................................................. 27
Métodos y constructores ........................................................ 28
Representación de clases y objetos.......................................... 32

Objetos .............................................................33
La referencia null .................................................................. 35
Referencias compartidas por varios objetos............................... 36

i
 El ciclo de vida de un objeto ................................................... 39

Atributos ..........................................................40
Métodos............................................................41
Declaración de métodos ......................................................... 44
Invocación de métodos .......................................................... 45
El método main() .................................................................. 47
Parámetros y argumentos ...................................................... 48
Paso de parámetros............................................................... 50
El valor de retorno ................................................................ 52
Las variables locales de un método .......................................... 52
Sobrecarga de métodos ......................................................... 53

Constructores ...................................................54
4. Extensión de clases .................................. 59
Composición .....................................................59
Herencia ...........................................................64
Extensión de clases ............................................................... 64
Polimorfismo ........................................................................ 70

Compatibilidad de tipos ....................................74

Conversión ascendente de tipos .............................................. 74
Conversión descendente de tipos............................................. 76
Jerarquía de herencia ............................................................ 77

5. Ampliación de clases ................................ 79

Elementos de clase (Static) ..............................79
Derechos de acceso ..........................................80
Paquetes ..........................................................83
Uso ..................................................................................... 83
Nombres.............................................................................. 84

Clases predefinidas...........................................85
Las clases asociadas a los tipos primitivos ................................ 85
La clase Math ....................................................................... 86
La clase String ...................................................................... 87

6. Estructuras de control .............................. 89

Estructuras de selección ...................................90

ii
 Estructura if ......................................................................... 90
Estructura if else ................................................................... 91
Estructura if else if ................................................................ 94
Estructura switch .................................................................. 95
El operador condicional ........................................................ 101

Estructuras de repetición................................102
Estructura while .................................................................. 103
Estructura do-while ............................................................. 107
Estructura for ..................................................................... 109
Uso de las estructuras de repetición....................................... 111

Estructuras de salto........................................115
Sentencia break .................................................................. 115
Sentencia continue .............................................................. 115
Uso de break y continue....................................................... 115

7. Estructuras de almacenamiento ............. 119

Arrays.............................................................119
Arrays multidimensionales .............................127
Uso de arrays .................................................131
Búsqueda binaria en arrays ordenados...........141
Ordenación de arrays .....................................144
El algoritmo de ordenación “Bubble Sort”................................ 145
El método sort de la clase Arrays........................................... 149

Arrays redimensionables ................................153

Uso de arrays redimensionables .....................156
8. Entrada y salida...................................... 165
Los flujos de Java ...........................................165
Entrada de datos desde el teclado ..................167
Leer y escribir en ficheros de texto.................169
Leer y escribir objetos en ficheros ..................173

iii
Anexos
A. Operadores del lenguaje Java ................ 179
Operadores aritméticos ..................................179
Operadores unarios y compuestos..................179
Operadores de relación...................................181
Operadores lógicos .........................................181
Orden de precedencia de los operadores ........182
B. Referencias ............................................ 183
El lenguaje de programación Java ..................183
El API de Java.................................................184
C. Glosario .................................................. 185

iv
1. Introducción a Java

Los lenguajes de programación

Los lenguajes de programación son idiomas artificiales diseñados para
expresar cálculos y procesos que serán llevados a cabo por ordenadores. Un
lenguaje de programación está formado por un conjunto de palabras
reservadas, símbolos y reglas sintácticas y semánticas que definen su
estructura y el significado de sus elementos y expresiones. El proceso de
programación consiste en la escritura, compilación y verificación del código
fuente de un programa.

Antes de diseñar un programa es necesario entender completamente el

problema que queremos resolver y conocer las restricciones de operación de
la aplicación. La programación es una tarea compleja y es muy importante
abordar la solución a un problema específico desde un punto de vista
algorítmico. Un algoritmo es un conjunto ordenado y finito de operaciones
que permite hallar la solución de un problema. Está definido por
instrucciones o reglas bien definidas, ordenadas y finitas que permiten
realizar una actividad. Dado un estado inicial, una entrada y una secuencia
de pasos sucesivos, se llega a un estado final y se obtiene una solución.

Para programar de forma eficaz es necesario aprender a resolver problemas

de una forma sistemática y rigurosa. Solo se puede llegar a realizar un buen
programa si previamente se ha diseñado un algoritmo. Un algoritmo dará
lugar a un programa que puede codificarse en cualquier lenguaje de
programación.

Uno de los objetivos del curso de Fundamentos de Informática es que el

alumno desarrolle habilidades de análisis y diseño de algoritmos simples
que le puedan ser de utilidad en el futuro. Es importante tener nociones
básicas de programación porque esto permitirá entender y diseñar procesos
básicos en lenguajes de uso general como Java y también en aplicaciones
informáticas de uso común en la ingeniería o el diseño. En la actualidad la
mayoría de las aplicaciones que utilizamos a diario ofrecen posibilidades de
programación. Esto facilita el diseño de pequeñas aplicaciones para
automatizar tareas de uso cotidiano.

1
Introducción a Java

Historia de Java
Java es un lenguaje de programación desarrollado por Sun Microsystems.
Java fue presentado en la segunda mitad del año 1995 y desde entonces se
ha convertido en un lenguaje de programación muy popular. Java es un
lenguaje muy valorado porque los programas Java se pueden ejecutar en
diversas plataformas con sistemas operativos como Windows, Mac OS,
Linux o Solaris. James Gosling, el director del equipo de trabajo encargado
de desarrollar Java, hizo realidad la promesa de un lenguaje independiente
de la plataforma. Se buscaba diseñar un lenguaje que permitiera programar
una aplicación una sola vez que luego pudiera ejecutarse en distintas
máquinas y sistemas operativos. Para conseguir la portabilidad de los
programas Java se utiliza un entorno de ejecución para los programas
compilados. Este entorno se denomina Java Runtime Environment (JRE). Es
gratuito y está disponible para los principales sistemas operativos. Esto
asegura que el mismo programa Java pueda ejecutarse en Windows, Mac
OS, Linux o Solaris.

“Write Once, Run Anyware”, que podría traducirse como “programar una
sola vez y después ejecutar los programas en cualquier sistema operativo”,
era el objetivo del equipo de desarrollo de Java. Esta idea resume el
concepto de portabilidad. Los programas Java son portables, es decir,
independientes de la plataforma, porque pueden ejecutarse en cualquier
ordenador o dispositivo móvil, independientemente del sistema operativo
que tengan instalado: Un programa Java puede ejecutarse en un ordenador
de mesa, un ordenador portátil, una tableta, un teléfono, un reproductor de

2
 Fundamentos de programación en Java

música o en cualquier otro dispositivo móvil con cualquier sistema

operativo.

La plataforma de Java
Los programas Java se compilan a un lenguaje intermedio, denominado
Bytecode. Este código es interpretado por la máquina virtual de Java del
entorno de ejecución (JRE) y así se consigue la portabilidad en distintas
plataformas. El JRE es una pieza intermedia entre el código Bytecode y los
distintos sistemas operativos existentes en el mercado. Un programa Java
compilado en Bytecode se puede ejecutar en sistemas operativos como
Windows, Linux, Mac Os, Solaris, BlackBerry OS, iOs o Android utilizando el
entorno de ejecución de Java (JRE) apropiado.

Una de las características más importantes de los lenguajes de

programación modernos es la portabilidad. Como se ha comentado antes,
un programa es portable cuando es independiente de la plataforma y puede
ejecutarse en cualquier sistema operativo y dispositivo físico. Los
programas Java son portables porque se ejecutan en cualquier plataforma.
Sucede algo parecido con las fotografías o los ficheros PDF. Las fotografías
con formato JPEG son portables porque un archivo JPEG lo podemos
visualizar con distintos visores de fotos y en dispositivos como ordenadores,
tabletas o teléfonos. El formato JPEG es un estándar para almacenar
archivos de imagen. Todas las imágenes JPEG tienen el mismo formato y los
visores de fotos están diseñados para mostrar las imágenes con este
formato. De forma similar, los archivos PDF (Portable Document Format)
son portables. El formato PDF fue desarrollado por Adobe Systems con la
idea de que estos archivos se puedan ver en cualquier dispositivo que tenga
instalado Adobe Acrobat Reader, el software de visualización de documentos
PDF.

La portabilidad de Java ha contribuido a que muchas empresas hayan

desarrollado sus sistemas de comercio electrónico y sus sistemas de
información en Internet con Java. El proceso de desarrollo y de
mantenimiento de los sistemas resulta menos costoso y las aplicaciones son
compatibles con distintos sistemas operativos.

La evolución del lenguaje de programación Java ha sido muy rápida. La

plataforma de desarrollo de Java, denominada Java Development Kit (JDK),
se ha ido ampliando y cada vez incorpora a un número mayor de
programadores en todo el mundo. En realidad Java no solo es un lenguaje
de programación. Java es un lenguaje, una plataforma de desarrollo, un
entorno de ejecución y un conjunto de librerías para desarrollo de

3
Introducción a Java

programas sofisticados. Las librerías para desarrollo se denominan Java

Application Programming Interface (Java API).

El siguiente esquema muestra los elementos de la plataforma Java, desde el

código fuente, el compilador, el API de Java, los programas compilados en
Bytecode y el entorno de ejecución de Java. Este entorno de ejecución (JRE)
y la máquina virtual (JVM) permiten que un programa compilado Java se
ejecute en distintos sistemas operativos.

Entornos de desarrollo para Java

Existen distintos entornos de desarrollo de aplicaciones Java. Este tipo de
productos ofrecen al programador un entorno de trabajo integrado para
facilitar el proceso completo de desarrollo de aplicaciones, desde el diseño,
la programación, la documentación y la verificación de los programas. Estos
productos se denominan IDE (Integrated Development Environment).

Existen entornos de distribución libre como: NetBeans, Eclipse o BlueJ.

Entre los productos comerciales están JBuilder o JCreatorPro.

4
 Fundamentos de programación en Java

Para utilizar un entorno de desarrollo es necesario instalar el Java Runtime

Environment (JRE) apropiado para el sistema operativo. El JRE se descarga
de la página de Oracle Java.

El proceso de edición y compilación

En Java, al igual que en otros lenguajes de programación, se sigue el
siguiente proceso: edición del código fuente, compilación y ejecución. Los
programas Java se desarrollan y se compilan para obtener un código
denominado Bytecode que es interpretado por una máquina virtual de Java
(Java Virtual Machine).

La edición del programa fuente se realiza escribiendo el programa Java en

un editor de texto como el Bloc de notas o utilizando un entorno integrado
de desarrollo. El código fuente se almacena en un fichero de tipo .java.

La compilación se realiza con el compilador Java javac o utilizando un

entorno integrado de desarrollo. Durante el proceso de compilación se
verifica que el código fuente cumple la definición léxica, sintáctica y
semántica de Java. Esto significa que el compilador comprueba que el
código fuente se compone de palabras válidas en Java y que los comandos
Java tienen la forma sintáctica correcta. Si durante el proceso de
compilación el compilador detecta los errores que ha cometido el
programador y le informa de los problemas que ha encontrado para que
pueda corregirlos. Si durante la compilación no se detectan errores, se
genera un fichero de tipo class en Bytecode. Una vez finalizado el proceso
de compilación se puede ejecutar el programa. Para esto, es necesario que
la máquina virtual de Java interprete el código Bytecode y ejecute la
aplicación.

5
Introducción a Java

La codificación de programas Java

El estilo de programación o codificación de los programas Java es muy
importante. La legibilidad de un programa determina en buena medida que
se haya desarrollado correctamente y que el producto final sea eficiente.

Legibilidad > Corrección > Eficiencia

Legibilidad. Un programa Java debe ser fácil de leer y entender, incluso

para una persona que no ha participado en el desarrollo del programa. La
legibilidad es un aspecto muy importante porque facilita el mantenimiento
del software, la corrección de errores o la modificación de la funcionalidad
de la aplicación con menor coste.

Corrección. Un programa debe hacer lo que debe hacer, ni más, ni menos.

Esto es lo que se entiende por corrección. Un programa debe cumplir
rigurosamente los requisitos funcionales y técnicos de la fase de
especificación. Durante la fase de prueba se verifica que el programa
funciona correctamente y que cumple los requisitos técnicos y funcionales.

Eficiencia. La eficiencia se refiere al tiempo que un programa tarda en

ejecutarse y a los recursos que consume. Cuanto más rápido sea un
programa y utilice menos memoria o disco duro, el diseño es mejor. La
eficiencia no es un problema que deba atender cuando se aprende a
programar. Ahora lo mejor es utilizar los mecanismos de optimización
propios de los compiladores. La eficiencia se debe analizar solo cuando un
programa funciona correctamente y cumple con los requisitos técnicos
definidos.

El proceso de desarrollo de software

El proceso de desarrollo de los programas Java no difiere de la mayoría de
los lenguajes de programación. Es necesario seguir un conjunto de pasos
para desarrollar correctamente un producto software.

La Ingeniería del Software estudia los distintos procesos de desarrollo de

software. El IEEE define Ingeniería del Software como la aplicación
sistemática, disciplinada y cuantificable de un proceso de desarrollo,
operación y mantenimiento de un producto software.

6
 Fundamentos de programación en Java

El proceso clásico de desarrollo de software es ampliamente utilizado por su

sencillez. Este proceso se compone de las siguientes fases: especificación,
diseño, codificación, prueba y mantenimiento.

Especificación. En esta fase se decide la funcionalidad, las características

técnicas de una aplicación y sus condiciones de uso. En esta fase es
necesario responder a las siguientes preguntas:

 ¿Para qué se va a utilizar la aplicación?

 ¿Cuáles son las necesidades funcionales de los usuarios?

 ¿Cuál es el perfil de los usuarios de la aplicación?

 ¿En qué plataforma se ejecutará la aplicación?

 ¿Cuáles son sus condiciones de operación?

 ¿Cómo se va a utilizar?

Diseño. En esta fase se utiliza toda la información recogida en la fase de

especificación y se propone una solución que responda a las necesidades del
usuario y se pueda desarrollar. En esta fase se define la arquitectura de la
aplicación. Es necesario detallar la estructura y la organización del
programa y cómo se relacionan las distintas partes de la aplicación.

Codificación. Esta fase consiste en la programación en Java de las

especificaciones de diseño de la fase anterior. Durante esta fase de
codificación o implementación se aplican normas de programación para
facilitar la legibilidad de los programas Java.

Prueba. En esta fase se compila y se ejecuta la aplicación para verificar

que cumple con los requisitos funcionales y técnicos definidos en la fase de
especificación. Si el programa no cumple con todos los requisitos, se puede
deber a errores de diseño o de programación. En tal caso, es necesario
corregir los errores que se hayan detectado y repetir de nuevo el proceso de
diseño y codificación. Durante la fase de prueba se verifica que la aplicación
cumple con los criterios de calidad establecidos en el proyecto: facilidad de
uso, corrección, eficiencia, integridad, fiabilidad, flexibilidad, facilidad de
mantenimiento, facilidad de prueba, portabilidad, capacidad de reutilización
e interoperabilidad.

Una vez que la aplicación se ha probado y cumple con los requisitos

establecidos, entonces se pone en funcionamiento y comienza la fase de
operación para que sea utilizada para el fin con el que ha sido desarrollada.

7
Introducción a Java

Mantenimiento. Una vez que la aplicación se ha puesto en operación da

comienzo la fase de mantenimiento. En esta fase se corrigen errores de
funcionamiento de la aplicación, se modifica la funcionalidad o se añaden las
nuevas funcionalidades que demandan los usuarios. La fase de
mantenimiento es la de mayor duración, pues pueden pasar muchos años
desde el inicio de la operación hasta que el producto es retirado.

8
2. Estructura de un programa Java

Un programa describe cómo un ordenador debe interpretar las órdenes del

programador para que ejecute y realice las instrucciones dadas tal como
están escritas. Un programador utiliza los elementos que ofrece un lenguaje
de programación para diseñar programas que resuelvan problemas
concretos o realicen acciones bien definidas.

El siguiente programa Java muestra un mensaje en la consola con el texto

“Hola Mundo”.

/*
* Este programa escribe el texto "Hola Mundo" en la consola
* utilizando el método System.out.println()
*/

public class HolaMundo {

public static void main (String[] args) {

System.out.println("Hola Mundo");
}

La estructura de un programa Java

En este programa se pueden identificar los siguientes elementos del
lenguaje Java: comentarios, definiciones de clase, definiciones de método y
sentencias.

Comentario. El programa comienza con un comentario. El delimitador de

inicio de un comentario es /* y el delimitador de fin de comentario es */. El
texto del primer comentario de este ejemplo sería: ‘Este programa escribe
el texto “Hola Mundo” en la consola utilizando el método
System.out.println()'. Los comentarios son ignorados por el compilador y
solo son útiles para el programador. Los comentarios ayudan a explicar
aspectos relevantes de un programa y lo hacen más legible. En un
comentario se puede escribir todo lo que se desee, el texto puede ser de
una o más líneas.

9
Estructura de un programa Java

Definición de clase. La primera línea del programa, después del primer

comentario. Define una clase que se llama HolaMundo. La definición de la
clase comienza por el carácter { y termina con el carácter }. El nombre de
la clase lo define el programador.

Definición de método. Después de la definición de clase se escribe la

definición del método main(). Todos los programas Java deben incluir un
método main(). Este método indica las sentencias a realizar cuando se
ejecuta un programa. Un método es una secuencia de sentencias
ejecutables. Las sentencias de un método quedan delimitadas por los
caracteres { y } que indican el inicio y el fin del método, respectivamente.

Sentencia. Dentro del método main() se incluye una sentencia para

mostrar un texto por la consola. Los textos siempre se escriben entre
comillas dobles para diferenciarlos de otros elementos del lenguaje. Todas
las sentencias de un programa Java deben terminar con el símbolo punto y
coma. Este símbolo indica al compilador que ha finalizado una sentencia.

Una vez que el programa se ha editado, es necesario compilarlo y ejecutarlo

para comprobar si es correcto. Al finalizar el proceso de compilación, el
compilador indica si hay errores en el código Java, dónde se encuentran y el
tipo de error que ha detectado: léxico, sintáctico o semántico.

/* Este programa calcula el perímetro de una circunferencia */

public class PerimetroCircunferencia {

public static void main (String[] args) {

// declaración de PI y la variables radio y perimetro

final double PI = 3.1415926536;

double radio = 25.0, perimetro;

perimetro = 2.0*PI*radio;
System.out.print("El perimetro de la circunferencia de radio ");
System.out.print(radio);
System.out.print(" es ");
System.out.print(perimetro);

}
}

10
 Fundamentos de programación en Java

En un programa Java las sentencias se ejecutan secuencialmente, una

detrás de otra en el orden en que están escritas.

En este ejemplo se puede ver que dentro del método main() se incluye un
comentario de una sola línea que comienza con //. A continuación se
declaran las variables PI, radio y perimetro, todas ellas de tipo double
porque almacenan números reales. PI representa un valor constante, por lo
que es necesario utilizar el delimitador final y asignarle el valor
3.1415926536 correspondiente al número pi.

Después de las declaraciones, se asigna el valor 25.0 a la variable radio y

se calcula el perímetro. Finalmente, se muestra el resultado del cálculo del
perímetro para una circunferencia de radio 25.

En este ejemplo se utilizan variables numéricas de tipo double. Cada

variable almacena un número real. La parte entera del número se separa de
los decimales con un punto, no con una coma. Esta es una característica de
Java que se debe tener en cuenta, de lo contrario, el compilador no
entiende que se trata de un número real.

El valor 25.0 almacenado en la variable radio es una magnitud para la que

no se indican sus unidades. El programador es responsable de que los
cálculos se realicen correctamente y de realizar la conversión de unidades
cuando sea necesario.

Para escribir un mensaje por la consola se utilizan los métodos

System.out.print() y System.out.println(). Para escribir un
mensaje sin saltar a la línea siguiente se utiliza System.out.print(),
System.out.println() escribe un mensaje y da un salto de línea.

¿Qué hace el siguiente código Java?

System.out.print("Hola");
System.out.print(" ");
System.out.print("Mundo");

En este ejemplo se escribe el texto “Hola Mundo” en la consola.

Hola Mundo

11
Estructura de un programa Java

¿Qué pasaría si se omitiera la segunda línea de código?,

System.out.print("Hola");
System.out.print("Mundo");

En este caso se escribiría “HolaMundo” sin el espacio de separación entre

las dos palabras.

HolaMundo

Si en vez de utilizar el método System.out.print() se utiliza el método

System.out.println(), entonces el mensaje se escribe en dos líneas
distintas.

System.out.println("Hola");
System.out.println("Mundo");

En este ejemplo, se escribiría “Hola” y “Mundo” en dos líneas.

Hola
Mundo

Combinando el uso de los métodos System.out.print() y

System.out.println() se puede escribir cualquier mensaje en la consola
saltando de línea cuando sea necesario. Además, ambos métodos permiten
utilizar el operador + para concatenar textos.

El siguiente código Java escribe “Hola Mundo” en la consola.

System.out.print("Hola");
System.out.print(" ");
System.out.print("Mundo");

12
 Fundamentos de programación en Java

En este caso se ejecutan tres métodos System.out.print(). Este código

se puede simplificar utilizando un solo método System.out.print() y el
operador + para concatenar los textos “Hola”, “ ” y “Mundo”.

System.out.print("Hola" + " " + "Mundo");

También se puede escribir directamente el mensaje “Hola Mundo”. El

resultado es el mismo y el código es más claro.

System.out.print("Hola Mundo");

Para mostrar por la consola un texto seguido del valor almacenado de una
variable se puede ejecutar dos veces el método System.out.print():

System.out.print("El perímetro es ");

System.out.print(perimetro);

Este código se puede simplificar utilizando el operador + para concatenar el

texto “El perímetro es ” con el valor almacenado en la variable perimetro.

System.out.print("El perímetro es " + perimetro);

En ambos casos el resultado es el mismo. Por ejemplo, si el valor

almacenado en la variable perimetro fuera 157.08 la salida por la consola
sería:

El perímetro es 157.08

Los elementos de un programa Java

A continuación se describe la definición léxica y sintáctica de los elementos
de un programa Java: comentarios, identificadores, variables y valores,
tipos primitivos, literales, operadores, expresiones y expresiones aritmético-
lógicas.

13
Estructura de un programa Java

Comentarios

En un programa Java hay tres tipos de comentarios.

Comentario de bloque. Empieza por /* y termina por */. El compilador

ignora todo el texto contenido dentro del comentario.

/*
* El programa HolaMundo se utiliza para aplicar los
* métodos System.out.print() y System.out.println()
*/

Comentario de documentación. Empieza por /** y termina por */. Java

dispone de la herramienta javadoc para documentar automáticamente los
programas. En un comentario de documentación normalmente se indica el
autor y la versión del software.

/**
* Programa HolaMundo
* @author Fundamentos de Informática
* @version 1.0
* @see Referencias
*/

Comentario de línea. Empieza con //. El comentario comienza con estos

caracteres y termina al final de la línea.

// El método System.out.println() salta la línea

El uso de comentarios hace más claro y legible un programa. En los

comentarios se debe decir qué se hace, para qué y cuál es el fin de nuestro
programa. Conviene utilizar comentarios siempre que merezca la pena
hacer una aclaración sobre el programa.

Identificadores

El programador tiene libertad para elegir el nombre de las variables, los

métodos y de otros elementos de un programa. Existen reglas muy estrictas

14
 Fundamentos de programación en Java

sobre los nombres que se utilizan como identificadores de clases, de

variables o de métodos.

Todo identificador debe empezar con una letra que puede estar seguida de
más letras o dígitos. Una letra es cualquier símbolo del alfabeto y el
carácter ‘_’. Un dígito es cualquier carácter entre ‘0’ y ‘9’.

Los identificadores Hola, hola, numero, numeroPar, numeroImpar,

numero_impar, numero_par, nombre, apellido1 y apellido2 son
válidos. El identificador 1numero no es válido porque empieza con un dígito,
no con una letra.

Cualquier identificador que empiece con una letra seguida de más letras o
dígitos es válido siempre que no forme parte de las palabras reservadas del
lenguaje Java. El lenguaje Java distingue entre letras mayúsculas y
minúsculas, esto significa que los identificadores numeroPar y numeropar
son distintos.

Existen unas normas básicas para los identificadores que se deben respetar.

 Los nombres de variables y métodos empiezan con minúsculas. Si se

trata de un nombre compuesto cada palabra debe empezar con
mayúscula y no se debe utilizar el guión bajo para separar las palabras.
Por ejemplo, los identificadores calcularSueldo, setNombre o
getNombre son válidos.

 Los nombres de clases empiezan siempre con mayúsculas. En los

nombres compuestos, cada palabra comienza con mayúscula y no se
debe utilizar el guión bajo para separar las palabras. Por ejemplo,
HolaMundo, PerimetroCircunferencia, Alumno o Profesor son
nombres válidos.

 Los nombres de constantes se escriben en mayúsculas. Para nombres

compuestos se utiliza el guión bajo para separar las palabras. Por
ejemplo, PI, MINIMO, MAXIMO o TOTAL_ELEMENTOS son nombres
válidos.

Variables y valores

Un programa Java utiliza variables para almacenar valores, realizar cálculos,

modificar los valores almacenados, mostrarlos por la consola, almacenarlos
en disco, enviarlos por la red, etc. Una variable almacena un único valor.

15
Estructura de un programa Java

Una variable se define por un nombre, un tipo y el rango de valores que

puede almacenar.

El nombre de una variable permite hacer referencia a ella. Este nombre

debe cumplir las reglas aplicables a los identificadores. El tipo indica el
formato de los valores que puede almacenar la variable: cadenas de
caracteres, valores lógicos, números enteros, números reales o tipos de
datos complejos. El rango indica los valores que puede tomar la variable.

Por ejemplo, una variable de tipo número entero, con nombre

mesNacimiento puede almacenar valores positivos y negativos, lo que no
tiene sentido cuando se trata de meses del año. El rango válido para esta
variable sería de 1 a 12.

Para declarar una variable en Java se indica el tipo y su nombre.

int mesNacimiento;

En este ejemplo se indica que la variable es de tipo entero (int) y su

nombre es mesNacimiento. Una vez declarada una variable, se puede
utilizar en cualquier parte del programa referenciándola por su nombre.
Para almacenar un valor en una variable se utiliza el operador de asignación
y a continuación se indica el valor, por ejemplo 2.

mesNacimiento = 2;

A partir de este momento la variable mesNacimiento almacena el valor 2 y

cualquier referencia a ella utiliza este valor. Por ejemplo, si se imprime el
valor de la variable por la consola, muestra el valor 2.

System.out.print(mesNacimiento);

Java permite declarar e inicializar una variable en una sola sentencia.

int diaNacimiento = 20;

int mesNacimiento = 3;

16
 Fundamentos de programación en Java

En este ejemplo se declaran las variables diaNacimiento con el valor 20 y

mesNacimiento con valor 3.

Si se declara una constante, entonces se debe utilizar el delimitador final

y es necesario indicar su valor. En la siguiente declaración se define el valor
de la constante pi de tipo double para almacenar un número real.

final double PI = 3.1415926536;

Es conveniente utilizar nombres apropiados para las variables. El nombre de

una variable debe indicar para qué sirve. El nombre de una variable debe
explicarse por sí mismo para mejorar la legibilidad del programa.

Si se desea declarar más de una variable a la vez se deben separar las

variables en la sentencia de la declaración.

int dia=20, mes=2, año=2020;

En este ejemplo se declaran las variables enteras dia, mes y año. La

variable día se inicializa con el valor 20, mes con 2 y año con 2020. La
siguiente declaración es equivalente a la anterior.

int dia=20;
int mes=2;
int año=2020;

Tipos primitivos

Las variables de java pueden ser de un tipo primitivo de datos o una

referencia a un objeto. Los tipos primitivos permiten representar valores
básicos. Estos tipos se clasifican en números enteros, números reales,
caracteres y valores booleanos.

Números enteros. Representan números enteros positivos y negativos con

distintos rangos de valores, desde cientos a trillones. Los tipos enteros de
Java son byte, int, short y long.

17
Estructura de un programa Java

Números reales. Existen dos tipos de números reales en Java, float y

double. La diferencia entre ellos está en el número de decimales que
tienen capacidad para expresar y en sus rangos de valores.

Caracteres. El tipo char permite representar cualquier carácter Unicode.

Los caracteres Unicode contienen todos los caracteres del alfabeto de la
lengua castellana.

Booleano. Se utiliza para representar los valores lógicos verdadero y falso.

Solo tiene dos valores true y false.

La siguiente tabla resume los tipos primitivos de Java.

Tipo Descripción Valor mínimo y máximo

byte Entero con signo -128 a 127

short Entero con signo -32768 a 32767

int Entero con signo -2147483648 a 2147483647

-922117036854775808 a
long Entero con signo
+922117036854775807

±3.40282347e+38 a
float Real de precisión simple
±1.40239846e-45

±1.7976931348623157e+309 a
double Real de precisión doble
±4.94065645841246544e-324

char Caracteres Unicode \u0000 a \uFFFF

boolean Valores lógicos true, false

Literales

Se denomina literal a la manera en que se escriben los valores para cada

uno de los tipos primitivos.

Números enteros. Un número entero en Java se puede escribir en

decimal, octal o en hexadecimal. Cuando se utiliza el sistema octal es
necesario poner el dígito 0 delante del número. Si se utiliza el sistema
hexadecimal se debe poner 0x delante del número. Por ejemplo, el número
decimal 10 se puede escribir 012 en octal y 0xA en hexadecimal. Los
números enteros se supone que pertenecen al tipo int.

18
 Fundamentos de programación en Java

Números reales. Un número real en Java siempre debe tener un punto

decimal o un exponente. Por ejemplo, el número 0.25 se puede expresar
también como 2.5e-1. Los números reales se supone que pertenecen al tipo
double.

Booleanos. Los valores lógicos solo pueden ser true y false. Se escriben
siempre en minúsculas.

Caracteres. Los valores de tipo carácter representan un carácter Unicode.

Se escriben siempre entre comillas simples, por ejemplo 'a', 'A', '0', '9'. En
Java un carácter se puede expresar por su código de la tabla Unicode en
octal o en hexadecimal. Los caracteres que tienen una representación
especial se indican en la siguiente tabla.

Carácter Significado

\b Retroceso

\t Tabulador

\n Salto de línea

\r Cambio de línea

\" Carácter comilla doble

\' Carácter comilla simple

\\ Carácter barra hacia atrás

Textos. Un texto en Java pertenece a la clase String y se expresa como el

texto entre comillas dobles. Un texto siempre debe aparecer en una sola
línea. Para dividir un texto en varias líneas se debe utilizar el operador +
para concatenar textos.

Un texto puede estar vacío o contener uno o más caracteres. Por ejemplo,
“Hola Mundo” es un texto de 10 caracteres, mientras que “” es un texto
vacío y tiene 0 caracteres. El texto “a” es diferente del carácter 'a' de tipo
char.

Operadores

Cada tipo puede utilizar determinados operadores para realizar operaciones

o cálculos.

19
Estructura de un programa Java

Números enteros. Al realizar una operación entre dos números enteros, el

resultado siempre es un número entero. Con los números enteros se
pueden realizar operaciones unarias, aditivas, multiplicativas, de incremento
y decremento, relacionales, de igualdad y de asignación.

 Una operación unaria permite poner un signo delante: +5, -2.

 Una operación aditiva se refiere a la suma y la resta: 2+3, 5-2.

 Una operación multiplicativa multiplica o divide dos valores: 5*2, 5/2. El

operador % calcula el resto de la división entera 5%2.

 Un incremento o decremento aumenta o decrementa en 1 el valor de

una variable: ++numero, numero++, --numero, numero--. Si el
operador va antes de la variable, primero se realiza la operación y se
modifica el valor de la variable. Si el operador va después de la variable,
su valor se modifica al final.

 Un operador relacional permiten comparar dos valores: >, <, >= y <=.
El resultado de la comparación es un valor booleano que indica si la
relación es verdadera o falsa.

 Un operador de igualdad compara si dos valores son iguales o no. El

operador == devuelve verdadero si los dos valores son iguales, el
operador != devuelve verdadero si son diferentes. El resultado de la
comparación es un valor booleano que indica si la igualdad o desigualdad
es verdadera o falsa.

 Un operador de asignación permite asignar un valor o el resultado de

una operación a una variable: =, +=, -=, *=, /=, %=.

Números reales. Con los números reales se aplican los mismos operadores
que con los números enteros. Si se realizan operaciones unarias, aditivas o
multiplicativas, el resultado es un número real. También se pueden aplicar
los operadores relacionales para comparar dos números reales.

Booleanos. Los operadores que se aplican a los valores lógicos son:

negación, Y lógico, O lógico.

 La negación (!) devuelve true si el operando es false.

 El Y lógico (&&) devuelve false si uno de los operandos es false.

 El O lógico (||) devuelve true si uno de los operandos es true.

20
 Fundamentos de programación en Java

Expresiones

Una expresión permite realizar operaciones entre valores utilizando distintos

operadores. Las expresiones son útiles para representar las fórmulas
matemáticas que se utilizan para realizar cálculos.

En Java se pueden definir expresiones tan complejas como sea necesario.

Por ejemplo, para convertir una temperatura de grados Fahrenheit a
Centígrados se utiliza la fórmula:

C = ((F – 32) * 5) / 9

En este ejemplo C representa la temperatura en grados centígrados y F en

grados Fahrenheit. La fórmula en Java, utilizando las variables
centigrados y fahrenheit de tipo double.

centigrados = ((fahrenheit – 32.0) * 5.0)) / 9.0;

Toda la expresión se evalúa a un valor. El orden de los cálculos depende del

orden de prioridad de los operadores: primero los operadores unarios,
después los multiplicativos, de izquierda a derecha, después los operadores
aditivos, de izquierda a derecha, después los operadores de relación y por
último los operadores de asignación.

Por ejemplo, la expresión x = -3 + 2 * 4 – 12 / 6 + 5 se calcula en el orden

siguiente:

Primero se aplica el operador unario (-) a 3 y se obtiene -3. A continuación

se evalúan los operadores multiplicativos de izquierda a derecha. Se calcula
el producto de 2 * 4 y se obtiene 8, después se divide 12 / 6 y se obtiene 2.
Al finalizar estas operaciones la expresión queda x = -3 + 8 – 2 + 5. Por
último, se evalúan los operadores aditivos de izquierda a derecha y se
obtiene 8.

Cuando se desea modificar el orden de prioridad de los operadores es

necesario utilizar paréntesis para indicar el orden de evaluación. Por
ejemplo, al calcular el valor de y = -3 + 2 * (14 – 2) / 6 + 5 se obtiene 6.

21
Estructura de un programa Java

Expresiones aritmético-lógicas

Una expresión aritmético-lógica devuelve un valor lógico verdadero o falso.

En este tipo de expresiones se utilizan operadores aritméticos, operadores
relacionales y de igualdad. Por ejemplo, una expresión lógica puede ser:

(10 – 2) > (5 – 3)

En este ejemplo la expresión aritmético-lógica es verdadera porque el lado

derecho de la expresión es mayor que el lado izquierdo.

En una expresión aritmético-lógica se pueden combinar varias expresiones

con operadores lógicos. La precedecencia de los operadores lógicos es
menor que la de los operadores relacionales, por lo que primero se evalúan
las desigualdades y después los operadores lógicos. El orden de prioridad de
los operadores lógicos es el siguiente: primero la negación, después el Y
lógico y por último el O lógico. La prioridad de los operadores de asignación
es la menor de todas.

Por ejemplo, la expresión 3 + 5 < 5 * 2 || 3 > 8 && 7 > 6 – 2 se evalúa en

el orden siguiente.

Primero se evalúan las expresiones aritméticas y se obtiene la expresión

lógica 8 < 10 || 3 > 8 && 7 > 4. A continuación se evalúan los operadores
relacionales y se obtiene true || false && true. Ahora se evalúa el
operador Y lógico con los operandos false && true y se obtiene false.
Por último, se evalúa el operador O lógico con los operandos true || false
y se obtiene true, el valor final de la expresión.

Los operadores lógicos && y || se evalúan por cortocircuito. Esto significa

que al evaluar a && b, si a es falso, no es necesario evaluar b porque la
expresión es falsa. De forma similar, al evaluar a || b, si a es verdadero, no
es necesario evaluar b porque la expresión es verdadera.

Conversión de tipos

Muchas veces es necesario realizar conversiones de tipos cuando se evalúa

una expresión aritmética. Por ejemplo, si después de realizar el cálculo de
conversión de grados Fahrenheit a Centígrados se quiere almacenar el
resultado en la variable de tipo entero temperatura, es necesario hacer

22
 Fundamentos de programación en Java

una conversión de tipos. La fórmula en Java, utilizando las variables

centigrados y fahrenheit de tipo double.

centigrados = ((fahrenheit – 32.0) * 5.0)) / 9.0;

Antes de asignar el valor resultante a la variable temperatura, que

almacena un valor entero, es necesario convertir el valor de tipo double de
la variable centigrados a int.

int temperatura = (int) centigrados;

Las palabras reservadas de Java

En todos los lenguajes de programación existen palabras con un significado

especial. Estas palabras son reservadas y no se pueden utilizar como
nombres de variables.

abstract final public

assert finally return
boolean float short
break for static
byte if strictfp
case implements super
catch import switch
char instanceof synchronized
class int this
continue interface throw
default long throws
do native transient
double new true
else null try
enum package void
extends private volatile
false protected while

23
Estructura de un programa Java

En realidad, las palabras false, null y true son literales. No son palabras
reservadas del lenguaje, pero no se pueden utilizar como identificadores.

24
3. Clases y objetos

La programación orientada a objetos se enfoca en los elementos de un

sistema, sus atributos y las interacciones que se producen entre ellos para
diseñar aplicaciones informáticas. Los elementos abstractos del modelo
orientado a objetos se denominan clases.

Un programa orientado a objetos es, esencialmente, una colección de

objetos que se crean, interaccionan entre sí y dejan de existir cuando ya no
son útiles durante la ejecución de un programa. Una aplicación informática
puede llegar a ser muy compleja. La complejidad es más manejable cuando
se descompone y se organiza en partes pequeñas y simples, los objetos.

Un programa Java utiliza clases y objetos. Las clases representan un

esquema simplificado de la casuística de una aplicación informática. Una
clase es una representación abstracta de un conjunto de objetos que
comparten los mismos atributos y comportamiento, es decir, una clase
describe un tipo de objetos. Un objeto es una instancia de una clase, tiene
una identidad propia y un estado. La identidad de un objeto se define por su
identificador. El estado de un objeto se define por el valor de sus atributos.
El comportamiento de un objeto queda determinado por el comportamiento
la clase a la que pertenece. Los objetos son unidades indivisibles y disponen
de mecanismos de interacción llamados métodos.

Para entender el concepto de objeto es necesario saber que existe una

relación directa entre los elementos que forman parte de una aplicación
informática y los objetos. Normalmente, para identificar los elementos de
una aplicación, debemos fijarnos en los sustantivos que utilizamos para
describir los objetos reales del sistema. Para diseñar una aplicación
orientada a objetos es necesario responder las siguientes preguntas:

 ¿Cuáles son los elementos tangibles de un sistema?

 ¿Cuáles son sus atributos?

 ¿Cuáles son sus responsabilidades?

 ¿Cómo se relacionan los elementos del sistema?

 ¿Qué objeto debe “saber”...?

 ¿Qué objeto debe “hacer”...?

25
Clases y objetos

Por ejemplo, si se desea diseñar un programa Java para gestionar las

ventas de una tienda, entonces habría que identificar y describir las
características elementos como: cliente, tipo de cliente, producto, pedido,
tipo de entrega, forma de pago, unidades en existencia de los productos,
etc. Los procesos de gestión de la tienda incluirían el registro de los
clientes, el registro de los productos de la tienda, el proceso de compra del
cliente y la realización de los pedidos, la entrada y salida de productos del
almacén, etc.

Si en vez de una tienda se trata de una aplicación para dibujar figuras

geométricas en dos dimensiones, entonces sería necesario identificar y
describir las características de las figuras y su posición. En este caso habría
figuras de tipo círculo, rectángulo, triángulo, etc. Las operaciones a realizar
con las figuras incluirían dibujar, borrar, mover o rotar.

Clases
En su forma más simple, una clase se define por la palabra reservada
class seguida del nombre de la clase. El nombre de la clase debe empezar
por mayúscula. Si el nombre es compuesto, entonces cada palabra debe
empezar por mayúscula. Circulo, Rectangulo, Triangulo y
FiguraGeometrica son nombres válidos de clases.

Por ejemplo, la clase Circulo se define con tres atributos: el radio y las
coordenadas x, y que definen la posición del centro del círculo.

/* Esta clase define los atributos de un círculo */

public class Circulo {

int x;
int y;
int radio;

26
 Fundamentos de programación en Java

Una vez que se ha declarado una clase, se pueden crear objetos a partir de
ella. A la creación de un objeto se le denomina instanciación. Es por esto
que se dice que un objeto es una instancia de una clase y el término
instancia y objeto se utilizan indistintamente.

Para crear objetos, basta con declarar una variable de alguno de los tipos
de figuras geométricas:

Circulo circulo1;
Circulo circulo2;

Para crear el objeto y asignar un espacio de memoria es necesario realizar

la instanciación con el operador new.

circulo1 = new Circulo();

circulo2 = new Circulo();

Después de crear los objetos, circulo1 y circulo2 almacenan los valores

predeterminados de la clase Circulo. A partir de este momento los objetos
ya pueden ser referenciados por su nombre. Los nombres circulo1 y
circulo2 son las referencias válidas para utilizar ambos objetos.

Los elementos de una clase

Una clase describe un tipo de objetos con características comunes. Es
necesario definir la información que almacena el objeto y su
comportamiento.

Atributos

La información de un objeto se almacena en atributos. Los atributos pueden

ser de tipos primitivos de Java o de tipo objeto. Por ejemplo, para el
catálogo de vehículos de una empresa de alquiler, es necesario conocer la
matrícula del coche, su marca, modelo, color, la tarifa del alquiler y su
disponibilidad.

27
Clases y objetos

public class Vehiculo {

String matricula;
String marca;
String modelo;
String color;
double tarifa;
boolean disponible;

En este ejemplo, los atributos matricula, marca, modelo y color son

cadenas de caracteres, tarifa es un número real y disponible es un
valor lógico.

Métodos y constructores

Además de definir los atributos de un objeto, es necesario definir los

métodos que determinan su comportamiento. Toda clase debe definir un
método especial denominado constructor para instanciar los objetos de la
clase. Este método tiene el mismo nombre de la clase. Por ejemplo, para la
clase Vehiculo, el identificador del método constructor es Vehiculo. El
método constructor se ejecuta cada vez que se instancia un objeto de la
clase. Este método se utiliza para inicializar los atributos del objeto que se
instancia.

Para diferenciar entre los atributos del objeto y los identificadores de los
parámetros del método constructor, se utiliza la palabra this. De esta
forma, los parámetros del método pueden tener el mismo nombre que los
atributos de la clase. Esto permite hacer una asignación como la que se
muestra a continuación, donde this.marca se refiere al atributo del objeto
y marca al parámetro del método.

this.marca = marca;

28
 Fundamentos de programación en Java

En el siguiente ejemplo el método constructor inicializa los atributos

matricula, marca, modelo, color y tarifa.

public class Vehiculo {

String matricula;
String marca;
String modelo;
String color;
double tarifa;
boolean disponible;

// el método constructor de la clase Vehiculo

public Vehiculo(String matricula,

String marca,
String modelo,
String color,
double tarifa) {
this,matricula = matricula;
this.marca = marca;
this.modelo = modelo;
this.color = color;
this.tarifa = tarifa;
this.disponible = false;
}
}

La instanciación de un objeto se realiza ejecutando el método constructor

de la clase.

Vehiculo vehiculo1 = new Vehiculo("4050 ABJ",

"VW", "GTI",
"Blanco",
100.0);

En este ejemplo se instancia el objeto vehiculo1. El método constructor

crea el objeto vehiculo1 con la matrícula “4050 ABJ”, marca “VW”,
modelo “GTI”, color “Blanco” y tarifa 100.0 euros.

29
Clases y objetos

Vehiculo vehiculo2 = new Vehiculo("2345 JVM",

"SEAT",
"León",
"Negro",
80.0);

En este ejemplo se instancia el objeto vehiculo2. El método constructor

crea el objeto vehiculo2 con la matrícula “2345 JVM”, marca “SEAT”,
modelo “León”, color “Negro” y tarifa 80.0 euros.

La instanciación de un objeto consiste en asignar un espacio de memoria al

que se hace referencia con el nombre del objeto. Los identificadores de los
objetos permiten acceder a los valores almacenados en cada objeto. En
estos ejemplos, los objetos vehiculo1 y vehiculo2 almacenan valores
diferentes y ocupan espacios de memoria distintos.

Para acceder a los atributos de los objetos de la clase Vehiculo se definen

los métodos ‘get’ y ‘set’. Los métodos ‘get’ se utilizan para consultar el
estado de un objeto y los métodos ‘set’ para modificar su estado. En la
clase Vehiculo es necesario definir un método ‘get’ para cada uno de sus
atributos: getMatricula(), getMarca(), getModelo(), getColor(),
getTarifa() y getDisponible(). Los métodos ‘set’ solo se definen para
los atributos que pueden ser modificados después de que se ha creado el
objeto. En este caso es necesario definir setTarifa(double tarifa) y
setDisponible(boolean disponible) para modificar la tarifa del
alquiler del vehículo y su disponibilidad, respectivamente.

30
 Fundamentos de programación en Java

public class Vehiculo {

String matricula;
String marca;
String modelo;
String color;
double tarifa;
boolean disponible;

// los métodos ‘get’ y ‘set’ de la clase Vehiculo

public String getMatricula() {

return this.matricula;
}
public String getMarca() {
return this.marca;
}
public String getModelo() {
return this.modelo;
}
public String getColor() {
return this.color;
}
public double getTarifa() {
return this.tarifa;
}
public boolean getDisponible() {
return this.disponible;
}
public void setTarifa(double tarifa) {
this.tarifa = tarifa;
}
public void setDisponible(boolean disponible) {
this.disponible = disponible;
}
}

31
Clases y objetos

Representación de clases y objetos

Representación de la clase vehículo utilizando un diagrama de clases.

Una clase se representa como un recuadro dividido en tres partes: el

nombre de la clase en la parte superior, la declaración de atributos y la
declaración de métodos.

El código Java de una clase se divide en dos partes, la declaración y su

definición. La declaración comienza por la palabra class y a continuación
se indica el nombre de la clase. La definición de una clase queda delimitada
por la llave de inicio { y la llave de fin }. En el bloque de definición de la
clase se declaran los atributos de los objetos y los métodos que definen su
comportamiento.

Los objetos se representan como cajas que indican el nombre del objeto, la
clase a la que pertenecen y el estado del objeto.

En este ejemplo, los objetos vehiculo1 y vehiculo2 son instancias de la

clase Vehiculo. Ambos objetos comparten los mismos atributos, pero
almacenan distintos valores. Los valores almacenados en un objeto
representan su estado. El estado del objeto vehiculo1 almacena los
valores: matricula “4050 ABJ”, marca “VW”, modelo “GTI”, color “Blanco”,
tarifa 100.0 y disponible true. El estado del objeto vehiculo2 almacena

32
 Fundamentos de programación en Java

matricula “2345 JVM”, marca “SEAT”, modelo “León”, color “Negro”, tarifa
80.0 y disponible false.

El estado de un objeto puede cambiar durante la ejecución de un programa

Java. En este ejemplo, se podría modificar la tarifa del alquiler y la
disponibilidad de los objetos de la clase Vehiculo, el resto de los atributos
no se pueden modificar.

Objetos
Un objeto se compone de atributos y métodos. Para acceder a los
elementos de un objeto se escribe el nombre del objeto, un punto y el
nombre del elemento al que se desea acceder.

Por ejemplo, para los objetos vehiculo1 y vehiculo2, se podría acceder

directamente a sus atributos como se muestra a continuación:

Vehiculo vehiculo1 = new Vehiculo("4050 ABJ",

"VW", "GTI",
"Blanco",
100.0);
System.out.println("Matricula : " +
vehiculo1.matricula);
System.out.println("Marca y modelo: " +
vehiculo1.marca + " " +
vehiculo1.modelo);
System.out.println("Color : " +
vehiculo1.color);
System.out.println("Tarifa : " +
vehiculo1.tarifa);

33
Clases y objetos

La salida por la consola:

Matrícula : 4050 ABJ

Marca y modelo: VW GTI
Color : Blanco
Tarifa : 100.0

Para acceder a un método, además de su nombre hay que indicar la lista de

argumentos requeridos por el método. Cuando la declaración del método no
incluye parámetros no es necesario pasar argumentos.

El siguiente código Java crea el objeto vehiculo1 y muestra su matrícula y

su tarifa. A continuación modifica la tarifa a 90.0 euros y la muestra de
nuevo.

Vehiculo vehiculo1 = new Vehiculo("4050 ABJ",

"VW",
"GTI",
"Blanco",
100.0);

System.out.println("Matricula : " +
vehiculo1.getMatricula());
System.out.println("Tarifa : " +
vehiculo1.getTarifa());

vehiculo1.setTarifa(90.0);

System.out.println("Matricula : " +
vehiculo1.getMatricula());
System.out.println("Tarifa : " +
vehiculo1.getTarifa());

34
 Fundamentos de programación en Java

La salida por la consola:

Matrícula : 4050 ABJ

Tarifa : 100.0
Matrícula : 4050 ABJ
Tarifa : 90.0

Para mostrar la tarifa del objeto vehiculo1 se puede acceder directamente

al atributo tarifa del objeto o se puede ejecutar el método getTarifa().
Esto se debe a que los atributos de clase Vehiculo son de acceso público
porque se han declarado public en vez de private. Los atributos de la
clase se deben declarar private y para acceder a ellos se debe utilizar un
método ‘get’.

La referencia null

Una referencia a un objeto puede no tener asignada una instancia. Esto

puede ocurrir porque se ha declarado el objeto pero no se ha instanciado,
es decir no se ha creado un objeto con el operador new. Existe un valor
especial, llamado null que indica que un objeto no se ha instanciado. A
continuación se declara el objeto vehiculo2, pero no se crea una instancia
para él.

Vehiculo vehiculo2;

Mientras no se instancie el objeto vehiculo2 su referencia vale null. En

un programa Java no se deben dejar referencias de objetos sin instanciar.
Es necesario asegurarse que los objetos existen para evitar referencias
null.

El objeto se puede instanciar en la misma declaración o más adelante, como

se muestra en el siguiente ejemplo.

Vehiculo vehiculo2;

// el objeto vehiculo2 se declara pero no se instancia

// la instancia se crea utilizando el operador new

35
Clases y objetos

Vehiculo vehiculo2 = new Vehiculo("2345 JVM",

"SEAT",
"León",
"Negro",
80.0);

Para saber si una referencia está instanciada o no, se puede comparar con
null.

if (vehiculo2 == null) {
System.out.print("vehiculo2 es una referencia null")
}

if (vehiculo2 != null) {
System.out.print("vehiculo2 está instanciado")
}

Si vehiculo2 es null, la primera expresión es true y la segunda false.

En ese caso, el programa muestra por la consola el mensaje:

vehiculo2 es una referencia null

Referencias compartidas por varios objetos

Un objeto puede tener varias referencias o nombres. Un alias es otro

nombre que se referencia al mismo objeto. Un alias es una referencia más
al mismo espacio de memoria del objeto original. Por ejemplo, si se crea el
objeto vehiculo1 y después se declara otro objeto vehiculo3 y a
continuación se asigna la referencia de vehiculo1 a vehiculo3, entonces
vehiculo3 es un alias de vehiculo1. Esto significa que el espacio de
memoria de vehiculo1 y vehiculo3 es el mismo.

36
 Fundamentos de programación en Java

Vehiculo vehiculo1;
Vehiculo vehiculo3;

vehiculo1 = new Vehiculo("4050 ABJ",

"VW",
"GTI",
"Blanco",
100.0);

// el objeto vehiculo1 se instancia, vehiculo3 solo

// está declarado y es una referencia null

vehiculo3 = vehiculo1;

// al asignar la referencia de vehiculo1 a vehiculo3,

// éste se convierte en alias de vehiculo1 y referencia
// el mismo espacio de memoria

System.out.println("Matricula : " +
vehiculo1.getMatricula());
System.out.println("Tarifa : " +
vehiculo1.getTarifa());

// se muestra la matricula y la tarifa de vehiculo1

System.out.println("Matricula : " +
vehiculo3.getMatricula());
System.out.println("Tarifa : " +
vehiculo3.getTarifa());

37
Clases y objetos

// se muestra la matricula y la tarifa de vehiculo3,

// un alias de vehiculo1, por lo que muestra de nuevo
// la información correspondiente a vehiculo1

La salida por la consola muestra dos veces los valores asignados al objeto
vehiculo1.

Matrícula : 4050 ABJ

Tarifa : 100.0
Matrícula : 4050 ABJ
Tarifa : 100.0

Un alias se puede utilizar para mostrar el estado de un objeto y también

para modificarlo. Si se ejecuta setTarifa(90.0) con el objeto vehiculo3
en realidad se modifica la tarifa de vehiculo1.

vehiculo3.setTarifa(90.0);

// al modificar la tarifa de vehiculo3 en realidad se

// modifica la tarifa de vehiculo1

System.out.println("Matricula : " +
vehiculo1.getMatricula());
System.out.println("Tarifa : " +
vehiculo1.getTarifa());

System.out.println("Matricula : " +
vehiculo3.getMatricula());
System.out.println("Tarifa : " +
vehiculo3.getTarifa());

38
 Fundamentos de programación en Java

Se muestra la matrícula y la tarifa de vehiculo1 y vehiculo3.

Matrícula : 4050 ABJ

Tarifa : 90.0
Matrícula : 4050 ABJ
Tarifa : 90.0

El objeto vehiculo3 es un alias de vehiculo1 y no tiene un espacio de

memoria propio. Utiliza el mismo espacio de memoria que vehiculo1. Es
decir, vehiculo1 comparte con sus alias el mismo espacio de memoria. Si
se modifica el valor de la tarifa almacenada en vehiculo3, en realidad se
modifica el valor de vehiculo1.

Esquemáticamente, un alias se puede ver como un objeto que apunta al

espacio de memoria de otro objeto, como se muestra a continuación:

En este esquema, el objeto vehiculo3 es un alias de vehiculo1 y ambos

objetos comparten el mismo espacio de memoria. El objeto vehiculo2,
tiene su espacio de memoria propio y no lo comparte con otro objeto.

El ciclo de vida de un objeto

El ciclo de vida de un objeto empieza por su declaración, su instanciación y

su uso en un programa Java hasta que finalmente desaparece.

Cuando un objeto deja de ser utilizado, Java libera la memoria asignada al

objeto y la reutiliza. El entorno de ejecución de Java decide cuándo puede
reutilizar la memoria de un objeto que ha dejado de ser útil en un
programa. El programador no debe preocuparse de liberar la memoria

39
Clases y objetos

utilizada por los objetos. A este proceso se le conoce como recolección de

basura. Java cuenta con un sistema recolector de basura que se encarga de
liberar los objetos y los espacios de memoria que ocupan cuando éstos
dejan de ser utilizados en un programa.

Atributos
Los atributos son los elementos que almacenan el estado de un objeto. Se
definen de la misma forma que las variables, pero dentro del bloque de la
clase.

Existen dos tipos de atributos: los atributos de clase y los atributos de

objeto. Los atributos de clase existen siempre, son independientes de que
existan objetos instanciados. Los atributos de clase se declaran utilizando
static. Los atributos de objeto existen durante el ciclo de vida de un
objeto, es decir, se crean cuando se instancia el objeto y se pueden utilizar
mientras el objeto exista.

Un atributo se declara con la siguiente sintaxis:

tipo-de-acceso tipo nombre [ = valor-inicial ];

El tipo de acceso puede ser private, protected o public. Los atributos

con acceso private solo se pueden acceder desde la propia clase que los
define, mientras que los atributos public se pueden acceder libremente
desde otras clases. Los atributos protected se pueden acceder desde la
propia clase que los define y desde sus subclases. El concepto de subclase
se explica más adelante, en el apartado de extensión de clases.

El tipo puede ser un tipo primitivo de Java o el identificador de una clase. El

nombre del atributo debe cumplir las normas de los identificadores y se
recomienda utilizar un sustantivo que sea representativo de la información
que almacena.

La inicialización del objeto es opcional. Se puede declarar un objeto que

será instanciado después o se puede instanciar al momento de su
declaración.

40
 Fundamentos de programación en Java

public class Vehiculo {

String matricula;
String marca;
String modelo;
String color;
double tarifa = 0.0;
boolean disponible = false;
}

En el ejemplo anterior, el atributo tarifa se inicializa a cero y disponible a

false. Al resto de atributos no se les asigna un valor inicial. Con esta
declaración, cuando se instancia un objeto de tipo Vehiculo se inicializan
los valores de los atributos tarifa y disponible. Si no se define el tipo de
acceso, entonces el atributo tiene acceso de tipo public.

La clase Vehiculo se debe declarar con atributos privados. Se utiliza el tipo

de acceso private para que solo los métodos ‘get’ y ‘set’ de la clase
puedan acceder a ellos.

public class Vehiculo {

private String matricula;
private String marca;
private String modelo;
private String color;
private double tarifa = 0.0;
private boolean disponible = false;
}

En esta nueva declaración, todos los atributos tienen acceso private y solo
es posible acceder a ellos desde los métodos de la clase.

Métodos
Los métodos son funciones que determinan el comportamiento de los
objetos. Un objeto se comporta de una u otra forma dependiendo de los
métodos de la clase a la que pertenece. Todos los objetos de una misma
clase tienen los mismos métodos y el mismo comportamiento.

41
Clases y objetos

Existen tres tipos de métodos: métodos de consulta, métodos modificadores

y operaciones. Los métodos de consulta sirven para extraer información de
los objetos, los métodos modificadores sirven para modificar el valor de los
atributos del objeto y las operaciones definen el comportamiento de un
objeto.

Los métodos ‘get’ son métodos de consulta, mientras que los métodos ‘set’
son métodos modificadores.

Los métodos ‘get’ se utilizan para extraer el valor de un atributo del objeto
y los métodos ‘set’ para modificarlo. En la clase Vehiculo es necesario
definir un método ‘get’ para cada uno de sus atributos: getMatricula(),
getMarca(), getModelo(), getColor(), getTarifa() y
getDisponible(). Los métodos ‘set’ solo se definen para los atributos que
pueden ser modificados después de que se ha creado el objeto. En este
caso es necesario definir los métodos setTarifa(double tarifa) y
setDisponible(boolean disponible) para modificar la tarifa del
alquiler del vehículo y su disponibilidad, respectivamente.

Un método ‘get’ se declara public y a continuación se indica el tipo que

devuelve. Es un método de consulta. Por ejemplo, el método getTarifa()
devuelve double porque el atributo tarifa es de tipo double. La lista de
parámetros de un método ‘get’ queda vacía. En el cuerpo del método se
utiliza return para devolver el valor correspondiente al atributo tarifa
del objeto, al que se hace referencia como this.tarifa.

Un método ‘get’ se El valor de retorno es double, igual

declara public que el atributo tarifa
La lista de parámetros de un método
‘get’ queda vacía

public double getTarifa() {

return this.tarifa;
}

Un método ‘get’ utiliza return para devolver el valor del atributo. En este caso el identificador
del atributo es tarifa y se refiere a él como this.tarifa

42
 Fundamentos de programación en Java

El método getAtributos() es un caso particular de método ‘get’ que

devuelve los valores concatenados de los atributos del objeto.

public class Vehiculo {

private String matricula;
private String marca;
private String modelo;
private String color;
private double tarifa = 0.0;
private boolean disponible = false;

public String getAtributos() {

return "Matrícula: " + this.matricula +
" Modelo: " + this.marca + " " + this.modelo +
" Color: " + this.color +
" Tarifa: " + this.tarifa +
" Disponible: " + this.disponible;
}
}

Un método ‘set’ se declara public y devuelve void. La lista de parámetros

de un método ‘set’ incluye el tipo y el valor a modificar. Es un método
modificador. Por ejemplo, el método setTarifa(double tarifa) debe
modificar el valor de la tarifa del alquiler almacenado en el objeto. El cuerpo
de un método ‘set’ asigna al atributo del objeto el parámetro de la
declaración.

Un método ‘set’ se El valor de retorno La lista de parámetros de un método ‘set’

declara public es void incluye el tipo y el nombre del parámetro

public void setTarifa(double tarifa) {

this.tarifa = tarifa;
}

Un método ‘set’ modifica el valor de un atributo del objeto. En este caso el identificador del
atributo es tarifa y se refiere a él como this.tarifa para asignarle el valor del parámetro

43
Clases y objetos

Un método de tipo operación es aquel que realiza un cálculo o modifica el

estado de un objeto. Este tipo de métodos pueden incluir una lista de
parámetros y puede devolver un valor o no. Si el método no devuelve un
valor, se declara void.

Por ejemplo, la clase Circulo define dos métodos de tipo operación, uno
para calcular el perímetro y otro para calcular el área.

public class Circulo {

public static final double PI = 3.1415926536;
private double radio;

public Circulo(double radio) {

this.radio = radio;
}

public double getRadio() {

return this.radio;
}

public double calcularPerimetro() {

return 2 * PI * this.radio;
}

public double calcularArea() {

return PI * this.radio * this.radio;
}

En este ejemplo, los métodos calcularPerimetro() y calcularArea()

devuelven un valor double y ninguno de ellos recibe parámetros.

Declaración de métodos

La declaración de un método indica si el método necesita o no argumentos.

Los métodos ‘get’ no tienen argumentos y devuelven un valor, los métodos
‘set’ necesitan un argumento para indicar el valor del atributo que van a
modificar.

44
 Fundamentos de programación en Java

El método setTarifa(double tarifa) tiene un argumento. El nombre

de este parámetro es tarifa y su tipo es double.

Un método se declara con la siguiente sintaxis:

tipo-de-acceso tipo nombre (lista-parametros);

El tipo de acceso puede ser private o public. Si el método devuelve un

valor se debe indicar su tipo. Este valor puede ser de un tipo primitivo de
Java o el identificador de una clase. Si el método no devuelve un valor
entonces el tipo es void. El nombre del atributo debe cumplir las normas
de los identificadores y se recomienda utilizar un verbo que sea
representativo de la acción que realiza el método. La lista de parámetros
indica los valores que requiere el método para su ejecución.

La lista de parámetros se declara con la siguiente sintaxis:

tipo nombre [,tipo nombre ]

La lista de parámetros puede declarar una o más variables separadas por

una coma. El tipo puede ser un tipo primitivo de Java o el identificador de
una clase. El nombre del parámetro debe cumplir las normas de los
identificadores y se recomienda utilizar un sustantivo que sea
representativo de la información que almacena.

Dentro de una clase los métodos se identifican unívocamente por su nombre

y su lista de parámetros.

Invocación de métodos

Un método se puede invocar dentro o fuera de la clase donde se ha

declarado. Si el método se invoca dentro de la clase, basta con indicar su
nombre. Si el método se invoca fuera de la clase entonces se debe indicar el
nombre del objeto y el nombre del método.

Por ejemplo, el método getAtributos() de la clase Vehiculo se podría

codificar invocando a los métodos getMatricula(), getMarca(),
getModelo(), getTarifa() y getDisponible(). En este caso, el

45
Clases y objetos

método getAtributos() utiliza los métodos ‘get’ de la clase en vez de

hacer referencia directa a los atributos del objeto.

public class Vehiculo {

private String matricula;
private String marca;
private String modelo;
private String color;
private double tarifa = 0.0;
private boolean disponible = false;

public String getAtributos() {

return "Matrícula: " + getMatricula() + " " +
" Modelo: " + getMarca() + " " + getModelo() +
" Color: " + getColor() +
" Tarifa: " + getTarifa() +
" Disponible: " + getDisponible;
}

Si el método getAtributos() se va a invocar desde fuera de la clase,

entonces es necesario indicar el nombre del objeto y el nombre del método.

En este ejemplo, el método getAtributos() se utiliza para mostrar los

valores almacenados en el objeto vehiculo1.

Vehiculo vehiculo1 = new Vehiculo("4050 ABJ",

"VW",
"GTI",
"Blanco",
100.0);

// invocación del método getAtributos para mostrar

// los datos del objeto vehiculo1

System.out.print("Datos del vehículo " +

vehiculo1.getAtributos());

46
 Fundamentos de programación en Java

Si el método es estático, entonces es necesario indicar el nombre de la

clase y el nombre del método. Por ejemplo, la clase Math incluye el método
sqr para calcular el cuadrado de un número. En este caso, es necesario
indicar el nombre de la clase y el nombre del método que se invoca.

int numero = 4;

// invocación del método sqr de la clase Math

System.out.print("El cuadrado del número es: " +

Math.sqr(numero));

Cuando se invoca a un método ocurre lo siguiente:

 En la línea de código del programa donde se invoca al método se

calculan los valores de los argumentos.

 Los parámetros se inicializan con los valores de los argumentos.

 Se ejecuta el bloque código del método hasta que se alcanza return o

se llega al final del bloque.

 Si el método devuelve un valor, se sustituye la invocación por el valor

devuelto.

 La ejecución del programa continúa en la siguiente instrucción donde se

invocó el método.

El método main()

Existe un método especial, llamado main(). Este método se invoca cuando

se ejecuta un programa Java. Todo programa Java debe tener una clase con
el método main(). Este método se debe declarar public static void.
Es un método estático, público y no devuelve un valor de retorno. Los
parámetros String[] args se refieren a la línea de comandos de la
aplicación.

Cuando la máquina virtual de Java (JVM) ejecuta un programa Java invoca

al método main(). Es este método quien a su vez ejecuta los métodos de
la aplicación.

47
Clases y objetos

public class MisVehiculos {

public static void main(String args[]) {

// este programa crea un objeto de la clase vehiculo y

// muestra sus atributos

// instanciación del objeto vehiculo1

Vehiculo vehiculo1 = new Vehiculo("4050 ABJ",

"VW",
"GTI",
"Blanco",
100.0);

// invocación del método getAtributos() para mostrar los datos

// del objeto vehiculo1

System.out.print("Datos del vehículo " +

vehiculo1.getAtributos());

}
}

Parámetros y argumentos

Los parámetros de un método definen la cantidad y el tipo de dato de los

valores que recibe un método para su ejecución. Los argumentos son los
valores que se pasan a un método durante su invocación. El método recibe
los argumentos correspondientes a los parámetros con los que ha sido
declarado.

Un método puede tener tantos parámetros como sea necesario. La lista de

parámetros de la cabecera de un método se define con la siguiente sintaxis:

tipo nombre [,tipo nombre ]

Por ejemplo, el método constructor de la clase Vehiculo tiene cinco

parámetros, la matrícula, la marca, el modelo, el color del vehículo y su

48
 Fundamentos de programación en Java

tarifa. Los parámetros matricula, marca, modelo y color son de tipo

String, tarifa es de tipo double.

public Vehiculo(String matricula,

String marca,
String modelo,
String color,
double tarifa) {
}

El método setTarifa(double tarifa) de la clase Vehiculo tiene un

parámetro tarifa de tipo double.

public void setTarifa(double tarifa) {

}

Durante la invocación de un método es necesario que el número y el tipo de

argumentos coincidan con el número y el tipo de parámetros declarados en
la cabecera del método.

Por ejemplo, es correcto invocar al método setTarifa(double tarifa)

del objeto vehiculo1 pasando un argumento de tipo double.

vehiculo1.setTarifa(100.0); // invocación correcta

vehiculo1.setTarifa(90.0); // invocación correcta

La invocación del método no es correcta si se pasan dos argumentos de tipo

double o un argumento de tipo String porque la cabecera del método
solo incluye un parámetro double. Las invocaciones del método
setTarifa(double tarifa) son incorrectas.

vehiculo1.setTarifa(100.0, 20.0); // no es correcto

vehiculo1.setTarifa("100.0"); // no es correcto

49
Clases y objetos

Los dos ejemplos anteriores no son válidos porque la lista de argumentos

del método setTarifa(double tarifa) no coincide con la lista de
parámetros de la declaración de este método.

Durante el proceso de compilación se comprueba que durante la invocación

de un método se pasan tantos argumentos como parámetros tiene
declarados y que además coinciden los tipos. Esta es una característica de
los lenguajes que se denominan “strongly typed” o “fuertemente tipados”.

Paso de parámetros

Cuando se invoca un método se hace una copia de los valores de los

argumentos en los parámetros. Esto quiere decir que si el método modifica
el valor de un parámetro, nunca se modifica el valor original del argumento.

Cuando se pasa una referencia a un objeto se crea un nuevo alias sobre el

objeto, de manera que esta nueva referencia utiliza el mismo espacio de
memoria del objeto original y esto permite acceder al objeto original.

Por ejemplo, el método recibirVehiculoAlquilado(Vehiculo v)

recibe el parámetro v de tipo Vehiculo. Si el método modifica el estado del
objeto v, en realidad modifica el estado del objeto original vehiculo1 que
recibe como argumento.

public void recibirVehiculoAlquilado (Vehiculo v) {

v.setDisponible(true);
}

50
 Fundamentos de programación en Java

En el siguiente programa Java, en el método main() se crea un objeto

vehiculo1 de la clase Vehiculo. Al instanciar el objeto, el método
constructor asigna el valor false al atributo disponible, pero al invocar al
método recibirVehiculoAlquilado(Vehiculo v) con el objeto
vehiculo1, se modifica su disponibilidad.

public class MisVehiculos {

public static void recibirVehiculoAlquilado(Vehiculo v) {

v.setDisponible(true);
}

public static void main(String args[]) {

Vehiculo vehiculo1 = new Vehiculo("4050 ABJ",

"VW",
"GTI",
"Blanco",
100.0);

// el valor del atributo disponible de vehiculo1 es false

System.out.println("El objeto vehiculo1 está disponible: " +

vehiculo1.getDisponible());

recibirVehiculoAlquilado (vehiculo1);

// el valor del atributo disponible de vehiculo1 es true

System.out.println("El objeto vehiculo1 está disponible: " +

vehiculo1.getDisponible());

}
}

La salida por la consola:

El objeto vehiculo1 está disponible: false

El objeto vehiculo1 está disponible: true

51
Clases y objetos

El valor de retorno

Un método puede devolver un valor. Los métodos que no devuelven un

valor se declaran void, mientras que los métodos que devuelven un valor
indican el tipo que devuelven: int, double, char, String o un tipo de
objeto.

Los métodos ‘set’ devuelven void, mientras que los métodos ‘get’
devuelven el tipo correspondiente al atributo al que hacen referencia. Los
métodos ‘set’ devuelven void porque son métodos modificadores, realizan
operaciones y cálculos para modificar el estado de los objetos. Los métodos
‘get’, en cambio, son métodos de consulta y devuelven los valores
almacenados en los atributos de un objeto.

Por ejemplo, el método setTarifa(double tarifa) recibe el parámetro

tarifa de tipo double y devuelve void.

public void setTarifa(double tarifa) {

this.tarifa = tarifa;
}

El método getTarifa() devuelve el tipo double correspondiente al

atributo tarifa. El valor del atributo se devuelve con return.

public double getTarifa() {

return this.tarifa;
}

Las variables locales de un método

Las variables locales de un método son útiles para almacenar valores

temporales cuyo tiempo de vida coincide con el método.

Por ejemplo, el método getAtributos() no utiliza variables locales. El

valor de retorno se calcula al momento de hacer return.

52
 Fundamentos de programación en Java

public String getAtributos() {

return "Matrícula: " + getMatricula() + " " +
" Modelo: " + getMarca() + " " + getModelo() +
" Color: " + getColor() +
" Tarifa: " + getTarifa() +
" Disponible: " + getDisponible;
}

Este método se podría codificar declarando la variable local atributos de

tipo String para almacenar el valor de retorno. Esta variable se declara
dentro del cuerpo del método.

public String getAtributos() {

String atributos;
atributos = "Matrícula: " + getMatricula() + " " +
" Modelo: " + getMarca() + " " + getModelo() +
" Color: " + getColor() +
" Tarifa: " + getTarifa() +
" Disponible: " + getDisponible;
return atributos;
}

Los dos métodos son equivalentes, pero el primero es más claro porque
evita el uso de una variable local que no es necesaria.

Sobrecarga de métodos

La sobrecarga de métodos es útil para que el mismo método opere con

parámetros de distinto tipo o que un mismo método reciba una lista de
parámetros diferente. Esto quiere decir que puede haber dos métodos con
el mismo nombre que realicen dos funciones distintas. La diferencia entre
los métodos sobrecargados está en su declaración.

53
Clases y objetos

Por ejemplo, el método getAtributos() se puede sobrecargar para

devolver los atributos de un vehículo y para mostrar la tarifa reducida al
aplicar el porcentaje de descuento recibido como argumento.

public String getAtributos() {

return "Matrícula: " + getMatricula() + " " +
" Modelo: " + getMarca() + " " + getModelo() +
" Color: " + getColor() +
" Tarifa: " + getTarifa() +
" Disponible: " + getDisponible;
}
public String getAtributos(double porcentajeDescuento) {
return "Matrícula: " + getMatricula() + " " +
" Modelo: " + getMarca() + " " + getModelo() +
" Color: " + getColor() + " Tarifa: " +
(100.0 – porcentajeDescuento)/100*tarifa +
" Disponible: " + getDisponible;
}

En este ejemplo los dos métodos se diferencian por la declaración de sus

parámetros y ambos métodos realizan operaciones distintas.

Constructores
Para crear un objeto se utiliza el operador new. Si no se ha definido un
método constructor para la clase, entonces el objeto se instancia indicando
el nombre de la clase y a continuación un paréntesis abierto y otro cerrado.
Si ya se ha definido un método constructor, entonces no es posible
instanciar un objeto utilizando el constructor por defecto. Cuando se invoca
al constructor por defecto se asigna un espacio de memoria para el nuevo
objeto y sus atributos se inicializan a los valores por defecto
correspondientes a su tipo. Los números enteros se inicializan a cero, los
números reales a 0.0, los valores lógicos a false, los caracteres se
inicializan a \u0000 y las referencias a null.

54
 Fundamentos de programación en Java

En una clase se pueden definir uno o más métodos constructores para

inicializar los atributos de un objeto con valores distintos de los valores por
defecto de Java. Para instanciar un objeto es necesario indicar los valores
iniciales de sus atributos cuando se ejecuta el método constructor. En la
clase Vehiculo se ha definido un método constructor que inicializa los
atributos matricula, marca, modelo, color y tarifa.

public class Vehiculo {

String matricula; this.matricula se refiere al
atributo del objeto
String marca;
String modelo;
String color;
double tarifa;
boolean disponible;

// El método constructor de la clase Vehiculo

public Vehiculo(String matricula, matricula se refiere al

parámetro del método
String marca,
String modelo,
String color,
double tarifa) {
this.matricula = matricula;
this.marca = marca;
this.modelo = modelo;
this.color = color;
this.tarifa = tarifa;
this.disponible = false;
}
}

55
Clases y objetos

A veces es necesario contar con diferentes métodos constructores con

distintos parámetros. Por ejemplo, se podría crear un objeto de la clase
Vehiculo sin conocer la tarifa de alquiler. El método constructor debería
inicializar la tarifa a cero.

public Vehiculo(String matricula,

String marca,
String modelo,
String color) {
this.matricula = matricula;
this.marca = marca;
this.modelo = modelo;
this.color = color;
this.tarifa = 0.0;
this.disponible = false;
}

Cuando se definen dos o más métodos constructores para la clase

Vehiculo, se dice que el método constructor de la clase está
sobrecargado. En este ejemplo la diferencia entre los dos métodos es que el
primero recibe cuatro parámetros e inicializa la tarifa a cero, el segundo
recibe cinco parámetros, uno de ellos para inicializar la tarifa del vehículo.

public Vehiculo(String matricula,

String marca,
String modelo,
String color)

public Vehiculo(String matricula,

String marca,
String modelo,
String color,
double tarifa)

56
 Fundamentos de programación en Java

La clase Vehiculo con dos métodos constructores.

public class Vehiculo {

private String matricula;
private String marca;
private String modelo;
private String color;
private double tarifa;
private boolean disponible;

public Vehiculo(String matricula,

String marca,
String modelo,
String color) {
this.matricula = matricula;
this.marca = marca;
this.modelo = modelo;
this.color = color;
this.tarifa = 0.0;
this.disponible = false;
}
public Vehiculo(String matricula,
String marca,
String modelo,
String color,
double tarifa) {
this.matricula = matricula;
this.marca = marca;
this.modelo = modelo;
this.color = color;
this.tarifa = tarifa;
this.disponible = false;
}
}

Java diferencia los métodos sobrecargados por el número y el tipo de los

argumentos que tiene el método. En la clase Vehiculo el número de
parámetros de los dos métodos constructores es diferente.

Cuando se invoca al método constructor de la clase con el operador new,

Java selecciona el método que debe ejecutar por el número y el tipo de
argumentos que recibe.

57
Clases y objetos

Creación de objetos de la clase Vehiculo utilizando ambos métodos

constructores.

Vehiculo vehiculo1 = new Vehiculo("4050 ABJ",

"VW",
"GTI",
"Blanco",
100.0);

Vehiculo vehiculo2 = new Vehiculo("2345 JVM",

"SEAT",
"León",
"Negro");

El objeto vehiculo1 se instancia ejecutando constructor de cinco

parámetros, mientras que vehiculo2 se instancia ejecutando el
constructor de cuatro parámetros.

58