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

Presentación del tema: "TÉCNICAS DE PROGRAMACIÓN Lenguaje Java Introducción a Java – 2 Daniel Finol."— Transcripción de la presentación:

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

2 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 10 Clase Abstracta

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

12 Daniel Finol – ICA - LUZ 12 Clases Abstractas abstract class Figura { Color color; void setColor(Color nuevoColor) { color = nuevoColor; redibujar(); } abstract void redibujar(); } // fin de la clase Fig

13 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 17 Una interfaz puede extender otra interfaz. Marker Interfaces.

18 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 28 class StackException extends Exception { StackException() {} StackException(String msg) { super(msg); }

29 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 38 try/catch/finally try { statement(s) } catch (exceptiontype name) { statement(s) } finally { statement(s) }

39 Daniel Finol – ICA - LUZ 39 throws public static String readFirstLine(String filename) throws IOException { BufferedReader in = new BufferedReader(new FileReader(filename)); return in.readLine(); }

40 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 42 finally { if (out != null) { System.out.println("Closing PrintWriter"); out.close(); } else { System.out.println("PrintWriter not open"); }

43 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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 Daniel Finol – ICA - LUZ 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.