POO Unidad 2: Programación Orientada a Objetos

Programación Orientada a Objetos
Ph.D. Franklin Parrales
Carrera de Software
0
07/06/2022
Material docente compilado por el profesor Ph.D. Franklin Parrales Bravo
para uso de los cursos de Programación Orientada a Objetos
Programación Orientada a
Objetos
Unidad 2

Carrera de Software
1
07/06/2022
Objetivo general de la Unidad 2
Desarrollar proyectos que resuelvan problemas sencillos
de la realidad utilizando el modelamiento orientado a
objetos y manejando adecuadamente las posibles
excepciones a generarse.

Carrera de Software
2
07/06/2022
Contenido
▪ Encapsulamiento: paquetes, y modificadores de acceso
▪ Constructores, getters y setters.
▪ Sobrecarga de métodos
▪ Herencia y sobrescritura de métodos
▪ Clases abstractas e interfaces
▪ Modificadores final y static (en variables y métodos)
▪ Polimorfismo: upcasting, downcasting, enlace dinámico de
métodos
▪ Arreglos de objetos y uso de colecciones (ArrayList y HashMap)
▪ Definición, tipos y manejo de excepciones

Ph.D. Franklin Parrales 3
07/06/2022
Programación Orientada a Objetos Carrera de Software
Paquetes: empaquetado de clases
Son agrupaciones de clases, interfaces y otros paquetes relacionados
entre sí, que favorecen la encapsulación.
package nombrePaquete;
Todos los elementos contenidos en el archivo con la declaración
anterior formarán parte del paquete nombrePaquete.
Podríamos crear un paquete con la información relativa a la
matriculación de alumnos, que incluyera alumnos, asignaturas, notas,
profesorado, horarios, etcétera.
Posteriormente se podrían usar para diferentes aplicaciones de
matriculación: institutos, colegios, ...
package Matricula;
class Alumno { . . }
class Asignatura { . . . }
...

07/06/2022
Paquetes: empaquetado de clases
Para usar algún componente de un paquete hay que añadir una
declaración de importación, que puede ser de un elemento o de
todos los elementos.
Un solo elemento:
import Matricula.Alumno;
...
Alumno alumno1;
...
Todo el paquete sin cualificación:
import Matricula.*;
...
Alumno alumno1;
...
Se importa sólo la clase Alumno
Se importa todo y para usar los
elementos no es necesario
cualificarlos

07/06/2022
Paquetes: ejemplo de empaquetamiento
Creo el directorio que va a contener clases (relacionadas):
cursojava
→ utils
→ teclado
Y en ese directorio creo dos archivos, cada uno con una clase útil:
Al compilar dichos programa, se empaquetan dos clases .class en
el directorio teclado.
Archivo Clase01.java
Carpeta/package con utilidades
de lectura por teclado
package cursojava.utils.teclado;
public class Clase01 {}
package cursojava.utils.teclado;
public class Clase02 {}
Archivo Clase02.java

07/06/2022
Paquetes: ejemplo
Si quiero usar dichas clases en cualquier otro programa:
import cursojava.utils.teclado.*;
class PruebaPaq {
public static void main(String[] args){
Clase01 c = new Clase02();
Clase02 d = new Clase02()}
}
✓ Cuando el compilador se encuentra import, comienza a buscar en
los subdirectorio de CLASSPATH, y encuentra utilsteclado,
porque CLASSPATH= C:....
✓ Ahora puedo utilizar las clases públicas Clase01 y Clase02.
Puedo usar todas las clases
públicas del package teclado

07/06/2022
Paquetes
Todas las clases se organizan en paquetes incluso las clases del
sistema. Para utilizar algunas clases de un paquete o paquetes
enteros se utiliza la instrucción import.
Al importar un paquete sólo son accesibles sus elementos declarados
como públicos, salvo para las clases que heredan de alguna de las
declaradas en el paquete.
Ejemplos de paquetes incluidos en el sistema:
java.lang: Clases esenciales de java: Object, String...
java.util: Utilidades y estructuras de datos
java.io: Todo lo relacionado con entrada/Salida
java.net: Soporte para programación en red
java.awt, java.swing: Soporte para interfaces gráficas

07/06/2022
Paquetes

07/06/2022
Modificadores de acceso: miembros
◼ Se pueden establecer distintos niveles de encapsulación
u ocultamiento para los miembros de una clase
(atributos y métodos).
Paquetes (package): mecanismo para agrupar clases que tienen
algo en común.

07/06/2022
Modificadores de acceso:miembros
◼ Los distintos modificadores de acceso quedan resumidos
en la siguiente tabla:
La misma
clase
Otra clase del
mismo paquete
Subclase
Otra clase de
otro paquete
public X X X X
protected X X X
default X X
private X

07/06/2022
El modificador protected
package p1
class C1
protected int x
class C3
C1 c1;
c1.x se puede leer o
modificar
package p2
class C2 extends C1
x se puede leer o
modificar en C2
class C4
C1 c1;
c1.x no se puede leer
o modificar

Carrera de Software
12
07/06/2022
Combinación de datos y métodos
▪ Combinación de datos y métodos en una sola cápsula
▪ La frontera de la cápsula crea un espacio interior y otro
exterior
Retirar( )
Ingresar( )
saldo
Retirar( )
Ingresar( )
saldo
¿CuentaBancaria ?
¿CuentaBancaria?

Carrera de Software
13
07/06/2022
Control de la visibilidad de acceso
▪ Los métodos son públicos, accesibles desde el exterior
▪ Los datos son privados, accesibles sólo desde el
interior
Retirar( )
Ingresar( )
saldo
Retirar( )
Ingresar( )
saldo

¿CuentaBancaria ?
¿CuentaBancaria ?

Carrera de Software
14
07/06/2022
¿Por qué se encapsula?
▪ Porque permite el control
▪ El objeto se usa sólo
con los métodos
públicos
▪ Porque permite el cambio
▪ El uso del objeto no
varía si cambia el tipo
de los datos privados
Retirar( )
Ingresar( )
euros 12
Retirar( )
Ingresar( )
saldo 12,56
céntimos 56


Carrera de Software
15
07/06/2022
Datos de objetos
▪ Los datos de objetos describen información para objetos
concretos
▪ Por ejemplo, cada cuenta bancaria tiene su propio saldo. Si dos
cuentas tienen el mismo saldo, será sólo una coincidencia .
Retirar( )
Ingresar( )
saldo 12,56
prop. “Juan"
Retirar( )
Ingresar( )
saldo 12,56
prop. “Pedro"

07/06/2022
Público y privado: las clases
Las clases por defecto son “propias” del paquete (package)
en el que están definidas. Es decir, son conocidas en cualquier
otra clase del mismo paquete, pero no se podrán usar en
otros programas o paquetes.
Para que se puedan usar en otros programas o paquetes se deben
declarar como “públicas”, usando el modificador de acceso public:
public class ...
En cada archivo fuente sólo puede haber una clase pública.
Lo normal es declarar cada clase en su propio archivo fuente.
También los atributos y los métodos son, por defecto, conocidos
en todas las clases del paquete en el que se encuentra su clase.
Pero a los atributos y los métodos se les puede aplicar tanto
el modificador de de acceso public como el modificador
de acceso private.

07/06/2022
Público y privado: atributos y métodos
Un atributo o método public se conocerá en cualquier otro
programa o paquete, pudiendo ser entonces accedido por medio
de objetos de esa clase (con la notación punto).
Un atributo o método private sólo se conoce en la propia clase
en la que está definido, pudiendo ser accedido tan sólo en ella.
 Los métodos serán públicos si constituyen servicios
que los objetos proporcionan al exterior
y privados si son funciones auxiliares de la clase.
Las directrices de la programación orientada a objetos nos aseguran
un menor riesgo de errores en los programas si:
✓ Los atributos se declaran siempre como privados.
✓ La manipulación de los atributos se realiza, consecuentemente,
por medio de métodos (públicos, claro).

Carrera de Software
18
07/06/2022
Contenido
métodos

07/06/2022
Inicialización de objetos: los constructores
Aunque Java realiza una inicialización automática de los atributos,
a menudo los valores que se asignan por defecto no son adecuados
para nuestras necesidades o podemos necesitar indicar cuáles
han de ser esos valores de inicialización.
Para realizar una inicialización personalizada de los atributos
disponemos de los constructores, unos métodos especiales.
Los constructores se llaman igual que las clases (son excepciones
de la regla de comienzo por minúscula para los métodos).
public Punto() {
_x = 1;
_y = 1;
}
Ahora, cuando se creen objetos (new Punto())
se establecerán las dos coordenadas (atributos) con el valor 1.
No se indica ningún tipo para el método.
Esa información la añade automáticamente el compilador

07/06/2022
Inicialización de objetos: los constructores
Los constructores se pueden sobrecargar, de forma que podemos
incluir otro en la clase Punto:
public Punto(double cx, double cy) {
_x = cx;
_y = cy;
}
Ahora podemos crear objetos de la clase Punto proporcionando los
valores deseados para las dos coordenadas:
Punto p = new Punto(3,7);
Si no se proporcionan argumentos, se ejecuta automáticamente el
constructor predeterminado (el que no tiene parámetros).
Y si no se proporciona ningún constructor, el compilador añade uno
predeterminado por su cuenta (que inicializa siempre por defecto).
→ Por esto se crean los objetos con el nombre de la clase seguida de paréntesis.

07/06/2022
Público y privado: accedentes(Get) y mutadores(Set)
Como los atributos deben ser siempre privados, a menudo
necesitaremos ciertos métodos que nos permitan establecer
u obtener los valores de los atributos:
✓ Accedente(Get): método que nos devuelve el valor de un atributo.
✓ Mutador (Set): método que nos permite ajustar el valor de un
atributo.
Normalmente tendremos un accedente y un mutador por cada
atributo. Aunque habrá ocasiones en las que no proceda
que haya accedentes o (sobre todo) mutadores, para evitar
que el programador que use la clase pueda alterar un valor
que deba ser ajustado tan sólo por la propia clase.

