OOP Java: Principios de abstracción, encapsulamiento y polimorfismo

OOP
JAVA
C A R L O S S E R R A N O
H T T P S : / / W W W . L I N K E D I N . C O M / I N / C A R L O S S E R R A N O S A N C H E Z /
H T T P S : / / G I T H U B . C O M / D E V E L O P O D O ? T A B = R E P O S I T O R I E S

REQUISITOS PREVIOS
• CONOCIMIENTOS DE ALGORITMO
• CONOCIMIENTOS DE PROGRAMACIÓN
ESTRUCTURADA (ORIENTADA A FUNCIONES)
• CONOCIMIENTOS BÁSICOS DE JAVA

OBJECT
ORIENTED
PROGRAMMING
E L PA R A D I G M A Q U E D E F I N E U N M O D O D E
E N T E N D E R E L A N Á L I S I S , D I S E Ñ O Y
D E S A R R O L L O S O F T W A R E

¿CÓMO LO HACEMOS?
5 MINUTOS PARA PENSAR INDIVIDUAL , 5 PAREJA Y 5 MINUTOS EN GRUPO DE 4 PERSONAS
Vamos a programar un colegio con clases llena de
estudiantes.
En las clases que se identifica por un nombre único, se pueden agregar
estudiantes(Create), listar y mostrar los estudiantes(Read), editar los
estudiantes(Update) y borrar los estudiantes(Delete). Es decir, un CRUD.
Cada Estudiante tiene:
- dni único
- nombre
- teléfono
- email
IMAGINEMOS

TIPO DE VARIABLES?
NOMBRE DE LAS VARIABLES?
NÚMERO DE VARIABLES?
FUNCIONES?
¿HAS PENSADO…

Y AUNQUE LLEVAS MÁS DE 10
MINUTOS…
AÚN NO ESTÁ BIEN DEFINIDO EL
PROBLEMA?

LAS PERSONAS QUE AÚN NO HAN
CONSEGUIDO DEFINIR EL DISEÑO,
QUIZÁ SEA POR LAS HERRAMIENTAS
EMPLEADAS…
¡Y SI CAMBIAMOS DE HERRAMIENTA!

DISEÑO DE LOS
DATOS: MODELO
E-R
L A S P E R S O N A S Q U E N O S E PA N D E B A S E D E
D AT O S AVA N Z A D D I R E C TA M E N T E A L A
PÁ G I N A X

DEFINAMOS EL MODELO
• Imaginemos que no es problema de Programación, si no
de Base de datos.
• Efectivamente en el problema hay datos: Clases con
estudiantes y datos en los estudiantes… Imagina que un
estudiante solo puede estar en una clase.
• Identifiquémoslos.
• Intentemos diseñar el modelo con una herramienta bien
conocida: E-R.
• Veamos como queda el colegio.
¿CÓMO LO HACEMOS?
5 MINUTOS PARA PENSAR INDIVIDUAL , 5 PAREJA Y 5 MINUTOS EN GRUPO DE 4 PERSONAS

UNA POSIBLE SOLUCIÓN (TABLAS)
• Todos los datos VARCHAR.
• ¿Discutimos por qué el teléfono no es
numérico?

¿POR QUÉ ”TODOS” HEMOS DADO CON UNA
SOLUCIÓN ESTÁNDAR?
¿POR QUÉ AHORA SÍ ESTÁ COMPLETAMENTE
DEFINIDO EL PROBLEMA?
SI BIEN, LOS DATOS ESTÁN DEFINIDOS, LAS
FUNCIONALIDADES (CRUD) NO APARECEN…
RECAPACITEMOS (QUÉ HA CAMBIADO RESPECTO A
CUANDO LO PLANTEAMOS COMO PROGRAMACIÓN)…

”OBJETOS” EN
PROGRAMACIÓN
C U A N D O A G R U PA M O S L O S D AT O S Y S U S
F U N C I O N A L I D A D E S D E N T R O D E U N A U N A
M I S M A E S T R U C T U R A : L A C L A S E

