RSS

Deberes – Arrays y Enumerados

27 Abr

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…

Ejercicio1:
Vamos a escribir en un bloc de notas la clase DeclaracionArrays, con algunos ejemplos de declaraciones. Compilaremos esta vez directamente usando javac en una consola y ejecutaremos con el comando java.

public class DeclaracionArrays{
public static void main {String [] args}
int [] arrayEnteros;
char [] arrayCaracteres;
String [] arrayCadenas;
int[][] matrizEnteros;
    }
}

No se nos muestra ningún error. Modificamos para ver qué error daría si incluyeramos un tamaño a un array en la declaración.

public class DeclaracionArrays{

public static void main {String [] args}
int [15] arrayEnteros;
char [] arrayCaracteres;
String [] arrayCadenas;
int[][] matrizEnteros;
 }
}


Modificamos para ver qué error obtendríamos si hacemos una llamada al método length cuando el array aún no ha sido creado.

public class DeclaracionArrays {

public static void main(String[] args) {
int[] arrayEnteros;
char[] arrayCaracteres;
String[] arrayCadenas;
int[][] matrizEnteros;

System.out.println("Longitud : "; + arrayEnteros.length);

}

}


Ejercicio2:
Creamos la clase PreguntaExamen.

public class PreguntaExamen {

private String enunciadoPregunta;
private char respuestaCorrecta;
private float puntuacionPregunta;

public PreguntaExamen(String enunciadoPregunta, char respuestaCorrecta, float puntuacionPregunta){
this.enunciadoPregunta = enunciadoPregunta;
this.respuestaCorrecta = respuestaCorrecta;
this.puntuacionPregunta = puntuacionPregunta;
}

public String getEnunciadoPregunta(){
return enunciadoPregunta;
}
public char getRespuestaCorrecta(){
return respuestaCorrecta;
}
public float getPuntuacionPregunta(){
return puntuacionPregunta;
}

public void setEnunciadoPregunta(String enunciadoPregunta){
this.enunciadoPregunta = enunciadoPregunta;
}
public void setRespuestaCorrecta(char respuestaCorrecta){
this.respuestaCorrecta = respuestaCorrecta;
}
public void setPuntuacionPregunta(float puntuacionPregunta){
this.puntuacionPregunta = puntuacionPregunta;
}

public String toString(){
return "\nPregunta: \n" + getEnunciadoPregunta() +"\n Puntos: " + getPuntuacionPregunta() + "\n Respuesta: ";
}
}

Creamos la clase RespuestaAlumno

public class RespuestaAlumno {
private char[] respuestas;

public RespuestaAlumno(int dimension){
respuestas = new char[dimension];
}

public void addRespuesta (char r, int pos){
respuestas[pos] = r;
}

public char getRespuesta(int pos){
return respuestas[pos];
}

}

Creamos la clase PrincipalExamen.

Hemos creado primero las preguntas y las hemos añadido al array examen. Hemos creado el array para las respuestas y mediante un bucle presentamos primero la pregunta y luego pedimos por teclado la respuesta y lo vamos añadiendo en el array de respuestas. Luego recorremos el array de respuestas y si son correctas vamos escribiendo los puntos en el array puntuacion. Finalmente sumamos los puntos obtenidos.

Para leer el teclado hemos necesitado hacer uso del método read() de Java, que puede lanzar una excepción y por conflictos con el System.out.println hemos necesitado usar el método skip()… En definitiva para el ejercicio no hacía falta esto, se podría definir el array de respuestas del alumno directamente y luego ir escribiendo en el array de puntos.

import java.io.IOException;

