Prog. Ejercicios POO

De MediaWiki
Saltar a: navegación, buscar
  • A parte de los ejercicios que están puesto en el Moodle, podéis realizar los siguientes:

Ejercicio Ahorcado

  • Modifica el ejercicio del ahorcado realizado en este manual y adáptalo a lo visto en la POO.
  • Debes de aplicar los visto sobre los modificadores de acceso.
  • El usuario va a poder enviar letras con mayúsculas/minúsculas, pero la clase deberá convertirlas a mayúsculas.
  • Crearás una clase Ahorcado que ofrecerá la funcionalidad del juego. Desde dicha clase no se debe realizar ningún printf. Cuando se quiera informar de algo lo hará un método con el valor de retorno y será desde la clase que hace uso de la clase Ahorcado, la que mostrará al usuario el mensaje correspondiente.
  • Inicialmente, la palabra a adivinar será 'enviada' a la clase Ahorcado y no podrá ser modificada.
  • El usuario dispondrá de dos formas de intentar adivinar la palabra.
  • Enviando una letra
  • Enviando una frase con el formato: RESUELVO:palabra. Dicha frase (RESUELVO:) podrá ser accedida por el usuario para ser utilizada cuando quiera resolver.
  • Si el usuario resuelve la palabra o alcanza el máximo de intentos, la clase no responderá (no realizará ninguna acción) en ninguno de sus métodos. Será necesario crear un nuevo objeto de la clase Ahorcado para empezar un nuevo juego.
El número máximo de intentos puede ser accedido por el usuario para ver su valor.
  • Deberás hacer uso de la clase StringBuilder para guardar la palabra con '*'.
  • Deberás documentar la clase, sus métodos y variables/constantes que consideres necesario.
  • Simula jugar una partida desde una clase Principal.
Haz que la palabra a adivinar sea introducida por el usuario desde el teclado, así como las letras. Debes mostrar la palabra (con *) y el número de intentos durante el juego.



Posible solución juego del Ahorcado

Clase Ahorcado

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package ExerciciosPOO.aforcado;

/**
 *
 * @author clase
 */

public class Ahorcado {
    /**
     * Número de intentos máximo para adivinar la palabra
     */

   public final byte NUM_INTENTOS = 10;
   private byte numIntentos = 1;
   /**
    * Cadena con el formato RESUELVO: para intentar adivinar la palabra
    */

   public static final String CAD_RESOLVER = "RESUELVO:";
   
   private boolean adivinada = false;
   
   private String palabraAdivinar = "";
   private StringBuffer palabraMostrar = new StringBuffer();

   
   public Ahorcado(String palabra){
       setPalabraAdivinar(palabra);
   }

   public String getPalabraMostrar() {
        return palabraMostrar.toString();
   }
   private void setPalabraAdivinar(String palabraAdivinar) {
       this.palabraAdivinar = palabraAdivinar.toUpperCase().trim();
       setPalabraMostrar();
   }
   private void setPalabraMostrar(){
       palabraMostrar.append(palabraAdivinar.replaceAll("[a-zA-Z]","*"));
   }
   
   /**
    * Intenta adivinar una letra de la palabra
    * @param letra: letra a adivinar
    * @return true: si el palabra fue adivinada
    *         false: Si ya llegamos al máximo de intentos o la palabra no fue adivinada
    */

   public boolean intentar(char letra){
       letra = String.valueOf(letra).toUpperCase().charAt(0);
       if (adivinada) return adivinada; // Si ya adivinamos la palabra no permmite jugar
       if (numIntentos>NUM_INTENTOS) return false;

       for (int cont=0;cont < palabraMostrar.length();cont++){
           if (palabraAdivinar.charAt(cont)==letra){
               palabraMostrar.setCharAt(cont, letra);
           }
           
       }
       if (palabraMostrar.indexOf("*")==-1){
           adivinada = true;
       }
       numIntentos++;
       
       return adivinada;
   }
   /**
    * Intenta adivinar la palabra con el formato: @link CAD_RESOLVER
    * @param cadena: palabra a adivinar
    * @return true: si el palabra fue adivinada
    *         false: en caso de no adivinar la palabra o si ya llegamos al máximo de intentos
    */