07/06/2022
Una clase Punto con getters(accedente) y setters(mutador)
public class Punto {
private double _x;
private double _y;
public double x() { // accedente
return _x;
}
public double y() { // accedente
return _y;
}
public void x(double d) { // mutador
_x = d;
}
public void y(double d) { // mutador
_y = d;
}
public void print() {
System.out.print("(" + _x + "," + _y + ")");
}
} Punto.java
Atributos privados
Servicios que
proporciona la clase:
métodos públicos

07/06/2022
Ejercicio: una clase Contador
Crea una clase que se denomine Contador y que defina un único
atributo _contador (un entero).
El contador se podrá inicializar a cualquier valor no negativo.
Otros servicios que han de proporcionar los objetos de esta clase:
✓ Obtener / ajustar el valor del contador.
✓ Incrementar / decrementar el contador (en una unidad).
✓ Mostrar el valor actual del contador.
El contador nunca podrá tener un valor negativo.
Prueba la clase con un programa principal que cree varios contadores
y use sobre ellos todos los métodos existentes.
Comprueba también el comportamiento de las variables referencias.
Usa los modificadores de acceso public y private de acuerdo
con las directrices de la POO.

07/06/2022
Ejercicio: mejora de la clase Contador
Modifica la clase Contador del ejercicio anterior, de forma que la
inicialización del atributo se realice siempre durante la creación de los
objetos (constructores).
Por defecto, el atributo se inicializará a 1.
Prueba nuevamente la clase en un programa principal.

Carrera de Software
25
07/06/2022
Contenido
métodos

07/06/2022
¿Qué es la sobrecarga(overloading) de métodos?
◼ Si una clase tiene varios métodos con el mismo nombre pero
diferentes parámetros, se conoce como sobrecarga de métodos.
◼ Si tenemos que realizar una sola operación, tener el mismo nombre de
los métodos aumenta la legibilidad del programa.
◼ ¿Ventaja de la sobrecarga de métodos?
◼ La sobrecarga de métodos aumenta la legibilidad del
programa.

07/06/2022
Métodos: sobrecarga
✓ Los métodos se pueden sobrecargar: varios métodos con igual
nombre pero diferente signatura.
public class X {
...
}
static int max(int num1, int num2) { ... }
static long max(long num1, long num2) { ... }
static float max(float num1, float num2) { ... }
static double max(double num1, double num2) { ... }
}
✓ Se sabe cuál usar por el tipo de los argumentos.
Sobrecarga.java

Carrera de Software
28
07/06/2022
Diferentes formas de sobrecargar el
método
▪ Hay dos formas de sobrecargar el método en Java
▪ Al cambiar el número de argumentos
▪ Al cambiar el tipo de datos
▪ Nota: En Java, la sobrecarga de métodos no es posible
cambiando el tipo de devolución del método.

07/06/2022
1) Método de sobrecarga cambiando el no. de argumentos
class Calculation {
void sum(int a,int b) {
System.out.println(a+b); }
void sum(int a,int b,int c) {
System.out.println(a+b+c); }
public static void main(String args[]) {
Calculation obj=new Calculation();
obj.sum(10,10,10);
obj.sum(20,20);
}
}
Output:
30
40

07/06/2022
2) Sobrecarga del método cambiando el tipo de datos del
argumento
class Calculation{
void sum(int a,int b){
System.out.println(a+b);}
void sum(double a,double b){
System.out.println(a+b);}
public static void main(String args[]){
obj.sum(10.5,10.5);
obj.sum(20,20);
}
}
Output:
21.0
40

07/06/2022
¿Por qué la sobrecarga de métodos no es posible
cambiando el tipo de método de retorno?
class Calculation {
int sum(int a,int b) {
double sum(int a,int b) {
int result=obj.sum(20,20);
//Compile Time Error
/* Here how can java determine which sum() method should be called */
}
}

07/06/2022
¿Podemos sobrecargar el método main()?
class Simple{
public static void main(int a){
System.out.println(a);
}
System.out.println("main()method invoked");
main(5);
}
}
Output:
main() method invoked
5

Carrera de Software
33
07/06/2022
Contenido
métodos

07/06/2022
Herencia
Mecanismo exclusivo y fundamental de la POO.
La herencia no está contemplada en la programación
basada en tipos (TAD).
Es el principal mecanismo que ayuda a fomentar y
facilitar la reutilización del software:
Las clases como componentes software reutilizables.
Si se necesita una nueva clase de objetos y se detectan suficientes
similitudes con otra clase ya desarrollada, se toma esa clase existente
como punto de partida para desarrollar la nueva:
✓ Se adoptan automáticamente características ya implementadas
 Ahorro de tiempo y esfuerzo
✓ Se adoptan automáticamente características ya probadas
 Menor tiempo de prueba y depuración

07/06/2022
Herencia
Base de la aplicación del mecanismo de herencia:
◼ Suficientes similitudes:
Todas las características de la clase existente
(o la gran mayoría de ellas)
resultan adecuadas para la nueva.
◼ En la nueva clase se ampliará y/o redefinirá
el conjunto de características.
Características de las clases que se adoptan:
Todos los miembros definidos en las clases.
◼ Atributos
◼ Métodos
Dependiendo de la forma en que se aplique el mecanismo de
herencia, en la nueva clase se puede tener o no acceso a ciertas
características heredadas (a pesar de que se adopten todas).

07/06/2022
Herencia
La relación de herencia se establece entre una nueva clase
(referida aquí con el nombre Nueva) y una clase ya existente
(referida aquí con el nombre Existente).
Un poco de terminología:
✓ Existente se dice que es la clase base, la clase madre
o la superclase (término genérico de la POO).
✓ Nueva se dice que es la clase derivada, la clase hija
o la subclase (término genérico de la POO).
✓ También se utiliza el término derivación para
referirse a la herencia.
✓ La clase Nueva es la que tiene establecida la relación de herencia
con la clase Existente; Existente no necesita a Nueva, pero
Nueva sí necesita la presencia de Existente.

07/06/2022
Herencia
La relación de herencia se establece entre una clase Nueva
y una clase Existente.
Sobre la clase que hereda de la existente:
✓ Nueva hereda todas las características de Existente.
✓ Nueva puede definir características adicionales.
✓ Nueva puede redefinir características heredadas de Existente.
✓ El proceso de herencia no afecta de ninguna forma a la superclase
Existente.
Para que una nueva clase sea subclase
de otra existente basta con añadir
extends existente
a continuación del nombre de la nueva:
public class Nueva extends Existente {
...
Existente
Nueva

07/06/2022
Herencia: una subclase Alumno
Recordemos la clase Persona del tema anterior.
Vamos a crear una subclase Alumno para representar alumnos
de una clase.
✓ Los alumnos también tienen NIF, nombre, apellidos y edad:
Los atributos de la clase Persona son adecuados para Alumno.
✓ Los métodos de la clase Persona, en principio, parecen todos
ellos adecuados para la clase Alumno.
Los alumnos son personas
Resulta adecuado aplicar el mecanismo de herencia y crear
la nueva clase (Alumno) a partir de la existente (Persona).
public class Alumno extends Persona {
...
}

07/06/2022
...
}
Por el mero hecho de indicar que Alumno es subclase de Persona,
los objetos de la clase Alumno ya tienen automáticamente 4 atributos
y 12 métodos, los heredados de la clase Persona.
En la subclase Alumno obviamente se puede acceder a lo público
de la superclase Persona, pero NO se puede acceder a lo privado
de la superclase Persona (los atributos en este caso).
Ahora nos centramos en lo que hay que añadir en la subclase:
✓ Un atributo curso.
✓ Accedente y mutador para el nuevo atributo.

07/06/2022
private int curso;
// Accedente
public int dameCurso() { return curso; }
// Mutador
public void ponCurso(int curso) { this.curso = curso; }
}
La clase Alumno ya tiene un atributo y 2 métodos más (propios).
En la subclase Alumno nos faltan los constructores.
En los constructores podemos aprovechar lo que ya hacen
los constructores de la superclase Persona,
invocándolos por medio de la palabra reservada super.

07/06/2022
private int curso;
// Constructor predeterminado
public Alumno() {
super();
curso = 1;
}
// Constructor parametrizado
public Alumno(long dni, int edad, String nombre,
String apellidos, int curso) {
super(dni, edad, nombre, apellidos);
this.curso = curso;
}
public void ponCurso(int curso) { this.curso=curso; }
}

07/06/2022
Redefinición(sobrescritura) de métodos
Algunos de los métodos heredados pueden no resultar adecuados (en
mucho o en poco). Resulta necesario volver a desarrollarlos
en la subclase. Para hacerlo basta crear un método en la subclase con
el mismo nombre que el de la superclase y entonces se pasará por
alto éste y se ejecutará el de la subclase.
Pero si en un método redefinido se quiere ejecutar un método de la
superclase que se ha redefinido, se puede utilizar la palabra clave
super para pasarle el correspondiente mensaje.
public String toString() {
// De la subclase Alumno
return super.toString() + "Curso: " + curso + "n";
}

07/06/2022
private int curso;
public Alumno() {
super();
curso = 1;
}
public Alumno(long dni, int edad, String nombre,
this.curso = curso;
}
return super.toString() + "Curso: " + curso + "n";
}
public void leer() {
super.leer();
System.out.print("Curso: ");
curso = MyInput.readInt();
}
} Alumno.java

07/06/2022
Subclase Alumno2 con atributo de clase Persona
public class Alumno2 extends Persona {
private int curso;
private Persona profesor;
public Alumno2() {
super();
curso = 1;
profesor = null;
}
public Alumno2(long dni, int edad, String nombre,
String apellidos, int curso, Persona profesor) {
this.curso = curso;
this.profesor = profesor;
}
public Alumno2(long dni, int edad, String nombre,
this.curso = curso;
this.profesor = null;
}
. . .
Persona
Alumno2
1

07/06/2022
Subclase Alumno2 con atributo de clase Persona
public Persona dameProfesor() { return profesor; }
public void ponProfesor(Persona profesor)
{ this.profesor = profesor; }
String cadena = super.toString() + "Curso: " + curso
+ "nProfesor: ";
if(profesor == null) cadena += "no asignado.n";
else cadena += profesor.nombreCompleto() + "n";
return cadena;
}
public void leer() {
super.leer();
System.out.print("Curso: ");
curso = MyInput.readInt();
}
}
Alumno2.java