¿QUÉ CLASES PUEDEN DEFINIR
NUESTRO PROBLEMA?
Los objetos se definen en unas estructuras denominadas clases. Por lo
tanto, por ahora, cambiaremos el nombre de objeto por clase.
Cada clase agrupará los datos relacionados con una temática y sus
funcionalidades.
Debemos pensar de forma abstracta, como en base de datos, pero no
solo centrándonos en los datos, sino también en lo que se puede
hacerse con esos datos.
Por tanto, debemos definir objetos (clases) que puedan definir el
problema.
CLASES

Clase:
Datos:
- nombre
Funciones:
- agregar un estudiante (C)
- listar los estudiantes (R)
- editar un estudiante (U)
- borrar un estudiante (D)
Estudiante:
Datos:
- dni
- nombre
- teléfono
- email
NUESTOS OBJETOS / CLASES

PRIMER PRINCIPIO
DE OOP:
ABSTRACCIÓN
C R E A M O S O B J E T O S Q U E D E N R E S P U E S TA A
N U E S T R O P R O B L E M A , P E N S A N D O D E F O R M A
G L O B A L Y S I N T E N E R E N C U E N TA A C Ó M O L O
V A M O S A P R O G R A M A R .

• Es una estructura de datos y funcionalidades.
• Las clases son la plantilla que definen los tipos de
objetos.
• Por ejemplo la clase Estudiante define que atributos
(datos) debe tener un estudiante, pero luego existirán en
el programa estudiantes con sus datos, por ejemplo:
juan, con dni…. A la materialización (reserva de memoria
y asignación de valores) de una clase en el programa se
le llama OBJETO.
• Por tanto, existirá una clase Estudiante, pero luego
multitud de objetos de tipo Estudiante con sus valores.
¿CÓMO SE DEFINEN LAS CLASES?

• Por ahora, cada clase deberá estar en su propio archivo
que tendrá el mismo nombre que la clase.
• Por ejemplo, creemos Estudiante.java. (Primera letra en
mayúscula).
• El contenido básico de una clase debe ser:
class Estudiante {
//ámbito de definición de la clase
}

class Estudiante {
//definición de atributos (variables) de una clase
String dni;
String nombre;
String email;
String telefono;
}

class Ejecutable{
public static void main(String args[]){
//declaración de tipo, sin inicializar
Estudiante estudiante = null;
//instanciación de una clase Estudiante
//estudiante es un objeto
estudiante = new Estudiante();
}
}
¿CÓMO LAS EMPLEAMOS?
Nota: ambas clases deben estar en la misma carpeta
Nota: hemos creado Ejecutable.java con este contenido

Estudiante estudiante = null;
// se ha definido una variable llamada estudiante que será
compatible con apuntar a una zona de memoria que
contenga un objeto de tipo Estudiante, pero ahora mismo
no apunta a ninguna zona de memoria (en realidad
apunta a una zona denominada null de la JVM) .
Solo ocupa 4 u 8 bytes,
necesarios en el futuro
para almacenar la zona
de memoria dónde se
ubica el objeto.

estudiante = 5;
estudiante = “Hola”;
estudiante = 1.3;
estudiante = new Scanner(System.in);
/*ERROR, estudiante solo puede ”apuntar” a
una zona de memoria que almacene una
estructura de tipo Estudiante.*/

new Estudiante();
/* Invoca al constructor de la clase
Estudiante.
Todas las clases tienen un constructor,
aunque no se haya definido. Este
constructor reserva una zona de
memoria para almacenar una estructura
de tipo estudiante e inicializa sus
atributos. Por defecto, las primitivas a 0
o false y los objetos null */

estudiante = new Estudiante();
/* la variable estudiante
”apuntará” a la zona de
memoria de un OBJETO
de tipo Estudiante
que se acaba de crear */

estudiante.dni = 5;
//ERROR de tipo
estudiante.nombre = “Carlos”;
estudiante.telefono = “0052”;
System.out.println(estudiante.nombre);
//Imprime Carlos
System.out.println(estudiante.email);
//Imprime null
System.out.println(estudiante);
¿Qué imprime? Tenéis 5 minutos para
buscar información sobre el método que
tienen todos los objetos en Java llamado

