Java Estructurado

El lenguaje Java
Marta I. Tarrés Puertas
P03/75063/00959
 FUOC • P03/75063/00959 2 El lenguaje Java
 FUOC • P03/75063/00959 El lenguaje Java
Índice
Introducción .............................................................................................. 7
Objetivos ..................................................................................................... 8
Bloque I. Java como lenguaje de programación estructurada ..... 9
1. Introducción ........................................................................................ 9
1.1. Origen del lenguaje .......................................................................... 9
1.2. Características del lenguaje ............................................................... 9
1.3. La máquina virtual Java (Java virtual machine) ................................. 10
1.4. The garbage collection (gestión automática de memoria) ................... 11
1.5. Seguridad en el código....................................................................... 12
1.5.1. La seguridad en Java. Resumen gráfico ................................. 14
2. Primeros pasos en Java ...................................................................... 16

2.1. Los comentarios en Java. Forma de introducirlos ............................ 17
2.2. Últimas observaciones ....................................................................... 17
3. Instalación de Java ............................................................................. 19

3.1. La compilación de un programa ...................................................... 19
3.2. La ejecución de un programa ........................................................... 20
4. Tipos de datos en Java ....................................................................... 23

4.1. Tipos simples .................................................................................... 23
4.2. Declaración de tipos ......................................................................... 24
4.3. Variables final ................................................................................... 25
4.4. Conversión de tipos o casting ........................................................... 25
4.5. Otros tipos ........................................................................................ 26
4.5.1. La clase String ......................................................................... 26
4.5.2. La clase StringBuffer ................................................................ 30
4.6. Palabras reservadas en Java ............................................................... 30
5. Operadores en Java ............................................................................. 32

5.1. Operadores aritméticos ..................................................................... 32
5.2. Operadores lógicos ........................................................................... 33
5.3. Operadores relacionales .................................................................... 34
5.4. Equivalencias .................................................................................... 34
6. Los condicionales ................................................................................ 36

6.1. El condicional if – else ....................................................................... 36
6.2. El condicional switch ........................................................................ 37
7. Los bucles .............................................................................................. 39

7.1. El bucle while .................................................................................... 39
7.2. El bucle do - while............................................................................... 39
7.3. El bucle for ........................................................................................ 40
7.4. Control de flujo en los bucles: break, continue, label ........................ 40
8. Procedimientos y funciones en Java: los métodos ...................... 42

8.1. Métodos predefinidos: el API ............................................................ 43
8.1.1. Paquetes básicos de la versión JDK ....................................... 44
8.2. Organización del API de JAVA .......................................................... 44
8.2.1. Opciones del API de Java ...................................................... 45
8.2.2. Estructura de la ayuda de un paquete ................................... 46
8.2.3. Estructura de la ayuda de una clase ...................................... 46
8.2.4. La página de uso .................................................................... 46
8.2.5. La jerarquía de clases ............................................................. 46
8.2.6. Los elementos obsoletos ....................................................... 47
8.2.7. El índice.................................................................................. 47
8.2.8. La ayuda ................................................................................ 47
8.3. Nomenclatura de los métodos de las clases del API ......................... 47
9. Entrada y salida en Java .................................................................... 49

9.1. Lectura de datos desde la línea de instrucciones .............................. 49
9.2. Lectura de datos desde el teclado ..................................................... 49
9.3. Escritura de datos .............................................................................. 51
9.4. Escritura en un archivo ..................................................................... 51
9.5. Lectura desde un archivo .................................................................. 51
10. Arrays y vectores en Java ............................................................... 52

10.1. Comparación array-Vector ........................................................... 53
10.2. Declaración y creación de arrays ................................................ 54
10.3. Ejemplo de uso de arrays ............................................................ 55
10.4. Declaración y creación de vectores ............................................ 55
Bloque II. Java orientado a objetos .................................................... 57
1. Tipos primitivos y objetos ................................................................ 57

1.1. La declaración de variables ............................................................... 57
1.2. El acceso a los métodos de las clases y los objetos ............................ 58
1.3. La asignación .................................................................................... 59
1.4. Las operaciones de comparación (equals) y copia (clone) ................. 59
1.5. El paso de parámetros ....................................................................... 60
2. Clases ...................................................................................................... 62
2.1. Definición con métodos ................................................................... 63
2.2. Estructura de una clase ..................................................................... 65
2.3. Sobrecarga de métodos ..................................................................... 67
2.4. Utilización de this ............................................................................. 70

2.5. Atributos estáticos ............................................................................ 73
2.6. Métodos static ................................................................................... 74
3. Relaciones entre clases ....................................................................... 75

3.1. Agregación ..................................................................................... 75
3.2. Asociación ...................................................................................... 75
3.3. Uso ................................................................................................. 76
3.4. Ejemplo de diseño de clases .......................................................... 76
3.5. Herencia simple ............................................................................. 80
3.6. La palabra reservada super ............................................................. 82
3.7. El operador instanceof ................................................................... 82
3.8. Redefinición de métodos ............................................................... 83
3.9. Visibilidad de atributos y métodos ................................................ 83
3.10. El modificador abstract .................................................................. 85
3.11. El modificador final ....................................................................... 85
4. Breve introducción a UML ................................................................ 86

4.1. El diagrama de clases ........................................................................ 86
4.1.1. El compartimento del nombre .............................................. 87
4.1.2. El compartimento de los atributos ........................................ 87
4.1.3. El compartimento de las operaciones ................................... 88
4.1.4. Las relaciones entre clases ..................................................... 88
Ejercicios de autoevaluación ................................................................. 93
Solucionario ............................................................................................... 96
Glosario ..................................................................................................... 117
Bibliografía .............................................................................................. 118

Introducción
Este módulo didáctico pretende introducir a los estudiantes en el mundo de la

programación con lenguaje Java. Partimos del supuesto de que habéis cursado
alguna asignatura de programación estructurada con un lenguaje de progra-
mación tipo Pascal o C, y ya conocéis las bases de dicha programación.
Este módulo didáctico se ha estructurado en dos bloques:
• Primeros pasos con Java o Java como lenguaje de programación estructurada.
• Java orientado a objetos.
En el primer bloque, “Java como lenguaje de programación estructurada”, se

pretende que los estudiantes conozcan la sintaxis del lenguaje Java (en cuanto
a tipo de datos y también en condicionales y bucles), aprendan a utilizar con
facilidad la biblioteca de procedimientos y funciones que aporta el lenguaje
(API de Java), conozcan los pasos que es preciso seguir para intercambiar in-
formación con los usuarios de las aplicaciones (mediante el teclado y archi-
vos), conozcan las estructuras estáticas y dinámicas del lenguaje y recuerden
aspectos de la programación modular que, seguramente, ya conocen.
Así, en este primer bloque trabajaréis los contenidos necesarios para poder uti-
lizar el lenguaje Java en el desarrollo de pequeños programas que interaccio-
nan con el usuario.
En el segundo bloque del módulo didáctico, se describen las características de

la programación orientada al objeto para poder entender y trabajar a fondo los
módulos teóricos de la asignatura y las relaciones entre clases, como por ejem-
plo la herencia y el polimorfismo.
La teoría se presenta siempre acompañada de una serie de ejemplos y ejerci-

cios, con las correspondientes soluciones, para facilitar el aprendizaje.
No me gustaría acabar esta introducción sin agradecer la colaboración de los

antiguos estudiantes de Fundamentos de programación II que, mediante sus du-
das, han hecho posible la mejora de aspectos docentes de la asignatura, y es-
pero que los futuros estudiantes encuentren en este documento una guía
válida para conocer el lenguaje Java.
Objetivos
Los materiales didácticos de este módulo proporcionan conocimientos funda-

mentales para que el estudiante alcance los siguientes objetivos:
1. Aprovechar las características del lenguaje Java, en cuanto a portabilidad,

gestión automática de memoria y seguridad en el código, para el desarro-
llo de aplicaciones siguiendo la filosofía de programación estructurada.
2. Obtener los códigos objeto a partir de los códigos fuente, utilizando las
herramientas que proporciona el entorno de desarrollo.
3. Obtener los códigos ejecutables a partir de los códigos objeto, con la uti-
litzación de librerías, utilidades y recursos.
4. Generar la documentación de un programa codificado en Java, utilizando

las herramientas que proporciona el entorno de desarrollo.
5. Conocer y utilizar la sintaxis del lenguaje Java, en relación con los tipos
de datos existentes y también con los operadores, sentencias condiciona-
les y bucles.
6. Definir y utilizar las estructuras estáticas y dinámicas necesarias para re-

solver problemas con el lenguaje Java.
7. Conocer y utilizar los métodos que permiten la interacción con el usua-

rio, mediante el teclado o archivo.
8. Comprobar que los formatos de entrada y de salida del programa y la fun-

cionalidad de los datos se ajustan a los parámetros definidos.
9. Utilizar correctamente los métodos que proporciona la librería del len-

guaje API de Java.
10. Conocer la sintaxis básica en Java de los elementos que permiten el uso
de la filosofía de programación orientada al objeto.
11. Implementar una aplicación utilizando las directrices de la programación

orientada al objeto con el lenguaje Java.
12. Diseñar aplicaciones utilizando el lenguaje UML.

Bloque I. Java como lenguaje de programación

estructurada
1. Introducción
1.1. Origen del lenguaje
Existen distintas versiones del origen del lenguaje Java, pero la más extendida
es la siguiente:
En 1991 James Goslingn, el creador de Java, llamó a este lenguaje OAK, porque
desde la ventana de su oficina de Sun Microsystems podía contemplar un gran
roble (oak, en inglés) .
Más tarde, el equipo de desarrollo de Java descubrió que Oak era el nombre de
otro lenguaje de programación y que, por lo tanto, era necesario encontrar otro.
Mientras se encontraban en una cafatería pensaron en llamarlo Java, que en Es-
tados Unidos es una forma coloquial de referirse al café. Esta es la explicación
del símbolo de Java: una taza de café humeante.
Java nació en mayo de 1995.
En cierto modo, se trata de un nuevo lenguaje simplificado de Sun basado en

objetos y sistemas abiertos, con el que los desarrolladores de software pueden
crear aplicaciones para distribuir en Internet mediante el Web (u otros medios).
Además, es un ordenador virtual (llamado técnicamente máquina virtual Java)
que permitirá que las aplicaciones basadas en Java sean omnipresentes, que pue-
dan ejecutarse en cualquier ordenador independientemente de su hardware y su
sistema operativo.
1.2. Características del lenguaje
La sintaxis del lenguaje de programación Java es similar a la sintaxis de C++,

y la semántica es parecida a la de SmallTalk. El lenguaje de programación Java
puede utilizarse para desarrollar cualquier tipo de aplicación, tanto si se trata
de applets como de aplicaciones.
Los applets son programas escritos en Java cuyo código se encuentra en los servidores web.
Se descargan mediante un navegador en el sistema cliente y son ejecutados por el navegador.
Normalmente los applets son de tamaño reducido con el fin de minimizar el tiempo de des-
carga y se llaman a partir de páginas HTML (hypertext markup language).
Las aplicaciones Java son programas independientes que no precisan navegador para
ejecutarse. Son programas de propósito general que pueden ejecutarse en cualquier má-
quina con un entorno de ejecución de Java instalado.
Los principales objetivos del lenguaje de programación Java, como describe el

manual oficial de Sun, son los siguientes:
• Facilitar un lenguaje de uso sencillo: eliminar la aritmética de punteros y

la gestión de memoria utilizada en otros lenguajes, adoptando la filosofía
de orientación al objeto.
• Permitir al usuario una forma concurrente de ejecutar programas.
• Soportar cambios dinámicos en tiempos de ejecución.
• Proporcionar más seguridad.
• Proporcionar un entorno interpretado (Java es un lenguaje interpretado),

y ello implica los siguientes beneficios:
– Velocidad de desarrollo: se elimina el ciclo compilación-enlace-carga-veri-

ficación.
– Portabilidad del código. Cuando se tiene un programa escrito en Java, pue-

de cogerse el archivo de código fuente, trasladarlo a cualquier tipo de orde-
nador y compilarlo. El compilador de Java es javac: sin variar ni una coma
del código fuente, sería de aplicación a todos los ordenadores para los que
exista un compilador de Java. Sin embago, este proceso, a pesar de ser muy
sencillo, no es necesario, puesto que el programa de Java es asimismo com-
pletamente portátil, o lo que es lo mismo, puede ejecutarse directamente
en cualquier tipo de ordenador.
Para resolver el problema que puede representar el hecho de que cada ordenador entienda
el código máquina de un modo distinto, Java introduce un nivel entre el programa eje-
cutable y el código máquina. Para hacerlo, Java introduce los conceptos de bytecodes y má-
quina virtual Java, que estudiaremos a continuación.
1.3. La máquina virtual Java (Java virtual machine)
La Java virtual machine specification define del siguiente modo la máquina vir-
Java virtual machine
tual de Java (JVM): specification...
... proporciona las especifica-

ciones de hardware necesarias
Una máquina imaginaria implementada mediante la emulación por para la tecnología Java. Esta es-
pecificación permite que el
software en una máquina real. El código para la JVM se almacena en ar- software en Java sea indepen-
chivos .class, y cada uno contiene, como mínimo, el código para una diente de la plataforma, puesto
que la compilación se lleva a
clase pública. cabo para una máquina gené-
rica conocida como JVM.
A partir del código fuente, el compilador genera bytecodes, instrucciones bina-

rias, muy parecidas al código máquina, que representan operaciones que debe
llevar a cabo un ordenador que no existe: la máquina virtual Java. Los bytecodes,
al no ser el código máquina de ningún ordenador concreto, sirven para cual-
quier arquitectura de hardware.
La máquina virtual Java es un programa que toma los ceros y unos represen-
tados en bytecodes, los traduce a código máquina y los ejectua en un ordenador
determinado. La JVM depende del tipo de ordenador; por lo tanto, existe una
para cada tipo de ordenador y no son compatibles entre sí.
La Java virtual machine specification proporciona definiciones muy concretas

para implementar lo siguiente:
• Conjunto de instrucciones (equivalente al de la CPU).

• Registros del sistema.
• Formato de los archivos de clases.
• Pila.
• Gestión automática de memoria (garbage-collected heap).
• Área de memoria.
Cualquier intérprete que sea compatible con la tecnología Java debe ser capaz
de ejecutar cualquier programa con archivos de clases que respeten el formato de
archivo de clase definido en la Java virtual machine specification.
No hay que confundir la JVM con un intérprete de un lenguaje de alto nivel: la entrada
de la máquina virtual son bytecodes y la salida, código máquina; la entrada de un intér-
prete son instrucciones del lenguaje, y la salida, código máquina.
La JVM es una pequeña CPU emulada que toma los bytecodes compilados en Java y los
transforma en código máquina: es un ordenador dentro de nuestro ordenador (de ahí su
nombre). Esto conlleva ventajas evidentes: los programas son totalmente portátiles, el ries-
go de que el ordenador se cuelgue es nulo, y el ordenador no puede ser infectado por nin-
gún virus, puesto que de la JVM no puede salir nada que sea perjudicial para el sistema.
1.4. The garbage collection (gestión automática de memoria)
Buena parte de los lenguajes de programación permiten reservar memoria en

tiempo de ejecución. El proceso de reserva de memoria varía según la sintaxis
del lenguaje, pero siempre implica el regreso de un puntero al principio del
bloque de memoria reservado.
Cuando la memoria reservada deja de necesitarse, el programa o el entorno de

ejecución deben liberarse.
En C, C++ y otros lenguajes, el programador es responsable de la gestión de

liberar memoria. Esta tarea es a veces compleja, porque no siempre se sabe a
priori cuando se puede liberar la memoria. Los programas que no liberan me-
moria no utilizada pueden generar errores de ejecución cuando ya no queda
memoria disponible en el sistema. Se dice que estos programas tienen pérdidas

de memoria (memory-leaks).
El lenguaje de programación Java libera al programador de la responsabili-

dad de liberar memoria. El lenguaje Java proporciona un proceso en ejecu-
ción, en el ámbito del sistema, que rastrea las operaciones de reserva de
memoria. Durante los ciclos muertos de la máquina virtual Java, el proceso
de garbage collection comprueba qué memoria puede liberarse y la libera.
El proceso de garbage collection se realiza automáticamente durant el ciclo de

vida de un programa en Java, elimina la necesidad de liberar memoria y evita
pérdidas.
1.5. Seguridad en el código
La figura siguiente muestra el entorno de ejecución de la tecnología Java, y

como dicho entorno, fuerza la seguridad del código ejecutado:
Los archivos de código fuente en Java se compilan, se convierten a un conjun-

to de bytecodes a partir de los archivos de texto escritos por el programador.
El resultado de la compilación se guarda en archivos con extensión .class.
En el momento de la ejecución, los distintos archivos de bytecodes que integran

el programa a ejecutar se cargan, se verifican y se ejecutan en el intérprete. La
función del intérprete es doble: ejecuta los bytecodes y gestiona las llamadas al
hardware del sistema.
En ciertos entornos de ejecución Java, una parte de los bytecodes verificados se

compila a código máquina nativo y se ejecuta directamente en el hardware.
Esto permite que el hardware escrito en Java alcance velocidades de ejecución
similares a la de los lenguajes C o C++, aunque siempre será preciso tener en
cuenta el pequeño retraso que provocará la etapa de compilación en el mo-
mento de cargar la aplicación.
La seguridad de un sistema mide la posibilidad de que le afecten errores en el

diseño de aplicaciones o diseños malintencionados (virus). Además de contro-
lar los virus, també es preciso controlar los errores involuntarios que puedan
perjudicar al sistema.
Los programadors de C/C++, que conocen perfectamente la potencia de ambos lenguajes,

también conocen la facilidad con que se despistan los punteros, con lo que pueden pro-
vocarse efectos no deseados.
La base de la seguridad en Java es que las aplicaciones se ejecutan en la máqui-

na virtual Java y no acceden a otros recursos del ordenador. Para conseguirlo,
existen cuatro niveles de seguridad establecidos:
• El lenguaje. Si el lenguaje no permite acceder al disco duro, evidentemente,

debería crearse un lenguaje completamente seguro, pero a la vez completa-
mente inútil: el lenguaje quedaría limitado a cuatro operaciones básicas.
Java intenta ser lo más seguro posible, sin limitar las posibilidades que ofre-
ce. Por ello, se aparta de C/C++ (que es la referencia natural de Java) en dos
cuestiones que pueden ser claves para la seguridad: el uso de punteros y la
asignación a memoria.
• El cargador de clases carga todas las clases necesarias para la ejecución de

un programa. Cuando se han cargado, hay que determinar el mapa de me-
moria de la aplicación, y en este momento se asignan direcciones de memoria
reales a las referencias simbólicas del código, y se cumplimenta la tabla de
asignación de memoria. Puesto que el proceso de asignación de memoria
se lleva a cabo en el momento de la ejecución, el intérprete de Java protege
contra cualquier acceso no autorizado a las áreas de código.
Durante la ejecución de una aplicación en Java, ésta puede llamar a deter-

minadas clases, que pueden provenir de tres localizaciones distintas: el or-
denador local, la red de área local o Internet. Según el origen, se llevarán a
cabo una serie de comprobaciones distintas: el nivel de exigencia, lógica-
mente, es mayor para las clases procedentes de Internet.
• El verificador de bytecode. El código de Java se verifica mediante varios

tests antes de ejecutarse en la máquina con el fin de comprobar que el có-
digo siga las especificaciones de la JVM y no repercuta negativamente en la
integridad del sistema. Cuando se han superado estos tests, podemos estar
seguros de los siguientes aspectos:
– Las clases tienen formato de archivo de clase de la especificación de la JVM.

– No existen violaciones de acceso restringido.
– El código no provoca desbordamientos de la pila.
– El tipo de parámetros para todo el código es correcto y no se modificará du-
Ejemplo
rante la ejecución.
No se convierten enteros
– No hay conversiones ilegales de datos. a punteros a objetos.
– Los accesos a los campos de los objetos están autorizados.
Aunque es muy difícil, es posible desarrollar un compilador para generar bytecodes que
puedan saltarse las especificaciones de seguridad introducidas en el ámbito del lenguaje.
Entonces, podría lanzar un conjunto de bytecodes que enmascararan operaciones peligro-
sas para el sistema. Para evitarlo, la JVM verifica los bytecodes antes de ejecutarlos: analiza
su formato y comprueba que no existen punteros y el acceso a los recursos del sistema
mediante los objetos de Java, entre otros.
Este proceso de verificación implica que la ejecución sea más lenta, pero cuando se han
garantizado los puntos anteriores, la JVM funciona mucho más rápido.
• La API. La última barrera defensiva se constituye por el conjunto de méto-

dos y clases necesarios para acceder a los recursos del sistema. Éstos se di-
señan de modo que llevan a cabo muchas comprobaciones al llamarlos, y
ello dificulta los errores voluntarios e involuntarios.
Antes de hablar de Java como lenguaje seguro, es preciso tener en cuenta que
la seguridad de un sistema es inversamente proporcional a su grado de apertu-
ra: no puede existir un sistema completamente seguro y abierto a todo el mun-
do. Java es un lenguaje abierto a todo el mundo que permite la ejecución de
programas muy distintos con la incorporación –mediante Internet– de clases
que pueden hallarse a miles de quilómetros de distancia y de las que no cono-
cemos su autor. La seguridad que proporciona Java está en el hecho de que
ejectua los programas en la JVM, de la que es muy difícil salir.
1.5.1. La seguridad en Java. Resumen gráfico
Un entorno de ejecución de código Java ejecuta el código compilado por una

JVM y realiza tres tareas principales:
El lema de Java es “write once, run everywhere”.

