Programar en java, curso inicial de clases, constructores, variables, metodos

1. Programación avanzada
en Java

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

3. El lenguaje Java

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

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

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

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

8. 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 • Punteros a void.
de tipos (wrappers).

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

10. Elementos del lenguaje

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

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

13. 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;

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

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

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

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

18. 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:
…
}

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

20. Clases y objetos
en Java

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

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

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

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

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

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

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

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

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

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

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