RSS

Archivo de la categoría: Deberes

Soluciones – Assertions

Solución Ejercicio 1:

Creamos la clase Assert_Identificador.java

public class Assert_Identificador
{
        //Código Anterior a la J2SE 1.4
        //assert como identificador.
	public static void main(String[] args)
	{
		boolean assert;
		assert = Integer.parseInt(args[0]) % 5 == 0;
                if (assert) {
			System.out.println("Correcto");
		}
		else{
			System.out.println("No Correcto");
		}
	}
}

Compilamos normalmente y observamos el error:

Compilamos ahora indicando la versión 1.3 y observamos los warnings:

Ejecutamos:


Solución Ejercicio 2: 

Creamos la clase Assert_PalabraClave.java.

Definimos un constructor con la longitud del array de edades como parámetro.

Creamos un método público setEdad(int pos, int valor) para dar valores a las posiciones del array.
En este método público setEdad, validamos los argumentos lanzando excepciones si no son correctos. Quitaremos estas comprobaciones para provocar que salte la assertion posteriormente.

Creamos el método privado mediaEdades() que calcula la media e incluye la assertion que supone que la media siempre será >0.

public class Assert_PalabraClave{
    private int[] edades;

    public Assert_PalabraClave (int tam){
       edades = new int[tam];
    }

    public void setEdad(int i, int valor){
    /* En un método público no podemos usar assertions para comprobar los
       argumentos, se deben lanzar excepctions si no son válidos. Comentar
       los ifs y exceptions para dejar solo this.edades[i] = valor y
       poder poner en el main un valor negativo que haga saltar
       la assertion en mediaEdades. */

        if (iedades.length-1){
            throw new IllegalArgumentException("\nPosicion: " + i + " fuera de rango del array");
        }
        else if (valor < 0){
            throw new IllegalArgumentException("\nValor: " + valor + " menor de 0");
        }
        else{
    	    this.edades[i] = valor;
        }
    }

    private float mediaEdades(){
        int suma = 0;
        float media = 0;
        int i;
        for (i=0; i 0): "La media no es mayor que cero, es: " + media;
        return media;
    }

    public static void main (String[] args)
    {
          Assert_PalabraClave apc = new Assert_PalabraClave(5);
          apc.setEdad(0, 10);
          apc.setEdad(1, 3);
          apc.setEdad(2, 4);
          apc.setEdad(3, 7);
          apc.setEdad(4, 23);
          //apc.setEdad(4, -100); //para provocar excepción por valor menor de cero.
          //apc.setEdad(5, 39); //para provocar excepción por posición fuera de rango.

	  System.out.println("La media de edad es: " + apc.mediaEdades());

    }
Compilamos con -source 1.3 para observar el error:
Compilarmos normalmente y ejecutamos habilitando assertions:
Modificamos el código fuente para hacer saltar la assertion, compilamos y ejecutamos:

Solución Ejercicio 3:
En el constructor no se puede utilizar un assertion para comprobar los argumentos, ya que es público y esencial que al construirse el objeto se garantice que sus atributos tengan valores válidos. Modificar con excepciones.

Los asserts en los métodos públicos subir(int personas) y bajar(int personas) son correctos ya que no están comprobando los valores del argumento personas, sino el estado final de los atributos del objeto bus.

El assert que comprueba los argumentos pasados en la línea de comandos al programa también es un uso inapropiado. Modificar con excepciones.

Solución Ejercicio 4:

Escribimos un switch sencillo que según el entero nos imprima el día de la semana que le correspondería.

public class AssertSwitch{

  public static void mostrarDiaSemana(int dia)
  {
       switch(dia){
           case 1: System.out.println("Lunes");
           break;

           case 2: System.out.println("Martes");
           break;

           case 3: System.out.println("Miercoles");
           break;

	   case 4: System.out.println("Jueves");
           break;

	   case 5: System.out.println("Viernes");
           break;

           case 6: System.out.println("Sabado");
           break;

	   case 7: System.out.println("Domingo");
           break;

	   default:
		assert(false): "Int Dia pasado: " + dia;
        }
    }

