Java

Arreglos

• Declaración preferida de un arreglo:

int[] A; • Declaración compatible con C:

int A[];

Arreglos

• En Java, la declaración de un arreglo es similar a la declaración de un puntero en C:

• Errores típicos con arreglos:

int A[10]; // Ahí no va el tamaño!

int[] A; // Ok

A[1]= 100; // Todavía no se ha pedido

// espacio para el arreglo.

• Petición de espacio para un arreglo:

int[] A;

A= new int[10];

A[1]= 100; // Ahora sí!

Los argumentos de un programa

Al ejecutar un programa en la ventana de comandos, el usuario puede especificar argumentos:

java Hello Hola que tal Los argumentos "Hola", "que" y "tal" se reciben en un arreglos de strings en el main:

public static void main(String[] args) { ... } – args[0] es "Hola" – args[1] es "que" – args[2] es "tal"

• Ejemplo: Un programa que despliega todos los argumentos que recibe desde la línea de comandos.

• Ejecute el siguiente comando en la ventana de DOS: • java Echo Hola que tal • El código de Echo.java es: public class Echo { public static void main (String[] args) { for (int i=0; <args.length; i++)

System.out.println(args[i]); } }

public class Suma { public static void main (String[] args) {

// Un arreglo de 4 enteros: int[] a= new int[4]; a[0]= 1; a[1]= 5; a[2]= 20; a[3]= 15; // (estas dos instrucciones se pueden resumir en una sola: // int[] a={1, 5, 20, 15}; )

// Un segundo arreglo de 4 enteros con la inicializacion abreviada: int[] b= {2, 3, 23, 4};

// Esta es la parte que tiene que hacer Ud.

Construya un arreglo de ``a.length'' enteros y asígnelo a una variable c (de tipo arreglo de enteros).

Haga un ciclo haciendo que una variable entera i tome valores desde 0 hasta a.length-1

En cada iteración sume el i-ésimo elemento de a con el i-ésimo elemento de b y asigne el resultado al i-ésimo elemento de c

// Desplagamos el resultado: for (int i=0; i<c.length; i++) System.out.println("c["+i+"]= "+c[i]); Consola.esperar(); }}

Ejercicio

• Realice la suma de vectores siguiendo las instrucciones que aparecen en el ejemplo anterior.

Propuesto: Frecuencia de números

• Haga un programa que determine cuantas veces aparece cada número entero especificado en la línea de comandos. Ejemplo:

• java Frec 4 6 6 6 10 1000• 4 -> 1 6 -> 3 10 -> 1 Sólo considere los

números enteros que estén entre 0 y 99. Obs.: Para obtener el valor entero almacenado en el string s utilice Integer.parseInt(s).

Respuestapublic class Frec { public static void main (String[] args) { int[] F= new int[100]; // Con índices de 0 a 99

for (int i= 0; i<args.length; i++) { int num= Integer.parseInt(args[i]); if (num>=0 && num<100) F[num]++; // o bien F[num]= F[num]+1; }

for (int j=0; j<F.length; j++) if (F[j]!=0) System.out.println(j+" -> "+F[j]); }}

Objetos y Clases

• Un objeto es un tipo de datos abstracto. • Los objetos se crean con el operador new: • new Animator(); • new Box(Color.black, Color.red, 20, 25,

30, 15); • Al operador new se le indica la clase del

objeto que se desea crear. • Los argumentos indicados son los

atributos del objeto.

• La clase de un objeto determina las operaciones (métodos) que acepta ese objeto.

Para conocer un objeto es necesario tener una referencia de él:

Animator anim; Box box;

• Una variable referencia un objeto creado con new. La variable no contiene el objeto.

• El tipo de la variable indica la clase de objetos que podrá referenciar.

anim= new Animator(); box= new Box(Color.black, Color.red, 20, 25, 30,

15); box= new Animator(); // ¡Error en compilación!

• Invocación de métodos:

anim.push(box);

box.moveTo(100,200);

• Las variables en Java referencian objetos. • Las variables de tipos no primitivos son

punteros. • La asignación Box box2= box; hace que

las variables box y box2 referencien el mismo objeto.

• Sólo las variables de tipos primitivos contienen directamente los valores (int, double, boolean, etc.).

La referencia nula: null

• Agregue el siguiente código:

• Box box3= null; anim.push(box3);

• java.lang.NullPointerException: at Scenes.Scene.addAfter(Scene.java:64) at Scenes.Scene.push(Scene.java:86) at Game.main(Game.java:27)

• Una variable asignada con null no referencia ningún objeto. Si se intenta realizar cualquier operación con él se produce un NullPointerException.

Subclases

• La clase Grob tiene subclases: Box, Text, Ellipse.

• Los objetos de la subclase también pertenecen a la clase.

• Las operaciones de la clase también son válidas en objetos de la subclase.

• Proyección: Una variable de tipo Grob también puede referenciar objetos de cualquiera de las subclases de Grob.

• Grob go= box;

Bibliotecas de Clases

• Java ofrece una enorme biblioteca estándar de clases: Java Platform Core API.

• Todas las implementaciones de Java 1.1 implementan esta API.

• La API se organiza en paquetes de clases.

• Para poder usar el paquete java.io: • import java.io.*;

Entrada/Salida en Java

• Para leer un archivo por líneas: BufferedReader reader= new BufferedReader(new

FileReader(args[0]));

String linea= reader.readLine();

while(linea!=null) {

System.out.println(linea);

linea= reader.readLine();

}

Excepciones

• En la API se indica que ciertos métodos lanzan (throws) excepciones.

• Una excepción es una eventual situación de error que se podría producir al invocar un método. Ejemplo: El archivo no existe.

• Java encausa la programación de aplicaciones robustas forzando a que los programadores manejen todas las excepciones.

• Una excepción es un objeto de la clase Exception.

Excepciones

• Forma simple de manejar una excepción E:

• El método declara que lanza esa excepción (throws E).

• public static void main(String[] args) throws IOException { ... } Ejecute el programa colocando cualquier archivo de texto como argumento del programa en la línea de comandos.

• Forma recomendada de manejar una excepción E:

• Atrapar la excepción con:

• try { instrucciones } catch ( tipo-excepción variable ) { instrucciones }

public static void main(String[] args) // sin throws

{ try

{ coloque aquí todo el cuerpo del main }

catch ( IOException e ) {

System.err.println("Se produjo un error de E/S");

}

}

Constructores

• Un constructor es un método que lleva el mismo nombre de la clase.

• Se invoca automáticamente cada vez que se crea un nuevo objeto.

• Sirve para inicializar las variables de instancia del objeto.

• Un constructor puede incluir parámetros. Estos parámetros se enlazan con los argumentos especificados al crear un objeto con new.

• Una clase puede definir varios constructores con distintos tipos de argumentos (sobrecarga).

• Ejemplo: el constructor de Punto. public class Punto { int x,y; // Variables de instancia public Punto(int x, int y) { // El constructor this.x= x; this.y= y; } ... }

• Ejercicio: se desea agregar un nuevo constructor a la clase Punto que reciba como argumento otro punto. El punto creado debe quedar en las mismas coordenadas que el punto recibido.

• Ejemplo de uso: • Punto p= new Punto(10,10); Punto q=

new Punto(q); • System.out.println(q); // (10,10)