2. Primeros pasos en Java
Lo primero que hay que saber para programar en Java es que cualquier progra-
ma, independientemente de su simplicidad, tiene los siguientes elementos:
import ....
public class Programa {
public static void main (String args[ ]) {
// cuerpo del programa
}
}
Analizemos detalladamente este esquema de programa:
Cualquier programa que creemos será una clase (class) con una serie de variables
que se inicializarán (atributos) y procedimientos y funciones (métodos).
* Podemos encontrar programas
que no contengan la sentencia
Cualquier programa deberá trebajar con métodos propios de la librería que import, porque existen métodos
que el compilador ya sabe donde
debe ir a buscar directamente, y no
proporciona Java (API) y, por lo tanto, deberá importarlos con la sentencia será preciso utilizarla.
import*.
Podemos encontrar el nombre args con las formas argv, params, etc., aunque,
por convención, se utiliza generalmente args o argv.
La definición String args[ ], o lo que es lo mismo, String[ ] args, sirve para alma-
cenar los parámetros que siguen a la ejecución del programa.
Ejemplo
Nota
Tenemos el siguient programa:
Podemos saber cuántos pará-
public class Prueba (String args[]) { metros se han intorducido
// cuerpo del programa consultando args.length.
} Si el resultado es 0, significará
que no se ha introducido nin-
Lo primero que hay que hacer es compilar el programa con la sentencia javac prueba.java. gún parámetro. El resultado
de consultar args.length en
Como resultado de la compilación, se habrá creado un archivo prueba.class que ya puede
el ejemplo anterior es 3 porque
ser ejecutado por el intérprete de Java del siguiente modo: se han introducido tres pará-
metros.
java Prueba Observad que args se inicializa
con el índice 0.
Si hacemos:
java Prueba parametro1 parametro2 parametro3
Haremos que se inicie el array de strings del siguiente modo:
args[0] contendrá parametro1

y así sucesivamente.
Así, pues, puede accederse a los parámetros entrados por la línea de instruccio-
nes. Estos parámetros pueden ser números enteros, reales, caracteres, etc., y siem-
pre se leerán como strings. La conversión correspondiente (de String a entero, a
real, etc.) se realiza dentro del programa.
En el apartado “Entrada/salida en
Java” de este mismo módulo
didáctico se presentan otras formas
de introducir datos en un programa.
Ejemplo
El programa siguiente toma dos números entrados por la línea de instrucciones y los suma:
public class Suma {

public static void main(String[] args) {
int x;
int y;
int sum;
x = Integer.parseInt(args[0]); // Conversión de String a entero
y = Integer.parseInt(args[1]);
sum = x + y;
System.out.println("La suma de "+ x +" i "+ y +" es "+ sum);
}
}
El programa siguiente escribe las letras que se han entrado por la línea de comandos en
sentido contrario:
public class AlReves {

int i = args.length;
while (i != 0) {
for (int j = args[i - 1].length() - 1; j >= 0; j--)
System.out.print(args[i - 1].charAt(j));
System.out.print(" ");
i--;
}
System.out.println();
}
}
public –Indica que el método main() es de acceso público para todo el mundo, incluido el Las palabras reservadas public,
static, void y class se analizan
intérprete de Java. en profundidad en la segunda parte
static –Indica al compilador que el método main() es el primero que debe ejecutarse. de este módulo didáctico.
void –Indica que el método a que se refiere no devuelve ningún parámetro.
class –Significa ‘clase’. Cualquier programa en Java es una clase.
2.1. Los comentarios en Java. Forma de introducirlos
Existen tres formas de introducir comentarios en un programa de Java: Los comentarios de documentación
son generados por la instrucción
javadoc, que se explica en el apartado
“La generación de la documentación”.
• // comentario en una línea
• /* comentario en una o más líneas */
• /** comentario de documentación */
2.2. Últimas observaciones
Comparado con C, Java no tiene preprocesador y, por lo tanto, el uso de las

directivas del tipo #ifdef y #define no tiene sentido.
En Java no existe diferencia entre declaración y definición: el archivo que con-

tiene la clase también contiene la declaración de interfaz y la implementación.
En éste, #include pasa a ser import, que no incluye ningún archivo, sino que in-
Trataremos los paquetes en el
dica dónde se encuentra el paquete (package) con las clases que nos interesan. apartado “Métodos predefinidos: el
API”, de este mismo módulo didáctico.
Después de ver cómo se lleva a cabo un programa simple, estudiaremos cómo

se compila y ejecuta, y analizaremos los tipos de datos com los que trabaja Ja-
va, los operadores y la sintaxis de las estructuras condicionales y los bucles.
3. Instalación de Java
3.1. La compilación de un programa
Una vez creado el archivo NombrePrograma con la extensión .java, la compila-

ción se lleva a cabo mediante esta instrucción:
javac NombrePrograma.java
javac [opciones] NombreFichero1.java [Nombre2.java...]
A continuación recogemos algunas de las opciones disponibles:
• -classpath path: permite especificar el directorio en el que se buscarán

las clases necesarias para ejecutar javac y otras clases referenciadas por las
clases que compilamos.
• -d directory: permite especificar el directorio raíz de la jerarquía de cla-

ses y deposita en él los archivos compilados.
• -g: indica al compilador que genere tablas de depuración para facilitar in-
formación al depurador.
• -deprecation: genera un aviso cuando utilizamos una clase o miembro

desaprovado (deprecated).
• -nowarn: desactiva los avisos (warnings).
• -O: aplica optimización independiente de la plataforma.
• -verbose: muestra mensajes sobre los archivos que se compilan y los que
se cargan.
• -depend: recopila las clases de las que depende nuestro código.
Ejemplo
Supongamos que hemos creado el siguiente programa:
public class NombrePrograma {

public static void main(String args[]) {
// cuerpo del programa
}
}
Este programa deberá guardarse en un archivo llamado NombrePrograma.java.
Para que pueda ser compilado será necesario lo siguiente:
javac NombrePrograma.java
Si el compilador no devuelve ningún mensaje, se generará automáticamente un archivo

NombrePrograma.class, que podrá ser intepretado por el intérprete de Java.
Si se da algún error compilando la aplicación, aparecerá un mensaje por pantalla del error
producido, que deberá solucionarse. Por ejemplo:
In class NombrePrograma: main must be public and static
Este error se debe a que se han olvidado las palabras static o public en la línea que contiene
la declaración del método main.
3.2. La ejecución de un programa
Para ejecutar la aplicación que hemos creado, es preciso utilizar el intérprete

javaw y java_g
de Java, java, que se encuentra en el mismo directorio que el compilador.
javaw y java_g son variantes
del intérprete java.
java NombrePrograma javaw ejecuta sin que aparezca
la ventana de instrucciones, y
java_g ejecuta sin optimización.
java. Intérprete de Java. Ejecuta los códigos byte producidos por el compila-
dor, o sea, archivos .class.
java [ options ] classname <args>
Las opciones disponibles para todas las plataformas son las siguientes:
• -classpath path: permite especificar el directorio al que se van a buscar

las clases necesarias para ejecutar y otras clases referenciadas por las clases
que ejecutan.
• -D variable = valor: modifica el valor en una de las variables del sistema.
• -jar: permite ejecutar todo un programa encapsulado en un archivo JAR.

Con esta opción solo se utilitzarán clases dentro del JAR.
• -version: muestra información de la versión.
• -help: muestra un mensaje informativo sobre el uso del programa.
• -verbose: muestra un mensaje cada vez que se carga un archivo class.
• -X: muestra información sobre las opciones no estándar.
En el cas de crear programas para ejecutarlos como miniaplicaciones:
appletviewer. Visor de miniaplicaciones. Permite ejecutar miniaplicaciones

sin un navegador a partir del URL (uniform resource locator) del archivo. Por lo
tanto, toma como entrada un archivo HTML.
appletviewer [ opciones ] urls

Las opciones disponibles son las siguientes:
• debug: inicia la miniaplicación visualizadora dentro del depurador y per-

mite depurar las miniaplicaciones en el archivo HTML.
• encoding name: especifica el nombre codificado del archivo de entrada

HTML.
Ejemplo de error de ejecución
Can’t find class NombrePrograma
En general, esto significa que el nombre de la clase de la línea de comandos es distinta

que el del archivo NombrePrograma.class.
El lenguaje de programación Java distingue entre mayúsculas y minúsculas (es

case sensitive) y el nombre del archivo debe coincidir con el de la clase.
3.3. La generación de la documentación
javadoc. Generador de documentación. A partir del código fuente de un pro-

grama, genera documentación de todas las clases que lo integran, en un archi-
vo de texto, normalmente en formato HTML.
Los comentarios que el analizador busca en el código fuente están en bloques

que empiezan por “/**” y acaban por “*/”.
Existe un conjunto de indicadores que javadoc reconoce como especiales y que

Ejemplos
empiezan por @.
Algunos de los indicadores
que javadoc reconoce como
La utilidad de los indicadores está en el hecho que permiten decidir si la in- especiales son:
-- @author
formación que los acompaña debe figurar en el archivo de documentación
-- @version
generado. -- @deprecated
javadoc [ opciones ] [ package | fichero.java ]*
Uno de los grandes cambios que presenta el javadoc 1.2 es que el formato de
la documentación que saldrá está definido en unas clases especiales, los
doclets.
JDK (Java development kit) proporciona un doclet que genera documentación en formato
HTML, pero pueden definirse doclets que generen documentaciones en formato XML,
SGML, RTF y MIF.
Las opciones disponibles son las siguientes:
• -public: sólo muestra clases y miembros públicos.
• -protected: sólo muestra clases y miembros protegidos.

• -private: sólo muestra clases y miembros privados.
• -package: sólo muestra paquetes y clases, y miembros públicos y protegidos.
• -classpath path: permite especificar el directorio en el que se buscarán

las clases necesarias para ejecutar javadoc.
• -d directory: especifica el directorio en el que se dejan los archivos

HTML generados.
• -notree: ignora la jerarquía clase/interfaz.
• -noindex: ignora el índice del paquete.
• -verbose: genera mensajes al cargar el código fuente que especifican el

número de milisegundos para tratar cada archivo fuente.
• -sourcepath path: especifica donde hay que buscar los archivos fuente.
• -nodeprecated: excluye párrafos con el indicador @deprecated.
• -version: incluye los indicadores @version.
• -author : incluye los indicadores @author.
• -encoding name: especifica el nombre codificado del fuente.
• -docencoding name: especifica el nombre codificado del archivo HTML Volveremos sobre esta opción
en la segunda parte de este módulo
generado. didáctico.
• -doclet name: especifica el doclet que desea utilizarse en la creación de la

documentación.
4. Tipos de datos en Java
Java permite declarar variables que almacenen información durante la eje-

cución de un programa. Todas las variables en Java tienen un tipo, un nom-
bre y un ámbito (el ámbito determina cuando es accesible y cuando se crea
y se destruye).
4.1. Tipos simples
Los tipos simples que permite declarar Java son los siguientes:
• Tipos enteros
– byte: valor entero de 8 bits (-27..27-1) Ejemplos de declaración

de variables enteras
– short: valor entero de 16 bits (-215..215-1)
– int: valor entero de 32 bits (-231..231-1)
int x,y;
x = 6; y = 100;
– long: valor entero de 64 bits (-263..263-1)
Las constantes enteras se consideran de tipo int, siempre y cuando no vayan

seguidas de la letra L. La L indica un valor long.
Todos los tipos enteros en Java son números con signo.
Ejemplos
2L: el valor decimal dos como tipo long.

077L: el cero inicial indica que es un valor en notación octal.
0xBAACL: 0x indica un valor en hexadecimal.
• Números en coma flotante (reales)
– float: precisión simple, utiliza 32 bits (3.4E-038 a 3.4E+038) Ejemplos de declaración

de variables en coma
– double: precisión doble, utiliza 64 bits (1.7E-308 a 1.7E+308)
flotante
float z = 3.1416f;
Se dice que una constante es en punto o coma flotante si incluye un punto
double w = 3.1416;
decimal, una parte exponencial (indicada por la letra E o e) o si va seguida de
la letra F o f (float) o de la letra D o d (double).
En otros lenguajes...
Ejemplos:
... el volumen y el formato de los
3,14: número real simple (double) tipos de datos primitivos puede
6.02E23: número real grande depender de la plataforma don-
2.718F: valor real de volumen float de se ejecuta el programa. En Ja-
va, el lenguaje especifica el
Ejemplos de asignaciones incorrectas: volumen y el formato de los ti-
pos de datos primitivos y, por lo
tanto, el programador no debe
i = 3,1416; // 3,1416 no es un entero preocuparse de las dependen-
w = 175,0000; // No es una coma, sino un punto cias del sistema.
z = 3,1416; // Un double no cabe en un float
• Caracteres
char: almacena un carácter alfanumérico
Las variables de tipo char deben ir entre comilla simple.
Ejemplos:
char ch = ’a’;
char ch2 = ’\t’; // Un tabulador
Un conjunto de caracteres se representa mediante la clase String (no es un tipo

simple). A diferencia de C/C++, las cadenas de texto no acaban con \0.
• Booleano
boolean: con dos valores posibles (true y false)
No hay conversión entre tipo entero y tipo booleano. Algunos lenguajes,

como C y C++, permiten interpretar valores numéricos como lógicos conside-
rando el cero como false y diferente de cero como true. Java no lo permite.
Ejemplo
int i = 1;
if (i) // Error de compilación
if (i! = 0) // Correcto
4.2. Declaración de tipos
Por convención, en Java el nombre de las variables empieza por una letra mi-
núscula. Si un nombre de variable tiene más de una palabra, éstas se unen y
cada una, menos la primera, empieza con una letra mayúscula (isVisible ). En
los nombres de clase, en cambio, todas las palabras empiezan con mayúscula.
El nombre de la variable va precedido de su tipo y puede inicializarse en la pro-

Java y C/C++
pia declaración.
A los programadores en
C/C++, los tipos de variables
Ejemplo empleados en Java les parece-
rán los que éstos utilizan, pero
int count = 0; // Se define una variable llamada count que es de hay que tener en cuenta que
en Java no existen tres tipos
// tipo int y que se inicializa en 0. de datos que sí aparecen en
String[] args; // Se define una variable llamada args que es un C/C++: los punteros, las unio-
// array de strings. nes (union) y las estructuras
byte s; de datos (struct).
char w;
char m = 'r';
char cambio_de_linea = '\n';
float d2 = 5.67f;
double d = .53316;
boolean booleano = true;
La declaración de una variable en Java es tipo variable.

4.3. Variables final
Existen variables cuyo valor no puede modificarse después de inicializarse: son

las variables final y pueden verse como las constantes de otros lenguajes de
programación.
Para declarar una variable como final, se utiliza la palabra reservada final de-
lante del tipo.
Ejemplo
Si tenemos una definición como la siguiente:
final int variable = 0;
hacer algo como lo siguiente:
final int variable = 0;

...
variable = 5;
daría lugar a un error de compilación.
4.4. Conversión de tipos o casting
La conversión de tipos es precisa en el momento en que se intenta convertir

un tipo a otro que ocupa menos espacio.
Para llevarla a cabo, debe igualarse la nueva variable a la antigua, incluyendo

el operando detrás = y el nuevo tipo al que debe convertirse.
Ejemplo
int a = 2;
byte b;
b = (byte) a;
La conversión de tipos es el proceso que consiste en tomar una variable de-

clarada como un tipo e indicar al compilador que deseamos tratarla como
otro tipo. La conversión de tipos puede realizarse tanto con tipos primitivos,
como int o float, como con tipos de objetos, por ejemplo java.lang.Object y
java.lang.String.
Sintaxis de la conversión de tipos
(datatype) expression
donde datatype es el nuevo tipo como deseamos que se trate el valor de la expresión.
En el caso de tipos primitivos, la conversión de tipos es necesaria cuando cam-

biamos entre tipos de datos y existe la posibilidad de perder información.
Ejemplo
Si tenenos un int y queremos tratarlo como un double, no es necesario realizar una con-
versión de tipos porque un double contiene todo el rango de valorse del int.
O sea, podría hacerse:
int i = 2;
double d = i;
No obstante, para ir en dirección contraria, es precisa la conversión de tipos. El rango de

números posibles para un double es superior que per a un int; por lo tanto, siguiendo el
ejemplo anterior, sería necesaria una conversión de tipos:
double d = 2.0;
int i = (int) d;
Las variables pueden convertirse automáticamente cuando no se pierde infor- La conversión de tipos también es
precisa en el trabajo con objetos,
como en la segunda parte de este
mación en la conversión. módulo didáctico.
Ejemplo
long valor = 6; // 6 es un int. Correcto

int valor2 = 99L // 99L es un Long. Incorrecto
double z = 12.414F; // 12.414F es un float. Correcto
float z1 = 12.414; // 12.414 es un double. Incorrecto
4.5. Otros tipos
A diferencia de otros lenguajes, Java contiene otros tipos especificados en las En Java también hay los tipos
de referencia (arrays, clases
clases que se incluyen en el JDK; como la clase String que, en realidad, no es e interfaces).
Los arrays se estudian en el apartado
“Arrays y vectores”, y las clases y las
un tipo, sino una clase que se utiliza en los programas, que facilita la progra- interfaces, en la segunda parte de este
módulo didáctico.
mación aportando métodos preexistentes que permitirán, por ejemplo, calcu-
lar automáticamente la longitud de una cadena o modificar el contenido del
carácter i-ésimo de una cadena por otro carácter, pero puede utilizarse como
un tipo básico en muchos aspectos.
Con el fin de llevar a cabo la gestión de cadenas, el paquete java.lang contiene

las clases String y StringBuffer, que estudiaremos a continuación.
4.5.1. La clase String
Las cadenas serán el tipo de datos que utilizaremos para comunicar nuestras
aplicaciones con los dispositivos de lectura y escritura de datos: el teclado y la
pantalla.
Una variable de tipo String puede interpretarse como un vector de caracteres.

Existen distintas operaciones que podemos llevar a cabo sobre strings:
• Declarar una variable de tipo String (de hecho, de la clase String).
Ejemplo
String prueba;
• Asignar un valor a un String.
Hay dos métodos para asignar valores a los strings:
– Se crea un String con el operador new:
String cad = new String ();
y después se le asigna un valor:
cad = "cadena";
– Se llevan a cabo ambas operaciones a la vez (String cad = "cadena";).
Puede comprobarse que el resultado de ambos métodos es el mismo si se hace

lo siguiente:
System.out.println(cad);
• Concatenar strings.
La concatenación puede realizarse de modo sencillo:
String cad = " Tengo " + num + "hermanos";
También puede hacerse mediante la clase StringBuffer:
String cad = new StringBuffer ("Tengo") num es un número entero.
.append(num)
.append("hermanos")
.toString();
• Realizar conversiones implícitas de otros tipos a strings.
Ejemplo
Supongamos que tenemos una variable x de tipo int, cuyo valor es 5.
Después de hacer
prueba = "El valor de x es " + x;
el String prueba valdría "El valor de x es 5".
En esta asignación, se interpreta que el resultado final debe ser un String. Por ello, ope-
rando x de la concatenación se convierte implícitamente a String.
• Conocer la longitud de un String.
Ejemplo
prueba = "Hola."; int l = prueba.length();
Después de ejecutar las sentencias anteriores, el valor de l será 5.

• Llevar a cabo conversiones explícitas de strings a otros tipos de datos. Para

ello, es necesario que el String contenga un vector de caracteres interpreta-
ble como un dato del tipo al que queremos convertir.
Ejemplo
Si prueba = "385", haciendo int x = Integer.parseInt(prueba) convertimos el

valor de prueba a un entero y tendremos el valor int 385 en la variable x.
Si la misma sentencia se hubiera ejecutado con el valor prueba = "Hola", habríamos

observado un error de ejecución del programa indicando que el contenido de la variable Nota
prueba no puede interpretarse como un enter:
El tipo de datos carácter se
java.lang.NumberFormatException: Hola define entre comilla simple
y el tipo de datos String, con
at java.lang.Integer.parseInt(Integer.java)
comilla doble.
at java.lang.Integer.parseInt(Integer.java)
at Programa.main(Suma.java:11)
• Extraer caracteres de la cadena
El primer modo es referirse a un caracter indexado de la cadena:
char c = cad.charAt(0); // Obtiene el primer carácter de la

cadena cad
La segunda forma es mediante getChars:
char str[] = new char[end-start];

cad.getChars(start, end, str, 0);
Siendo el caracter en la posición start el primer caracter de la cadena; el que

está en la posición end, el último, y str la cadena donde debe almacenarse la
extracción, empezando, en este caso, desde la posición cero.
Una función interesante es toCharArray, que devuelve una matriz de caracteres

con la cadena completa. Igualmente, getBytes coloca los caracteres en una ma-
triz de bytes, descartando el byte más significativo; exactamente con las mis-
mas características que getChars.
• Comparar strings
Los strings no pueden compararse utilizando operadores relacionales conven-

cionales.
Ejemplo
Después de ejecutar lo siguiente, el valor de la variable x será 2:
String s1 = "Hola";
String s2 = "Hola";
int x;
if (s1 == s2) x = 1; else x = 2;
Se lleva a cabo mediante equals y equalsIgnoreCase, y el segundo se diferencia

del primero porque distingue entre consonantes y vocales.
Ejemplos
boolean a = cad1.equals(cad2) // devuelve true si cad1 es

// idéntica a cad2
boolean a = cad1.equalsIgnoreCase(cad2) // devuelve true si cad1
// es idéntica a cad2, sin diferenciar mayúsculas y minúsculas
Mayor o menor que
Se lleva a cabo mediante compareTo, que devuelve un número que puede ser
el siguiente:
−1: cadena menor que parámetro.

0: cadena igual a parámetro.
1: cadena mayor que parámetro.
Ejemplo
int a = cad1.compareTo(cad2) // donde cad1 es la cadena y cad2 es

// el parámetro. a puede ser -1, 0 ó 1
• Buscar caracteres
Buscar un carácter o subcadena determinados en una cadena concreta, se lleva

