Modelo Teléfono Celular (Smartphone)

Diagrama de clases

En nuestro modelo simplificado que describe a un teléfono celular, haciendo abstracción el mismo
está formado por dos componentes principales:

a) Una Unidad Modular

b) Una batería de alimentación.

Además tiene otros componentes que para nuestro sistema no son relevantes por eso no los
vamos a incluir en esta versión simplificada (pantalla, carcaza, micrófono, lector de huella, etc.)

Según el Diagrama de clases que aparece al inicio de este texto, se puede observar las siguientes
clases.

Clase Dispositivo:
Esta clase representa o modela un dispositivo cualquiera. Por tanto, como nos falta información, no
sabríamos de qué dispositivo se trata. Eso nos lleva a concluir que la misma es una clase abstracta
porque representa un dispositivo genérico cualquiera.

Las clases abstractas se implementan utilizando el calificador abstract

Instructivo para resolver el Ejercicio 2 – Guía de Trabajos Prácticos

Prof. Pablo Wilkinson

J. T.P Paradigmas de Programación – UTN
Ciclo 2020
Implementación de una clase abstracta

public abstract class Dispositivo{….}

Algo que surge del análisis de esta clase es que el dispositivo se puede Encender() o Apagar(), pero
desconocemos cómo hacerlo (pues no sabemos de qué dispositivo se trata). Es decir, desconocemos
su implementación. Cuando se desconoce la implementación de un método el mismo será
abstracto. Deberá implementarse en alguna subclase.

public abstract void Encender(); //Desconocemos su implementación por eso es abstracto

public abstract void Apagar();

Clase Celular
Un objeto celular es un dispositivo, es decir, que aplica relación de Herencia. Va a heredar los
atributos y comportamientos de la clase Dispositivo y agregará los suyos propios.

Implementación de Herencia

public class Celular extends Dispositivo{……}

Para que la clase Celular no sea abstracta deberá implementar todos los métodos que hereda de
Dispositivo.

¿AGREGACION vs COMPOSICIÓN? ¿Cómo me doy cuenta cuál

utilizar y en qué difiere su implementación?
Como dijimos anteriormente, un objeto de tipo Celular estará formado por 2 elementos principales:

 Un objeto umodular de tipo UnidadModular que es el núcleo o corazón del teléfono.

NO se puede concebir un celular sin módulo y un módulo para lo único que se podría utilizar
es para un celular. Es un vínculo permanente o estático. Nacen y mueren juntos. Por tanto,
aquí se presenta una relación de COMPOSICIÓN. (no se concibe uno sin el otro y el ciclo de
vida del objeto umodular está limitado al del teléfono)