class Estudiante {
String dni;
String nombre;
String email;
String telefono;
public String toString(){
return “Mi nombre es ” + nombre;
}
}
/*Es un método que contienen todas los objetos. Su funcionalidad, por defecto, es imprimir
la zona de memoria que la JVM le ha asignado al objeto. En Java, podemos sobreescribir un
método. Es decir, volver a definirlo “machacando” su funcionalidad y sustituyéndola por una
nueva. Para ello tenemos que definirlo exactamente cómo fue declarado en su origen:
public que devuelve un String y no recibe nada. En este caso hemos hecho que devuelva un
String compuesto por la frase que veis en el código. El método toString() puede ser llamado
directamente o automáticamente cuando insertamos un objeto en algún método que
esperaba un String como es el caso de System.out.println*/
System.out.println(“Esto es una forma ”+estudiante.toString());
System.out.println(estudiante); //esto, otra

class Estudiante {
String dni;
String nombre;
String email;
String telefono;
Estudiante(){
dni=“”; nombre=“C”; email=“E”;telefono=“”;
}
return “D:”+dni+” N:”+nombre+” E:”
+email+” T:”+telefono;
}
}
Estudiante estudiante = new Estudiante();
//inicializa los atributos empleando el constructor por defecto;
PODEMOS SOBREESCRIBIR EL CONSTRUCTOR

CUARTO PRINCIPIO
DE OOP:
POLIMORFISMO
P O D R E M O S D E F I N I R M É T O D O S C O N E L M I S M O N O M B R E , P E R O
D I S T I N T O N Ú M E R O Y / O T I P O D E P A R Á M E T R O S .
A D E M Á S , M Á S A D E L A N T E , C U A N D O E M P L E E M O S H E R E N C I A , P O D R E M O S A P L I C A R E L
P O L I M O R F I S M O D E O T R A S F O R M A S : S O B R E C A R G A R D E M É T O D O S Y U S O D E C L A S E S
S U P E R I O R E S P A R A F U N C I O N A R C O M O G E N É R I C A S .

Estudiante(String d,String n,String e,String t){
dni=d; nombre=n; email=e; telefono=t;
}
/* d,n,e,t son variables locales del método constructor Estudiante.
No confundir con las variables de clase dni, nombre, email y teléfono.
Mientras que d,n,e,t dejarán de existir al finalizar la ejecución del
constructor, las otras permanecerán mientras el objeto exista
(por ahora, hasta el final del programa). */
Prueba:
Estudiante e1 = new Estudiante();
Estudiante e2 = new Estudiante(“1”,”C”,”E”,”T”);
System.out.println(e1);
System.out.println(e2);
Podríamos crear tantos como quisiéramos, con la condición que tengan distinto número de parámetros
y/o tipo para que Java pueda distinguir a cual invocar en cada llamada.
PODEMOS DEFINIR CONSTRUCTORES PERSONALIZADOS

Estudiante(String dni,String nombre,String e,String t){
this.dni=dni; this.nombre=nombre; email=e; telefono=t;
}
/* En aquellos ámbitos de métodos en los que una variable
local tengan el mismo identificador que el atributo de la clase,
podemos distinguirlos con el operador this.
this.dni -> atributo de la clase
dni -> variable local del constructor
*/
EL OPERADOR THIS PARA SITUACIONES AMBIGUAS

SEGUNDO
PRINCIPIO DE OOP:
ENCAPSULAMIENTO
C U A N D O A G R U P A M O S L O S D AT O S Y S U S
F U N C I O N A L I D A D E S D E N T R O D E U N A U N A
M I S M A E S T R U C T U R A : L A C L A S E

Debemos ver una clase como una maquinaria que contiene en su
interior multitud de datos y funciones para cumplir una misión, pero
desde el exterior no debemos preocuparnos de cómo se programó
(ABSTRACCIÓN) y solo debemos tener acceso a aquellos atributos y
métodos que sean públicos, es decir, diseñador para su uso desde el
exterior.
Por tanto, es una buena práctica definir los atributos como privados
(no accesibles desde el exterior) y métodos que controlen su acceso
como públicos (Los Getters y Setters).
A este control de acceso se le denomina ENCAPSULAMIENTO.
MODIFICADORES DE ACCESO DE ATRIBUTOS Y MÉTODOS