a cabo mediante indexOf o lastIndexOf, según si se empieza por el principio o
por el final.
Ejemplos
int indexOf(int char);

int lastIndexOf(int char);
Devuelve el índice de la primera aparición del carácter char. Si en lugar de un carácter se

indica una cadena (String cad), devuelve el índice del primer carácter de la primera apari-
ció de la subcadena cad.
int indexOf(int char, int desdIndex)

int indexOf(int char, int desdIndex)
Tanto si se trata de un carácter como de una cadena, puede indicarse a partir

de donde se empieza a mirar con desdIndex.
Modificadores de copia de cadenas
• Subcadenas. Puede extraerse un fragmento de una cadena del modo si-

guiente:
String subcad = cad.substring(x,y); // donde x e y serán

// inicio y final de los caracteres incluidos en subcadena.
• Concatenación de cadenas. Se lleva a cabo mediante concat:
"Hola".concat(" a todos.") "Hola a todos."
• Reemplazar: para sustituir caracteres. Se realiza mediante replace:
"Jaba".replace('b','v') "Java"
• Convertir a mayúsculas o minúsculas. Se lleva a cabo, respectivamente,

con toUpperCase() y toLowerCase().
4.5.2. La clase stringBuffer
La clase StringBuffer es una clase gemela de String, que añade funcionalidades a

la clase String.
• Para crear una cadena StringBuffer hacemos lo siguiente:
StringBuffer str = new StringBuffer ("Cadena");
• Puede conocerse el espacio total asignado a la cadena mediante capacity().
ensureCapacity sirve para conocer la dimensión del buffer.
• Puede conocerse la longitud de la cadena mediante length().
Para establecer la longitud exacta del valor String en un buffer, se utiliza la senten-
cia setLength(nuevaLongitud).
• Para obtener el carácter que tiene como índice el número, se utiliza

cad.charAt(número).
• Para cambiar el carácter se utiliza setCharAt(número, nuevo_carácter).
4.6. Palabras reservadas en Java
Las palabras reservadas tienen un significado especial para el compilador de Ja-

va: identifican el nombre de un tipo de datos o de una construcción de pro-
grama. Las palabras reservadas en Java son las siguientes:
abstract do implements private throw
boolean double import protected throws
break else instanceof public transient
byte extends int return true
case false interface short try
catch final long static void
char finally native super volatile
class float new switch while
continue for null synchronized
default if package this

Los literales true, false y null es escriben con minúscula, y no con mayúscula como en el
lenguaje C++.
El operador sizeof no existe; el volumen y la representación de todos los tipos es fijo y no

depende de la plataforma.
goto y const son palabras reservadas que no tienen ninguna aplicación en el lenguaje Java.
5. Operadores en Java
Java, como otros lenguajes de programación, incluye los siguientes tipos de

operadores:
• Operadores aritméticos
• Operadores lógicos
– Operadores de bit
– Operadores lógicos booleanos
• Operadores relacionales
5.1. Operadores aritméticos
Los operadores aritméticos permiten realizar las siguientes operaciones:
Operador Uso Resultado
+ op1 + op2 Suma op1 y op2.
Resta op2 de op1. También sirve para realizar los cambios de

- op1 - op2
signo.
* op1 * op2 Multiplica op1 por op2.
/ op1 / op2 Divide op1 entre op2.
% op1 % op2 Retorna el residuo de dividir op1 entre op2.
++ op++ Incrementa en 1 op.
-- op1-- Decrementa en 1 op.
...
int a,b;
a = 3;
b = 6;
suma = a+b; resta = a-b; multip = a*b; divent = a/b;
System.out.println("La suma es" + suma);
System.out.println("La resta es" + resta);
System.out.println("La multiplicacion es" + multip);
System.out.println("La division entera es" + divent);
if (a%2 == 0) System.out.println("El numero es par");
a++;
b--;
...
Al utilizar el operador suma, hay que tener presente que, cuando los dos ope-
randos son de tipo numérico y primitivo, el resultado es, al menos, un int y
tiene como valor el calculado después de convertir los dos operandos al tipo
del resultado o de convertir el resultado al tipo mayor entre los operandos.

Esto puede provocar situaciones de desbordamiento:
Ejemplo
short a, b, c;
a = 1;
b = 2;
c = a+b;
// Error !!!
c = (short)(a + b);
// Correcto
5.2. Operadores lógicos
Existen dos tipos de operadores lógicos:
• Operadores lógicos de bit que pueden modificar e inspeccionar los bytes

que integran los valores de los tipos numéricos siguientes: long, int, short,
char y byte.
Operador Resultado
~ NOT unari de bit
& AND de bit
| OR de bit
^ OR exclusivo de bit
&= AND de bit y asignación
|= OR de bit y asignación
^= OR exclusivo de bit y asignación
>> desplazamiento a la derecha
>>> desplazamiento a la derecha llenando con ceros
<< desplazamiento a la izquierda
>>= desplazamiento a la derecha y asignación
>>>= desplazamiento a la derecha llenando con ceros y asignación
<<= desplazamiento a la izquiera y asignación
Ejemplo
1010 >> 2 da 111010

1010 >>> 2 da 001010
−256 >> 4 da -256/24 = −16
16 << 2 da 16 * 4 = 64
• Los operadores lógicos booleanos que operan únicamente sobre operandos

booleanos. Combinan dos valores booleanos para devolver un booleano.
Decimos que dos operadores están en cortocircuito cuando el primero ya decide el resul-
tado. En este caso, Java no consulta el segundo operando.
Ejemplo
cierto OR cierto =
El primer cierto ya definirá el resultado como cierto.
Operador Resultado
&& AND lógico
|| OR lógico
^ XOR lógico
== igual a
!= distinto de
! NOT unario lógico
Ejemplos
...
int a,b;
...
if ((a>0)&&(a<10)) System.out.println("El número está entre 0 y 10");
else if ((a < 0) || (a == 0))
System.out.println("El número está en el lado de los negativos");
....
if (b! = 0) System.out.println("Número distinto de 0");
...
5.3. Operadores relacionales
Operador Uso Resultado
> op1 > op2 Cierto si op1 es mayor que op2.
>= op1 >= op2 Cierto si op1 es mayor o igual que op2.
< op1 < op2 Cierto si op1 es menor que op2.
<= op1 <= op2 Cierto si op1 es menor o igual que op2.
== op1 == op2 Cierto si op1 y op2 son iguales.
!= op1 != op2 Cierto si op1 y op2 son diferentes.
5.4. Equivalencias
Operador Uso Equivalencia
+= op1 += op2 op1 = op1 + op2
-= op1 -= op2 op1 = op1 - op2
*= op1 *= op2 op1 = op1 * op2
/= op1 /= op2 op1 = op1 / op2
%= op1 %= op2 op1 = op1 % op2
&= op1 &= op2 op1 = op1 & op2
|= op1 |= op2 op1 = op1 | op2
^= op1 ^= op2 op1 = op1 ^ op2

Operador Uso Equivalencia
<<= op1 <<= op2 op1 = op1 << op2
>>= op1 >>= op2 op1 = op1 >> op2
>>>= op1 >>>= op2 op1 = op1 >>> op2

6. Los condicionales
6.1. El condicional if--else
El condicional if provoca que la ejecución pase por un conjunt de estados

booleanos que determinan que se ejecuten distintos fragmentos de código.
La sintaxis de este condicional es la siguiente:
if (expresión booleana) sentencia ;
if (expresión booleana) { // si hay más de una sentencia,

// se escriben entre entre llaves
sentencia1;
sentencia2;
...
}
Ejemplo 1
...
char c
...
if ((c >= 'A')&&(c <= 'Z')) return true;
else return false;
...
Ejemplo 2
...
if ((args.length > 2)||(args.length < 2))
System.out.println("Error: debes introducir dos números.");
else
nombre1 = Integer.parseInt(args[0]);
...
Si cuando la condición booleana no se cumple también debe ejecutarse un có-

digo, añadiremos else:
if (expresión booleana) ...

Puede hacerse
else sentencia1; el condicional...
... mediante el siguiente

operador:
o: expr ? op1 : op2
Equivalente a:
if expr then op1;
else {
else op2;
sentencia1;
sentencia2;
...
}
Ejemplo
...
if (args.length == 1) System.out.println("Procesando...\n");
else{
System.out.println("Error en el número de parámetros...\n");
System.exit(0);
}
...
El lenguaje Java se diferencia del C / C++ porque la sentencia de if tiene

una expresión booleana y no un valor numérico. No existe conversión
automática de int a boolean; por lo tanto, es preciso tener en cuenta el
siguiente código:
int abc = 1;
if (abc) // Genera un error de compilación
if (abc != 0) // Correcto
6.2. El condicional switch
El condicional switch proporciona un modo de enviar la ejecución a distintas

partes del código según el valor de una única variable o expresión.
Tiene el mismo formato que en el lenguaje C. Puede utilizarse tipo byte, char,
short, int o long como valores en el case y hay que tenen siempre la opción de
default.
La sintaxis de este condicional es la siguiente:
switch(expresión) {
case valor1: sentenciasAEjecutar;
break; // si no se pone, también ejecutaría las sentencias de
// valor2 y siguientes
case valor2: sentenciasAEjecutar;
break;
default: sentenciasAEjecutar; // si no es ninguno de los
// valores, qué hay que hacer
}
Ejemplo
...
numeroi = argv[0];
basei = Integer.parseInt(argv[1]);
switch(basei) {
case 2: {numero10 = Integer.parseInt(numeroi,2);break;}
default: break;
}
…
La palabra reservada default se utiliza pera especificar el segmento de código

que debe ejecutarse cuando el valor de la variable no coincide con ninguno de
los valores del case. Si no hay un break al final del segmento de código de un
case, la ejecución continúa en el código del case siguiente, sin comprobar su
valor.
7. Los bucles
7.1. El bucle while
El bucle while ejecuta repetidamente una sentencia, o una serie de sentencias,

mientras una expresión booleana sea cierta.
La sintaxis de este bucle es la siguiente:
while (expresión) sentencia; // una sentencia

while (expresión) { // más de una sentencia
sentencia1;
sentencia2;
...
}
Ejemplo 1
String texto = args[0];

char c;
int contador = 0;
int i = 0;
while (i < texto.length()) {
c = texto.charAt(i);
if (esMayuscula(c)) {
contador++;
}
i++;
System.out.println("El total de letras mayúsculas es: " + contador);

...
Ejemplo 2
...
int i = 100;
int suma = 0;
while (i <= 200) {
suma = suma + i;
i = i + 2;
}
...
7.2. El bucle do - while;
El funcionamiento del bucle do - while es similar al de while, pero en este caso

comprueba la expresión booleana después de realizar las sentencias; o sea, las
sentencias, como mínimo, se llevarán a cabo una vez.
La sintaxis de este bucle es la siguiente:
do sentencia while (expresión);
do {
sentencia1;
sentencia2;
...
} while (expresión);
Ejemplo
...
int i = 100;
int suma = 0;
do {
suma = suma + i;
i = i + 2;
} while (i <= 200);
...
7.3. El bucle for
El bucle for es la forma compacta de expresar un bucle. Su sintaxis es la Uso de for
siguiente: Por regla general, se emplea

con una variable que se inicia-
liza en la parte de ‘inicializa-
for (inicialización ; expresión ; iteración) sentencias; ción’ y se irá transformando
en cada iteración según indica
‘iteración‘, mientras la expre-
sión sea cierta.
Ejemplo 1
for (int i = 0 ; i < 10 ; i++) { cuerpo };

Java...
El cuerpo del bucle se ejecutará 10 veces; para los valores de i desde 0 hasta 9.
... acepta la coma como sepa-
Ejemplo 2 rador en la estructura del for().
El siguiente ejemplo inicializa
... i, j a 0 y los incrementa tras
int suma = 0; la ejecución:
for (int i = 100; i <= 200; i++) { for (i = 0, j = 0;
suma = suma + i; j < 10; i++,j++)
i = i + 1;
}
...
La instrucción for se emplea cuando el bucle tiene que ejecutarse cierta

cantidad de veces, mientras que while y do, cuando no se conoce con
exactitud el número de veces que debe repetirse el código.
7.4. Control de flujo en los bucles: break, continue, label
• break[etiqueta]
Se utiliza para salir de las sentencias switch, los bucles y las etiquetas.
• continue[etiqueta]
Se utiliza para saltar al final del bucle.

• etiqueta: sentencia
Se utiliza para identificar una sentencia en un bucle. Identifica cualquier

sentencia válida a la que sea preciso saltar.
...
saltar: while(true) {
for (int i = 0; i < 100; i++) {
switch (c = System.in.read()) {
case –1:
case ’\n’:
break saltar;
...
}
} // fin del for

} // fin del while
test: for(.....) {
...
while (.......){
if(i > j){
continue test; // salta a la iteración siguiente de for
}
// fin while
} // fin for
8. Procedimientos y funciones en Java: los métodos
En Java no hablamos de procedimientos y funciones, sino de métodos.
En el caso de funciones, la cabecera del método es la siguiente:
public tipo_retorno nombre_método (parámetros)
En el cas de procedimientos, la cabecera del método es la siguiente:
public void nombre_método(parámetros)
En el caso de métodos que devuelven algún valor, se emplea la palabra reser-

vada return. Cuando se ha llamado un método, al encontrar la sentencia return
la ejecución vuelve al punto del código donde se hizo la llamada, aunque que-
de código para ejecutar en el método que se había llamado.
Ejemplo
El siguiente programa utiliza el método esMajuscula, que de ha llamado desde el main:
public class ContarMayusculas {

public static boolean esMayuscula(char c) {
if ((c >= 'A') && (c <= 'Z')) {
return true;
} else {
return false;
}
}

String texto;
if (args.length == 1) {
System.out.println("Procesando...\n");
} else {
System.out.println("Error en el número de parámetros...\n");
System.exit(0);
}
text = args[0];
char c;
int contador = 0;
int i = 0;
while (i < texto.length()) {
c = texto.charAt(i);
if (esMayuscula(c)) {
contador++;
}
i++;
}
System.out.println("El total de letras mayúsculas es: " + contador);
}
}
Como método de programación es aconsejable partir los programas lar-

gos en métodos para hacer que el código sea más legible.
8.1. Métodos predefinidos: el API
El API es un conjunto de rutinas que el lenguaje ofrece al programador. La es-

tructura del API depende del lenguaje de programación. En el caso concreto
de Java, los elementos que ofrece el API son paquetes (package), clases (class) e
interfaces (interface).
El API incluye, entre otros, una descripción de los distintos paquetes que in-
corpora el JDK.
El API no es un manual, sino una descripción de lo que podemos encontrar en los dis-
tintos paquetes que nos ofrece. Esto puede parecer poco útil, però hay que tener en cuen-
ta que cuando ya se conocen los mínimos del lenguaje de programación Java y se
pretende utilizar las rutinas del API, normalmente surgen dudas (¿cómo se llama un mé-
todo determinado?, ¿cuál es la cantidad de parámetros necesarios para llamar un método
determinado?). En este momento es cuando se agradece la presencia del JDK, puesto que
proporciona información puntual adecuada para resolver este tipo de problemas.
El equipo desarrollador de Java no lo presentó desnudo al público, sino

acompañado de una serie de clases que permitían llevar a cabo una gran can-
tidad de funciones. Estas clases se agruparon según su función en unos con-
juntos llamados paquetes (el equivalente de las librerías de funciones de otros
lenguajes).
Los paquetes de Java son los archivos en los que se agrupan clases –con sus
correspondientes métodos– según su función.
El nombre de los paquetes se construye según la siguiente estructura:
java.nombreDelPaquete
Pueden crearse paquetes personales que agrupen las mejores clases creadas con
Los paquetes
vista a futuros programas.
No es necesario que un paque-
te se encuentre en Internet
Antes de crear una clase nueva es preciso comprobar que no existe. Hay que tener en para poder utilizarlo.
cuenta que las clases predefinidas de Java cubren una amplia gama de funciones.
En la programación orientada al objeto es fundamental conocer a fondo las clases están-

dar proporcionadas por el lenguaje. El dominio de las clases estándar ahorra horas de pro-
gramación, estandariza los procesos y solidifica las estructuras.
El desarrollo de nuevas clases debe quedar restringido al caso de que

exista seguridad de que ninguna de las existentes cubre las necesidades
de programación concretas.
8.1.1. Paquetes básicos de la versión JDK
Alguno de los paquetes básicos que se incluyen en la versión JDK de Java son
los siguientes:
• java.lang: es el paquete principal y el compilador lo imcopora automática-

mente (no es necesario importarlo). Contiene las clases básicas de Java, in-
cluido el tratamiento de cadenas de caracteres, el manejo de nombres y
funciones matemáticas, el acceso a los recursos del sistema, y la programa-
ció multiárea.
• java.io: controla las operaciones de entrada y salida y los archivos.
• java.util: contiene clases y métodos de propósitos muy variados, como ge-

neración de números aleatorios, propiedades del sistema, etc.
• java.net: apoya las comunicaciones TCP/IP. Incluye las clases que se refie-
ren a la comunicación en red.
• java.applet: sólo contiene la clase Applet, que permite el desarrollo de apli-

caciones incrustadas en páginas HTML.
• java.awt: contiene las clases y los métodos del Abstract Windows Toolkit,
Los paquetes de Java
independientes del sistema, para el manejo de la interfaz de usuario.
Además de los citados paque-
tes, hay otros, como el JDBC
• java.awt.image: contiene clases y métodos independientes del sistema, (no incluido en el JDK). Este pa-
necesarios para el manejo de gráficos e imágenes. quete se utiliza para manejar
bases de datos -java.sql.
• java.awt.peer: al ser las clases y los métodos específicos de cada sistema,

java.awt.peer contiene las clases necesarias para conectar los componentes defi-
nidos en el paquete java.awt con los componentes correctos de cada sistema.
8.2. Organización del API de JAVA
Si conocemos el nombre del paquete, de la clase o del método o atributo que

deseamos utilizar, no hay ningún problema. Sólo es necesario acceder a él por
una de las distintas vías que nos ofrece el API.
La tarea problemática es encontrar algo que no sabemos si existe o cuyo nom-

bre ignoramos. Este apartado nos ofrece una serie de objetivos que nos ayuda-
rán en dicha tarea. De momento, unos cuantos consejos básicos:
• Fijarse en los nombres de los paquetes, clases y métodos. Por ejemplo, el

paquete java.sql, como es obvio, contiene todas las clases y métodos rela-
cionados con el uso del lenguaje SQL desde Java.
• Leer la descripción de los paquetes. Los paquetes tienen una descripción que
explica para qué sirven y, además, están distribuidos de forma coherente.
• Buscar en el índice palabras que tengan similitud con lo que deseamos hacer.
Por ejemplo, por cuestiones relacionadas con cálculos matemáticos buscaría-
mos la palabra math.
• La experiencia. La consulta constante de la ayuda del API nos proporciona-

rá una experiencia muy útil.
Al cargar la página inicial 1 de la ayuda de Java, obtenemos por pantalla la dis-

posición siguiente, cuyos elementos explicaremos a continuación:
8.2.1. Opciones del API de Java
• Overview. Al hacer clic en esta opción, volveremos a la página inicial.

Fijaos en la imagen
de la pantalla de ayuda
• Package. Al hacer clic sobre esta opción, obtendremos una lista de las cla- Las opciones se presentan
en el marco superior derecho
ses e interfaces de cada paquete, junto a una breve descripción. Los paque- de la página.
tes pueden contener cuatro tipos de categorías:
– Interfaces (mostradas en cursiva)

– Clases
– Excepciones
– Errores
8.2.2. Estructura de la ayuda de un paquete
La disposición de la ayuda de un paquete es la siguiente:
• package nombrePackage: breve descripción del paquete

• class Summary (o una de las cuatro categorías anteriores)
• NombreClase: breve descripción de la clase
• package nombrePackage Descripción: descripción completa del paquete
• since: versión del JDK en la que se incorporará el paquete.
8.2.3. Estructura de la ayuda de una clase
La disposición de la ayuda de una clase (o de una de las cuatro categorías) es

la siguiente:
• NombrePackage
• Class NombreClase
• Diagrama de herencia de la clase
• Subclases
• Subinterfaces
• Implementaciones
• Declaración de la clase
• Descripción de la clase
• Resumen de la clase
• Resumen de los campos
• Resumen de los constructores
• Resumen de métodos
• Detalle de los campos
• Detalle de los constructores
• Detalle de los métodos
8.2.4. La página de uso
Cada paquete, clase o interfaz tiene su página de uso (use), que indica los pa-
Accesibilidad
quetes, las clases, los métodos, los constructores y los atributos que emplea.
A esta opción sólo se tiene ac-
ceso desde un paquete, desde
una clase o desde una interfaz.
8.2.5. La jerarquía de clases
Cada página de jerarquía de clases (tree) contiene una lista de clases y una de
interfaces.
Las clases se organizan según una estructura de herencia. La primera es

java.lang.Object, y de ella deriva todo.
Si hacemos clic en tree desde la página de inicio, obtendremos la jerarquía de

todos los paquetes. Si hacemos clic en tree desde un paquete, una clase o una
interfaz, obtendremos la jerarquía correspondiente.
8.2.6. Los elementos obsoletos
La página de los elementos obsoletos (deprecated) contiene la lista de elemen-

tos que ya no se utilizan (que pueden haber sido sustituidos por otros o no).
No es recomendable hacer uso de elementos obsoletos, puesto que no puede

asegurarse que una próxima versión del JDK les preste apoyo.
8.2.7. El índice
El índice contiene la lista de todas las clases, interfaces, constructores, méto-

dos y campos ordenada alfabéticamente.
8.2.8. La ayuda
La ayuda nos describe la forma de navegar mediante el API de Java.
La sentencia import sirve para incluir clases o paquetes en un programa Java;

nombreClase: si se desea incluir
la forma general de esta sentencia es la siguiente: una clase concreta del paquete.
Un asterisc:o si se desea incluir
todo el paquete.
paquete1: si se hace referencia
import paquete1.[paquete2].(NombreClase | *); a un paquete de alto nivel.
paquete2: si se hace referencia
a un paquete opcional que está
contenido en el paquete de
Ejemplo alto nivel.
import java.lang.String; // la clase String del subpaquete lang del

// paquete Java.
import java.lang.* // todas las clases del subpaquete lang del paquete
// Java.
8.3. Nomenclatura de los métodos de las clases del API
Signatura de una función. Nombre, parámetros de entrada y tipo de retorno de

la función, con el siguiente formato:
nombre(param1 : tipo1,param2 : tipo2,...,paramN : tipoN) : tipoRetorno
Por ejemplo, la función suma tiene dos parámetros de entrada (el operando 1
y el operando 2) enteros y retorna otro entero (la suma de ambos operandos).
La signatura de la función suma sería la siguiente:
suma (operando1 : entero, operando2 : entero) : entero

Ejercicio
Analizad qué ocurre con la aplicación de los métodos siguientes sobre este string:
String sT1 = "Ejercio 1"
• String mayus = st1.toUpperCase();
• String minus = st1.toLowerCase();
• int longitud = st1.length();
• char caracter = st1.charAt(1);
• tring sub = st1.substring(3,5);
S
• String sT = st1.concat(" i 2");

• boolean B = st1.startsWith("Exe");
• int inicio = st1.indexOf("rci");
9. Entrada y salida en Java
9.1. Lectura de datos desde la línea de instrucciones
La ejecución de programas en Java nos permite leer datos directamente de la

línea de instrucciones en la que invocamos el programa.
Ejemplo
public class Suma {

public static void main(String[] args) throws IOException {
int x;
int y;
int sum;
x = Integer.parseInt(args[0]); // Conversión de String a entero
y = Integer.parseInt(args[1]);
sum = x + y;
System.out.println("La suma de " + x + " y " + y + " es " + sum);
}
}
La interacción con el usuario sería muy simple:
>java Suma 12 5
La suma de 12 y 5 es 17
>
El vector args de la función main (programa principal) recoge todos los strings
que añadimos tras el nombre del programa. De este modo, args[0] contiene el
primer String, args[1], el segundo, etc. Sin embargo, con este mecanismo es ne-
cesario garantizar que el programa no accederá a más argumentos de los espe-
cificados en la línea de instrucciones.
Ejemplo
Si ejecutáramos el programa anterior como se indica a continuación, obtendríamos el

error observado debido a que la sentencia i = Integer.parseInt (args[1]); inten-
taría acceder al segundo elemento del vector args, que sólo tiene un elemento.
> java Suma 12

java.lang.ArrayIndexOutOfBoundsException: 1
at Suma.main(Suma.java:9)
>
9.2. Lectura de datos desde el teclado
Muchos de nuestros programas reclamarán que introduzcamos datos median-

te el teclado que, a la vez, veremos en la pantalla.
Existen muchas formas de introducir datos. En nuestros primeros programas

lo haremos mediante un mecanisme sencillo: leyendo líneas que contienen
strings. No hay que preocuparse por el significado exacto de las sentencias que
se explicarán, sólo es necesario saber que nos permitirán leer datos que poste-
riormente podremos utilizar en nuestros programas.
Ejemplo
Programa que calcula la suma de dos nombres enteros
import java.io.*;
public class Suma2 {

String s; // s albergará los strings leídos
BufferedReader in; // Dispositivo del que leeremos los datos
int x;
int y;
int sum;
// Primero identificamos el
// dispositivo de entrada de datos (teclado)
in = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Entra el primer número: ");
s = in.readLine();
x = Integer.parseInt(s);
System.out.print("Entra el segundo número: ");
y = Integer.parseInt(in.readLine());
sum = x + y;
System.out.println("La suma de " + x + " y " + y + " es " + sum);
}
}
Declararemos el dispositivo de entrada de datos una variable de tipo BufferedReader. Al