   public boolean intentar(String cadena){
       cadena = cadena.toUpperCase();
       String palabra="";
       palabraMostrar = new StringBuffer(palabraAdivinar);  // Queremos mostrar la palabra

       if (adivinada) return adivinada; // Si ya adivinamos la palabra no permmite jugar
       if (numIntentos>NUM_INTENTOS) return false;

       if (cadena.contains(CAD_RESOLVER)){
           palabra = cadena.substring(CAD_RESOLVER.length());
           if (palabra.contains(palabraAdivinar)){
               adivinada = true;
           }
       }
       
       numIntentos++;
       return adivinada;
   }

    public byte getNumIntentos() {
        return numIntentos;
    }

 
}

Clase Principal

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package ExerciciosPOO.aforcado;

/**
 *
 * @author clase
 */

public class Principal {
   
   
    public static void main(String arg[]){
       
        // CASO 1: Intentamos averiguar la palabra con letras individuales
        Ahorcado ahorcado = new Ahorcado("palabra");
        if (ahorcado.intentar('a')){
            System.out.printf("%nIntentos:%d",ahorcado.getNumIntentos());
            System.out.println("Juego acabado");
            return;
        }
        ahorcado.intentar('p');    // no lo ponemos en un if porque sabemos la palabra
        System.out.printf("%n%s",ahorcado.getPalabraMostrar());
        ahorcado.intentar('b');    // no lo ponemos en un if porque sabemos la palabra
        System.out.printf("%n%s",ahorcado.getPalabraMostrar());
        ahorcado.intentar('l');    // no lo ponemos en un if porque sabemos la palabra
        System.out.printf("%n%s",ahorcado.getPalabraMostrar());
        if (ahorcado.intentar('r')){
            System.out.printf("%n%s",ahorcado.getPalabraMostrar());
            System.out.printf("%nIntentos:%d",ahorcado.getNumIntentos());
            System.out.println("\nJuego acabado");
        }

       
        // CASO 2: Adivinamos la palabra entera
        ahorcado = new Ahorcado("adios");
        ahorcado.intentar('s');
        System.out.printf("%n%s",ahorcado.getPalabraMostrar());
        if (ahorcado.intentar(Ahorcado.CAD_RESOLVER+"adios")){
            System.out.printf("%n%s",ahorcado.getPalabraMostrar());
            System.out.printf("%nIntentos:%d",ahorcado.getNumIntentos());
            System.out.println("\nJuego acabado");
        }
       
        // CASO 3: Fallamos la palabra entera
        ahorcado = new Ahorcado("nueva");
        ahorcado.intentar('u');
        System.out.printf("%n%s",ahorcado.getPalabraMostrar());
        if (ahorcado.intentar(Ahorcado.CAD_RESOLVER+"mueca")){
            System.out.printf("%n%s",ahorcado.getPalabraMostrar());
            System.out.printf("%nIntentos:%d",ahorcado.getNumIntentos());
            System.out.println("\nJuego acabado");
        }
        else{
            System.out.printf("%nIntentos:%d",ahorcado.getNumIntentos());
            System.out.println("\nJuego acabado");
            System.out.printf("%nLa palabra era: %s",ahorcado.getPalabraMostrar());
        }

        // CASO 4: Llegamos al máximo de intentos
        System.out.println("\nNUEVO JUEGO:");
        ahorcado = new Ahorcado("colina");
        ahorcado.intentar('u');
        ahorcado.intentar('a');
        ahorcado.intentar('e');
        ahorcado.intentar('i');
        ahorcado.intentar('o');
        ahorcado.intentar('q');
        ahorcado.intentar('r');
        ahorcado.intentar('s');
        ahorcado.intentar('u');
        ahorcado.intentar('t');
        // Llegamos al máximo. Ya no muestra mas letras
        ahorcado.intentar('l');
        System.out.printf("%n%s",ahorcado.getPalabraMostrar());
        System.out.printf("%nIntentos:%d",ahorcado.getNumIntentos());
    }
}




Ejercicio Ahorcado Modificado

  • La palabra a adivinar ya no será enviada a la clase Ahorcado.
Tendrá un conjunto de palabras en un array y será escogida una de ellas aleatoriamente.
  • En cualquier momento el jugador puede introducir la cadena 'ME RINDO' (la cual debe estar guardada en la clase Ahoracado y la va a poder referenciar) finalizando la partida.
  • Se llevará cuenta del número de partidas que lleva el usuario, tanto ganadas como perdidas, y el número de intentos 'de media' que ha tardado el usuario en adivinar las palabras.
  • Modifica la clase principal para que el usuario siga jugando partidas hasta que teclee la palabra 'EXIT'.
  • Se informará al finalizar la partida, cuantas partidas lleva jugando, cuentas ha ganado y cuantas ha perdido y en cuentos intentos de media ha adivinado las palabras.



Posible solución juego del Ahorcado

Clase Ahorcado

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package ExerciciosPOO.AhorcadoModificado;

/**
 *
 * @author clase
 */

public class Ahorcado {
    private final String[] palabras = {"CASA","NAPOLEON","TIERRA","AMIGO","PERRO"};
    private static int partidasGanadas;
    private static int partidasPerdidas;
    private static int intentosMedia;

    /**
     * Número de intentos máximo para adivinar la palabra
     */

   public final byte NUM_INTENTOS = 10;
   private byte numIntentos = 1;

   /**
    * Cadena con el formato RESUELVO: para intentar adivinar la palabra
    */

   public static final String CAD_RESOLVER = "RESUELVO:";
   /**
    * Cadena para comenzar un nuevo juego
    */

   public static final String CAD_ME_RINDO = "ME RINDO";

   private boolean adivinada = false;
   private boolean finPartida = false;  // Necesaria ya que podemos acabar la partida porque la adivina o porque falla o alcanza el nº maximo de intentos
   
   private String palabraAdivinar = "";
   private StringBuffer palabraMostrar = new StringBuffer();

   
   public Ahorcado(){
       setPalabraAdivinar();
   }

   public String getPalabraMostrar() {
        return palabraMostrar.toString();
   }
   private void setPalabraAdivinar() {
       int indice = (int)(Math.random()*(palabras.length-1));
       
       this.palabraAdivinar = palabras[indice];
       setPalabraMostrar();
   }
   private void setPalabraMostrar(){
       palabraMostrar.append(palabraAdivinar.replaceAll("[a-zA-Z]","*"));
   }
   
   private void actualizarIntentos(){
       if (adivinada){
           partidasGanadas++;
           intentosMedia = (intentosMedia==0) ? numIntentos  : (intentosMedia+numIntentos)/2;
       }
       else{
           partidasPerdidas++;
       }
   }
   
   /**
    * Intenta adivinar una letra de la palabra
    * @param letra: letra a adivinar
    * @return true: si el palabra fue adivinada
    *         false: Si ya llegamos al máximo de intentos o la palabra no fue adivinada
    */

   public boolean intentar(char letra){
       letra = String.valueOf(letra).toUpperCase().charAt(0);
       if (adivinada) return adivinada; // Si ya adivinamos la palabra no permmite jugar
       if (numIntentos>NUM_INTENTOS) {
           finPartida = true;
           actualizarIntentos();
           return false;
       }

       for (int cont=0;cont < palabraMostrar.length();cont++){
           if (palabraAdivinar.charAt(cont)==letra){
               palabraMostrar.setCharAt(cont, letra);
           }
           
       }
       numIntentos++;

       if (palabraMostrar.indexOf("*")==-1){
           adivinada = true;
           finPartida = true;
           actualizarIntentos();
       }
       
       return adivinada;
   }
   /**
    * Intenta adivinar la palabra con el formato: @link CAD_RESOLVER
    * @param cadena: palabra a adivinar
    * @return true: si el palabra fue adivinada
    *         false: en caso de no adivinar la palabra o si ya llegamos al máximo de intentos
    */

   public boolean intentar(String cadena){
       cadena = cadena.toUpperCase();
       String palabra="";
       palabraMostrar = new StringBuffer(palabraAdivinar);  // Queremos mostrar la palabra

       if (cadena.contains(CAD_ME_RINDO)){
           numIntentos = NUM_INTENTOS+1;    // No creamos una condición específica para ME RINDO
           finPartida = true;
       }

       if (adivinada) return adivinada; // Si ya adivinamos la palabra no permmite jugar
       if (numIntentos>NUM_INTENTOS) return false;

       numIntentos++;
       if (cadena.contains(CAD_RESOLVER)){
           palabra = cadena.substring(CAD_RESOLVER.length());
           if (palabra.equals(palabraAdivinar)){
               adivinada = true;
           }
           finPartida = true;
           actualizarIntentos();
       }
       
       return adivinada;
   }

    public boolean getFinPartida() {
        return finPartida;
    }

    public byte getNumIntentos() {
        return numIntentos;
    }
    public static int getPartidasGanadas() {
        return partidasGanadas;
    }

    public static int getPartidasPerdidas() {
        return partidasPerdidas;
    }

    public static int getIntentosMedia() {
        return intentosMedia;
    }

   
}

Clase Principal

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package ExerciciosPOO.AhorcadoModificado;

import java.util.Scanner;


/**
 *
 * @author clase
 */

public class Principal {
   
   
    public static void main(String arg[]){
        String entrada = "";
        Scanner sc = new Scanner(System.in);
       

        do { // Este bucle representa cada una de las partidas del ahorcado
            System.out.println("\nNUEVA PARTIDA.");
            Ahorcado ahorcado = new Ahorcado();
            do {    // Este bucle representa una partida concreta del ahorcado
                System.out.printf("%n%s",ahorcado.getPalabraMostrar());
                System.out.println("\nEscribe una letra de la palabra:");
                entrada = sc.nextLine().toUpperCase();
                System.out.printf("%nNúmero de intentos:%d",ahorcado.getNumIntentos());
                if (entrada.equals("EXIT")){
                    break;
                }

                if (entrada.length()==1){   // Estamos jugando con una letra
                    ahorcado.intentar(entrada.charAt(0));
                }
                else{                      
                    if ((entrada.contains(Ahorcado.CAD_RESOLVER)) ||
                       ((entrada.contains(Ahorcado.CAD_ME_RINDO)))){
                        ahorcado.intentar(entrada);
                    }
                    else{
                        System.out.println("\nFormato de entrada incorrecto. Vuelva a intentarlo...");
                    }
                }
            }while(!ahorcado.getFinPartida());
           
            System.out.println("\nJuego acabado");
            System.out.printf("%n%s",ahorcado.getPalabraMostrar());
            System.out.printf("%nPartidas ganadas:%d",Ahorcado.getPartidasGanadas());
            System.out.printf("%nPartidas perdidas:%d",Ahorcado.getPartidasPerdidas());
            System.out.printf("%nIntentos de media en las partidas ganadas:%d",Ahorcado.getIntentosMedia());
           
        }while(!entrada.equals("EXIT"));
       
       
       
    }
}



Ejercicio Cadena

  • Crea una clase Cadena.
Se pretende crear una clase parecida a la clase String.
Se pasará el dato a guardar en el constructor.
  • Que tenga los métodos:
  • getLongitud(): Devuelve el tamaño de la cadena.
  • getVocales(): Devuelve el número de vocales de la cadena.
  • getVocales(char vocal): Devuelve el número de veces que aparece la vocal indicada en el parámetro.
  • getConsonantes(): Devuelve el número de consonantes de la cadena.
  • getVocales(char consonante): Devuelve el número de veces que aparece la consonante indicada en el parámetro.
  • anadirCadena(String palabra): Añade a la cadena guardada la palabra enviada en el parámetro.
  • borrarCadena(): Elimina la cadena guardada.
  • setCadena(String nuevaPalabra): Método que cambia la cadena guardada.
  • convertirANumero(): Intenta convertir el contenido de la cadena a un número entero y lo devuelve.
  • reemplazarCadena(String cadBuscar,String cadReemplazar): Reemplaza en la cadena guardada la cadena indicada por cadBuscar y la reemplaza por cadReemplazar. Devuelve true en caso de que haya reemplazado alguna cadena, en caso contrario devuelve false.
  • toString(): Devuelve la cadena guardada.
  • Se deben controlar las posibles excepciones.
  • Se debe hacer uso de los métodos que ya estén definidos en la clase String.



Ejercicio Cadena Modificado

  • Hacer uso de la clase StringBuilder en vez de la clase String.




Página creada por Angel D. Fernández González