class Estudiante {
private String dni;
private String nombre;
private String email;
private String telefono;
public Estudiante(){
}
public Estudiante(String dni,String nombre,String email, String telefono){
this.dni = dni; this.nombre = nombre; this.email = email; this.telefono = telefono;
}
public void setDni(String dni){
this.dni = dni;
}
public String getDni(){
return dni;
}
Completa los demás GETTERs y SETTERs
return “D:”+dni+” N:”+nombre+” E:”+email+” T:”+telefono;
}
}
MODIFICADORES DE ACCESO DE ATRIBUTOS Y MÉTODOS

Estudiante e1 = new Estudiante();
Estudiante e2 = new Estudiante(“1”,”Carlos”,”E”,”T”);
e1.nombre = “Juan”; //Error, no accesible
e1.setNombre(“Juan”); //Correcto, modificado
System.out.println(e2.dni); //Error, no accesible
System.out.println(e2.getDni()); //Correcto, devuelve su nombre
/* Al inicio, puede parecer redundante e incluso sin sentido. Tener que
definir un método para asignar y leer el valor de una variable, cuando
podría hacerlo directamente, pero he aquí el principio de
Encapsulamiento. Especialmente útil para validación de datos, control de
lectura y empleo de la Reflexión en frameworks. Todo lo entenderás poco
PROBANDO GETTERS Y SETTERS

public void setDni(String dni){
if(validaDNI(dni)){
this.dni=dni;
}
}
private boolean validaDNI(String dni) {
boolean result = false;
// Aquí excluimos cadenas distintas a 9 caracteres que debe tener un dni y también si el último carácter no es una letra
if(dni.length() == 9 && Character.isLetter(this.dni.charAt(8)) == true ) {
// Al superar la primera restricción, la letra la pasamos a mayúscula
char letraMayuscula = (this.dni.substring(8)).toUpperCase();
if(soloNumeros(dni) == true && letraDNI(dni)==letraMayuscula) {
result=true;
}
}
return result;
}
- Defino como privado métodos que no queremos publicar. Es decir, son de utilidad interna.
- Pueda invocar desde la clase a todos los métodos definidos en ella
- El Setter lo empleamos para no asignar dni válidos.
- Métodos por definir: soloNumeros devuelve true si todos los caracteres son números. letraDNI calcula la letra de los
números dados. (INTÉNTALO)
PONIENDO EN PRÁCTICA GETTERS Y SETTERS

REFLEXIÓN Y
EJERCICIO
PROPUESTO PARA
CONSOLIDAR
P R O G R A M A T O D A L A C L A S E E S T U D I A N T E ,
I N C L U I D O S O L O N U M E R O S Y L E T R A D N I

SOLUCIÓN private boolean soloNumeros(String dni) {
boolean result= true;
String numero = dni.substring(0,8);
for(int i=0 ; i<8 && result ; i++){
char digito = dni.charAt(i);
if(digito < ‘0’ || digito > ‘9’){
result=false;
}
}
return result;
}
private char letraDNI(String dni) {
// pasar miNumero a integer
int miDNI = Integer.parseInt(dni.substring(0,8));
int resto = 0;
char miLetra = "";
char[] asignacionLetra = {‘T’ ‘R’, ‘W’, ‘A’, ‘G’, ‘M’, ‘Y’, ‘F’, ‘P’, ‘D’,
‘X’, ‘B’, ‘N’, ‘J’, ‘Z’, ‘S’, ‘Q’, ’V’, ‘H’, 'L’, ‘C’, ‘K’, ‘E’};
resto = miDNI % 23;
miLetra = asignacionLetra[resto];
return miLetra;
}

EJERCICIO
AVANZADO
Q U É O C U R R E C U A N D O Q U E R E M O S
C O M PA R A R Y S A B E R S I D O S O B J E T O S
S O N “ I G U A L E S ”

EQUALS
Empleando la clase Estudiante completa.
Ejecuta lo siguiente en el main:
Estudiante e1 = new Estudiante(“00000000T”,”Carlos”,””,””);
Estudiante e3 = e1;
System.out.println(e1==e2);
Ejecútalo de forma individual. 5 Minutos para pensar el resultado.
En parejas, 5 minutos para encontrar la respuesta a lo hallado.
En grupos de 4, 15 minutos para investigar sobre el método equals e
implementarlo.
¿Cuándo deberían ser iguales dos estudiantes?

EJERCICIO
AVANZADO
L A S O L U C I Ó N

LO QUE HA OCURRIDO
Estudiante e3 = e1;
System.out.println(e1==e2); //false
System.out.println(e2==e3); //false
System.out.println(e1==e3); //true
El operador == compara el contenido de una variable.
En el caso de las variables primitivas es su valor efectivo.
(int n=5; int s=5; n==s; // true)
En el caso de los objectos es el valor de su dirección de memoria.
Por tanto objecto1 == objeto2 solo dará true si ambos
objetos apuntan a la misma zona de memoria, pero no compara
su contenido.

LO QUE HA OCURRIDO
Por tanto el operador == será útil para saber si dos
variables apuntan al mismo objeto, pero no nos servirá para
comparar dos objetos desde un punto de vista semántico.
Es decir, supongamos que nuestro programa queremos que
entienda que dos estudiantes son iguales cuando tienen el
mismo
dni.
En ese caso deberemos hacer uso del método genérico
equals.
== compara igualdad desde el punto de vista de la
máquina, es decir que sean el mismo objeto en memoria.
equals compara dos objetos desde el punto de vista
semántico
(siempre que sea sobreescrito con esa funcionalidad).
Dado que, por defecto, su funcionalidad es similar a ==.
Prueba:
System.out.println(e1.equals(e2)); //false

SOBREESCRIBIR EQUALS
Como dijimos para sobreescribir un método debemos definirlo tal como lo estaba
previamente. En este caso debemos ir a la documentación oficial de Java y ver cómo se define
por defecto:
https://docs.oracle.com/javase/10/docs/api/java/lang/Object.html#equals(java.lang.Object)
public boolean equals(Object obj)
Aún es pronto para explicar el tipo de dato Object, puesto que está relacionado con el tercer
principio de la OOP: HERENCIA.
No obstante, diremos que el tipo Object es compatible con cualquier otro tipo en Java. Es un
super tipo. De esta forma, el método equals recibirá cualquier tipo de variable sin dar error.
No obstante, cuando queremos comparar Estudiantes, no solo queremos que tengan un
atributo dni y su valor sea el mismo, sino que además el tipo con el que se compara sea
también un Estudiante.
¿Cómo lo empleamos?
e1.equals(e2), debería dar el mismo resultado que e2.equals(e1).
Sin embargo, en la primera opción llamamos al método equals de e1, pasándole como
parémetro e2, y en la segunda opción viceversa. No obstante, si está bien programado,
debería dar el mismo resultado en ambos casos.

SOBREESCRIBIR EQUALS
public boolean equals(Object obj){
boolean result= false;
if(obj == this){ //comparamos el objeto pasado con esta instancia (this), si es la misma zona de memoria es igual, devolvemos
true
result = true;
}else if(obj != null && obj.getClass() == getClass() ){ //getClass devuelve el tipo de clase, esperamos Estudiante
Estudiante e = (Estudiante) obj;
//Hacemos un casting para tener una variable de tipo Estudiante apuntando a la zona de memoria. Hasta ahora era una
variable compatible Objet, pero necesitamos una variable que tenga las ”palancas” necesarias, en este caso getDni();
if(dni.equals(e.getDni())){
//Comparamos ambos dnis, con equals por ser objetos.
result = true;
}
}
return result;
}
Ejercicio de ampliación:
ver la definición de la clase Object.
https://docs.oracle.com/javase/10/docs/api/java/lang/Object.html

COMPLETANDO
EL PROYECTO
L A C L A S E E S TÁ C O M P U E S TA D E A L U M N O S

LA CLASE
Las clases pueden emplear otras clases como tipo de atributo.
Imaginemos que una clase tiene 30 puestos (un array).
Podríamos definirla como:
class Clase{
private String nombre;
private Estudiante[] estudiantes;
public Clase(String nombre){
this.nombre = nombre;
estudiantes = new Estudiante[30];
}
…
}
Ahora toca trabajar en la implementación de la clase completa, el CRUD.

LA CLASE
Clase clase = new Clase(“1 DAM”);
new Clase: ha reservado zona de
memoria para un objeto de tipo
Clase.
El objeto contiene un String
nombre.
Y una variable de tipo array de
Estudiante.
El constructor ha inicializado
nombre al parámetro (1 DAM).
Y ha creado una zona para 30
”punteros” a Estudiante. Dichas
variables están apuntando cada
una de ellas a NULL.
El atributo estudiante está
apuntando a array de 30

LA CLASE
Creamos un método para saber cuántos alumnos hay
en la clase. A pesar de que hay 30 pupitres, ahora
mismo están a valor NULL, por lo que la clase está
vacía.
class Clase{
…
public int nEstudiantes(){
int n=0;
for(int i=0;i<estudiantes.lenght;i++){
if(estudiantes[i]!=null){
n++;
}
}
return n;
}
}

LA CLASE - CREATE
Creamos un método para insertar un alumno.
Debemos comprobar si hay pupitres vacíos.
Y deberemos buscar el primer pupitre disponible y
sentarlo
en él. Devolverá true si conseguimos sentar al
estudiante.
class Clase{
…
public boolean insertaEstudiante(Estudiante e){
boolean result=false;
if(e!=null && nEstudiantes()<30){
for(int i=0;i<estudiantes.lenght &&
!result;i++){
if(estudiantes[i]==null){
estudiantes[i]=e;
result = true;
}
}
}

LA CLASE - CREATE
for(int i=0;i<estudiantes.lenght && !result;i++){
estudiantes[i]=e;
result = true;
}
}
}
return result;
}
Imaginemos que e!=null, es decir, existe un espacio de
memoria
con un objeto (zona verde).
Además, nEstudiantes() es < 0 puesto que toda la clase está
vacía.
El bucle for recorre buscando un puntero estudiante[i] que
esté vacío, es decir, valga null.
Cuando lo encuentra, en nuestro caso estudiante[0], iguala las
direcciones de memoria, haciendo que estudiante[0] apunte a
la misma zona que e. De esta forma deja de valer null.
Empleamos el flag result para interrumpir el for, puesto que si

LA CLASE - READ
public Estudiante[] ,muestraTodos(){
getEstudiantes(); //¿hemos programado los GETTERs y SETTERs, si no…ahora es un buen
momento.
}
/**
* Devuelve el estudiante indicado por el dni o null en caso contrario
* param dni : dni del estudiante a buscar
* return el estudiante encontrado o null si no se encuentra
**/
public Estudiante muestraPorDni(String dni){
}
¿Te atreves?