07/06/2022
Sobrescritura(Overriding) de Métodos en Java
◼ Si la subclase (clase secundaria) tiene el mismo método que el
declarado en la clase principal, se conoce como Sobrescritura de
método.
◼ En otras palabras, si la subclase proporciona la implementación
específica (diferente) del método que ha proporcionado una de sus
clases principales, se conoce como Sobrescritura de método.
◼ Ventajas
◼ La sobrescritura de métodos se utiliza para proporcionar una
implementación específica de un método que ya proporciona su
superclase.
◼ La sobrescritura de métodos se utiliza para el polimorfismo en
tiempo de ejecución

07/06/2022
Reglas para la sobrescritura de métodos
◼ El método debe tener el mismo nombre que en la clase principal
◼ El método debe tener el mismo parámetro que en la clase
principal.
◼ Debe ser una relación ES-UN (herencia).

07/06/2022
Ejemplo
class Animal{
public void move(){
System.out.println("Animals can move");
} }
class Dog extends Animal{
public void move(){
System.out.println("Dogs can run");
} }
public class TestDog{
Dog d = new Dog();
d.move();
//Runs the method in Dog class
} }
Output:
Dogs can run

07/06/2022
Otro Ejemplo

07/06/2022
Otro Ejemplo
class Bank{
int getRateOfInterest(){
return 0;
} }
class SBI extends Bank {
return 8;
} }
class ICICI extends Bank {
return 7;
} }
class AXIS extends Bank{
return 9;
} }
class Test{
SBI s=new SBI();
ICICI i=new ICICI();
AXIS a=new AXIS();
System.out.println("SBI Rate of Interest: "+s.getRateOfInterest());
System.out.println("ICICI Rate of Interest: "+i.getRateOfInterest());
System.out.println("AXIS Rate of Interest: "+a.getRateOfInterest());
} }
Output:
SBI Rate of Interest: 8 ICICI
Rate of Interest: 7 AXIS
Rate of Interest: 9

07/06/2022
¿Diferencia entre sobrecarga y sobrescritura de métodos?
◼ Hay tres diferencias básicas entre la sobrecarga de métodos y la
anulación de métodos. Son los siguientes:
Method Overloading Method Overriding
1) La sobrecarga de métodos se
utiliza para aumentar la legibilidad
del programa.
La sobrescritura de métodos se utiliza
para proporcionar la implementación
específica del método que ya
proporciona su superclase.
2) La sobrecarga de métodos se
realiza dentro de una clase.
La sobrescritura de métodos ocurre
en dos clases que tienen una relación
ES-UN.
3) En caso de sobrecarga del
método, el parámetro debe ser
diferente.
En caso de sobrescritura de métodos,
el parámetro debe ser el mismo.

Carrera de Software
52
07/06/2022
Contenido
métodos

07/06/2022
Jerarquía de clases
A medida que se establecen relaciones de herencia entre las clases,
implícitamente se va construyendo una jerarquía de clases.
En forma de árbol:
Titular
Alumno Profesor
Administrativo
Oficial Libre Tiempo-
Completo
Tiempo-
Parcial
Catedratico
Persona
Object

07/06/2022
Utilizando diagramas de UML (omitiendo la clase Object):
Persona
Administrativo
Alumno Profesor
Oficial Libre TiempoCompleto TiempoParcial
Libre
Catedratico Titular

07/06/2022
Cuanto más arriba en la jerarquía,
más abstractas son las clases
(menor nivel de detalle).
A medida que se desciende
por la jerarquía aumenta
el nivel de detalle
(disminuye la abstracción).
Así, una Persona es una entidad
mucho más abstracta y general que un Titular.
◼ Cada clase de la jerarquía debe implementar todas las
características que son comunes a todas sus subclases.
◼ Cada subclase debe contemplar únicamente las peculiaridades
que la distinguen de su superclase.
Titular
Alumno Profesor
Administrativo
Oficial Libre Tiempo-
Completo
Tiempo-
Parcial
Catedratico
Persona

07/06/2022
Clases abstractas
En ocasiones tendremos definidas clases en la jerarquía que
simplemente recogen las características comunes de otra serie de
clases (sus descendientes), pero que no se van a (o no se deben)
utilizar para crear ejemplares.
Clase abstracta:
✓ Modela el comportamiento común de sus clases derivadas.
✓ Implementa métodos que son comunes a todas sus subclases.
✓ Establece métodos que necesariamente han de ser implementados
por sus subclases (las clases derivadas).
En el sistema no van a crearse ejemplares de la clase abstracta
porque no serían objetos con existencia propia en el mundo real.
Los objetos que se crearán serán ejemplares de las subclases
(aquellas que no sean también abstractas).
La clase abstracta puede definir atributos comunes a sus subclases.

07/06/2022
Clases abstractas
ObjetoGrafico y
Paralelogramo son
clases abstractas.
En el programa de dibujo sólo se van a crear objetos gráficos
concretos: puntos, elipses, círculos, cuadrados, rectángulos,
rombos o romboides.
Clases abstractas
ObjetoGrafico
Punto
Circulo Paralelogramo
Elipse
Rectangulo Romboide
Cuadrado Rombo

07/06/2022
Clases abstractas
Para definir una clase como abstracta se coloca la palabra reservada
abstract antes de class:
public abstract class ObjetoGrafico {
...
Si en la clase abstracta se quiere obligar a que las subclases
implementen un determinado método, basta declararlo como método
abstracto. No tendrá cuerpo y terminará en punto y coma:
public abstract class ObjetoGrafico { // Abstracta
public abstract String toString();
public abstract void leer();
public abstract boolean esCerrada();
}
Las subclases (no abstractas) no podrán compilarse si no implementan
métodos con esos prototipos.
ObjetoGrafico.java

07/06/2022
Clases abstractas
// Clase Punto: no abstracta
public class Punto extends ObjetoGrafico {
private double x;
private double y;
public Punto() {
x = 0;
y = 0;
}
public Punto(double cx, double cy) {
x = cx;
y = cy;
}
public double dameX() { return x; }
public double dameY() { return y; }
public void ponX(double d) { x = d; }
public void ponY(double d) { y = d; } . . .

07/06/2022
Clases abstractas
// Implementa todos los métodos abstractos:
public void desplaza(double deltaX, double deltaY) {
x += deltaX;
y += deltaY;
}
public String toString(){
return "(" + x + "," + y + ")";
}
public boolean esCerrada() { return false; }
}
Punto.java

07/06/2022
Clases abstractas
// Paralelogramo: otra clase abstracta
public abstract class Paralelogramo
extends ObjetoGrafico {
protected Punto esquina;
public Paralelogramo() { esquina = new Punto(0, 0); }
public Punto dameEsquina() { return esquina; }
public void ponEsquina(Punto p) { esquina = p; }
// Implementa uno de los métodos abstractos
public boolean esCerrada() { return true; }
// Todos los paralelogramos son cerrados.
}
Paralelogramo.java

07/06/2022
Clases abstractas
// Cuadrado: clase no abstracta
public class Cuadrado extends Paralelogramo {
protected double lado;
public Cuadrado() {
super();
lado = 0;
}
public double dameLado() { return lado; }
public void ponLado(double d) { lado = d; }
// Implementa los otros dos métodos abstractos
return "[" + esquina.toString() + ", " + lado + "]";
}
public void desplaza(double deltaX, double deltaY) {
esquina.desplaza(deltaX, deltaY);
}
}
Cuadrado.java

07/06/2022
Interfaz e implementación
Todo aquello que esté declarado como público en la clase
constituirá la interfaz de la clase, lo que puede ser utilizado
en otras clases.
Como hemos visto, la interfaz va a venir dada por:
✓ El nombre de la clase.
✓ Las signaturas de los métodos públicos.
Todo lo que no es parte de la interfaz es parte de la implementación:
✓ Los atributos.
✓ Los métodos privados.
✓ Los cuerpos de todos los métodos.
La implementación no tiene por qué ser conocida para poder utilizar la
clase. Lo único que necesitamos conocer es la interfaz.

07/06/2022
Una clase Punto más correcta
I
N
T
E
R
F
A
Z
public class Punto {
private double _x;
private double _y;
public double x() { // accedente
return _x;
}
public double y() { // accedente
return _y;
}
public void x(double d) { // mutador
_x = d;
}
public void y(double d) { // mutador
_y = d;
}
public void print() {
System.out.print("(" + _x + "," + _y + ")");
}
} Todo lo que no es interfaz es implementación Punto.java
Atributos privados
Servicios que
proporciona la clase:
métodos públicos
A menudo los
atributos se
colocan al final

07/06/2022
Una clase Punto más correcta
Lo privado (los atributos) está aislado del exterior, siendo accesible
sólo por el código de los métodos de la clase.
Ahora, un código como
este no compilará:
Punto p;
p = new Punto();
p._x = 7; // ERROR
No se permite acceder
al atributo _x.
Hay que usar un mutador:
p.x(7); // OK
_y
_x
x()
x(double)
y()
y(double)
print()
Protegidos
frente a
accesos
desde el
exterior
Accesibles
desde el
interior

07/06/2022
Dentro (de la clase) y fuera (de los objetos)
La clase (dentro del objeto)
Se conocen los atributos.
Se conocen todos los métodos
(públicos o privados).
Implementa los métodos:
En el método se trabaja sobre
o con el objeto receptor.
Para pasar otro mensaje al objeto
receptor basta invocar
el correspondiente método
(sin poner ni receptor ni punto).
El método puede utilizar también
objetos locales y objetos
parámetros.
Desde fuera del objeto
No se conocen sus atributos.
No se conocen sus métodos
privados.
Sólo se conocen los servicios que
proporciona (métodos públicos).
Se utiliza pasándole mensajes.
Paso de mensaje:
objeto.mensaje(...)
Se ejecuta el código del método
con igual nombre que esté
definido en su clase (y con
parámetros que concuerden).

07/06/2022
Categorías de métodos
En las clases se pueden identificar distintas categorías de métodos:
✓ Métodos accedentes: devuelven el contenido de los atributos
(cada accedente devuelve un atributo) – x().
✓ Métodos mutadores: establecen el contenido de los atributos
(cada mutador, el contenido de un atributo) – x(double).
✓ Métodos visualizadores: muestran el objeto (valores de los
atributos o alguna representación visual del objeto) – print().
✓ Métodos inicializadores: inicializan atributos.
✓ Métodos computadores: realizan cálculos y generan resultados.
✓ Otros.
En algunas clases no tendrán sentido ciertos tipos de métodos:
✓ Por ejemplo, en una clase Pila no debe haber accedentes ni
mutadores, ya que se trata de una máquina de datos que se
usa sólo mediante operaciones como la inserción y la eliminación.

07/06/2022
Interfaces
Java no permite herencia múltiple (una clase extienda varias otras).
Sin embargo, por medio de los interfaces se puede conseguir un
efecto similar.
Una interfaz es parecido a una clase abstracta, pero sólo puede
tener definidos métodos abstractos y constantes (static/final). Ni
atributos ni implementaciones de métodos.
Se crear igual que las clases, pero utilizando interface
en lugar de class:
public interface Comparable { // interfaz estándar
public int compareTo(Object obj); // sin abstract
}
Esta interfaz define un único método, que indica si el objeto receptor
es menor que el proporcionado (resultado negativo),
es mayor (resultado positivo) o es igual (0 como resultado).
Recuérdese que Object es la clase raíz de la jerarquía.

07/06/2022
Interfaces
Las clases pueden implementar interfaces, asegurando que incluyen la
funcionalidad descrita en la interfaz (o las interfaces).
public class Persona2 implements Comparable {
...
public int compareTo(Object obj) {
String este = nombreCompleto().toUpperCase();
String otro =
((Persona) obj).nombreCompleto().toUpperCase();
return este.compareTo(otro);
}
}
Nada impide que una clase herede de otra e implemente interfaces:
public class Alumno extends Persona
implements Comparable {
...
Y se pueden implementar varias interfaces (separadas por comas).
Persona2.java

07/06/2022
La interfaz Cloneable
Para que Java permita crear clones de los objetos de una clase
por medio del método clone() de la clase Object,
la clase debe implementar la interfaz Cloneable.
public class Alumno3 extends Persona
implements Cloneable {
...
}
Además, la clase debe redefinir el método clone() heredado
de la clase Object. Y debe hacerlo de esta forma:
public Object clone() {
try {
return super.clone();
}
catch (CloneNotSupportedException ex) {
return null;
}
}
El método debe estar protegido con el
manejo de esa excepción frente a intentos
de clonación de objetos de superclases
Alumno3.java

07/06/2022
public class PruebaAlumno3 {
Alumno3 al1 = new Alumno3(435762, 23, "Javier",
"Hernandez Perez", 4);
Persona per = new Persona(112233, 22, "Pedro",
"Gomez Alvarez");
al1.ponProfesor(per);
System.out.println(al1);
Alumno3 al2 = (Alumno3) al1.clone();
al1.ponNombre("Angel");
per = al1.dameProfesor();
per.ponNombre("Rosa");
}
}
Shallow copy (copia superficial)
El atributo profesor no se clona.
PruebaAlumno3.java

07/06/2022
Para conseguir una copia profunda (deep copy), el método clone()
de la clase se debe encargar de obtener por su cuenta
los clones de los atributos que sean referencias.
En la clase Persona se debe permitir la clonación:
try {
return super.clone();
}
catch (CloneNotSupportedException ex) {
return null;
}
}
Persona3.java

07/06/2022
En la clase Alumno el método clone() debe crear el clon
del profesor para colocarlo en su propio clon:
Alumno4 al = (Alumno4) super.clone();
Persona3 per = (Persona3) profesor.clone();
al.ponProfesor(per);
return al;
}
Como el método de la superclase Persona ya está protegido
con el manejo de la excepción, aquí no hay que volver a protegerlo.
PruebaAlumno4.java
Alumno4.java

07/06/2022
Clases internas
Una clase interna o anidada es una clase que está definida dentro
de otra clase (como si fuera otro atributo):
public class Clase {
private int dato;
public void metodo() {
Interna ejemplar = new Interna();
}
class Interna {
public void otro() {
dato++; // Puede acceder a los atributos
metodo(); // y a los métodos de la externa.
}
}
}
La clase interna sólo es conocida en aquella en la que se encuentra.
Si la clase interna es anónima (sin nombre)
se crea automáticamente un ejemplar suyo.
Es una clase auxiliar

Carrera de Software
75
07/06/2022
Contenido
métodos

07/06/2022
Los modificadores protected y final
Si se quiere permitir que en las subclases se pueda acceder
a los atributos de la superclase (o a métodos privados)
se declararán éstos como protected en lugar de private.
public class Persona {
protected Nif nif;
protected int edad;
protected String nombre, apellidos;
...
Y si se quiere evitar que se creen subclases de una clase se debe
declarar como final.
public final class Persona {
...

07/06/2022
Uso de datos estáticos
◼ Los datos estáticos describen información para todos los objetos de
una clase
◼ Por ejemplo, supongamos que todas las cuentas comparten el
mismo interés. No sería conveniente almacenar el interés en
todas las cuentas. ¿Por qué?
Retirar( )
Ingresar( )
saldo 12,56
interés 7%
Retirar( )
Ingresar( )
saldo 99,12
interés 7%
 

07/06/2022
Atributos de ejemplar y atributos de clase
Todos los atributos que hemos declarado hasta ahora
son atributos de ejemplar (o de “instancia”).
Cada objeto de la clase que se cree tendrá su propio atributo,
distinto de los atributos de los demás objetos.
También podemos declarar atributos de clase,
atributos compartidos por todos los objetos de la clase.
Tan sólo hay un ejemplar del atributo, de forma que todos
los objetos acceden a la misma zona de almacenamiento.
Para declarar un atributo como de clase,
basta añadir el modificador static en su declaración.
class Clase {
private static int _cuantos = 0; // Atributo de clase
private float _f; // Atributo de ejemplar
...
}
Los atributos constantes se declaran
como atributos de clase (final static)

07/06/2022
Atributos compartidos
class Clase {
private static int _cuantos = 0;
private float _f;
public Clase() {
_cuantos++;
}
public int cuantos() {
return _cuantos;
}
}
public class DeClase {
public static void main(String[] args) {
Clase c1 = new Clase();
System.out.println("Se han creado " + c3.cuantos() +
" objetos.");
}
}
DeClase.java

07/06/2022
0
_cuantos

07/06/2022
0
1
_cuantos
_f
c1
_cuantos

07/06/2022
2
_f
c1
_cuantos
_f
c2
_cuantos
_cuantos

07/06/2022
3
_f
c1
_cuantos
_f
c2
_cuantos
_f
c3
_cuantos
_cuantos

07/06/2022
Uso de métodos estáticos
◼ Los métodos estáticos acceden sólo a datos estáticos
◼ Un método estático se llama en la clase, no el objeto
Interés( )
interés 7%
Retirar( )
Ingresar( )
saldo 99,12
prop. “Pedro"
Un objeto cuenta
La clase cuenta
Las clases contienen datos
y métodos estáticos
Los objetos contienen datos
y métodos de objetos


✓

07/06/2022
Métodos de ejemplar y métodos de clase
El ejemplo anterior tiene un defecto.
¿Cómo podemos saber cuántos ejemplares (objetos) se han creado
antes de que se haya creado el primero?
Como todavía no se ha creado ninguno, no podemos pasar
el mensaje cuantos() a ningún objeto.
La solución se encuentra en los métodos de clase, métodos que
se ejecutan cuando el mensaje se pasa a la propia clase.
Para declarar un método como de clase,
basta añadir el modificador static en su declaración.
class Clase {
...
public static int cuantos() { // Método de clase
return _cuantos;
}
}

07/06/2022
Métodos de ejemplar y métodos de clase
class Clase {
...
public static int cuantos() { // Método de clase
return _cuantos;
}
}
public class DeClase2 {
System.out.println("Se han creado " +
Clase.cuantos() + " objetos.");
System.out.println("Se han creado " + c3.cuantos() +
" objetos.");
}
} DeClase2.java

07/06/2022
Ejercicio: una clase Usuario
Crea una clase Usuario que maneje los siguientes datos:
✓ Identificador del usuario (_idUsuario, un entero).
✓ Contador de accesos al sistema (_accesos).
✓ Contador de intentos de acceso fallidos (_fallidos).
Cada usuario tendrá un identificador distinto de los de los demás
usuarios. Se asignará el último número asignado más uno.
Para los contadores se utilizará la clase Contador del ejercicio
anterior, pero inicializando a cero por defecto.
La clase será usada por otra denominada Sistema que será
la que cree Usuarios y les notifique los accesos válidos o fallidos.
A los objetos de la clase Usuario se les podrá pasar un mensaje
println() para que muestren toda su información disponible.
Sistema.java

07/06/2022
Algunas pistas sobre la clase Usuario :
✓ Deberá haber un atributo de clase (_total, por ejemplo)
que se inicialice a cero y se incremente cada vez que
se cree un objeto de la clase (en el constructor, claro).
El valor incrementado será el identificador del nuevo Usuario.
✓ El constructor deberá crear los dos contadores.
✓ No tiene sentido que haya métodos mutadores en la clase,
ya que el identificador se asigna automáticamente y los
contadores solamente se incrementan cuando se notifica
un acceso o un fallo.
✓ Habrá un método hasAccedido() que notifica al Usuario que
ha conseguido acceder al sistema.
✓ Habrá un método hasFallado() que notifica al Usuario
que no ha conseguido acceder al sistema.

07/06/2022
Una ayuda: la interfaz de la clase Usuario.
class Usuario {
public Usuario() { ... }
public int idUsuario() { ... }
public Contador accesos() { ... }
public Contador fallidos() { ... }
public void hasAccedido() { ... }
public void hasFallado() { ... }
public void println() { ... }
}

07/06/2022
Otra ayuda: el programa principal.
public class Sistema {
Usuario u1 = new Usuario();
u1.println();
u1.hasAccedido();
u1.hasAccedido();
u1.hasFallado();
u1.println();
Usuario u2 = new Usuario();
u2.hasFallado();
u2.hasFallado();
u2.hasFallado();
u2.println();
}
}