    public static void main (String[] args){
        mostrarDiaSemana(3);
        mostrarDiaSemana(9); //Se supone que este valor nunca se daria
    }
}


Anuncios
 
1 comentario

Publicado por en 23 marzo, 2012 en Deberes

 

Etiquetas: , , , , ,

Deberes – Assertions

Algunos ejercicios para practicar Assertions:

  • Ejercicio 1: 

Crear una clase Assert_Identificador.java que utilice assert como identificador y que imprima “Correcto” si el argumento pasado en la línea de comandos es divisible por 5 y “No Correcto” en caso contrario.

Compilar normalmente para observar el fallo.
Compilar y ejecutar para que tome el código antiguo sin problemas.

  • Ejercicio 2: 

Crear una clase Assert_PalabraClave.java que tenga como atributo un array de enteros llamado edades y crear un método privado mediaEdades que devuelva la medida de las edades en el array y se asegure con una assertion que la media será siempre > 0.

Compilar indicando -source 1.3 para observar el fallo.
Compilar normalmente y ejecutar habilitando assertions.
Introducir valores incorrectos para provocar un AssertionError

  • Ejercicio 3:

Corregir la siguiente clase para que todos los assertions estén usados apropiadamente:

public class Bus {
    private int capacidad;
    private int asientosDisponibles;
    private int asientosOcupados;

    //Constructor para elegir capacidad y asientos iniciales ocupados.
    public Bus(int capacidad, int asientosOcupados){
       assert(capacidad>0);
       assert(asientosOcupados<capacidad);
       this.capacidad = capacidad;
       this.asientosDisponibles = this.capacidad - asientosOcupados;
       this.asientosOcupados = asientosOcupados;
    }

   public void subir(int personas)
    {
        try{comprobarPlazasDisponibles(personas);
        }catch(IllegalArgumentException e){
             System.out.println(e.getMessage());
             personas = this.asientosDisponibles;
        }
        this.asientosDisponibles = this.asientosDisponibles - personas;
        this.asientosOcupados = this.asientosOcupados + personas;
        assert(this.capacidad == this.asientosDisponibles + this.asientosOcupados);
    }

    private void comprobarPlazasDisponibles (int personas) throws IllegalArgumentException{
      if (personas > this.asientosDisponibles){
          throw new IllegalArgumentException("No hay asientos para " + personas + " personas");
      }
    }

    public void bajar(int personas)
    {
        try{ comprobarPlazasOcupadas(personas); //Llama a método privado.
        }catch(IllegalArgumentException e){
            System.out.println(e.getMessage());
            personas = this.asientosOcupados;
        }
    this.asientosDisponibles = this.asientosDisponibles + personas;
        this.asientosOcupados = this.asientosOcupados - personas;
        assert(this.capacidad == this.asientosDisponibles + this.asientosOcupados);
    }

    private void comprobarPlazasOcupadas (int personas) throws IllegalArgumentException{
      if(this.asientosOcupados < personas){
        throw new IllegalArgumentException("No hay " + personas + " personas ocupando asientos");
      }
    }

    public void mostrar()
    {    System.out.println("Capacidad: " + this.capacidad + ".\n" +
                "Ocupados: " + this.asientosOcupados + ".\n" +
	        "Disponibles: " + this.asientosDisponibles + ".\n");
    }

    public static void main (String [] args)
    {
     assert(Integer.parseInt(args[0])>0 && Integer.parseInt(args[1])>0);
     Bus b = new Bus(Integer.parseInt(args[0]), Integer.parseInt(args[1]));     b.mostrar();

    System.out.println("Suben 6");  b.subir(6);  b.mostrar();
    System.out.println("Bajan 3");  b.bajar(3);  b.mostrar();
    System.out.println("Sube 1");   b.subir(1);  b.mostrar();
    System.out.println("Bajan 42"); b.bajar(42); b.mostrar();
    }
}

  • Ejercicio4:

Escribir un bloque switch en el que usemos una assertion para comprobar un caso que no debe producirse.

Soluciones en la siguiente entrada para no alargar mucho el post.

 
Deja un comentario

Publicado por en 22 marzo, 2012 en Deberes

 

Etiquetas: , , , , ,

Solución – Deberes Orientación Objetos (II)

Ejercicio 1:

Hemos creado la clase Producto:

public class Producto {
    //Atributos privados.
    private int idProducto;
    private String nombreProducto;
    private boolean disponible;
    private float precio;

