TÉCNICAS DE PROGRAMACIÓN Lenguaje Java

1. Introducción a Java – 2 Daniel Finol TÉCNICAS DE PROGRAMACIÓNLenguaje Java

2. Otras diferencias entre C y Java • No hay typedef ni enum. • No existe el operador coma. • Pero sí: for(int i = 0, j = 0; condición; j++, i++); • No hay uniones ni campos de bits. • No hay apuntadores a métodos. • No hay argumentos de longitud variable (printf).

3. Otras diferencias entre C y Java • No hay que declarar antes de usar. • Las variables pueden declararse en cualquier lugar, no sólo al inicio de un bloque. • Aunque esto a veces no es recomendado. • Sobrecarga de métodos: dos métodos pueden tener el mismo nombre si difieren en la lista de argumentos. • Recolector de basura (garbage collector).

4. Paquetes y acceso a clases • Las clases pueden tener dos tipos de acceso: • public: Pueden ser accedidas por clases en otros paquetes. • Por defecto: Sólo se puede acceder a ellas desde el mismo paquete en que se definen. • Cuando no se especifica ningún paquete (en el archivo fuente donde se define una clase) éstas están en el "paquete global". • Ámbito (Namespace).

5. CLASSPATH • CLASSPATH: Cuando en un programa usamos clases que no están definidas en el mismo archivo, javac y java buscan los archivos .class correspondientes en los directorios definidos en la variable de entorno CLASSPATH. • También, al ejecutar un programa (con el comando java), se puede especificar dónde buscar mediante la opción –classpath. • Cuando hemos incluido paquetes también se buscan los subdirectorios (de los directorios mencionados arriba) que correspondan con los nombres de los paquetes.

6. Firma de métodos • Se llama firma de un método a la combinación de su nombre y la lista de los tipos de argumentos que recibe. • Esto es lo que distingue a un método de otro dentro de una misma clase.

7. Variables objeto • Un objeto en Java (una variable cuyo tipo es una clase) en realidad contiene una "referencia" es decir, una indicación de dónde se encuentra el objeto en memoria, es por eso que: • Al comparar dos objetos == no estamos comparando sus contenidos. • Al asignarle un objeto a otro no estamos copiando los contenidos del objeto. • Cuando se pasa un objeto como argumento a una función no se hace una copia del objeto. • Cuando una función retorna un objeto (aunque retorne una referencia a un objeto que se creó dentro de la función) la referencia sigue siendo válida.

8. final • Variables final: Constantes, después de ser inicializadas su valor no puede cambiar. • Variable final local: No tiene que inicializarse en la declaración. • Métodos final: No pueden sobre–escribirse. • Son más rápidos de llamar. • Los métodos private son implícitamente final. • Clases final: No pueden "heredarse", no se pueden crear subclases a partir de ella.

9. Clases Abstractas • Si una clase tiene un método abstract la clase es abstracta y de ser declarada abstract. • Una clase abstract no se puede "instanciar". • Si una subclase de una clase abstracta no sobreescribe (implementa) todos los métodos abstractos de su superclase entonces también será abstracta y debe ser declarada como tal. • Los métodos static, final y private no pueden ser abstractos. Una clase final no puede ser abstracta. • Una clase se puede declarar como abstract aunque no tenga métodos abstractos.

10. Clase Abstracta