07/06/2022
Ejercicio: mejora de la clase Usuario
Añade en las clases los métodos copia() necesarios
para que se pueda clonar un objeto de la clase Usuario.
Prueba la clonación en el programa principal.
¿Qué problema tiene el programa que has obtenido?
(Investiga si la secuencia de identificadores que se asigna
según se crean objetos es realmente correcta ahora.)
Sistema2.java

07/06/2022
NO a los objetos degenerados
◼ Un objeto contiene datos y operaciones que manipulan los
datos, pero ...
◼ Podemos distinguir dos tipos de objetos degenerados:
◼ Un objeto sin datos (que sería lo mismo que una biblioteca
de funciones). Si los métodos son estáticos, “peor” aún.
◼ Un objeto sin “operaciones”, con sólo atributos lo que
permitiría crear, recuperar, actualizar y borrar su estado
(que se correspondería con las estructuras de datos
tradicionales)
◼ Un sistema construido con objetos degenerados NO es un
sistema verdaderamente orientado a objetos

07/06/2022
Palabra clave final en Java
◼ La palabra clave final en java se usa para restringir al usuario.
◼ La palabra clave final se puede utilizar en muchos contextos. final
puede ser :
➢ variable
➢ method
➢ class
◼ La palabra clave final se puede aplicar con las variables, una variable
final que no tiene valor se llama variable final en blanco o
variable final no inicializada. Solo se puede inicializar en el
constructor.
◼ La variable final en blanco también puede ser estática, que se
inicializará solo en el bloque estático.

07/06/2022
1) variable final
◼ Si hace que cualquier variable sea final, no puede cambiar el valor de
la variable final (será constante).
class Bike{
final int speedLimit=90;
//final variable
void run(){
speedLimit=400;
}
Bike obj=new Bike();
obj.run();
}
}
Output:
Compile Time Error

07/06/2022
2) Método final
◼ Si establece algún método como final, no puede sobrescribirlo.
class Bike{
final void run(){
System.out.println(“Bike Class");
}
}
class Honda extends Bike{
void run(){
System.out.println(“Honda Class");
}
Honda honda= new Honda();
honda.run();
}
}
Output:
Compile Time Error

07/06/2022
3) Clase final
◼ Si haces alguna clase como final, no puedes extenderla.
final class Bike{
}
void run(){
System.out.println(" Honda Class ");
}
Honda honda= new Honda();
honda.run();
}
}
Output:
Compile Time Error

07/06/2022
¿método final heredado?
class Bike{
final void run(){
System.out.println(“Bike Class");
}
}
new Honda().run();
}
}
Nota: El método final se puede heredar pero no se puede sobrescribir.
Output:
Bike Class

07/06/2022
Variable final en blanco o sin inicializar
◼ Una variable final que no se inicializa en el momento de la
declaración se conoce como variable final en blanco.
◼ Si desea crear una variable que se inicialice en el momento de
crear el objeto y que una vez inicializada no se pueda cambiar, es
útil. Por ejemplo número de PAN CARD de un empleado.
◼ Solo se puede inicializar en el constructor.
class Student{
int id;
String name;
final String PAN_CARD_NUMBER;
}

07/06/2022
Inicializar variable final en blanco
class Bike{
final int speedLimit;//blank final variable Bike
(){
speedLimit=70;
System.out.println(speedLimit);
}
new Bike();
}
}
Nota: La variable final en blanco solo se puede
inicializar en el constructor.
Output:
70

07/06/2022
variable final static en blanco
◼ Una variable final estática que no se inicializa en el momento de la
declaración se conoce como variable final estática en blanco.
◼ Solo se puede inicializar en bloque estático
class A{
static final int data;
//static blank final variable
static{
data=50;
}
System.out.println(A.data);
}
} Output:
50

07/06/2022
Parametro final
◼ Si declara algún parámetro como final, no puede cambiar el valor
del mismo.
class Bike{
int cube(final int n){
n=n+2;
//can't be changed as n is final
}
Bike b=new Bike();
b.cube(5);
}
}
Output:
:Compile Time Error

Carrera de Software
102
07/06/2022
Contenido
métodos

07/06/2022
Compatibilidad entre objetos de distintas clases
Todos los alumnos son personas,
pero no todas las personas son alumnos
A un identificador de la clase Persona (superclase)
se le puede asignar un objeto de la clase Alumno (subclase),
pero a un identificador de la clase Alumno (subclase)
no se le puede asignar un objeto de la clase Persona (superclase)
Persona unaPersona;
Alumno unAlumno;
...
unaPersona = unAlumno; // Correcto:
// todos los alumnos son personas
unAlumno = unaPersona; // INCORRECTO:
// no todas las personas son alumnos

07/06/2022
Compatibilidad entre objetos de distintas clases
Regla general de compatibilidad entre objetos:
A un identificador de una clase sólo se le pueden asignar
objetos de esa clase o de cualquiera de sus subclases
Esta compatibilidad resulta muy útil cuando se quieren manejar listas
de objetos: basta declarar un array de objetos de la
superclase y podremos asignar a las distintas posiciones del array
objetos de esa clase y de cualquiera de las subclases.
La lista de Personas puede perfectamente guardar Alumnos.
No hay que cambiar nada. Todo funciona sin cambios.

07/06/2022
¿Qué es polimorfismo?
◼ El polimorfismo indica que una variable pasada
◼ o esperada puede adoptar múltiples formas.
◼ Es la habilidad de una variable de un determinado tipo para hacer
referencia a objetos de diferentes tipos y llamar automáticamente a
los métodos del tipo específico del objeto al que hace referencia.

07/06/2022
Polimorfismo y vinculación dinámica
En la clase Lista está definido el método toString():
String cad = "Elementos de la lista:nn";
for(int i = 0; i < _cont; i++)
cad += _array[i].toString() + "n";
return cad;
}
Si en la lista se guardan tanto Personas como Alumnos,
no podemos saber si cada _array[i] hace referencia
a una Persona o a un Alumno. Y consecuentemente,
no podemos saber si se ejecutará el método toString()
de la clase Persona o el de la clase Alumno.
_array[i] puede tener distintas formas: es polimórfico.
La vinculación entre el mensaje y el método que corresponde
se realiza en tiempo de ejecución: vinculación dinámica.

07/06/2022
Moldes de objetos y el operador instanceof
Si queremos asignar a un identificador de una subclase
el objeto referenciado por un identificador de una de sus superclases,
deberemos utilizar un molde de objeto:
Persona unaPersona;
...
Alumno unAlumno = (Persona) unaPersona;
Para que la asignación se pueda realizar, el objeto referenciado
por unaPersona deberá ser en realidad un objeto Alumno.
La regla de compatibilidad permite que unaPersona haga referencia
a un objeto de clase Persona o a uno de clase Alumno.
Deberemos asegurarnos de que se trate de un objeto Alumno.
El operador instanceof indica si el objeto apuntado por una
referencia es de una determinada clase:
if(unaPersona instanceof Alumno)
unAlumno = (Persona) unaPersona;

07/06/2022
Selección dinámica de método o Enlace Dinámico
◼ Ventajas del enlace dinámico
◼ La sobreescritura de métodos permite a Java admitir el
polimorfismo en tiempo de ejecución.
◼ El polimorfismo es esencial en la Programación Orienta a Objetos
◼ Permite que una clase general especifique métodos
que serán comunes a todas sus clases derivadas,
permitiendo a éstas definir la implementación
específica de alguno de estos métodos.

07/06/2022
Enlace Dinámico
class A
{
void llamame()
{
System.out.println("Llama al metodo "llamame" de la clase A");
}
}
class B extends A
{
void llamame()
{
System.out.println("Llama al metodo "llamame" de la clase B");
}
}

07/06/2022
Enlace Dinámico
class C extends A
{
void llamame()
{
System.out.println("Llama al metodo "llamame" de la clase C");
}
}

07/06/2022
Enlace Dinámico
class SeleccionDinamica
{
public static void main(String args[])
{
A a = new A();
B b = new B();
C c = new C();
A r;
//Polimorfismo y enlace dinámico
r = a;
r.llamame();
r = b;
r.llamame();
r = c;
r.llamame();
}
}

07/06/2022
Enlace Dinámico

Carrera de Software
116
07/06/2022
Contenido
métodos

07/06/2022
Colecciones
Manejo de grupos de datos → colecciones
Máquinas de datos que permiten almacenar, recuperar y
manipular elementos de datos.
Organización de las colecciones
Interfaces → Manipulan los datos independientemente de
los detalles de implementación.
Clases → Implementan las interfaces.
¿Cómo se trabaja con las colecciones?
Se elige una interfaz para la funcionalidad deseada.
Se elige una clase que implemente la interfaz con la eficiencia
deseada o alguna otra característica particular.
Se adapta (extiende) si es necesario.
Las interfaces permiten cambiar de implementación sin modificar
el código que hace uso de la interfaz.

07/06/2022
La arquitectura de colecciones de Java
Como las interfaces y las clases están relacionadas y colaboran
entre sí, se habla del armazón (framework) de colecciones, una
arquitectura completa para facilitar el uso de colecciones.
✓ Interfaces de colecciones: diferentes tipos de colecciones
en general, en abstracto.
✓ Implementaciones de propósito general: clases que
implementan las interfaces.
✓ Implementaciones abstractas: implementaciones parciales
de las interfaces.
✓ Algoritmos: métodos estáticos que realizan tareas útiles
sobre las colecciones, tal como ordenar una lista.
✓ Infraestructura: interfaces de soporte para las colecciones.