LA CLASE - READ
public Estudiante[] muestraTodos(){
getEstudiantes(); //¿hemos programado los GETTERs y SETTERs, si no…ahora es un buen
momento.
}
/**
* Devuelve el estudiante indicado por el dni o null en caso contrario
* param dni : dni del estudiante a buscar
* return el estudiante encontrado o null si no se encuentra
**/
public Estudiante muestraPorDni(String dni){
Estudiante e=null;
if(estudiantes!=null && nEstudiantes() > 0){
for(int i=0;i<estudiantes.lenght && e==null;i++){
if(estudiantes[i].getDni().equals(dni)){
e=estudiantes[i];
}
}
}
return e;
}

LA CLASE - CREATE
estudiantes[i]=e;
result = true;
}
}
}
return result;
}
Podemos mejorar insertaEstudiante para que no se puedan
insertar dos estudiantes con el mismo dni. ¿Te atreves?

LA CLASE - CREATE
if(e!=null && nEstudiantes()<30 &&
muestraPorDni(e.getDni())==null){
estudiantes[i]=e;
result = true;
}
}
}
return result;
}

LA CLASE - UPDATE
public boolean actualizaEstudiante(Estudiante e){
if(e!=null && muestraPorDni(e.getDni())!=null){
if(estudiantes[i].equals(e)){
estudiantes[i]=e;
result = true;
}
}
}
return result;
}

