Taller JAVA:

Sintaxis
Arreglos
Clases y Objetos
Objetivos
1. Sintaxis – Eclipse
2. Arreglos
3. Profundizar los conceptos de:
• Clase
• Objeto
• Atributo
• Método
• Instancia
4. Construir aplicaciones sencillas que empleen
los conceptos anteriores.
Sintaxis – repaso rápido

¿Cuál sería la salida de las siguientes líneas de código?

int a = 5;
int b = 2;
double c = 2;

System.out.println(a/b); 2
System.out.println(((double) a)/b); 2.5
System.out.println(a/c); 2.5
Sintaxis – repaso rápido

¿Cuál sería la salida de las siguientes líneas de código?

String a = "aadvark";
String e = "elephant";

System.out.println(
a.substring(0,4) + Error
e.substring(3,9));
Sintaxis – repaso rápido

¿Cuál sería la salida de las siguientes líneas de código?

0
for(int i = 0; i < 5; i++) {
System.out.println(i*2);
2
}
4

8
 Arreglos
• Un arreglo es un conjunto de datos del mismo tipo.

• Los mas comunes son los arreglos de una dimensión (vectores) y de

dos dimensiones (matrices).

6
 Para usar un arreglo
1. Declarar.
2. Asignar espacio (tamaño).
3. Usar (guardar y leer datos)

Nota: los pasos se pueden hacer al mismo tiempo.

7
 Arreglos de una dimensión
1. Declarar
char a[];
int vector[];
double datos[];
2. Asignar espacio (tamaño)
a = new char[20]; // a[0]…a[19]
vector = new int[15]; //vector[0]…vector[14]
datos = new double[n]; // datos[0]…datos[n-1] (¿n debe cumplir alguna condición?)
n debe ser entero y tener valor

8
 Arreglos de una dimensión
Pasos 1 y 2 en una sola instrucción:

char a[] = new char[20];

int vector[] = new int[15];
double datos[] = new datos[n];

9
 Arreglos de una dimensión
3. Usar.

a[2] = ‘c’; // a es de tipo char

char d = a[6];
vector[10] = 29; // vector es de tipo int
if (datos[i] < 0.0) {
// datos es de tipo double, i ya debe tener valor
}

10
 Arreglos de una dimensión
Pasos 1, 2 y 3 en una instrucción:

char a[] = {‘h’, ‘o’, ‘l’, ‘a’};

int vector[] = {4, 32, 12, 45, 23};
float datos[] = {4, 2.4, 3.1415};

11
 Tamaño de un arreglo
• Una vez definido el tamaño de un arreglo, no se puede cambiar.
• La variable length regresa el tamaño del arreglo.
ej: nombre.length, donde nombre es el nombre de la variable.

12
 Tamaño de un arreglo
• Por ejemplo, para escribir todos los elementos de un arreglo:

int vector[] = {4, 3, 9, 7};

for (int i = 0; i < vector.length; i++)
System.out.println (vector[i]);

13
Sintaxis – repaso rápido - arreglos

¿Cuál sería la salida de las siguientes líneas de código?

String[] a = {“uno", “dos",“tres"};

uno
System.out.println(a[0]);
String[] b = a;
System.out.println(b[1]); dos
System.out.println(a[3]);
ERROR
Sintaxis – repaso rápido - arreglos

¿Cuál sería la salida de las siguientes líneas de código?

boolean flag = true;

n = 8; k = 2
int n = 8;
int k = 2;
n = 2; k = 2
while (flag) {
System.out.println("n = “ + n + "; k = " + k);
n = n - 3 * k;
if (n < 0) {
flag = false;
}
}
Sintaxis – repaso rápido - arreglos
¿Cuál sería la salida de las siguientes líneas de código?

int total = 0, i = 0;
while( total < 90 ) {
switch( i ) {
case 0:
total += 30;
30
i = 1;
break;
30
case 1:
i = 2;
60
total -= 15;
case 2:
60
i = 0;
total += 15;
90
break;
}
System.out.println(total);
}
Programación Orientada a Objetos

• Hay cuatro elementos fundamentales en este modelo:

• Abstracción.
• Encapsulamiento.
• Modularidad
• Jerarquía.
Abstracción
• “Una descripción simplificada o especificación de un sistema que
enfatiza algunos de los detalles o propiedades del mismo mientras
suprime otros.”
Encapsulamiento
• “Es cualquier mecanismo que nos permite ocultar la implementación
del objeto.”
Modularidad
• “La modularidad es la propiedad que tiene un sistema que ha sido
descompuesto en un conjunto de módulos cohesivos y débilmente
acoplados.”
Jerarquía
• La jerarquía es una clasificación u ordenación de abstracciones.
Clases
Entidades que describen objetos que tienen la misma estructura y el mismo
comportamiento.
Instancia:
Es el termino utilizado para referirse a un objeto que pertenece a una clase
concreta.
Atributos:
• Determinan una estructura de almacenamiento para cada objeto de la
clase.
Métodos:
• Operaciones aplicables a los objetos.
• Modo de acceder a los atributos.
Atributos y Métodos
Ejemplo: En una aplicación de operaciones con fracciones,
encontramos objetos fracciones. Estos objetos tienen propiedades
comunes:
Atributos: Numerador, denominador, …
Métodos: Multiplicar, dividir, …

ESTO VA EN UNA CLASE FRACCIÓN

public class Fraccion {
private int num;
private int den;
public Fraccion multiplicar(Fraccion f) {
Fraccion aux = new Fraccion();
aux.num = this.num * f.num;
aux.den = this.den * f.den;
return aux;
}
public Fraccion dividir(Fraccion f) {
Fraccion aux = new Fraccion();
aux.num = this.num * f.den;
aux.den = this.den * f.num;
return aux;
}
}
Modificadores de visibilidad:
Public: Accesible desde todas las clases
Private: accesible solo desde la clase donde se define
Métodos y Mensajes
Un método está compuesto por:
Cabecera: Identificador y Parámetros.
Cuerpo: Secuencia de instrucciones.
Mensaje:
Mecanismo básico de la computación OO.
Invocación de la aplicación de un método sobre un objeto.
Un mensaje está formado por tres partes:
Objeto receptor.
Selector o identificador del método a aplicar.
Argumentos.

Ejemplo: Fraccion producto = f1.multiplicar(f4);

Acceso y modificación de atributos
La única forma de acceder a los atributos es a través de métodos
públicos
Métodos get: para consultar el valor del atributo
Métodos set: para establecer el valor del atributo
Se aísla al cliente de los cambios en la estructura de datos.
public int getDen() {
return den;
}

public void setDen(int den) {

this.den = den;
}
Objetos
Un objeto es una instancia de una clase, creada en tiempo de
ejecución.
Es una estructura de datos formada por tantos campos como atributos
tiene la clase.
El estado de un objeto viene dado por el valor de los campos.
Los métodos permiten consultar y modificar el estado del objeto.
Definición de Métodos
Todo método tiene un valor de retorno.
Si no devuelve nada se indica con void.
Para cada método se establece el nivel de visibilidad.
¿Qué instrucciones podemos incluir en el cuerpo de un método?
• Asignación
• Estructuras condicionales
• Iteración
• Invocación a otro método = Mensajes
• Creación de objetos
Sobrecarga de métodos
Java soporta sobrecarga de métodos.
El mismo nombre pero con DIFERENTE lista de tipos de argumentos.
No pueden diferenciarse únicamente en el tipo de retorno.
public Fraccion() {
this.num = 0;
this.den = 1;
}

public Fraccion(int num, int den) {

this.num = num;
if(den==0){
den = 1;
}
this.den = den;
}

public Fraccion(int num) {

this.num = num;
this.den = 1;
}
Instancia actual
Cada operación de una computación OO es relativa a cierto objeto, la
instancia actual, en el momento de la ejecución de la operación.
¿A qué objeto Fraccion se refiere el texto de la rutina division?
El cuerpo de una rutina se refiere a la instancia sobre la que se aplica.
La instancia actual es el receptor de la llamada actual, el objeto
receptor del mensaje.
Si se aplica un método y no se especifica el objeto receptor, se asume
que es la instancia actual.
El lenguaje Java proporciona la palabra clave this que referencia a la
instancia actual.
Creación de Objetos
La declaración de una variable cuyo tipo sea una clase no implica la
creación del objeto.
Se necesita un mecanismo explícito de creación de objetos: new
¿Por qué?
Evitar cadena de creaciones antes de empezar a hacer nada útil
Estructuras recursivas
Los objetos se crean cuando se necesitan (referencias vacías,
compartir objeto)
Constructores
• Método encargado de inicializar correctamente los objetos.
• Métodos con el mismo nombre de la clase pero sin valor de retorno.
No se pueden invocar una vez que el objeto se ha creado.
• Permite sobrecarga para especificar formas distintas de inicializar los
objetos.
• Toda clase tiene que tener al menos un constructor.
• Si no se define ningún constructor, el compilador crea uno por
defecto sin argumentos, vacío, que inicializa los atributos a los valores
por defecto.
Creación de objetos
La construcción de un objeto consta de tres etapas:
• Se reserva espacio en memoria para la estructura de datos que define
la clase.
• Inicializa los campos de la instancia con los valores por defecto.
• Garantiza que cada atributo de una clase tenga un valor inicial antes de la
llamada al constructor
• Se aplica sobre la instancia el constructor que se invoca

Ejemplo: Fraccion f1 = new Fraccion(1, 4);

Atributos finales
• Java permite especificar que el valor de un atributo no podrá variar
una vez construido el objeto
• Un atributo se declara de sólo consulta anteponiendo el modificador
final a su declaración.
• Los atributos finales sólo pueden ser inicializados en la declaración o
en el constructor
Ejercicio 2
Construir un proyecto con dos clases.
En el método main de la clase principal se debe
instanciar 4 fracciones.
Se debe invocar a métodos para hacer el producto de
f1 con f2 y el cociente de f3 con f4.
Por último mostrar los resultados.
En la otra clase se describe al objeto “Fraccion”.
Sus atributos son numerador y denominador.
Tendrá los métodos producto y cociente.
Jerarquía de excepciones

Son objetos
Tratamiento de excepciones
El código que puede generar la excepción debe encerrarse dentro de
un bloque try.
try
{
// Código que puede generar la excepción
}
A continuación, la excepción se captura con un bloque catch.
catch (Exception e)
{
// Código para tratar el error
}
Tratamiento de excepciones
El código dentro del try puede generar más de una excepción, y se pueden
capturar todas ellas
try
{
//Código que puede provocar el error
}
catch(IOException ioe)
{
//Código para tratar la IOException
}
catch(Exception e)
{
//Código para tratar la Exception
}
Tratamiento de excepciones
try try
{ {
//código que genera //código que genera
//excepciones //excepciones
} }
catch(IOException ioe) catch(Exception e)
{ {
//catch accesible //catch accesible
} }
catch (Exception e) catch (IOException ioe)
{ {
//catch accesible //catch NO accesible
} }
Tratamiento de excepciones
try
Al tratamiento de una
{
//código que genera excepciones
excepción se le puede
} añadir al final un bloque
catch(IOException ioe) finally que se ejecuta
{ siempre, se produzcan o no
//tratamiento de la excepción Excepciones.
}
finally
Se puede usar para cerrar
{ ficheros, liberar recursos,
//código que se ejecuta siempre etc.
}
Tratamiento de excepciones
• Si una excepción no se captura se propaga hacia
el método llamante, para que éste la trate.
• Si no la trata, se sigue propagando hasta llegar
al main.
• Si en el main tampoco se trata, se aborta la
ejecución del programa.
Clase ArrayList
• Almacena datos de manera similar a los arrays.
• Tamaño dinámico.
• Iteradores.
Los Iteradores (Iterator) sirven para recorrer los ArrayList y poder trabajar con
ellos. Los Iteradores solo tienen tres métodos que son:
• “hasNext()” para comprobar que siguen quedando elementos en el iterador.
• “next()” para que nos de el siguiente elemento del iterador.
• “remove()” que sirve para eliminar el elemento del Iterador.
Clase ArrayList
ArrayList<String> nombreArrayList = new ArrayList<String>();
nombreArrayList.add("Elemento"); // Añade el elemento al ArrayList
nombreArrayList.add(n, "Elemento 2"); // Añade el elemento al ArrayList en la posición 'n'
nombreArrayList.size(); // Devuelve el numero de elementos del ArrayList
nombreArrayList.get(2); // Devuelve el elemento que esta en la posición '2' del ArrayList
nombreArrayList.contains("Elemento"); // Comprueba se existe del elemento ('Elemento')
que se le pasa como parámetro.
nombreArrayList.indexOf("Elemento"); // Devuelve la posición de la primera ocurrencia
('Elemento') en el ArrayList
nombreArrayList.lastIndexOf("Elemento"); // Devuelve la posición de la última ocurrencia
('Elemento') en el ArrayList
nombreArrayList.remove(5); // Borra el elemento de la posición '5' del ArrayList
nombreArrayList.remove("Elemento"); // Borra la primera ocurrencia del 'Elemento' que se le
pasa como parametro.
nombreArrayList.clear(); //Borra todos los elementos de ArrayList
nombreArrayList.isEmpty(); // Devuelve True si el ArrayList esta vacio. Sino Devuelve False
arrayListCopia = (ArrayList) nombreArrayList.clone(); // Copiar un ArrayList ArrayList
Object[] array = nombreArrayList.toArray(); // Pasa el ArrayList a un Array
ArrayList: Ejemplo
Ejercicio 3
Leer desde un fichero de texto, una serie de partidos de fútbol que
guardaremos en un ArrayList de objetos “PartidoFutbol”.
Los partido de fútbol estan guardados en el fichero con la siguiente
estructura: equipoLocal::equipoVisitante::golesLocal::golesVisitante
Recorremos el ArrayList con un Iterator y mostramos por pantalla todos
los resultados de fútbol.
Ejercicio 3: Leer un archivo
// Instanciamos el fichero donde estan los datos
File fichero = new File(nombreFichero);
Scanner s = null;

// Leemos el contenido del fichero

System.out.println("... Leemos el contenido del fichero ...");
s = new Scanner(fichero);

// Obtengo los datos de los partidos de fútbol del fichero

while (s.hasNextLine()){
String linea = s.nextLine();// Obtengo una linea del fichero (un partido de fútbol)
String [] cortarString = linea.split("::");// Obtengo los datos del partido de futbol
.
.
.
}