07/06/2022
Interfaces de colecciones
Interfaces para manejar colecciones de datos:
Collection Map
Set List SortedMap
SortedSet
Map y SortedMap, aunque están relacionadas, en realidad
no representan colecciones, sino correspondencias. Se explican
también porque se manejan como las colecciones.
Algunas implementaciones pueden imponer restricciones en
los elementos que se pueden incluir, estableciendo que sean
de un determinado tipo o que no sean null, por ejemplo.
Si se intenta saltar la restricción se elevará una excepción.
Implementaciones abstractas: AbstractCollection,
AbstractSet, AbstractList, AbstractMap, etcétera.

07/06/2022
Terminología
✓ Colección inmodificable: que no soporta operaciones
de modificación (add o remove, por ejemplo).
✓ Colección modificable: que no es inmodificable.
✓ Colección inmutable: que, además de inmodificable,
garantiza que no se percibirá ningún cambio en la colección.
✓ Colección mutable: que no es inmutable.
✓ Lista de tamaño fijo: aquella en la que el número
de elementos permanece invariable.
✓ Lista de tamaño variable: que no es de tamaño fijo.
✓ Lista de acceso aleatorio (o acceso directo): que permite
accesos indexados rápidos a los elementos.
✓ Lista de acceso secuencial: que no es de acceso aleatorio.

07/06/2022
Interfaces de colecciones java.util
✓ Collection
Representa un grupo de objetos. Sin implementaciones
directas, agrupa la funcionalidad general que todas las
colecciones ofrecen.
✓ Set
Colección que no puede tener objetos duplicados.
✓ SortedSet
Set que mantiene los elementos ordenados.
✓ List
Colección ordenada que puede tener objetos duplicados.
✓ Map
Colección que mapea claves y valores; no puede tener claves
duplicadas y cada clave debe tener al menos un valor.
✓ SortedMap
Map que mantiene las claves ordenadas.

07/06/2022
La interfaz Collection
add(Object): añade el objeto en la colección (opcional).
addAll(Collection): añade la colección (opcional).
clear(): quita todos los elementos de la colección (opcional).
contains(Object): ¿el objeto se encuentra en la colección?
conatinsAll(Collection): ¿todos esos elementos están?
equals(Object): ¿es igual esta colección y la proporcionada?
isEmpty(): ¿la colección está vacía?
Iterator iterator(): devuelve un iterador para la colección.
remove(Object): elimina una aparición del objeto (opcional).
removeAll(Collection): elimina todos esos objetos (opcional).
retainAll(Collection): se queda sólo con esos objetos (opcional).
size(): número de elementos en la colección
toArray(): devuelve un array con los objetos de la colección.

07/06/2022
La interfaz List
Colecciones ordenadas (secuencias) en las que cada elemento
ocupa una posición identificada por un índice. El primer índice
es el 0. Las listas admiten duplicados.
add(int, Object): añade el objeto en la posición indicada (opcional).
add(Object): añade el objeto al final de la lista (opcional).
addAll(int, Collection): añade la colección en la posición (opcional).
addAll(Collection): añade la colección al final (opcional).
clear(): quita todos los elementos de la lista (opcional).
contains(Object): ¿el objeto se encuentra en la lista?
get(int): devuelve el objeto en la posición.
indexOf(Object): devuelve la 1ª posición en la que está el objeto (o –1).
isEmpty(): ¿la lista está vacía? . . .

07/06/2022
La interfaz List
Iterator iterator(): devuelve un iterador para la colección.
lastIndexOf(Object): devuelve la última posición del objeto (o –1).
ListIterator listIterator(): devuelve un iterador de lista.
listIterator(int): devuelve un iterador de lista para la sublista.
remove(int): quita de la lista el objeto en esa posición (opcional).
remove(Object): elimina la primera aparición del objeto (opcional).
removeAll(Collection): elimina todos esos objetos (opcional).
retainAll(Collection): se queda sólo con esos objetos (opcional).
set(int, Object): reemplaza el objeto en esa posición por el objeto
que se proporciona (opcional).
size(): número de elementos en la colección
subList(int, int): devuelve la sublista que comienza en el índice que
se proporciona en primer lugar y termina en el elemento anterior al del
índice que se proporciona en segundo lugar.
toArray(): devuelve un array con los objetos de la colección.

07/06/2022
La interfaz Map
Pares (clave, valor). No puede haber claves duplicadas
y cada clave se corresponde con al menos un valor.
clear(): quita todos los pares del mapa (opcional).
containsKey(Object): ¿la clave proporcionada se encuentra en el mapa?
containsValue(Object): ¿hay algún par con el valor proporcionado?
equals(Object): ¿es igual este mapa y el proporcionado?
get(Object): devuelve el objeto que se corresponde con la clave dada.
isEmpty(): ¿la lista está vacía?
put(Object clave, Object valor): asocia la clave proporcionada con
el valor proporcionado (opcional).
putAll(Map): incluye los pares de ese mapa (opcional).
remove(Object): quita la clave del mapa, junto con sus correspondencias
(opcional).
size(): devuelve el número de pares que hay en el mapa.
. . .

07/06/2022
Implementaciones de propósito general java.util
Tablas hash:
✓ HashSet: implementa la interfaz Set.
✓ HashMap: implementa la interfaz Map.
Arrays de tamaño variable:
✓ Vector: implementa la interfaz List.
✓ Stack: implementa la interfaz List.
✓ ArrayList: implementa la interfaz List.
Árboles equilibrados:
✓ TreeSet: implementa la interfaz Set.
✓ TreeMap: implementa la interfaz Map.
Listas enlazadas:
✓ LinkedList: implementa la interfaz List.

07/06/2022
Implementaciones de propósito general

07/06/2022
La clase Vector
Vectores de objetos que pueden
aumentar o disminuir de tamaño
según se necesite.
Son como arrays sin posiciones
libres entre medias.
La creación de un vector se
realiza de la forma habitual:
Vector v = new Vector();
El índice de la primera posición
del vector es el 0.

07/06/2022
La clase Vector
add(int, Object): inserta el objeto en la posición indicada.
add(Object) o addElement(Object): añade el objeto al final del vector.
addAll(int, Collection): añade la colección en la posición indicada.
addAll(Collection): añade los elementos de la colección al final,
en el orden que especifique el iterador de la colección.
capacity(): devuelve el tamaño actual del vector.
clear() o removeAllElements(): quita todos los elementos del vector.
clone(): devuelve un clon del vector.
contains(Object): ¿el objeto se encuentra en el vector?
firstElement(): devuelve el primer elemento del vector (posición 0).
get(int) o elementAt(int): devuelve el objeto en la posición indicada.
. . .

07/06/2022
La clase Vector
indexOf(Object): devuelve la 1ª ocurrencia del objeto (o –1). Se usa el
método equals() de la clase del objeto para encontrarlo.
indexOf(Object, int): busca el objeto desde la posición indicada.
insertElementAt(Object, int): inserta el objeto en la posición dada.
isEmpty(): ¿el vector está vacío?
lastElement(): devuelve el último elemento del vector.
lastIndexOf(Object): devuelve la última ocurrencia del objeto (o –1).
Se usa el método equals() de la clase del objeto para encontrarlo.
lastIndexOf(Object, int): busca la última ocurrencia del objeto
desde la posición indicada y hacia el principio del vector.
remove(int) o removeElementAt(int):quita el objeto en esa posición.
remove(Object): elimina la primera aparición del objeto.
removeAll(Collection): elimina todos esos objetos.
. . .

07/06/2022
La clase Vector
removeRange(int, int): quita los elementos desde el índice que se
proporciona en primer lugar hasta el elemento anterior al otro índice.
retainAll(Collection): se queda sólo con esos objetos.
set(int, Object) o setElementAt(Object, int): reemplaza el objeto
en esa posición por el objeto que se proporciona.
setSize(int): establece el tamaño del vector.
size(): número de elementos en el vector.
subList(int, int): devuelve el subvector que comienza en el índice
que se proporciona en primer lugar y termina en el elemento anterior
al del índice que se proporciona en segundo lugar.
toArray(): devuelve un array con los objetos del vector.
toString()
trimToSize(): ajusta el tamaño del vector a su número de elementos.

07/06/2022
Ejemplo de uso de la clase Vector
// Vectores.java: prueba de la clase Vector
import java.util.Vector;
public class Vectores {
Vector v = new Vector();
Persona p = new Persona(223344, 32, "Juan", "Pardo Gil");
v.add(p);
Alumno a = new Alumno(11133322, 21, "Rosa", "Garrido
Aguado", 2, p);
v.add(a);
v.add(p);
muestra(v);
int posicion = v.indexOf(p);
System.out.println("El siguiente objeto:");
System.out.print(p);
System.out.println("... se encuentra en la posición "
+ posicion + " del vector.");
. . .

07/06/2022
posicion = v.lastIndexOf(p);
p = new Persona(7654321, 28, "Ana", "Martos Hevia");
posicion = v.indexOf(p);
v.add(p);
Vector otro = (Vector) v.clone();
muestra(otro);
v.clear();
muestra(v);
otro.remove(2);
muestra(otro);
otro.set(0, p);
muestra(otro);
System.out.println(otro);
} . . .
toString()

07/06/2022
public static void muestra(Vector vector) {
Persona per;
System.out.println("==================================");
System.out.println();
if(vector.isEmpty()) {
System.out.println("Vector vacío");
}
else
for(int i = 0; i < vector.size(); i++) {
per = (Persona) vector.get(i);
System.out.println(per);
}
}
}

07/06/2022
La clase ArrayList
Similar a la clase Vector.
Más moderna.
La clase Vector tiene
mayor funcionalidad,
aunque algunos de
sus métodos
son redundantes.

