Este documento presenta información general sobre un curso de Java, incluyendo los profesores, índice del curso y bibliografía. Luego resume las características principales de Java como lenguaje interpretado, fuertemente tipado y portable. Finalmente, explica conceptos clave como el desarrollo en Java, compilación e interpretación, y comparativa con C++.

2. Información general (I)
 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.
Miguel Ángel Corella
José María Fuentes
Francisco Saíz

3. Información general (y II)
 Bibliografía:
 Core Java 1.2, Volúmenes I – II. C.S. Horstmann, Gary
Cornell, Prentice Hall, 1999.
 Tutorial de Java en http://java.sun.com

4. El lenguaje Java

5. 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.

6. 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

7. 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
 …

8. Compilación e interpretación
class Ejemplo {
...
}
class Aux {
...
}
Ejemplo.java
Compilador
Java
Ejemplo.class Aux.class
Java Virtual Machine
JVM

9. Comparativa: Java vs. C++ (I)
 Interpretado
 Portable
 Todo memoria dinámica
 Garbage collection
 No existen punteros
 Todos los métodos virtuales
 No hay herencia múltiple
 Información sobre clases
en tiempo de ejecución.
 Tratamiento genérico
de tipos (wrappers).
Java C++• Compilado
• Aspectos no portables
• Memoria automática y dinámica
• Gestión del programador
• Existen punteros
• No todos los métodos virtuales
• Hay herencia múltiple
• Información muy escasa
(dynamic_cast).
• Punteros a void.

10. Comparativa: Java vs. C++ (y II)
 Soporte estándar para interfaces:
AWT, SWING
 Soporte estándar para concurrencia
 Soporte estándar para objetos
distribuidos
 Ejecutable en navegadores web
 Homogeneidad del lenguaje
 Lenguaje bien diseñado
Java C++
• No incluido en el lenguaje:
Microsoft MFC, Borland OWL…
• No incluido en el lenguaje
• No incluido en el lenguaje:
CORBA, ActiveX
• No ejecutable por navegadores
• Múltiples sintaxis
• Compatibilidad con C

11. Elementos del lenguaje

12. 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…

13. Valores y variables
 Tipos básicos:
 Variables y literales:
 Declaración y utilización de variables y literales similar a
C/C++.
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)

14. Compatibilidad entre tipos
Ensanchar: automático
f = c;
d = s;
f = l;
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);
Estrechar: cast explícito
c = (char) i;
b = (byte) d;
f = (float) d;
char: cast explícito
s = (short) c;
c = (char) s;
c = (char) b;

15. Operadores
 En total hay 46 operadores.
 Numéricos:
+, -, *, /, %, +=, -=, *=, /=, %=, --, ++
 Lógicos:
&&, ||, !
 Operadores de bit:
&, |, ^, ~, >>, <<
 Relacionales:
>, <, >=, <=, ==, !=
 Condicional:
If-then-else: (condicion) ? acción1 : acción2

16. Precedencia de operadores
( ) [ ] .
++ -- ~ !
new
* / %
+ -
>> >>> <<
> >= < <= instanceof
== !=
&
^
|
&&
||
? :
= += *= -= /=
Ordendeejecucióndeoperadores
Igualdad de precedencia

17. Arrays
 Declaración:
int a[];
a = new int[3];
int b[] = {1, 2, 3, 4};
• Reserva de tamaño:
• 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

18. 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]

19. Expresiones condicionales Dos tipos de condicionales.
if (condición1) acción1 [else acción2] [else if (condición2)…
switch (expresión) {
case valor1:
…
break;
case valor2:
…
break;
default:
…
}
byte, char, short o int
Tienen que ser literales

20. Iteraciones Tres tipos de iteraciones.
while (condición1) {
…
}
do {
…
} while (condición1)
for (inicialización; condición; iteración) {
…
}

21. Clases y objetos
en Java

22. Clases Estructura de datos + funciones.
class CuentaBancaria {
long numero;
String titular;
long saldo;
void ingresar (long cantidad) {
saldo += cantidad;
}
void retirar (long cantidad) {
if (cantidad > saldo)
System.out.println ("Saldo insuficiente");
else saldo -= cantidad;
}
}
Variables
(datos)
Funciones

23. Variables de una clase
 Definen una estructura de datos (similar al struct de C)
• Pueden almacenar objetos de otras clases
• Por defecto, se inicializan a 0, false y/o null.
class CuentaBancaria {
long numero;
String titular;
long saldo;
}
struct CuentaBancaria {
long numero;
char *titular;
long saldo;
};
class CuentaBancaria {
long numero;
Cliente titular;
long saldo = 0;
}
class Cliente {
String nombre;
long dni;
}

24. Creación de objetos Una clase define un tipo de dato que se puede utilizar para declarar
variables.
 Declarar un objeto es declarar una referencia al objeto.
 Los objetos se crean mediante el operador new.
 Crear un objeto es reservar memoria para sus variables.
 El operador new reserva memoria y devuelve una referencia.
CuentaBancaria cuenta1, cuenta2;
cuenta1 = new CuentaBancaria();
CuentaBancaria
0
null
0
numero
titular
saldo

25. 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";

26. 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 “.”.
 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.
cuenta2.ingresar(1000);

27. 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);
}
}
}

28. Acceso a objetos
class X { String nombre; }
class Y { int i; }
class Z { String nombre; }
class A {
int num;
X obj4;
void f (int n, Y obj3) {
Z obj2 = new Z ();
obj4.nombre = obj2.nombre
num = obj3.i + n;
}
}
2.
1. 3.
4.
1. Variable del objeto de la invocación
2. Objeto definido en variable local
3. Objeto pasado como argumento
4. Objeto almacenado en variable de
clase

29. 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) {
...;
}
}

30. 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;
}
}

31. 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);

32. 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.