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

TÉCNICAS DE PROGRAMACIÓN

Lenguaje Java

Introducción a Java – 2Daniel Finol

2Daniel Finol – ICA - LUZ

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


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


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


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.


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.


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.


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.


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

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ía que 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


Excepcionesclass 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(new FileReader(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.

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

Documents

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