    //Métodos getters y setters.
    public int getIdProducto() {
        return idProducto;
    }

    public void setIdProducto(int idProducto) {
        this.idProducto = idProducto;
    }

    public String getNombreProducto() {
        return nombreProducto;
    }

    public void setNombreProducto(String nombreProducto) {
        this.nombreProducto = nombreProducto;
    }

    public boolean isDisponible() {
        return disponible;
    }

    public void setDisponible(boolean disponible) {
        this.disponible = disponible;
    }

    public float getPrecio() {
        return precio;
    }

    public void setPrecio(float precio) {
        this.precio = precio;
    }

    //Constructor por defecto.
    public Producto()
    {
         idProducto = -1;
         nombreProducto = "ProductoxDefecto";
         disponible = false;
         precio = 0.0f;
    }

    //Constructor con parámetros.
    public Producto(int idProducto, String nombreProducto, boolean disponible, float precio){
         this.idProducto = idProducto;
         this.nombreProducto = nombreProducto;
         this.disponible = disponible;
         this.precio = precio;
    }

    //Procedimiento mostrar()
    public void mostrar(){
         System.out.println("Producto: " + idProducto + "-" + nombreProducto + "\n Disponible: "
                             + disponible + "\n Precio: " + precio);
    }

    //Procedimiento rebajarPrecio(float f)
    public void rebajarPrecio(float r){
         if (precio > r) {
             precio = precio - r;
         }
    }
}

Y las subclases que se indicaban en el diagrama:

La clase DiscoDuro:

public class DiscoDuro extends Producto {
    //Atributos privados.
    private String idHd;
    private String marca;
    private String capacidad;

    //Getters y Setters.
    public String getIdHd() {
        return idHd;
    }

    public void setIdHd(String idHd) {
        this.idHd = idHd;
    }

    public String getMarca() {
        return marca;
    }

    public void setMarca(String marca) {
        this.marca = marca;
    }

    public String getCapacidad() {
        return capacidad;
    }

    public void setCapacidad(String capacidad) {
        this.capacidad = capacidad;
    }

    //Constructor por defecto.
    public DiscoDuro(){
        super();
        idHd = "-1";
        marca = "HDxDefecto";
        capacidad = "OTB";
    }

    //Constructor con parámetros.
    public DiscoDuro(int idProducto, String nombreProducto, boolean disponible, float precio,
                     String idHd, String marca, String capacidad){
        super(idProducto, nombreProducto, disponible, precio);
        this.idHd = idHd;
        this.marca = marca;
        this.capacidad = capacidad;
    }

    //Procedimiento mostrar()
    public void mostrar(){
        System.out.println("Disco Duro: " + idHd +
                           " Marca: " + marca + " Capacidad : " + capacidad +
                           "\n Disponible: " + this.isDisponible() + "\n Precio: " + this.getPrecio());
    }
}

La clase Mp3:

public class Mp3 extends Producto {
    //Atributos privados.
    private String idMp3;
    private String marca;

    //Getters y Setters.
    public String getIdMp3() {
        return idMp3;
    }

    public void setIdMp3(String idMp3) {
        this.idMp3 = idMp3;
    }

    public String getMarca() {
        return marca;
    }

    public void setMarca(String marca) {
        this.marca = marca;
    }

    //Constructor por defecto.
    public Mp3(){
        super();
        idMp3 = "-1";
        marca = "Mp3xDefecto";
    }

    //Constructor con parámetros.
    public Mp3(int idProducto, String nombreProducto, boolean disponible,
                float precio, String idMp3, String marca){
        super(idProducto, nombreProducto, disponible, precio);
        this.idMp3 = idMp3;
        this.marca = marca;
    }

    //Procedimiento mostrar()
    public void mostrar(){
        System.out.println("Mp3: " + idMp3 + " Marca: " + marca
                           + "\n Disponible: " + this.isDisponible()
                           + "\n Precio: " + this.getPrecio());
    }
}

La clase Ordenador:

public class Ordenador extends Producto {
    //Atributos privados.
    private String idOrdenador;
    private String sistemaOperativo;
    private String velocidad;
    private String procesador;