Implementación de la Composición
public Celular(){//Constructor

Instructivo para resolver el Ejercicio 2 – Guía de Trabajos Prácticos

Prof. Pablo Wilkinson

J. T.P Paradigmas de Programación – UTN
Ciclo 2020
 //el módulo se crea en el constructor del teléfono estableciendo la Composición

// En el diagrama aparece graficado con un rombo negro

this.umodular=new UnidadModular();

 Un objeto bat de tipo Bateria que lo integra. Podríamos pensar que la batería integra el
celular de manera casi permanente (hasta que tengamos que cambiarla por otra). Se trata
entonces de una relación de AGREGACIÓN. A diferencia del objeto umodular que está
integrado o soldado (es fijo), la batería podría cambiarse cuando se agote.

Implementación de Agregación

public Celular(){ ….}

public void insertar(Batería objbateria){

//recibo como parámetro un objeto y lo vinculo dentro de un método

//en el Diagrama de Clases aparece representado con un rombo blanco o transparente

//el objeto objbateria es creado independientemente de la creación del celular

this.bat=objbateria;//aquí se produce la vinculación

Clase Batería
Tiene 3 atributos propios calificados como privados: amperaje, voltaje y número de serie.

Clase UnidadModular
Tiene como atributo propio la cantidad de circuitos que la integra

Análisis del ejercicio 2

RELACIONES DE AGREGACIÓN Y HERENCIA

Instructivo para resolver el Ejercicio 2 – Guía de Trabajos Prácticos

Prof. Pablo Wilkinson

J. T.P Paradigmas de Programación – UTN
Ciclo 2020
PARADIGMAS DE PROGRAMACIÓN Universidad Tecnológica Nacional
Facultad Regional Mendoza

RELACIONES DE AGREGACIÓN Y HERENCIA

2. Agregar al modelo anterior lo que se indica.

La relación entre PH y Departamento implementarla usando un contenedor ArrayList, parametrizado para que sólo
admita objetos Departamento.
Implementar una clase excepción ErrorLote, que sea lanzada si se pretende asignar más de un edificio a un lote.
Implementar en los objetos Escritura la persistencia, usando la interface Serializable y métodos guardar/recuperar
para gestionarlos.
Implementar la relación 1..n (rol inmueble) usando un objeto contenedor ArrayList.

Escritura
(from inmuebles)
Registro
numero : Integer
(from i nmuebles)
superficie : int
coefAvaluoEdificio : float
domicilio : String
municipio : String
tasa : float Lote
Escritura() (from inmuebles)

Registro() idPadron : Integer

+inscripto +inmueble domicilio : String
valuar()
registrar() avaluoxmt : float
1 1..n superficie : int
emitirBoletos()
setTasa()
getTasa() Lote()
setCoefAvaluoEdificio() valuar()
getCoefAvaluoEdificio()
guardar()
recuperar()
-construccion
0
Edificio
(from inmuebles)
avaluoXmtr : float Departamento
(from inmuebles)

valuar() piso : byte

setAvaluo() dpto : char
getAvaluo() superficie : int
demoler()
unidad Departamento()
1..n

Casa PH
(from i nmuebles) (from inmuebles)
plantaAlta : boolean cantPisos : byte
superficie : int
PH()
Casa() valuar()
valuar()

GUÍA DE TRABAJOS PRÁCTICOS 2

  La relación entre PH y Departamento implementarla usando un contenedor ArrayList, parametrizado
para que sólo admita objetos Departamento.

Se trata de una relación de Composición. Un ArrayList es un contenedor de objetos. Pero la

especificación solicita que sólo admita objetos Departamento. Por lo tanto deberás agregar esa
restricción. Entre tags se encierra la clase a la que está restringido el contenedor

ArrayList<Departamento> listaDepartamentos = new ArrayList<Departamento>();

 Implementar una clase excepción ErrorLote, que sea lanzada si se pretende asignar más de un edificio a
un lote.
Para resolver este punto deberás crear una clase ErrorLote que derive de Exception, pues se trata de
una excepción propia.
A través de una estructura condicional deberás evaluar si la variable de referencia de tipo lote vale null
Eso significa que no está asignada, por tanto se la puede vincular a un edificio. Caso contrario, se crea
un objeto ErrorLote() y se lanza ese objeto creado con la cláusula throw.

 Implementar en los objetos Escritura la persistencia, usando la interface Serializable y métodos

guardar/recuperar para gestionarlos.

Class Escritura implements Serializable{…..

Deberás también, basándote en los apuntes de teoría, generar métodos para guardar() y recuperar().

A continuación te dejo un ejemplo de como guardar y recuperar datos de una agenda.

Vamos a suponer que existe una clase llamada Agenda, que almacena solamente nombres

import java.io.*;

public class TestAgenda{

public static void main(String[] args){

Agenda a1 = new Agenda("Ana", "Martínez", "Fernández");//Estos son los objetos a1 y a2 que quiero
persistir

Agenda a2 = new Agenda("Ernesto", "García", "Pérez");

//la siguiente lógica deberá estar dentro del método guardar()

try{

FileOutputStream fs = new FileOutputStream("agenda.ser");//Creamos el archivo

Instructivo para resolver el Ejercicio 2 – Guía de Trabajos Prácticos

Prof. Pablo Wilkinson

J. T.P Paradigmas de Programación – UTN
Ciclo 2020
 ObjectOutputStream os = new ObjectOutputStream(fs);//Esta clase tiene el método writeObject() que
necesitamos

os.writeObject(a1);//El método writeObject() serializa el objeto y lo escribe en el archivo

os.writeObject(a2);

os.close();//Hay que cerrar siempre el archivo

}catch(FileNotFoundException e){// en caso de que el archive no se pueda crear

e.printStackTrace();

}catch(IOException e){// en caso de que ocurra otro error

e.printStackTrace();

//la siguiente lógica deberá estar dentro del método recuperar

try{

FileInputStream fis = new FileInputStream("agenda.ser");

ObjectInputStream ois = new ObjectInputStream(fis);

a1 = (Agenda) ois.readObject();//El método readObject() recupera el objeto

a2 = (Agenda) ois.readObject();

ois.close();

}catch(FileNotFoundException e){

e.printStackTrace();

}catch(IOException e){

e.printStackTrace();

}catch(ClassNotFoundException e){

e.printStackTrace();

System.out.println(a1);// puede ser tambien a1.mostrar()

System.out.println(a2);

Instructivo para resolver el Ejercicio 2 – Guía de Trabajos Prácticos

Prof. Pablo Wilkinson

J. T.P Paradigmas de Programación – UTN
Ciclo 2020