DiplomadoDesarrollo de Aplicaciones en Internet

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 clasescorrelacionados entre sí y es una característica muy importantepara 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

// ...

}

Nota : [ ] indican que son opcionales en la declaración

Especifica que la clase vaA pertenecer a este paquete.

Permite “reusar” clases de otros paquetes.

Clases – Forma Avanzada

[<Modificadores de clase>]

class <NombreClase> [extends <SuperClase>]

[implements <Lista Interfaces>]

{

// Atributos

// ...

// Métodos

// ...

}

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 implementsindicamos 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 UMLde 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

Notas

Observe que el método getHorario() no está implementado, note la ausencia de {}.

El valor de retorno de getHorario es un objeto de tipo Horario.

Observe que los atributos si existen son final, estáticos.

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:

privateprivate int alto; publicpublic 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 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 sentenciasreturn (<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á implementado en

otro archivo fuente y en otro lenguaje

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>}

EjemploRectangulo (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

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);

Ejemplospublic abstract int area(); //abstracto de la clase figurapublic 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áticaspublic class Matematica {

public static final double PI = 3.1416;public static double seno(double arg) {

return ...}

}

Uso:public class test{

private double base = hipotenusa * Matematica.seno(alfa);private double longitud = 2 * Matematica.PI * radio;

}

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>}

Ejemploprotected void finalize() {

origen = null;}

Objetos – Creación

Tres pasos: Declarar, instanciar e inicializarRectangulo 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étodoForma

idRefObjeto.idMétodo(parámetros);

Ejemplosrect.mover(45,56); rect.area();anchoRectangulo = rect.elAncho();

Objetos – Uso

Acceso directo a los atributos del objetoForma

idRefObjeto.idVarObjetoEjemplos

rect.alto = 16; anchoRectangulo = rect.ancho;

Recomendable: Usar métodos para acceso y modificación rect.setAlto(16); anchoRectangulo = rect.getAncho();

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ónDriver bob = new Driver();

Bus bigBus = new Bus();

bigBus.assignDriver(Bob);

Ejemplo 2 - ComposiciónDriver bob = new Driver();

Bus bigBus = new Bus(bob);

Asociación Bidireccional

class Driver {protected Bus bus;public void assignBus(Bus newBus) {

bus = newBus;}

}

EjemploDriver bob = new Driver(); Bus bigBus = new Bus();bob.assignBus(bigBus); bigBus.assignDriver(Bob);

Asociación con Cardinalidad

Bus Conductor

1 1..*

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 conductores y el bus conoce sus conductores

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 partes que 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:void

Herencia

Forma[modificadores] class idSubClase extends idSuperClase{

<Sentencias>}

Ejemplo//La subclase Rectangulo "extiende" la superclase Figurapublic 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 Objectpublic 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 actual y se desea llamar a mover de la superclase

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);

EjemploMath.seno(alfa);

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 seHace al constructor de la superclase

import java.util.Date;public class Prestamo { public Prestamo (String n, String a, int tipo) {

//tipo 1 empleado 2 clienteif (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

Observe que lnkPersona es instanciado como Clienteo empleado.