    //Getters y Setters.
    public String getIdOrdenador() {
        return idOrdenador;
    }

    public void setIdOrdenador(String idOrdenador) {
        this.idOrdenador = idOrdenador;
    }

    public String getSistemaOperativo() {
        return sistemaOperativo;
    }

    public void setSistemaOperativo(String sistemaOperativo) {
        this.sistemaOperativo = sistemaOperativo;
    }

    public String getVelocidad() {
        return velocidad;
    }

    public void setVelocidad(String velocidad) {
        this.velocidad = velocidad;
    }

    public String getProcesador() {
        return procesador;
    }

    public void setProcesador(String procesador) {
        this.procesador = procesador;
    }

    //Constructor por defecto.
    public Ordenador(){
        super();
        idOrdenador = "-1";
        sistemaOperativo = "OSxDefecto";
        velocidad = "0 Mhz";
        procesador ="Intel 0";
    }

    //Constructor con parámetros.
    public Ordenador(int idProducto, String nombreProducto, boolean disponible
                     , float precio, String idOrdenador, String sistemaOperativo,
                     String velocidad, String procesador){
        super(idProducto, nombreProducto, disponible, precio);
        this.idOrdenador = idOrdenador;
        this.procesador = procesador;
        this.velocidad = velocidad;
        this.sistemaOperativo = sistemaOperativo;
    }

    //Procedimiento mostrar()
    public void mostrar(){
        System.out.println("Ordenador: " + idOrdenador +
                           "\n Procesador: " + procesador +
                           "\n Velocidad: "  + velocidad +
                           "\n SistemaOperativo: " + sistemaOperativo +
                           "\n Disponible: " + this.isDisponible() +
                           "\n Precio: " + this.getPrecio());
    }
}

Veamos la clase principal:

Tenemos al principio un procedimiento estático cartel que está sobrecargado y nos devuelve un mensaje dependiendo del tipo del parámetro de entrada, Producto, Ordenador, Mp3 o DiscoDuro.
Se harán varias llamadas en el procedimiento main.

En el procedimiento main se comienza instanciando varios objetos.
Veamos si son correctas.

public class MainProducto {

  public static void cartel(Producto p){
    System.out.println("¡¡Los mejores productos!!");
  }

  public static void cartel(Ordenador o){
    System.out.println("Oferta HP 620 T4500 - solo 378€");
  }

  public static void cartel(Mp3 m){
    System.out.println("Oferta MP3 Creative Zen 8GB 80.20€");
  }

  public static void cartel(DiscoDuro d){
    System.out.println("Oferta Western Digital 1 Tera 45.30€");
  }

  public static void main(String[] args) {
      Producto p1 = new Ordenador();  //Correcto. El padre está contenido en el hijo.
      //Ordenador o1 = new Producto();  Incorrecto. El hijo no está contenido en el padre.
      //Mp3 m1 = new Producto();        Incorrecto. El hijo no está contenido en el padre.
      //Ordenador o2 = new DiscoDuro(); Incorrecto. Son hijos, no tienen nada que ver.
      Producto p2 = new DiscoDuro();  //Correcto. El padre está contenido en el hijo.
      Producto p3 = new Mp3();        //Correcto. El padre está contenido en el hijo.

      p1.mostrar(); //Llama a mostrar de Ordenador
      p2.mostrar(); //Llama a mostrar de DiscoDuro
      p3.mostrar(); //Llama a mostrar de Mp3
      //Importa el tipo en tiempo de ejecución.

      cartel(p1); //Llama a cartel de parámetro Producto.
      cartel(p2); //Llama a cartel de parámetro Producto.
      cartel(p3); //Llama a cartel de parámetro Producto.
      //En la sobrecarga importa el tipo en tiempo de compilación.
  }

}

Compilamos las clases y ejecutamos:

Ejercicio 2:

Hemos creado un vector de tamaño 5 y hemos añadido objetos Producto, Ordenador, Mp3 y DiscoDuro.
Recorremos el vector y llamamos a las funciones rebajarPrecio() y mostrar().

public class MainProducto2 {