LA CLASE - DELETE
public boolean eliminaEstudiante(Estudiante e){
if(e!=null && muestraPorDni(e.getDni())!=null){
if(estudiantes[i].equals(e)){
estudiantes[i]=null;
result = true;
}
}
}
return result;
}

PROYECTO
COMPLETADO
E L C R U D E S TÁ C O M P L E T O

PROYECTO EN
EQUIPO
V U E S T R O T U R N O

METODOLOGÍA
GRUPO DE 3/4 PERSONAS
METOLOGÍA ÁGIL SCRUM
EMPLEO DE GIT COMO CONTROL DE VERSIONES
CREACIÓN DE UN PROYECTO DE TEMÁTICA LIBRE CON LOS SIGUIENTES
REQUISITOS:
EMPLEO DE PROGRAMACIÓN ORIENTADA A OBJETOS.
EMPLEO DE CRUD.
EMPLEO DE ARRAY DE OBJETOS.
DISEÑO DE MENÚ CON VALIDACIÓN POR CONSOLA
Ejemplo: Creación de un juego de cartas (donde el mazo sea un objeto con
un array de naipes…), Creación de un gestor de biblioteca (con libros,
películas…),
Creación de un gestor de empleados de una empresa…

REQUISITOS DE LA ENTREGA.
UN PDF ADECUADAMENTE FORMATEADO (PORTADA, INDICE,
PAGINACIÓN, CABECERA, PIE DE PÁGINA, NUMERACIÓN DE TÍTULOS…
CON, AL MENOS, LOS SIGUIENTES PUNTOS:
1. INDICE
2. DESCRIPCIÓN Y ALCANCE DEL PROYECTO
3. DOCUMENTACIÓN DEL DISEÑO (DIAGRAMA DE CLASES, DISEÑO DE
PANTALLAS, CASOS DE USO…)
4. ASPECTOS A DESTACAR Y FUNCIONALIDADES ESPECIALES
5. ENLACE AL GIT PÚBLICO
6. ASPECTOS DE MEJORA
7. REPARTO DE TAREAS Y % DE TRABAJO
El código debe estar correctamente documentado.
SE DEBE REALIZAR UNA PRESENTACIÓN TÉCNICO-COMERCIAL CON DEMO
DEL PRODUCTO.

METODOLOGÍA
SE ELIGE UN SCRUM MÁSTER.
SE COMIENZA DEFINIDENDO LA ESTRUCTURA DEL PROYECTO.
SE DEFINEN TAREAS (PEQUEÑAS) PARA IR COMPLETANDO.
SE REPARTEN LAS TAREAS.
CADA DÍA SE REALIZA UN DAILY MEETING DE NO MÁS DE 10 MINUTOS.
SE ANALIZAN TAREAS PENDIENTES, TAREAS A REPARTIR… Y SE COMIENZA
A TRABAJAR.
SE RECOMIENDA EL USO DE BRANCH PARA SUBIR MEJORAS.
SI NO SE TIENEN SUFICIENTES CONOCIMIENTOS DE GIT, AL MENOS, LA
VERSIÓN FINAL, DEBE ESTAR PUBLICADA EN UN GIT PÚBLICO (POR
EJEMPLO, GITHUB).

A TRABAJAR
O B J E T I V O S :
- A F I A N Z A R O O P B Á S I C O
- T R A B A J A R E N E Q U I P O
- G I T
- S C R U M
- D O C U M E N T A C I Ó N
- E X P R E S I Ó N D E I D E A S
E M P R E N D E Y D E S A F Í A L O S L Í M I T E S

OOP Java: Principios de abstracción, encapsulamiento y polimorfismo

Recomendados

Recomendados

Más contenido relacionado

Similar a OOP Java: Principios de abstracción, encapsulamiento y polimorfismo

Similar a OOP Java: Principios de abstracción, encapsulamiento y polimorfismo (20)

Último

Último (20)

OOP Java: Principios de abstracción, encapsulamiento y polimorfismo