Escuela Técnica Superior en Ingeniería Informática
20 de Junio del 2017
Programación Orientada a Objetos
Duración: 2 horas y 30 minutos.
Lea atentamente todo el enunciado antes contestar. Especifique nombre y apellidos en todas las hojas que entregue.
Cualquier suposición o decisión sobre el enunciado del examen debe ser detallada y justificada convenientemente.
Se pide la implementación resumida de un sistema domótico de casas. Las empresas de seguridad
(EmpresaSeguridad) controlan los elementos domóticos de varias casas (Casa). La información que se
almacena de una casa es el DNI del propietario y su nombre. Además, cada casa tiene una alarma (Alarma)
con su correspondiente código de seguridad, y un listado de estancias con los elementos programables. Cada
estancia (Estancia) tiene un nombre, una cámara (Camara) y un conjunto de luces (Luz). Las luces pueden
ser del techo (Luz) o de suelo (LuzSuelo). En este último caso, se podrá regular la intensidad en una escala
de 1 a 10. Cuando se cree una luz de tipo suelo, el valor por defecto de la intensidad debe ser 1.
El diagrama UML que modela las clases de este sistema se puede ver en la figura siguiente:
*
Los elementos programables de una casa serán la alarma, la cámara, y las luces con independencia del tipo
de las mismas. Los elementos programables estarán definidos por un identificador único y un estado que
indicará si está encendido o apagado. Además, existirán dos métodos abstractos en esta clase. Uno permite
activar y otro que permite desactivar los objetos programables. Se deberá poder extraer la información
almacenada en cualquier objeto programable y devolverla en una cadena de caracteres (compuesta por el id
y su está activado o desactivado) así como decidir si dos objetos programables (independientemente de su
tipo) son iguales. Dos objetos se consideran iguales si coincide el id.
La alarma tiene un código de seguridad y un timbre (que se simulará con un String). Al crear una alarma se
debe establecer el código (un valor positivo -si se le da un código incorrecto se pondrá a 0- ) y el sonido
característico (por ejemplo “beep”).
La cámara tendrá un atributo que especifique si se encuentra grabando o no y cuando se inicialice deberá
estar apagada y sin grabar.
La luz se debe inicializar apagada.
1
No se implementarán métodos get() / set() ni constructores que NO se pidan explícitamente.
Omitir los import de todas las clases.
Se pide:
a) Desarrollar la clase Programable, con los atributos, el constructor con un argumento (el id) que establezca
el id y la ponga desactivada y los métodos para que la aplicación funcione correctamente. [1 punto]
POSIBLE SOLUCION:
public abstract class Programable {
private int identificador;
private boolean on;
public Programable(int identificador) {
this.identificador = identificador;
}
public int getIdentificador() {
return identificador;
}
public boolean getOn() {
return on;
}
public void setOn(boolean on) {
this.on = on;
}
@Override
public String toString() {
return "identificador=" + identificador + ", on=" + on + '}';
}
public abstract void activar();
public abstract void desactivar();
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
Programable other = (Programable) obj;
boolean sonIguales = false;
if (this.identificador == other.identificador) {
sonIguales=true;
}
return sonIguales;
}
}
2
b) Implementar la clase Alarma, con los atributos, el constructor con dos argumentos que recibe el id y el
código de la alarma y los métodos para que la aplicación funcione correctamente. [0,5 puntos]
POSIBLE SOLUCION:
public class Alarma extends Programable implements Serializable{
private int codigo;
private String sonido;
public Alarma(int codigo, int identificador) {
super(identificador);
if (codigo>0){
this.codigo = codigo;
}
sonido="Beep";
}
@Override
public void activar() {
setOn(true);
}
@Override
public void desactivar() {
setOn(false);
}
@Override
public String toString() {
StringBuilder cadena = new StringBuilder("Alarma: ");
cadena.append(super.toString());
cadena.append(", codigo=").append(codigo);
cadena.append(", sonido=").append(sonido);
return cadena.toString();
}
}
3
c) Implementar la clase Camara con los atributos, el constructor con un argumento (el id), un método para
empezar la grabación que deberá actualizar el estado del objeto de la cámara a modo “grabando” –si está
desactivada la tendrá que activar- además de escribir en pantalla 10 veces la palabra “Grabando” y los
métodos necesarios para el funcionamiento correcto de la clase. [1,5 puntos]
POSIBLE SOLUCION:
public class Camara extends Programable implements Serializable{
private boolean grabando;
private static final int NUMMENSAJES=10;
public Camara(int identificador) {
super(identificador);
}
public void grabar(){
activar();
grabando=true;
for(int i=0; i<NUMMENSAJES; i++){
System.out.println("Grabando");
}
}
@Override
public void activar() {
setOn(true);
}
@Override
public void desactivar() {
grabando=false;
setOn(false);
}
@Override
public String toString() {
StringBuilder cadena = new StringBuilder("Camara: ");
cadena.append(super.toString());
cadena.append(", grabando=").append(grabando);
return cadena.toString();
}
}
4
d) Implementar la clase Luz, con los atributos, el constructor con un argumento (el id) y los métodos para que
la aplicación funcione correctamente. [0,5 puntos]
POSIBLE SOLUCION:
public class Luz extends Programable implements Serializable{
public Luz(int identificador) {
super(identificador);
}
@Override
public void activar() {
setOn(true);
}
@Override
public void desactivar() {
setOn(false);
}
@Override
public String toString() {
StringBuilder cadena = new StringBuilder("Luz: ");
cadena.append(super.toString());
return cadena.toString();
}
}
e) Implementar la clase LuzSuelo, con los atributos, un constructor con dos argumentos (el id y la intensidad
de la luz), método que permita actualizar de una forma segura la intensidad de la luz y los métodos para
que la aplicación funcione correctamente. [0,5 puntos]
POSIBLE SOLUCION:
public class LuzSuelo extends Luz implements Serializable{
private int intensidad;
private static final int NIVELINFERIOR = 1;
private static final int NIVELSUPERIOR = 10;
public LuzSuelo(int intensidad, int identificador) {
super(identificador);
this.intensidad =
((intensidad<NIVELINFERIOR)||(intensidad>NIVELSUPERIOR))?NIVELINFERIOR:int
ensidad;
}
public void setIntensidad(int intensidad) {
if ((intensidad>=NIVELINFERIOR)&&(intensidad<=NIVELSUPERIOR)){
this.intensidad = intensidad;
}
}
@Override
public String toString() {
StringBuilder cadena = new StringBuilder("Luz de suelo: ");
cadena.append(super.toString());
cadena.append(", intensidad=").append(intensidad);
return cadena.toString();
}
}
5
f) Implementar la clase Estancia, con los atributos, un constructor con dos argumentos (el nombre de la
estancia y el listado de luces), 1) un método que permita encender todas las luces, 2) un método que
reciba un id y devuelva una referencia al dispositivo programable cuyo id coincida con el dado –si no
existe debe devolver null- y 3) un método que devuelva una cadena de caracteres con toda la información
de la estancia. [2 puntos]
POSIBLE SOLUCION:
public class Estancia implements Serializable{
private String nombre;
private Camara camara;
private ArrayList<Luz> luces;
public Estancia(String nombre, ArrayList<Luz> luces) {
this.nombre = nombre;
if (luces!=null){
this.luces = luces;
} else {
this.luces=new ArrayList<Luz>();
}
}
public void encenderLuces(){
for (Luz luz: luces){
luz.activar();
}
}
public ArrayList<Luz> getLuces() {
return luces;
}
public Programable devolverDispositivo(int id){
Programable dispositivo = null;
if ((camara!=null)&&(camara.getIdentificador()==id)) {
dispositivo = camara;
} else {
Iterator <Luz> it = luces.iterator();
Luz actual=null;
boolean encontrado =false;
while ((it.hasNext())&&(!encontrado)){
actual = it.next();
if (actual.getIdentificador()==id){
dispositivo=actual;
encontrado = true;
}
}
}
return dispositivo;
}
@Override
public String toString() {
StringBuilder cadena = new StringBuilder("Estancia: ");
cadena.append("Nombre : ").append(nombre).append("/n");
if (camara!=null) {
cadena.append(camara.toString()).append("/n");
}
for (Luz luz: luces){
cadena.append(luz.toString()).append("/n");
}
return cadena.toString();
6
}
}
g) Implementar la clase Casa, con los atributos y un constructor que recibe el nombre del propietario, su DNI,
el id y el código de seguridad de la alarma y un listado de estancias de la casa. Además, se deberá
implementar un método que devuelva true si la alarma está activada y otro método que devuelva true si
hay alguna luz encendida. [1,5 puntos]
POSIBLE SOLUCION:
public class Casa implements Serializable, Comparable <Casa>{
private String propietario;
private int dni;
private Alarma alarma;
private ArrayList<Estancia> estancias;
public Casa(String propietario, int dni, int id, int codigo,
ArrayList<Estancia> estancias) {
this.propietario = propietario;
this.dni = dni;
alarma = new Alarma(codigo,id);
if (estancias!=null){
this.estancias = estancias;
} else {
this.estancias = new ArrayList<Estancia>();
}
}
public boolean estaAlarmaEncendida(){
return alarma.getOn();
}
public boolean estaLuzEncendida(){
Iterator <Estancia> itEstancia = estancias.iterator();
Estancia actual=null;
boolean encendida =false;
while ((itEstancia.hasNext())&&(!encendida)){
actual = itEstancia.next();
ArrayList<Luz> lucesEstancia = actual.getLuces();
Iterator <Luz> it = lucesEstancia.iterator();
Luz actualLuz=null;
while ((it.hasNext())&&(!encendida)){
actualLuz = it.next();
encendida = actualLuz.getOn();
}
}
return encendida;
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Casa other = (Casa) obj;
if ((!this.propietario.equalsIgnoreCase(other.propietario))||
(this.dni!=dni)){
return false;
7
} else
return true;
}
@Override
public int compareTo(Object t) {
Casa other = (Casa) t;
return this.propietario.compareTo(other.propietario);
}
@Override
public String toString() {
StringBuilder cadena = new StringBuilder("Casa: ");
cadena.append("Propietario : ").append(propietario).append("/n");
cadena.append("DNI : ").append(dni).append("/n");
cadena.append(alarma.toString()).append("/n");
for (Estancia estancia: estancias){
cadena.append(estancia.toString()).append("/n");
}
return cadena.toString();
}
}
8
h) Dado el siguiente esquema de la clase EmpresaSeguridad, implementar el código de los métodos:
anadirCasa sin permitir duplicados (una casa es igual a otra si coincide tanto el DNI y como el nombre
del propietario) [0,5 puntos]
muestraOrdenadasxPropietario que deberá mostrar por pantalla el listado de las casas ordenado
alfabéticamente por propietario [0,5 puntos]
doBackup que hará un backup del listado de casas de la empresa en un fichero binario dentro de la
carpeta “backup” del directorio actual con nombre “casas.bin”. [1,5 puntos]
public class EmpresaSeguridad {
private static final String DIRECTORIO = "backup";
private ArrayList<Casa> lcasas;
public EmpresaSeguridad(){ lcasas = new ArrayList<>();}
public boolean anadirCasa(Casa c){…}
public void muestraOrdenadasxPropietario(){ …}
public boolean doBackup(){ … }
}
POSIBLE SOLUCION:
public boolean anadirCasa(Casa c) {
boolean sePuede = false;
if (!lcasas.contains(c)){
lcasas.add(c);
sePuede=true;
}
return sePuede;
}
public void muestraOrdenadasxPropietario() {
Collections.sort(lcasas);
muestraCasas();
}
private void muestraCasas() {
for (Casa casa : lcasas) {
System.out.println(casa.toString());
}
}
public boolean doBackup() {
boolean sePuede = false;
String ruta = DIRECTORIO + System.getProperty("file.separator") +
NOMBREARCHIVO;
if (!lcasas.isEmpty()) {
FileOutputStream out;
ObjectOutputStream so;
try {
out = new FileOutputStream(ruta);
so = new ObjectOutputStream(out);
so.writeObject(lcasas);
so.close();
out.close();
sePuede = true;
} catch (IOException ex) {
}
}
return sePuede;
}
}
9