    public static void main(String[] args) {
        //Declaramos un array de Producto.
        Producto[] listap = new Producto [5];

        //Instanciamos diferentes objetos.
        Producto p1 = new Producto(100, "USB", true, 50f);

        Ordenador o1 = new Ordenador(200, "Ordenador VAIO", true, 450.30f,
                                     "VPC", "SonyVAIO", "500 Mhz", "Windows7");

        Mp3 m1 = new Mp3(300, "Mp3 Zen", false, 80.2f, "Zen 8GB", "Zen Creative 8GB" );

        Ordenador o2 = new Ordenador(300, "Ordenador HD", true, 500f, "HD",
                                     "HD 244", "233 Mhz", "Windows 2000");

        DiscoDuro d1 = new DiscoDuro(400, "Western Digital", true, 80f, "WD", "WD 1TB", "1TB");

        //Los añadimos a la lista de Producto.
        listap[0] = p1;
        listap[1] = o1;
        listap[2] = m1;
        listap[3] = o2;
        listap[4] = d1;

        System.out.println("Lista de los productos con la rebaja aplicada: \n");
        //Recorremos la lista.
        //Por cada elemento rebajamos su precio y llamamos al metodo mostrar()
        for (int i=0; i<listap.length; i++){
            listap[i].rebajarPrecio(10.50f);
            listap[i].mostrar();
            System.out.println();
        }
    }

}

Compilamos y ejecutamos:

Si te gusta esta entrada, vótala en Bitácoras.com votar

¿Cómo ves esta entrada o el blog? Deja un comentario!

 
Deja un comentario

Publicado por en 12 julio, 2011 en Deberes

 

Etiquetas: , , , , , ,

Deberes – Orientación a objetos (II)

En Orientación a objetos (II) hablamos del Polimorfismo, de las colecciones hetereogéneas y de la Sobrecarga de métodos.

Vamos a practicar y a resolver ejercicios relacionados con estos temas.

  • Ejercicio 1: Crear las siguientes clases.

Realizar constructores por defecto y constructor con parámetros.
Sobrescribir el método mostrar() en las subclases para que muestren sus atributos específicos.
Razonar qué instrucciones serían correctas y cuales serían los resultados en la siguiente clase principal. Comprobar ejecutando.

public class MainProducto {

  public static void cartel(Producto p){
    System.out.println("¡¡Los mejores productos!!");
  }

  public static void cartel(Ordenador o){
    System.out.println("Oferta HP 620 T4500 - solo 378€");
  }

  public static void cartel(Mp3 m){
    System.out.println("Oferta MP3 Creative Zen 8GB 80.20€");
  }

  public static void cartel(DiscoDuro d){
    System.out.println("Oferta Western Digital 1 Tera 45.30€");
  }

  public static void main(String[] args) {
      Producto p1 = new Ordenador();
      Ordenador o1 = new Producto();
      Mp3 m1 = new Producto();
      Ordenador o2 = new DiscoDuro();
      Producto p2 = new DiscoDuro();
      Producto p3 = new Mp3();

      p1.mostrar();
      p2.mostrar();
      p3.mostrar();

      cartel(p1);
      cartel(p2);
      cartel(p3);

}

}
  • Ejercicio 2: Crear una clase principal que cree varios objetos de las clases anteriores, tanto de Producto como de DiscoDuro, MP3 y Ordenador. Crear un array de Producto para guardarlos. Rebajar el precio de todos los productos en 10.50 y mostrar el resultado.

Si te gusta esta entrada, vótala en Bitácoras.com votar

¿Cómo ves esta entrada o el blog? Deja un comentario!

 
1 comentario

Publicado por en 29 junio, 2011 en Deberes

 

Etiquetas: , , , , , ,

Solucion – Deberes Orientacion Objetos (I)

Pongo la solución a los ejercicios anteriores en esta nueva entrada para no hacer excesivamente larga la anterior.

Ejercicio 1: Veamos las clases y qué debemos cambiar.

La clase Concurso tiene sus atributos públicos y de esta forma se puede acceder a ellos directamente en la clase mainConcurso e incluso darles valores incorrectos a los atributos.

Deberíamos hacer estos atributos privados y proveer métodos getters y setters que tengan en cuenta las condiciones que vemos para los atributos en el constructor.

En la clase mainConcurso se deben usar los métodos getters y setters de la clase Concurso.

Modificaciones clase Concurso:

import java.util.*;
import java.text.*;
public class Concurso{

    //1. Ponemos privados los atributos
     private int codConcurso;
     private int codOrgano;
     private String titulo;
     private int tipo;
     private Date fechaResolucion;

    //2. Creamos métodos getters y setters para los atributos.
     public void setCodConcurso(int codConcurso){
         if(codConcurso>0){
             this.codConcurso = codConcurso;
         }
     }

     public int getCodConcurso(){
         return codConcurso;
     }

     public void setCodOrgano(int codOrgano){
         this.codOrgano = codOrgano;
     }
     public int getCodOrgano(){
         return codOrgano;
     }

     public void setTitulo(String titulo){
         this.titulo = titulo;
     }
     public String getTitulo(){
         return titulo;
     }

     public void setTipo(int tipo){
        if(tipo>0 && tipo<4){
            this.tipo = tipo;
        }
        else {
            System.out.println("Fecha incorrecta");
        }
    }
    public int getTipo(){
       return tipo;
    }

    public void setFechaResolucion(String fechaResolucion){
       DateFormat df = new SimpleDateFormat("dd/MM/yyyy")<wbr>;
       try {
           this.fechaResolucion = df.parse(fechaResolucion);
       }
       catch (ParseException e){
           System.out.println("Fecha incorrecta");
       }
    }

 //Aunque se guarde internamente como Date para los que
 //usen la clase vamos a devolver un string formateado.
   public String getFechaResolucion(){
       SimpleDateFormat sdf = new SimpleDateFormat ("dd/MM/yyyy");
       String fecha = sdf.format(fechaResolucion);
       return fecha;
  }

 public Concurso(int codConcurso, int codOrgano, String titulo, int tipo, String fechaResolucion){
     if (codConcurso > 0){
         this.codConcurso = codConcurso;
     }
     else
     {
         this.codConcurso = -1;
     }

     this.codOrgano = codOrgano;
     this.titulo = titulo;

     if (tipo>0 && tipo <4)
     {  this.tipo = tipo;}
     else
     {  this.tipo = -1; }

     DateFormat df = new SimpleDateFormat("dd/MM/yyyy")<wbr>;
     try {
         this.fechaResolucion = df.parse(fechaResolucion);
     }
     catch (ParseException e){
         e.printStackTrace();
     }
 }

Modificamos la clase principal MainConcurso:

public class mainConcurso{

    public static void main(String[] args) {

    Concurso c = new Concurso(100, 105082, "Adjudicación suministro licencias SW.",1, "20/06/2011");

    //Modificamos los atributos con setters.
    c.setCodConcurso(-199);
    c.setTipo(5);

    //Para mostrar los datos utilizamos los getters.
    //Como getFechaResolucion devuelve ahora un String la salida es más
    //amigable.
    System.out.println("Concurso " + c.getCodConcurso() + ": " + c.getTitulo()
+ "\n Tipo: " + c.getTipo() + " Fecha Res: " + c.getFechaResolucion());

    }
}

Ejercicio 2: Creamos la jerarquía de clases.

Primero la clase Persona:

public class Persona{
    private String codPersona;
    private String nombre;
    private int edad;
    private String telContacto;

    //Constructor
    public Persona(String codPersona, String nombre, int edad, String telContacto){
        this.codPersona = codPersona;
        this.nombre = nombre;
        this.edad = edad;
        this.telContacto = telContacto;
    }

    //Getters y Setters
    public String getCodPersona(){
        return codPersona;
    }
    public void setCodPersona(String codPersona){
        this.codPersona = codPersona;
    }
    public String getNombre(){
        return nombre;
    }
    public void setNombre(String nombre){
        this.nombre = nombre;
    }
    public int getEdad(){
        return edad;
    }
    public void setEdad(int edad){
        this.edad = edad;
    }
    public String getTelContacto(){
        return telContacto;
    }
    public void setTelContacto(String telContacto){
        this.telContacto = telContacto;
    }