public class PrincipalExamen {

public static void main(String[] args) throws IOException {

//Definición del examen
PreguntaExamen[] examen = new PreguntaExamen[5];
examen[0] = new PreguntaExamen("¿Cuantos tipos primitivos hay en Java? a)Seis b)Ocho c)Nueve\n", 'b', 0.5f);
examen[1] = new PreguntaExamen("Si no se quiere que un método pueda ser redefinido hay que hacerlo... a)final b)abstract c)static\n", 'a', 0.5f);
examen[2] = new PreguntaExamen("Una interfaz puede implementar a una clase? a)Si b)No c)Si es una subclase\n", 'b', 1.0f);
examen[3] = new PreguntaExamen("¿Puede declararse un tipo enumerado en un método? a)Nunca b)Siempre c)Sí, si es un método miembro\n", 'a', 2.0f);
examen[4] = new PreguntaExamen("Si no se define un constructor para una clase... a)Existe  b)No hay ninguno c)Se tiene que definir por el programador siempre\n", 'a', 1.0f);

//Se crea el array de respuestaas del alumno
RespuestaAlumno respuestasAlumno1 = new RespuestaAlumno(examen.length);

//Se escribe el examen y se espera respuesta del alumno:
for (int i = 0; i{
System.out.print(examen[i].toString());
respuestasAlumno1.addRespuesta((char)System.in.read(), i);
System.in.skip(System.in.available());
}

//Calcular puntuacion
float[] puntuacion = new float [5];
float sumaPuntos = 0;
for (int i = 0; iif (respuestasAlumno1.getRespuesta(i) == examen[i].getRespuestaCorrecta())
    {puntuacion[i] = examen[i].getPuntuacionPregunta();
    sumaPuntos = sumaPuntos + puntuacion[i];
    }
}

System.out.println("\n Puntacion Total: " + sumaPuntos);

}

}

Compilamos cada clase y ejecutamos la clase principal:

Ejercicio3:

Creamos la clase Cita declarando el tipo enumerado Semana. Se ha creado como un tipo dentro de la clase Cita. También podría haberse creado el enumerado como una clase.

public class Cita{

enum Semana{ LUNES, MARTES, MIERCOLES, JUEVES, VIERNES, SABADO, DOMINGO};

private String tarea;
private Semana dia;

public Cita(){
tarea = "Predeterminada";
dia = Semana.LUNES;
}

public Cita(String tarea, Semana dia){
this.tarea = tarea;
this.dia   = dia;
}

public String getTarea(){
return tarea;
}

public Semana getDia(){
return dia;
}

public void setTarea(String tarea){
this.tarea = tarea;
}

public void setDia(Semana dia){
this.dia = dia;
}

public String toString(){
return "Cita: \n Tarea: " + getTarea() + " Dia: " + getDia() + "\n";
}
}

Y creamos una pequeña clase principal para probar su funcionamiento:

public class PrincipalSemana{

public static void main(String[] args){

Cita citaDentista = new Cita("Revision Dentista a las 18.30.", Cita.Semana.LUNES); //Necesitamos anteponer la clase Cita
 Cita citaMaqueta = new Cita("Quedar para grabar primera canción.", Cita.Semana.JUEVES); //pq si no lo hacemos no encuentra el enum Semana.

System.out.println(citaDentista);
 System.out.println(citaMaqueta);
 }

}

Vemos el resultado de la ejecución:

Ejercicio4:

Creamos el tipo enumerado, con un constructor sin argumentos y con un constructor con argumentos.

public class PrincipalHamburguesa{

enum Hamburguesa{

MINI("Mini", 1.5f, 50.0f), //aqui usamos el constructor con parametros
NORMAL("Normal", 2.5f, 100.0f), //aqui usamos el constructor con parametros
MAXI("Maxi", 3.5f, 150.0f), //aqui usamos el constructor con parametros
LUXURY("Luxury", 5.0f, 300.0f), //aqui usamos el constructor con parametros
PREDET(); //aqui usamos el constructor por defecto

private String nombre;
private float precio;
private float peso;

Hamburguesa(){
nombre = "Normal";
precio = 2.5f;
peso = 100.0f;
}

Hamburguesa(String nombre, float precio, float peso){
this.nombre = nombre;
this.precio = precio;
this.peso = peso;
}

public String getNombre(){
return nombre;
}
public float getPrecio(){
return precio;
}
public float getPeso(){
return peso;
}
public void setNombre(String nombre){
this.nombre = nombre;
}
public void setPrecio(float precio){
this.precio = precio;
}
public void setPeso(float peso){
this.peso = peso;
}

}

public static void main (String[] args){

Hamburguesa hmini = Hamburguesa.MINI;
Hamburguesa hnormal = Hamburguesa.NORMAL;
Hamburguesa hpredet = Hamburguesa.PREDET;

System.out.println(hmini.getNombre() + "\n precio: " + hmini.getPrecio() + " peso: " + hmini.getPeso());
System.out.println(hnormal.getNombre() + "\n precio: " + hnormal.getPrecio() + " peso: " + hnormal.getPeso());
System.out.println(hpredet.getNombre() + "\n precio: " + hpredet.getPrecio() + " peso: " + hpredet.getPeso());
}

}

Al ejecutar queda así:

Anuncios
 
1 comentario

Publicado por en 27 abril, 2011 en Deberes

 

Etiquetas: , , ,

Una respuesta a “Deberes – Arrays y Enumerados

  1. Nendrel

    6 agosto, 2013 at 5:42 pm

    Un par de apuntes:

    En el ejercicio 2, en la clase PrincipalExamen no se ven bien las condiciones de los bucles. Te las pongo aquí:
    //Se escribe el examen y se espera respuesta del alumno:
    for (int i = 0; i < examen.length – 1; i++) {
    System.out.println(examen[i].toString());
    respuestasAlumno1.addRespuesta((char)System.in.read(), i);
    System.in.skip(System.in.available());
    }
    //Calcular puntuación
    float[] puntuacion = new float[5];
    float sumaPuntos = 0;
    for (int i = 0; i < examen.length – 1; i++) {
    if (respuestasAlumno1.getRespuesta(i) == examen[i].getRespuestaCorrecta()) {
    puntuacion[i] = examen[i].getPuntuacionPregunta();
    sumaPuntos = sumaPuntos + puntuacion[i];
    }
    }

    Otra cosa que veo ahí es que el array de puntuaciones no haría falta.

    Saludos!

     

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

 
A %d blogueros les gusta esto: