Programación avanzada

en Java
Información general
• Profesores:
– Miguel Ángel Corella, José María Fuentes y
Francisco Saíz.
• Índice del curso:
– Introducción.
• El lenguaje Java.
• Programación orientada a objetos en Java.
– Jerarquías de clases.
– Excepciones.
– Applets.
– Interfaces de usuario.
El lenguaje Java
Características principales (I)

• Lenguaje interpretado.
• Fuertemente tipado.
• Sintaxis similar a C/C++.
• Sin punteros: Garbage collection.
• 100% portable.
• Integra librearías estándar para:
– Interfaces de usuario.
– Objetos distribuidos.
– Threads.
Características principales (y II)

• Ejecutable desde navegadores web.

• Origen: Aumento de HTML para conseguir
páginas Web dinámicas.
• Versiones:
– 1995 – JDK 1.0
– 1997 – JDK 1.1
–…
– 2004 – JDK 1.5
Desarrollo en Java

• Java Development Kit (JDK):

– Java Runtime Environment (JRE):
• Java Virtual Machine.
• Java API: lenguaje básico y librerías estándar.
– Compilador a bytecode.
– Otras herramientas:
• Debuggers.
• Applet viewer.
• Compiladores RMI
• …
Compilación e interpretación
Ejemplo.java

class Ejemplo {
...
}
Java Virtual Machine
class Aux { JVM
...
}
Compilador
Java

Ejemplo.class Aux.class
Comparativa: Java vs. C++ (I)
Java C++
• Interpretado • Compilado

• Portable • Aspectos no portables

• Todo memoria dinámica • Memoria automática y dinámica

• Garbage collection • Gestión del programador
• No existen punteros • Existen punteros

• Todos los métodos virtuales • No todos los métodos virtuales

• No hay herencia múltiple
• Hay herencia múltiple
• Información sobre clases
• Información muy escasa
en tiempo de ejecución.
(dynamic_cast).
• Tratamiento genérico
de tipos (wrappers). • Punteros a void.
Comparativa: Java vs. C++ (y II)
Java C++

• Soporte estándar para interfaces: • No incluido en el lenguaje:

AWT, SWING Microsoft MFC, Borland OWL…

• Soporte estándar para concurrencia • No incluido en el lenguaje

• Soporte estándar para objetos • No incluido en el lenguaje:

distribuidos CORBA, ActiveX

• Ejecutable en navegadores web • No ejecutable por navegadores

• Homogeneidad del lenguaje • Múltiples sintaxis

• Lenguaje bien diseñado • Compatibilidad con C

Elementos del lenguaje
Aspectos léxicos

• Ignora múltiples espacios en blanco

• Sentencias separadas por “;”.
• Comentarios:
– /* … */  Múltiples líneas de comentario
– //  Una única línea de comentario
• Case – sensitive.
• Convenios de nomenclatura:
– Clases con mayúscula.
– Métodos y variables con minúscula.
– etc…
Valores y variables
• Tipos básicos:
byte 1 byte
char 2 bytes (sin signo, caracteres Unicode, incluyen los ASCII)
short 2 bytes
int 4 bytes
long 8 bytes
float 4 bytes
double 8 bytes
boolean 1 bit (true ó false, no compatible con tipos numéricos)

• Variables y literales:
– Declaración y utilización de variables y
literales similar a C/C++.
Compatibilidad entre tipos
byte b = 42;
char c = 'a'; // también válido: c = 97;
short s = 1024;
int i = 50000;
long l = 120000;
float f = 5.67f;
double d = .1234;
double result = (f*b) + (i/c) - (d*s);

Ensanchar: automático Estrechar: cast explícito char: cast explícito

f = c; c = (char) i; s = (short) c;
d = s; b = (byte) d; c = (char) s;
f = l; f = (float) d; c = (char) b;
Operadores

• En total hay 46 operadores.

– Numéricos:
+, -, *, /, %, +=, -=, *=, /=, %=, --, ++

– Lógicos:
&&, ||, !

– Operadores de bit:
&, |, ^, ~, >>, <<

– Relacionales:
>, <, >=, <=, ==, !=

– Condicional:
If-then-else: (condicion) ? acción1 : acción2
Precedencia de operadores
( ) [ ] .
++ -- ~ !
Orden de ejecución de operadores

new
* / %
+ -
>> >>> <<
> >= < <= instanceof
== !=
&
^
|
&&
||
? :
= += *= -= /=

Igualdad de precedencia
Arrays
• Declaración:
int a[];

• Reserva de tamaño:
a = new int[3];
int b[] = {1, 2, 3, 4};

• Asignación de valores:
a[1] = 7;
b = a;

• Errores:
a[6] = 7; // Fuera del rango
a = {1, 2, 3}; // Sólo válido en la inicialización
int c[5]; // La dimensión sólo al hacer new
char str[] = “hola”; // Los Strings no son arrays en Java
 Arrays multidimensionales

float a[][] = new float [4][3];

float m[][] = new float [4][];

m[0] = new float [2];
m[1] = new float [5];
m[2] = new float [m[1].length];
float x[] = {4.5, 8/3, m[2][1]};
m[3] = x; // O cualquier expresión que devuelva un float[]
a[0] = m[1]; // Las variables de array no son constantes
a[2, 1] = 7.3 // Error de sintaxis: a[2][1]
Expresiones condicionales
• Dos tipos de condicionales.

if (condición1) acción1 [else acción2] [else if (condición2)…

switch (expresión) { byte, char, short o int

case valor1:
…
break; Tienen que ser literales

case valor2:
…
break;

default:
…
}
Iteraciones
• Tres tipos de iteraciones.
while (condición1) {
…
}

do {
…
} while (condición1)

for (inicialización; condición; iteración) {

…
}
Clases y objetos
en Java
Clases
• Estructura de datos + funciones.
class CuentaBancaria {

long numero;
String titular; Variables
long saldo; (datos)

void ingresar (long cantidad) {

saldo += cantidad;
}
Funciones
void retirar (long cantidad) {
if (cantidad > saldo)
System.out.println ("Saldo insuficiente");
else saldo -= cantidad;
}
}
Variables de una clase
• Definen una estructura de datos (similar al struct de C)
class CuentaBancaria { struct CuentaBancaria {
long numero; long numero;
String titular; char *titular;
long saldo; long saldo;
} };

• Pueden almacenar objetos de otras clases

class CuentaBancaria { class Cliente {
long numero; String nombre;
Cliente titular; long dni;
long saldo = 0; }
}

• Por defecto, se inicializan a 0, false y/o null.

Creación de objetos
• Una clase define un tipo de dato que se puede utilizar para declarar
variables.
CuentaBancaria cuenta1, cuenta2;

• Declarar un objeto es declarar una referencia al objeto.

• Los objetos se crean mediante el operador new.
CuentaBancaria

cuenta1 = new CuentaBancaria(); numero 0

titular null
saldo 0

• Crear un objeto es reservar memoria para sus variables.

• El operador new reserva memoria y devuelve una referencia.
Acceso a variables
• El acceso a las variables de un objeto se lleva a
cabo mediante la notación “.”
CuentaBancaria cuenta1, cuenta2;
cuenta1 = new CuentaBancaria ();
cuenta2 = cuenta1;
Cliente cliente1 = new Cliente ();

cliente1.nombre = "Luis Gomez";

cliente1.dni = 25672046;
cuenta1.numero = 6831531;
cuenta1.titular = cliente1;
cuenta1.saldo = 100000;
cuenta2.saldo = 200000;

cuenta2.titular.nombre = "Pilar Garcia";

Métodos
• Los métodos son funciones definidas dentro de un clase.

• Son similares a un puntero a función dentro de un struct de C.

• Los métodos de una clase pueden referenciar directamente

las variables de la misma.

• Los métodos se invocan sobre un objeto de la clase a la que

pertenecen mediante la notación “.”.

cuenta2.ingresar(1000);
• Al ejecutar un método sobre un objeto de la clase X, las
variables de dicha clase X toman los valores que tiene el
objeto.
 Llamadas desde métodos
• Los métodos pueden invocar directamente otros
métodos de la misma clase (sin “.”).
• Al ejecutar un método invocado sobre un objeto de clase
A, las llamadas a otros métodos de la clase A se
ejecutan sobre el mismo objeto a menos que se
invoquen sobre otro objeto
cuenta3 = new CuentaBancaria ();
cuenta2.transferencia (cuenta3, 1000);
class CuentaBancaria {
...
void transferencia (CuentaBancaria destino, long cantidad) {
if (cantidad <= saldo ) {
retirar (cantidad);
destino.ingresar (cantidad);
}
}
}
 Acceso a objetos

class X { String nombre; }

class Y { int i; }
class Z { String nombre; }

class A { 1. Variable del objeto de la invocación

int num; 2. Objeto definido en variable local
X obj4; 3. Objeto pasado como argumento
void f (int n, Y obj3) { 4. Objeto almacenado en variable de clase
Z obj2 = new Z ();
4. obj4.nombre = obj2.nombre
num = obj3.i + n;
} 2.
}
1. 3.
Constructores
• Métodos ejecutados automáticamente al crear un objeto
de una clase (“new”).
• Se usan para llevar a cabo labores de inicialización.
• Simplifican la sintaxis y apoyan el encapsulamiento de
los datos.
• Los métodos constructores de una clase tienen que
tener el mismo nombre que la clase.

class Cliente {

// Constructor de la clase Cliente

Cliente (String str, long num) {
...;
}
}
Ejemplos de constructores
class Cliente {
String nombre;
long dni;
Cliente (String str, long num) {
nombre = str;
dni = num;
}
}
class CuentaBancaria {
long numero;
Cliente titular;
long saldo;
CuentaBancaria (long num, Cliente clt, long s) {
numero = num; titular = clt; saldo = s;
}
}
 Ejemplos de invocación
• Automáticamente al crear objetos.

Cliente cliente1 = new Cliente ("Luis Gomez", 25672046);

CuentaBancaria cuenta1 =
new CuentaBancaria (6831531, cliente1, 100000);

CuentaBancaria cuenta2 =
new CuentaBancaria (8350284,
new Cliente ("Pilar Garcia", 15165442),
200000);
Constructor por defecto

• Si no se definen constructores, Java

proporciona uno por defecto.
– Sin parámetros: Llamadas del tipo new X();
– Sin funcionalidad: Variables inicializadas por defecto.

• Pero si se define un constructor (o más) el

constructor por defecto no es definido.