07/06/2022
La clase ArrayList
add(int, Object): inserta el objeto en la posición indicada.
add(Object): añade el objeto al final de la lista.
addAll(int, Collection): añade la colección en la posición indicada.
addAll(Collection): añade los elementos de la colección al final,
en el orden que especifique el iterador de la colección.
clear(): quita todos los elementos de la lista.
clone(): devuelve un clon de la lista.
contains(Object): ¿el objeto se encuentra en la lista?
get(int): devuelve el objeto en la posición indicada.
indexOf(Object): devuelve la 1ª ocurrencia del objeto (o –1). Se usa el
método equals() de la clase del objeto para encontrarlo.
isEmpty(): ¿la lista está vacía?
lastIndexOf(Object): devuelve la última ocurrencia del objeto (o –1).
Se usa el método equals() de la clase del objeto para encontrarlo.
. . .

07/06/2022
La clase ArrayList
remove(int): quita el objeto en esa posición.
removeRange(int, int): quita los elementos desde el índice que se
proporciona en primer lugar hasta el elemento anterior al otro índice.
set(int, Object): reemplaza el objeto en esa posición por el objeto que
se proporciona.
size(): número de elementos en la lista.
toArray(): devuelve un array con los objetos de la lista.
trimToSize(): ajusta el tamaño de la lista a su número de elementos.

07/06/2022
Ejemplo de uso de la clase ArrayList
// Listas.java: prueba de la clase ArrayList
import java.util.ArrayList;
public class Listas {
ArrayList lista = new ArrayList();
Persona p = new Persona(223344, 32, "Juan", "Pardo Gil");
lista.add(p);
Alumno a = new Alumno(11133322, 21, "Rosa", "Garrido
Aguado", 2, p);
lista.add(a);
lista.add(p);
muestra(lista);
int posicion = lista.indexOf(p);
System.out.println("... se encuentra en la posicion "
+ posicion + " de la lista.");
. . .
Prácticamente basta con
reemplazar Vector por ArrayList

07/06/2022
posicion = lista.lastIndexOf(p);
p = new Persona(7654321, 28, "Ana", "Martos Hevia");
posicion = lista.indexOf(p);
lista.add(p);
ArrayList otra = (ArrayList) lista.clone();
muestra(otra);
lista.clear();
muestra(lista);
otra.remove(2);
muestra(otra);
otra.set(0, p);
muestra(otra);
System.out.println(otra);
} . . .

07/06/2022
public static void muestra(ArrayList l) {
Persona per;
if(l.isEmpty()) {
System.out.println("Lista vacía");
}
else
for(int i = 0; i < l.size(); i++) {
per = (Persona) l.get(i);
System.out.println(per);
}
}
}

07/06/2022
Otro ejemplo
// Cuenta.java
public class Cuenta {
private long numero;
private String nombre;
private double saldo;
public Cuenta (long num, String prop, double saldo) {
numero = num;
nombre = prop;
this.saldo = saldo;
}
public long numero() { return numero; }
void imprimeCuenta() {
System.out.println(numero + " " + nombre + " " + saldo);
}
}

07/06/2022
Otro ejemplo
// Banco.java
import java.util.ArrayList;
public class Banco {
private ArrayList listaCuentas;
public Banco() {
listaCuentas = new ArrayList();
}
public void crearCuenta(){
System.out.println("Introduce el número de cuenta: ");
long c = MyInput.readLong();
System.out.println("Introduce el propietario: ");
String n = MyInput.readString();
System.out.println("Introduce el saldo inicial: ");
double s = MyInput.readDouble();
listaCuentas.add(new Cuenta(c, n, s));
}
. . .

07/06/2022
Otro ejemplo
public void mostrarCuentas() {
for(int i = 0; i < listaCuentas.size(); i++) {
Cuenta c = (Cuenta) listaCuentas.get(i);
c.imprimeCuenta();
}
}
public void borrarCuenta() {
System.out.println("Introduce el código de la cuenta a
borrar: ");
long c = MyInput.readLong();
for(int i = 0; i < listaCuentas.size(); i++) {
Cuenta cuenta = (Cuenta) listaCuentas.get(i);
if(c == cuenta.numero()) {
listaCuentas.remove(i);
System.out.println("Cuenta borrada.");
return;
}
}
System.out.println("No existe esa cuenta.");
}
. . .

07/06/2022
Otro ejemplo
Banco b = new Banco();
do {
System.out.println("1.Crear 2.Mostrar 3.Borrar
4.Salir");
System.out.println(">>");
int opcion = MyInput.readInt();
switch(opcion) {
case 1 : b.crearCuenta();; break;
case 2 : b.mostrarCuentas(); break;
case 3 : b.borrarCuenta();break;
case 4 : System.exit(0);
default : System.out.println("Orden desconocida.");
}
} while(true);
}
}

07/06/2022
Tipos primitivos y la clase ArrayList
Los elementos de los ArrayList son objetos (Object).
Los enteros, por ejemplo, no son objetos.
Por tanto, un int no se puede insertar en un ArrayList.
¿Qué hacemos entonces? Utilizar la clase envoltorio Integer.
ArrayList lista = new ArrayList();
int unInt = 42;
lista.add(new Integer(unInt));
...
Integer n;
n = (Integer)lista.get(0);
int miEntero = n.intValue();
Otras clases envoltorios son Byte, Float, Double, Long y Short.

07/06/2022
La interfaz Iterator
Los iteradores permiten recorrer colecciones sin preocuparse de
la implementación subyacente.
hasNext(): ¿hay un elemento siguiente?
next(): devuelve el siguiente elemento de la colección.
remove(): elimina el último elemento devuelto por el iterador.
public void imprime(Collection col){
Iterator it = col.iterator();
while(it.hasNext())
System.out.println(it.next());
}

07/06/2022
Ejemplo de iterador sobre Vector
public class Basedatos {
private Vector vectorPersonas;
public Basedatos() { // Constructor
vectorPersonas = new Vector ();
}
//Añade una persona a la base de datos.
public void aniadePersona(Persona p) {
vectorPersonas.addElement(p);
}
// Muestra las personas de la base de datos.
public void listaTodo () {
for (Iterator it = vectorPersonas.iterator();
it.hasNext();) {
System.out.println(it.next());
}
}
}

07/06/2022
Iteradores sobre distintos tipos de colecciones
import java.util.*;
public class PruebaColecciones{
public static void prueba(Collection c) {
String[] lista = {"uno", "dos" , "tres", "cuatro", "tres"};
for(int i = 0; i < lista.length; i++ )
c.add( lista[i] );
Iterator it = c.iterator();
while(it.hasNext())
System.out.println( it.next() );
System.out.println( "-------------------------");
}
Collection c;
c = new ArrayList(); prueba(c);
c = new LinkedList(); prueba(c);
c = new HashSet(); prueba(c);
c = new TreeSet(); prueba(c);
}
}
Mismo código de iteración
Las cuatro veces

07/06/2022
La interfaz ListIterator
Iteradores más potentes para implementaciones de List.
add(Object): inserta en la posición actual el elemento proporcionado.
hasNext(): ¿hay un elemento siguiente yendo hacia el final de la lista?
hasPrevious(): ¿hay un elemento anterior yendo hacia el principio?
next(): devuelve el siguiente elemento de la lista.
nextIndex(): devuelve el índice del siguiente elemento de la lista.
previous(): devuelve el elemento anterior de la lista.
previousIndex(): devuelve el índice del elemento anterior de la lista.
remove(): elimina el último elemento devuelto por next() o previous().
set(Object): reemplaza el último elemento devuelto por next() o
previous().

07/06/2022
HashMap - Colección
◼ HashMap es una colección que almacena objetos sin orden específico.
◼ Un HashMap no puede contener claves duplicadas.
◼ Si se almacena con una clave duplicada no lo agrega a la colección
HashMap, y no presenta error.
◼ Java HashMap permite valores null y clave null.
◼ Para crear un objeto HashMap se realiza lo siguiente:
◼ HashMap<clave, valor> lista=new HashMap<>();
◼ La clave y el valor son clases, la clave no puede duplicarse.

07/06/2022
HashMap - Métodos
◼ void get(K clave) Devuelve el objeto que posee la clave indicada
◼ void put(Object clave, V valor) Coloca el par clave-valor en el
mapa (asociando la clave a dicho valor). Si la clave ya existiera,
sobrescribe el anterior valor y devuelve el objeto antiguo. Si esa clave
no aparecía en la lista, devuelve null
◼ void remove(Object clave) Elimina de la lista el valor asociado
a esa clave. Devuelve el valor que tuviera asociado esa clave o null si
esa clave no existe en el mapa.
◼ boolean containsKey(Object clave) Indica si el mapa posee la
clave señalada
◼ boolean containsValue(Object valor) Indica si el mapa posee el valor
señalado
◼ boolean equals(Object valor) Verifica si un objeto se encuentra o no
en el mapa

07/06/2022
HashMap - Interface
◼ void putAll( Map mapa) Añade todo el mapa indicado, al mapa actual
◼ Set keySet() Obtiene un objeto Set creado a partir de las claves del
mapa
◼ Collection values() Obtiene la colección de valores del mapa,
permite utilizar el HashMap como si fuera una lista normal al estilo de
la clase Collection (por lo tanto se permite recorrer cada
elemento de la lista con un iterador)
◼ int size() Devuelve el número de pares clave-valor del mapa
◼ Set<Mapa, Entry<K,V> entrySet() Devuelve una lista formada por
objetos Map.Entry
◼ void clear() Elimina todos los objetos del mapa

07/06/2022
HashMap – Ejercicio

Carrera de Software
154
07/06/2022
Contenido
métodos

07/06/2022
Excepciones
Las excepciones son la manera que ofrece Java de manejar
los errores en tiempo de ejecución.
Muchos lenguajes imperativos simplemente detienen la ejecución
de programa cuando surge un error.
Las excepciones nos permiten escribir código que nos permita
manejar el error y continuar (si lo estimamos conveniente)
con la ejecución del programa.
El error de ejecución más clásico en Java es el de
desbordamiento, el intento de acceso a una posición de
un vector que no existe. Veamos un ejemplo...

07/06/2022
Excepciones
public class Desbordamiento {
String mensajes[] = {"Primero","Segundo","Tercero" };
for(int i = 0; i <= 3; i++)
System.out.println(mensajes[i]);
}
}
Este programa tendrá un serio problema cuando intente acceder
a mensajes[3], pues no existe dicho valor.
Al ejecutarlo mostrará lo siguiente:
Primero Segundo Tercero Exception in thread "main"
java.lang.ArrayIndexOutOfBoundsException at
Desbordamiento.main(Desbordamiento.java, Compiled Code)

