Download está la segunda parte de java

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