principio de la ejecución del programa, identificaremos el dispositivo que deseamos uti-
lizar:
in = new BufferedReader(new InputStreamReader(System.in));
El dispositivo system.in corresponde al teclado de nuestro ordenador. A partir de aquí,

podemos leer líneas (secuencias de caracteres hasta fin de línea) y almacenarlas en varia-
bles de tipo String.
Las sentencias:
s = in.readLine();
x = Integer.parseInt(s);
leen un String y lo almacenan en s. Después se interpreta el contenido de s como un en-

tero y se asigna a x. Todo ello puede llevarse a cabo con una única sentencia, como se
muestra al leer la variable y:
y = Integer.parseInt(in.readLine());
Durante la ejecución del programa anterior, se apreciaría esta interacción con el usuario:
> java Suma2

Entra el primer número: 12
Entra el segundo número: 5
La suma de 12 y 5 es 17
>
9.3. Escritura de datos
A menudo desearemos ver el resultado calculado por nuestros programas en la

pantalla del ordenador. Podremos hacerlo mediante la siguiente sentencia:
System.out.println(s);
En esta sentencia s es una expresión de tipo String. Como se ha visto con la manipulación
de strings, esta expresión puede incluir operandos de otros tipos que serán convertidos
implícitamente en strings . La sentencia anterior escribe el String por pantalla y añade un
salto de línea.
Ejemplo
La sentencia siguiente escribiría esta línea en la pantalla del ordenador:

Nota
Mensaje: el valor de x es 13:
Si no se quiere añadir el salto
String s = "Mensaje: ";
de línea, puede utilizarse la
int x = 13; sentencia System.out.print(s).
System.out.println (s + "el valor de x es " + x + ".");
9.4. Escritura en un archivo
Declararemos el dispositivo de entrada de datos como una variable de tipo

PrintStream. Al principio de la ejecución del programa, identificaremos el dis-
positivo que deseamos utilizar.
Ejemplo
import java.io.*;
class Entra2 {
PrintStream printer = new PrintStream (new FileOutputStream("abc.txt"));
printer.print("Dos + " + 2);
printer.println("=" + (2 + 2));
printer.close();
}
}
9.5. Lectura desde un archivo
Declararemos el dispositivo de entrada de datos como una variable de tipo

BufferedReader. Al principio de la ejecución del programa, identificaremos el
dispositivo que deseamos utilizar.
Ejemplo
import java.io.*;
class Entra3 {
BufferedReader reader = new BufferedReader (new FileReader("abc.txt"));
String str = reader.readLine();
System.out.println(str);
reader.close();
}
10. Arrays y vectores en Java
Los arrays, las clases y las interfaces son tipos de referencia. El valor de una va-
Una comparación
riable de referencia, al contrario de los tipos primitivos, es una referencia al va-
lor actual o al conjunto de valores representados por la variable. Una referencia sería el equiva-
lente a la dirección de un
amigo. La dirección no es pro-
piamente el amigo, sino una
forma de llegar a él.
Una variable de referencia no es el array u objeto, sino la dirección que
nos conduce a él.
El JDK de Java ofrece un conjunto de clases que permiten la gestión y el al-

macenaje de colecciones de objetos. Estas clases se encuentran en el paquete
java.util.
class java.lang.Object
o class java.util.AbstractCollection (implements java.util.Collection)
o class java.util.AbstractList (implements java.util.List)
o class java.util.AbstractSequentialList
o class java.util.LinkedList (implements
java.lang.Cloneable, java.util.List, java.io.Serializable)
o class java.util.Arraylist (implements java.lang.Cloneable,
java.util.List, java.io.Serializable)
o class java.util.Vector (implements java.lang.Cloneable,
java.util.List, java.io.Serializable)
o class java.util.Stack
o class java.util.AbstractSet (implements java.util.Set)
o class java.util.HashSet (implements java.lang.Cloneable,
java.io.Serializable, java.util.Set)
o class java.util.TreeSet (implements java.lang.Cloneable,
java.io.Serializable, java.util.SortedSet)
Diagrama de herencias del JDK 1.2.1 referente a colecciones
Vector y ArrayList…
Muchas de estas clases (como TreeSet o LinkedList) son muy específicas y que- ... son almacenes de objetos
dan fuera de los objetivos del curso. Vector es muy popular porque ya existía que nos permiten acceder
a los elementos que contienen
en las versiones anteriors al JDK 1.2. ArrayList ha aparecido con la versión 1.2, de formas distintas. Por ejem-
plo, podemos acceder a un ele-
però parece que acabará siendo tan popular como Vector. mento refiriéndonos a su
posición dentro de la colec-
ción, realizar una búsqueda
de un determinado elemento
En la documentación del JDK (en el paquete java.util) podéis encontrar más para ver si se encuentra
en la colección, etc.
información sobre estas dos clases.
10.1. Comparación array-vector
En este apartado estudiaremos la diferencia entre los arrays y la classe Vector.

Ambas permiten almacenar un conjunto de datos mediante determinados
índices y comparten las siguientes características:
• Constan de una o más posiciones.

• Cada posición tiene un índice entero.
• El índice de la primera posición es el 0.
• Es preciso crearlos con la operación new.
• Son objetos.
• Se referencian mediante variables de referencia.
Las principales diferencias que existen entre array y Vector son las siguientes:
• Un array no es una clase. No está definido en la biblioteca de clases, es parte

integrante del lenguaje en en sí.
• No hay métodos de array para trabajar con los arrays o con sus elementos;
el lenguaje proporciona símbolos especiales que nos permiten acceder a los
elementos de los arrays.
• Los arrays tienen un campo llamado length que indica el número de ele-
mentos del array. Los vectores deben utilizar el método size para dar esta
información.
• Los elementos del array pueden contener tipos de datos primitivos (como
por ejemplo los enteros) y referencias de objetos.
• El tipo de los elementos de los array debe especificarse en la declaración del

array. Todo lo que se almacena en ésta deberá ser de este tipo.
• Los arrays no pueden crecer. Una vez se han creado, tienen una cantidad
de elementos fija.
Si comparamos los arrays con los vectores, en cuanto al uso, podemos estable-
cer la siguiente tabla de ventajas e inconvenientes:
array respecto a vector
Ventajas Inconvenientes
* Un código que utilice arrays será
más rápido que un código que
Tienen unas dimensiones fijas, no pueden emplee vectores.
Permiten almacenar tipos primitivos.
crecer. Sin embargo, la búsqueda binaria
en un Vector seguirá siendo mucho
Puede accederse a sus elementos sin enviar Ofrecen un conjunto de operaciones más más rápida que la búsqueda
un mensaje*. limitado. secuencial en un array.
array a Vector v
Establecido para la
Tipos de elementos Referencia de objeto
declaración de a
¿Cómo se denota la
a[índice] v.elementAt(índice)
referencia de un elemento?
¿Cómo se asigna un valor a

a[índice] = valor v.setElementAt(valor)
un elemento?
¿Cómo puede conocerse el

a.length v.size()
número de elements?
¿Permite almacenar tipos

Sí No
primitivos?
¿Puede crecer
No Sí
dinámicamente?
¿Dónde se define? En el lenguaje Java En la biblioteca de clases Java
10.2. Declaración y creación de arrays
Con el fin de declarar una variable que referencie un array, se escribe el tipo
de todos los elementos, seguido por un par de corchetes vacíos y el nombre de
la variable de referencia.
Ejemplo
int[] nombres; // Esta es la referencia de un array en el que todos

// los elementos serán enteros
Para crear un array se emplea el operador new, seguido por el tipo de elementos
y un entero entre corchetes. Este entero especifica el número de elementos que
tendrá el array.
Ejemplo
nombres = new int[6];
Para conocer la cantidad de elementos del array podemos hacer nombres.length.

Con el length no utilizaremos paréntesis porque no es un método.
Para crear un array de enteros, primero es preciso declarar una variable de re-
ferencia array y, después, se crea un array formado por seis enteros y se hace
que la variable anterior referencie el nuevo array.
Java permite inicializar arrays en el momento de su declaración:
String nombre[ ] = { “Pepi”,

“Sara”,
“Mar” };
es equivalente a:
String nombre[ ];
nombre = new String[3];
nombre[0]="Pepi";
nombre[1]="Sara";
nombre[2]="Mar";
10.3. Ejemplo de uso de arrays
El siguiente programa lee e imprime una lista de cien enteros, uno por línea
en ambos sentidos.
import java.io.*;
import java.lang.*;
class EnteroAlReves {
public static void main(String[] a) throws Exception {
BufferedReader teclat = new BufferedReader(new
InputStreamReader(System.in));
int[] z = new int[10];
int i = 0;
while (i != 10) {
z[i] = Integer.parseInt(teclat.readLine());
i++;
}
int k = 9;
System.out.println("El resultado es:");
while (k != -1) {
System.out.println(z[k]);
--k;
}
}
}
10.4. Declaración y creación de vectores
Vector es una clase que permite almacenar objetos de cualquier tipo (trabaja
con la clase Object, por lo tanto, puede almacenar cualquier subclase de Object).
Su representación gráfica de vector es la siguiente:
pos0 pos1 pos2
"A" "B" "C"
La forma habitual de crear objetos Vector es empleando su constructor:
Vector(inicial, incremento)
inicial es el número de posiciones que tendrá de entrada el vector.
incremento es el número de posiciones en que se incrementará cuando sea necesario redi-

mensionarlo para que tenga todas las posiciones ocupadas.
En la representación gráfica de vector, tenemos tres posiciones y, por lo tanto,

podríamos haber construido el vector del siguiente modo:
java.util.Vector v = new java.util.Vector(3,3);
De este modo se crea un vector de tres posiciones que se redimensionará automáticamen-

te a 6 (3 posiciones más) al insertar el cuarto elemento.
Pueden añadirse elementos a un vector (realizar inserciones) mediante el mé-

todo add(Object) que permite incorporar un elemento a la posición libre si-
guiente del vector. Así, para conseguir tres strings como en el dibujo anterior,
será preciso lo siguiente:
v.add("A");
v.add("B");
v.add("C");
Vector también permite buscar elementos con la función indexOf(Object) que

* Si existe más de un elemento igual
retorna la posición del elemento indicado como parámetro.* al buscado, retorna la posición del
primero que encuentra.
Ejemplo
v.indexOf("B");
Esta función devolvería como respuesta 1. La posición 1 es la que almacena el String "B".
Dada una posición, también podemos obtener el objeto almacenado mediante

el método get(posición).
Ejemplo
Así, para obtener el String “B” haríamos lo siguiente:
v.get(1);
Todas las colecciones nos ofrecen la posibilidad de obtener la secuencia de to-

dos los elementos que almacenan. En el caso de la clase Vector, se realiza me-
diante los métodos iterator() y listIterator().
Estas funciones nos proporcionan unos objetos para recorrer secuencialmente

los elementos de un vector.
Ejemplo
Más información
for (java.util.Iterator i = v.iterator() ; i.hasNext() ;) {
System.out.println(i.next().toString()); También existe toda una jerar-
} quía de iteradores que nos
ofrecen varias funcionalidades.
o bien Si deseáis más información,
podéis consultar el JDK
for (java.util.Iterator i = v.listIterator() ; i.hasNext() ;) { (en el paquete java.util).
System.out.println(i.next().toString());
}
Esta función imprime el valor de todos los elementos por pantalla.
Para trabajar con Vector es necesario hacer un import del paquete java.util,
o directamente de la clase java.util.Vector.
Bloque II. Java orientado a objetos
1. Tipos primitivos y objetos
En la primera parte de este módulo, hemos utilizado los tipos primitivos de Java
(numérico, carácter y lógico), junto con otros tipos que representaban almace-
nes de información, como las cadenas de caracteres, los vectores y los arrays.
Recordemos que, en Java, todos los tipos que no sean primitivos (int, long, double,
short, char, boolean y byte) son tipos de referencia.
Diferencia tipo primitivo – tipo de referencia
Una variable que representa un tipo primitivo almacena el valor de este tipo, mientras
que una variable que representa un tipo de referencia sólo almacena una referencia a la
localización en memòria de este objeto.
Las referencias de memoria las asigna automáticamente el compilador y no

son accesibles al usuario. Por ello, no pueden emplearse operaciones de ma-
nipulación de referencias como en el lenguaje de programación C.
Si por cualquier motivo es preciso tener referencias de los tipos primitivos int
o double, el propio lenguaje define las clases Integer y Double.
Como en otros lenguajes de programación, si dos variables de referencia tie-

nen un mismo valor, esto significará que ambas referencian el mismo objeto.
Además, cuando una referencia no apunta hacia ningún objeto, almacena la
referencia nula o null. La constante null es única y se emplea para cualquier
objeto (se dice que está sobrecargada).
1.1. La declaración de variables
En el bloque anterior, se ha visto como se puede llevar a cabo la declaración

de variables que almacenan tipos primitivos. En la orientación al objeto, la de-
claración del objeto no genera el propio objeto.
Ejemplo
Supongamos que deseamos crear un objeto de tipo Panel (la clase Panel sirve en Java para
llevar a cabo la gestión de interfaces):
Panel p; // p val null

p = new Panel(); // p se refiere al objeto creado
No es necesario llevar a cabo la creación en dos pasos. Puede hacerse directamente:
Panel p = new Panel();
Cuando se desea utilizar un objeto de cierto tipo, es necesario crearlo

explícitamente. Hasta que no se crea, no existe, y cualquier intento de
referenciarlo provocaría un error en tiempo de ejecución.
Las variables locales de los métodos deben inicializarse antes de utilizarlas.

Las variables de instancia de tipo básico se inicializan por defecto.
1.2. El acceso a los métodos de las clases y los objetos
Podemos encontrar métodos asociados a los objetos que se aplicarán sobre

estos. El operador punto (“.”) nos permite seleccionar los métodos que
contiene un objeto. En notación de objetos, cuando se ejecuta un método
asociado a un objeto, se dice que se envía un mensaje al objeto en cues-
tión.
Ejemplo
Tomamos una clase predeterminada en Java, como la del ejemplo anterior (Panel) y la cla-
se Button*. * La clase Button permite
la creación, dentro de un Panel,
de los típicos botones de aceptar
... y cancelar.
Panel p = new Panel();
// Creación del panel
Button b = new Button();
// Creación del botón
b.setLabel("Aceptar"); // Llama al método setLabel de la clase
// Button, que permite crear un botón con el nombre el nombre que se
// le introduce como parámetro p.add(b);
// Se añade el botón al panel utilizando el
// método add de la clase Panel, que permite añadir Las clases Panel y Button se incluyen
// al panel aquello que se introduce como parámetro en el paquete java.awt.
...
Si un objeto no existe (porque tiene el valor null) y se le intenta enviar

un mensaje, se generará la excepción NullPointerException.
También es preciso destacar que muchos objetos pueden crearse dándo-

les directamente un valor inicial. En el caso de los botones, podríamos
haber hecho directamente lo siguiente:
...
Button b = new Button("Aceptar");
...
1.3. La asignación
Dadas dos variables de tipos compatibles (tanto si se trata de tipos primitivos

Ejemplo
como de variables de referencia), al realizar la asignación “=” entre éstas, se
sustituye el valor de una por el de otra. t1 = t2 // El contenido
de la variable t1 se
sustituye por el de t2.
Una asignación entre referencias copia la dirección contenida.

El operador = asigna referencias.
Cuando se utiliza la asignación es preciso tener cuidado para no perder refe- Se ha perdido la referencia
del objeto “dos” porque ambas
rencias a objetos que después puedan necesitarse. variables referencian el mismo
objeto.
Ejemplo
...
Button uno = new Button("Aceptar");
Button dos = new Button("Cancelar");
dos = uno; // Copia la referencia. Ahora, dos referencia adonde
// referenciaba uno
...
1.4. Las operaciones de comparación (equals) y copia (clone)
Al hablar de los tipos primitivos, vimos que el operador == permite saber si los
valores de las variables que se comparan son iguales o no. En la orientación al
objeto, el operador == retorna cierto si las referencias de ambos objetos son
iguals, y falso en el caso contrario. Para poder comparar correctamente los con-
tenidos de los objetos, es necesario emplear el método equals.
El operador == compara si dos referencias referencian un mismo objeto.
El método equals() compara el contenido de dos objetos.
Ejemplo
...
Objeto uno = new Objeto();
Objeto dos = new Objeto();
if un.equals(dos) then System.out.println("Son iguales")
else System.out.println("Son distintos");
...
Para hacer copias de objetos, es preciso emplear el método clone.
Ejemplo
...
Objeto uno = new Objeto();
Objeto dos = un.clone();
...
El operador == asigna referencias. Para copiar objetos, es necesario uti-

lizar el método clone().
1.5. El paso de parámetros
En Java, el paso de parámetros siempre es por valor. Esto significa que cuando
el parámetro de cierto método es un objeto representado mediante una refe-
rencia, el valor que se transmite al método es la referencia a la zona de memo-
ria en que se encuentra el objeto.
Comprobad qué ocorre cuando ejecutáis los siguientes ejemplos:
Ejemplo 1
P.java
class P {
static void f(int i) {
System.out.println(++i);
}

int n = 5;
System.out.println(n);
f(n);
System.out.println(n);
}
}
Ejemplo 2
P1.java
class CuentaBancaria {
long numero;
String titular;
long saldo;
}
class P1 {
static void arruinar(CuentaBancaria c) {
c.saldo = 0;
c = null;
}

CuentaBancaria ct = new CuentaBancaria();
ct.saldo = 100000;
System.out.println(ct.saldo);
arruinar(ct);
System.out.println(ct.saldo);
}
}
Ejemplo 3
P2.java
class P2 {
static void f(int x[]) {
x[3] = 0;
x = new int[8];
x[3] = 5;
}

int a[] = {5, 4, 3, 2, 1};
System.out.println(a[3]);
f(a);
System.out.println(a[3]);
}
}
2. Clases
Como ya hemos comentado, una clase es la descripción de la estructura y el

comportamiento de los objetos pertenecen a ella.
Supongamos que necesitamos representar los triángulos rectángulos y que, de