07/06/2022
Jerarquía de excepciones
Throwable
Error Exception
RuntimeException IOException

07/06/2022
Clases de excepciones
Throwable
Superclase que engloba a todas las excepciones
Error
Representa los errores graves causados por el sistema (JVM, ...);
no son tratados por los programas.
Exception
Define las excepciones que los programas deberían tratar
(IOException, ArithmeticException, etcétera).

07/06/2022
try ... catch ... finally
El ejemplo del desbordamiento detecta un error de ejecución
(lanza una excepción) al intentar acceder a la posición inexistente.
Cuando se detecta el error, por defecto se interrumpe la ejecución.
Pero podemos evitarlo.
La estructura try-catch-finally nos permitirá capturar
excepciones, es decir, reaccionar a un error de ejecución.
De este modo podremos imprimir mensajes de error "a la medida"
y continuar con la ejecución del programa si consideramos que el
error no es demasiado grave.
Para ver cómo funcionan vamos a modificar el ejemplo anterior,
pero asegurándonos ahora de que capturamos las excepciones.

07/06/2022
try ... catch
try {
// Código que puede hacer que se eleve la excepción
}
catch(TipoExcepcion e) {
// Gestor de la excepción
}
El comportamiento de Java es el siguiente:
Si en la ejecución del código dentro del bloque try se eleva
una excepción de tipo TipoExcepcion (o descendiente de éste),
Java omite la ejecución del resto del código en el bloque try y
ejecuta el código situado en el bloque catch (gestor).

07/06/2022
public class EjemploCatch {
String mensajes[] = {"Primero", "Segundo", "Tercero" };
try {
for(int i = 0; i <= 3; i++)
System.out.println(mensajes[i]);
}
catch ( ArrayIndexOutOfBoundsException e ) {
System.out.println("El asunto se nos ha desbordado");
}
finally {
System.out.println("Ha finalizado la ejecución");
}
}
}
Dentro del bloque de la sección try colocamos el código normal.
Después de la sección try debemos colocar al menos una sección
catch o una finally, pudiendo tener ambos e incluso más de una
sección catch.

07/06/2022
try
El bloque de código donde se prevé que se eleve una excepción.
Al encerrar el código en un bloque try es como si dijéramos:
"Prueba a usar estas instrucciones y mira a ver si se produce
alguna excepción". El bloque try tiene que ir seguido, al menos,
por una cláusula catch o una cláusula finally.
catch
El código que se ejecuta cuando se eleva la excepción. Controla
cualquier excepción que cuadre con su argumento. Se pueden
colocar varios catch sucesivos, cada uno controlando un tipo
de excepción diferente.
finally
Bloque que se ejecuta siempre, haya o no excepción. Existe
cierta controversia sobre su utilidad, pero podría servir, por
ejemplo, para hacer un seguimiento de lo que está pasando,
ya que al ejecutarse siempre puede dejar grabado un registro
(log) de las excepciones ocurridas y su recuperación o no.

07/06/2022
La clase Exception
Cuando se eleva una excepción, lo que se hace es activar un
ejemplar de Exception o de alguna de sus subclases.
Normalmente las clases derivadas nos permiten distinguir
entre los distintos tipos de excepciones.
En el programa anterior, por ejemplo, en el bloque catch se
captura una excepción del tipo ArrayIndexOutOfBoundsException,
ignorando cualquier otro tipo de excepción.
Esta clase tiene dos constructores y dos métodos destacables:
Exception(): crea una excepción si ningún mensaje específico.
Exception(String): crea una excepción con un mensaje que
detalla el tipo de excepción.
String getMessage(): el mensaje detallado, si existe (o null).
void printStackTrace(): muestra una traza que permite ver
donde se generó el error (muy útil para depurar).

07/06/2022
Excepciones predefinidas

07/06/2022
Captura de excepciones
A catch le sigue, entre paréntesis, la declaración de una
excepción. Es decir, el nombre de una clase derivada de
Exception (o la propia Exception) seguido del nombre de
una variable. Si se lanza una excepción que es la que deseamos
capturar (o una derivada de la misma) se ejecutará el código
que contiene el bloque. Así, por ejemplo:
catch(Exception e) { ... }
se ejecutará siempre que se produzca una excepción del tipo
que sea, ya que todas las excepciones se derivan de Exception.
No es recomendable utilizar algo así, ya que estaremos
capturando cualquier tipo de excepción sin saber si eso afectará
a la ejecución del programa o no.

07/06/2022
Captura de excepciones
Se pueden colocar varios bloques catch. Si es así, se comprobará,
en el mismo orden en que se encuentren esos bloques catch,
si la excepción elevada es la que se trata en el bloque catch;
si no, se pasa a comprobar el siguiente.
Eso sí, sólo se ejecuta un bloque catch. En cuanto se captura
la excepción se deja de comprobar el resto de los bloques.
Por esto, lo siguiente:
catch(Exception e) {
...
}
catch(DerivadaDeException e) {
...
}
no sería correcto, ya que el segundo catch no se ejecutará nunca.

07/06/2022
Ejemplo: Sin try-catch
public class Excepcion1 {
public static void main(String args[ ]){
int a = args.length;
System.out.println("a = " + a);
int b = 42 / a;
}
}
a = 0
java.lang.ArithmeticException: / by zero
at Excepcion1.main(Excepcion1.java:6)
Exception in thread "main" Process Exit...
Se produce el error
y se interrumpe ...

07/06/2022
Ejemplo: Con try-catch
public static void main(String args[ ]){
try {
int a = args.length;
System.out.println("a = " + a);
int b = 42 / a;
}
catch (ArithmeticException e) {
System.out.println("No dividas por 0 (" + e + ")");
}
System.out.println("La ejecución sigue ...");
}
}
a = 0
No dividas por 0 (java.lang.ArithmeticException: / by zero)
La ejecución sigue ...
Se produce el error
Se captura la excepción
Y sigue la ejecución fuera

07/06/2022
Lanzamiento de excepciones explícito
Los métodos en los que se puede producir un error deben avisar
al compilador de que éste se puede producir. Para ello utilizan
la cláusula throws.
Por ejemplo, un método de lectura de un archivo podría elevar
una excepción de tipo IOException:
public String leer(FileInputStream archivo) throws IOException
{
// ...
Se pueden elevar varias excepciones en un mismo método:
public Image cargar(String s) throws EOFException,
MalformedURLException
{
// ...

07/06/2022
Lanzamiento de excepciones explícito
Las excepciones se lanzan con la instrucción throw.
Por ejemplo, cuando estamos implementando un método que
efectúa una lectura de un archivo de datos, y se llega
inesperadamente a su final, podemos lanzar una EOFException:
public String leerDatos(DataInput archivo)
throws EOFException {
// ...
while( /* ... */ ) {
if(ch == -1) { // Fin de archivo
if(n < longitud)
throw new EOFException();
}
}
return s;
}

07/06/2022
Excepciones a medida
El programador puede crear sus propias excepciones, si resulta
que ninguna de las predefinidas es adecuada. Para ello, se define
una clase que desciende de Exception (o de la clase deseada).
Se suele agregar un constructor con el mensaje de la excepción,
que se inicializa en el constructor llamando al de la clase padre.
Además, toda excepción tiene un método getMessage() que
devuelve un String con el mensaje.
// Define una clase de excepción propia
public class MiExcepcion extends Exception {
public MiExcepcion(){
super("error malísimo...");
}
}

07/06/2022
Excepciones a medida
public class MiExcepcion extends Exception {. . .}
public class UnaClase {
public void metodo() throws MiExcepcion {
System.out.println("Lanzo mi excepción desde aquí.");
throw new MiExcepcion();
}
}
UnaClase c = new UnaClase();
try { c.metodo(); }
// Invoco al método que eleva la excepción
catch(MiExcepcion e) {
System.out.println("La pillé! " + e);
}
System.out.println("... y sigo.");
}
} Lanzo mi excepción desde aquí.
La pillé! MiExcepcion: error malísimo...
... y sigo.

07/06/2022
class Limites extends Exception {}
class demasiadoCalor extends Limites {}
class demasiadoFrio extends Limites {}
class demasiadoRapido extends Limites {}
class demasiadoCansado extends Limites {}
. . .
try {
if(temp > 40 ) throw new demasiadoCalor();
if(dormir < 8 ) throw new demasiado Cansado();
}
catch(Limites lim) {
if(lim instanceof demasiadoCalor ) {
System.out.println("Capturada excesivo calor!");
return;
}
if( lim instanceof demasiadoCansado ) {
System.out.println("Capturada excesivo cansancio!");
return;
}
}
finally System.out.println("En la cláusula finally" ); ...
Un ejemplo

07/06/2022
class NoHayDineroException extends Exception {
private int dinero;
public NoHayDineroException(int n) {
super();
dinero = n;
}
public int getDinero() { return dinero; }
}
class Cuenta {
private int saldo;
public Cuenta() { saldo = 0; }
public Cuenta(int n) { saldo = n; }
public void meterDinero(int n) { saldo += n; }
public void sacarDinero(int n) throws NoHayDineroException {
if(saldo > n) saldo -= n;
else throw new NoHayDineroException(n - saldo);
}
}
Otro ejemplo

07/06/2022
class Test {
public static void main(String a[]) {
Cuenta c = new Cuenta(5000);
try {
c.sacarDinero(60000);
}
catch(NoHayDineroException e) {
System.out.println("Te has pasado en " + e.getDinero());
}
}
}
Otro ejemplo

Carrera de Software
176
07/06/2022
Programación Orientada a
Objetos
Unidad 2
Final de la unidad

POO Unidad 2: Programación Orientada a Objetos

Más contenido relacionado

La actualidad más candente

Similar a POO Unidad 2: Programación Orientada a Objetos

Más de Franklin Parrales Bravo

POO Unidad 2: Programación Orientada a Objetos