    //Métodos
    public void mostrar(){
         System.out.println("Persona: " + codPersona + "-" + nombre + "\n Edad: " + edad + "\n TelContacto: " + telContacto + "\n");
    }
}

La clase Alumno:
Para poder mostrar bien el atributo asignaturas, que es un array de String, hemos creado una función AsignaturasToString que se utiliza en el método a sobrescribir mostrar().

public class Alumno extends Persona{
    private int curso;
    private String[] asignaturas;

    //Constructor
    public Alumno(String codPersona, String nombre, int edad, String telContacto,int curso, String[]asignaturas){
        super(codPersona, nombre, edad, telContacto);
        this.curso = curso;
        this.asignaturas = asignaturas;
    }

    //Getters y Setters
    public int getCurso(){
        return curso;
    }

    public void setCurso(int curso){
        this.curso = curso;
    }
    public String[] getAsignaturas(){
        return asignaturas;
    }
    public String AsignaturasToString(){
        String resultado = "Asignaturas: ";
        for (int i=0; i<asignaturas.length; i ++)
        {
             if (i == 0){
                 resultado = resultado + asignaturas[i];
             }
             else {
                 resultado = resultado + ", " + asignaturas[i];
             }
        }
        return resultado;
    }

    public void setAsignaturas(String []asignaturas){
         this.asignaturas = asignaturas;
    }

    //Métodos
    public void mostrar(){
        System.out.println("Alumno: " + getNombre() + "\n Curso: " + curso + " " +  AsignaturasToString() + "\n");
    }
}

La clase Profesor:

public class Profesor extends Persona{

private float salario;
private String fecContratacion;

//Constructor
public Profesor(String codPersona, String nombre, int edad, String telContacto, float salario, String fecContratacion){
    super(codPersona, nombre, edad, telContacto);
    this.salario = salario;
    this.fecContratacion = fecContratacion;
}

//Getters y Setters
public float getSalario(){
    return salario;
}
public void setSalario(float salario){
    this.salario = salario;
}
public String getFecContratacion(){
    return fecContratacion;
}
public void setFecContratacion(String fecContratacion){
    this.fecContratacion = fecContratacion;
}

//Métodos
public void mostrar(){
    System.out.println("Profesor: " + getNombre() + "\n Salario: " + salario + "\n FecContratacion: " + fecContratacion + "\n");
}

}

Creamos una clase principal para ver los resultados:

public class MainPersonas {

public static void main(String[] args) {
    //Creamos una persona
    Persona p = new Persona("001", "Lola Gomez", 19, "600101010");

    //Creamos un alumno y lo mostramos.
    String[] asigA = {"IP1", "IP2", "IMD", "CI", "EST"};
    Alumno a = new Alumno("002", "Novatín Chiquitito", 20, "606514458", 2, asigA);
    a.mostrar();

    //Cambiamos las asignaturas del alumno y lo mostramos.
    String[] asigB = {"IP1","IP2","CI"};
    a.setAsignaturas(asigB);
    a.mostrar();

    //Creamos un profesor
    Profesor pro = new Profesor("003", "Amparo Osuna", 45, "615010250", 1500.50f, "12/03/1990" );

    //Mostramos la persona y el profesor.
    p.mostrar();
    pro.mostrar();
 }
}

Si te gusta esta entrada, vótala en Bitácoras.com votar

¿Cómo ves esta entrada o el blog? Deja un comentario!

 
1 comentario

Publicado por en 23 junio, 2011 en Deberes

 

Etiquetas: , , , , , ,

Deberes – Orientacion a Objetos (I)

En la entrada Orientación a Objetos(I)
hablamos de la encapsulación, la herencia y la sobrescritura de métodos.

Vamos a poner en práctica estos conceptos con algunos ejercicios:

  • Ejercicio1: Las siguientes clases no están aplicando la encapsulación. Modificar la clase Concurso y la clase mainConcurso para que la apliquen.
    import java.util.*;
    import java.text.*;
    public class Concurso{
        public int codConcurso;
        public int codOrgano;
        public String titulo;
        public int tipo;
        public Date fechaResolucion;