cada uno, nos interesa conocer su base y altura y, además, una serie de opera-
ciones. Podríamos definir una clase nueva, muy simple, llamada Triangulo:
class Triangulo {
double base;
double altura;
} // final de la clase
En esta definición se ha incluido el nombre de la clase (Triangulo) y el de dos

variables (base y altura) asociada a cada nuevo objeto de la clase triángulo que
se desee crear. Estas variables, que representan información propia de cada ob-
jeto, se llaman atributos o también variables de instancia.
En general, una nueva clase se guarda en un archivo con el mismo nombre de

la clase que, al compilarse, genera un archivo .class que ya permite utilizarla.
En el programa siguiente se plantean una serie de operaciones parecidas a la

nueva clase que se acaba de definir:
PruebaTriangulo.java
class Triangulo {
double base;
double altura;
}
class PruebaTriangulo { Mediante el operador new, se crea
public static void main(String[] args) { el nuevo objeto, mientras que la
referencia de cada una de las
Triangulo t1 = new Triangulo(); variables de instancia del objeto se
Triangulo t2 = new Triangulo(); lleva a cabo con el operador punto.
t1.base = 7;
t1.altura = 8;
t2.base = 8;
t2.altura = 10;
System.out.println("Área triángulo 1:" + ((t1.base * t1.altura) / 2));
}
}
Aunque la clase Triangulo puede escribirse en un archivo individual, también

es posible hacerlo en un mismo archivo con otras clases (por ejemplo, con la
clase PruebaTriangulo). De este modo, cuando se compile este archivo, se gene-
rarán tantos archivos .class como clases existen.
En cada archivo de Java sólo puede haber un método main Java.
En el ejemplo anterior, el área del triángulo se calcula por medio de la instruc-

ción siguiente:
(t1.base ∗ t1.altura)/2
Aunque es un modo correcto de realizarlo, no es el más adecuado, porque

nos obliga a repetir la instrucción tantes veces como triángulos se hayan
creado. Una solución más pertinente sería crear un método que encapsule la
operación. Sin embargo, esta tampoco sería la solución idónea, puesto que
cualquier clase que emplee la clase triángulo no tiene por qué conocer cómo
se representa internamente un triángulo, igual que para sumar dos valores
double, es irrelevante la representación concreta que utiliza el compilador
para almacenar un valor double.
En el ejemplo
Desde el punto de vista de la programación orientada a objetos, un nue- del triángulo,...
vo objeto queda definido por una estructura de datos que lo soporte, un ... los atributos base y altura
son la estructura del objeto, y
estado, o valor, del objeto en cada instante y un conjunto de métodos el valor del objeto en cada ins-
para manipularlo. tante es el valor de los compo-
nentes base y altura.
2.1. Definición con métodos
A continuación se muestran distintos aspectos que se refieren a la accesibili-

dad de la información declarada en una clase.
Consideremos, por ejemplo, la siguiente definición para la clase Triangulo :
class Triangulo {
private double base;
private double altura;
public Triangulo() { }
public double area() {
return(base * altura / 2)
}
public double getBase() {
return(base);
}
public double getAltura() {
return(altura);
}
public void setBase(double bas) {
base = bas;
}
public void setAltura(double al) {
altura = al;
}
}
• Toda la información declarada private es exclusiva del objeto e inaccesible

desde el exterior de la clase: cualquier intento de acceso a las variables de ins-
tancia base y altura fuera de la clase dará lugar a un error de compilación.
• Toda la información declarada pública es accesible desde el exterior de la

clase: un método de una clase declarado público es accesible desde cual-
quier clase.
• En cualquier método existe por defecto (y, por lo tanto, puede declararse o
En el ejemplo…
no) un método sin tipos con el nombre de la propia clase.
… es el método Triangulo(),
que se utiliza para crear nuevos
Los métodos pueden clasificarse, según su función, del modo siguiente: objetos de la clase mediante el
operador new.
• Constructores, métodos que permiten la construcción del objeto. En el

ejemplo anterior, el único constructor es el método Triangulo(). Como vere-
mos más adelante, un método constructor puede tener argumentos e ini-
cializar el objeto en cierto modo.
• Accesores (getters), métodos que posibilitan el conocimiento, sin alterarlo,

del estado del objeto. Se llaman getters porque se les da nombre con el pre-
fijo get seguido del nombre del atributo que permiten retornar.
• Modificadores (setters), métodos que permiten alterar el estado (los valores

de las variables de instancia) del objeto. Se llaman métodos setters porque
se les da nombre con el prefijo set seguido del nombre del atributo que per-
miten retornar.
Para ejecutar un método correspondiente a un objeto (enviarle un mensaje),

es necesario emplear la notación de punto.
Ejemplo
Este programa emplea la nueva clase Triangulo que hemos definido:
PruebaTriangulo2.java
class Triangulo2 {
public Triangulo2() {
}
return ((base * altura) / 2);
}
return (base);
}
return (altura);
}
base = bas;
}

altura = al;
}
}
class PruebaTriangulo2 {
Triangulo2 t = new Triangulo2();
t.setBase(7);
t.setAltura(10);
double a = t.area();
System.out.println("Area" + a);
}
}
2.2. Estructura de una clase
Tras haber analizado el ejemplo de definición de una clase, podemos presentar

su forma general:
[calificadores] class NombreClase [ extends NombreClase ] {

[calificadores] tipo nombreVar1;// Definición de los atributos o
// variables de instancia
[calificadores] tipo nombreVar2;
... ... ...
[calificadores] tipo nombreVarN;
[calificadores] tipo nombreMetodo1 ([listaArgs]) {
// Definición de los métodos cuerpo_del_metodo
}
[calificadores] tipo nombreMetodo2 ([listaArgs]) {
cuerpoDelMetodo
}
... ... ...
[calificadores] tipos nombreMetodo-n ([listaArgs]) {
// cuerpoDelMetodo
}
}
• Los elementos escritos entre corchetes ([ ]) en la declaración son opcionales.
• El término tipo se refiere a un nombre de tipo, que puede ser primitivo o de

otro tipo, que en el caso de los métodos puede ser void o bien el tipo del
elemento de retorno.
• Cada uno de los nombreVar y de los nombreMetodo se refiere a una variable

de instancia o a un método.
• Los únicos cualificadores estudiados hasta ahora son los correspondientes

al ámbito de la declaración (private y public), aunque pueden existir de otro
tipo, como por ejemplo protected o static, que se describirán más adelante.
• Uno o más métodos pueden ser constructores de la clase, con lo que no

tendrían ningún tipo específico.
Recordemos lo siguiente:
• Un objeto es una unidad de programación que asocia datos a las operacio-

nes que pueden utilizarlas/afectarlas.
• Llamamos a las operaciones métodos.
• Llamamos a los datos atributos o variables de instancia.
• El encapsulamiento de los objetos sirve para esconder la implementación

concreta de los datos y las operaciones.
• Cuando un objeto recibe un mensaje (destinatario.mensaje*) en tiempo * El destinatario es un objeto o

expr.obj.
de ejecución, se selecciona el método correspondiente.
• Los objetos, como entidades, pueden cambiar de estado, comportarse de

formas distintas y ser manipulados por diferentes estímulos.
• Un objeto existe (espacio) y tiene atributos y varias funcionalidades.
• Un método es una sección delimitada de código que pertenece a una clase

y define un comportamiento específico de ella. De hecho, los servicios o
métodos son las operaciones que pueden llevarse a cabo sobre los datos.
Pueden ser funciones o procedimientos, es decir, pueden retornar valores
de cualquier tipo o no retornar ningún valor.
• Un mensaje es el mecanismo por el que se invoca un método. Un mensaje

consiste en el nombre del método seguido de una listaParametros que pue-
de estar vacía.
• El protototipo es la cabecera del método, es decir, el nombre del método

junto a la descripción de la lista de parámetros y el tipo de retorno.
• El tipo de valor void indica que el método no retorna ningún valor. Las fun-
ciones retornan su valor gracias a la palabra reservada return.
• Cualquier clase tiene asociado un servicio de creación de objetos: el construc-

Recordad
tor. Por ejemplo, unEstudiante es una instanciación de la clase Estudiante, y se
crea al llamar al método new Estudiante(), que es el constructor de la clase. Los constructores son los mé-
todos de la clase que permiten
crear o instanciar objetos.
• En Java se utiliza la palabra clave new para solicitar la creación de un objeto.
Este constructor retorna una referencia al objeto que ha creado.
• El operador new da una referencia a un objeto para poderlo utilizar poste-

riormente, pero no se podrán enviar mensajes al objeto si no se guarda di-
cha referencia. Por ello, es preciso crear una variable del tipo de la clase que
estemos creando con el fin de poder guardar el nuevo objeto creado.
• El nombre de un método constructor coincide con el de la clase a que per-

tenece.
2.3. Sobrecarga de métodos
En los lenguajes de programación se llama sobrecarga a la definición de un mis-

Ejemplo de sobrecarga
mo ítem (símbolo, identificador, etc.) con distintos significados, de modo que
El operador + se utiliza como
el significado depende de la forma de emplearlo.
de concatenación de cadenas
y operador de suma aritmética.
La sobrecarga explícita de los métodos tiene una gran importancia en la progra-

mación orientada al objeto, especialmente su utilización en la relación de he-
rencia entre clases, com veremos más adelante. Sin embargo, prácticament no
existe en otros lenguajes de programación tradicionales como C o Pascal.
Java permite que distintos métodos dentro de una clase se llamen igual,
siempre y cuando sus listas de parámetros sean diferentes. Esto se deno-
mina sobrecarga de métodos.
En la sobrecarga de métodos, el método que debe ejecutarse se identifica por

el tipo o el número de parámetros.
La sobrecarga permite al programador utilizar el mismo nombre para dos métodos dife-
rentes. El que invoca al método especifica implícitamente qué método se invocará me-
diante la lista de argumentos que se pasa en el mensaje, y que entonces se compara con
los prototipos de los diferentes métodos candidatos hasta encontrar una coincidencia. La
determinación de cuál es el método correcto se lleva a cabo en tiempo de compilación.
Hay que tener presente que en la definición de la clase Triangulo del apartado
“Definición con objetos”, se incluye un constructor Triangulo() que sólo crea
el objeto (por ello, no está definido el cuerpo del constructor), y dos métodos
(setBase y setAltura) para asignar valores a las variables de instancia de los ob-
jetos.
Puede definirse un método constructor que, además de crear el objeto, alte-

re su estado, por ejemplo para inicializar los valores de las variables de ins-
tancia.
class Triangulo {
public Triangulo() { } // primer constructor
public Triangulo(double bas, double al) { // segundo constructor

base = bas;
altura = al;
}
public Triangulo(double medida) { // tercer constructor

base = medida;
altura = medida;
}

return(base * altura / 2)
}

return(base);
}

return(altura);
}

base = bas;
}

altura = al;
}
}
En este ejemplo se incluyen tres métodos constructores, que se llaman igual pero que
cuentan con un número de parámetros diferente:
MasPrueba.java
class Triangulo3 {
public Triangulo3() { // primer constructor

public Triangulo3(double bas, double al) { // segundo constructor
base = bas;
altura = al;
}
public Triangulo3(double medida) { // tercer constructor

base = medida;
altura = medida;
}

return ((base * altura) / 2);
}

return (base);
}

return (altura);
}

base = bas;
}

altura = al;
}
}
class MasPrueba {
Triangulo3 t1 = new Triangulo3();
Triangulo3 t2 = new Triangulo3(2.5, 3.5);
Triangulo3 t3 = new Triangulo3(34.2);
}
}
Otro ejemplo:
Sumar.java
public class Sumar {

public static float suma(float a, float b) {
System.out.println("Suma de reales");
return a + b;
}
public static int suma(int a, int b) {
System.out.println("Suma de enteros");
return a + b;
}

float x = 1;
float y = 2;
int v = 3;
int w = 5;
System.out.println(suma(x, y));
System.out.println(suma(v, w));
}
}
La aplicación más habitual de la sobrecarga de métodos es la sobrecarga

de constructores.
Rectangulo2.java
public class Rectangulo2 {

private float x1;
private float y1;
private float x2;
private float y2;
public Rectangulo2(float ex1, float ey1, float ex2, float ey2) {

x1 = ex1;
x2 = ex2;
y1 = ey1;
y2 = ey2;
}
public Rectangulo2() {
x1 = 0;
x2 = 0;
y1 = 1;
y2 = 1;
}
public float calcularArea() {

return (x2 - x1) * (y2 - y1);
}

Rectangulo2 prueba1 = new Rectangulo2(1, 4, 7, 6);
Rectangulo2 prueba2 = new Rectangulo2();
System.out.println(prueba1.calcularArea());
}
}
2.4. Utilización de this
El lenguaje Java incluye una referencia especial llamada this, utilizada en cual-
quier método para referenciar el objete actual. El valor this se refiere al objeto
sobre el que se ha llamado el método actual.
Ejemplo
En este ejemplo, la referencia this
indica el objeto en curso, y ello
Triangulo4.java permite resolver la ambigüedad
referente a los nombres
de los parámetros.
class Triangulo4 {
public Triangulo4(double base, double altura) {

this.base = base;
this.altura = altura;
}
}
Un aspecto interesante del uso de this es que resuelve la dificultad que a veces
se presenta al identificar sobre qué objeto se está trabajando.
Supongamos un caso en que se tiene una clase, que cuenta con un método de
transferencia. Dicho método transfiere todo el dinero de una cuenta, indicada
por parámetro, a la cuenta que representa el objeto en curso. La clase Cuenta y
el método transferencia podrían implementarse del siguiente modo:
Cuenta.java
class Cuenta {
public double saldo;
public String idCuenta;
// constructor apertura cuenta

public Cuenta(String id) {
saldo = 0;
idCuenta = id;
}
public double getSaldo() {

return saldo;
}
public String getidCuenta() {

return idCuenta;
}
public void ingresar(double dinero) {

saldo += dinero;
}
public void transferencia(cuenta origen) {

saldo += origen.saldo;
origen.saldo = 0;
}
}
¿Qué sucede si se lleva a cabo una transferencia cuando la cuenta representada

por el objeto en curso y el origen es la misma?
PruebaCuenta.java
public class PruebaCuenta {

Cuenta cc1;
Cuenta cc2;
cc1 = new Cuenta("x32001-a2");
cc1.ingresar(100000);
cc2 = cc1;
cc1.transferencia(cc2);
System.out.println("Saldo primera cuenta: " + cc1.getSaldo() +
" Saldo segunda cuenta: " + cc2.getSaldo());
}
}
El resultado es la eliminación de la cuenta de origen y de destino, puesto que

Esta solución funciona si el
ambas son, en realidad, la misma. Una posible solución a este problema sería identificador de cuentas es único
para cada uno, ya que ello permite
comprobar la igualdad
la siguiente: de los identificadores
correspondientes a las cuentas.
PruebaCuenta2.java
class Cuenta2 {
public double saldo;
public String idCuenta;
// constructor apertura cuenta

public Cuenta2(String id) {
saldo = 0;
idCuenta = id;
}
public double getSaldo() {

return saldo;
}
public String getIdCuenta() {

return idCuenta;
}
public void ingresar(double dinero) {

saldo += dinero;
}
public void transferencia(Cuenta2 origen) {

if (this.idCuenta.equals(origen.idCuenta)) {
System.out.println("Error de transferencia entre
cuentas iguales");
} else {
saldo += origen.saldo;
origen.saldo = 0;
}
}
}
public class PruebaCuenta2 {

Cuenta2 cc1;
Cuenta2 cc2;
c1 = new Cuenta2("x32001-a2");
cc1.ingresar(100000);
cc2 = cc1;
cc1.transferencia(cc2);
System.out.println("Saldo primera cuenta: " + cc1.getSaldo() +
" Saldo segunda cuenta: " + cc2.getSaldo());
}
}
Veamos más ejemplos del uso del identificador this.
public class Prueba {

private int i = 0;
Prueba sucesor() {
i++;
Al ejecutar este programa retorna
return this; un 2: el método sucesor no sólo
} incrementa la propiedad privada y,
sino que se retorna a sí mismo, y
ello permite llamarlo varias veces
Prueba escribir() { en el mismo orden.
System.out.println(i);
return this;
}

Prueba x = new Prueba();
x.sucesor().sucesor().escribir();
}
}
This también puede emplearse como método, o más bien como constructor,
lo que puede ser muy cómodo si se tienen distintos constructores con paráme-
tros diferentes, puesto que permite que se llamen entre sí:
Rectangulo3.java
public class Rectangulo3 {

private float x1;
private float y1;
private float x2;
private float y2;
public Rectangulo3(float ex1, float ey1, float ex2, float ey2) {

x1 = ex1;
x2 = ex2;
y1 = ey1;
y2 = ey2;
}
public Rectangulo3() {
El segundo constructor, en lugar de
this(0, 0, 1, 1); modificar directament el valor de
las variables, llama al constructor
} que, al utilizar this admite cuatro
parámetros.
public float calcularArea() {
return (x2 - x1) * (y2 - y1);
}

Rectangulo3 prueba1 = new Rectangulo3(1, 4, 7, 6);
Rectangulo3 prueba2 = new Rectangulo3();
}
}
2.5. Atributos estáticos
Los atributos estáticos se emplean cuando es preciso que todos los elementos
de la clase puedan acceder a una variable. Estas variables también se conocen
como variables de clase y se declaran con el modificador static.
class Ejemplo {
int x; // x es una variable de instancia
static int y; // y es global en todas las instancias
}
Cuando se declare un nuevo objeto de tipo ejemplar, incluirá una instancia

particular de la variable x, mientras que la variable y se comporta como una
variable global para todas las instancies de la clase. Normalmente estas varia-
bles se emplean para mantener información referente a todos los objetos de la
clase, por ejemplo, para mantenir un contador de instancias creadas.
El acceso a las variables de clase se realiza con la notación punto.
Ejemplo
PruebaEj.java
class Ejemplo {
static int contador = 0;
int x;
public Ejemplo() {
contador++;
}
}
class PruebaEj { Cada vez que se crea un objeto,

public static void main(String[] args) { se incrementa el contador global
Ejemplo ej1 = new Ejemplo(); asociado a la clase.
Ejemplo [] vej = new Ejemplo[100];
for (int i = 0; i < 100; i++)

vej[i] = new Ejemplo ();
int numTotal = Ejemplo.contador;
System.out.println("Numero: " + numTotal);
}
}
Los atributos estáticos también son útiles para definir constantes simbólicas,
independientemente de los objetos específicos que se construyen. En este ca-
so, también se utiliza el modificador final, mediante el cual se define la no mo-
dificabilidad del elemento que lo contiene. Así, todas las instancias de clases
que se creen pueden acceder a la constante.
Ejemplo
En Java, la clase predefinida Integer contiene la siguiente definición:
public final static int MAX_VALUE = 2147483647;
Esta definición también puede escribirse como sigue:
System.out.println("Max Int: " + Integer.MAX_VALUE);

Las variables de tipo static son, en ciertos aspectos, similares a las varia-
bles globales de algunos lenguajes. El lenguaje Java no tiene variables
globales, pero sí static, a las que se puede tener acceso desde cualquier
instancia de una clase.
2.6. Métodos static
Los métodos con el modificador static, igual que las variables de clase, son pro-
Ejemplo
pios de la clase, sin que se apliquen específicamente a ningún objeto de la cla-
se. Es decir, puede emplearse sin crear ninguna instancia de la clase. Estos Son métodos static algunos de
los predefinidos por el lenguaje
métodos también se denominan métodos de clase. como la clase Math, en la que
las funciones trigonométricas
y logarítmicas son de tipo static.
Ejemplo
....
System.out.println("El mínimo es " + Math.min(2,3));
...
Otro ejemplo
LaFuncion.java Uso.java
public class LaFuncion {

public static int anade(int x, int y) {
return x + y;
}
}
public class Uso {
int a = 9;
int b = 10;
int c = LaFuncion.anade(a, b);
System.out.println("anade() da como resultado " + c);
}
}
Los métodos estáticos, o con responsabilidad de clase, permiten llevar a

cabo un conjunto de acciones y operaciones sin instancia de la clase; es
decir, no están asociados con ningún objeto en particular.
Normalmente, los métodos estáticos se emplean para llevar a cabo ac-

ciones comunes a todas las instancias.
Los métodos estáticos incorporan la palabra clave static como modifica-

dor del método (antes del tipo de retorno).
– Los métodos static pueden invocarse independientemente de cualquier instancia de la

clase; se invocan utilizando el nombre de la clase como receptor del mensaje.
– Los métodos responsabilidad de clase no pueden acceder a las variables de instancia,

puesto que el receptor no es un objeto y, por lo tanto, no tienen variables de instancia.
La única forma de acceder es creando una instancia de la misma clase, y acceder a los
atributos de instancia del nuevo objeto.
– El método main() es estático, porque la aplicación debe acceder a él para ejecutarse, an-
tes de que se haga cualquier instancia.
3. Relaciones entre clases
3.1. Agregación
Esta relación también se conoce como is-part-of , y solemos encontrarla en los En el ejemplo de diseño de clases
que cierra este apartado, veremos
una relación de agregación entre
tres casos siguientes: las clases Departamento - Asignatura
y Departamento - Alumno.
• Acoplamientos-partes. Por ejemplo, una máquina y sus piezas o una vi-

vienda y cada una de sus habitaciones.
• Continente-contenido. Por ejemplo, un avión y su tripulación o el caso de

la cuenta bancaria y sus transacciones.
• Colecciones-miembros. Por ejemplo, un departamento y sus miembros o

un equipo de fútbol y sus jugadores.
Normalmente, en una relación de agregación entre dos clases, una de

éstas debe contener una lista de objetos de la otra.
3.2. Asociación
Esta relación también se conoce como has-knowledge-of.
Podríamos decir que la relación de asociación se sobreentiende siempre que

existe una relación de agregación. La relación de agregación es más fuerte que
la de asociación: las clases que intervienen en una agregación se conocen entre
ellas.
Ejemplo
La empresa tiene conocimiento de la existencia de los trabajadores, es decir, existe

una relación de asociación entre empresa y trabajador. Pero al haber identificado tra-
bajador como “es-parte-de” una empresa, hablaremos de agregación y no de asocia-
ción entre empresa y trabajador.
Para identificar asociaciones entre clases, se mira si puede accederse a

una clase desde la otra.
Por ejemplo, si una clase directivo tiene un atributo referido a su secreta-

rio, el directivo puede acceder siempe a su secretario. Por lo tanto, nos en-
contramos ante una relación de asociación entre directivo y secretario.
3.3. Uso
Esta relación también se conoce como depends-on, es decir, para su funciona-

miento una de las clases depende de la existencia de la otra.
Decimos que existe una relación de uso entre la clase A y la clase B si en

Recordad
algún momento la clase A tiene que llamar algún método de la clase B.
Los constructores de una clase
también son métodos.
Casi siempre que existe una relación de agregación o de asociación entre dos
clases, también se da una relación de uso entre éstas, al menos en una direc-
ción. Pero la relación de uso es la más débil que existe, y si hay otras relaciones
ya no se dibuja.
Ejemplo
Al analizar la relación de agregación entre empresa y trabajador (la lista de trabajadores),

se aprecia con bastante facilidad que también existe una relación de uso de estas dos cla-
ses, puesto que la empresa depende de la existencia de la clase Trabajador para funcionar.
La siguiente figura muestra cómo se representan estas relaciones en UML:
3.4. Ejemplo de diseño de clases
Al programar en orientación al objeto, es preciso saber en primer lugar qué cla-

Con lo que hemos visto, ya estamos
ses intervendrán en el problema, con qué atributos y qué métodos. en condiciones de presentar
un ejemplo completo de diseño
de clases.
Supongamos que hay que guardar los datos referentes a los alumnos y a las
asignaturas de un colegio.
En cuanto a los alumnos, interesa conocer su nombre y DNI. Así, será necesa-
rio crear una clase alumno con los atributos nombre y DNI:
Alumno.java
public class Alumno {
String nombre;
long dni;
public alumno(String str, long n) {

nombre = str;
dni = n;
}
public String toString() {

return (nombre + " " + dni);
}
}
En cuanto a las asignaturas, interesa saber cuantas se han creado, el nombre,

el código y qué alumnos cursan cada una de éstas.
Además, también será necesario definir los siguientes métodos:
• Un método que permita añadir un alumno a una asignatura.

• Un método que permita listar a los alumnos de una asignatura.
Asignatura.java
importe java.util.*;
public class Asignatura {
private static long nasignaturas = 0;

String nombre;
long codigo;
private Vector alumnos = new Vector();
public asignatura(String str) {

nombre = str;
codigo = generarCodigo();
}
private static long generarCodigo() {

return nasignaturas++;
}
public void matricular(Alumno al) {

alumnos.addElemento(al);
}

return "Asignatura: " + nombre + "\tCodigo: " + codigo;
}
public String listaAlumnos() {

Enumeration enum = alumnos.elementos();
StringBuffer lista =
new StringBuffer("Alumnos matriculados:\n");
while (enum.hasMoreElemens()) {
Alumno alumno = (Alumno) enum.nextElemento();
lista.append(alumno.toString() + "\n");
}
return lista.toString();
}
}
Además, habrá que definir una clase que se utilizará para llevar a cabo el man-
tenimiento de la información sobre las asignaturas y alumnos del colegio. Por
ello, se crea la clase Departamento, que contiene la lista de alumnos y la de las
asignaturas que se imparten y las mantiene.
Departamento.java
import java.util.*;
public class Departamento {

private Vector asignaturas = new Vector();
private Vector alumnos = new Vector();
public void matricular(Alumno al, Asignatura asig) {

asig.matricular(al);
}
public Alumno nuevoAlumno(String nombre, long dni) {
Alumno alumno = new Alumno(nombre, dni);
alumnos.addElemento(alumno);
return alumno;
}
public Alumno buscarAlumno(long dni) {
Enumeration enum = alumnos.elementos();
while (enum.hasMoreElements()) {
Alumno alumno = (Alumno) enum.nextElement();
if (alumno.dni == dni) {
return alumno;
}
}
return null;
}
public Asignatura nuevaAsignatura(String nombre) {

Asignatura asig = new Asignatura(nombre);
Asignaturas.addElement(asig);
return asig;
}
public Asignatura buscarAsignatura(long codigo) {
Enumeration enum = asignaturas.elementos();
Asignatura asig = (Asignatura) enum.nextElement();
if (asig.codigo == codigo) {
return asig;
}
}
return null;
}
public String listaAsignaturas() {
Enumeration enum = asignaturas.elementos();
StringBuffer lista = new StringBuffer();
Asignatura asig = (Asignatura) enum.nextElement();
lista.append(asig.toString() + "\n");
}
return lista.toString();
}
}
Finalmente, se precisa una clase que gestione la entrada/salida de datos, que

presente el menú de opciones al usuario y llame a las clases pertinentes. Para
esta función se define la clase secretaria.
Secretaria.java
import java.io.*;
public class Secretaria {

static BufferedReader reader = new BufferedReader
(new InputStreamReader(System.in));
static long readLong() throws IOException {

return Integer.valueOf(readln()).longValue();
}
static String readln() throws IOException {

return reader.readLine();
}
static void matricularAlumno(Departament dpt) throws IOException {

System.out.print("DNI alumno: ");
long dni = readLong();

Alumno alumno = dpt.buscarAlumno(dni);
if (alumno == null) {
System.out.print("Nombre: ");
String nombre = readln();

alumno = dpt.nuevoAlumno(nombre, dni);
}
System.out.print("Código asignatura: ");
long codigo = readLong();

Asignatura asignatura = dpt.buscarAsignatura(codigo);
if (asignatura == null) {
System.out.println("Asignatura no existe");
return;
}
dpt.matricular(alumno, asignatura);
System.out.println("Operación realizada");
}
static void nuevaAsignatura(Departamento dpt) throws IOException {
System.out.print("Nombre asignatura: ");
String nombre = readln();

Asignatura asignatura = dpt.nuevaAsignatura(nombre);
System.out.println(asignatura.toString());
}
static void mostrarMatriculados(Departamento dpt) throws IOException {

System.out.print("Código asignatura: ");
long codigo = readLong();

Asignatura asignatura = dpt.buscarAsignatura(codigo);
if (asignatura == null) {
System.out.println("Asignatura no existente");
return;
}
System.out.println(asignatura.listaAlumnos());
}
static void mostrarAsignatures(Departamento dpt) throws IOException {

System.out.println(dpt.listaAsignaturas());
}

Departamento dpt = new Departamento();
int opcio;
do {
System.out.println("Escoge la opción");
System.out.println(" 1. Matricular alumno");
System.out.println(" 2. Crear nueva asignatura");
System.out.println(" 3. Mostrar asignaturas");
System.out.println(" 4. Mostrar alumnos matriculados");
System.out.println(" 5. Acabar");
System.out.print("Teclea la opción");
opcion = (int) readLong();
switch (opcion) {
case 1:
matricularAlumno(dpt);
break;
case 2:
nuevaAsignatura(dpt);
break;
case 3:
mostrarAsignaturas(dpt);
break;
case 4:
mostrarMatriculados(dpt);
break;
case 5:
break;
}
} while (opcion != 5);
}
}
3.5. Herencia simple
Esta relación también se conoce como is-a, y es la solución de Java para casos
tan comunes como el siguiente: después de haber creado una clase, se necesita
una versión más especializada.
Por ejemplo, se ha creado la clase Empleado con sus datos, y es preciso crear la
clase Secretaria, que tendrá todos los datos de Empleado y unos datos privativos.
Puede decirse que Secretaria es un empleado con características adicionales.
public class Empleado {

String nombre
Date inicioTrabajo;
Date fechaNacimiento;
String titulacion;
}
public class Secretaria {

String nombre;
Date inicioTrabajo ;
Date fechaNacimiento;
String titulacion;
String departamento;
Empleado [ ] listaEmpleados;
}
Al definir Secretaria se han duplicado los datos que ya se habían incluido en

Empleado. La herencia simple soluciona este problema mediante la palabra re-
servada extends.
public class Secretaria extends Empleado {

Empleado [ ] listaEmpleados;
}
La clase Secretaria es una subclase de Empleado y hereda de él todos los métodos

y características (atributos).
Aunque una subclase hereda los métodos y las variables de la clase pa-
dre, no hereda de ella los constructores.
Todas las clases que se crean heredan de una clase padre global que es
la clase Object.
Otro ejemplo de herencia simple
Punto.java
class Punto {
int x;
int y;
float norm() {
return (x * x) + (y * y);
}
Punto borrar() {
x = y = 0;
return this;
}
Punto mover(int dx, int dy) {

x += dx;
y += dy;
return this;
}
}
Ahora se creará la clase PuntoColor añadiendo un atributo y rescribiendo el método mover:
PuntoColor.java
class PuntoColor extends Punto {

String c;
boolean esBlanco() {
return c.equals("white");
}
Punto mover(int dx, int dy) {

x += dx;
y += dy;
c = "white";
return this;
}
}
3.6. La palabra reservada super
La palabra reservada super apunta a alguna variable o método de la superclase

de la clase en que se emplea la palabra.
Ejemplo
En las clases Empleado y Secretaria tendríamos los siguientes métodos constructores:
Empleado.java
public class Empleado {

String nombre;
String titulacion;
public Empleado(String a, String tit) {

nombre = a;
titulacion = tit;
}
}
Secre.java
public class Secre extends Empleado {

Empleado[] listaEmpleados;
public Secre(String a, String tit, String d) {

super(a, tit);
departamento = d;
listaEmpleados = new Empleado[20];
}
}
3.7. El operador instanceof
Dado que los objetos pueden ser apuntados por variables definidas del tipo de
la clase padre y pueden pasarse a los métodos, a menudo es preciso conocer
qué se ha pasado en realidad. Esta es la función del operador instanceof.
Ejemplo
public class Empleado [extends Object] // No es necesario poner

En C++, el método runtime-type
// el extends porque toda la clase hereda de Object information realiza esta función.
public class Secretaria extends Empleado
public class Jefe extends Empleado
Si un método recibe un objeto apuntado por una variable de tipo Empleado,

puede ser que se le haya pasado una instancia de Secretaria o de Jefe .
Puede comprobarse qué es por medio del operador instanceof del siguiente
modo:
public void metodo(Empleado e) {

if (e instanceof Secretaria) {
...
} else if (e instanceof Jefe) {
...
} else {
// empleado normal
}
}
El operador instanceof verifica el tipo de un objeto. Si no se ha llevado a cabo la

conversión y se intenta acceder
al departamento, el compilador no
encuentra el miembro departamento
Si se tiene un objeto apuntado por una variable del tipo de la clase padre y se en la clase Empleado.
ha comprobado, mediante instanceof, que pertenece a una subclase, puede ob-

tenerse con una conversión del puntero:
public void metode(Empleado e) {

if (e instanceof Secretaria) {
Secretaria m = (Secretaria) e;
System.out.println("El departamento es "+m.departamento);
}
}
3.8. Redefinición de métodos
Para crear una clase nueva a partir de una ya existente, añadiéndole caracterís-
Sobrecarga
ticas nuevas, puede modificarse el comportamiento de la clase existente defi- de métodos
niendo en la clase nueva un método con el mismo nombre que la clase padre, Llamamos sobrecarga de méto-
dos a la existencia de métodos
el mismo tipo de retorno y la misma lista de argumentos. Lo llamamos redefi- con el mismo nobre, pero con
una lista de parámetros distin-
nición de métodos. ta, dentro de una misma clase.
La lista de parámetros indica
al compilador qué método se
Cuando se redefine un método hay que tener en cuenta lo siguiente: está invocando.
– El tipo de retorno de los dos métodos debe ser igual.
– El método de la subclase no puede ser menos acesible que el de la cla-

se padre.
– El método de la subclase no puede provocar más excepciones que el

método padre.
3.9. Visibilidad de atributos y métodos
El modificador public hace que los métodos o clases sean accesibles desde cual-
quier lugar.
El modificador private hace que los métodos o atributos no sean visibles desde
fuera de la clase. Para cualquiera que se encuentre fuera de la clase, es como si
no existieran, porque no los puede ver.
Si se desea que un método o una variable sean accesibles desde el exte-

rior de la clase, deben declararse public; en caso contrario, se declaran
private.
Los métodos que aparecen en la interfaz deben declararse public, porque tienen que ser
accesibles desde fuera de la clase.
Al no aparecer en la interfaz, los métodos secundarios sólo sirven para facilitar la imple-
mentación de los métodos public, no es necesarios declararlos public. Lo mismo sucede
con las variables.
El modificador protected es menos restrictivo que private y permite que los mé-
todos o atributos definidos como protected sean visibles desde su clase y las
subclases que dependen de él.
Ejemplo
Si se tienen una clase Z con atributos privados y una clase M que hereda la clase Z, la clase
M puede emplear los atributos de Z si se han declarado private? ¿Y si se han declarado
protected?
¡Vamos a comprobarlo!
A.java
public class A {
private String nombre;
private String apellidos;
public A(String nombre, String apellidos) {

this.nombre = nombre;
this.apellidos = apellidos;
}

return (nombre + " " + apellidos);
}
}
B.java
public class B extends A {

public B(String nombre, String apellidos) {
super(nombre, apellidos);
}
public String toStringInverso() {

return (apellidos + ", " + nombre);
}
}
Al compilar A.java todo va bien... pero al realizar
javac B.java
aparecen estos errores:
B.java:11: Undefined variable: apellidos

^
B.java:11: Undefined variable: nombre
^
2 errores
3.10. El modificador abstract
El modificador abstract convierte una clase en abstracta, que consta de un mé-

todo, o más, codificado en sus clases hijas, lo que obliga a heredar; al contra-
rio, no podrían instanciarse los métodos codificados en las clases hijas.
– Los métodos que no se han implementado en la clase, también deben marcarse como
abstract.
– No puede crearse una instancia de una clase abstracta.
– No pueden definirse constructores abstractos o métodos estáticos abstractos.
– Las subclases de las clases abstractas deben implementar todos los métodos abstractos
que se han declarado en las clases padre.
3.11. El modificador final
El modificador final se utiliza para impedir que una clase pueda modificarse.
Ejemplo
Al declarar una clase como final, estamos indicando que se encuentra al final
de la jerarquía de clases, y ello impide que pueda heredarse. La clase java.lang.String, que
proporciona el mismo lengua-
je, es una clase final.
Los métodos también pueden definirse como finales. Los métodos marcados con la pala-
bra resenvada final no se pueden sobrescribir o redefinir. Esto será útil cuando la imple-
mentación de un método no pueda cambiarse porque, al hacerlo, por ejemplo, se pone
¡Alerta!
en peligro la consistencia de la clase.
Los métodos static o private
son final automáticamente.
En programación orientada al objeto no se puede declarar una clase abstract y Si una variable se marca
final a la vez: se estaría obligando e impidiendo, al mismo tiempo, la herencia con la palabra reservada final,
se convierte en una constante.
de esta clase.
Si se está programando en Java y, accidentalmente, se incurre en este error, el

compilar dará error al hacer la declaración.
Una interfaz es una variación de la idea de clase abstracta. En una interfaz to-
dos los métodos son abstractos, ninguno puede tener cuerpo y sólo pueden de-
finirse variables estáticas y finales.
Las interfaces se definen con la palabra reservada interface. Una clase puede
instanceof
implementar muchas interfaces. La implementación de la interfaz se indica al
final de la declaración de la clase y es una lista separada por comas. Puede emplearse el operador
instanceof para determinar
si la clase implementa una
interfaz.
Una clase sólo puede heredar de otra, pero puede definir todas las inter-
faces que precise.
Cuando una clase implementa una interfaz, debe implementar todos

sus métodos.
4. Breve introducción a UML
El lenguaje unificado de modelización (UML) es un lenguaje gráfico y flexible UML: unified modeling language
de modelización que permite describir modelos que representan sistemas (tan-
to de software como del mundo real) basándose en los conceptos de la orien-
tación al objeto.
La especificación, implementación, prueba y documentación de un sistema

http://www.omg.org
http://www.rational.com/
con gran cantidad de software requiere que el sistema pueda ser visto por dife- index.jtmpl
http://uml.shl.com
rentes usuarios (usuarios finales, analistas, desarrolladores, integradores de sis-
temas, encargados de los tests, encargados de la documentación técnica, jefes
de proyectos, etc.), cada uno con su punto de vista en distintos momentos du-
rante la vida del proyecto.
Los diagramas (representaciones gráficas de un conjunto de elementos) permi-

Bibliografía
ten visualizar un sistema desde varias perspectivas: un diagrama es una pro- recomendada
yección de un sistema. G. Booch; J. Rumbaugh; Y.
Jacobson (1999). The Unified
Modeling Language User Guide.
UML proporciona hasta nueve diagramas diferentes que permiten cubrir todo el Addison Wesley (traducción
castellana: El lenguaje
abanico de las distintas vistas del sistema que requieren estos usuarios. Sólo estu- unificado de modelado).
diaremos el diagrama de clases, posiblemente el más utilizado en sistemas orien-
tados al objeto y el único al que se hace referencia en esta asignatura.
4.1. El diagrama de clases
Un diagrama de clases permite definir un modelo que describe un sistema,

concretamente permite diseñar un modelo estático del sistema. Un diagrama
de clases describe la visión estática del sistema en términos de clases y de las
relaciones entre éstas. Aunque tiene semejanzas con los modelos de datos, re-
cordad que las clases no sólo estructuran la información, sino que también
describen su comportamiento.
En un diagrama de clases sólo representamos las clases.
Para crear un diagrama de clases, es preciso identificar y describir cada una de

las clases y representar las relaciones que se establecen entre éstas.
Una clase se representa mediante un rectángulo dividido en tres comparti-

mentos:
La sintaxis que se emplea en cada compartimento es independiente del len-

guaje de programación utilizado en el momento de la implementación.
4.1.1. El compartimento del nombre
El compartimento superior del rectángulo contiene el nombre de la clase, que

se escribe en negrita y centrado.
El nombre debe ser significativo (derivado del dominio del problema), no

ambiguo y lo más simple posible. El nombre de la clase empieza en mayús-
cula y, si fuera compuesto, habría que escribir todas las palabras seguidas
(sin espacios) y la primera letra de cada palabra en mayúscula.
4.1.2. El compartimento de los atributos
El compartimento central del rectángulo contiene el nombre de los atributos

Atributo
de la clase. Los atributos describen las características del objeto. La notación
Un atributo de una clase alma-
de los atributos es la siguiente:
cena la información que descri-
be e identifica una instancia
específica de la clase.
nombre : tipo
El tipo de un atributo puede ser

cualquier clase o bien un tipo
primitivo (int, char, etc.). En este
caso, potencia es int.
Sólo hay que incluir los atributos que interesen para diseñar el sistema.
Como ya sabemos, los atributos tienen distinta visibilidad:

Visibilidad
La visibilidad se indica delante

• La visibilidad pública se expresa con el signo más (+).
del atributo.
• La visibilidad privada se expresa con el signo menos (-).
• La visibilidad protegida se expresa con el signo (#)
4.1.3. El compartimento de las operaciones
El compartimento inferior del rectángulo contiene el nombre de las operacio-

nes de la clase. Las operaciones permiten manipular los atributos o ejecutar
otras acciones que definen el comportamiento del objeto. Las operaciones, o
métodos, describen lo que puede hacer una clase y los servicios que pueden
ofrecer las instancias de ésta. También se dice que los métodos son la interfaz
de la clase. La notación de las operaciones es la siguiente:
Signatura * (parámetro : tipo, parámetro : tipo...)

* La signatura es el nombre
de la operación.
4.1.4. Las relaciones entre clases
Una relación puede definirse como una conexión entre elementos. En mode-
lización de objetos, las principales relaciones que pueden establecerse son las
siguientes:
• Asociación
• Agregación
• Generalización
• Dependencia
Asociación
Asociación
Las asociaciones representan

En UML se define una asociación como una relación que describe un con- relaciones (estructurales) entre
instancias de clases.
junto de vínculos, entendiendo como vínculo una conexión semántica en-
tre clases. Un ejemplo de asociación podría ser el hecho de que una persona
trabaja para una empresa, o que una empresa tiene cierta cantidad de ofi-
cinas.
Una asociación normal entre dos clases representa una relación estruc-
tural entre iguales, o sea, las dos clases están conceptualmente al mismo
nivel, sin que una sea más importante que otra.
La asociación se representa gráficamente mediante una línea sólida entre las

dos clases. La asociación puede tener un nombre (normalmente se trata de un
verbo).
Cuando se modeliza un diagrama, éste debe reflejar, con la máxima fi-

delidad posible, el sistema que se está construyendo. Por lo tanto, es re-
comendable que el nombre de la asociación provenga del dominio del
problema.
Si no se indica lo contrario, una asociación es bidireccional (puede navegarse

en ambas direcciones). En determinadas situaciones conviene restringir la na-
vegación en una de las direcciones. Esto se representa gráficamente añadiendo
una flecha al final de la asociación, que indica que la asociación sólo puede
emplearse en dicha dirección.
Una asociación puede tener dos nombres, uno para cada dirección. La direc-
ción de cada etiqueta se indica mediante un triángulo opaco cuya punta in-
dica la dirección (en la “base” del triángulo se escribe la etiqueta de la
asociación):
En el ejemplo sólo vemos un rectángulo con el nombre de la clase (no tenemos toda la
descripción de la clase: nombre, atributos y métodos. Esto es para simplificar y para que
los diagramas sean más compactos y más fáciles de leer, pero debería haber un diagrama
previo en que cada clase estuviera totalmente especificada.
Las asociaciones y las restantes relaciones entre clases pueden tener un cuan-
tificador que indica cuántos objetos están vinculados. El rango puede ser de
cero a uno (0..1), de cero a muchos (0..* ), de uno a muchos (1..*), de dos (2),
de cinco a once (5..11), etc. Si no se especifica nada, se toma el valor 1 por de-
fecto. El rango se indica al principio y al fin de la relación.
Agregación
La agregación es un tipo especial de asociación en que la relación que se establece

entre las instancias es del tipo “parte de un todo”; es decir, existe una clase que
representa un elemento grande (el todo) que consta de elementos más pequeños
(las partes). La agregación se representa gráficamente mediante un diamante va-
cío en la parte del “todo”:
Generalización (herencia)
Una generalización es una relación entre un elemento general (superclase o

padre) y otro más específico (subclase o hijo).
La generalización es una relación entre clases, nunca entre instancias (una clase puede
heredar de otra, pero un objeto sólo existe en tiempo de ejecución y no tiene sentido ha-
blar de herencia en cuanto a objetos), aunque las instancias están directamente afectadas
(polimorfismo) por su tipo.
Normalmente, el elemento más específico sólo contiene información adicio-

Ejemplo
nal del más general. Una instancia del elemento más específico puede utilizar-
se como si fuera un elemento más general. La relación que existe entre
Persona (clase més general) y
Empleado (clase más específica):
un empleado “es una” persona.
La subclase hereda de la superclase los atributos, métodos y asociaciones.
Visibilidad
Los atributos y métodos que eran públicos en la superclase, también lo serán en la sub-
clase.
Los miembros (atributos y métodos) con visibilidad privada en la superclase, los hereda
la subclase, pero no son accesibles dentro de la subclase.
Para proteger los atributos y/o métodos de la superclase y de la subclase del acceso exter-
no y conseguir que, a mismo tiempo, sean accesibles para ambas, podemos declararlos
protegidos.
Gráficamente, una generalización se representa con una línea sólida desde la

subclase hacia la superclase, que acaba con un gran triángulo vacío:
Dependencia (uso)
Una dependencia es una relación de uso (un elemento emplea otro). La rela-
ción de dependencia es una conexión semántica entre dos elementes en que
uno depende del otro. Un cambio en el elemento independiente afectará al
dependiente, pero no al revés.
Ejemplos
Una clase que toma un objeto de otra clase como parámetro en alguno de sus métodos;
o una clase que llama a miembros estáticos de otra clase.
En estos casos, existe una dependencia de una clase con respecto a otra, pero no se da
una asociación explícita entre éstos.
La relación de dependencia se representa gráficamente como una línea discon-

tinua que acaba con una punta de flecha apuntando hacia el elemento depen-
diente:
Ejercicios de autoevaluación
1. ¿Existe algún método para saber si un carácter es una letra? Indicad su signatura y escribid
Pista
un ejemplo de uso.
2. Dado un entero, ¿cómo podemos obtener una cadena de caracteres con su representación? Pensad en la clase Character
(del paquete java.lang).
Indicad la signatura de la función o funciones que transforman un entero en un string y es-
cribid un ejemplo de uso con las representaciones hexadecimal, octal y decimal. Pista
3. Dada una cadena de caracteres que contiene el nombre de una persona, con un número
Pensad en la clase Integer
indeterminado de espacios al principio (por ejemplo “ 1111juan”), ¿cómo podríamos obte- (del paquete java.lang).
ner otra cadena con sólo la inicial del nombre en mayúscula?
Indicad la signatura de los métodos empleados. Pista
4. Para enviar mensajes al canal de salida estándar, también llamado consola, se envía un Pensad en la clase String
mensaje al objeto out de la clase System (por ejemplo, System.out.println("Hola")). (del paquete java.lang).
Indicad de qué tipo de objeto estamos hablando; o sea, cuál es la clase de este objeto out.
Pista
5. Editad el siguiente programa y guardadlo con el nombre TDoble.java en un archivo.
Pensad en la clase System
Después, compiladlo, ejecutadlo y localizad los siete errores que contiene. Debéis tener en (del paquete java.lang).
cuenta que los errores pueden ser tanto sintácticos como de programación.
Identificad cada uno de los errores en el código resaltándolo en negrita y subrayado. Además,
debéis indicar por qué se produce y cómo se soluciona.
1 /** Esta clase calcula el doble del número introducido */

2 public class TDoble2 {
3 /** Método empleado por la máquina virtual para ejecutar la clase*/
4 public static void main(String[] argv) {
5 // Definición de las variables.
6 int numero1;
7 int resultado;
8 string mensaje;
9
10 System.out.println("Cálculo del doble de un número introducido");
11 if (argv.length => 10)||(argv.length < 1) {
12 System.out.println("Error: Debéis introducir, como mínimo, 1 número y, como máximo, 10");
13 } else {
14 for(i = 0; i <= argv.length; i++);
15 {
16 numero1 = Integer.parseInt(argv[i]);
17 resultado = numero1 * 2;
18 mensaje = "El doble de " + " " + numero1 + " " + "es" + " " + resultado;
19 System.out.println(mensaje);
20 }
21 }
22 }
23 }
24
6. Realizad un programa en Java que, a partir de un número, indique si es par o impar.
7. Realizad un programa en Java que, a partir de un número, calcule su tabla de multiplicar.
8. Realizad un programa en Java que calcule el mayor de diez números introducidos como
parámetro por la línea de instrucciones.
9. Realizad un programa en Java que calcule el factorial de un número.
10. Realizad un programa en Java que lea un número e indique de qué números entre 1 y 10
es múltiplo.
11. Realizad un programa en Java que calcule el promedio de los números leídos, siempre y
cuando el último leído sea un 0.
12. Realizad un programa en Java que indique si un número dado es primo.

Recordad
13. Realizad un programa en Java que calcule la suma de los números entre 10 y 50.
Un número primo sólo es divi-
14. Realizad un programa en Java que reciba una cantidad de horas, minutos y segundos y sible por 1 y por sí mismo.
la incremente en 1 segundo.
15. Realizad un programa en Java que lea dos números y si ninguno acaba en 9, escriba su Ejemplo
cuadrado.
Entrada: 1h 54min 59seg
16. Realizad un programa en Java que lea un número entero e indique los dígitos pares que Salida: 1h 55min 0seg
tiene.
17. Realizad un programa en Java que calcule la suma de los números pares entre 100 y 200
utilizando un bucle for, un bucle while y un bucle do.
18. Realizad un programa en Java que, a partir de unas palabras, indique si son iguales.
19. Realizad un programa en Java que identifique si la palabra introducida es capicúa.
20. Realizad un programa en Java que retorne el seno, el coseno y la tangente de un ángulo
dado.
21. Realizad un programa en Java que, a partir de una frase, la escriba toda en mayúsculas.
22. Realizad un programa en Java que cuente la cantidad de vocales de una palabra.
23. Realizad un programa en Java que cuente los blancos de una frase.
24. Realizad un programa en Java que muestre todas las permutaciones de una cadena como
la siguiente: Ejemplo
Una variable x contiene un String que, a su vez, contiene tres caracteres diferentes (como, por Para la cadena abc, el progra-
ma retornaría lo siguiente:
ejemplo, “abc”).
abc
25. Realizad un programa en Java que, a partir de una frase, la escriba invertida. acb
bac
bca
26. Realizad un programa en Java que, a partir de un número en binario, lo escriba en decimal. cab
cba
27. Realizad un programa en Java que, a partir de un número en decimal, lo escriba en binario.
28. Realizad un programa en Java que, a partir de un número en una base determinada (de-
cimal, binario, octal, hexadecimal), lo pase a la base indicada como segundo parámetro
(decimal, binario, octal, hexadecimal).
29. Buscad en el API de Java todos los métodos que permiten trabajar con vectores y analizad
su utilidad.
30. Realizad un programa en Java que construya un array que guarde las letras del abecedario
y, posteriormente, las muestre en orden inverso y ocupando las posiciones pares del array.
31. Realizad un programa en Java que construya un array de enteros entre 1 y 100 y, poste-
riormente, los muestre en orden inverso y ocupando las posiciones impares del array.
32. Investigad, utilizando el API de Java, en qué paquete está guardada la clase Vector, qué mé-
todos (funciones y procedimientos) tiene y cómo hay que definirlo. Después, repetid los dos
ejercicios anteriores utilizando un vector en lugar de un array.
33. Realizad un programa en Java que sume 2 arrays y guarde el resultado en otro array. No
es preciso que solicitéis desde teclado los arrays de entrada. Ejemplo
023418910
34. Repetid el ejercicio anterior, pero empleando la clase Vector.
+137
35. Realizad un programa que indique cuántas veces aparece cada número entero especifica- 0 3 6 11 1 8 9 1 0
do en la línea de instrucciones. Considerad sólo los enteros entre 0 y 99.
36. Realizad una programa que lea una línea de caracteres de la pantalla, la escriba en ma-
yúsculas y dé la suma de todos los números que aparecen en ella.
37. Realizad un programa que, dado el código de un alumno y sus notas, calcule el promedio
de las notas. Utilizad un array bidimensional para guardar cinco alumnos y cinco notas.
Solucionario
1.
Signatura: +isLetter(ch : char): boolean
Ejemplo de uso: if (Character.isLetter(’A’) ) { ... }
2.
Signaturas:
+toString() : String
+toString(int i) : String
+toString(i : int, radix : int) : String
+toBinaryString(i : int) : String
+toHexString(i : int) : String
+toOctalString(i : int) : String
Ejemplo de uso:
Integer enter = new Integer(10);
String a = enter.toString();
String b = Integer.toString(10);
String c = Integer.toString(154,16);
String c2 = Integer.toHexString(154);
String d = Integer.toString (154,2);

String d2 = Integer.toBinaryString(154);
String e = Integer.toString (154,8);

String e2 = Integer.toOctalString(154);
3.
Signaturas:
+trim() : String
+substring(int beginIndex, int endIndex) : String
+toUpperCase(): String
Ejemplo de uso:
// s contiene un String como indica el anunciado.
String resul = s.trim();
resul = resul.substring(0,1);
resul = resul.toUpperCase();
// resul contiene un String con el primer carácter no blanco en mayúscula.
// también puede escribirse todo junto.
resul = s.trim().substring(0,1).toUpperCase();
4.
El atributo out es de la clase: java.io.PrintStream.
En otras palabras, es la clase PrintStream del paquete java.io
5.
1 /** Esta clase calcula el doble del número introducido */

2 public class TDoble2 {
3 /** Método empleado por la máquina virtual para ejecutar la clase*/
4 public static void main(String[] argv) {
5 // Definición de las variables.
6 int numero1;
7 int resultado;
8 String mensaje;
9
10 System.out.println("Cálculo del doble de un número introducido");
11 if ((argv.length >= 10)||(argv.length < 1)) {
12 System.out.println("Error: debéis introducir un mínimo de 1 número y un máximo de 10");
13 } else {
14 for(int i = 0;i <= argv.length;i++);
15 {
16 numero1 = Integer.parseInt(argv[i]);
17 resultado = numero1 * 2;
18 mensaje = "El doble de " + " " + numero1 + " " + "es" + " " + resultado;
19 System.out.println(mensaje);
20 }
21 }
22 }
23 }
24
Errores de compilación
Error 1: El nombre del archivo debe ser el mismo que el de la clase, así que debe cambiarse
el nombre del archivo o el de la clase. Otra posibilidad es quitar el modificador public de la
clase.
Por ello, el error que aparece al compilar es un mensaje del siguiente tipo:
public class TDoble2 must be defined in a file called "TDoble2.java"
Error 2: La clase String se escribe en mayúsculas (Java es un lenguaje que distingue entre ma-
yúsculas y minúsculas –case sensitive).
class String not found
Error 3: Faltan los paréntesis que engloban la disyunción en la condición de la línea 11.
Missing Term. Invalid Expression statement. ';' expected. Else without if

(todos éstos, derivados de la falta de cierre de paréntesis)
Error 4: => es incorrecto, hay que escribir >=
Missing Term =>
Error 5: Debe declararse el tipo de la variable i.
Undefined variable i
Error 6: Sobra el ";" de detrás del for. Si no lo quitamos, se le está diciendo a la máquina
virtual que recorra todos los parámetros (sin hacer nada en ninguno de ellos) y que, al final,
ejecute una sola vez el bloque situado entre las líneas 16 y 21.
Undefined variable i
Error de ejecución
Error 1: El array de strings que representan los parámetros de entrada como en la posición 0,
como hay n parámetros (argv.length), debemos parar en la posición n − 1 (argv.length-1).
También puede escribirse cambiando la comparación, en lugar de “para todo i menor o igual
a n − 1” también puede decirse “para todo i menor que n”.
Por este motivo, el error que aparece al compilar es un mensaje del tipo siguiente:
ArrayIndexOutOfBoundsExeption at TDoble2.main(Compiled Code)
6. ParImpar.java
/**Retorna si un número es par o impar*/

public class ParImpar {
// función que controla el número y los tipos de parámetros correcto
public static boolean controlErrores(String[] a) {

int i = 0;
boolean esnum = true;
if ((a.length) != 1) {
System.out.println("Error: Debéis introducir un parámetro");
esnum = false;
} else {
while ((i < a[0].length()) && (esnum)) {

if ((a[0].charAt(i) >= 'A') && (a[0].charAt(i) <= 'z')) {
System.out.println("Error: Debéis introducir números");
esnum = false;
}
i++;
}
}
return esnum;
}
public static void main(String[] argv) {

System.out.println("Números pares o impares");
if (controlErrores(argv)) {
if ((Integer.parseInt(argv[0]) % 2) != 0) {
System.out.println("El número " + argv[0] + " es impar");
} else {
System.out.println("El número " + argv[0] + " es par");
}
}
}
}
7. TablaMultiplicar.java
/**Tabla de multiplicar*/
public class TablaMultiplicar {
// función que controla el número y tipo de parámetros correctos
int i = 0;
esnum = false;
} else {

esnum = false;
}
i++;
}
}
return esnum;
}

System.out.println("Tabla de multiplicar");
for (int i = 0; i <= 10; i++)
System.out.println(argv[0] + " * " + i + " = " +
(Integer.parseInt(argv[0]) * i));
}
}
}
8. MayorDe10.java
/**Calcula el mayor de 10 números*/

public class MayorDe10 {
public static boolean esNumero(String a) {
int i = 0;
while ((i < a.length()) && (esnum)) {

if ((a.charAt(i) >= 'A') && (a.charAt(i) <= 'z')) {
esnum = false;
}
i++;
}
return esnum;
}

// Definición de las variables.
int numero = 0;
int resultat = 0;
System.out.println("Cálculo del mayor de 10 números");
if ((argv.length) != 10) {
System.out.println("Error: Debéis introducir 10 parámetros");
} else {
int i = 0;
while ((i < 10) && (esNumero(argv[i]))) {

nombre = Integer.parseInt(argv[i]);
if (numero > resultado) {

resultado = numero;
}
i++;
}
if (i == 10) {
System.out.println("El número mayor es: " + resultado);
}
}
}
}
9. Factorial.java
/**Calcula el factorial de un número*/

public class Factorial {
int i = 0;
esnum = false;
} else {

esnum = false;
}
i++;
}
}
return esnum;
}

// Definición de las variables
long fact = 1;
System.out.println("Cálculo del factorial de un número");
if (Integer.parseInt(argv[0]) == 0) {
fact = 1;
} else {
for (int i = Integer.parseInt(argv[0]) - 1; i >= 1; i--)
fact = fact * i;
}
System.out.println("El resultado es: " + fact);

}
}
}
10. Multiplos1y10.java
/**Calcula los números entre 1 y 10 que son múltiplos del parámetro*/

public class Multiplos1y10 {
int i = 0;
esnum = false;
} else {

esnum = false;
}
i++;
}
}
return esnum;
}

int numero = 0;
System.out.println("cálculo de los múltiplos entre 1 y 10" + " de
" + integer.parseInt(argv[0]));
if (Integer.parseInt(argv[0]) != 0) {
for (int i = 10; i >= 1; i--) {
if ((Integer.parseInt(argv[0]) % i) == 0) {
System.out.println("El número " + i + " es múltiplo");
}
}
}
}
}
}
11. PromedioNumeros.java
/**Calcula el promedio de los números introducidos*/

public class PromedioNumeros {
public static boolean controlErrores2(String[] a) {
int i = 0;
int j = 0;
if ((a.length) == 0) {
System.out.println("Error: No habéis introducido el parámetro");
esnum = false;
} else {
while ((j < a.length) && (esnum)) {
while ((i < a[j].length()) && (esnum)) {
if ((a[j].charAt(i) >= 'A') && (a[j].charAt(i) <= 'z')) {
esnum = false;
}
i++;
}
// while
j++;
i = 0;
}
if (esnum) {
if (!(a[(a.length) - 1].equals("0"))) {
System.out.println("Error: Última cifra debe ser un cero");
esnum = false;
}
}
}
// else
return esnum;
}

int suma = 0;
int numero = 0;
System.out.println("Calcula el promedio de los números leídos

hasta que introducimos un 0");
if (controlErrores2(argv)) {
for (int contador = argv.length - 2; contador >= 0; contador--) {
numero = integer.parseInt(argv[contador]);
suma = suma + numero;
}
System.out.println("El promedio de los números es: " +

(suma / ((argv.length) - 1)));
}
}
}
12. NumeroPrimo.java
/**Calcula si un número es primo*/

public class NumeroPrimo {
int i = 0;
esnum = false;
} else {

esnum = false;
}
i++;
}
}
return esnum;
}

int numdivisors = 0;
int numero = 0;
System.out.println("Calcula si el número " + argv[0] +
"es primo");
numero = Integer.parseInt(argv[0]);
for (int cont = numero; cont >= 1; cont--) {

if ((numero % cont) == 0) {
numDivisores = numDivisores + 1;
}
}
if ((numDivisores == 2) || (numero == 0) || (numero == 1)) {

System.out.println("El número es primo");
} else {
System.out.println("El número no es primo");
}
}
}
}
13. SumaNumeros.java
// Suma los números entre 10 y 50

public class SumaNumeros {
int numero = 50;
int suma = 0;
System.out.println("Calcula la suma de los números entre 1 y 50");
for (int max = 10; max <= numero; max++) {

suma = suma + max;
}
System.out.println("La suma de los números es: " + suma);

}
}
14. HorasMinutosSegundos.java
// Suma 1 segundo en una hora expresada en horas, minutos y segundos

public class HorasMinutosSegundos {
public static boolean controlErrores(String[] argv) {
int i = 0;
if (argv.length == 0) {
System.out.println("ERROR: Formato hh:mm:ss como parámetro");
} else {
System.out.println("Suma 1 segundo");
if ((argv[0].charAt(2) != ':') || (argv[0].charAt(5) != ':') ||

(argv[0].length() != 8)) {
System.out.println("ERROR: El formato no es válido");
} else {
while ((i < argv[0].length()) && (esnum)) {
if ((i != 2) && (i != 5) && (argv[0].charAt(i) >= 'A') &&
(argv[0].charAt(y) <= 'z')) {
esnum = false;
}
i++;
}
}
}
return esnum;
}

int horai;
int minutosi;
int segundosi;
horai = Integer.parseInt(argv[0].substring(0, 2));
minutosi = Integer.parseInt(argv[0].substring(3, 5));
segundosi = Integer.parseInt(argv[0].substring(6, 8));
if ((horai > 23) || (minutosi > 59) || (segundosi > 59)) {

System.out.println("ERROR: Algún dato no es correcto");
} else {
if (segundosi < 59) {
segundosi = segundosi + 1;
} else if (minutosi < 59) {
minutosi = minutosi + 1;
segundosi = 0;
} else if (horai < 23) {
horai = horai + 1;
minutosi = 0;
segundosi = 0;
} else {
horai = 0;
minutosi = 0;
segundosi = 0;
}
if (horai < 10) {

System.out.print("0" + horai + ":");
} else {
System.out.print(horai + ":");
}
if (minutosi < 10) {

System.out.print("0" + minutosi + ":");
} else {
System.out.print(minutosi + ":");
}
if (segundosi < 10) {

System.out.print("0" + segundosi);
} else {
System.out.print(segundosi);
}
}
}
}
}
15. Cuadrados9.java
public class Cuadrados9 {

int i = 0;
int j = 0;
if (a.length != 2) {
System.out.println(
"ERROR: Debéis introducir dos números como parámetros");
esnum = false;
} else {
System.out.println("ERROR: Debéis introducir números");
esnum = false;
}
i++;
}
// while
j++;
i = 0;
}
}
return esnum;
}

int j;
int k;
System.out.println(
"Retorna el cuadrado de los números que acaban en 9 entre " +
argv[0] + " i " + argv[1]);
j = Integer.parseInt(argv[0]);
k = Integer.parseInt(argv[1]);
while (j <= k) {
j++;
if (Integer.toString(j).endsWith("9")) {
System.out.println("El número " + j +
" acaba en 9 y tiene el cuadrado: " + (j * j));
}
}
}
}
}
16. DigitosPares.java
public class DigitosPares {

int i = 0;
System.out.println("ERROR: Debéis introducir un parámetro");
esnum = false;
} else {

esnum = false;
}
i++;
}
}
return esnum;
}

string parametro;
int num;
System.out.println("Dígitos pares del número entero " + argv[0]);
parametro = argv[0];
for (int i = 0; y < parametro.length(); i++) {

if ((parametro.substring(y i + 1)).compareTo("-") != 0) {
num = Integer.parseInt(parametro.substring(y, i + 1));
if ((num % 2) == 0) {
System.out.println(parametro.charAt(i));
}
}
}
}
}
}
17. SumaNumerosParesA.java
// Suma los números pares entre 100 y 200 empleando un bucle FOR
public class SumaNumerosParesA {
int suma = 0;
System.out.println("Suma los números pares entre 100 y 200");
for (int i = 100; i <= 200; i++) {

if ((i % 2) == 0) {
suma = suma + i;
}
}
System.out.println(suma);
}
}
SumaNumerosParesB.java
// Suma los números pares entre 100 y 200 empleando un bucle WHILE
public class SumaNumerosParesB {
int suma = 0;
int i = 0;

i = 100;
while (i <= 200) {

if ((i % 2) == 0) {
suma = suma + i;
}
i = i + 1;
}
}
}
SumaNumerosParesC.java
// Suma los números pares entre 100 y 200 empleando un bucle DO WHILE
public class SumaNumerosParesC {
int suma = 0;
int i = 0;

i = 100;
do {
if ((i % 2) == 0) {
suma = suma + i;
}
i = i + 1;
} while (i <= 200);
}
}
18. PalabrasIguales.java
public class PalabrasIguales {

String parametro;
int param;
int num;
if (argv.length != 2) {
System.out.println(
"ERROR: Debéis introducir dos palabras como parámetros");
} else {
System.out.println("Comprueba si las palabras " + argv[0] + " i " +
argv[1] + " son iguales");
if (argv[0].compareTo(argv[1]) == 0) {
System.out.println("Ambas palabras son idénticas");
} else {
System.out.println("Ambas palabras son diferentes");
}
}
}
}
19. PalabraCapicua.java
// Comprueba si una palabra es capicúa

public class PalabraCapicua {
int longitud = 0;
String izquierda = "";
String derecha = "";
int calculo = 0;
int i = 0;
System.out.println("ERROR: Debéis introducir una palabra
por parámetro");
} else {
System.out.println("Comprueba si la palabra " + argv[0] +
" es capicúa");
longitud = argv[0].length();
calculo = longitud / 2;
if ((longitud % 2) == 0) {
izquierda = argv[0].substring(0, calcul);
for (i = (calculo + calculo) - 1; i > (calculo - 1); i--) {

derecha = derecha.concat(argv[0].substring(i, i + 1));
}
}
// impar
else {
izquierda = argv[0].substring(0, calculo);
for (i = calculo + calculo; i > calculo; i--) {
derecha = derecha.concat(argv[0].substring(i, i + 1));
}
}
if (izquierda.compareTo(derecha) == 0) {
System.out.println("Es capicúa");
} else {
System.out.println("No es capicúa");
}
}
}
}
20. SenoCosenoTangente.java
// Retorna el seno, el coseno y la tangente de un ángulo

public class SenoCosenoTangente {
int i = 0;
esnum = false;
} else {

esnum = false;
}
i++;
}
}
return esnum;
}

System.out.println(
"Retorna el seno, el coseno y la tangente del ángulo " + argv[0]);
System.out.println("El seno es " +

Math.sin(Math.toRadians(Double.parseDouble(argv[0]))));
System.out.println("El coseno es " +
Math.cos(Math.toRadians(Double.parseDouble(argv[0]))));
System.out.println("La tangente es " +
Math.tan(Math.toRadians(Double.parseDouble(argv[0]))));
}
}
}
21. FraseMayusculas.java
// Pasa una frase a mayúsculas

public class FraseMayusculas {
String frase = "";

String frase2 = "";
if (argv.length == 0) {
System.out.println("ERROR: Debéis introducir una frase por parámetro");
} else {
for (int i = 0; i < argv.length; i++) {
if (i == (argv.length - 1)) {
frase = frase.concat(argv[i]);
} else {
frase = frase.concat(argv[i] + " ");
}
frase2 = frase2.concat(frase.toUpperCase());
frase = "";
}
System.out.println("La frase en mayúsculas es");

System.out.println(frase2 + ".");
}
}
}
22. CuentaVocales.java
public class CuentaVocales {

String palabra = "";
int longitud = 0;
int numVocales = 0;
System.out.println("ERROR: Debéis introducir una palabra por parámetro");
} else {
palabra = argv[0];
longitud = palabra.length();
palabra = palabra.toUpperCase();
for (int i = 0; i < palabra.length(); i++) {

if ((palabra.charAt(i) == 'A') || (palabra.charAt(i) == 'E') ||
(palabra.charAt(i) == 'I') ||
(palabra.charAt(i) == 'O') ||
(palabra.charAt(i) == 'U')) {
numVocales = numVocales + 1;
}
}
System.out.println("El numero de vocales de la palabra: " + argv[0]

+ " es: " + numVocales);
}
}
}
23. CuentaBlancos.java
// Cuenta los espacios en blanco de una frase

public class CuentaBlancos {
String frase = "Ésta es una frase para probar los espacios en blanco";
int longitud = 0;
int i = 0;
boolean respuesta;
int numblancos = 0;
System.out.println(frase);
longitud = frase.length();
for (i = 0; i < longitud; i++) {
respuesta = Character.isWhitespace(frase.charAt(i));
if (respuesta) {
numBlancos = numBlancos + 1;
}
}
System.out.println("El número de espacios en blanco de la frase es: " +

numBlancos);
}
}
24. TresLetras.java
// Obtiene las combinaciones posibles de 3 letras

public class TresLetras {
int i = 0;
int j = 0;
int k = 0;
if ((argv.length != 1) || (argv.length > 1)) {

} else {
for (i = 0; i <= 2; i++)

for (j = 0; j <= 2; j++)
if (j != i) {
for (k = 0; k <= 2; k++)
if ((k != i) && (k != j)) {
System.out.println("" + argv[0].charAt(i) +
argv[0].charAt(j) + argv[0].charAt(k));
}
}
}
}
}
25. FraseInvertida.java
public class FraseInvertida {

String frase = "";
int longitud = 0;
frase = "Esta es una frase de prueba.";

longitud = frase.length();
for (int i = longitud - 1; i >= 0; i--)

System.out.print(frase.charAt(i));
}
}
26. BinarioDecimal.java
// Pasa un número de binario a decimal

public class BinarioDecimal {
int i = 0;
System.out.println("ERROR: Debéis introducir un parámetro);
esnum = false;
} else {

esnum = false;
}
if ((a[0].charAt(i) != '0') && (a[0].charAt(i) != '1')) {

esnum = false;
System.out.println("Error: Debéis introducir números (0 ó 1)");
}
i++;
}
}
return esnum;
}

System.out.println("El número " + argv[0] + " en decimal es " +
Integer.parseInt(argv[0], 2));
}
}
}
27. DecimalBinario.java
// Pasa un número de decimal a binario

public class DecimalBinario {
int i = 0;
esnum = false;
} else {

esnum = false;
}
i++;
}
}
return esnum;
}

System.out.println("El número " + argv[0] + " en binario es " +
Integer.toBinaryString(Integer.parseInt(argv[0], 10)));
}
}
}
28. PasoDeNumeros.java
// Pasa un número de una base a otra

public class PasoDeNumeros {
int i = 0;
System.out.println("ERROR: Entra: Número baseNum baseAConvertir");
esnum = false;
} else {
esnum = false;
}
if (Integer.parseInt(a[1]) == 2) {
if ((a[0].charAt(i) != '0') && (a[0].charAt(i) != '1')) {
esnum = false;
System.out.println("Error número a convertir no en base 2");
}
}
i++;
}
}
if (esnum == true) {
if ((Integer.parseInt(a[1]) != 2) && (Integer.parseInt(a[1]) != 8) &&
(Integer.parseInt(a[1]) != 10) &&
(Integer.parseInt(a[1]) != 16)) {
System.out.println("Error de base inicial");
esnum = false;
} else if ((Integer.parseInt(a[2]) != 2) &&
(Integer.parseInt(a[2]) != 16)) {
System.out.println("Error de base para convertir");
esnum = false;
}
}
return esnum;
}

int numero10 = 0;
String numerof = "";
switch (Integer.parseInt(argv[1])) {
case 2: {
numero10 = Integer.parseInt(argv[0], 2);
break;
}
case 8: {
break;
}
case 10: {
break;
}
case 16: {
break;
}
default:
break;
}
switch (Integer.parseInt(argv[2])) {
case 2: {
numerof = Integer.toBinaryString(numero10);
break;
}
case 8: {
numerof = Integer.toOctalString(numero10);
break;
}
case 10: {
numerof = Integer.toString(numero10);
break;
}
case 16: {
numerof = Integer.toHexString(numero10);
break;
}
default:
break;
}
System.out.println("Habéis introducido el número " + argv[0] + "

en base " +
Integer.parseInt(argv[1]));
System.out.println("El numero en base " +
Integer.parseInt(argv[2]) + " es: " + numerof);
}
}
}
30. Abecedario.java
public class Abecedario {

char[] letras;
letras = new char[26];
String letrasn = "abcdefghijklmnopqrstuvwxyz";
for (int i = 0, j = 0; i < 26; i++, j++)

letras[i] = letrasn.charAt(j);
for (int i = 0; i < 26; i++)

if ((i % 2) != 0) {
System.out.println(letras[i]);
}
}
}
31. Enteros.java
public class Enteros {

int[] números = new int[51];
for (int i = 0, j = 0; i <= 50; i++, j++)

números[j] = i;
for (int i = 50; i >= 0; i--) {

if ((i % 2) != 0) {
System.out.println(números[i]);
}
}
}
}
32. AbecedarioV.java
import java.util.*;
public class AbecedarioV {

Vector tabla;
tabla = new Vector();
String letrasn = "abcdefghijklmnopqrstuvwxyz";
for (int i = 0, j = 0; i <= 25; i++, j++)

tabla.add(i, new Character(letrasn.charAt(j)));
for (int i = 25; i >= 0; i--) {

if ((i % 2) != 0) {
System.out.println(tabla.elementoAt(i));
}
}
}
}
EnterosV.java
import java.util.*;
public class EnterosV {

Vector numeros = new Vector();
for (int i = 0, j = 0; i <= 100; i++, j++)

numeros.add(j, new Integer(i));
for (int i = 100; i >= 0; i--) {

if ((i % 2) != 0) {
System.out.println(numeros.elementoAt(i));
}
}
}
}
33. SumaArrays.java
public class SumaArrays {

double[] numeros = new double[7];
double[] numeros2 = new double[7];
double[] numeros3 = new double[7];
for (int i = 0; i < 7; i++) {

números[i] = Math.round(Math.random() * 10);
numeros2[i] = Math.round(Math.random() * 10);
numeros3[i] = numeros[i] + numeros2[i];
System.out.println("La suma de los números " + numeros[i] + " i " +
numeros2[i] + " de posición " + i + " es " + numeros3[i]);
}
}
}
34. SumaArraysV2.java
import java.util.*;
public class SumaArraysV2 {

Vector v = new Vector();
Vector v1 = new Vector();
Vector v2 = new Vector();
for (int i = 0; i < 7; i++) {

v.add(new Double(Math.round(Math.random() * 10)));
v1.add(new Double(Math.round(Math.random() * 10)));
double n = (double) v.get(i);

double n1 = (double) v1.get(i);
v2.add(new Double((n.doubleValue() + n1.doubleValue())));
System.out.println("La suma de los números " + v.elementoAt(i) +
" i " + v1.elementoAt(i) + " de posición " + i + " es " +
v2.elementoAt(i));
}
}
}
35. CuantasVeces.java
public class CuantasVeces {

int i = 0;
int j = 0;
System.out.println("ERROR: No habéis introducido ningún parámetro");
esnum = false;
} else {
esnum = false;
}
i++;
}
// while
j++;
i = 0;
}
}
return esnum;
}

int[] numeros = new int[100];
if (controlErrores2(args)) {
for (int i = 0; i < 100; i++) // inicialización del array
numeros[i] = 0;
for (int j = 0; j < args.length; j++) {

int a = 0;
a = Integer.parseInt(args[j]);
numeros[a] = numeros[a] + 1;
}
for (int k = 0; k < 100; k++)

if (numeros[k] != 0) {
System.out.println("El número " + k + " sale " +
numeros[k] + " vez/ces.");
}
}
}
}
CuantasVecesV.java
import java.util.*;
public class CuantasVecesV {

int i = 0;
int j = 0;
esnum = false;
} else {
esnum = false;
}
i++;
}
// while
j++;
i = 0;
}
}
return esnum;
}

Vector numeros = new Vector();
System.out.println("Muestra cuántas veces aparece cada número entero");
if (controlErrores2(args)) {
// llena el vector de ceros
for (int i = 0; i < 100; i++)
numeros.add(i, new Integer(0));
// suma 1 si se repite
int z;
for (int j = 0; j < args.length; j++) {

z = Integer.parseInt(args[j]);
numeros.set(z,
new Integer(((Integer) números.get(z)).intValue() + 1));
}
// muestra los resultados por pantalla

for (int k = 0; k < 100; k++)
if (((Integer) (números.elementoAt(k))).intValue() != 0) {
System.out.println("El número " + k + " sale " +
numeros.elementoAt(k) + " vez/ces.");
}
}
}
}
36. LineaCaracteres.java
public class LineaCaracteres {

esnum = false;
}
return esnum;
}
public static void impResultado(String aux, int suma) {

System.out.println("La frase en mayúsculas es: " + aux);
System.out.println("La suma de los dígitos encontrados en la frase es: " + suma);
}

String frase = " ";
String aux = "";
int suma = 0;
if (controlErrores(args)) {
for (int i = 0; i < args.length; i++)
frase = frase + args[i] + " ";
for (int i = 0; i < frase.length(); i++) {

if (Character.isWhitespace(frase.charAt(i))) {
aux = aux + frase.charAt(i);
}
if (Character.isLetter(frase.charAt(i))) {
aux = aux + Character.toUpperCase(frase.charAt(i));
} else if (Character.isDigit(frase.charAt(i))) {
suma = suma +
(Integer.parseInt(frase.substring(i, i + 1)));
}
}
impResultado(aux, suma);
}
}
}
37. NotasAlumnos.java
// Las notas de cada alumno se generan aleatoriamente

public class NotasAlumnos {
int[][] alumnos = new int[5][5];
int[] promedio = new int[5];
for (int i = 0; i < 5; i++)

for (int j = 0; j < 5; j++)
alumnos[i][j] = (new Double(Math.random() * 10)).intValue();
for (int l = 0; l < 5; l++) {

System.out.print("Las notas del alumno " + l + " son ");
for (int m = 0; m < 5; m++) {

System.out.print(alumnos[l][m] + " ");
promedio[l] += alumnos[l][m];
}
System.out.println();
}
for (int r = 0; r < 5; r++)

System.out.println("El promedio del alumno " + r + " es: " +
(promedio[r] / 5));
}
}
Glosario
API f Conjunto de rutinas (procedimientos y funciones que en la sintaxis de la programa-
ción orientada al objeto se conocen como métodos) que el lenguaje ofrece al programador.
array m Tipo de datos que permiten almacenar un conjunto de datos mediante determina-
dos índices.
atributo o variable de instancia m Los atributos de una clase almacenan la información que
describe e identifica una instancia especifica de la clase. Para cada clase, sólo es preciso incluir los
atributos que interesen para diseñar el sistema. Para cada atributo hay que especificar su nombre,
':' y el tipo. El tipo de un atributo puede ser cualquier clase o un tipo primitivo (int, char, etc.).
atributo static o variable de clase m Atributos accesibles desde cualquier instancia de

una clase. Un ejemplo es un contador de instancias creadas de una clase.
bytecode m Resultado de la compilación de archivos código fuente Java y que se carga, veri-
fica y ejecuta en el intérprete.
clase f Elemento básico de la programación orientada al objeto. Una clase es una descripción
de la estructura y el comportamiento de los objetos que pertenecen a ella.
garbage collection m Proceso que rastrea las operaciones de reserva de memoria y libera
automáticamente la memoria que no se necesita.
método m Operación, procedimiento o función que trabaja sobre los datos que representan
un objeto.
método accesor m Método que permite conocer, sin alterarlo, el estado del objeto.
sin método getter
método constructor m Método que permite la construcción del objecto.
método de clase m Ved método static.
método getter m Ved método accesor.
método modificador m Método que permite alterar el estado (valores de las variables de
instancia) del objeto.
sin método setter
método setter m Ved método modificador.
método static m Los métodos del modificador static son propios de la clase, sin que se apli-
quen específicamente en ningún objeto de la clase. Es decir, puede emplearse sin crear nin-
guna instancia de la classe.
sin método de clase
mensaje m Mecanismo por el que se invoca un método. Un mensaje consiste en el nombre

del método seguido de una lista de parámetros que puede estar vacía.
objeto m Agrupación o colección de datos y operaciones que tienen una estructura determi-
nada y mediante la que pueden modelizase aspectos relevantes de un problema.
private m Modificador que permite que toda la información declarada como private tenga
ocultación total; o sea, que sólo sea accesible desde la propia clase.
protected m Modificador que permite que toda la información declarada protected tenga
ocultación parcial; o sea, que sólo sea accesible desde la propia clase y las subclases.
public m Modificador que permite que toda la información (sea método, atributo o clase)
declarada public sea accesible desde fuera de la clase; o sea, puede accederse a los métodos así
definidos desde otras clases que no sean la propia.
sobrecarga f Definición de un mismo ítem con significados distintos, de modo que puede
interpretarse su significado según de qué modo se utilice.
super f Palabra reservada que apunta a la superclase de la clase en que se emplea. Sirve para
apuntar a alguna variable o método de la superclase.
this m Referencia especial que se utiliza dentro de cualquier método con el fin de poder re-
ferenciar el objeto actual. El valor this se refiere al objeto sobre el que se ha llamado el método
actual.
UML m Lenguaje unificado de modelización. Lenguaje gráfico y flexible de modelización

que permite describir modelos que representen sistemas (tanto de software como del mundo
real) basándose en los conceptos de la orientación al objeto.
en unified modeling language
unified modeling language m Ved UML.
vector m Clase que permite almacenar un conjunto de datos mediante determinados índices.
Bibliografía
Manual oficial de Sun.
SUN Microsystems (1998). Programación en Java. SL-276. Guía de Usuario (Revisión B).
API de Java.
Flanagan, D. (2002). Java in a Nutshell (4.ª ed.). O’Reilly & Associates, Inc.

Java Estructurado

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Java Estructurado

Cargado por

Copyright:

Formatos disponibles

El lenguaje Java

Marta I. Tarrés Puertas

Bloque I. Java como lenguaje de programación estructurada ..... 9

2. Primeros pasos en Java ...................................................................... 16

3. Instalación de Java ............................................................................. 19

4. Tipos de datos en Java ....................................................................... 23

5. Operadores en Java ............................................................................. 32

6. Los condicionales ................................................................................ 36

7. Los bucles .............................................................................................. 39

8. Procedimientos y funciones en Java: los métodos ...................... 42

9. Entrada y salida en Java .................................................................... 49

10. Arrays y vectores en Java ............................................................... 52

Bloque II. Java orientado a objetos .................................................... 57

1. Tipos primitivos y objetos ................................................................ 57

2.4. Utilización de this ............................................................................. 70

3. Relaciones entre clases ....................................................................... 75

4. Breve introducción a UML ................................................................ 86

Ejercicios de autoevaluación ................................................................. 93

Glosario ..................................................................................................... 117

Bibliografía .............................................................................................. 118

Este módulo didáctico pretende introducir a los estudiantes en el mundo de la

Este módulo didáctico se ha estructurado en dos bloques:

• Primeros pasos con Java o Java como lenguaje de programación estructurada.

• Java orientado a objetos.

En el primer bloque, “Java como lenguaje de programación estructurada”, se

En el segundo bloque del módulo didáctico, se describen las características de

La teoría se presenta siempre acompañada de una serie de ejemplos y ejerci-

No me gustaría acabar esta introducción sin agradecer la colaboración de los

Los materiales didácticos de este módulo proporcionan conocimientos funda-

1. Aprovechar las características del lenguaje Java, en cuanto a portabilidad,

4. Generar la documentación de un programa codificado en Java, utilizando

6. Definir y utilizar las estructuras estáticas y dinámicas necesarias para re-

7. Conocer y utilizar los métodos que permiten la interacción con el usua-

8. Comprobar que los formatos de entrada y de salida del programa y la fun-

9. Utilizar correctamente los métodos que proporciona la librería del len-

11. Implementar una aplicación utilizando las directrices de la programación

12. Diseñar aplicaciones utilizando el lenguaje UML.

Bloque I. Java como lenguaje de programación

1.1. Origen del lenguaje

Java nació en mayo de 1995.

En cierto modo, se trata de un nuevo lenguaje simplificado de Sun basado en

1.2. Características del lenguaje

La sintaxis del lenguaje de programación Java es similar a la sintaxis de C++,

Los principales objetivos del lenguaje de programación Java, como describe el

• Facilitar un lenguaje de uso sencillo: eliminar la aritmética de punteros y

• Permitir al usuario una forma concurrente de ejecutar programas.

• Soportar cambios dinámicos en tiempos de ejecución.

• Proporcionar más seguridad.

• Proporcionar un entorno interpretado (Java es un lenguaje interpretado),

– Velocidad de desarrollo: se elimina el ciclo compilación-enlace-carga-veri-

– Portabilidad del código. Cuando se tiene un programa escrito en Java, pue-

1.3. La máquina virtual Java (Java virtual machine)

... proporciona las especifica-

A partir del código fuente, el compilador genera bytecodes, instrucciones bina-

La Java virtual machine specification proporciona definiciones muy concretas

• Conjunto de instrucciones (equivalente al de la CPU).

1.4. The garbage collection (gestión automática de memoria)

Buena parte de los lenguajes de programación permiten reservar memoria en

Cuando la memoria reservada deja de necesitarse, el programa o el entorno de

En C, C++ y otros lenguajes, el programador es responsable de la gestión de

memoria disponible en el sistema. Se dice que estos programas tienen pérdidas

El lenguaje de programación Java libera al programador de la responsabili-

El proceso de garbage collection se realiza automáticamente durant el ciclo de

1.5. Seguridad en el código