Curso de Arquitecturas de
Software
Programación Orientada a
Objetos
UML a Java
UML a Java
Diagramas desarrollados durante el
análisis y el diseño necesitan ser
convertidos a código en Java o cualquier otro Lenguaje OO
Dado que Java es un lenguaje orientado a
objetos mapear de UML a Java es directo
Paquetes
Logica package Logica; package Logica.ModelodelMundo; LogicaModelodelMundo Pueden existir paquetes dentro
De paquetes.
Los paquetes agrupan clases correlacionados entre sí y es una característica muy importante para la reutilización de código.
Paquetes – Ejemplo
-El paquete anterior llamado Mundo tiene 4 clases: Punto, Figura (Abstracta), Rectangulo y Triangulo.
Clases - Forma Básica
[import <Nombre Paquete>[* ò<clase>];] [package <Nombre Paquete>;]
class <NombreClase> { // Atributos // ... // Métodos // ... }
Especifica que la clase va A pertenecer a este paquete.
Permite “reusar” clases de otros paquetes.
Clases –Forma
Avanzada-[<Modificadores de clase>]
class <NombreClase> [extends <SuperClase>]
Clases – Modificadores
•Modificadores de clase: •public: Clase publica (+) •private: Clase privada (-) •Protected: Clase protegida (#) •abstract: Clase abstracta
•final: Clase final (no pueden crearse subclases de ella)
Si no aparece ninguno la clase sólo es visible en el directorio.
Clases – Cláusulas
Cláusula extends
indicamos la clase de la que hereda
Cláusula implements
indicamos una lista de interfaces que implementa
Clases – Propiedades
Propiedades: this y super. • this
Es una referencia al objeto (instancia de la clase) que está ejecutando en ese momento.
• super
Es una referencia a la superclase desde la que una clase hereda, pudiendo así, ejecutar métodos de la superclase (incluyendo contructores).
Clases – Interfaces
Observe la representación UML de interface
Clases – Interfaces
/* Generated by Together */public interface PersonaColegial { public Horario getHorario(); /**
* @directed */
Horario lnkSchedule = null; }
/* Generated by Together */
public class Estudiante implements PersonaColegial { public Horario getHorario()
{ return this.lnkSchedule; } }
Clases – Interfaces
NotasObserve que el método getHorario() no está implementado, note la ausencia de {}. El valor de retorno de getHorario es un objeto de tipo Horario.
Ejemplo
Clases – Ejemplo
package Mundo; class Punto { private int x = 0; private int y = 0; ... } package Mundo; abstract class Figura {private Punto origen; static final double PI = 3.1416; ... } package Mundo; public class Rectangulo extends Figura { private int alto,
ancho; ... }
Atributos – Forma Básica
•Forma
[<Modificador de atributo>] <Tipo> <NombreAtributo>; •Modificadores de atributo
public, private, protected
Si no se especifica ninguno el atributo es accesible sólo en el directorio.
Ejemplos:
private int alto; public int alto = 33;
Atributos - Estáticos
• Existe una sola copia y es compartida por todos los objetos de la clase.
static [modificadores] idTipo idVar;
Ejemplos
static public int maxAlturaRectangulo; static final double PI = 3.1416; final indica que el atributo no puede ser modificado.
Métodos – Forma Básica
[<Modificadores de método>]
<TipoRetorno> <Nombre> ( [<ListaParámetros>] ) [throws <Lista TiposExcepcion>]
{ // Variables locales // Instrucciones o sentencias return (<Expresión>); }
Métodos – Modificadores
Modificadores de método: public, private, protected, static abstract: método que no tiene implementación final: método que no puede sobreescribirse synchronized: Método sincronizado , el método
se ejecuta por exclusión mutua (un solo hilo a la vez).
native: Método nativo, el método está
Métodos – Constructor
Sirven para inicializar los objetos Un objeto puede tener uno o más
constructores.
Todos los constructores tienen el mismo
nombre de la clase y se distinguen por la lista de parámetros (polimorfismo)
En caso de no especificar ningún
constructor, automáticamente se crea uno sin parámetros (constructor por defecto) que inicializa las variables de instancia a cero
Métodos – Constructor
Forma[modificadores] idClase (<parámetros>) {
<sentencias> }
Ejemplo
Rectangulo (int al, int an){
origen = new Punto();
this.alto = al; this.ancho = an; }
Métodos – Constructor
class Punto { private int x = 0; private int y = 0; Punto(){} Punto(int x, int y){this.x = x; this.y = y; }
}
abstract class Figura { protected Punto origen; static final double PI = 3.1416; ...
}
Métodos – Constructor
public class Rectangulo extends Figura {private int alto, ancho;
public Rectangulo() {origen = new Punto();} public Rectangulo( Punto p) {origen = p;} public Rectangulo( int ancho, int alto) {
this (new Punto(), ancho, alto);
}
public Rectangulo (Punto p, int ancho, int alto) {
origen = p; this.ancho= ancho; this.alto= alto; }
... }
Métodos – Parámetros
Podremos pasarlos de dos modos:
Por Valor: Tipos primitivos Por Referencia: Objetos y Arrays
Paso de Mensajes:
Llamada a uno de los métodos de una
clase
Métodos – Sobrecarga
La Sobrecarga hace referencia a métodos con igual
nombre.
Deben tener listas de parámetros diferentes para distinguir
cuando ejecutar uno u otro.
El tipo devuelto puede ser igual
Ejemplo:
public void mover(int x, int y) { origen.mover(x,y);
}
public void mover(Punto p) { origen = p;
}
Métodos Abstractos Ejemplo
Métodos Abstractos
Son aquellos métodos donde no se especifica el cuerpo, éste será implementado en las subclases (por sobrescritura). Forma Básica
[modificadores] abstract [idTipo] idMetodo (parámetros);
Ejemplos
public abstract int area(); //abstracto de la clase figura public int area() //método sobreescrito de rectangulo {
return alto * ancho; }
public int area() {
return base * altura / 2; //método sobreescrito de triangulo }
Métodos Static
Métodos de clase que pueden ser llamados
directamente sin que haya sido creado un objeto de esa clase
Para utilizarlos se antecede el nombre de la
clase
Permiten realizar tareas que no estén
necesariamente asociadas a un objeto Forma
[modificadores] static [idTipo] idClase (parámetros) {
<sentencias> }
Métodos Static
Métodos Static
//Clase con las funciones y constantes matemáticas public class Matematica {
public static final double PI = 3.1416; public static double seno(double arg) {
return ... }
} Uso:
public class test{
Métodos Finalize
Opcionalmente puede incluirse un método finalize() que
es ejecutado de forma automática en caso de existir, inmediatamente antes de destruir una instancia de la clase. En ocasiones puede ser útil, p.e. para anular objetos y facilitar la labor al recolector de basura de Java. Forma
[modificadores] void finalize () { <sentencias>
}
Ejemplo
protected void finalize() { origen = null; }
Objetos – Creación
Tres pasos: Declarar, instanciar e
inicializar
Rectangulo rect = new Rectangulo(100,100);
o también en dos partes:
Rectangulo rect;
rect = new Rectangulo(100,100);
Objetos – Inicialización
Inicialización de objetos con constructores Utilidad de asignar un valor inicial a las
propiedades del objeto.
Un constructor tiene el nombre de la
clase y es ejecutado después de crear el objeto con new
El constructor tiene como parámetros los
valores que sirven para inicializar el objeto
Objetos – Inicialización
Distintas formas de inicialización con
Distintos constructores
Rectangulo r1 = new Rectangulo(punto); Rectangulo r2 = new Rectangulo(14, 28); Rectangulo r3 = new Rectangulo(punto, 15, 25); Rectangulo r4 = new Rectangulo() Æ Constructor
por defecto
Objetos – Uso
El comportamiento de un objeto es
expresado a través de sus métodos. Estos deben soportar todas las posibles
interacciones de ese objeto con el resto de objetos Ejecución de un método Forma idRefObjeto.idMétodo(parámetros); Ejemplos rect.mover(45,56);
Objetos – Uso
Acceso directo a los atributos del objeto
Forma
idRefObjeto.idVarObjeto
Ejemplos
rect.alto = 16;
anchoRectangulo = rect.ancho;
Recomendable: Usar métodos para
acceso y modificación
rect.setAlto(16);
Objetos – Destrucción
En Java con Eliminador automático
de objetos no utilizados
"Recolector de basura" (garbage collector)
Sistema que durante la ejecución del
programa recorre periódicamente la
memoria buscando y eliminando los
objetos sin ninguna referencia válida
Asociación
Bus Conductor
1 1
Si la relación tiene navegabilidad, se coloca una
referencia a la clase conocida en la clase conocedora, esta referencia se hace en la sección de atributos de la clase
Si la relación es bidireccional (ambas se
conocen) entonces se coloca un atributo en cada clase que haga referencia a la otra clase
En el siguiente ejemplo el bus conoce su
conductor.
Asociación Unidireccional
class Bus {protected Driver driver = null;
public void assignDriver(Driver newDriver) {
driver = newDriver; }
public Driver getDriver() { return driver;
}
public boolean isDriverAssigned() { return driver == null;
} }
Asociación Unidireccional
Ejemplo 1 - Agregación
Driver bob = new Driver(); Bus bigBus = new Bus(); bigBus.assignDriver(Bob);
Ejemplo 2 - Composición
Driver bob = new Driver(); Bus bigBus = new Bus(bob);
Asociación Bidireccional
class Driver {protected Bus bus;
public void assignBus(Bus newBus) {
bus = newBus; }
}
Ejemplo
Driver bob = new Driver(); Bus bigBus = new Bus(); bob.assignBus(bigBus); bigBus.assignDriver(Bob);
Asociación con Cardinalidad
Bus Conductor
Si la cardinalidad (multiplicidad) de la
relación es mayor que 1 se usa una colección para guardar las referencias
En el ejemplo un bus puede tener muchos
Asociación
class Bus {protected Driver driverList[] = new Driver[2]; protected int driverCount = 0;
public void assignDriver(Driver newDriver) { if (driverCount < 2) {
driverList[driverCount] = newDriver; driverCount++;
} }
public int getDriverCount() { return driverCount;
} }
Agregación/Composición
Se colocan referencias en el todo de las partesque lo componen, si hay relaciones muchos se usa una colección
En el siguiente ejemplo el libro está compuesto
de páginas y cubiertas
Agregación/Composición
class Pagina {…}class Cubierta {…} class Libro {
private Cubierta cubiertaPosterior; private Cubierta cubiertaAnterior; private Pagina[] paginas;
Libro( int numPages) {
this. cubiertaPosterior = new Cubierta(); this. cubiertaAnterior = new Cubierta(); this.paginas = new Pagina[numPages]; } }
Herencia
0..* 1 Cliente -Ingresos:float +Cliente +ToString:String Persona -Apellido:String +Persona +ToString:String nombre:String Empleado -Sueldo:float +Empleado Prestamo -FechaPrestamo:Date +Prestamo +main:voidHerencia
Forma[modificadores] class idSubClase extends idSuperClase {
<Sentencias> }
Ejemplo
//La subclase Rectangulo "extiende" la superclase Figura
public class Rectangulo extends Figura
{
private int alto, ancho;
... }
Herencia – Forma Básica
/* Generated by Together */
public class Empleado extends Persona { public Empleado( String n, String a, float s)
{
super (n, a);
this.Sueldo = s; }
private float Sueldo;
Herencia – Reglas
Se heredan todos los miembros (atributos y
métodos), aunque sólo son accesibles los declarados public o protected, en caso de no tener calificador de acceso es posible el acceso si la subclase esta declarada en el mismo directorio
No se hereda un miembro de la superclase si la
subclase declara un miembro idéntico (sobrescritura)
Los miembros declarados private se heredan
aunque sin posibilidad de acceso
Las clases con el modificador final no pueden ser
heredadas
Herencia – Acceso
Private: No hay posibilidad de acceso directo por
lo que se eliminan los efectos laterales y dependencias entre clases. Por el contrario, exige añadir métodos para el acceso indirecto.
Protected: Permite el acceso directo sólo a las
subclases, esto es útil a veces, aunque añade dependencias en la jerarquía de clases.
Public: Facilita el acceso directo de todas las
clases, lo que por norma es peligroso.
Sin modificador: Público en el mismo directorio y
privado entre distintos directorios.
Como norma general el acceso debe ser privado
Herencia – Sobreescritura
Una subclase puede redefinir un método
de la superclase a efectos de especializarse
Método sobrescrito
sustituye al método heredado
• nombre, parámetro y tipo devuelto Métodos private , static ó final
no pueden sobrescribirse
Métodos abstract
obligatoriamente sobrescritos
Herencia – Sobreescritura
public class Cliente extends Persona {public Cliente( String n, String a, float i) { super (n, a);
this.Ingresos = i; }
// Sobreescritura – ToString Herado de Clase Object
public String ToString() {
return ""+ this.Ingresos; }
private float Ingresos;
}
Herencia – Llamado de
métodos
En la misma clase o subclases (acceso
protected)
Forma
idMétodo(parámetros);
Ejemplo
mover(x,y);
En la misma clase (métodos sobrescritos de
superclases)
Forma
super.idMétodo(parámetros);
Ejemplo
super.mover(x,y);
Esto supone que existe un método mover en la clase
Herencia – Llamado de
métodos
Fuera de la clase (acceso public)
Formas idRefObj.idMétodo(parámetros); expresión.idMétodo(parámetros); Ejemplos rect.mover(x,y) listaRect[indRec].mover(x,y);
Fuera de la clase (métodos static)
Forma
idClase.idMétodo(parámetros);
Ejemplo
Herencia – Constructores
Al crear un objeto los constructores
se ejecutan en orden de derivación,
desde la superclase a la subclase
En cada superclase se ejecuta el
constructor por defecto salvo que se
indique uno concreto con la palabra
clave super
Herencia – Constructores
abstract class Figura { protected Punto origen; Figura (Punto origen) {
this.origen = origen; }
}
public class Rectangulo extends Figura { private int alto, ancho;
...
public Rectangulo(Punto punto) { super (punto); alto = 0; ancho = 0; }
... }
/* Generated by Together */
public class Empleado extends Persona { public Empleado (String n, String a, float s) {
super (n, a);
this.Sueldo = s; }
private float Sueldo;
}
Herencia – Constructores
Observe la llamada que se Hace al constructor de la superclase
import java.util.Date; public class Prestamo {
public Prestamo (String n, String a, int tipo) { //tipo 1 empleado 2 cliente
if (tipo==1){
lnkPersona = new Empleado(n, a, 5000); }
if (tipo==2){
lnkPersona = new Cliente(n,a, 100000); }
}
public static void main( String[] args){ Prestamo p = new Prestamo("julio","carreño",2); System.out.println(p.lnkPersona.ToString()); }
private Persona lnkPersona; private Date FechaPrestamo; }
Herencia y Polimorfismo
(Implementación)
Observe que lnkPersona es de tipo Persona
