Objetivo: Desarrollar proyectos que resuelvan problemas sencillos de la realidad utilizando el modelamiento orientado a objetos y manejando adecuadamente las posibles excepciones a generarse.
1. 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
2. Programación Orientada a Objetos
Ph.D. Franklin Parrales
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.
3. Programación Orientada a Objetos
Ph.D. Franklin Parrales
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
4. 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 { . . . }
...
5. Ph.D. Franklin Parrales 4
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
6. Ph.D. Franklin Parrales 5
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
7. Ph.D. Franklin Parrales 6
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
8. Ph.D. Franklin Parrales 7
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
9. Ph.D. Franklin Parrales 8
07/06/2022
Programación Orientada a Objetos Carrera de Software
Paquetes
10. Ph.D. Franklin Parrales 9
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
11. Ph.D. Franklin Parrales 10
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
12. Ph.D. Franklin Parrales 11
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
13. Programación Orientada a Objetos
Ph.D. Franklin Parrales
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?
14. Programación Orientada a Objetos
Ph.D. Franklin Parrales
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 ?
15. Programación Orientada a Objetos
Ph.D. Franklin Parrales
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
16. Programación Orientada a Objetos
Ph.D. Franklin Parrales
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"
17. Ph.D. Franklin Parrales 16
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
18. Ph.D. Franklin Parrales 17
07/06/2022
Programación Orientada a Objetos Carrera de Software
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).
19. Programación Orientada a Objetos
Ph.D. Franklin Parrales
Carrera de Software
18
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
20. Ph.D. Franklin Parrales 19
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
21. Ph.D. Franklin Parrales 20
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
22. Ph.D. Franklin Parrales 21
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
23. Ph.D. Franklin Parrales 22
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
24. Ph.D. Franklin Parrales 23
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
25. Ph.D. Franklin Parrales 24
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
26. Programación Orientada a Objetos
Ph.D. Franklin Parrales
Carrera de Software
25
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
27. Programación Orientada a Objetos Carrera de Software
Ph.D. Franklin Parrales 26
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.
28. Programación Orientada a Objetos Carrera de Software
Ph.D. Franklin Parrales 27
07/06/2022
Métodos: sobrecarga
✓ Los métodos se pueden sobrecargar: varios métodos con igual
nombre pero diferente signatura.
public class X {
public static void main(String[] args){
...
}
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
29. Programación Orientada a Objetos
Ph.D. Franklin Parrales
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.
30. Programación Orientada a Objetos Carrera de Software
Ph.D. Franklin Parrales 29
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
31. Programación Orientada a Objetos Carrera de Software
Ph.D. Franklin Parrales 30
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[]){
Calculation obj=new Calculation();
obj.sum(10.5,10.5);
obj.sum(20,20);
}
}
Output:
21.0
40
32. Programación Orientada a Objetos Carrera de Software
Ph.D. Franklin Parrales 31
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) {
System.out.println(a+b); }
double sum(int a,int b) {
System.out.println(a+b); }
public static void main(String args[]){
Calculation obj=new Calculation();
int result=obj.sum(20,20);
//Compile Time Error
/* Here how can java determine which sum() method should be called */
}
}
33. Programación Orientada a Objetos Carrera de Software
Ph.D. Franklin Parrales 32
07/06/2022
¿Podemos sobrecargar el método main()?
class Simple{
public static void main(int a){
System.out.println(a);
}
public static void main(String args[]){
System.out.println("main()method invoked");
main(5);
}
}
Output:
main() method invoked
5
34. Programación Orientada a Objetos
Ph.D. Franklin Parrales
Carrera de Software
33
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
35. Ph.D. Franklin Parrales 34
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
36. Ph.D. Franklin Parrales 35
07/06/2022
Programación Orientada a Objetos Carrera de Software
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).
37. Ph.D. Franklin Parrales 36
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
38. Ph.D. Franklin Parrales 37
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
39. Ph.D. Franklin Parrales 38
07/06/2022
Programación Orientada a Objetos Carrera de Software
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 {
...
}
40. Ph.D. Franklin Parrales 39
07/06/2022
Programación Orientada a Objetos Carrera de Software
Herencia: una subclase Alumno
public class Alumno extends Persona {
...
}
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.
41. Ph.D. Franklin Parrales 40
07/06/2022
Programación Orientada a Objetos Carrera de Software
Herencia: una subclase Alumno
public class Alumno extends Persona {
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.
42. Ph.D. Franklin Parrales 41
07/06/2022
Programación Orientada a Objetos Carrera de Software
Herencia: una subclase Alumno
public class Alumno extends Persona {
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 int dameCurso() { return curso; }
public void ponCurso(int curso) { this.curso=curso; }
}
43. Ph.D. Franklin Parrales 42
07/06/2022
Programación Orientada a Objetos Carrera de Software
Herencia: una subclase Alumno
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";
}
44. Ph.D. Franklin Parrales 43
07/06/2022
Programación Orientada a Objetos Carrera de Software
Herencia: una subclase Alumno
public class Alumno extends Persona {
private int curso;
public Alumno() {
super();
curso = 1;
}
public Alumno(long dni, int edad, String nombre,
String apellidos, int curso) {
super(dni, edad, nombre, apellidos);
this.curso = curso;
}
public int dameCurso() { return curso; }
public void ponCurso(int curso) { this.curso = curso; }
public String toString() {
return super.toString() + "Curso: " + curso + "n";
}
public void leer() {
super.leer();
System.out.print("Curso: ");
curso = MyInput.readInt();
}
} Alumno.java
45. Ph.D. Franklin Parrales 44
07/06/2022
Programación Orientada a Objetos Carrera de Software
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) {
super(dni, edad, nombre, apellidos);
this.curso = curso;
this.profesor = profesor;
}
public Alumno2(long dni, int edad, String nombre,
String apellidos, int curso) {
super(dni, edad, nombre, apellidos);
this.curso = curso;
this.profesor = null;
}
. . .
Persona
Alumno2
1
46. Ph.D. Franklin Parrales 45
07/06/2022
Programación Orientada a Objetos Carrera de Software
Subclase Alumno2 con atributo de clase Persona
public int dameCurso() { return curso; }
public Persona dameProfesor() { return profesor; }
public void ponCurso(int curso) { this.curso = curso; }
public void ponProfesor(Persona profesor)
{ this.profesor = profesor; }
public String toString() {
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
47. Ph.D. Franklin Parrales 46
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
48. Ph.D. Franklin Parrales 47
07/06/2022
Programación Orientada a Objetos Carrera de Software
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).
49. Ph.D. Franklin Parrales 48
07/06/2022
Programación Orientada a Objetos Carrera de Software
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{
public static void main(String args[]){
Dog d = new Dog();
d.move();
//Runs the method in Dog class
} }
Output:
Dogs can run
50. Ph.D. Franklin Parrales 49
07/06/2022
Programación Orientada a Objetos Carrera de Software
Otro Ejemplo
51. Ph.D. Franklin Parrales 50
07/06/2022
Programación Orientada a Objetos Carrera de Software
Otro Ejemplo
class Bank{
int getRateOfInterest(){
return 0;
} }
class SBI extends Bank {
int getRateOfInterest(){
return 8;
} }
class ICICI extends Bank {
int getRateOfInterest(){
return 7;
} }
class AXIS extends Bank{
int getRateOfInterest(){
return 9;
} }
class Test{
public static void main(String args[]){
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
52. Ph.D. Franklin Parrales 51
07/06/2022
Programación Orientada a Objetos Carrera de Software
¿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.
53. Programación Orientada a Objetos
Ph.D. Franklin Parrales
Carrera de Software
52
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
54. Ph.D. Franklin Parrales 53
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
55. Ph.D. Franklin Parrales 54
07/06/2022
Programación Orientada a Objetos Carrera de Software
Jerarquía de clases
Utilizando diagramas de UML (omitiendo la clase Object):
Persona
Administrativo
Alumno Profesor
Oficial Libre TiempoCompleto TiempoParcial
Libre
Catedratico Titular
56. Ph.D. Franklin Parrales 55
07/06/2022
Programación Orientada a Objetos Carrera de Software
Jerarquía de clases
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
57. Ph.D. Franklin Parrales 56
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
58. Ph.D. Franklin Parrales 57
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
59. Ph.D. Franklin Parrales 58
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
60. Ph.D. Franklin Parrales 59
07/06/2022
Programación Orientada a Objetos Carrera de Software
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; } . . .
61. Ph.D. Franklin Parrales 60
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
62. Ph.D. Franklin Parrales 61
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
63. Ph.D. Franklin Parrales 62
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
public String toString() {
return "[" + esquina.toString() + ", " + lado + "]";
}
public void desplaza(double deltaX, double deltaY) {
esquina.desplaza(deltaX, deltaY);
}
}
Cuadrado.java
64. Ph.D. Franklin Parrales 63
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
65. Ph.D. Franklin Parrales 64
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
66. Ph.D. Franklin Parrales 65
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
67. Ph.D. Franklin Parrales 66
07/06/2022
Programación Orientada a Objetos Carrera de Software
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).
68. Ph.D. Franklin Parrales 67
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
69. Ph.D. Franklin Parrales 68
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
70. Ph.D. Franklin Parrales 69
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
71. Ph.D. Franklin Parrales 70
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
72. Ph.D. Franklin Parrales 71
07/06/2022
Programación Orientada a Objetos Carrera de Software
La interfaz Cloneable
public class PruebaAlumno3 {
public static void main(String args[]) {
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();
System.out.println(al2);
al1.ponNombre("Angel");
per = al1.dameProfesor();
per.ponNombre("Rosa");
System.out.println(al1);
System.out.println(al2);
}
}
Shallow copy (copia superficial)
El atributo profesor no se clona.
PruebaAlumno3.java
73. Ph.D. Franklin Parrales 72
07/06/2022
Programación Orientada a Objetos Carrera de Software
La interfaz Cloneable
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:
public Object clone() {
try {
return super.clone();
}
catch (CloneNotSupportedException ex) {
return null;
}
}
Persona3.java
74. Ph.D. Franklin Parrales 73
07/06/2022
Programación Orientada a Objetos Carrera de Software
La interfaz Cloneable
En la clase Alumno el método clone() debe crear el clon
del profesor para colocarlo en su propio clon:
public Object clone() {
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
75. Ph.D. Franklin Parrales 74
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
76. Programación Orientada a Objetos
Ph.D. Franklin Parrales
Carrera de Software
75
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
77. Ph.D. Franklin Parrales 76
07/06/2022
Programación Orientada a Objetos Carrera de Software
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 {
...
78. Ph.D. Franklin Parrales 77
07/06/2022
Programación Orientada a Objetos Carrera de Software
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%
79. Ph.D. Franklin Parrales 78
07/06/2022
Programación Orientada a Objetos Carrera de Software
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)
80. Ph.D. Franklin Parrales 79
07/06/2022
Programación Orientada a Objetos Carrera de Software
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();
Clase c2 = new Clase();
Clase c3 = new Clase();
System.out.println("Se han creado " + c3.cuantos() +
" objetos.");
}
}
DeClase.java
81. Ph.D. Franklin Parrales 80
07/06/2022
Programación Orientada a Objetos Carrera de Software
Atributos compartidos
0
_cuantos
82. Ph.D. Franklin Parrales 81
07/06/2022
Programación Orientada a Objetos Carrera de Software
Atributos compartidos
Clase c1 = new Clase();
0
1
_cuantos
_f
c1
_cuantos
83. Ph.D. Franklin Parrales 82
07/06/2022
Programación Orientada a Objetos Carrera de Software
Atributos compartidos
Clase c2 = new Clase();
2
_f
c1
_cuantos
_f
c2
_cuantos
_cuantos
84. Ph.D. Franklin Parrales 83
07/06/2022
Programación Orientada a Objetos Carrera de Software
Atributos compartidos
Clase c3 = new Clase();
3
_f
c1
_cuantos
_f
c2
_cuantos
_f
c3
_cuantos
_cuantos
85. Ph.D. Franklin Parrales 84
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
✓
86. Ph.D. Franklin Parrales 85
07/06/2022
Programación Orientada a Objetos Carrera de Software
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 {
private static int _cuantos = 0;
...
public static int cuantos() { // Método de clase
return _cuantos;
}
}
87. Ph.D. Franklin Parrales 86
07/06/2022
Programación Orientada a Objetos Carrera de Software
Métodos de ejemplar y métodos de clase
class Clase {
private static int _cuantos = 0;
...
public static int cuantos() { // Método de clase
return _cuantos;
}
}
public class DeClase2 {
public static void main(String[] args) {
System.out.println("Se han creado " +
Clase.cuantos() + " objetos.");
Clase c1 = new Clase();
Clase c2 = new Clase();
Clase c3 = new Clase();
System.out.println("Se han creado " + c3.cuantos() +
" objetos.");
}
} DeClase2.java
88. Ph.D. Franklin Parrales 87
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
89. Ph.D. Franklin Parrales 88
07/06/2022
Programación Orientada a Objetos Carrera de Software
Ejercicio: una clase Usuario
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.
90. Ph.D. Franklin Parrales 89
07/06/2022
Programación Orientada a Objetos Carrera de Software
Ejercicio: una clase Usuario
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() { ... }
}
91. Ph.D. Franklin Parrales 90
07/06/2022
Programación Orientada a Objetos Carrera de Software
Ejercicio: una clase Usuario
Otra ayuda: el programa principal.
public class Sistema {
public static void main(String[] args) {
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();
}
}
92. Ph.D. Franklin Parrales 91
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
93. Ph.D. Franklin Parrales 92
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
94. Ph.D. Franklin Parrales 93
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
95. Ph.D. Franklin Parrales 94
07/06/2022
Programación Orientada a Objetos Carrera de Software
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;
}
public static void main(String args[]){
Bike obj=new Bike();
obj.run();
}
}
Output:
Compile Time Error
96. Ph.D. Franklin Parrales 95
07/06/2022
Programación Orientada a Objetos Carrera de Software
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");
}
public static void main(String args[]){
Honda honda= new Honda();
honda.run();
}
}
Output:
Compile Time Error
97. Ph.D. Franklin Parrales 96
07/06/2022
Programación Orientada a Objetos Carrera de Software
3) Clase final
◼ Si haces alguna clase como final, no puedes extenderla.
final class Bike{
}
class Honda extends Bike{
void run(){
System.out.println(" Honda Class ");
}
public static void main(String args[]){
Honda honda= new Honda();
honda.run();
}
}
Output:
Compile Time Error
98. Ph.D. Franklin Parrales 97
07/06/2022
Programación Orientada a Objetos Carrera de Software
¿método final heredado?
class Bike{
final void run(){
System.out.println(“Bike Class");
}
}
class Honda extends Bike{
public static void main(String args[]){
new Honda().run();
}
}
Nota: El método final se puede heredar pero no se puede sobrescribir.
Output:
Bike Class
99. Ph.D. Franklin Parrales 98
07/06/2022
Programación Orientada a Objetos Carrera de Software
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;
}
100. Ph.D. Franklin Parrales 99
07/06/2022
Programación Orientada a Objetos Carrera de Software
Inicializar variable final en blanco
class Bike{
final int speedLimit;//blank final variable Bike
(){
speedLimit=70;
System.out.println(speedLimit);
}
public static void main(String args[]){
new Bike();
}
}
Nota: La variable final en blanco solo se puede
inicializar en el constructor.
Output:
70
101. Ph.D. Franklin Parrales 100
07/06/2022
Programación Orientada a Objetos Carrera de Software
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;
}
public static void main(String args[]){
System.out.println(A.data);
}
} Output:
50
102. Ph.D. Franklin Parrales 101
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
}
public static void main(String args[]){
Bike b=new Bike();
b.cube(5);
}
}
Output:
:Compile Time Error
103. Programación Orientada a Objetos
Ph.D. Franklin Parrales
Carrera de Software
102
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
104. Ph.D. Franklin Parrales 103
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
105. Ph.D. Franklin Parrales 104
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
106. Ph.D. Franklin Parrales 105
07/06/2022
Programación Orientada a Objetos Carrera de Software
¿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.
107. Ph.D. Franklin Parrales 106
07/06/2022
Programación Orientada a Objetos Carrera de Software
Polimorfismo y vinculación dinámica
En la clase Lista está definido el método toString():
public String 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.
108. Ph.D. Franklin Parrales 107
07/06/2022
Programación Orientada a Objetos Carrera de Software
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;
109. Ph.D. Franklin Parrales 108
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
110. Ph.D. Franklin Parrales 109
07/06/2022
Programación Orientada a Objetos Carrera de Software
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");
}
}
111. Ph.D. Franklin Parrales 110
07/06/2022
Programación Orientada a Objetos Carrera de Software
Enlace Dinámico
class C extends A
{
void llamame()
{
System.out.println("Llama al metodo "llamame" de la clase C");
}
}
112. Ph.D. Franklin Parrales 111
07/06/2022
Programación Orientada a Objetos Carrera de Software
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();
//Polimorfismo y enlace dinámico
r = b;
r.llamame();
//Polimorfismo y enlace dinámico
r = c;
r.llamame();
}
}
113. Ph.D. Franklin Parrales 112
07/06/2022
Programación Orientada a Objetos Carrera de Software
Enlace Dinámico
114. Ph.D. Franklin Parrales 113
07/06/2022
Programación Orientada a Objetos Carrera de Software
Enlace Dinámico
115. Ph.D. Franklin Parrales 114
07/06/2022
Programación Orientada a Objetos Carrera de Software
Enlace Dinámico
116. Ph.D. Franklin Parrales 115
07/06/2022
Programación Orientada a Objetos Carrera de Software
Enlace Dinámico
117. Programación Orientada a Objetos
Ph.D. Franklin Parrales
Carrera de Software
116
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
118. Ph.D. Franklin Parrales 117
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
119. Ph.D. Franklin Parrales 118
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
120. Ph.D. Franklin Parrales 119
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
121. Ph.D. Franklin Parrales 120
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
122. Ph.D. Franklin Parrales 121
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
123. Ph.D. Franklin Parrales 122
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
124. Ph.D. Franklin Parrales 123
07/06/2022
Programación Orientada a Objetos Carrera de Software
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?
conatinsAll(Collection): ¿todos esos elementos están?
equals(Object): ¿es igual esta colección y la proporcionada?
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? . . .
125. Ph.D. Franklin Parrales 124
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
126. Ph.D. Franklin Parrales 125
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
. . .
127. Ph.D. Franklin Parrales 126
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
128. Ph.D. Franklin Parrales 127
07/06/2022
Programación Orientada a Objetos Carrera de Software
Implementaciones de propósito general
129. Ph.D. Franklin Parrales 128
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
130. Ph.D. Franklin Parrales 129
07/06/2022
Programación Orientada a Objetos Carrera de Software
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?
conatinsAll(Collection): ¿todos esos elementos están?
equals(Object): ¿es igual esta colección y la proporcionada?
firstElement(): devuelve el primer elemento del vector (posición 0).
get(int) o elementAt(int): devuelve el objeto en la posición indicada.
. . .
131. Ph.D. Franklin Parrales 130
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
. . .
132. Ph.D. Franklin Parrales 131
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
133. Ph.D. Franklin Parrales 132
07/06/2022
Programación Orientada a Objetos Carrera de Software
Ejemplo de uso de la clase Vector
// Vectores.java: prueba de la clase Vector
import java.util.Vector;
public class Vectores {
public static void main(String[] args){
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.");
. . .
134. Ph.D. Franklin Parrales 133
07/06/2022
Programación Orientada a Objetos Carrera de Software
Ejemplo de uso de la clase Vector
posicion = v.lastIndexOf(p);
System.out.println("El siguiente objeto:");
System.out.print(p);
System.out.println("... se encuentra en la posición "
+ posicion + " del vector.");
p = new Persona(7654321, 28, "Ana", "Martos Hevia");
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.");
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()
135. Ph.D. Franklin Parrales 134
07/06/2022
Programación Orientada a Objetos Carrera de Software
Ejemplo de uso de la clase Vector
public static void muestra(Vector vector) {
Persona per;
System.out.println("==================================");
System.out.println();
if(vector.isEmpty()) {
System.out.println("Vector vacío");
System.out.println();
}
else
for(int i = 0; i < vector.size(); i++) {
per = (Persona) vector.get(i);
System.out.println(per);
}
System.out.println("==================================");
System.out.println();
}
}
136. Ph.D. Franklin Parrales 135
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
137. Ph.D. Franklin Parrales 136
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
. . .
138. Ph.D. Franklin Parrales 137
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
139. Ph.D. Franklin Parrales 138
07/06/2022
Programación Orientada a Objetos Carrera de Software
Ejemplo de uso de la clase ArrayList
// Listas.java: prueba de la clase ArrayList
import java.util.ArrayList;
public class Listas {
public static void main(String[] args){
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("El siguiente objeto:");
System.out.print(p);
System.out.println("... se encuentra en la posicion "
+ posicion + " de la lista.");
. . .
Prácticamente basta con
reemplazar Vector por ArrayList
140. Ph.D. Franklin Parrales 139
07/06/2022
Programación Orientada a Objetos Carrera de Software
Ejemplo de uso de la clase ArrayList
posicion = lista.lastIndexOf(p);
System.out.println("El siguiente objeto:");
System.out.print(p);
System.out.println("... se encuentra en la posicion "
+ posicion + " de la lista.");
p = new Persona(7654321, 28, "Ana", "Martos Hevia");
posicion = lista.indexOf(p);
System.out.println("El siguiente objeto:");
System.out.print(p);
System.out.println("... se encuentra en la posicion "
+ posicion + " de la lista.");
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);
} . . .
141. Ph.D. Franklin Parrales 140
07/06/2022
Programación Orientada a Objetos Carrera de Software
Ejemplo de uso de la clase ArrayList
public static void muestra(ArrayList l) {
Persona per;
System.out.println("==================================");
System.out.println();
if(l.isEmpty()) {
System.out.println("Lista vacía");
System.out.println();
}
else
for(int i = 0; i < l.size(); i++) {
per = (Persona) l.get(i);
System.out.println(per);
}
System.out.println("==================================");
System.out.println();
}
}
142. Ph.D. Franklin Parrales 141
07/06/2022
Programación Orientada a Objetos Carrera de Software
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);
}
}
143. Ph.D. Franklin Parrales 142
07/06/2022
Programación Orientada a Objetos Carrera de Software
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));
}
. . .
144. Ph.D. Franklin Parrales 143
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.");
}
. . .
145. Ph.D. Franklin Parrales 144
07/06/2022
Programación Orientada a Objetos Carrera de Software
Otro ejemplo
public static void main(String[] args) {
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);
}
}
146. Ph.D. Franklin Parrales 145
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
147. Ph.D. Franklin Parrales 146
07/06/2022
Programación Orientada a Objetos Carrera de Software
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());
}
148. Ph.D. Franklin Parrales 147
07/06/2022
Programación Orientada a Objetos Carrera de Software
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());
}
}
}
149. Ph.D. Franklin Parrales 148
07/06/2022
Programación Orientada a Objetos Carrera de Software
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( "-------------------------");
}
public static void main(String args[]) {
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
150. Ph.D. Franklin Parrales 149
07/06/2022
Programación Orientada a Objetos Carrera de Software
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().
151. Ph.D. Franklin Parrales 150
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
152. Ph.D. Franklin Parrales 151
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
153. Ph.D. Franklin Parrales 152
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
154. Ph.D. Franklin Parrales 153
07/06/2022
Programación Orientada a Objetos Carrera de Software
HashMap – Ejercicio
155. Programación Orientada a Objetos
Ph.D. Franklin Parrales
Carrera de Software
154
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
156. Ph.D. Franklin Parrales 155
07/06/2022
Programación Orientada a Objetos Carrera de Software
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...
157. Ph.D. Franklin Parrales 156
07/06/2022
Programación Orientada a Objetos Carrera de Software
Excepciones
public class Desbordamiento {
String mensajes[] = {"Primero","Segundo","Tercero" };
public static void main(String[] args) {
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)
158. Ph.D. Franklin Parrales 157
07/06/2022
Programación Orientada a Objetos Carrera de Software
Jerarquía de excepciones
Throwable
Error Exception
RuntimeException IOException
159. Ph.D. Franklin Parrales 158
07/06/2022
Programación Orientada a Objetos Carrera de Software
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).
160. Ph.D. Franklin Parrales 159
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
161. Ph.D. Franklin Parrales 160
07/06/2022
Programación Orientada a Objetos Carrera de Software
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).
162. Ph.D. Franklin Parrales 161
07/06/2022
Programación Orientada a Objetos Carrera de Software
try ... catch ... finally
public class EjemploCatch {
String mensajes[] = {"Primero", "Segundo", "Tercero" };
public static void main(String[] args) {
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.
163. Ph.D. Franklin Parrales 162
07/06/2022
Programación Orientada a Objetos Carrera de Software
try ... catch ... finally
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.
164. Ph.D. Franklin Parrales 163
07/06/2022
Programación Orientada a Objetos Carrera de Software
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).
165. Ph.D. Franklin Parrales 164
07/06/2022
Programación Orientada a Objetos Carrera de Software
Excepciones predefinidas
166. Ph.D. Franklin Parrales 165
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
167. Ph.D. Franklin Parrales 166
07/06/2022
Programación Orientada a Objetos Carrera de Software
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.
168. Ph.D. Franklin Parrales 167
07/06/2022
Programación Orientada a Objetos Carrera de Software
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 ...
169. Ph.D. Franklin Parrales 168
07/06/2022
Programación Orientada a Objetos Carrera de Software
Ejemplo: Con try-catch
public class Excepcion1 {
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
170. Ph.D. Franklin Parrales 169
07/06/2022
Programación Orientada a Objetos Carrera de Software
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
{
// ...