sábado, 30 de abril de 2011

Solución Exámen Final POO - 27/04/2011

 // Definición de la clase Cliente
 class Cliente{
  int numero;
  String nombre;
  String direccion;
  String telefono;
 }
 
 // Definición de la clase Producto
 class Producto{
  int codigo;
  String descripcion;
  double precio;
 }
 
 // Definición de la clase Ventas
 class Ventas{
  int factura;
  String fecha;
  // Se define el atributo cliente del tipo de la clase Cliente
  Cliente cliente;
  // Se define el atributo producto del tipo de la clase Producto
  Producto producto;
  int cantidad;
  double total;
 }
 
 // Definición de la clase ClienteEspecial. La palabra reservada extends
 // hará que la clase ClienteEspecial herede todos los atributos de la
 // clase Cliente y además se definirá un atributo propio.
 class ClienteEspecial extends Cliente{
  double MontoCredito;
 }
 
 // Definición de la clase Principal donde se tendrá el método main.
 public class ExamenFinal{
  public static void main(String[]args){
   
   // Creación del objeto cliente1 a partir de la clase 
   // ClienteEspecial.  Todos los atributos heredados de la clase
   // Cliente se pueden asignar.
   ClienteEspecial cliente1 = new ClienteEspecial();
   cliente1.numero = 1234;
   cliente1.nombre = "Fulano de Tal";
   cliente1.direccion = "Algún Lugar de Nicaragua";
   cliente1.telefono = "505-22498788";
   cliente1.MontoCredito = 1500;
   
   // Creación del objeto producto1 a partir de la clase Producto
   Producto producto1 = new Producto();
   producto1.codigo = 999;
   producto1.descripcion = "Monitor LCD 21"; 
   producto1.precio = 250;
   
   // Creación del objeto venta1 a partir de la clase Venta
   // se asigna al atributo producto el objeto producto1 y 
   // al atributo cliente el objeto cliente1
   Ventas venta1 = new Ventas();
   venta1.factura = 1;
   venta1.fecha = "27 Abril 2011";
   venta1.cliente = cliente1;
   venta1.producto = producto1;
   venta1.cantidad = 3;
   // para hacer la operación y encontrar el total se debe hacer
   // referencia al objeto interno no directamente al objeto 
   // producto1, esto porque si el producto cambia, no necesitamos
   // referenciar el programa nuevamente
   venta1.total = (venta1.cantidad * venta1.producto.precio);
   
   // La impresión se puede hacer con un método o directamente en
   // el programa principal
   System.out.println("DATOS DE LA FACTURA");
   System.out.println("-------------------");
   System.out.println("Numero de Factura   : " + venta1.factura);
   System.out.println("Fecha               : " + venta1.fecha);
   System.out.println("Nombre del cliente  : " + venta1.cliente.nombre);
   System.out.println("Nombre del producto : " + venta1.producto.descripcion);
   System.out.println("Total de la venta   : " + venta1.total);
   System.out.println("Limite del credito  : " + cliente1.MontoCredito);
  }
   
 }

martes, 19 de abril de 2011

Ejercicio de Herencia resuelto

El ejercicio fue un exámen realizado el año pasado al grupo de POO. Se los dejo como ejercicio de herencia en java.

Enunciado:

La empresa informática “IPM Tech” necesita llevar un registro de todos sus empleados que se encuentran en la oficina central, para eso ha creado un diagrama de clases que debe incluir lo siguiente:

1) Empleado

Atributos:

- nombre: tipo cadena (Debe ser nombre y apellido)
- cedula: tipo cadena
- edad : entero (Rango entre 18 y 45 años)
- casado: boolean
- salario: tipo numérico doble

Métodos:
- Constructor con y sin parámetros de entrada
- Método que permita mostrar la clasificación según la edad de acuerdo al siguiente algoritmo:
Si edad es menor o igual a 21, Principiante
Si edad es >=22 y <=35, Intermedio
Si edad es >35, Senior.-

- Imprimir los datos del empleado por pantalla (utilizar salto de línea \n para separar los atributos.

- Un método que permita aumentar el salario en un porcentaje que sería pasado como parámetro al método.

2. Programador (Especialización de Empleado). Clase que hereda de Empleado todos los atributos y métodos.

- Atributos:

- lineasDeCodigoPorHora : tipo entero

- lenguajeDominante: tipo cadena

- Metodos:

- Constructor con y sin parámetos de entrada.

SOLUCION:

Primero debe definirse la clase Empleado con los atributos señalados en el exámen, se definen los métodos con las acciones pertinentes. Posteriormente se define la clase Programador como hija de la clase Empleado, con sus atributos y métodos correspondientes. Cuando se hace referencia a la clase padre se antepone al atributo la palabra super. La palabra this sirve para referenciar el objeto actual.

/**
 * ExamnIPM.java
 */

class Empleado{
 String nombre;
 String cedula;
 int edad;
 boolean casado;
 double salario;
 
 Empleado(){
 }
 
 Empleado(String nombre, String cedula, int edad, boolean casado, double salario)  {
  this.nombre = nombre;
  this.cedula = cedula;
  this.edad = edad;
  this.casado = casado;
  this.salario = salario;
  
 }
 
 public String Clasificacion(){
  String c="";
  if (edad <= 21){
   c = "Principiante";
  }
  if ((edad >=22) & (edad <= 35)){
   c = "Intermedio";
  }
  if (edad > 35){
   c = "Senior";
  }
  return c;
 }
 
 public void ImprimirEmpleado(){
  System.out.println(this.nombre);
  System.out.println(this.cedula);
  System.out.println(this.edad);
  if (casado) {
   System.out.println("Casado");
  }
  else
  {
   System.out.println("Soltero");
  }
  System.out.println(this.salario);
 }
 
 public void AumentarSalario(double incremento){
  salario = salario * (1 + incremento);
 }
 
}

class Programador extends Empleado{
 int lineasDeCodigoPorHora;
 String lenguajeDominante; 
  
 Programador(String nombre, String cedula, int edad, boolean casado, double salario, int lineasDeCodigoPorHora, String lenguajeDominante){
 
  super.nombre = nombre;
  super.cedula = cedula;
  super.edad = edad;
  super.casado = casado;
  super.salario = salario;
  this.lineasDeCodigoPorHora = lineasDeCodigoPorHora;
  this.lenguajeDominante = lenguajeDominante;
 }  
 
 Programador(){
 } 
 
}

public class ExamnIPM {

    public static void main(String[] args){
     Empleado e = new Empleado("Orlando Arróliga","12345",17,true,2000);
     Programador p1 = new Programador("Flavio","3456",20,false,1000,123,"Visual Basic");
     p1.nombre = "Flavio";
     p1.salario = 1000;
     p1.AumentarSalario(0.25);
  p1.ImprimirEmpleado();      
    }
    
    
}

Ampliación de Clases y Objetos

Los atributos o variables en una clase pueden almacenar cualquier tipo de datos.  Los datos al definirlos pueden inilizarse con un valor, por ejemplo tomando el ejemplo del exámen:

public class Cuenta {
    // Definición de los atributos
    int numero;
    String nombre;
    double saldo = 0;
}
El saldo fue inicializado en cero, de esta forma al crear un objeto a partir de la clase Cuenta el saldo queda inicializado en cero. Esto se puede hacer también en el constructor por defecto.

Las clases también pueden contener objetos como variables. Por ejemplo vamos a crear una nueva clase Cliente para definir al cliente que pertenece una cuenta.

// Definición de la clase Cliente
public class Cliente {
    String nombre;
    String cedula;
    String direccion;
}

Ahora podremos modificar la clase Cuenta y definirla de esta manera:

// Redefinición de la clase Cuenta
public class Cuenta {
    // Definición de los atributos
    int numero;
    Cliente cliente;
    double saldo;
}
Si observamos hemos definido uno de los atributos como un objeto de la clase Cliente
llamándose cliente ( en java podemos usar el mismo nombre en mayúsculas y en minísculas y son diferentes).

Ahora podemos definir en la clase principal una cuenta de la siguiente manera:
public class CuentaBanco {
    public static void main(String[] args){
        // Creamos un objeto Cliente
        Cliente cli = new Cliente();
        cli.nombre = "Fulano de Tal";
        cli.cedula = "111-111111-11111";
        cli.direccion = "La dirección de Fulano";
        // Creamos el objeto Cuenta con el constructor
        // por defecto
        Cuenta cta = new Cuenta();
        cta.numero = 1;
        cta.saldo = 1000;
        cta.cliente = cli;
        
        // Si imprimimos el valor del nombre 
        // de la cuenta bancaria
        System.out.println("El nombre de la cuenta es: "+ cta.cliente.nombre );
    }
}

Saludos y hasta el próximo post.

Creación de Constructores en Java

Un tema que ya hemos visto en varias ocasiones es la definición de constructores en Java.  Un constructor define como construir un objeto a partir de una clase.
Por ejemplo si creamos la clase Cuenta:
// Definición de la clase cuenta
public class Cuenta {
int numero;
String nombre;
double saldo;

public void Balance()
{
System.out.println("El saldo de la cuenta No. "+ this.numero + " es " +     this.saldo);
}
}

Si revisamos la clase podemos observar que no hay definido ningún constructor, por lo que Java le define internamente un constructor por defecto. El constructor por defecto se llama utilizando la palabra new. El código siguiente muestra como se crearía el objeto c a partir de la clase Cuenta con el constructor por defecto.

public class Principal { 
public static void main(String[] args) { 
// Creación del objeto c del tipo Cuenta 
Cuenta c = new Cuenta(); 
c.Balance(); 
} 
} 

TIPOS DE CONSTRUCTORES
Cuando queremos definir un constructor a una clase colocamos la palabra public seguido del nombre de la clase, abrimos llaves y escribimos el código correspondiente.  Los constructores pueden tener parámetros y se pueden definir más de uno siempre y cuando sus parámetros sean diferentes.  Por ejemplo para la clase cuenta se podrían definir tres constructores.  CUANDO SE DEFINE UN CONSTRUCTOR CON PARAMETROS, EL CONSTRUCTOR POR DEFECTO  TIENE QUE DEFINIRSE EXPLICITAMENTE EN LA CLASE SI SE DESEA USAR.



// Definición de la clase cuenta
public class Cuenta {
int numero;
String nombre;
double saldo;

public Cuenta(){
}

public Cuenta(int numero)
{
this.numero = numero;
}
public Cuenta(int numero, String nombre) {
this.numero = numero;
this.nombre = nombre;
}
public Cuenta(int numero, String nombre, double saldo) {
this.numero = numero;
this.nombre = nombre;
this.saldo = saldo;
}

public void Balance()
{
System.out.println("El saldo de la cuenta No. "+ this.numero + " es " +     this.saldo);
}
}


En el ejemplo anterior se definieron 4 constructores para la clase Cuenta, un constructor por defecto y 3 constructores con parámetros.  Si se fija bien los parámetros son diferentes en cada constructor; el primero tiene un parámetro, el segundo tiene dos y el tercero tiene tres.  Podrían definirse más si así lo desea.

Saludos

Herencia en Java

En la última clase estudiamos el tema de la herencia en Java.  El objetivo de la herencia es permitir la creación de nuevas clases basadas en clases existentes.  Cuando heredamos de una clase existente reusamos o heredamos de esa clase los métodos y atributos, además podemos definir nuevos métodos y atributos propios de la clase nueva.
La clase ya existente es llamada superclase o clase padre.  La clase nueva que creamos a partir de la clase padre se llama subclase o clase hija.
Por ejemplo podemos pensar en una clase Empleado y definirla como
class Empleado {
String nombre;
int numEmpleado , sueldo; 

static private int contador = 0; 

Empleado(String nombre, int sueldo) {
this.nombre = nombre;
this.sueldo = sueldo;
numEmpleado = ++contador;
} 

public void aumentarSueldo(int porcentaje) {
sueldo += (int)(sueldo * aumento / 100);
} 

public String toString() {
return "Num. empleado " + numEmpleado + " Nombre: " + nombre +
" Sueldo: " + sueldo;
}
}


En el ejemplo el Empleado se caracteriza por un nombre (String) y por un número de empleado y sueldo (enteros). La clase define un constructor que asigna los valores de nombre y sueldo y calcula el número de empleado a partir de un contador (variable estática que siempre irá aumentando), y dos métodos, uno para calcular el nuevo sueldo cuando se produce un aumento de sueldo (método aumentarSueldo)  y un segundo que devuelve una representación de los datos del empleado en un String.(método toString).


Con esta representación podemos pensar en otra clase que reuna todas las características de Empleado y añada alguna propia. Por ejemplo, la clase Ejecutivo. A los objetos de esta clase se les podría aplicar todos los datos y métodos de la clase Empleado y añadir algunos, como por ejemplo el hecho de que un Ejecutivo tiene un presupuesto.


Así diríamos que la clase Ejecutivo extiende o hereda la clase Empleado. Esto en Java se hace con la clausula extends que se incorpora en la definición de la clase, de la siguiente forma:


class Ejecutivo extends Empleado {
int presupuesto;
void asignarPresupuesto(int p) {
presupuesto = p;
}
}


Con esta definición un Ejecutivo es un Empleado que además tiene algún rasgo distintivo propio. El cuerpo de la clase Ejecutivo incorpora sólo los miembros que son específicos de esta clase, pero implícitamente tiene todo lo que tiene la clase Empleado.


A Empleado se le llama clase base o superclase y a Ejecutivo clase derivada o subclase.


Los objetos de las clases derivadas se crean igual que los de la clase base y pueden acceder tanto sus datos y métodos como a los de la clase base. Por ejemplo:


Ejecutivo jefe = new Ejecutivo( "Armando Mucho", 1000);
jefe.asignarPresupuesto(1500);
jefe.aumentarSueldo(5);


Atención!: Un Ejecutivo ES un Empleado, pero lo contrario no es cierto. Si escribimos:


Empleado curri = new Empleado ( "Esteban Comex Plota" , 100) ;
curri.asignarPresupuesto(5000);  // error


se producirá un error de compilación pues en la clase Empleado no existe ningún método llamado asignarPresupuesto.

jueves, 7 de abril de 2011

Próxima Clase - Miercoles 13 de Abril

Para la próxima clase utilizaremos el programa Netbeans versión 6.5 / 6.7 para realizar los ejercicios. Vamos a finalizar con el tema de las clases y objetos y derivados.  Estaré subiendo la información para que estudien para la clase.

Saludos

Solución Exámen 2do Parcial

La evaluación para las notas se hará en base al siguiente criterio:

Actividad Valor Unitario Total
Caso de Uso (Ejercicio) 30 30
Creación los constructores de la clase Cuenta 5 10
Creación de los métodos de la clase Cuenta
10
30
Creación de Objeto Cuenta con el constructor sin parámetros (default)
10
10
Creación del Objeto Cuenta con el constructor con parámetros 10 10
Funcionalidad del programa (que ejecute) 10 10

Enunciado:


Crear una clase en java que represente una cuenta bancaria.  La cuenta debe tener como atributos el número de cuenta que será un número entero,  el titular de la cuenta que será el nombre de la persona dueña de la cuenta y su saldo (del tipo doble).
La clase deberá tener un método llamado Retiro que permita disminuir el saldo de la cuenta en un monto específico y un método Deposito que deberá aumentar la cuenta en un monto específico.
La clase deberá disponer de un constructor  por defecto y un constructor con parámetros (todos los parámetros).
Un tercer método llamado balance deberá mandar a imprimir por pantalla todos los datos de la cuenta.   Si la cuenta tiene menos de 500 deberá generarse un mensaje que diga “CUENTA POR DEBAJO DEL LIMITE PERMITIDO”.  Si la cuenta excede los  500 deberá imprimir “CUENTA CON SALDOS NORMALES”. Si la cuenta excede los 500 se incrementará el saldo un 2% en concepto de bonificación.

Solución:

Archivo : Cuenta.java

// Definición de la clase Cuenta
public class Cuenta {
    // Definición de los atributos
    int numero;
    String nombre;
    double saldo;

    // Definición del constructor con parámetros
    public Cuenta(int numero, String nombre, double saldo) {
        this.numero = numero;
        this.nombre = nombre;
        this.saldo = saldo;
    }

    // Definición del constructor por defecto (Sin parámetros)
    public Cuenta(){}

    // Definición del método Deposito el cual aumentará el saldo
    // de la cuenta.  Solo se requiere pasar un parámetos para
    // aumentar el saldo con un monto.
    public void Deposito(double monto){
        this.saldo = this.saldo + monto;
    }

    // Definición del método Retiro, el cual debe disminuir la cuenta
    // por el retiro de dinero que acabamos de hacer.
    public void Retiro(double monto){
        this.saldo = this.saldo - monto;
    }

    // El método balance solo imprime la información de la cuenta
    public void Balance()
    {
        System.out.println("INFORMACION DE LA CUENTA");
        System.out.println("------------------------");
        System.out.println("Número   :" + this.numero);
        System.out.println("Titular  :" + this.nombre);
        System.out.println("Saldo    :" + this.saldo); 
if (this.saldo < 500)
            System.out.println("CUENTA CON SALDO POR DEBAJO DEL LIMITE PERMITIDO");
        if (this.saldo > 500)
        {
            System.out.println("SE BONIFICARA CON 2% POR EXECEDER LOS 500");
            this.saldo = this.saldo + (this.saldo * 0.02);
            System.out.println("Nuevo Saldo :" + this.saldo); 
}
    }
}

Archivo : CuentaBanco.java

// Definición del programa principal
public class CuentaBanco {
    public static void main(String[] args) {
        // Crear un objeto Cuenta con el constructor por defecto
        Cuenta cuenta1 = new Cuenta();
        cuenta1.numero = 1;
        cuenta1.nombre = "Jose de la Paz";
        cuenta1.saldo = 1000;
        // La cuenta inició con un saldo de 1000, ahora vamos a hacerle
        // un retiro de 400
        cuenta1.Retiro(400);

        // La cuenta debió haber quedado con 600, podemos imprimir
        // el balance para verificar.
        cuenta1.Balance();

        //Ahora haremos un depósito a la cuenta por 350
        cuenta1.Deposito(350);

        // La cuenta deberá tener ahora 950
        cuenta1.Balance();

        // Crear un objeto Cuenta con el constructor con parámetros
        Cuenta cuenta2 = new Cuenta(2,"María Asunción", 2000);
        cuenta2.Deposito(450);
        cuenta2.Balance();
    }
}

La solución anterior está orientada a dos archivos. Se pueden generar un solo archivo como hemos acostumbrado creando un solo archivo llamado CuentaBanco.java
con todos los datos, excepto que la clase Cuenta no debería quedar como pública. Recordemos que solo puede existir en java una clase pública por archivo. La solución en todo caso quedaría así:

Archivo : CuentaBanco.java


// Definición del programa principal
public class CuentaBanco {
    public static void main(String[] args) {
        // Crear un objeto Cuenta con el constructor por defecto
        Cuenta cuenta1 = new Cuenta();
        cuenta1.numero = 1;
        cuenta1.nombre = "Jose de la Paz";
        cuenta1.saldo = 1000;
        // La cuenta inició con un saldo de 1000, ahora vamos a hacerle
        // un retiro de 400
        cuenta1.Retiro(400);

        // La cuenta debió haber quedado con 600, podemos imprimir
        // el balance para verificar.
        cuenta1.Balance();

        //Ahora haremos un depósito a la cuenta por 350
        cuenta1.Deposito(350);

        // La cuenta deberá tener ahora 950
        cuenta1.Balance();

        // Crear un objeto Cuenta con el constructor con parámetros
        Cuenta cuenta2 = new Cuenta(2,"María Asunción", 2000);
        cuenta2.Deposito(450);
        cuenta2.Balance();
    }
}

class Cuenta {
    // Definición de los atributos
    int numero;
    String nombre;
    double saldo;

    // Definición del constructor con parámetros
    public Cuenta(int numero, String nombre, double saldo) {
        this.numero = numero;
        this.nombre = nombre;
        this.saldo = saldo;
    }

    // Definición del constructor por defecto (Sin parámetros)
    public Cuenta(){}

    // Definición del método Deposito el cual aumentará el saldo
    // de la cuenta.  Solo se requiere pasar un parámetos para
    // aumentar el saldo con un monto.
    public void Deposito(double monto){
        this.saldo = this.saldo + monto;
    }

    // Definición del método Retiro, el cual debe disminuir la cuenta
    // por el retiro de dinero que acabamos de hacer.
    public void Retiro(double monto){
        this.saldo = this.saldo - monto;
    }

    // El método balance solo imprime la información de la cuenta
    public void Balance()
    {
        System.out.println("INFORMACION DE LA CUENTA");
        System.out.println("------------------------");
        System.out.println("Número   :" + this.numero);
        System.out.println("Titular  :" + this.nombre);
        System.out.println("Saldo    :" + this.saldo);
    }
}

domingo, 3 de abril de 2011

Ejercicio de Ejemplo - Clases y Objetos

Construir una clase en java que defina a un estudiante, teniendo como atributos su número de carnet, nombre y las notas correspondientes al primer parcial, segundo parcial, trabajo acumulado y exámen final.  La clase deberá tener los métodos necesarios para encontrar la nota final del estudiante basado en el cálculo usado en la UCYT (el primer parcial, el segundo parcial y el trabajo acumulado corresponden al 20% de la nota final cada uno y el exámen final el 40%).  Del mismo modo deberá tener un método que defina si el estudiante esta aprobado o reprobado.  Un tercer método deberá imprimir la información del estudiante en una caja de diálogo gráfica.   Deberá crear también una clase que contenga el método main donde se pidan los datos del estudiante de forma gráfica (utilizando la interface SWING), creando un objeto alumno y definiendo sus atributos.

SOLUCION:
Vamos a construir dos clases una llamada Notas y otra llamada Alumno.  Se pueden hacer dos archivos separados y compilarlos posteriormente.  Si los dos archivos están en el mismo directorio, java reconocerá y buscará la clase.

Definimos la clase Alumno (Alumno.java)

// Clase Alumno
import javax.swing.*;
public class Alumno {
    String carnet;
    String nombre;
    int notapp;
    int notasp;
    int notata;
    int notaef;

    public double notafinal()
    {
        double nf;
        nf = (this.notapp * 0.20) + (this.notasp * 0.20)
              + (this.notata * 0.20) + (this.notaef * 0.40);
        return nf;
    }

    public String estado()
    {
        if (this.notafinal() >= 70 )
            return "Aprobado";
        else
            return "Reprobado";
    }

    public void MostrarDatos()
    {
        String datos = "Nombre      :" + "\t" + this.nombre + "\n" +
                       "Carnet No.  :" + "\t" +  this.carnet + "\n" +
                       "Nota 1P     :" + "\t" +  this.notapp + "\n" +
                       "Nota 2P     :" + "\t" +  this.notasp + "\n" +
                       "Nota TA     :" + "\t" +  this.notata + "\n" +
                       "Nota EF     :" + "\t" +  this.notaef + "\n" +
                       "Nota Final  :" + "\t" +  this.notafinal() + "\n" +
                       "Estado      :" + "\t" +  this.estado();
        JOptionPane.showMessageDialog(null, datos);
    }
  
}

Ahora podemos definir la clase que contendrá el programa principal (Notas.java)

import javax.swing.*;
public class notas {
    public static void main(String[] args) {
        // TODO code application logic here
        Alumno a = new Alumno();
        a.carnet = JOptionPane.showInputDialog("Carnet del Estudiante: ");
        a.nombre = JOptionPane.showInputDialog("Nombre del Estudiante: ");
        a.notapp = Integer.parseInt(JOptionPane.showInputDialog("Nota del Primer Parcial: "));
        a.notasp = Integer.parseInt(JOptionPane.showInputDialog("Nota del Segundo Parcial: "));
        a.notata = Integer.parseInt(JOptionPane.showInputDialog("Nota del Trabajo Acumulado: "));
        a.notaef = Integer.parseInt(JOptionPane.showInputDialog("Nota del Examen Final: "));
        a.MostrarDatos();
    }
}




Ejercicios de Casos de Uso - Entrega el 06/04/2011

Los siguientes ejercicios deberán ser entregados el día del segundo exámen parcial de POO.  Hay tres tipos de ejercicios los cuales están asignados a diferentes estudiantes.  Al final se define que ejercicio le toca a cada quien.


Ejercicio 1.
Una empresa encargada de vender productos, desea de informatizarla, y para ello desea que el
sistema realice las siguientes funciones:
El sistema ha de permitir que los Vendedores introduzcan los productos que venden, junto con sus
precios en el sistema. Esta información se empleará para construir listados estadísticos, para que el
Director pueda consultarla. Cada mes, se generará un listado especial con agrupaciones de ventas por
meses.
El sistema, además, ha de permitir al Jefe de Recursos Humanos, dar de alta y borrar a los diferentes
vendedores que se añadan o dejen la empresa. En cualquier momento, también tendrá la opción de
consultarla. Para la realización de estas tres funcionalidades, se dispondrá de un sistema gestor  de base
de datos, encargado de traducir las peticiones del Jefe de recursos Humanos.
El Director, también podrá consultar en todo momento  toda la información referente al personal de
la empresa.

Ejercicio 2

Identificar los diferentes casos de uso de la siguiente aplicación encargada que dibujar planos para
arquitectos:
La aplicación ha de permitir que el arquitecto pueda crear un nuevo dibujo, pueda modificar un
dibujo que haya realizado, y pueda hacer uso de una serie de herramientas de dibujo.
El arquitecto, dispondrá de las opciones de grabar el dibujo actual en un archivo; cargar un dibujo
que hubiera grabado en otra ocasión; y pueda “plotear” una imagen que esté guardada en un archivo.
La opción de crear un nuevo dibujo, dispondrá de una serie de plantillas predeterminadas para
aplicar al dibujo. Tanto esta última opción, como la de modificación, carga, y salvaguarda harán uso de
un lienzo sobre el que actuarán las herramientas del programa, y el cual contendrá el dibujo en
cuestión.
La opción de plotear, cargará a una zona de memoria el dibujo, previamente almacenado en el
fichero, para procesarlo y traducirlo en instrucciones para un plotter.

Ejercicio 3

Una empresa encargada del desarrollo de software “a medida”, tiene la necesidad de disponer de la
siguiente aplicación CASE:
Los diferentes Clientes a los que se dará servicio, hablarán con los Analistas de Información para
establecer los requisitos. El sistema ha de permitir a estos Analistas dar de alta un análisis de requisitos
en los que queden establecido la funcionalidad que el Cliente desea que tenga su programa. Para esto
último, en el proceso de alta, se ha de tener la posibilidad de poder realizar una edición para introducir
en el sistema el documento con los requisitos.
Los Analistas de Sistemas de la empresa, podrán realizar consulta a estos últimos documentos, para
lo cual tendrán que editarlo. Una vez estudiados, procederán a dar de alta a los diagramas y documentos
de análisis. Para realizar los diagramas se utilizará la herramienta “Rational Rose”. Estos mismos
agentes, también realizaran el diseño funcional del sistema, utilizando la funcionalidad de edición que
ofrece el sistema.
Los Programadores, son los encargados de consultar el diseño, accediendo a la herramienta de
edición, lo traducirán al lenguaje de programación JAVA, y lo compilarán.
Por último, existe en la empresa el personal de Calidad encargada de revisar tanto la documentación
generada por los Analistas como los programas tecleados por los Programadores. Para esto, podrán
realizar consultas generales, pudiendo hacer uso tanto del módulo de edición como del compilador.
Representar mediante la técnica de “Casos de Uso”, las diferentes funcionalidades que ofrecerá el sistema, junto con los actores que la utilizan.

Asignación de Ejercicios
Ejercicio 1 :
Nery Coronado
Marcia Martínez
Hellen Miranda
Lestwin Silva


Ejercicio 2 :
Samuel Galo
Oscal Rosales
Jarvin Valle
Meyling Gutiérrez


Ejercicio 3 :
David López
Jose Luis Sánchez
Milvia Valle
Berman Urbina

Cualquier duda pueden escribirme a mi correo orlandoarroliga@hotmail.com o comentar en el post.