11. Clases Abstractas class Figura { Color color; void setColor(Color nuevoColor) { color = nuevoColor; redibujar(); } void redibujar() { //¿cuáles son las sentencias que // habríaque colocar aquí? } } // fin de la clase Fig

12. Clases Abstractas abstract class Figura { Color color; void setColor(Color nuevoColor) { color = nuevoColor; redibujar(); } abstract void redibujar(); } // fin de la clase Fig

13. Clases Abstractas class Círculo extends Figura { void redibujar() { System.out.println("Dibujar círculo"); } } class Rectángulo extends Figura { void redibujar() { System.out.println("Dibujar rectángulo"); } }

14. Interfaces Una interfaz especifica lo que hace una clase sin implementarlo. Es parecida a una clase abstracta excepto: • La palabra interface reemplaza a abstract class. • Todos los métodos son abstractos (implícitamente): no se define (implementa) ninguno, sólo se declaran. No hay métodos static. • En cambio los datos deben ser constantes: static final. • Todos los métodos son públicos (aunque no se indique). • Como no se puede "instanciar" no hay constructores.

15. Interfaces • Mientras que una clase sólo puede extender una sola (super–)clase, cualquier clase puede implementar cualquier número de interfaces: public interface Centered { public void setCenter(double x, double y); public double getCenterX(); public double getCenterY(); }

16. public class CenteredRectangle extends Rectángulo implements Centered { private double cx, cy; public CenteredRectangle(double cx, double cy, double w, double h) { super(w, h); this.cx = cx; this.cy = cy; } public void setCenter(double x, double y) { cx = x; cy = y; } public double getCenterX() { return cx; } public double getCenterY() { return cy; } } Llama al constructor de la superclase

17. Una interfaz puede extender otra interfaz. • Marker Interfaces.

18. "Clases Internas" • Clases miembro estáticas. Puede acceder a miembros estáticos de la clase que la contiene. • Clases miembro. Puede acceder a todos los miembros de la clase que la contiene. • Clases locales. Se definen dentro de un bloque de código. Como el código también está dentro de una clase tienen acceso como si fueran clases miembro. • Clases anónimas. Como las locales pero anónimas.

19. La clase Object • La clase Object (definida en java.lang) es la raíz de la jerarquía de clases de Java: • Toda clase en Java (esto incluye las definidas por Ud.; también los arreglos) hereda (extiende) la clase Object implícitamente; directa o indirectamente. • Algunos métodos de esta clase son: • Object clone() • boolean equals(Object obj) • Class getClass() • String toString() • finalize() • También están hashCode() y métodos para la sincronización de hilos.

20. finalize() • Este método es llamado por el recolector de basura antes de destruir un objeto. • No hay garantías de si será llamado ni cuándo. • Se puede usar para liberar recursos asociados a un objeto: cerrar archivos, liberar conexiones de red, etc.

21. Excepciones En C se usan valores específicos de retorno para indicar que ha ocurrido en error. Eso requiere que se verifiquen los valores de retorno, a veces, a través cadenas de llamadas anidadas. Ejemplo: supóngase que en main se llama a la función f() que a su vez llama a g() y ésta llama a h(). Si se produce un error en h() habría que pasar el código a g() y luego a f() y finalmente a main. Esto requiere crear código que oculta la lógica del algoritmo.

22. Excepciones • Las excepciones permiten manejar los errores manteniendo el código claro y legible. // In main() try { f(); } catch (MyException e) { System.out.println(e); } // In h() throw new MyException("optional text here"); No se necesita propagar el error a través de la pila de llamadas a funciones.

23. Excepciones • Es un evento que ocurre durante la ejecución de un programa que impide que el programa continúe normalmente; generalmente es un error. • Las excepciones son de distintos tipos y forman una jerarquía extendible de clases. Todos los tipos de excepciones derivan de Throwable. • Hay dos tipos: Exception y Error que derivan de Throwable. • Una excepción es un objeto de tipo Throwable.

24. Excepciones • Una excepción señala que alguna condición excepcional o error ha ocurrido. • Lanzar (throw) una excepción es señalar una condición excepcional. • Atajar (catch) un excepción es manejarla: hacer lo necesario para recuperarse de ella.

25. Excepciones – ¿De dónde vienen? • Una excepción se puede lanzar: throw new MyException("optional text here"); bien sea en el código de uno o en funciones de clases que uno utiliza. • Un método debe lanzar una excepción sólo si no puede cumplir con su especificación. • Un ejemplo podría ser una Pila que lanza una excepción si se llama a pop() cuando la pila está vacía. • Otra fuente de excepciones es la máquina virtual de Java.

26. Excepciones class FixedStack{ private int capacity; private int size; private Object[] data; public FixedStack(int cap) { data = new Object[cap]; capacity = cap; size = 0; } public void push(Object o) throws StackException { if (size == capacity) throw new StackException("pila llena"); data[size++] = o; }

27. public Object pop() throws StackException { if (size<=0) throw new StackException("pila vacía"); return data[--size]; } public Object top() throws StackException { if (size<=0)throw new StackException("pila vacía"); return data[size-1]; } public int size() { return this.size; } }

28. class StackException extends Exception { StackException() {} StackException(String msg) { super(msg); } }

29. class StackTest{ public static void main(String[] args) { FixedStack s = new FixedStack(3); doTest(s); } public static void doTest(FixedStack s) { try { s.push("one"); s.push(new Integer(2)); s.push(new Float(3.0)); s.push("one too many"); // error! } catch(StackException x) { System.out.println(x);// This should happen: }

30. try { System.out.println("Top: " + s.top()); System.out.println("Popping..."); while (s.size() > 0) System.out.println(s.pop()); } catch(StackException x) { // This should never happen: throw new InternalError(x.toString()); } } }

31. Excepciones • No Verificada (unchecked): Los excepciones tipo Error y RuntimeException pueden ocurrir en cualquier momento. Por eso usulmente no se chequean. • Verificadas (checked): Los excepciones tipo Exception excepto RuntimeException sí se chequean y se espera que se manejen.

32. Excepciones Si se usan excepciones verificadas el compilador verifica que sucedan dos cosas: • Todo método que lanze (throw) potencialmente una excepción debe anunciarlo en el encabezado: public Object top() throws StackException { • Todo método que llame a un método que anuncie una excepción verificada debe hacer una de dos cosas: • Manejar la excepción: try/catch; o • Anunciar a su vez la excepción con su propia cláusula throws en el encabezado.

33. Excepciones • La excepciones no verificadas no se colocan en la cláusula throws. • Las tipo RuntimeException se pueden atajar (cath), pero no es necesario. Ejemplos: • ArithmeticException • ArrayStoreException • IndexOutOfBoundsException • NegativeArraySizeException • NullPointerException

34. Las tipo Error no se atajan pues señalan un error grave que requiere que se "apague" la máquina virtual. Ejemplos: • InternalError, • VirtualMachineError, • OutOfMemoryError, • StackOverflowError, • LinkageErrors.

35. La sentencia catch(E e) { .... } atajaría todas las excepciones de tipo E y sus derivadas. • Por ej.: try{ // whatever } catch (Exception e){ System.out.println(e); } ataja todas las excepciones (verficables). • Cuando se lanza una excepción en el try el sistema busca los catch en el orden en que aparecen; por eso no debe colocarse un catch de una super–clase antes de uno para una sub–clase de esa super–clase.

36. Cuando una sub–clase sobre–escribe un método no deben añadirse nuevos tipos de excepciones a la cláusula throws. • A menos que sean excepciones derivadas de las que tenía el método original. • En el bloque try/catch/finally debe haber: • Un try. • Por lo menos un catch. • Uno o ningún finally.

37. Excepciones if (x < 0) throw new IllegalArgumentException("x must be >= 0")); double fact; for(fact=1.0; x > 1; fact *= x, x--); return fact;

38. try/catch/finally try { statement(s) } catch (exceptiontype name) { statement(s) } finally { statement(s) }

39. throws public static String readFirstLine(String filename) throws IOException { BufferedReader in = new BufferedReader(newFileReader(filename)); return in.readLine(); }

40. private Vector vector; private static final int SIZE = 10; PrintWriter out = null; try { System.out.println("Entered try statement"); out = new PrintWriter(new FileWriter("OutFile.txt")); for (int i = 0; i < SIZE; i++) { out.println("Value at: " + i + " = "+ vector.elementAt(i)); } } catch and finally statements . . .

41. catch (FileNotFoundException e) { System.err.println("FileNotFoundException: " + e.getMessage()); throw new SampleException(e); } catch (IOException e) { System.err.println("Caught IOException: " + e.getMessage()); }

42. finally { if (out != null) { System.out.println("Closing PrintWriter"); out.close(); } else { System.out.println("PrintWriter not open"); } }

43. public void writeList() { PrintWriter out = null; try { System.out.println("Entering try statement"); out = new PrintWriter(new FileWriter("OutFile.txt")); for (int i = 0; i < SIZE; i++) out.println("Value at: " + i + " = " + victor.elementAt(i)); } catch (ArrayIndexOutOfBoundsException e) { System.err.println("Caught " +"ArrayIndexOutOfBoundsException: " + e.getMessage()); } catch (IOException e) { System.err.println("Caught IOException: " + e.getMessage()); } finally { if (out != null) { System.out.println("Closing PrintWriter"); out.close(); } else { System.out.println("PrintWriter not open"); } }}

44. this y super • La palabra clave this es una referencia a la instancia de la clase. Ej.: class Abc { int a; Abc(int a) { this.a = a; } } • La palabra super se usa para tener acceso a los miembros de la super–clase de la clase actual. O para llamar a su constructor: super().

45. Applets • Los applets son programas pequeños que hechos para distribuirse a través de internet y ejecutarse dentro del navegador. • Los programas tipo applet deben derivares de la clase Applet y sobre–escribir algunos métodos de ésta.

46. javadoc • Los comentarios que comienzan por /** son usados por la herramienta javadoc para crear documentación html de nuestras clases. • Dentro de estos comentarios se usan etiquetas como @author, @param, @return para insertar información. Dentro de los comentarios puede usarse código html y poner enlaces.