        public Concurso(int codConcurso, int codOrgano, String titulo, int tipo, String fechaResolucion){

            if (codConcurso > 0){
                this.codConcurso = codConcurso;
            }
            else
            {
                this.codConcurso = -1;
            }

            this.codOrgano = codOrgano;
            this.titulo = titulo;

            if (tipo>0 && tipo <4)
            {  this.tipo = tipo;}
            else
            {  this.tipo = -1; }

            DateFormat df = new SimpleDateFormat("dd/MM/yyyy")<wbr>;
            try {
              this.fechaResolucion = df.parse(fechaResolucion);
            }
            catch (ParseException e){
              e.printStackTrace();
            }
      }

}
 

La clase principal:

public class mainConcurso{

    public static void main(String[] args) {

    Concurso c = new Concurso(100, 105082, "Adjudicación suministro licencias SW.",1, "20/06/2011");

    c.codConcurso = -199;
    c.tipo = 5;

    System.out.println("Concurso " + c.codConcurso + ": " + c.titulo
    + "\n Tipo: " + c.tipo + " Fecha Res: " + c.fechaResolucion);

    }
}

La clase Concurso tiene un atributo fechaResolución de tipo Date.
Para más información sobre los tipos de fechas en Java, estos enlaces puede ser útiles: http://t.co/Y1XgxJL, http://t.co/RKrimEf

 

  • Ejercicio 2: Crear la clase Persona y las subclases Alumno y Profesor.La clase Persona puede tener los siguientes atributos: String codPersona, String nombre, int edad, String telContacto.

    La clase Alumno puede tener los siguientes atributos: int curso, String[] asignaturas. La clase Profesor puede tener los siguientes atributos: float salario, String fecContratacion.Sobrescribir el método void mostrar(), que se encargará de mostrar los atributos específicos de cada clase.

 
1 comentario

Publicado por en 22 junio, 2011 en Deberes

 

Etiquetas: , , , , , ,

Deberes – Arrays y Enumerados

Después del último post de estudio sobre Arrays y tipos Enumerados, vamos a realizar los siguientes ejercicios:

  • Ejercicio1: Realizar varios ejemplos de declaraciones de arrays, de tipos primitivos y de clase.
    Comprobar que no es posible indicar la dimensión de los arrays en la declaración.
    Comprobar que llamadas a métodos como length dan error de compilación.
  • Ejercicio2:
    • Crear una clase PreguntaExamen con los siguientes atributos, enunciadoPregunta de tipo String, respuestaCorrecta de tipo char y puntuacionPregunta de tipo float. Escribir un método toString() que nos devuelva el enunciado, los puntos que vale y un literal “Respuesta: “
    • Crear una clase RespuestaAlumno como un array de char. El char en la posición i será la respuesta que el alumno considera correcta para la pregunta en la posición i. Crear un constructor RespuestaAlumno(int dimension) y un método addRespuesta (char resp, int pos) para poder ir añadiendo respuestas en el array.
    • Crear una clase PrincipalExamen en la que con un array de PreguntaExamen dado y un array de respuestas de un alumno, rellenemos un array de float puntuacion, que contendrá la puntuación del alumno para cada pregunta. Sumar todas las puntuaciones del array para mostrar la nota final del alumno.
  • Ejercicio3: Declarar un tipo enumerado Semana con los valores de los días de la semana y usar este tipo de datos en una clase Cita que tenga un atributo tarea y un dia de Semana.
  • Ejercicio4: Declarar un tipo enumerado Hamburguesa que tenga los siguientes valores  (MINI, NORMAL, MAXI, LUXURY) y los atributos nombre de tipo String, precio de tipo float y peso de tipo float.
    Escribir un constructor sin argumentos y otro con argumentos.
    Escribir los métodos getters asociados a los atributos.
    Escribir una clase PrincipalHamburguesa donde utilizar el enumerado.

Ya están todos resueltos.

Para ver los ejercicios resueltos click en Leer más…

Read the rest of this entry »

 
1 comentario

Publicado por en 27 abril, 2011 en Deberes

 

Etiquetas: , , ,

 
A %d blogueros les gusta esto: