Hola a todos, hoy os dejo una serie de ejercicios de Java para practicar todo aquello que hemos explicado en anteriores posts, haciendo hincapié en la programación orientada a objetos.
Todos los ejercicios que proponemos están resueltos en este mismo post, intenta hacerlo por ti mismo y si te quedas atascado puedes mirar la solución. Recuerda, que no tiene por que estar igual tu solución con la del post, el objetivo es que aprendas no que me copies la solución.
Crea un proyecto en Java por ejercicio. Colocare en las soluciones algunos comentarios para que sean más fácilmente entendibles.
Acostúmbrate a usar Javadoc. Te recomiendo que uses mensajes de trazas, donde te sean necesarios. Si tienes problemas también puedes usar el depurador.
Aquí tienes todos los posts relacionados con Java:
También tenemos el curso en formato video:
Si tienes alguna duda, recuerda que puedes consultarnos escribiendo un comentario en este post o enviándonos un e-mail a administrador@discoduroderoer.es
1) Crea una clase llamada Cuenta que tendrá los siguientes atributos: titular y cantidad (puede tener decimales).
El titular será obligatorio y la cantidad es opcional. Crea dos constructores que cumpla lo anterior.
Crea sus métodos get, set y toString.
Tendrá dos métodos especiales:
- ingresar(double cantidad): se ingresa una cantidad a la cuenta, si la cantidad introducida es negativa, no se hará nada.
- retirar(double cantidad): se retira una cantidad a la cuenta, si restando la cantidad actual a la que nos pasan es negativa, la cantidad de la cuenta pasa a ser 0.
Spoiler
–Clase Cuenta
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 |
/** * Clase Cuenta * @author DiscoDurodeRoer */ public class Cuenta { //Atributos private String titular; private double cantidad; //Constructores public Cuenta(String titular) { this(titular, 0); //Sobrecarga } public Cuenta(String titular, double cantidad) { this.titular = titular; //Si la cantidad es menor que cero, lo ponemos a cero if (cantidad < 0) { this.cantidad = 0; } else { this.cantidad = cantidad; } } //Metodos public String getTitular() { return titular; } public void setTitular(String titular) { this.titular = titular; } public double getCantidad() { return cantidad; } public void setCantidad(double cantidad) { this.cantidad = cantidad; } /** * Ingresa dinero en la cuenta, * solo si es positivo la cantidad * * @param cantidad */ public void ingresar(double cantidad) { if(cantidad > 0){ this.cantidad += cantidad; } } /** * Retira una cantidad en la cuenta, si se quedara en negativo se quedaria * en cero * * @param cantidad */ public void retirar(double cantidad) { if (this.cantidad - cantidad < 0) { this.cantidad = 0; } else { this.cantidad -= cantidad; } } /** * Devuelve el estado del objeto * * @return */ @Override public String toString() { return "El titular " + titular + " tiene " + cantidad + " euros en la cuenta"; } } |
–Clase ejecutable
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
public class CuentaApp { public static void main(String[] args) { Cuenta cuenta_1 = new Cuenta("DiscoDurodeRoer"); Cuenta cuenta_2 = new Cuenta("Fernando", 300); //Ingresa dinero en las cuentas cuenta_1.ingresar(300); cuenta_2.ingresar(400); //Retiramos dinero en las cuentas cuenta_1.retirar(500); cuenta_2.retirar(100); //Muestro la informacion de las cuentas System.out.println(cuenta_1); // 0 euros System.out.println(cuenta_2); // 600 euros } } |
2) Haz una clase llamada Persona que siga las siguientes condiciones:
- Sus atributos son: nombre, edad, DNI, sexo (H hombre, M mujer), peso y altura. No queremos que se accedan directamente a ellos. Piensa que modificador de acceso es el más adecuado, también su tipo. Si quieres añadir algún atributo puedes hacerlo.
- Por defecto, todos los atributos menos el DNI serán valores por defecto según su tipo (0 números, cadena vacía para String, etc.). Sexo sera hombre por defecto, usa una constante para ello.
- Se implantaran varios constructores:
- Un constructor por defecto.
- Un constructor con el nombre, edad y sexo, el resto por defecto.
- Un constructor con todos los atributos como parámetro.
- Los métodos que se implementaran son:
- calcularIMC(): calculara si la persona esta en su peso ideal (peso en kg/(altura^2 en m)), si esta fórmula devuelve un valor menor que 20, la función devuelve un -1, si devuelve un número entre 20 y 25 (incluidos), significa que esta por debajo de su peso ideal la función devuelve un 0 y si devuelve un valor mayor que 25 significa que tiene sobrepeso, la función devuelve un 1. Te recomiendo que uses constantes para devolver estos valores.
- esMayorDeEdad(): indica si es mayor de edad, devuelve un booleano.
- comprobarSexo(char sexo): comprueba que el sexo introducido es correcto. Si no es correcto, sera H. No sera visible al exterior.
- toString(): devuelve toda la información del objeto.
- generaDNI(): genera un número aleatorio de 8 cifras, genera a partir de este su número su letra correspondiente. Este método sera invocado cuando se construya el objeto. Puedes dividir el método para que te sea más fácil. No será visible al exterior.
- Métodos set de cada parámetro, excepto de DNI.
- calcularIMC(): calculara si la persona esta en su peso ideal (peso en kg/(altura^2 en m)), si esta fórmula devuelve un valor menor que 20, la función devuelve un -1, si devuelve un número entre 20 y 25 (incluidos), significa que esta por debajo de su peso ideal la función devuelve un 0 y si devuelve un valor mayor que 25 significa que tiene sobrepeso, la función devuelve un 1. Te recomiendo que uses constantes para devolver estos valores.
Ahora, crea una clase ejecutable que haga lo siguiente:
- Pide por teclado el nombre, la edad, sexo, peso y altura.
- Crea 3 objetos de la clase anterior, el primer objeto obtendrá las anteriores variables pedidas por teclado, el segundo objeto obtendrá todos los anteriores menos el peso y la altura y el último por defecto, para este último utiliza los métodos set para darle a los atributos un valor.
- Para cada objeto, deberá comprobar si esta en su peso ideal, tiene sobrepeso o por debajo de su peso ideal con un mensaje.
- Indicar para cada objeto si es mayor de edad.
- Por último, mostrar la información de cada objeto.
Puedes usar métodos en la clase ejecutable, para que os sea mas fácil.
Spoiler
–Clase Persona
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 |
/** * Clase Persona * Contiene información de una persona * @author DiscoDurodeRoer */ public class Persona { //Constantes /** * Sexo por defecto */ private final static char SEXO_DEF = 'H'; /** * El peso de la persona esta por debajo del peso ideal */ public static final int INFRAPESO = -1; /** * El peso de la persona esta en su peso ideal */ public static final int PESO_IDEAL = 0; /** * El peso de la persona esta por encima del peso ideal */ public static final int SOBREPESO = 1; //Atributos /** * Nombre de la persona */ private String nombre; /** * Edad de la persona */ private int edad; /** * DNI de la persona, se genera al construir el objeto */ private String DNI; /** * Sexo de la persona, H hombre M mujer */ private char sexo; /** * Peso de la persona */ private double peso; /** * Altura de la persona */ private double altura; //Contructores /** * Constructor por defecto */ public Persona() { this("", 0, SEXO_DEF, 0, 0); } /** * Constructor con 3 parametroe * * @param nombre de la persona * @param edad de la persona * @param sexo de la persona */ public Persona(String nombre, int edad, char sexo) { this(nombre, edad, sexo, 0, 0); } /** * Constructor con 5 parametros * * @param nombre de la persona * @param edad de la persona * @param sexo de la persona * @param peso de la persona * @param altura de la persona */ public Persona(String nombre, int edad, char sexo, double peso, double altura) { this.nombre = nombre; this.edad = edad; this.peso = peso; this.altura = altura; generarDni(); this.sexo = sexo; comprobarSexo(); } //Métodos privados private void comprobarSexo() { //Si el sexo no es una H o una M, por defecto es H if (sexo != 'H' && sexo != 'M') { this.sexo = SEXO_DEF; } } private void generarDni() { final int divisor = 23; //Generamos un número de 8 digitos int numDNI = ((int) Math.floor(Math.random() * (100000000 - 10000000) + 10000000)); int res = numDNI - (numDNI / divisor * divisor); //Calculamos la letra del DNI char letraDNI = generaLetraDNI(res); //Pasamos el DNI a String DNI = Integer.toString(numDNI) + letraDNI; } private char generaLetraDNI(int res) { char letras[] = {'T', 'R', 'W', 'A', 'G', 'M', 'Y', 'F', 'P', 'D', 'X', 'B', 'N', 'J', 'Z', 'S', 'Q', 'V', 'H', 'L', 'C', 'K', 'E'}; return letras[res]; } //Métodos publicos /** * Modifica el nombre de la persona * * @param nombre a cambiar */ public void setNombre(String nombre) { this.nombre = nombre; } /** * Modifica la edad de la persona * * @param edad a cambiar */ public void setEdad(int edad) { this.edad = edad; } /** * Modifica el sexo de la persona, comprueba que es correcto * * @param sexo a cambiar */ public void setSexo(char sexo) { this.sexo = sexo; } /** * Modifica el peso de la persona * * @param peso a cambiar */ public void setPeso(double peso) { this.peso = peso; } /** * Modifica la altura de la persona * * @param altura a cambiar */ public void setAltura(double altura) { this.altura = altura; } /** * Calcula el indice de masa corporal * * @return codigo numerico *
* * */ public int calcularIMC() { //Calculamos el peso de la persona double pesoActual = peso / (Math.pow(altura, 2)); //Segun el peso, devuelve un codigo if (pesoActual >= 20 && pesoActual <= 25) { return PESO_IDEAL; } else if (pesoActual < 20) { return INFRAPESO; } else { return SOBREPESO; } } /** * Indica si la persona es mayor de edad * * @return true si es mayor de edad y false es menor de edad */ public boolean esMayorDeEdad() { boolean mayor = false; if (edad >= 18) { mayor = true; } return mayor; } /** * Devuelve informacion del objeto * * @return cadena con toda la informacion */ @Override public String toString() { String sexo; if (this.sexo == 'H') { sexo = "hombre"; } else { sexo = "mujer"; } return "Informacion de la persona:\n" + "Nombre: " + nombre + "\n" + "Sexo: " + sexo + "\n" + "Edad: " + edad + " años\n" + "DNI: " + DNI + "\n" + "Peso: " + peso + " kg\n" + "Altura: " + altura + " metros\n"; } } |
–Clase ejecutable con JOptionPane
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 |
import javax.swing.JOptionPane; public class PersonaApp { public static void main(String[] args) { //Introducimos los datos String nombre = JOptionPane.showInputDialog("Introduce el nombre"); String texto = JOptionPane.showInputDialog("Introduce la edad"); int edad = Integer.parseInt(texto); texto = JOptionPane.showInputDialog("Introduce el sexo"); char sexo = texto.charAt(0); texto = JOptionPane.showInputDialog("Introduce el peso"); double peso = Double.parseDouble(texto); texto = JOptionPane.showInputDialog("Introduce la altura"); double altura = Double.parseDouble(texto); //Creamos objetos con cada constructor Persona persona1 = new Persona(); Persona persona2 = new Persona(nombre, edad, sexo); Persona persona3 = new Persona(nombre, edad, sexo, peso, altura); //Los datos que no esten completos los insertamos con los metodos set persona1.setNombre("Laura"); persona1.setEdad(30); persona1.setSexo('M'); persona1.setPeso(60); persona1.setAltura(1.60); persona2.setPeso(90.5); persona2.setAltura(1.80); //Usamos metodos para realizar la misma accion para cada objeto System.out.println("Persona1"); MuestraMensajePeso(persona1); MuestraMayorDeEdad(persona1); System.out.println(persona1.toString()); System.out.println("Persona2"); MuestraMensajePeso(persona2); MuestraMayorDeEdad(persona2); System.out.println(persona2.toString()); System.out.println("Persona3"); MuestraMensajePeso(persona3); MuestraMayorDeEdad(persona3); System.out.println(persona3.toString()); } public static void MuestraMensajePeso(Persona p) { int IMC = p.calcularIMC(); switch (IMC) { case Persona.PESO_IDEAL: System.out.println("La persona esta en su peso ideal"); break; case Persona.INFRAPESO: System.out.println("La persona esta por debajo de su peso ideal"); break; case Persona.SOBREPESO: System.out.println("La persona esta por encima de su peso ideal"); break; } } public static void MuestraMayorDeEdad(Persona p) { if (p.esMayorDeEdad()) { System.out.println("La persona es mayor de edad"); } else { System.out.println("La persona no es mayor de edad"); } } } |
–Clase ejecutable con Scanner
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 |
import java.util.Locale; import java.util.Scanner; import javax.swing.JOptionPane; public class PersonaApp_Scanner { public static void main(String[] args) { Scanner sc = new Scanner(System.in); sc.useDelimiter("\n"); sc.useLocale(Locale.US); //Introducimos los datos System.out.println("Introduce el nombre"); String nombre = sc.next(); System.out.println("Introduce la edad"); int edad = sc.nextInt(); System.out.println("Introduce el sexo"); char sexo = sc.next().charAt(0); System.out.println("Introduce el peso"); double peso = sc.nextDouble(); System.out.println("Introduce la altura"); double altura = sc.nextDouble(); //Creamos objetos con cada constructor Persona persona1 = new Persona(); Persona persona2 = new Persona(nombre, edad, sexo); Persona persona3 = new Persona(nombre, edad, sexo, peso, altura); //Los datos que no esten completos los insertamos con los metodos set persona1.setNombre("Laura"); persona1.setEdad(30); persona1.setSexo('M'); persona1.setPeso(60); persona1.setAltura(1.60); persona2.setPeso(90.5); persona2.setAltura(1.80); //Usamos metodos para realizar la misma accion para cada objeto System.out.println("Persona1"); MuestraMensajePeso(persona1); MuestraMayorDeEdad(persona1); System.out.println(persona1.toString()); System.out.println("Persona2"); MuestraMensajePeso(persona2); MuestraMayorDeEdad(persona2); System.out.println(persona2.toString()); System.out.println("Persona3"); MuestraMensajePeso(persona3); MuestraMayorDeEdad(persona3); System.out.println(persona3.toString()); } public static void MuestraMensajePeso(Persona p) { int IMC = p.calcularIMC(); switch (IMC) { case Persona.PESO_IDEAL: System.out.println("La persona esta en su peso ideal"); break; case Persona.INFRAPESO: System.out.println("La persona esta por debajo de su peso ideal"); break; case Persona.SOBREPESO: System.out.println("La persona esta por encima de su peso ideal"); break; } } public static void MuestraMayorDeEdad(Persona p) { if (p.esMayorDeEdad()) { System.out.println("La persona es mayor de edad"); } else { System.out.println("La persona no es mayor de edad"); } } } |
3) Haz una clase llamada Password que siga las siguientes condiciones:
- Que tenga los atributos longitud y contraseña . Por defecto, la longitud sera de 8.
- Los constructores serán los siguiente:
- Un constructor por defecto.
- Un constructor con la longitud que nosotros le pasemos. Generara una contraseña aleatoria con esa longitud.
- Los métodos que implementa serán:
- esFuerte(): devuelve un booleano si es fuerte o no, para que sea fuerte debe tener mas de 2 mayúsculas, mas de 1 minúscula y mas de 5 números.
- generarPassword(): genera la contraseña del objeto con la longitud que tenga.
- Método get para contraseña y longitud.
- Método set para longitud.
Ahora, crea una clase clase ejecutable:
- Crea un array de Passwords con el tamaño que tu le indiques por teclado.
- Crea un bucle que cree un objeto para cada posición del array.
- Indica también por teclado la longitud de los Passwords (antes de bucle).
- Crea otro array de booleanos donde se almacene si el password del array de Password es o no fuerte (usa el bucle anterior).
- Al final, muestra la contraseña y si es o no fuerte (usa el bucle anterior). Usa este simple formato:
contraseña1 valor_booleano1
contraseña2 valor_bololeano2
…
Spoiler
–Clase Password
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 |
/** * Clase Password * * Contiene una contraseña y una longitud * * @author Fernando * @version 1.0 */ public class Password { //Constantes /** * Longitud por defecto */ private final static int LONG_DEF=8; //Atributos /** * Longitud de la contraseña */ private int longitud; /** * caracteres de la contraseña */ private String contraseña; //Metodos publicos /** * Devuelve la longitud * @return longitud de la contraseña */ public int getLongitud() { return longitud; } /** * Modifica la longitud de la contraseña * @param longitud a cambiar */ public void setLongitud(int longitud) { this.longitud = longitud; } /** * Devuelve la contraseña * @return contraseña */ public String getContraseña() { return contraseña; } /** * Genera una contraseña al azar con la longitud que este definida * @return contraseña */ public String generaPassword (){ String password=""; for (int i=0;i<longitud;i++){ //Generamos un numero aleatorio, segun este elige si añadir una minuscula, mayuscula o numero int eleccion=((int)Math.floor(Math.random()*3+1)); if (eleccion==1){ char minusculas=(char)((int)Math.floor(Math.random()*(123-97)+97)); password+=minusculas; }else{ if(eleccion==2){ char mayusculas=(char)((int)Math.floor(Math.random()*(91-65)+65)); password+=mayusculas; }else{ char numeros=(char)((int)Math.floor(Math.random()*(58-48)+48)); password+=numeros; } } } return password; } /** * Comprueba la fortaleza de la contraseña * @return */ public boolean esFuerte(){ int cuentanumeros=0; int cuentaminusculas=0; int cuentamayusculas=0; //Vamos caracter a caracter y comprobamos que tipo de caracter es for (int i=0;i<contraseña.length();i++){ if (contraseña.charAt(i)>=97 && contraseña.charAt(i)<=122){ cuentaminusculas+=1; }else{ if (contraseña.charAt(i)>=65 && contraseña.charAt(i)<=90){ cuentamayusculas+=1; }else{ cuentanumeros+=1; } } } //Si la constraseña tiene mas de 5 numeros, mas de 1 minuscula y mas de 2 mayusculas if (cuentanumeros>=5 && cuentaminusculas>=1 && cuentamayusculas>=2){ return true; }else{ return false; } } //Constructores /** * Crea una contraseña al azar */ public Password (){ this(LONG_DEF); } /** * La contraseña sera la pasada por parametro * @param longitud */ public Password (int longitud){ this.longitud=longitud; contraseña=generaPassword(); } } |
–Clase ejecutable
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
import javax.swing.JOptionPane; public class PasswordApp { public static void main(String[] args) { //Introducimos el tamaño del array y la longitud del password String texto=JOptionPane.showInputDialog("Introduce un tamaño para el array"); int tamanio=Integer.parseInt(texto); texto=JOptionPane.showInputDialog("Introduce la longitud del password"); int longitud=Integer.parseInt(texto); //Creamos los arrays Password listaPassword[]=new Password[tamanio]; boolean fortalezaPassword[]=new boolean[tamanio]; //Creamos objetos, indicamos si es fuerte y mostramos la contraseña y su fortaleza. for(int i=0;i<listaPassword.length;i++){ listaPassword[i]=new Password(longitud); fortalezaPassword[i]=listaPassword[i].esFuerte(); System.out.println(listaPassword[i].getContraseña()+" "+fortalezaPassword[i]); } } } |
4) Crearemos una supeclase llamada Electrodomestico con las siguientes características:
- Sus atributos son precio base, color, consumo energético (letras entre A y F) y peso. Indica que se podrán heredar.
- Por defecto, el color sera blanco, el consumo energético sera F, el precioBase es de 100 € y el peso de 5 kg. Usa constantes para ello.
- Los colores disponibles son blanco, negro, rojo, azul y gris. No importa si el nombre esta en mayúsculas o en minúsculas.
- Los constructores que se implementaran serán
- Un constructor por defecto.
- Un constructor con el precio y peso. El resto por defecto.
- Un constructor con todos los atributos.
- Los métodos que implementara serán:
- Métodos get de todos los atributos.
- comprobarConsumoEnergetico(char letra): comprueba que la letra es correcta, sino es correcta usara la letra por defecto. Se invocara al crear el objeto y no sera visible.
- comprobarColor(String color): comprueba que el color es correcto, sino lo es usa el color por defecto. Se invocara al crear el objeto y no sera visible.
- precioFinal(): según el consumo energético, aumentara su precio, y según su tamaño, también. Esta es la lista de precios:
| Letra | Precio |
|---|---|
| A | 100 € |
| B | 80 € |
| C | 60 € |
| D | 50 € |
| E | 30 € |
| F | 10 € |
| Tamaño | Precio |
|---|---|
| Entre 0 y 19 kg | 10 € |
| Entre 20 y 49 kg | 50 € |
| Entre 50 y 79 kg | 80 € |
| Mayor que 80 kg | 100 € |
- Su atributo es carga, ademas de los atributos heredados.
- Por defecto, la carga es de 5 kg. Usa una constante para ello.
- Los constructores que se implementaran serán:
- Un constructor por defecto.
- Un constructor con el precio y peso. El resto por defecto.
- Un constructor con la carga y el resto de atributos heredados. Recuerda que debes llamar al constructor de la clase padre.
- Los métodos que se implementara serán:
- Método get de carga.
- precioFinal():, si tiene una carga mayor de 30 kg, aumentara el precio 50 €, sino es así no se incrementara el precio. Llama al método padre y añade el código necesario. Recuerda que las condiciones que hemos visto en la clase Electrodomestico también deben afectar al precio.
Crearemos una subclase llamada Television con las siguientes características:
- Sus atributos son resolución (en pulgadas) y sintonizador TDT (booleano), ademas de los atributos heredados.
- Por defecto, la resolución sera de 20 pulgadas y el sintonizador sera false.
- Los constructores que se implementaran serán:
- Un constructor por defecto.
- Un constructor con el precio y peso. El resto por defecto.
- Un constructor con la resolución, sintonizador TDT y el resto de atributos heredados. Recuerda que debes llamar al constructor de la clase padre.
- Los métodos que se implementara serán:
- Método get de resolución y sintonizador TDT.
- precioFinal(): si tiene una resolución mayor de 40 pulgadas, se incrementara el precio un 30% y si tiene un sintonizador TDT incorporado, aumentara 50 €. Recuerda que las condiciones que hemos visto en la clase Electrodomestico también deben afectar al precio.
Ahora crea una clase ejecutable que realice lo siguiente:
- Crea un array de Electrodomesticos de 10 posiciones.
- Asigna a cada posición un objeto de las clases anteriores con los valores que desees.
- Ahora, recorre este array y ejecuta el método precioFinal().
- Deberás mostrar el precio de cada clase, es decir, el precio de todas las televisiones por un lado, el de las lavadoras por otro y la suma de los Electrodomesticos (puedes crear objetos Electrodomestico, pero recuerda que Television y Lavadora también son electrodomésticos). Recuerda el uso operador instanceof.
Por ejemplo, si tenemos un Electrodomestico con un precio final de 300, una lavadora de 200 y una televisión de 500, el resultado final sera de 1000 (300+200+500) para electrodomésticos, 200 para lavadora y 500 para televisión.
Spoiler
–Clase Electrodomestico
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 |
/** * Clase Electrodomestico * * Contiene informacion de los electrodomesticos * @author Fernando * @version 1.0 */ public class Electrodomestico { //Constantes /** * Color por defecto */ protected final static String COLOR_DEF="blanco"; /** * Consumo energetico por defecto */ protected final static char CONSUMO_ENERGETICO_DEF='F'; /** * Precio base por defecto */ protected final static double PRECIO_BASE_DEF=100; /** * Peso por defecto */ protected final static double PESO_DEF=5; //Atributos /** * El precio base del electrodomestico */ protected double precioBase; /** * Color del electrodomestico */ protected String color; /** * Indica el consumo energetico del electrodomestico */ protected char consumoEnergetico; /** * Peso del electrodomestico */ protected double peso; //Métodos privados private void comprobarColor(String color){ //Colores disponibles String colores[]={"blanco", "negro", "rojo", "azul", "gris"}; boolean encontrado=false; for(int i=0;i<colores.length && !encontrado;i++){ if(colores[i].equals(color)){ encontrado=true; } } if(encontrado){ this.color=color; }else{ this.color=COLOR_DEF; } } /** * Comprueba el consumo energetico * Solo mayusculas, si es una 'a' no lo detecta como una 'A' * @param consumoEnergetico */ public void comprobarConsumoEnergetico(char consumoEnergetico){ if(consumoEnergetico>=65 && consumoEnergetico<=70){ this.consumoEnergetico=consumoEnergetico; }else{ this.consumoEnergetico=CONSUMO_ENERGETICO_DEF; } } //Métodos publicos /** * Devuelve el precio base del electrodomestico * @return precio base del electrodomestico */ public double getPrecioBase() { return precioBase; } /** * Devuelve el color del electrodomestico * @return color del elesctrodomestico */ public String getColor() { return color; } /** * Devuelve el consumo energetico del electrodomestico * @return consumo energetico del electrodomestico */ public char getConsumoEnergetico() { return consumoEnergetico; } /** * Devuelve el peso del electrodomestico * @return peso del electrodomestico */ public double getPeso() { return peso; } /** * Precio final del electrodomestico * @return precio final del electrodomestico */ public double precioFinal(){ double plus=0; switch(consumoEnergetico){ case 'A': plus+=100; break; case 'B': plus+=80; break; case 'C': plus+=60; break; case 'D': plus+=50; break; case 'E': plus+=30; break; case 'F': plus+=10; break; } if(peso>=0 && peso<19){ plus+=10; }else if(peso>=20 && peso<49){ plus+=50; }else if(peso>=50 && peso<=79){ plus+=80; }else if(peso>=80){ plus+=100; } return precioBase+plus; } //Constructores /** * Contructor por defecto */ public Electrodomestico(){ this(PRECIO_BASE_DEF, PESO_DEF, CONSUMO_ENERGETICO_DEF, COLOR_DEF); } /** * Contructor con 2 parametros * @param precioBase del electrodomestico * @param peso del electrodomestico */ public Electrodomestico(double precioBase, double peso){ this(precioBase, peso, CONSUMO_ENERGETICO_DEF, COLOR_DEF); } /** * Constructor con 4 parametros * @param precioBase * @param peso * @param consumoEnergetico * @param color */ public Electrodomestico(double precioBase, double peso, char consumoEnergetico, String color){ this.precioBase=precioBase; this.peso=peso; comprobarConsumoEnergetico(consumoEnergetico); comprobarColor(color); } } |
–Clase Lavadora
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 |
/** * Clase Lavadora * * Contiene informacion de lavador * * @author Fernando * @version 1.0 */ public class Lavadora extends Electrodomestico{ //Constantes /** * Carga por defecto */ private final static int CARGA_DEF=5; //Atributos /** * Carga de la lavadora */ private int carga; //Métodos publicos /** * Devuelve la carga de la lavadora * @return */ public int getCarga() { return carga; } /** * Precio final de la lavadora * @return precio final de la lavadora */ public double precioFinal(){ //Invocamos el método precioFinal del método padre double plus=super.precioFinal(); //añadimos el código necesario if (carga>30){ plus+=50; } return plus; } //Constructor /** * Contructor por defecto */ public Lavadora(){ this(PRECIO_BASE_DEF, PESO_DEF, CONSUMO_ENERGETICO_DEF, COLOR_DEF, CARGA_DEF); } /** * Constructor con 2 parametros * @param precioBase * @param peso */ public Lavadora(double precioBase, double peso){ this(precioBase, peso, CONSUMO_ENERGETICO_DEF, COLOR_DEF, CARGA_DEF); } /** * Constructor con 5 parametros * @param precioBase * @param peso * @param consumoEnergetico * @param color * @param carga */ public Lavadora(double precioBase, double peso, char consumoEnergetico, String color, int carga){ super(precioBase,peso, consumoEnergetico,color); this.carga=carga; } } |
–Clase Television
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 |
/** * Clase Television * * Contiene informacion de una television * * @author Fernando * @version 1.0 */ public class Television extends Electrodomestico{ //Constantes /** * Resolucion por defecto */ private final static int RESOLUCION_DEF=20; //Atributos /** * Resolucion del televisor */ private int resolucion; /** * Indica si tiene o no sintonizadorTDT */ private boolean sintonizadorTDT; //Métodos publicos /** * Precio final de la television * @return precio final de la television */ public double precioFinal(){ //Invocamos el método precioFinal del método padre double plus=super.precioFinal(); //Añadimos el codigo necesario if (resolucion>40){ plus+=precioBase*0.3; } if (sintonizadorTDT){ plus+=50; } return plus; } //Constructor /** * Constructor por defecto */ public Television(){ this(PRECIO_BASE_DEF, PESO_DEF, CONSUMO_ENERGETICO_DEF, COLOR_DEF, RESOLUCION_DEF, false); } /** * Constructor con 2 parametros * @param precioBase * @param peso */ public Television(double precioBase, double peso){ this(precioBase, peso, CONSUMO_ENERGETICO_DEF, COLOR_DEF, RESOLUCION_DEF, false); } /** * Contructor con 6 parametros * @param precioBase * @param peso * @param consumoEnergetico * @param color * @param resolucion * @param sintonizadorTDT */ public Television(double precioBase, double peso, char consumoEnergetico, String color, int resolucion, boolean sintonizadorTDT){ super(precioBase, peso, consumoEnergetico, color); this.resolucion=resolucion; this.sintonizadorTDT=sintonizadorTDT; } } |
–Clase Ejecutable
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
/** * Clase ejecutable * @author DiscoDurodeRoer */ public class ElectrodomesticosApp { public static void main(String[] args) { //Creamos un array de Electrodomesticos Electrodomestico listaElectrodomesticos[]=new Electrodomestico[10]; //Asignamos cada una de las posiciones como queramos listaElectrodomesticos[0]=new Electrodomestico(200, 60, 'C', "Verde"); listaElectrodomesticos[1]=new Lavadora(150, 30); listaElectrodomesticos[2]=new Television(500, 80, 'E', "negro", 42, false); listaElectrodomesticos[3]=new Electrodomestico(); listaElectrodomesticos[4]=new Electrodomestico(600, 20, 'D', "gris"); listaElectrodomesticos[5]=new Lavadora(300, 40, 'Z', "blanco", 40); listaElectrodomesticos[6]=new Television(250, 70); listaElectrodomesticos[7]=new Lavadora(400, 100, 'A', "verde", 15); listaElectrodomesticos[8]=new Television(200, 60, 'C', "naranja", 30, true); listaElectrodomesticos[9]=new Electrodomestico(50, 10); //Creamos las variables que usaremos para almacenar la suma de los precios double sumaElectrodomesticos=0; double sumaTelevisiones=0; double sumaLavadoras=0; //Recorremos el array invocando el metodo precioFinal for(int i=0;i<listaElectrodomesticos.length;i++){ /* * Cuando una Television o una Lavadora este en la posicion del array actual, * pasara por su clase y por la de electrodomestico, ya que una television es un electrodomestico. * Ejecutamos en cada uno su propia version del metodo precioFinal */ if(listaElectrodomesticos[i] instanceof Electrodomestico){ sumaElectrodomesticos+=listaElectrodomesticos[i].precioFinal(); } if(listaElectrodomesticos[i] instanceof Lavadora){ sumaLavadoras+=listaElectrodomesticos[i].precioFinal(); } if(listaElectrodomesticos[i] instanceof Television){ sumaTelevisiones+=listaElectrodomesticos[i].precioFinal(); } } //Mostramos los resultados System.out.println("La suma del precio de los electrodomesticos es de "+sumaElectrodomesticos); System.out.println("La suma del precio de las lavadoras es de "+sumaLavadoras); System.out.println("La suma del precio de las televisiones es de "+sumaTelevisiones); } } |
- Sus atributos son titulo, numero de temporadas, entregado, genero y creador.
- Por defecto, el numero de temporadas es de 3 temporadas y entregado false. El resto de atributos serán valores por defecto según el tipo del atributo.
- Los constructores que se implementaran serán:
- Un constructor por defecto.
- Un constructor con el titulo y creador. El resto por defecto.
- Un constructor con todos los atributos, excepto de entregado.
- Los métodos que se implementara serán:
- Métodos get de todos los atributos, excepto de entregado.
- Métodos set de todos los atributos, excepto de entregado.
- Sobrescribe los métodos toString.
Crearemos una clase Videojuego con las siguientes características:
- Sus atributos son titulo, horas estimadas, entregado, genero y compañia.
- Por defecto, las horas estimadas serán de 10 horas y entregado false. El resto de atributos serán valores por defecto según el tipo del atributo.
- Los constructores que se implementaran serán:
- Un constructor por defecto.
- Un constructor con el titulo y horas estimadas. El resto por defecto.
- Un constructor con todos los atributos, excepto de entregado.
- Los métodos que se implementara serán:
- Métodos get de todos los atributos, excepto de entregado.
- Métodos set de todos los atributos, excepto de entregado.
- Sobrescribe los métodos toString.
Como vemos, en principio, las clases anteriores no son padre-hija, pero si tienen en común, por eso vamos a hacer una interfaz llamada Entregable con los siguientes métodos:
- entregar(): cambia el atributo prestado a true.
- devolver(): cambia el atributo prestado a false.
- isEntregado(): devuelve el estado del atributo prestado.
- Método compareTo (Object a), compara las horas estimadas en los videojuegos y en las series el numero de temporadas. Como parámetro que tenga un objeto, no es necesario que implementes la interfaz Comparable. Recuerda el uso de los casting de objetos.
Implementa los anteriores métodos en las clases Videojuego y Serie. Ahora crea una aplicación ejecutable y realiza lo siguiente:
- Crea dos arrays, uno de Series y otro de Videojuegos, de 5 posiciones cada uno.
- Crea un objeto en cada posición del array, con los valores que desees, puedes usar distintos constructores.
- Entrega algunos Videojuegos y Series con el método entregar().
- Cuenta cuantos Series y Videojuegos hay entregados. Al contarlos, devuélvelos.
- Por último, indica el Videojuego tiene más horas estimadas y la serie con mas temporadas. Muestralos en pantalla con toda su información (usa el método toString()).
Spoiler
–Clase Serie
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 |
/** * Clase Serie * * Contiene informacion sobre una serie (en general) * @author DiscoDurodeRoer * */ public class Serie implements Entregable{ //Constantes /** * Numero de temporadas por defecto */ private final static int NUM_TEMPORADAS_DEF=3; /** * Constante que indica que un objeto es mayor que otro */ public final static int MAYOR=1; /** * Constante que indica que un objeto es menor que otro */ public final static int MENOR=-1; /** * Constante que indica que un objeto es igual que otro */ public final static int IGUAL=0; //Atributos /** * Titulo de la serie */ private String titulo; /** * Numero de temporadas de la serie */ private int numeroTemporadas; /** * Indica si esta entregado la serie */ private boolean entregado; /** * Genero de la serie */ private String genero; /** * Creador de la serie */ private String creador; //Métodos publicos /** * Devuelve el titulo de la serie * @return titulo de la serie */ public String getTitulo() { return titulo; } /** * Modifica el titulo de la serie * @param titulo a cambiar */ public void setTitulo(String titulo) { this.titulo = titulo; } /** * Devuelve la numeroTemporadas de la serie * @return numeroTemporadas de la serie */ public int getnumeroTemporadas() { return numeroTemporadas; } /** * Modifica la numeroTemporadas de la serie * @param numeroTemporadas a cambiar */ public void setnumeroTemporadas(int numeroTemporadas) { this.numeroTemporadas = numeroTemporadas; } /** * Devuelve el genero de la serie * @return genero de la serie */ public String getGenero() { return genero; } /** * Modifica el genero de la serie * @param genero a cambiar */ public void setGenero(String genero) { this.genero = genero; } /** * Devuelve el creador de la serie * @return creador de la serie */ public String getcreador() { return creador; } /** * Modifica el creador de la serie * @param creador a cambiar */ public void setcreador(String creador) { this.creador = creador; } /** * Cambia el estado de entregado a true */ public void entregar() { entregado=true; } /** * Cambia el estado de entregado a false */ public void devolver() { entregado=false; } /** * Indica el estado de entregado */ public boolean isEntregado() { if(entregado){ return true; } return false; } /** * Compara dos series segun su numero de temporadas * @param objeto a comparar * @return codigo numerico * * * * */ public int compareTo(Object a) { int estado=MENOR; //Hacemos un casting de objetos para usar el metodo get Serie ref=(Serie)a; if (numeroTemporadas>ref.getnumeroTemporadas()){ estado=MAYOR; }else if(numeroTemporadas==ref.getnumeroTemporadas()){ estado=IGUAL; } return estado; } /** * Muestra informacion de la Serie * @return cadena con toda la informacion de la Serie */ public String toString(){ return "Informacion de la Serie: \n" + "\tTitulo: "+titulo+"\n" + "\tNumero de temporadas: "+numeroTemporadas+"\n" + "\tGenero: "+genero+"\n" + "\tCreador: "+creador; } /** * Indica si dos Series son iguales, siendo el titulo y creador iguales * @param a Serie a comparar * @return true si son iguales y false si son distintos */ public boolean equals(Serie a){ if (titulo.equalsIgnoreCase(a.getTitulo()) && creador.equalsIgnoreCase(a.getcreador())){ return true; } return false; } //Constructor /** * Constructor por defecto */ public Serie(){ this("",NUM_TEMPORADAS_DEF, "", ""); } /** * Contructor con 2 parametros * @param titulo de la Serie * @param creador de la Serie */ public Serie(String titulo, String creador){ this(titulo,NUM_TEMPORADAS_DEF, "", creador); } /** * Constructor con 4 parametros * @param titulo de la Serie * @param numeroTemporadas de la Serie * @param genero de la Serie * @param creador de la Serie */ public Serie(String titulo, int numeroTemporadas, String genero, String creador){ this.titulo=titulo; this.numeroTemporadas=numeroTemporadas; this.genero=genero; this.creador=creador; this.entregado=false; } } |
–Clase Videojuego
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 |
/** * * Clase videojuego * * Contiene la informacion sobre un videojuego * * @author DiscoDurodeRoer */ public class Videojuego implements Entregable{ //Constantes /** * Horas estimadas por defecto */ private final static int HORAS_ESTIMADAS_DEF=100; /** * Constante que indica que un objeto es mayor que otro */ public final static int MAYOR=1; /** * Constante que indica que un objeto es menor que otro */ public final static int MENOR=-1; /** * Constante que indica que un objeto es igual que otro */ public final static int IGUAL=0; //Atributos /** * Titulo del videojuego */ private String titulo; /** * Horas estimadas del videojuego */ private int horasEstimadas; /** * Indica si esta o no entregado el videojuego */ private boolean entregado; /** * Genero del videojuego */ private String genero; /** * Compañia del videojuego */ private String compañia; //Métodos publicos /** * Devuelve el titulo del videojuego * @return titulo del videojuego */ public String getTitulo() { return titulo; } /** * Modifica el titulo del videojuego * @param titulo a cambiar */ public void setTitulo(String titulo) { this.titulo = titulo; } /** * Devuelve el numero de paginas del videojuego * @return numero de paginas del videojuego */ public int getHorasEstimadas() { return horasEstimadas; } /** * Modifica el numero de paginas del videojuego * @param horasEstimadas */ public void setHorasEstimadas(int horasEstimadas) { this.horasEstimadas = horasEstimadas; } /** * Devuelve el genero del videojuego * @return genero del videojuego */ public String getGenero() { return genero; } /** * Modifica el genero del videojuego * @param genero a cambiar */ public void setGenero(String genero) { this.genero = genero; } /** * Devuelve el compañia del videojuego * @return compañia del videojuego */ public String getcompañia() { return compañia; } /** * Modifica el compañia del videojuego * @param compañia a cambiar */ public void setcompañia(String compañia) { this.compañia = compañia; } /** * Cambia el estado de entregado a true */ @Override public void entregar() { entregado=true; } /** * Cambia el estado de entregado a false */ @Override public void devolver() { entregado=false; } /** * Indica el estado de entregado * @return */ @Override public boolean isEntregado() { if(entregado){ return true; } return false; } /** * Compara dos videojuegos segun el numero de paginas * @return codigo numerico * * * * */ @Override public int compareTo(Object a) { int estado=MENOR; //Hacemos un casting de objetos para usar el metodo get Videojuego ref=(Videojuego)a; if (horasEstimadas>ref.getHorasEstimadas()){ estado=MAYOR; }else if(horasEstimadas==ref.getHorasEstimadas()){ estado=IGUAL; } return estado; } /** * Muestra informacion del videojuego * @return cadena con toda la informacion del videojuego */ @Override public String toString(){ return "Informacion del videojuego: \n" + "\tTitulo: "+titulo+"\n" + "\tHoras estimadas: "+horasEstimadas+"\n" + "\tGenero: "+genero+"\n" + "\tcompañia: "+compañia; } /** * Indica si dos videojuegos son iguales, siendo el titulo y compañia iguales * @param a videojuego a comparar * @return true si son iguales y false si son distintos */ public boolean equals(Videojuego a){ if (titulo.equalsIgnoreCase(a.getTitulo()) && compañia.equalsIgnoreCase(a.getcompañia())){ return true; } return false; } //Constructor /** * Constructo por defecto */ public Videojuego(){ this("",HORAS_ESTIMADAS_DEF, "", ""); } /** * Constructor con 2 parametros * @param titulo del videojuego * @param compañia del videojuego */ public Videojuego(String titulo, String compañia){ this(titulo,HORAS_ESTIMADAS_DEF, "", compañia); } /** * Constructor con 4 parametros * @param titulo del videojuego * @param horasEstimadas * @param genero del videojuego * @param compañia del videojuego */ public Videojuego(String titulo, int horasEstimadas, String genero, String compañia){ this.titulo=titulo; this.horasEstimadas=horasEstimadas; this.genero=genero; this.compañia=compañia; this.entregado=false; } } |
–Interfaz Entregable
|
1 2 3 4 5 6 7 8 9 10 |
public interface Entregable { public void entregar(); public void devolver(); public boolean isEntregado(); public int compareTo(Object a); } |
–Clase ejecutable
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 |
public class EntregablesApp { public static void main(String[] args) { //Creamos dos arrays de cada tipo de objeto Serie listaSeries[]=new Serie[5]; Videojuego listaVideojuegos[]=new Videojuego[5]; //Creamos un objeto en cada posicion del array listaSeries[0]=new Serie(); listaSeries[1]=new Serie("Juego de tronos", "George R. R. Martin "); listaSeries[2]=new Serie("Los Simpsons", 25, "Humor", "Matt Groening"); listaSeries[3]=new Serie("Padre de familia", 12 ,"Humor", "Seth MacFarlane"); listaSeries[4]=new Serie("Breaking Bad", 5, "Thriller", "Vince Gilligan"); listaVideojuegos[0]=new Videojuego(); listaVideojuegos[1]=new Videojuego("Assasin creed 2", 30, "Aventura", "EA"); listaVideojuegos[2]=new Videojuego("God of war 3", "Santa Monica"); listaVideojuegos[3]=new Videojuego("Super Mario 3DS", 30, "Plataforma", "Nintendo"); listaVideojuegos[4]=new Videojuego("Final fantasy X", 200, "Rol", "Square Enix"); //entregamos algunos videojuegos y series listaSeries[1].entregar(); listaSeries[4].entregar(); listaVideojuegos[0].entregar(); listaVideojuegos[3].entregar(); //Recorremos los arrays para contar cuantos entregados hay, tambien los devolvemos int entregados=0; for(int i=0;i<listaSeries.length;i++){ if(listaSeries[i].isEntregado()){ entregados+=1; listaSeries[i].devolver(); } if(listaVideojuegos[i].isEntregado()){ entregados+=1; listaVideojuegos[i].devolver(); } } System.out.println("Hay "+entregados+" articulos entregados"); //Creamos dos objetos con la primera posicion de cada array Serie serieMayor=listaSeries[0]; Videojuego videojuegoMayor=listaVideojuegos[0]; //Recorremos el array desde la posicion 1 (no 0), comparando el mayor con las posiciones del array for(int i=1;i<listaSeries.length;i++){ if(listaSeries[i].compareTo(serieMayor)==Serie.MAYOR){ serieMayor=listaSeries[i]; } if(listaVideojuegos[i].compareTo(videojuegoMayor)==Videojuego.MAYOR){ videojuegoMayor=listaVideojuegos[i]; } } //Mostramos toda la informacion del videojuego y serie mayor System.out.println(videojuegoMayor); System.out.println(serieMayor); } } |
6) Crear una clase Libro que contenga los siguientes atributos:
– ISBN
– Titulo
– Autor
– Número de páginas
Crear sus respectivos métodos get y set correspondientes para cada atributo. Crear el método toString() para mostrar la información relativa al libro con el siguiente formato:
«El libro con ISBN creado por el autor tiene páginas»
En el fichero main, crear 2 objetos Libro (los valores que se quieran) y mostrarlos por pantalla.
Por último, indicar cuál de los 2 tiene más páginas.
Spoiler
–Clase Libro
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 |
public class Libro { /*Atributos*/ private int ISBN; private String titulo; private String autor; private int numPaginas; /*Constructores*/ public Libro(int pISBN, String pTitulo, String pAutor, int pNumPaginas){ ISBN=pISBN; titulo=pTitulo; autor=pAutor; numPaginas=pNumPaginas; } /*Metodos*/ public int getISBN() { return ISBN; } public void setISBN(int ISBN) { this.ISBN = ISBN; } public String getTitulo() { return titulo; } public void setTitulo(String titulo) { this.titulo = titulo; } public String getAutor() { return autor; } public void setAutor(String autor) { this.autor = autor; } public int getNumPaginas() { return numPaginas; } public void setNumPaginas(int numPaginas) { this.numPaginas = numPaginas; } @Override public String toString(){ return "El libro "+titulo+" con ISBN "+ISBN+"" + " creado por el autor "+autor + " tiene "+numPaginas+" páginas"; } } |
–Clase principal
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
public class Ejercicio_POO_DDR_1 { public static void main(String[] args) { //Creamos lo objetos Libro libro1=new Libro(1111111111, "titulo1", "autor1", 30); Libro libro2=new Libro(1111111112, "titulo2", "autor2", 60); //Mostramos su estado System.out.println(libro1.toString()); System.out.println(libro2.toString()); //Modificamos el atributo numPaginas del libro1 libro1.setNumPaginas(70); //Comparamos quien tiene mas paginas if(libro1.getNumPaginas()>libro2.getNumPaginas()){ System.out.println(libro1.getTitulo()+" tiene más páginas"); }else{ System.out.println(libro2.getTitulo()+" tiene más páginas"); } } } } |
7) Vamos a realizar una clase llamada Raices, donde representaremos los valores de una ecuación de 2º grado.
Tendremos los 3 coeficientes como atributos, llamémosles a, b y c.
Hay que insertar estos 3 valores para construir el objeto.
Las operaciones que se podrán hacer son las siguientes:
- obtenerRaices(): imprime las 2 posibles soluciones
- obtenerRaiz(): imprime única raíz, que será cuando solo tenga una solución posible.
- getDiscriminante(): devuelve el valor del discriminante (double), el discriminante tiene la siguiente formula, (b^2)-4*a*c
- tieneRaices(): devuelve un booleano indicando si tiene dos soluciones, para que esto ocurra, el discriminante debe ser mayor o igual que 0.
- tieneRaiz(): devuelve un booleano indicando si tiene una única solución, para que esto ocurra, el discriminante debe ser igual que 0.
- calcular(): mostrara por consola las posibles soluciones que tiene nuestra ecuación, en caso de no existir solución, mostrarlo también.
Formula ecuación 2º grado: (-b±√((b^2)-(4*a*c)))/(2*a)
Solo varia el signo delante de -b
Spoiler
–Clase Raices
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 |
/** * Clase Raices * Representa una ecuacion de 2º grado * @author discoduroderoer */ public class Raices { /*Atributos*/ private double a; private double b; private double c; /** * Ecuacion de 2º grado * @param a * @param b * @param c */ public Raices(double a, double b, double c){ this.a=a; this.b=b; this.c=c; } /** * Metodos para obtener las raices cuando hay 2 soluciones posibles */ private void obtenerRaices(){ double x1=(-b+Math.sqrt(getDiscriminante()))/(2*a); double x2=(-b-Math.sqrt(getDiscriminante()))/(2*a); System.out.println("Solucion X1"); System.out.println(x1); System.out.println("Solucion X2"); System.out.println(x2); } /** * Obtiene una unica raiz, cuando solo tiene la posibilidad de er una solucion */ private void obtenerRaiz(){ double x=(-b)/(2*a); System.out.println("Unica solucion"); System.out.println(x); } /** * Nos devuelve el valor del discriminante, * @return */ private double getDiscriminante(){ return Math.pow(b, 2)-(4*a*c); } /** * Si el discriminante es mayor que 0 tiene mas de una raiz * (No hemos puesto >= ya que puede confundirse con una solucion) * @return */ private boolean tieneRaices(){ return getDiscriminante()>0; } /** * Si el discriminante es igual a cero tiene una sola raiz * @return */ private boolean tieneRaiz(){ return getDiscriminante()==0; } /** * Nos permite calcular las raices de una ecuacion de 2º grado */ public void calcular(){ if(tieneRaices()){ obtenerRaices(); }else if(tieneRaiz()){ obtenerRaiz(); }else{ System.out.println("No tiene soluciones"); } } } |
–Clase Principal
|
1 2 3 4 5 6 7 8 9 |
public class Principal { public static void main(String[] args) { Raices ecuacion=new Raices(1,4,4); //creamos el objeto ecuacion.calcular(); //Calculamos } } |
8)
Queremos representar con programación orientada a objetos, un aula con estudiantes y un profesor.
Tanto de los estudiantes como de los profesores necesitamos saber su nombre, edad y sexo. De los estudiantes, queremos saber también su calificación actual (entre 0 y 10) y del profesor que materia da.
Las materias disponibles son matemáticas, filosofía y física.
Los estudiantes tendrán un 50% de hacer novillos, por lo que si hacen novillos no van a clase pero aunque no vayan quedara registrado en el aula (como que cada uno tiene su sitio).
El profesor tiene un 20% de no encontrarse disponible (reuniones, baja, etc.)
Las dos operaciones anteriores deben llamarse igual en Estudiante y Profesor (polimorfismo).
El aula debe tener un identificador numérico, el número máximo de estudiantes y para que esta destinada (matemáticas, filosofía o física). Piensa que más atributos necesita.
Un aula para que se pueda dar clase necesita que el profesor esté disponible, que el profesor de la materia correspondiente en el aula correspondiente (un profesor de filosofía no puede dar en un aula de matemáticas) y que haya más del 50% de alumnos.
El objetivo es crear un aula de alumnos y un profesor y determinar si puede darse clase, teniendo en cuenta las condiciones antes dichas.
Si se puede dar clase mostrar cuantos alumnos y alumnas (por separado) están aprobados de momento (imaginad que les están entregando las notas).
NOTA: Los datos pueden ser aleatorios (nombres, edad, calificaciones, etc.) siempre y cuando tengan sentido (edad no puede ser 80 en un estudiante o calificación ser 12).
Spoiler
— Clase Persona
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 |
//Clase Persona public abstract class Persona { /*Atributos*/ private String nombre; private char sexo; private int edad; private boolean asistencia; /*Contantes*/ private final String[] NOMBRES_CHICOS={"Pepe", "Fernando", "Alberto", "Nacho", "Eustaquio"}; private final String[] NOMBRES_CHICAS={"Alicia", "Laura", "Clotilde", "Pepa", "Elena"}; private final int CHICO=0; private final int CHICA=1; /*Constructores*/ public Persona(){ //entre 0 y 1 int determinar_sexo=MetodosSueltos.generaNumeroAleatorio(0,1); //Si es 0 es un chico if(determinar_sexo==CHICO){ nombre=NOMBRES_CHICOS[MetodosSueltos.generaNumeroAleatorio(0,4)]; sexo='H'; }else{ nombre=NOMBRES_CHICAS[MetodosSueltos.generaNumeroAleatorio(0,4)]; sexo='M'; } //Indicamos la disponibilidad disponibilidad(); } /*Metodos*/ /** * Devuelve el nombre * @return */ public String getNombre() { return nombre; } /** * Modifica el nombre * @param nombre */ public void setNombre(String nombre) { this.nombre = nombre; } /** * Devuelve el sexo de la persona * @return */ public char getSexo() { return sexo; } /** * Modifica el sexo de la persona * @param sexo */ public void setSexo(char sexo) { this.sexo = sexo; } /** * Devuelve la edad de la persona * @return */ public int getEdad() { return edad; } /** * Modifica la edad de la edad * @param edad */ public void setEdad(int edad) { this.edad = edad; } /** * Indica la asistencia de la persona * @return */ public boolean isAsistencia() { return asistencia; } /** * Modifica la asistencia de la persona * @param asistencia */ public void setAsistencia(boolean asistencia) { this.asistencia = asistencia; } //abtracto, las clases hijas deben implementarlo public abstract void disponibilidad(); } |
— Clase Alumno
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 |
//Clase Alumno, hereda de la clase Persona public class Alumno extends Persona{ /*Atributos*/ private int nota; /*Constructor*/ public Alumno(){ super(); nota=MetodosSueltos.generaNumeroAleatorio(0,10); super.setEdad(MetodosSueltos.generaNumeroAleatorio(12,15)); } /*Metodos*/ /** * Devuelve la nota * @return nota del alumno */ public int getNota() { return nota; } /** * Modifica la nota del alumno * @param nota */ public void setNota(int nota) { this.nota = nota; } /** * Indica si el alumno esta disponible (50%) */ @Override public void disponibilidad() { int prob=MetodosSueltos.generaNumeroAleatorio(0, 100); if(prob<50){ super.setAsistencia(false); }else{ super.setAsistencia(true); } } /** * Muestra la informacion del alumno * @return informacion */ public String toString(){ return "Nombre: "+super.getNombre()+" ,sexo: "+super.getSexo()+" , nota: "+nota; } } |
— Clase Profesor
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
//Clase profesor que hereda de la clase Persona public class Profesor extends Persona{ /*Atributos*/ private String materia; /*Constructores*/ public Profesor(){ super(); //Llama al constructor padre super.setEdad(MetodosSueltos.generaNumeroAleatorio(25,50)); //llama al metodo padre materia=Constantes.MATERIAS[MetodosSueltos.generaNumeroAleatorio(0,2)]; } /*Metodos*/ /** * Devuelve la materia del profesor * @return */ public String getMateria() { return materia; } /** * Modifica la materia del profesor * @param materia */ public void setMateria(String materia) { this.materia = materia; } /** * Calcula la disponibilidad del profesor(20%) */ @Override public void disponibilidad() { int prob=MetodosSueltos.generaNumeroAleatorio(0, 100); if(prob<20){ super.setAsistencia(false); }else{ super.setAsistencia(true); } } } |
— Clase Aula
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 |
public class Aula { /*Atributos*/ private int id; private Profesor profesor; private Alumno[] alumnos; private String materia; /*Constantes*/ private final int MAX_ALUMNOS=20; /*Constructores*/ public Aula(){ id=1; profesor=new Profesor(); alumnos= new Alumno[MAX_ALUMNOS]; creaAlumnos(); materia=Constantes.MATERIAS[MetodosSueltos.generaNumeroAleatorio(0,2)]; } /*Metodos*/ /** * Crea los alumnos para el aula */ private void creaAlumnos(){ for(int i=0;i<alumnos.length;i++){ alumnos[i]=new Alumno(); } } /** * Indica si la asistencia de los alumnos es mayor del 50% * @return */ private boolean asistenciaAlumnos(){ int cuentaAsistencias=0; //contamos las asistencias for(int i=0;i<alumnos.length;i++){ if(alumnos[i].isAsistencia()){ cuentaAsistencias++; } } //Muestro la asistencia total System.out.println("Hay "+cuentaAsistencias+" alumnos"); return cuentaAsistencias>=((int)(alumnos.length/2)); } /** * Indicamos si se puede dar clase * @return */ public boolean darClase(){ //Indicamos las condiciones para que se pueda dar la clase if(!profesor.isAsistencia()){ System.out.println("El profesor no esta, no se puede dar clase"); return false; }else if(!profesor.getMateria().equals(materia)){ System.out.println("La materia del profesor y del aula no es la misma, no se puede dar clase"); return false; }else if (!asistenciaAlumnos()){ System.out.println("La asistencia no es suficiente, no se puede dar clase"); return false; } System.out.println("Se puede dar clase"); return true; } /** * Indicamos las notas de los alumnos aprobados, chicos y chicas */ public void notas(){ int chicosApro=0; int chicasApro=0; for(int i=0;i<alumnos.length;i++){ //Comprobamos si el alumno esta aprobado if(alumnos[i].getNota()>=5){ //Segun el sexo, aumentara uno o otro if(alumnos[i].getSexo()=='H'){ chicosApro++; }else{ chicasApro++; } System.out.println(alumnos[i].toString()); } } System.out.println("Hay "+chicosApro+" chicos y "+chicasApro+" chicas aprobados/as"); } } |
— Clase Constantes
|
1 2 3 4 5 6 |
//Clase constantes public class Constantes { public static final String[] MATERIAS={"Matematicas", "Filosofia", "Fisica"}; } |
— Clase MetodosSueltos
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
public class MetodosSueltos { /** * Genera un numero aleatorio entre dos numeros. * Entre el minimo y el maximo * @param minimo * @param maximo * @return numero entre minimo y maximo */ public static int generaNumeroAleatorio(int minimo, int maximo){ int num=(int)Math.floor(Math.random()*(minimo-(maximo+1))+(maximo+1)); return num; } } |
— Clase Principal
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
public class Principal { public static void main(String[] args) { //Creamos el objeto Aula aula=new Aula(); //Indicamos si se puede dar la clase if(aula.darClase()){ aula.notas(); } } } |
9) Nos piden hacer un programa orientado a objetos sobre un cine (solo de una sala) tiene un conjunto de asientos (8 filas por 9 columnas, por ejemplo).
Del cine nos interesa conocer la película que se está reproduciendo y el precio de la entrada en el cine.
De las películas nos interesa saber el título, duración, edad mínima y director.
Del espectador, nos interesa saber su nombre, edad y el dinero que tiene.
Los asientos son etiquetados por una letra (columna) y un número (fila), la fila 1 empieza al final de la matriz como se muestra en la tabla. También deberemos saber si está ocupado o no el asiento.
8 A 8 B 8 C 8 D 8 E 8 F 8 G 8 H 8 I
7 A 7 B 7 C 7 D 7 E 7 F 7 G 7 H 7 I
6 A 6 B 6 C 6 D 6 E 6 F 6 G 6 H 6 I
5 A 5 B 5 C 5 D 5 E 5 F 5 G 5 H 5 I
4 A 4 B 4 C 4 D 4 E 4 F 4 G 4 H 4 I
3 A 3 B 3 C 3 D 3 E 3 F 3 G 3 H 3 I
2 A 2 B 2 C 2 D 2 E 2 F 2 G 2 H 2 I
1 A 1 B 1 C 1 D 1 E 1 F 1 G 1 H 1 I
Realizaremos una pequeña simulación, en el que generaremos muchos espectadores y los sentaremos aleatoriamente (no podemos donde ya este ocupado).
En esta versión sentaremos a los espectadores de uno en uno.
Solo se podrá sentar si tienen el suficiente dinero, hay espacio libre y tiene edad para ver la película, en caso de que el asiento este ocupado le buscamos uno libre.
Los datos del espectador y la película pueden ser totalmente aleatorios.
Spoiler
— Clase Espectador
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 |
/** * Clase Espectador, lleva todo lo relativo a la información del espectador * * @author DiscoDurodeRoer */ public class Espectador { /*Atributos*/ private String nombre; private int edad; private double dinero; /*Constructores*/ public Espectador(String nombre, int edad, double dinero) { this.nombre = nombre; this.edad = edad; this.dinero = dinero; } /*Metodos*/ 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 double getDinero() { return dinero; } public void setDinero(double dinero) { this.dinero = dinero; } /** * Pagamos la entrada del cine * * @param precio */ public void pagar(double precio) { dinero -= precio; } /** * Indicamos si el espectador tiene edad para ver la pelicula (en el video * estaba en la clase pelicula tiene mas sentido que sea un metodo del * espectador) * * @param edadMinima * @return */ public boolean tieneEdad(int edadMinima) { return edad >= edadMinima; } /** * Indicamos si el espectador tiene dinero (en el video estaba en la clase * cine tiene mas sentido que sea un metodo del espectador) * * @param precioEntrada * @return */ public boolean tieneDinero(double precioEntrada) { return dinero >= precioEntrada; } @Override public String toString() { return "el nombre del espectador es " + nombre + " de " + edad + " años y con " + dinero + " euros en su bolsillo"; } } |
— Clase Asiento
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 |
/** * Clase asiento, se usa para manejar toda la informacion relativa al asiento * * @author DiscoDurodeRoer */ public class Asiento { /*Atributos*/ private char letra; private int fila; private Espectador espectador; // informacion del espectador que esta sentado, null si es vacio /*Constructores*/ public Asiento(char letra, int fila) { this.letra = letra; this.fila = fila; this.espectador = null; //al iniciar el asiento, no habrá nadie sentado } /*Metodos*/ public char getLetra() { return letra; } public void setLetra(char letra) { this.letra = letra; } public int getFila() { return fila; } public void setFila(int fila) { this.fila = fila; } public Espectador getEspectador() { return espectador; } public void setEspectador(Espectador espectador) { this.espectador = espectador; } /** * Indica si el asiento esta ocupado * * @return */ public boolean ocupado() { return espectador != null; } @Override public String toString() { if (ocupado()) { return "Asiento: " + fila + letra + " y " + espectador; } return "Asiento: " + fila + letra + " y este asiento está vacio "; } } |
— Clase Pelicula
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 |
/** * Clase Pelicula, lleva todo lo relacionado con la pelicula * * @author DiscoDurodeRoer */ public class Pelicula { /*Atributos*/ private String titulo; private int duracion; private int edadMinima; private String director; /*Constructor*/ public Pelicula(String titulo, int duracion, int edadMinima, String director) { this.titulo = titulo; this.duracion = duracion; this.edadMinima = edadMinima; this.director = director; } /*Metodos*/ public String getTitulo() { return titulo; } public void setTitulo(String titulo) { this.titulo = titulo; } public int getDuracion() { return duracion; } public void setDuracion(int duracion) { this.duracion = duracion; } public int getEdadMinima() { return edadMinima; } public void setEdadMinima(int edadMinima) { this.edadMinima = edadMinima; } public String getDirector() { return director; } public void setDirector(String director) { this.director = director; } @Override public String toString() { return "'" + titulo + "' del director " + director + ", con una duracion de " + duracion + " minutos y la edad minima es de " + edadMinima + " años"; } } |
— Clase Cine
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 |
/** * Clase Cine, lleva todo lo relativo al cine * * @author DiscoDurodeRoer */ public class Cine { /*Atributos*/ private Asiento asientos[][]; private double precio; private Pelicula pelicula; /*Constructor*/ public Cine(int filas, int columnas, double precio, Pelicula pelicula) { asientos = new Asiento[filas][columnas]; this.precio = precio; this.pelicula = pelicula; rellenaButacas(); } /*Metodos*/ public Asiento[][] getAsientos() { return asientos; } public void setAsientos(Asiento[][] asientos) { this.asientos = asientos; } public double getPrecio() { return precio; } public void setPrecio(double precio) { this.precio = precio; } public Pelicula getPelicula() { return pelicula; } public void setPelicula(Pelicula pelicula) { this.pelicula = pelicula; } /** * Rellena nuestros asientos, dandoles una fila y una letra */ private void rellenaButacas() { int fila = asientos.length; for (int i = 0; i < asientos.length; i++) { for (int j = 0; j < asientos[0].length; j++) { //Recuerda que los char se pueden sumar asientos[i][j] = new Asiento((char) ('A' + j), fila); } fila--; //Decremento la fila para actualizar la fila } } /** * Indicamos si hay sitio en el cine, cuando vemos una vacia salimos de la * función * * @return */ public boolean haySitio() { for (int i = 0; i < asientos.length; i++) { for (int j = 0; j < asientos[0].length; j++) { if (!asientos[i][j].ocupado()) { return true; } } } return false; } /** * Indico si en una posicion concreta esta ocupada * * @param fila * @param letra * @return */ public boolean haySitioButaca(int fila, char letra) { return getAsiento(fila, letra).ocupado(); } /** * Indicamos si el espectador cumple lo necesario para entrar: - Tiene * dinero - Tiene edad El tema de si hay sitio, se controla en el main * * @param e * @return */ public boolean sePuedeSentar(Espectador e) { return e.tieneDinero(precio) && e.tieneEdad(pelicula.getEdadMinima()); } /** * Siento al espectador en un asiento * * @param fila * @param letra * @param e */ public void sentar(int fila, char letra, Espectador e) { getAsiento(fila, letra).setEspectador(e); } /** * Devuelvo un asiento concreto por su fila y letra * * @param fila * @param letra * @return */ public Asiento getAsiento(int fila, char letra) { return asientos[asientos.length - fila - 1][letra - 'A']; } /** * Numero de filas de nuestro cine * * @return */ public int getFilas() { return asientos.length; } /** * Numero de columas de nuestro cine * * @return */ public int getColumnas() { return asientos[0].length; } /** * Mostramos la información de nuestro cine (Tambien se puede hacer en un * toString pero hay que devolver un String) */ public void mostrar() { System.out.println("Información cine"); System.out.println("Pelicula reproducida: " + pelicula); System.out.println("Precio entrada: " + precio); System.out.println(""); for (int i = 0; i < asientos.length; i++) { for (int j = 0; j < asientos[0].length; j++) { System.out.println(asientos[i][j]); } System.out.println(""); } } } |
— Clase Metodos
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
/** * Clase Metodos, contiene funciones útiles para nuestro programa * * @author DiscoDuroDeroer */ public class Metodos { public static final String nombres[] = {"Fernando", "Laura", "Pepe", "Eufrasio"}; public static int generaNumeroEnteroAleatorio(int minimo, int maximo) { int num = (int) (Math.random() * (minimo - (maximo + 1)) + (maximo + 1)); return num; } } |
— Clase Principal
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 |
import java.util.Scanner; /** * Clase ejecutable * @author DiscoDurodeRoer */ public class Principal { public static void main(String[] args) { //Creo la pelicula Pelicula pelicula = new Pelicula("Mi vida", 90, 16, "DDR"); // Pido datos (esto no se mostro en el video por falta de tiempo) // No valida nada al respecto de tamaños (siguiente version) Scanner sn = new Scanner(System.in); System.out.println("Introduce el numero de filas"); int filas=sn.nextInt(); System.out.println("Introduce el numero de columnas"); int columnas=sn.nextInt(); System.out.println("Introduce el precio de la entrada de cine"); double precio=sn.nextDouble(); //Creo el cine, necesito la pelicula para ello Cine cine = new Cine(filas, columnas, precio, pelicula); //Numero de espectadores que seran creados System.out.println("Introduce el numero de espectadores a crear"); int numEspectadores = sn.nextInt(); //Variables y objetos usados Espectador e; int fila; char letra; System.out.println("Espectadores generados: "); //Termino cuando no queden espectadores o no haya mas sitio en el cine for (int i = 0; i < numEspectadores && cine.haySitio(); i++) { //Generamos un espectador e = new Espectador( Metodos.nombres[Metodos.generaNumeroEnteroAleatorio(0, Metodos.nombres.length - 1)], //Nombre al azar Metodos.generaNumeroEnteroAleatorio(10, 30), //Generamos una edad entre 10 y 30 Metodos.generaNumeroEnteroAleatorio(1, 10)); //Generamos el dinero entre 1 y 10 euros //Mostramos la informacion del espectador System.out.println(e); //Generamos una fila y letra //Si esta libre continua sino busca de nuevo do { fila = Metodos.generaNumeroEnteroAleatorio(0, cine.getFilas() - 1); letra = (char) Metodos.generaNumeroEnteroAleatorio('A', 'A' + (cine.getColumnas()-1)); } while (cine.haySitioButaca(fila, letra)); //Si el espectador cumple con las condiciones if (cine.sePuedeSentar(e)) { e.pagar(cine.getPrecio()); //El espectador paga el precio de la entrada cine.sentar(fila, letra, e); //El espectador se sienta } } System.out.println(""); cine.mostrar(); //Mostramos la información del cine, tambien se puede usar un toString System.out.println("Fin"); } } |
10)
Vamos a hacer una baraja de cartas españolas orientado a objetos.
Una carta tiene un número entre 1 y 12 (el 8 y el 9 no los incluimos) y un palo (espadas, bastos, oros y copas)
La baraja estará compuesta por un conjunto de cartas, 40 exactamente.
Las operaciones que podrá realizar la baraja son:
- barajar: cambia de posición todas las cartas aleatoriamente
- siguienteCarta: devuelve la siguiente carta que está en la baraja, cuando no haya más o se haya llegado al final, se indica al usuario que no hay más cartas.
- cartasDisponibles: indica el número de cartas que aún puede repartir
- darCartas: dado un número de cartas que nos pidan, le devolveremos ese número de cartas (piensa que puedes devolver). En caso de que haya menos cartas que las pedidas, no devolveremos nada pero debemos indicárselo al usuario.
- cartasMonton: mostramos aquellas cartas que ya han salido, si no ha salido ninguna indicárselo al usuario
- mostrarBaraja: muestra todas las cartas hasta el final. Es decir, si se saca una carta y luego se llama al método, este no mostrara esa primera carta.
Spoiler
— Carta
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
/** * Clase Carta * @author Disco Duro de Roer */ public class Carta { //Atributos private int numero; private String palo; //Constantes public static final String[] PALOS={"ESPADAS", "OROS", "COPAS", "BASTOS"}; public static final int LIMITE_CARTA_PALO=12; //Constructor public Carta(int numero, String palo) { this.numero = numero; this.palo = palo; } @Override public String toString() { return "numero=" + numero + ", palo=" + palo; } } |
— Baraja
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 |
/** * Clase Baraja * @author Disco Duro de Roer */ public class Baraja { //Atributos private Carta cartas[]; private int posSiguienteCarta; //Cartas public static final int NUM_CARTAS = 40; public Baraja() { this.cartas = new Carta[NUM_CARTAS]; this.posSiguienteCarta = 0; crearBaraja(); //Creamos la baraja barajar(); // barajamos la baraja } /** * Crea la baraja ordenada */ private void crearBaraja() { String[] palos = Carta.PALOS; //Recorro los palos for (int i = 0; i < palos.length; i++) { //Recorro los numeros for (int j = 0; j < Carta.LIMITE_CARTA_PALO; j++) { //Las posiciones del 8 y del 9 son el 7 y el 8 (emepzamos en 8) if (!(j == 7 || j == 8)) { if (j >= 9) { //Solo para la sota, caballo y rey cartas[((i * (Carta.LIMITE_CARTA_PALO - 2)) + (j - 2))] = new Carta(j + 1, palos[i]); } else { //Para los casos de 1 a 7 cartas[((i * (Carta.LIMITE_CARTA_PALO - 2)) + j)] = new Carta(j + 1, palos[i]); } } } } } /** * Baraja todas las cartas */ public void barajar() { int posAleatoria = 0; Carta c; //Recorro las cartas for (int i = 0; i < cartas.length; i++) { posAleatoria = Metodos.generaNumeroEnteroAleatorio(0, NUM_CARTAS - 1); //intercambio c = cartas[i]; cartas[i] = cartas[posAleatoria]; cartas[posAleatoria] = c; } //La posición vuelve al inicio this.posSiguienteCarta = 0; } /** * Devuelve la casta donde se encuentre "posSiguienteCarta" * @return carta del arreglo */ public Carta siguienteCarta() { Carta c = null; if (posSiguienteCarta == NUM_CARTAS) { System.out.println("Ya no hay mas cartas, barajea de nuevo"); } else { c = cartas[posSiguienteCarta++]; } return c; } /** * Devuelve un numero de cartas. Controla si hay mas cartas de las que se piden * @param numCartas * @return */ public Carta[] darCartas(int numCartas) { if (numCartas > NUM_CARTAS) { System.out.println("No se puede dar mas cartas de las que hay"); } else if (cartasDisponible() < numCartas) { System.out.println("No hay suficientes cartas que mostrar"); } else { Carta[] cartasDar = new Carta[numCartas]; //recorro el array que acabo de crear para rellenarlo for (int i = 0; i < cartasDar.length; i++) { cartasDar[i] = siguienteCarta(); //uso el metodo anterior } //Lo devuelvo return cartasDar; } //solo en caso de error return null; } /** * Indica el numero de cartas que hay disponibles * @return */ public int cartasDisponible() { return NUM_CARTAS - posSiguienteCarta; } /** * Muestro las cartas que ya han salido */ public void cartasMonton() { if (cartasDisponible() == NUM_CARTAS) { System.out.println("No se ha sacado ninguna carta"); } else { //Recorro desde 0 a la posSiguienteCarta for (int i = 0; i < posSiguienteCarta; i++) { System.out.println(cartas[i]); } } } /** * Muestro las cartas que aun no han salido */ public void mostrarBaraja() { if (cartasDisponible() == 0) { System.out.println("No hay cartas que mostrar"); } else { for (int i = posSiguienteCarta; i < cartas.length; i++) { System.out.println(cartas[i]); } } } } |
— Métodos
|
1 2 3 4 5 6 7 8 9 10 11 12 |
/** * Clase Metodos, contiene métodos estaricos sueltos * @author Trabajo */ public class Metodos { public static int generaNumeroEnteroAleatorio(int minimo, int maximo) { int num = (int) (Math.random() * (minimo - (maximo + 1)) + (maximo + 1)); return num; } } |
— Main
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
public class Ejercicio_POO_DDR_05 { public static void main(String[] args) { //Creamos la baraja Baraja b = new Baraja(); //Mostramos las cartas disponibles (40) System.out.println("Hay "+b.cartasDisponible()+" cartas disponibles"); //Saco una carta b.siguienteCarta(); //Saco 5 cartas b.darCartas(5); //Mostramos las cartas disponibles (34) System.out.println("Hay "+b.cartasDisponible()+" cartas disponibles"); System.out.println("Cartas sacadas de momento"); b.cartasMonton(); //Barajamos de nuevo b.barajar(); //Saco 5 cartas Carta[] c = b.darCartas(5); System.out.println("Cartas sacadas despues de barajar "); for(int i=0;i<c.length;i++){ System.out.println(c[i]); } } } |
11) Estando en un grupo de amigos, se planea hacer una porra de la liga de fútbol. A nosotros se nos ocurre hacer un programa en POO para simular como podría desarrollarse la porra.
Cada jugador de la porra, pone un 1 euro cada jornada y decide el resultado de los partidos acordados.
Si nadie acierta en una jornada los resultados, el bote se acumula.
En principio, deben acertar el resultado de dos partidos para llevarse el dinero del bote de la porra.
Todos empiezan con un dinero inicial que será decidido por el programador (ya sea como parámetro o como constante). Si el jugador no tiene dinero en una jornada no podrá jugar la porra.
Para esta versión, entre jugadores podrán repetir resultados repetidos, por lo que el jugador que primero diga ese resultado (tal como estén de orden) se llevara primero el bote.
Los resultados de la porra serán generados aleatoriamente, tanto los de jugador como los de los partidos (no es necesario nombre, solo resultados).
Al final del programa, se deberá mostrar el dinero que tienen los jugadores y el número de veces que han ganado.
Para este ejercicio, recomiendo usar interfaces (no hablo de interfaces gráficas) para las constantes y métodos que sean necesarios.
Spoiler
— Constantes
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
/** * Interfaz Constantes * @author Disco Duro de Roer */ public interface Constantes { public final int NUMERO_PARTIDOS=2; public final int NUMERO_JORNADAS=38; public final double DINERO_INICIAL=35; public final int RESULTADO_MINIMO=0; public final int RESULTADO_MAXIMO=3; public final double DINERO_CADA_JORNADA=1; public final Jugador[] JUGADORES={ new Jugador("Make"), new Jugador("JuanMa"), new Jugador("Fernando"), new Jugador("Alberto"), new Jugador("Lorente"), new Jugador("Adrian"), new Jugador("Maria"), new Jugador("Parra"), new Jugador("Pablo"), new Jugador("Prieto"), new Jugador("Ruben"), new Jugador("Jony"), new Jugador("Fran"), new Jugador("Isidoro"), new Jugador("Rafa") }; } |
— Jugador
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 |
/** * Clase Jugador * @author Disco Duro de Roer */ public class Jugador implements Constantes, MetodosInterfaz{ private String nombre; private double dinero; private int porrasGanadas; private String[] resultados; public Jugador(String nombre){ this.nombre=nombre; this.dinero = DINERO_INICIAL; this.porrasGanadas=0; this.resultados = new String[NUMERO_PARTIDOS]; reiniciarResultados(); } public void reiniciarResultados(){ for(int i=0;i<resultados.length;i++){ resultados[i]=""; } } public boolean puedePagar(){ return dinero>=DINERO_CADA_JORNADA; } public void ponerEnElBote(){ dinero-=DINERO_CADA_JORNADA; System.out.println("Jugador "+nombre+" ha puesto "+DINERO_CADA_JORNADA+" euro/s y le queda "+dinero+" euro/s"); } public void ganarBote(double bote){ dinero+=bote; porrasGanadas++; System.out.println("Jugador "+nombre+" ha ganado "+bote+" euro/s y tiene "+dinero+" euro/s"); } @Override public void generarResultados() { int pLocal, pVisitante; for(int i=0;i<resultados.length;i++){ pLocal = Metodos.generaNumeroAleatorio(RESULTADO_MINIMO, RESULTADO_MAXIMO); pVisitante = Metodos.generaNumeroAleatorio(RESULTADO_MINIMO, RESULTADO_MAXIMO); resultados[i] = pLocal +" - "+pVisitante; System.out.println("El Jugador "+nombre+" ha elegido el resultado "+resultados[i]); } System.out.println(""); } public boolean haAcertadoPorra(String[] resultados_partidos){ for(int i=0;i<resultados.length;i++){ if(!resultados[i].equals(resultados_partidos[i])){ return false; } } return true; } @Override public String toString() { return "El jugador " + nombre + " tiene dinero=" + dinero + " y ha ganado " + porrasGanadas + " porra/s"; } } |
— Métodos
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
/** * Clase Métodos * @author Disco Duro de Roer */ public class Metodos { /** * Genera un numero aleatorio entre un minimo y un maximo * @param minimo * @param maximo * @return */ public static int generaNumeroAleatorio(int minimo, int maximo){ int num=(int)Math.floor(Math.random()*(minimo-(maximo+1))+(maximo+1)); return num; } } |
— Métodos Interfaz
|
1 2 3 4 5 |
public interface MetodosInterfaz { public void generarResultados(); } |
— POOrra
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 |
/** * Clase POOrra * @author Disco Duro de Roer */ public class POOrra implements Constantes{ private double bote; public POOrra(){ bote=0; } /** * Aumenta la cantidad del bote * @param dinero */ public void aumentarBote(double dinero){ bote+=dinero; } /** * Dejamos el bote a 0 */ public void vacirBote(){ bote=0; } /** * Metodo principal que simula el transcurso de la porra */ public void jornadas(){ Resultados resultados = new Resultados(); String[] partidos; //Recorremos las jornadas for(int i=0;i<NUMERO_JORNADAS;i++){ System.out.println("JORNADA "+(i+1)); System.out.println(""); //Apuesta for(int j=0;j<JUGADORES.length;j++){ //Si un jugador puede pagar if(JUGADORES[j].puedePagar()){ //el jugador paga, dice sus resultados y el bote se aumenta JUGADORES[j].ponerEnElBote(); JUGADORES[j].generarResultados(); aumentarBote(DINERO_CADA_JORNADA); }else{ //Si no puede pagar, los resultados se vacian JUGADORES[j].reiniciarResultados(); } } //Partido resultados.generarResultados(); partidos = resultados.getPartidos(); //Comprobacion for(int j=0;j<JUGADORES.length;j++){ //Indica si ha acertado if (JUGADORES[j].haAcertadoPorra(partidos)){ //Le damos el bota al jugador y vaciamos el bote JUGADORES[j].ganarBote(bote); vacirBote(); } } System.out.println(""); System.out.println(""); System.out.println(toString()); System.out.println(""); System.out.println(""); } //Motramos el estado de los jugadores for(int i=0;i<JUGADORES.length;i++){ System.out.println(JUGADORES[i]); } } @Override public String toString() { return "En la POOrra hay de bote" + bote + " euro/s"; } } |
— Resultados
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
/** * Clase Resultados * @author Disco Duro de Roer */ public class Resultados implements Constantes,MetodosInterfaz{ private String[] partidos; public Resultados() { partidos=new String[NUMERO_PARTIDOS]; } /** * Genera los resultado del partido */ @Override public void generarResultados() { int pLocal, pVisitante; for(int i=0;i<partidos.length;i++){ //Generamos los resultados pLocal = Metodos.generaNumeroAleatorio(RESULTADO_MINIMO, RESULTADO_MAXIMO); pVisitante = Metodos.generaNumeroAleatorio(RESULTADO_MINIMO, RESULTADO_MAXIMO); partidos[i] = pLocal +" - "+pVisitante; System.out.println("El partido "+(i+1)+" ha generado el resultado "+partidos[i]); } } public String[] getPartidos() { return partidos; } } |
— Main
|
1 2 3 4 5 6 7 8 9 |
public class Ejercicio_POO_DDR_06 { public static void main(String[] args) { POOrra p = new POOrra(); p.jornadas(); } } |
12) Vamos a hacer el juego de la ruleta rusa en Java.
Como muchos sabéis, se trata de un número de jugadores que con un revolver con un sola bala en el tambor se dispara en la cabeza.
Las clases a hacer son:
- Revolver:
- Atributos:
- posición actual (posición del tambor donde se dispara, puede que esté la bala o no)
- posición bala (la posición del tambor donde se encuentra la bala)
- Atributos:
Estas dos posiciones, se generaran aleatoriamente.
- Funciones:
- disparar(): devuelve true si la bala coincide con la posición actual
- siguienteBala(): cambia a la siguiente posición del tambor
- toString(): muestra información del revolver (posición actual y donde está la bala)
- Jugador:
- Atributos
- id (representa el número del jugador, empieza en 1)
- nombre (Empezara con Jugador más su ID, «Jugador 1» por ejemplo)
- vivo (indica si está vivo o no el jugador)
- Funciones:
- disparar(Revolver r): el jugador se apunta y se dispara, si la bala se dispara, el jugador muere.
- Juego:
- Atributos:
- Jugadores (conjunto de Jugadores)
- Revolver
- Funciones:
- finJuego(): cuando un jugador muere, devuelve true
- ronda(): cada jugador se apunta y se dispara, se informara del estado de la partida (El jugador se dispara, no ha muerto en esa ronda, etc.)
- Atributos:
- Atributos
El número de jugadores será decidido por el usuario, pero debe ser entre 1 y 6. Si no está en este rango, por defecto será 6.
En cada turno uno de los jugadores, dispara el revólver, si este tiene la bala el jugador muere y el juego termina.
Aunque no lo haya comentado, recuerda usar una clase ejecutable para probarlo.
Spoiler
— Revolver
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
public class Revolver { //Atributos private int posicionBalaActual; private int posicionBala; //Constructor public Revolver() { posicionBalaActual = Metodos.generaNumeroAleatorio(1, 6); posicionBala = Metodos.generaNumeroAleatorio(1, 6); } //Metodos //Dispara el revolver public boolean disparar() { boolean exito = false; if (posicionBalaActual == posicionBala) { exito = true; //Alguien va a morir... } siguienteBala(); return exito; } //Cambia a la siguiente posicion public void siguienteBala() { if (posicionBalaActual == 6) { posicionBalaActual = 1; //posicion incial } else { posicionBalaActual++; } } public String toString() { return "Posicion Bala Actual: " + posicionBalaActual + ", Posicion bala: " + posicionBala; } } |
— Jugador
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
/** * @author Discoduroderoer */ public class Jugador { //Atributos private int id; private String nombre; private boolean vivo; //Contructor public Jugador(int id) { this.id = id; this.nombre = "Jugador " + id; this.vivo = true; } //Propiedades /** * El jugador dispara el revolver * @param r */ public void disparar(Revolver r) { System.out.println("El " + nombre + " se apunta con la pistola"); //El jugador se pone el revolver y... if (r.disparar()) { this.vivo = false; //muere System.out.println("El " + nombre + " ha muerto..."); } else { System.out.println("El " + nombre + " se ha librado..."); //No muere } } public boolean isVivo() { return vivo; } } |
— Metodos
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
/** * @author Discoduroderoer */ public class Metodos { /** * Genera un numero aleatorio entre dos numeros * @param minimo * @param maximo * @return */ public static int generaNumeroAleatorio(int minimo, int maximo) { int num = (int) Math.floor(Math.random() * (maximo - minimo + 1) + (minimo)); return num; } } |
— Juego
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 |
/** * @author Discoduroderoer */ public class Juego { //atributos private Jugador[] jugadores; private Revolver revolver; //Constructor public Juego(int numJugadores) { jugadores = new Jugador[comprobarJugadores(numJugadores)]; crearJugadores(); revolver = new Revolver(); } //Comprueba que el numero de jugadores esta en el rango correcto private int comprobarJugadores(int numJugadores) { //Sino esta en el rango correcto se pone a 6 if (!(numJugadores >= 1 && numJugadores <= 6)) { numJugadores = 6; } return numJugadores; } //Crea los jugadores private void crearJugadores() { for (int i = 0; i < jugadores.length; i++) { jugadores[i] = new Jugador(i + 1); } } //indica si el juego acaba o no public boolean finJuego() { for (int i = 0; i < jugadores.length; i++) { if (!jugadores[i].isVivo()) { //Acabo el juego return true; } } return false; //No termina el juego } //Realiza una ronda (si muere algun jugador todos participan igualmente) public void ronda() { for (int i = 0; i < jugadores.length; i++) { //El jugador se dispara jugadores[i].disparar(revolver); } } //Realiza una ronda (si muere algun jugador, los siguientes no participan) public void rondaV2() { for (int i = 0; i < jugadores.length; i++) { jugadores[i].disparar(revolver); //Si muere, terminamos if(!jugadores[i].isVivo()){ return; } } } } |
— Main
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
/** * @author Discoduroderoer */ public class Ejercicio_POO_DDR_07 { public static void main(String[] args) { Juego juego = new Juego(2); while( !juego.finJuego() ){ juego.ronda(); //juego.rondaV2(); } System.out.println("El juego ha terminado"); } } |
12) Nos piden hacer una un programa que gestione empleados.
Los empleados se definen por tener:
- Nombre
- Edad
- Salario
También tendremos una constante llamada PLUS, que tendrá un valor de 300€
Tenemos dos tipos de empleados: repartidor y comercial.
El comercial, aparte de los atributos anteriores, tiene uno más llamado comisión (double).
El repartidor, aparte de los atributos de empleado, tiene otro llamado zona (String).
Crea sus constructores, getters and setters y toString (piensa como aprovechar la herencia).
No se podrán crear objetos del tipo Empleado (la clase padre) pero si de sus hijas.
Las clases tendrán un método llamado plus, que según en cada clase tendrá una implementación distinta. Este plus básicamente aumenta el salario del empleado.
- En comercial, si tiene más de 30 años y cobra una comisión de más de 200 euros, se le aplicara el plus.
- En repartidor, si tiene menos de 25 y reparte en la “zona 3”, este recibirá el plus.
Puedes hacer que devuelva un booleano o que no devuelva nada, lo dejo a tu elección.
Crea una clase ejecutable donde crees distintos empleados y le apliques el plus para comprobar que funciona.
Spoiler
— Empleado
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
/** * Clase Empleado, es abtracta * * @author DiscoDurodeRoer */ public abstract class Empleado { //Atributos private String nombre; private int edad; private double salario; //Constantes public final double PLUS = 300; //Constructores public Empleado(String nombre, int edad, double salario) { this.nombre = nombre; this.edad = edad; this.salario = salario; } //Metodos 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 double getSalario() { return salario; } public void setSalario(double salario) { this.salario = salario; } @Override public String toString() { return "nombre=" + nombre + ", edad=" + edad + ", salario=" + salario + ", "; } //Metodo abstracto, obliga a las clases hijas que implementen esta función public abstract boolean plus(); } |
— Comercial
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 |
/** * Clase comercial, hija de Empleado * * @author DiscoDurodeRoer */ public class Comercial extends Empleado { //Atributos private double comision; //Constructores public Comercial(double comision, String nombre, int edad, double salario) { super(nombre, edad, salario); this.comision = comision; } //Metodos public double getComision() { return comision; } public void setComision(double comision) { this.comision = comision; } /** * Devuelve el estado del objeto, llama primero al toString de la clase * padre * * @return */ @Override public String toString() { return super.toString() + " comision=" + comision; } /** * Si tiene mas de 30 años y la comision es mayor que 200, aumentamos el * sueldo al empleado * * @return */ @Override public boolean plus() { if (super.getEdad() > 30 && this.comision > 200) { //Con super. llamo a un metodo de la clase padre double nuevoSalario = super.getSalario() + super.PLUS; super.setSalario(nuevoSalario); System.out.println("Se le añadido el plus, al empleado " + super.getNombre()); return true; } return false; } } |
— Repartidor
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
/** * Clase Repartidor, hija de empleado * @author DiscoDurodeRoer */ public class Repartidor extends Empleado { //Atributos private String zona; //Constructores public Repartidor(String zona, String nombre, int edad, double salario) { super(nombre, edad, salario); this.zona = zona; } //Metodos public String getZona() { return zona; } public void setZona(String zona) { this.zona = zona; } @Override public String toString() { return super.toString() + " zona=" + zona; } /** * Si tiene menos de 25 años y la zona es "zona 3", * aumentamos el sueldo al empleado * @return */ @Override public boolean plus() { if (super.getEdad() < 25 && this.zona.equalsIgnoreCase("zona 3")) { //Con super. llamo a un metodo de la clase padre double nuevoSalario = super.getSalario() + super.PLUS; super.setSalario(nuevoSalario); System.out.println("Se le añadido el plus, al empleado "+super.getNombre()); return true; } return false; } } |
— Main
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
public class Ejercicio_POO_DDR_08 { public static void main(String[] args) { //Creamos los objetos Comercial c1 = new Comercial(300, "DDR", 37, 1000); Repartidor r1 = new Repartidor("zona 3", "Fer", 26, 900); //Llamamos a plus c1.plus(); r1.plus(); //Mostramos la informacion System.out.println(c1); System.out.println(r1); } } |
13) Nos piden hacer que gestionemos una serie de productos.
Los productos tienen los siguientes atributos:
- Nombre
- Precio
Tenemos dos tipos de productos:
- Perecedero: tiene un atributo llamado días a caducar
- No perecedero: tiene un atributo llamado tipo
Crea sus constructores, getters, setters y toString.
Tendremos una función llamada calcular, que según cada clase hará una cosa u otra, a esta función le pasaremos un numero siendo la cantidad de productos
- En Producto, simplemente seria multiplicar el precio por la cantidad de productos pasados.
- En Perecedero, aparte de lo que hace producto, el precio se reducirá según los días a caducar:
- Si le queda 1 día para caducar, se reducirá 4 veces el precio final.
- Si le quedan 2 días para caducar, se reducirá 3 veces el precio final.
- Si le quedan 3 días para caducar, se reducirá a la mitad de su precio final.
- En NoPerecedero, hace lo mismo que en producto
Crea una clase ejecutable y crea un array de productos y muestra el precio total de vender 5 productos de cada uno. Crea tú mismo los elementos del array.
Spoiler
— Producto
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
/** * Clase Producto, clase padre * @author DiscoDurodeRoer */ public class Producto { //Atributos private String nombre; private double precio; //Constructores public Producto(String nombre, double precio) { this.nombre = nombre; this.precio = precio; } //Metodos public String getNombre() { return nombre; } public void setNombre(String nombre) { this.nombre = nombre; } public double getPrecio() { return precio; } public void setPrecio(double precio) { this.precio = precio; } @Override public String toString() { return "nombre=" + nombre + ", precio=" + precio +", "; } /** * Indica el precio total segun una cantidad * @param cantidad * @return */ public double calcular(int cantidad){ return precio*cantidad; } } |
— Perecedero
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 |
/** * Clase Perecedero, clase hija de Producto * @author DiscoDurodeRoer */ public class Perecedero extends Producto { //Atributos private int dias_a_caducar; //Constructores public Perecedero(int dias_a_caducar, String nombre, double precio) { super(nombre, precio); this.dias_a_caducar = dias_a_caducar; } //Metodos public int getDias_a_caducar() { return dias_a_caducar; } public void setDias_a_caducar(int dias_a_caducar) { this.dias_a_caducar = dias_a_caducar; } @Override public String toString() { return super.toString() + " dias_a_caducar=" + dias_a_caducar; } /** * Calcula el precio segun una cantidad, * tambien segun los dias que le queden al prodcuto, * se reducira el precio. * * * * * * @param cantidad * @return */ @Override public double calcular(int cantidad) { double precioFinal = super.calcular(cantidad); switch (dias_a_caducar) { case 1: precioFinal /= 4; break; case 2: precioFinal /= 3; break; case 3: precioFinal /= 2; break; } return precioFinal; } } |
— No Perecedero
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
/** * Clase NoPerecedero, clase hija de Producto * No se ha implementado calcular, llama al del padre * @author DiscoDurodeRoer */ public class NoPerecedero extends Producto{ //Atributos private String tipo; //constructores public NoPerecedero(String tipo, String nombre, double precio) { super(nombre, precio); this.tipo = tipo; } //Metodos public String getTipo() { return tipo; } public void setTipo(String tipo) { this.tipo = tipo; } @Override public String toString() { return super.toString() + " tipo=" + tipo + '}'; } } |
— Main
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
public class Ejercicio_POO_DDR_09 { public static void main(String[] args) { //Creo que array de productos Producto[] productos = new Producto[3]; //Creo los elementos productos[0] = new Producto("producto 1", 10); productos[1] = new Perecedero(1, "producto 2", 20); productos[2] = new NoPerecedero("tipo 1", "producto 3", 5); //Calculo el precio double total=0; for(int i=0;i<productos.length;i++){ total += productos[i].calcular(5); //Polimorfismo } //Muestro el total System.out.println("el total es "+total); } } |
14) Nos piden hacer un almacén, vamos a usar programación orientado a objetos.
En un almacén se guardan un conjunto de bebidas.
Estos productos son bebidas como agua mineral y bebidas azucaradas (coca-cola, fanta, etc). De los productos nos interesa saber su identificador (cada uno tiene uno distinto), cantidad de litros, precio y marca.
Si es agua mineral nos interesa saber también el origen (manantial tal sitio o donde sea).
Si es una bebida azucarada queremos saber el porcentaje que tiene de azúcar y si tiene o no alguna promoción (si la tiene tendrá un descuento del 10% en el precio).
En el almacén iremos almacenado estas bebidas por estanterías (que son las columnas de la matriz).
Las operaciones del almacén son las siguientes:
- Calcular precio de todas las bebidas: calcula el precio total de todos los productos del almacén.
- Calcular el precio total de una marca de bebida: dada una marca, calcular el precio total de esas bebidas.
- Calcular el precio total de una estantería: dada una estantería (columna) calcular el precio total de esas bebidas.
- Agregar producto: agrega un producto en la primera posición libre, si el identificador esta repetido en alguno de las bebidas, no se agregará esa bebida.
- Eliminar un producto: dado un ID, eliminar el producto del almacén.
- Mostrar información: mostramos para cada bebida toda su información.
Puedes usar un main para probar las funcionalidades (añade productos, calcula precios, muestra información, etc)
Spoiler
— Bebida
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 |
public class Bebida { private static int idActual=1; private int id; private double cantidad; private double precio; private String marca; public Bebida(double cantidad, double precio, String marca){ this.id=idActual++; this.cantidad=cantidad; this.precio=precio; this.marca=marca; } public int getId() { return id; } public void setId(int id) { this.id = id; } public double getCantidad() { return cantidad; } public void setCantidad(double cantidad) { this.cantidad = cantidad; } public double getPrecio() { return precio; } public void setPrecio(double precio) { this.precio = precio; } public String getMarca() { return marca; } public void setMarca(String marca) { this.marca = marca; } @Override public String toString() { return "id=" + id + ", cantidad=" + cantidad + ", precio=" + precio + ", marca=" + marca + " "; } } |
— Bebida Azucarada
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
public class BebidaAzucarada extends Bebida { private double porcentajeAzucar; private boolean promocion; public BebidaAzucarada(double porcentajeAzucar, boolean promocion, double cantidad, double precio, String marca) { super(cantidad, precio, marca); this.porcentajeAzucar = porcentajeAzucar; this.promocion = promocion; } public double getPorcentajeAzucar() { return porcentajeAzucar; } public void setPorcentajeAzucar(double porcentajeAzucar) { this.porcentajeAzucar = porcentajeAzucar; } public boolean isPromocion() { return promocion; } public void setPromocion(boolean promocion) { this.promocion = promocion; } @Override public double getPrecio(){ if(isPromocion()){ return super.getPrecio()*0.9; }else{ return super.getPrecio(); } } @Override public String toString() { return super.toString() + "porcentajeAzucar=" + porcentajeAzucar + ", promocion=" + promocion ; } } |
— Agua mineral
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
public class AguaMineral extends Bebida { //Atributos private String manatial; //Constructores public AguaMineral(String manatial, double cantidad, double precio, String marca) { super(cantidad, precio, marca); this.manatial = manatial; } //Metodos public String getManatial() { return manatial; } public void setManatial(String manatial) { this.manatial = manatial; } @Override public String toString() { return super.toString() + "manatial=" + manatial; } } |
— Almacen
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 |
public class Almacen { //Atributos private Bebida[][] estanteria; //Constructores public Almacen(int filas, int columnas) { estanteria = new Bebida[filas][columnas]; } public Almacen() { estanteria = new Bebida[5][5]; } //Metodos /** * Agega una bebida, primera posicion que encuentre * @param b */ public void agregarBebida(Bebida b) { boolean encontrado = false; for (int i = 0; i < estanteria.length && !encontrado; i++) { for (int j = 0; j < estanteria[0].length && !encontrado; j++) { if (estanteria[i][j] == null) { estanteria[i][j] = b; //inserto la bebida encontrado = true; //Salgo } } } //Indico si se ha añadiddo la bebida o no if (encontrado) { System.out.println("Bebida añadida"); } else { System.out.println("No se ha podido añadir la bebida"); } } /** * Elimina la bebida con el id que le pasen, sino esta se indica * @param id */ public void eliminarBebida(int id) { boolean encontrado = false; for (int i = 0; i < estanteria.length && !encontrado; i++) { for (int j = 0; j < estanteria[0].length && !encontrado; j++) { if (estanteria[i][j] != null) { if (estanteria[i][j].getId() == id) { estanteria[i][j] = null; //Elimino la bebida encontrado = true; //Salgo } } } } //Indico si se ha eliminado if (encontrado) { System.out.println("Bebida eliminada"); } else { System.out.println("No existe la bebida"); } } /** * Recorro las estantenrias y muestro las bebidas */ public void mostrarBebidas() { for (int i = 0; i < estanteria.length; i++) { for (int j = 0; j < estanteria[0].length; j++) { if (estanteria[i][j] != null) {//controlo nulos System.out.println("fila " + i + ", columna: " + j + " Bebida: " + estanteria[i][j].toString()); } } } } /** * Calculo el precio de todas las bebidas * @return */ public double calcularPrecioBebidas() { double precioTotal = 0; for (int i = 0; i < estanteria.length; i++) { for (int j = 0; j < estanteria[0].length; j++) { if (estanteria[i][j] != null) {//controlo nulos precioTotal += estanteria[i][j].getPrecio();//acumulo el precio } } } return precioTotal; } /** * Calculo el precio de todas las bebidas dde una marca * @param marca * @return */ public double calcularPrecioBebidas(String marca) { double precioTotal = 0; for (int i = 0; i < estanteria.length; i++) { for (int j = 0; j < estanteria[0].length; j++) { if (estanteria[i][j] != null) {//controlo nulos if (estanteria[i][j].getMarca().equalsIgnoreCase(marca)) { precioTotal += estanteria[i][j].getPrecio(); //acumulo el precio } } } } return precioTotal; } /** * Calculo el precio de todas las bebidas de una determinada columna * @param columna * @return */ public double calcularPrecioBebidas(int columna) { double precioTotal = 0; if (columna >= 0 && columna < estanteria[0].length) { for (int i = 0; i < estanteria.length; i++) { if (estanteria[i][columna] != null) { //controlo nulos precioTotal += estanteria[i][columna].getPrecio(); //acumulo el precio } } } else { System.out.println("La columna debe estar entre 0 y " + estanteria[0].length); } return precioTotal; } } |
— Main
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
public class Ejercicio_POO_DDR_10 { public static void main(String[] args) { //Creo el almacen Almacen a = new Almacen(); Bebida b; //Añado bebidas (un poco de todo) //La forma de hacerlo es opcional for(int i=0;i<10;i++){ switch(i%2){ case 0: b=new AguaMineral("manantial1", 1.5, 5, "bezoya"); a.agregarBebida(b); break; case 1: b=new BebidaAzucarada(0.2, true, 1.5, 10, "Coca Cola"); a.agregarBebida(b); break; } } //Muestro las bebidas a.mostrarBebidas(); //Calculo el precio de todas las bebidas System.out.println("Precio de todas las bebidas "+a.calcularPrecioBebidas()); //Elimino una bebida en concreto a.eliminarBebida(4); //Muestro las bebidas a.mostrarBebidas(); // System.out.println("Precio de todas las bebidas"+a.calcularPrecioBebidas()); System.out.println("Precio de todas las bebidas de la marca bezoya" +a.calcularPrecioBebidas("bezoya")); System.out.println("Calcular el precio de la columna 0: "+a.calcularPrecioBebidas(0)); } } |
15)
Nos piden realizar una agenda telefónica de contactos.
Un contacto está definido por un nombre y un teléfono (No es necesario de validar). Un contacto es igual a otro cuando sus nombres son iguales.
Una agenda de contactos está formada por un conjunto de contactos (Piensa en que tipo puede ser)
Se podrá crear de dos formas, indicándoles nosotros el tamaño o con un tamaño por defecto (10)
Los métodos de la agenda serán los siguientes:
- aniadirContacto(Contacto c): Añade un contacto a la agenda, sino se pueden meter más a la agenda se indicara por pantalla. No se pueden meter contactos que existan, es decir, no podemos duplicar nombres, aunque tengan distinto teléfono.
- existeContacto(Conctacto c): indica si el contacto pasado existe o no.
- listarContactos(): Lista toda la agenda
- buscaContacto(String nombre): busca un contacto por su nombre y muestra su teléfono.
- eliminarContacto(Contacto c): elimina el contacto de la agenda, indica si se ha eliminado o no por pantalla
- agendaLlena(): indica si la agenda está llena.
- huecosLibres(): indica cuantos contactos más podemos meter.
Crea un menú con opciones por consola para probar todas estas funcionalidades.
Spoiler
— Contacto
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 |
/** * Representa a un contacto * @author Discoduroderoer */ public class Contacto { private String nombre; private int telefono; public Contacto(String nombre, int telefono) { this.nombre = nombre; this.telefono = telefono; } public Contacto(String nombre) { this.nombre = nombre; this.telefono = 0; } public String getNombre() { return nombre; } public void setNombre(String nombre) { this.nombre = nombre; } public int getTelefono() { return telefono; } public void setTelefono(int telefono) { this.telefono = telefono; } public boolean equals(Contacto c){ if(this.nombre.trim().equalsIgnoreCase(c.getNombre().trim())){ return true; } return false; } @Override public String toString() { return "nombre=" + nombre + ", telefono=" + telefono; } } |
— Agenda
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 |
/** * Lleva la gestion de una agenda * @author Discoduroderoer */ public class Agenda { //Atributos private Contacto[] contactos; //Constructores public Agenda() { this.contactos = new Contacto[10]; //por defecto } public Agenda(int tamanio) { this.contactos = new Contacto[tamanio]; //tamaño que nosotros queramos } //Metodos /** * Añade un contacto a la agenda * * @param c */ public void aniadirContacto(Contacto c) { if (existeContacto(c)) { //Indico si existe el contacto System.out.println("El contacto con ese nombre ya existe"); } else if (agendaLlena()) { //Indico si la agenda esta o no llena System.out.println("La agenda esta llena, no se pueden meter mas contactos"); } else { boolean encontrado = false; for (int i = 0; i < contactos.length && !encontrado; i++) { if (contactos[i] == null) { //controlo los nulos contactos[i] = c; //Inserto el contacto encontrado = true; //Indico que lo he encontrado } } if (encontrado) { System.out.println("Se ha añadido"); } else { System.out.println("No se ha podido añadir"); } } } /** * Indica si existe un contacto * * @param c * @return */ public boolean existeContacto(Contacto c) { for (int i = 0; i < contactos.length; i++) { //Controlo nulos e indico si el contacto es el mismo if (contactos[i] != null && c.equals(contactos[i])) { return true; } } return false; } /** * Lista los contactos de la agenda */ public void listarContactos() { if (huecosLibre() == contactos.length) { System.out.println("No hay contactos que mostrar"); } else { for (int i = 0; i < contactos.length; i++) { if (contactos[i] != null) { //Controlo nulos System.out.println(contactos[i]); } } } } /** * Busca un contacto por su nombre * * @param nombre */ public void buscarPorNombre(String nombre) { boolean encontrado = false; for (int i = 0; i < contactos.length && !encontrado; i++) { //Controlo nulos y cxompruebo que es el contacto buscado (forma mas engorrosa) if (contactos[i] != null && contactos[i].getNombre().trim().equalsIgnoreCase(nombre.trim())) { System.out.println("Su telefono es " + contactos[i].getTelefono()); //muestro el telefono encontrado = true; //Indico que lo he encontrado } } if (!encontrado) { System.out.println("No se ha encontrado el contacto"); } } /** * Indica si la agenda esta llena o no * * @return */ public boolean agendaLlena() { for (int i = 0; i < contactos.length; i++) { if (contactos[i] == null) { //Controlo nulos return false; //indico que no esta llena } } return true; //esta llena } /** * Elimina el contacto de la agenda * * @param c */ public void eliminarContacto(Contacto c) { boolean encontrado = false; for (int i = 0; i < contactos.length && !encontrado; i++) { if (contactos[i] != null && contactos[i].equals(c)) { contactos[i] = null; //Controlo nulos encontrado = true; //Indico que lo he encontrado } } if (encontrado) { System.out.println("Se ha eliminado el contacto"); } else { System.out.println("No se ha eliminado el contacto"); } } /** * Indica cuantos contactos más podemos meter * * @return */ public int huecosLibre() { int contadorLibres = 0; for (int i = 0; i < contactos.length; i++) { if (contactos[i] == null) { //Controlo nulos contadorLibres++; //Acumulo } } return contadorLibres; } } |
— Main
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 |
import java.util.InputMismatchException; import java.util.Scanner; public class Ejercicio_POO_DDR_11 { public static void main(String[] args) { Scanner sn = new Scanner(System.in); sn.useDelimiter("\n"); boolean salir = false; int opcion; //Guardaremos la opcion del usuario Agenda agendaTelefonica = new Agenda(3); String nombre; int telefono; Contacto c; while (!salir) { System.out.println("1. Añadir contacto"); System.out.println("2. Listar contactos"); System.out.println("3. Buscar contacto"); System.out.println("4. Existe contacto"); System.out.println("5. Eliminar contacto"); System.out.println("6. Contactos disponibles"); System.out.println("7. Agenda llena"); System.out.println("8. Salir"); try { System.out.println("Escribe una de las opciones"); opcion = sn.nextInt(); switch (opcion) { case 1: //Pido valores System.out.println("Escribe un nombre"); nombre = sn.next(); System.out.println("Escribe un telefono"); telefono = sn.nextInt(); //Creo el contacto c = new Contacto(nombre, telefono); agendaTelefonica.aniadirContacto(c); break; case 2: agendaTelefonica.listarContactos(); break; case 3: //pido el nombre System.out.println("Escribe un nombre"); nombre = sn.next(); agendaTelefonica.buscarPorNombre(nombre); break; case 4: //pido el nombre System.out.println("Escribe un nombre"); nombre = sn.next(); //Creo el contacto auxiliar c = new Contacto(nombre, 0); if (agendaTelefonica.existeContacto(c)) { System.out.println("Existe contacto"); } else { System.out.println("No existe contacto"); } break; case 5: //pido el nombre System.out.println("Escribe un nombre"); nombre = sn.next(); //Creo el contacto auxiliar c = new Contacto(nombre, 0); agendaTelefonica.eliminarContacto(c); break; case 6: System.out.println("Hay " + agendaTelefonica.huecosLibre() + " contactos libre"); break; case 7: //como devuelve un booleano, lo meto en un if if (agendaTelefonica.agendaLlena()) { System.out.println("La agenda esta llena"); } else { System.out.println("Aun puedes meter contactoss"); } break; case 8: salir = true; break; default: System.out.println("Solo números entre 1 y 8"); } } catch (InputMismatchException e) { System.out.println("Debes insertar un número"); sn.next(); } } } } |
16) Vamos a hacer unas mejoras a la clase Baraja del ejercicio 5 de POO de los videos.
Lo primero que haremos es que nuestra clase Baraja será la clase padre y será abstracta.
Le añadiremos el número de cartas en total y el número de cartas por palo.
El método crearBaraja() será abstracto.
La clase Carta tendrá un atributo genérico que será el palo de nuestra versión anterior.
Creamos dos Enum:
- PalosBarEspañola:
- OROS
- COPAS
- ESPADAS
- BASTOS
- PalosBarFrancesa:
- DIAMANTES
- PICAS
- CORAZONES
- TREBOLES
Creamos dos clases hijas:
- BarajaEspañola: tendrá un atributo boolean para indicar si queremos jugar con las cartas 8 y 9 (total 48 cartas) o no (total 40 cartas).
- BarajaFrancesa: no tendrá atributos, el total de cartas es 52 y el número de cartas por palo es de 13. Tendrá dos métodos llamados:
- cartaRoja(Carta
c): si el palo es de corazones y diamantes. - cartaNegra(Carta
c): si el palo es de tréboles y picas.
- cartaRoja(Carta
De la carta modificaremos el método toString()
Si el palo es de tipo PalosBarFrancesa:
- La carta número 11 será Jota
- La carta numero 12 será Reina
- La carta numero 13 será Rey
- La carta numero 1 será As
Si el palo es de tipo PalosBarFrancesa:
- La carta numero 10 será Sota
- La carta numero 12 será Caballo
- La carta numero 13 será Rey
- La carta numero 1 será As
Spoiler
— Palos baraja española
|
1 2 3 4 5 6 |
public enum PalosBarajaEspañola { OROS, COPAS, ESPADAS, BASTOS; } |
— Palos baraja francesa
|
1 2 3 4 5 6 |
public enum PalosBarajaFrancesa { DIAMANTES, PICAS, TREBOLES, CORAZONES; } |
— Carta
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 |
/** * Clase Carta * @author Disco Duro de Roer */ public class Carta //Atributos private int numero; private T palo; public int getNumero() { return numero; } public T getPalo() { return palo; } //Constructor public Carta(int numero, T palo) { this.numero = numero; this.palo = palo; } @Override public String toString() { String estado=""; String nombreFigura=""; if(palo.getClass().getSimpleName().equals("PalosBarajaEspañola")){ switch(numero){ case 1: nombreFigura="As"; break; case 10: nombreFigura="Sota"; break; case 11: nombreFigura="Caballo"; break; case 12: nombreFigura="Rey"; break; default: nombreFigura=numero+""; } }else if(palo.getClass().getSimpleName().equals("PalosBarajaFrancesa")){ switch(numero){ case 1: nombreFigura="As"; break; case 11: nombreFigura="Jota"; break; case 12: nombreFigura="Reina"; break; case 13: nombreFigura="Rey"; break; default: nombreFigura=numero+""; } } estado = nombreFigura + " de "+ palo; return estado; } } |
— Baraja
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 |
/** * Clase Baraja * * @author Disco Duro de Roer */ public abstract class Baraja //Atributos protected Carta protected int posSiguienteCarta; protected int numCartas; protected int cartasPorPalo; public Baraja() { this.posSiguienteCarta = 0; } /** * Metodo abstracto crearBaraja */ public abstract void crearBaraja(); /** * Baraja todas las cartas */ public void barajar() { int posAleatoria = 0; Carta c; //Recorro las cartas for (int i = 0; i < cartas.length; i++) { posAleatoria = Metodos.generaNumeroEnteroAleatorio(0, numCartas - 1); //intercambio c = cartas[i]; cartas[i] = cartas[posAleatoria]; cartas[posAleatoria] = c; } //La posición vuelve al inicio this.posSiguienteCarta = 0; } /** * Devuelve la casta donde se encuentre "posSiguienteCarta" * * @return carta del arreglo */ public Carta siguienteCarta() { Carta c = null; if (posSiguienteCarta == numCartas) { System.out.println("Ya no hay mas cartas, barajea de nuevo"); } else { c = cartas[posSiguienteCarta++]; } return c; } /** * Devuelve un numero de cartas. Controla si hay mas cartas de las que se * piden * * @param numCartas * @return */ public Carta[] darCartas(int numCartas) { if (numCartas > numCartas) { System.out.println("No se puede dar mas cartas de las que hay"); } else if (cartasDisponible() < numCartas) { System.out.println("No hay suficientes cartas que mostrar"); } else { Carta[] cartasDar = new Carta[numCartas]; //recorro el array que acabo de crear para rellenarlo for (int i = 0; i < cartasDar.length; i++) { cartasDar[i] = siguienteCarta(); //uso el metodo anterior } //Lo devuelvo return cartasDar; } //solo en caso de error return null; } /** * Indica el numero de cartas que hay disponibles * * @return */ public int cartasDisponible() { return numCartas - posSiguienteCarta; } /** * Muestro las cartas que ya han salido */ public void cartasMonton() { if (cartasDisponible() == numCartas) { System.out.println("No se ha sacado ninguna carta"); } else { //Recorro desde 0 a la posSiguienteCarta for (int i = 0; i < posSiguienteCarta; i++) { System.out.println(cartas[i]); } } } /** * Muestro las cartas que aun no han salido */ public void mostrarBaraja() { if (cartasDisponible() == 0) { System.out.println("No hay cartas que mostrar"); } else { for (int i = posSiguienteCarta; i < cartas.length; i++) { System.out.println(cartas[i]); } } } } |
— Baraja Española
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 |
/** * Baraja Española * @author Disco Duro de Roer */ public class BarajaEspañola extends Baraja { private boolean incluye_8_9; public BarajaEspañola(boolean incluye_8_9) { super(); this.incluye_8_9 = incluye_8_9; if (incluye_8_9) { numCartas = 48; cartasPorPalo = 12; } else { numCartas = 40; cartasPorPalo = 10; } crearBaraja(); //Creamos la baraja super.barajar(); // barajamos la baraja } @Override public void crearBaraja() { this.cartas = (Carta<PalosBarajaEspañola>[]) new Carta[numCartas]; PalosBarajaEspañola[] palos = PalosBarajaEspañola.values(); //Recorro los palos for (int i = 0; i < palos.length; i++) { //Recorro los numeros for (int j = 0; j < cartasPorPalo; j++) { if (incluye_8_9) { cartas[((i * cartasPorPalo) + j)] = new Carta(j + 1, palos[i]); } else { //Las posiciones del 8 y del 9 son el 7 y el 8 (emepzamos en 8) if (j >= 7) { //Solo para la sota, caballo y rey cartas[((i * cartasPorPalo) + j)] = new Carta(j + 3, palos[i]); } else { //Para los casos de 1 a 7 cartas[((i * cartasPorPalo) + j)] = new Carta(j + 1, palos[i]); } } } } } } |
–Baraja Francesa
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
/** * Baraja francesa * @author Disco Duro de Roer */ public class BarajaFrancesa extends Baraja { public BarajaFrancesa() { super(); this.numCartas = 52; this.cartasPorPalo = 13; crearBaraja(); //Creamos la baraja super.barajar(); // barajamos la baraja } @Override public void crearBaraja() { this.cartas = (Carta PalosBarajaFrancesa[] palos = PalosBarajaFrancesa.values(); //Recorro los palos for (int i = 0; i < palos.length; i++) { //Recorro los numeros for (int j = 0; j < cartasPorPalo; j++) { cartas[((i * cartasPorPalo) + j)] = new Carta(j + 1, palos[i]); } } } public boolean cartaRoja(Carta return c.getPalo() == PalosBarajaFrancesa.CORAZONES || c.getPalo() == PalosBarajaFrancesa.DIAMANTES; } public boolean cartaNegra(Carta return c.getPalo() == PalosBarajaFrancesa.TREBOLES || c.getPalo() == PalosBarajaFrancesa.PICAS; } } |
–Metodos
|
1 2 3 4 5 6 7 8 9 10 11 12 |
/** * Clase Metodos, contiene métodos estaricos sueltos * @author Disco Duro de Roer */ public class Metodos { public static int generaNumeroEnteroAleatorio(int minimo, int maximo) { int num = (int) (Math.random() * (minimo - (maximo + 1)) + (maximo + 1)); return num; } } |
— Main
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
public class Ejercicio_POO_DDR_12 { public static void main(String[] args) { //Creamos la baraja BarajaFrancesa b = new BarajaFrancesa(); //Mostramos las cartas disponibles (40) System.out.println("Hay "+b.cartasDisponible()+" cartas disponibles"); //Saco una carta b.siguienteCarta(); //Saco 5 cartas b.darCartas(5); //Mostramos las cartas disponibles (34) System.out.println("Hay "+b.cartasDisponible()+" cartas disponibles"); System.out.println("Cartas sacadas de momento"); b.cartasMonton(); //Barajamos de nuevo b.barajar(); //Saco 5 cartas Carta[] c = b.darCartas(5); System.out.println("Cartas sacadas despues de barajar "); for(int i=0;i<c.length;i++){ System.out.println(c[i]); } } } |
17)
Una academia nos pide hacer un programa para hacer un pequeño test a sus alumnos.
Estas preguntas, para facilitar la inclusión, estarán escritas en un txt (incluido en la descarga del proyecto).
Una opción se compone de:
- El texto de la opción (digamos la respuesta)
- Es correcto o no
Una pregunta consta de:
- Pregunta (tendrá delante dos puntos y coma ;P;)
- Opciones de la pregunta (entre 2 y 4)
- Opción correcta (tendrá delante dos puntos y coma ;R;)
- Puntos
La pregunta no será válida en los siguientes casos:
- Las opciones no están entre 2 y 4.
- La opción correcta esta entre el número de opciones y es un número.
- Los puntos es un número entero.
Sus métodos son:
- mostrarPregunta(): muestra la pregunta con sus opciones.
- comprobarRespuesta(int respuestaUsuario): comprueba la respuesta del usuario si es correcta o no.
- Getter de los atributos.
Un test está formado por un conjunto preguntas y los puntos acumulados. Piensa que debemos saber por cual pregunta vamos.
Sus métodos son:
- cargarPreguntas(String fichero): carga todas las preguntas del fichero
- siguientePregunta(): devuelve la siguiente pregunta
- reiniciarTest(): nos permite reiniciar el test.
- realizarTest(): empieza el test y empieza a formular las preguntas
El fichero de preguntas tiene el siguiente formato:
;P;Pregunta 1
Opción 1 pregunta 1
Opción 2 pregunta 1
Opción 3 pregunta 1
Opción 4 pregunta 1
;R;Numero opción correcta
Puntos pregunta 1
;P;Pregunta 2
Opción 1 pregunta 2
Opción 2 pregunta 2
…
…
Spoiler
— Nodo
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
/** * Clase Nodo * * @author DiscoDurodeRoer * @param */ public class Nodo //Atributos private T elemento; private Nodo //Contructor public Nodo(T elemento, Nodo this.elemento = elemento; this.siguiente = siguiente; } //Metodos public T getElemento() { return elemento; } public void setElemento(T elemento) { this.elemento = elemento; } public Nodo return siguiente; } public void setSiguiente(Nodo this.siguiente = siguiente; } @Override public String toString() { return elemento + "\n"; } } |
— Lista dinamica
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 |
/** * Lista Dinamica Version 2.0 * * @author DiscoDurodeRoer */ public class ListaDinamica //Atributos private Nodo private Nodo private int tamanio; public ListaDinamica() { primero = null; ultimo = null; tamanio = 0; } /** * Indica si esta la lista vacia o no * * @return */ public boolean isEmpty() { return tamanio == 0; } /** * Devuelve el tamaño de la lista * * @return */ public int size() { return tamanio; } /** * Devuelve el elemento en la posicion indicada * * @param index * @return */ public T get(int index) { //si esta vacio o el indice no es correcto, devuelve null if (isEmpty() || (index < 0 || index >= size())) { return null; } else if (index == 0) { return getFirst(); //Cojo el primero } else if (index == size() - 1) { return getLast(); //Cojo el ultimo } else { //Uso la funcion getNode para coger el nodo deseado Nodo return buscado.getElemento(); } } /** * Devuelve el primer elemento, null si esta vacia la lista * * @return */ public T getFirst() { //Si esta vacia, no hay primero que coger if (isEmpty()) { return null; } else { return primero.getElemento(); } } /** * Devuelve el ultimo elemento, null si esta vacia la lista * * @return */ public T getLast() { //Si esta vacia, no hay ultimo que coger if (isEmpty()) { return null; } else { return ultimo.getElemento(); } } /** * Devuelve el nodo completo de una posicion concreta * * @param index * @return */ private Nodo //si esta vacio o el indice no es correcto, devuelve null if (isEmpty() || (index < 0 || index >= size())) { return null; } else if (index == 0) { return primero; //devuelvo el primero } else if (index == size() - 1) { return ultimo; //devuelvo el ultimo } else { Nodo //Busco el nodo deseado con un recorrido int contador = 0; while (contador < index) { contador++; buscado = buscado.getSiguiente(); } //Me devuelve el buscado return buscado; } } /** * Añade un elemento al final de la lista * * @param elemento * @return elemento añadido */ public T addLast(T elemento) { Nodo //Si esta vacia, hago lo mismo que si fuera añadir el primero if (isEmpty()) { return addFirst(elemento); } else { //Hago el intercambio aux = new Nodo<>(elemento, null); ultimo.setSiguiente(aux); ultimo = aux; } //Aumento el tamanño tamanio++; return ultimo.getElemento(); } /** * Añade el elemento al principio de la lista * * @param elemento * @return elemento añadido */ public T addFirst(T elemento) { Nodo //si esta vacia, el nodo será el primero y ultimo if (isEmpty()) { aux = new Nodo<>(elemento, null); primero = aux; ultimo = aux; } else { //Hago el intercambio Nodo aux = new Nodo<>(elemento, primeroActual); primero = aux; } //Aumento el tamanño tamanio++; return primero.getElemento(); } /** * Añade un elemento en una posicion indicada * * @param elemento * @param index debe ser un indice valido * @return elemento añadido */ public T add(T elemento, int index) { //si esta vacio o el indice no es correcto, devuelve null if (index == 0) { return addFirst(elemento); //Añade en la primera posicion } else if (index == size()) { return addLast(elemento); //añade en la ultima posicion } else if ((index < 0 || index >= size())) { return null; } else { //Cojo el anterior nodo al que estoy buscando Nodo //Cojo el nodo de la posicion indicada Nodo //Creo el nuevo novo, este apuntara al de la posicion actual Nodo //el nodo anterior apunta a nuestro nuevo nodo buscado_anterior.setSiguiente(aux); //Aumento el tamaño tamanio++; return getNode(index).getElemento(); } } /** * Devuelve el estado de la lista * * @return */ public String toString() { String contenido = ""; //Si esta vacia, lo indica if (isEmpty()) { contenido = "Lista vacia"; } else { Nodo //Recorre la lista, mostrando el contenido while (aux != null) { contenido += aux.toString(); aux = aux.getSiguiente(); } } return contenido; } /** * Indica si existe el elemento indicado * * @param elemento * @return */ public boolean exists(T elemento) { //Si esta vacio, devuelve el false if (isEmpty()) { return false; } else { Nodo //Recorremos la lista while (aux != null) { if (elemento.equals(aux.getElemento())) { //Mejor .equals que == return true; //Existe } aux = aux.getSiguiente(); } //Si no lo encuentra devuelve false return false; } } /** * Indica la posición del elemento * * @param elemento * @return */ public int indexOf(T elemento) { //Si esta vacio, devuelvemos -1 if (isEmpty()) { return -1; } else { Nodo int posicion = 0; while (aux != null) { if (elemento.equals(aux.getElemento())) { //Mejor .equals que == return posicion; //Existe } posicion++; aux = aux.getSiguiente(); } //Si no lo encuentra devuelve -1 return -1; } } /** * Elimina el primer elemento de la lista * * @return */ public T removeFirst() { //Si la lista esta vacia, devolvemos null if (isEmpty()) { return null; } else { //Guardo el elemento antes T elemento = primero.getElemento(); //Cojo el segundo Nodo primero = null; //Lo marco como null para el recolector primero = aux; //Este es mi nuevo primero //En caso de que borremos el ultimo elemento,el ultimo también if (size() == 1) { ultimo = null; } tamanio--; return elemento; } } /** * Borra el ultimo elemento de la lista * * @return */ public T removeLast() { if (isEmpty()) { return null; } else { //Coge el elemento antes de borrar T elemento = ultimo.getElemento(); //Cojo el penultimo Nodo //En caso de que sea null //Hay 1 o dos elementos if (aux == null) { //marco el ultimo como nulo ultimo = null; //Si hay dos, el primero y el ultimo seran el mismo //Si hay 1 elemento, significa que borramos la lista if (size() == 2) { ultimo = primero; } else { primero = null; } } else { //el penultimo es el nuevo ultimo //y le ponemos como siguiente nulo ultimo = null; ultimo = aux; ultimo.setSiguiente(null); } tamanio--; return elemento; } } /** * Elimina el nodo de la lista en una posicion concreta * * @param index * @return */ public T remove(int index) { //si esta vacio o el indice no es correcto, devuelve null if (isEmpty() || (index < 0 || index >= size())) { return null; } else if (index == 0) { return removeFirst(); } else if (index == size() - 1) { return removeLast(); } else { //Cojo el nodo anterior al que quiero borrar Nodo //Cojo el nodo que quiero borrar Nodo //Cojo el elemento antes de borrar T elemento = nodo_actual.getElemento(); //Cojo el nodo siguiente al que quiero borrar Nodo //Lo marco para borrar para el recolector nodo_actual = null; //El nodo anterior apunta al nodo siguiente nodo_anterior.setSiguiente(nodo_siguiente); tamanio--; return elemento; } } /** * Modifico el elemento de una posicion No afecta a la estructura de la * lista * * @param elemento * @param index * @return */ public T modify(T elemento, int index) { //si esta vacio o el indice no es correcto, devuelve null if (isEmpty() || (index < 0 || index >= size())) { return null; } else { //Nodo actual Nodo //modifico aux.setElemento(elemento); return aux.getElemento(); } } } |
— Leer
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 |
import java.util.InputMismatchException; import java.util.Locale; import java.util.Scanner; /** * Clase para gestionar entrada de datos y validaciones * * @author DiscoDurodeRoer */ public class Leer { //Scanner para pedir datos private Scanner sc; /** * Por defecto */ public Leer() { sc = new Scanner(System.in); sc.useDelimiter("\n"); //Usado para nextLine() sc.useLocale(Locale.US); // Para double } /** * Nos pide un valor númerico, valida si es un valor numerico * * @return numero entero byte introducido por el usuario */ public byte pedirByte() { byte num = 0; boolean correcto; do { correcto = true; try { System.out.println("Introduce un numero entero byte"); num = sc.nextByte(); } catch (InputMismatchException ex) { // En caso de error, se marca como incorrecto correcto = false; sc.next(); } //En caso de error, muestro el error if (!correcto) { System.out.println("Error, introducce un numero entero byte"); } } while (!correcto); return num; } /** * Nos pide un valor númerico, valida si es un valor numerico * * @param mensaje * @return numero entero byte introducido por el usuario */ public byte pedirByte(String mensaje) { byte num = 0; boolean correcto; do { correcto = true; try { System.out.println(mensaje); num = sc.nextByte(); } catch (InputMismatchException ex) { // En caso de error, se marca como incorrecto correcto = false; sc.next(); } //En caso de error, muestro el error if (!correcto) { System.out.println("Error, introducce un numero entero byte"); } } while (!correcto); return num; } /** * Nos pide un valor númerico, valida si es un valor numerico * * @param mensaje * @param mensajeError * @return numero entero byte introducido por el usuario */ public byte pedirByte(String mensaje, String mensajeError) { byte num = 0; boolean correcto; do { correcto = true; try { System.out.println(mensaje); num = sc.nextByte(); } catch (InputMismatchException ex) { // En caso de error, se marca como incorrecto correcto = false; sc.next(); } //En caso de error, muestro el error if (!correcto) { System.out.println(mensajeError); } } while (!correcto); return num; } /** * Pide un valor entero positivo, valida que sea un numero y que sea * positivo * * @return numero entero byte positivo introducido por el usuario */ public byte pedirBytePositivo() { byte num; do { try { System.out.println("Introduce un numero entero byte positivo"); num = sc.nextByte(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno negativo num = -1; sc.next(); } if (num < 0) { System.out.println("Error, introducce un numero entero byte positivo"); } } while (num < 0); return num; } /** * Pide un valor entero positivo, valida que sea un numero y que sea * positivo * * @param mensaje * @return numero entero byte positivo introducido por el usuario */ public byte pedirBytePositivo(String mensaje) { byte num; do { try { System.out.println(mensaje); num = sc.nextByte(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno negativo num = -1; sc.next(); } if (num < 0) { System.out.println("Error, introducce un numero entero byte positivo"); } } while (num < 0); return num; } /** * Pide un valor entero positivo, valida que sea un numero y que sea * positivo * * @param mensaje * @param mensajeError * @return numero entero byte positivo introducido por el usuario */ public byte pedirBytePositivo(String mensaje, String mensajeError) { byte num; do { try { System.out.println(mensaje); num = sc.nextByte(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno negativo num = -1; sc.next(); } if (num < 0) { System.out.println(mensajeError); } } while (num < 0); return num; } /** * Pide un numero entero negativo, valida que sea un numero y sea negativo * * @return numero entero byte negativo introducido por el usuario */ public byte pedirByteNegativo() { byte num; do { try { System.out.println("Introduce un numero entero byte negativo"); num = sc.nextByte(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno positivo num = 1; sc.next(); } if (num >= 0) { System.out.println("Error, introducce un numero entero byte negativo"); } } while (num >= 0); return num; } /** * Pide un numero entero negativo, valida que sea un numero y sea negativo * * @param mensaje * @return numero entero byte negativo introducido por el usuario */ public byte pedirByteNegativo(String mensaje) { byte num; do { try { System.out.println(mensaje); num = sc.nextByte(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno positivo num = 1; sc.next(); } if (num >= 0) { System.out.println("Error, introducce un numero entero byte negativo"); } } while (num >= 0); return num; } /** * Pide un numero entero negativo, valida que sea un numero y sea negativo * * @param mensaje * @param mensajeError * @return numero entero byte negativo introducido por el usuario */ public byte pedirByteNegativo(String mensaje, String mensajeError) { byte num; do { try { System.out.println(mensaje); num = sc.nextByte(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno positivo num = 1; sc.next(); } if (num >= 0) { System.out.println(mensajeError); } } while (num >= 0); return num; } /** * Pide un numero entre dos numeros que le pasamos * * @param minimo * @param maximo * @return numero entero byte introducido por el usuario */ public byte pedirByteRango(byte minimo, byte maximo) { byte num; //En caso de el minimo sea mas grande, se intercambia if (minimo > maximo) { byte aux = minimo; minimo = maximo; maximo = aux; } do { try { System.out.println("Introduce un numero byte entre " + minimo + " y " + maximo); num = sc.nextByte(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como un numero no valido num = (byte) (maximo + 1); sc.next(); } if (!(num >= minimo && num <= maximo)) { System.out.println("Error, Introduce un numero byte entre " + minimo + " y " + maximo); } } while (!(num >= minimo && num <= maximo)); return num; } /** * Pide un numero entre dos numeros que le pasamos * * @param minimo * @param maximo * @param mensaje * @return numero entero byte introducido por el usuario */ public byte pedirByteRango(byte minimo, byte maximo, String mensaje) { byte num; //En caso de el minimo sea mas grande, se intercambia if (minimo > maximo) { byte aux = minimo; minimo = maximo; maximo = aux; } do { try { System.out.println(mensaje); num = sc.nextByte(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como un numero no valido num = (byte) (maximo + 1); sc.next(); } if (!(num >= minimo && num <= maximo)) { System.out.println("Error, Introduce un numero byte entre " + minimo + " y " + maximo); } } while (!(num >= minimo && num <= maximo)); return num; } /** * Pide un numero entre dos numeros que le pasamos * * @param minimo * @param maximo * @param mensaje * @param mensajeError * @return numero entero byte introducido por el usuario */ public byte pedirByteRango(byte minimo, byte maximo, String mensaje, String mensajeError) { byte num; //En caso de el minimo sea mas grande, se intercambia if (minimo > maximo) { byte aux = minimo; minimo = maximo; maximo = aux; } do { try { System.out.println(mensaje); num = sc.nextByte(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como un numero no valido num = (byte) (maximo + 1); sc.next(); } if (!(num >= minimo && num <= maximo)) { System.out.println(mensajeError); } } while (!(num >= minimo && num <= maximo)); return num; } /** * Nos pide un valor númerico, valida si es un valor numerico * * @return numero entero introducido por el usuario */ public int pedirInt() { int num = 0; boolean correcto; do { correcto = true; try { System.out.println("Introduce un numero entero integer"); num = sc.nextInt(); } catch (InputMismatchException ex) { // En caso de error, se marca como incorrecto correcto = false; sc.next(); } //En caso de error, muestro el error if (!correcto) { System.out.println("Error, introducce un numero entero integer"); } } while (!correcto); return num; } /** * Nos pide un valor númerico, valida si es un valor numerico * * @param mensaje * @return numero entero introducido por el usuario */ public int pedirInt(String mensaje) { int num = 0; boolean correcto; do { correcto = true; try { System.out.println(mensaje); num = sc.nextInt(); } catch (InputMismatchException ex) { // En caso de error, se marca como incorrecto correcto = false; sc.next(); } //En caso de error, muestro el error if (!correcto) { System.out.println("Error, introducce un numero entero integer"); } } while (!correcto); return num; } /** * Nos pide un valor númerico, valida si es un valor numerico * * @param mensaje * @param mensajeError * @return numero entero introducido por el usuario */ public int pedirInt(String mensaje, String mensajeError) { int num = 0; boolean correcto; do { correcto = true; try { System.out.println(mensaje); num = sc.nextInt(); } catch (InputMismatchException ex) { // En caso de error, se marca como incorrecto correcto = false; sc.next(); } //En caso de error, muestro el error if (!correcto) { System.out.println(mensajeError); } } while (!correcto); return num; } /** * Pide un valor entero positivo, valida que sea un numero y que sea * positivo * * @return numero entero positivo introducido por el usuario */ public int pedirIntPositivo() { int num; do { try { System.out.println("Introduce un numero entero positivo integer"); num = sc.nextInt(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno negativo num = -1; sc.next(); } if (num < 0) { System.out.println("Error, introducce un numero entero positivo integer"); } } while (num < 0); return num; } /** * Pide un valor entero positivo, valida que sea un numero y que sea * positivo * * @param mensaje * @return numero entero positivo introducido por el usuario */ public int pedirIntPositivo(String mensaje) { int num; do { try { System.out.println(mensaje); num = sc.nextInt(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno negativo num = -1; sc.next(); } if (num < 0) { System.out.println("Error, introducce un numero entero positivo integer"); } } while (num < 0); return num; } /** * Pide un valor entero positivo, valida que sea un numero y que sea * positivo * * @param mensaje * @param mensajeError * @return numero entero positivo introducido por el usuario */ public int pedirIntPositivo(String mensaje, String mensajeError) { int num; do { try { System.out.println(mensaje); num = sc.nextInt(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno negativo num = -1; sc.next(); } if (num < 0) { System.out.println(mensajeError); } } while (num < 0); return num; } /** * Pide un numero entero negativo, valida que sea un numero y sea negativo * * @return numero entero negativo introducido por el usuario */ public int pedirIntNegativo() { int num; do { try { System.out.println("Introduce un numero entero negativo integer"); num = sc.nextInt(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno positivo num = 1; sc.next(); } if (num >= 0) { System.out.println("Error, introducce un numero entero negativo integer"); } } while (num >= 0); return num; } /** * Pide un numero entero negativo, valida que sea un numero y sea negativo * * @param mensaje * @return numero entero negativo introducido por el usuario */ public int pedirIntNegativo(String mensaje) { int num; do { try { System.out.println(mensaje); num = sc.nextInt(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno positivo num = 1; sc.next(); } if (num >= 0) { System.out.println("Error, introducce un numero entero negativo integer"); } } while (num >= 0); return num; } /** * Pide un numero entero negativo, valida que sea un numero y sea negativo * * @param mensaje * @param mensajeError * @return numero entero negativo introducido por el usuario */ public int pedirIntNegativo(String mensaje, String mensajeError) { int num; do { try { System.out.println(mensaje); num = sc.nextInt(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno positivo num = 1; sc.next(); } if (num >= 0) { System.out.println(mensajeError); } } while (num >= 0); return num; } /** * Pide un numero entre dos numeros que le pasamos * * @param minimo * @param maximo * @return numero entero introducido por el usuario */ public int pedirIntRango(int minimo, int maximo) { int num; //En caso de el minimo sea mas grande, se intercambia if (minimo > maximo) { int aux = minimo; minimo = maximo; maximo = aux; } do { try { System.out.println("Introduce un numero integer entre " + minimo + " y " + maximo); num = sc.nextInt(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como un numero no valido num = maximo + 1; sc.next(); } if (!(num >= minimo && num <= maximo)) { System.out.println("Error, Introduce un numero integer entre " + minimo + " y " + maximo); } } while (!(num >= minimo && num <= maximo)); return num; } /** * Pide un numero entre dos numeros que le pasamos * * @param minimo * @param maximo * @param mensaje * @return numero entero introducido por el usuario */ public int pedirIntRango(int minimo, int maximo, String mensaje) { int num; //En caso de el minimo sea mas grande, se intercambia if (minimo > maximo) { int aux = minimo; minimo = maximo; maximo = aux; } do { try { System.out.println(mensaje); num = sc.nextInt(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como un numero no valido num = maximo + 1; sc.next(); } if (!(num >= minimo && num <= maximo)) { System.out.println("Error, Introduce un numero integer entre " + minimo + " y " + maximo); } } while (!(num >= minimo && num <= maximo)); return num; } /** * Pide un numero entre dos numeros que le pasamos * * @param minimo * @param maximo * @param mensaje * @param mensajeError * @return numero entero introducido por el usuario */ public int pedirIntRango(int minimo, int maximo, String mensaje, String mensajeError) { int num; //En caso de el minimo sea mas grande, se intercambia if (minimo > maximo) { int aux = minimo; minimo = maximo; maximo = aux; } do { try { System.out.println(mensaje); num = sc.nextInt(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como un numero no valido num = maximo + 1; sc.next(); } if (!(num >= minimo && num <= maximo)) { System.out.println(mensajeError); } } while (!(num >= minimo && num <= maximo)); return num; } /** * Pide una cadena * * @return cadena introducida por el usuario */ public String pedirString() { System.out.println("Introduce una cadena"); String cadena = sc.next(); return cadena; } /** * Pide una cadena * * @param mensaje * @return cadena introducida por el usuario */ public String pedirString(String mensaje) { System.out.println(mensaje); String cadena = sc.next(); return cadena; } /** * Pide una cadena con una longitud maxima * * @param longitudMaxima * @return cadena introducida por el usuario */ public String pedirString(int longitudMaxima) { String cadena = ""; do { System.out.println("Introduce una cadena"); cadena = sc.next(); if(!(cadena.length() < longitudMaxima)){ System.out.println("Error, la longitud maxima es "+longitudMaxima+" caracteres"); } } while (!(cadena.length() < longitudMaxima)); return cadena; } /** * Pide una cadena con una longitud maxima * * @param longitudMaxima * @param mensaje * @return cadena introducida por el usuario */ public String pedirString(int longitudMaxima, String mensaje) { String cadena = ""; do { System.out.println(mensaje); cadena = sc.next(); if(!(cadena.length() < longitudMaxima)){ System.out.println("Error, la longitud maxima es "+longitudMaxima+" caracteres"); } } while (!(cadena.length() < longitudMaxima)); return cadena; } /** * Pide una cadena con una longitud maxima * * @param longitudMaxima * @param mensaje * @param mensajeError * @return cadena introducida por el usuario */ public String pedirString(int longitudMaxima, String mensaje, String mensajeError) { String cadena = ""; do { System.out.println(mensaje); cadena = sc.next(); if(!(cadena.length() < longitudMaxima)){ System.out.println(mensajeError); } } while (!(cadena.length() < longitudMaxima)); return cadena; } /** * Nos pide un valor númerico, valida si es un valor numerico * * @return numero entero introducido por el usuario */ public long pedirLong() { long num = 0; boolean correcto; do { correcto = true; try { System.out.println("Introduce un numero entero long"); num = sc.nextLong(); } catch (InputMismatchException ex) { // En caso de error, se marca como incorrecto correcto = false; sc.next(); } //En caso de error, muestro el error if (!correcto) { System.out.println("Error, introducce un numero entero long"); } } while (!correcto); return num; } /** * Nos pide un valor númerico, valida si es un valor numerico * * @param mensaje * @return numero entero introducido por el usuario */ public long pedirLong(String mensaje) { long num = 0; boolean correcto; do { correcto = true; try { System.out.println(mensaje); num = sc.nextLong(); } catch (InputMismatchException ex) { // En caso de error, se marca como incorrecto correcto = false; sc.next(); } //En caso de error, muestro el error if (!correcto) { System.out.println("Error, introducce un numero entero long"); } } while (!correcto); return num; } /** * Nos pide un valor númerico, valida si es un valor numerico * * @param mensaje * @param mensajeError * @return numero entero introducido por el usuario */ public long pedirLong(String mensaje, String mensajeError) { long num = 0; boolean correcto; do { correcto = true; try { System.out.println(mensaje); num = sc.nextLong(); } catch (InputMismatchException ex) { // En caso de error, se marca como incorrecto correcto = false; sc.next(); } //En caso de error, muestro el error if (!correcto) { System.out.println(mensajeError); } } while (!correcto); return num; } /** * Pide un valor entero positivo, valida que sea un numero y que sea * positivo * * @return numero entero byte positivo introducido por el usuario */ public long pedirLongPositivo() { long num; do { try { System.out.println("Introduce un numero entero positivo long"); num = sc.nextLong(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno negativo num = -1; sc.next(); } if (num < 0) { System.out.println("Error, introducce un numero entero positivo long"); } } while (num < 0); return num; } /** * Pide un valor entero positivo, valida que sea un numero y que sea * positivo * * @param mensaje * @return numero entero byte positivo introducido por el usuario */ public long pedirLongPositivo(String mensaje) { long num; do { try { System.out.println(mensaje); num = sc.nextLong(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno negativo num = -1; sc.next(); } if (num < 0) { System.out.println("Error, introducce un numero entero positivo long"); } } while (num < 0); return num; } /** * Pide un valor entero positivo, valida que sea un numero y que sea * positivo * * @param mensaje * @param mensajeError * @return numero entero byte positivo introducido por el usuario */ public long pedirLongPositivo(String mensaje, String mensajeError) { long num; do { try { System.out.println(mensaje); num = sc.nextLong(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno negativo num = -1; sc.next(); } if (num < 0) { System.out.println(mensajeError); } } while (num < 0); return num; } /** * Pide un numero entero negativo, valida que sea un numero y sea negativo * * @return numero entero byte negativo introducido por el usuario */ public long pedirLongNegativo() { long num; do { try { System.out.println("Introduce un numero entero negativo long"); num = sc.nextLong(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno positivo num = 1; sc.next(); } if (num >= 0) { System.out.println("Error, introducce un numero entero negativo long"); } } while (num >= 0); return num; } /** * Pide un numero entero negativo, valida que sea un numero y sea negativo * * @param mensaje * @return numero entero byte negativo introducido por el usuario */ public long pedirLongNegativo(String mensaje) { long num; do { try { System.out.println(mensaje); num = sc.nextLong(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno positivo num = 1; sc.next(); } if (num >= 0) { System.out.println("Error, introducce un numero entero negativo long"); } } while (num >= 0); return num; } /** * Pide un numero entero negativo, valida que sea un numero y sea negativo * * @param mensaje * @param mensajeError * @return numero entero byte negativo introducido por el usuario */ public long pedirLongNegativo(String mensaje, String mensajeError) { long num; do { try { System.out.println(mensaje); num = sc.nextLong(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno positivo num = 1; sc.next(); } if (num >= 0) { System.out.println(mensajeError); } } while (num >= 0); return num; } /** * Pide un numero entre dos numeros que le pasamos * * @param minimo * @param maximo * @return numero entero byte introducido por el usuario */ public long pedirLongRango(long minimo, long maximo) { long num; //En caso de el minimo sea mas grande, se intercambia if (minimo > maximo) { long aux = minimo; minimo = maximo; maximo = aux; } do { try { System.out.println("Introduce un numero long entre " + minimo + " y " + maximo); num = sc.nextLong(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como un numero no valido num = (byte) (maximo + 1); sc.next(); } if (!(num >= minimo && num <= maximo)) { System.out.println("Error, Introduce un numero long entre " + minimo + " y " + maximo); } } while (!(num >= minimo && num <= maximo)); return num; } /** * Pide un numero entre dos numeros que le pasamos * * @param minimo * @param maximo * @param mensaje * @return numero entero byte introducido por el usuario */ public long pedirLongRango(long minimo, long maximo, String mensaje) { long num; //En caso de el minimo sea mas grande, se intercambia if (minimo > maximo) { long aux = minimo; minimo = maximo; maximo = aux; } do { try { System.out.println(mensaje); num = sc.nextLong(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como un numero no valido num = (byte) (maximo + 1); sc.next(); } if (!(num >= minimo && num <= maximo)) { System.out.println("Error, Introduce un numero long entre " + minimo + " y " + maximo); } } while (!(num >= minimo && num <= maximo)); return num; } /** * Pide un numero entre dos numeros que le pasamos * * @param minimo * @param maximo * @param mensaje * @param mensajeError * @return numero entero byte introducido por el usuario */ public long pedirLongRango(long minimo, long maximo, String mensaje, String mensajeError) { long num; //En caso de el minimo sea mas grande, se intercambia if (minimo > maximo) { long aux = minimo; minimo = maximo; maximo = aux; } do { try { System.out.println(mensaje); num = sc.nextLong(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como un numero no valido num = (byte) (maximo + 1); sc.next(); } if (!(num >= minimo && num <= maximo)) { System.out.println(mensajeError); } } while (!(num >= minimo && num <= maximo)); return num; } /** * Nos pide un valor númerico, valida si es un valor numerico * * @return numero entero introducido por el usuario */ public short pedirShort() { short num = 0; boolean correcto; do { correcto = true; try { System.out.println("Introduce un numero entero short"); num = sc.nextShort(); } catch (InputMismatchException ex) { // En caso de error, se marca como incorrecto correcto = false; sc.next(); } //En caso de error, muestro el error if (!correcto) { System.out.println("Error, introducce un numero entero short"); } } while (!correcto); return num; } /** * Nos pide un valor númerico, valida si es un valor numerico * * @param mensaje * @return numero entero introducido por el usuario */ public short pedirShort(String mensaje) { short num = 0; boolean correcto; do { correcto = true; try { System.out.println(mensaje); num = sc.nextShort(); } catch (InputMismatchException ex) { // En caso de error, se marca como incorrecto correcto = false; sc.next(); } //En caso de error, muestro el error if (!correcto) { System.out.println("Error, introducce un numero entero short"); } } while (!correcto); return num; } /** * Nos pide un valor númerico, valida si es un valor numerico * * @param mensaje * @param mensajeError * @return numero entero introducido por el usuario */ public short pedirShort(String mensaje, String mensajeError) { short num = 0; boolean correcto; do { correcto = true; try { System.out.println(mensaje); num = sc.nextShort(); } catch (InputMismatchException ex) { // En caso de error, se marca como incorrecto correcto = false; sc.next(); } //En caso de error, muestro el error if (!correcto) { System.out.println(mensajeError); } } while (!correcto); return num; } /** * Pide un valor entero positivo, valida que sea un numero y que sea * positivo * * @return numero entero byte positivo introducido por el usuario */ public short pedirShortPositivo() { short num; do { try { System.out.println("Introduce un numero entero positivo short"); num = sc.nextShort(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno negativo num = -1; sc.next(); } if (num < 0) { System.out.println("Error, introducce un numero entero positivo short"); } } while (num < 0); return num; } /** * Pide un valor entero positivo, valida que sea un numero y que sea * positivo * * @param mensaje * @return numero entero byte positivo introducido por el usuario */ public short pedirShortPositivo(String mensaje) { short num; do { try { System.out.println(mensaje); num = sc.nextShort(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno negativo num = -1; sc.next(); } if (num < 0) { System.out.println("Error, introducce un numero entero positivo short"); } } while (num < 0); return num; } /** * Pide un valor entero positivo, valida que sea un numero y que sea * positivo * * @param mensaje * @param mensajeError * @return numero entero byte positivo introducido por el usuario */ public short pedirShortPositivo(String mensaje, String mensajeError) { short num; do { try { System.out.println(mensaje); num = sc.nextShort(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno negativo num = -1; sc.next(); } if (num < 0) { System.out.println(mensajeError); } } while (num < 0); return num; } /** * Pide un numero entero negativo, valida que sea un numero y sea negativo * * @return numero entero byte negativo introducido por el usuario */ public short pedirShortNegativo() { short num; do { try { System.out.println("Introduce un numero entero negativo short"); num = sc.nextShort(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno positivo num = 1; sc.next(); } if (num >= 0) { System.out.println("Error, introducce un numero entero negativo short"); } } while (num >= 0); return num; } /** * Pide un numero entero negativo, valida que sea un numero y sea negativo * * @param mensaje * @return numero entero byte negativo introducido por el usuario */ public short pedirShortNegativo(String mensaje) { short num; do { try { System.out.println(mensaje); num = sc.nextShort(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno positivo num = 1; sc.next(); } if (num >= 0) { System.out.println("Error, introducce un numero entero negativo short"); } } while (num >= 0); return num; } /** * Pide un numero entero negativo, valida que sea un numero y sea negativo * * @param mensaje * @param mensajeError * @return numero entero byte negativo introducido por el usuario */ public short pedirShortNegativo(String mensaje, String mensajeError) { short num; do { try { System.out.println(mensaje); num = sc.nextShort(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como uno positivo num = 1; sc.next(); } if (num >= 0) { System.out.println(mensajeError); } } while (num >= 0); return num; } /** * Pide un numero entre dos numeros que le pasamos * * @param minimo * @param maximo * @return numero entero byte introducido por el usuario */ public short pedirShortRango(long minimo, long maximo) { short num; //En caso de el minimo sea mas grande, se intercambia if (minimo > maximo) { long aux = minimo; minimo = maximo; maximo = aux; } do { try { System.out.println("Introduce un numero short entre " + minimo + " y " + maximo); num = sc.nextShort(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como un numero no valido num = (byte) (maximo + 1); sc.next(); } if (!(num >= minimo && num <= maximo)) { System.out.println("Error, Introduce un numero short entre " + minimo + " y " + maximo); } } while (!(num >= minimo && num <= maximo)); return num; } /** * Pide un numero entre dos numeros que le pasamos * * @param minimo * @param maximo * @param mensaje * @return numero entero byte introducido por el usuario */ public short pedirShortRango(short minimo, short maximo, String mensaje) { short num; //En caso de el minimo sea mas grande, se intercambia if (minimo > maximo) { short aux = minimo; minimo = maximo; maximo = aux; } do { try { System.out.println(mensaje); num = sc.nextShort(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como un numero no valido num = (byte) (maximo + 1); sc.next(); } if (!(num >= minimo && num <= maximo)) { System.out.println("Error, Introduce un numero short entre " + minimo + " y " + maximo); } } while (!(num >= minimo && num <= maximo)); return num; } /** * Pide un numero entre dos numeros que le pasamos * * @param minimo * @param maximo * @param mensaje * @param mensajeError * @return numero entero byte introducido por el usuario */ public short pedirShortRango(short minimo, short maximo, String mensaje, String mensajeError) { short num; //En caso de el minimo sea mas grande, se intercambia if (minimo > maximo) { short aux = minimo; minimo = maximo; maximo = aux; } do { try { System.out.println(mensaje); num = sc.nextShort(); } catch (InputMismatchException ex) { // En caso de error, el num se marca como un numero no valido num = (byte) (maximo + 1); sc.next(); } if (!(num >= minimo && num <= maximo)) { System.out.println(mensajeError); } } while (!(num >= minimo && num <= maximo)); return num; } /** * Pide un double, valida que sea un numero * * @return double introducido por el usuario */ public double pedirDouble() { double real = 0; boolean correcto; do { correcto = true; try { System.out.println("Introduce un numero real double"); real = sc.nextDouble(); } catch (InputMismatchException ex) { // En caso de error, se marca como incorrecto correcto = false; sc.next(); } if (!correcto) { System.out.println("Error, introduce un numero real double"); } } while (!correcto); return real; } /** * Pide un double, valida que sea un numero * * @param mensaje * @return double introducido por el usuario */ public double pedirDouble(String mensaje) { double real = 0; boolean correcto; do { correcto = true; try { System.out.println(mensaje); real = sc.nextDouble(); } catch (InputMismatchException ex) { // En caso de error, se marca como incorrecto correcto = false; sc.next(); } if (!correcto) { System.out.println("Error, introduce un numero real"); } } while (!correcto); return real; } /** * Pide un double, valida que sea un numero * * @param mensaje * @param mensajeError * @return double introducido por el usuario */ public double pedirDouble(String mensaje, String mensajeError) { double real = 0; boolean correcto; do { correcto = true; try { System.out.println(mensaje); real = sc.nextDouble(); } catch (InputMismatchException ex) { // En caso de error, se marca como incorrecto correcto = false; sc.next(); } if (!correcto) { System.out.println(mensajeError); } } while (!correcto); return real; } /** * Pide un double positivo, valida que sea un numero y positivo * * @return double positivo introducido por el usuario */ public double pedirDoublePositivo() { double real; do { try { System.out.println("Introduce un numero real positivo double"); real = sc.nextDouble(); } catch (InputMismatchException ex) { real = -1; sc.next(); } if (real < 0) { System.out.println("Error, introducce un numero real positivo double"); } } while (real < 0); return real; } /** * Pide un double positivo, valida que sea un numero y positivo * * @param mensaje * @return double positivo introducido por el usuario */ public double pedirDoublePositivo(String mensaje) { double real; do { try { System.out.println(mensaje); real = sc.nextDouble(); } catch (InputMismatchException ex) { real = -1; sc.next(); } if (real < 0) { System.out.println("Error, introducce un numero real positivo double"); } } while (real < 0); return real; } /** * Pide un double positivo, valida que sea un numero y positivo * * @param mensaje * @param mensajeError * @return double positivo introducido por el usuario */ public double pedirDoublePositivo(String mensaje, String mensajeError) { double real; do { try { System.out.println(mensaje); real = sc.nextDouble(); } catch (InputMismatchException ex) { real = -1; sc.next(); } if (real < 0) { System.out.println(mensajeError); } } while (real < 0); return real; } /** * Pide un double negativo, valida que sea un numero y negativo * * @return double negativo introducido por el usuario */ public double pedirDoubleNegativo() { double real; do { try { System.out.println("Introduce un numero real negativo double"); real = sc.nextDouble(); } catch (InputMismatchException ex) { real = 1; sc.next(); } if (real >= 0) { System.out.println("Error, introducce un numero real negativo double"); } } while (real >= 0); return real; } /** * Pide un double negativo, valida que sea un numero y negativo * * @param mensaje * @return double negativo introducido por el usuario */ public double pedirDoubleNegativo(String mensaje) { double real; do { try { System.out.println(mensaje); real = sc.nextDouble(); } catch (InputMismatchException ex) { real = 1; sc.next(); } if (real >= 0) { System.out.println("Error, introducce un numero real negativo double"); } } while (real >= 0); return real; } /** * Pide un double negativo, valida que sea un numero y negativo * * @param mensaje * @param mensajeError * @return double negativo introducido por el usuario */ public double pedirDoubleNegativo(String mensaje, String mensajeError) { double real; do { try { System.out.println(mensaje); real = sc.nextDouble(); } catch (InputMismatchException ex) { real = 1; sc.next(); } if (real >= 0) { System.out.println(mensajeError); } } while (real >= 0); return real; } /** * Pide un double entre en un rango, valida que sea un numero * * @param minimo * @param maximo * @return double entre un rango introducido por el usuario */ public double pedirDoubleRango(double minimo, double maximo) { double real; //En caso de el minimo sea mas grande, se intercambia if (minimo > maximo) { double aux = minimo; minimo = maximo; maximo = aux; } do { try { System.out.println("Introduce un numero double entre " + minimo + " y " + maximo); real = sc.nextDouble(); } catch (InputMismatchException ex) { real = maximo + 1; sc.next(); } if (!(real >= minimo && real <= maximo)) { System.out.println("Error, Introduce un numero double entre " + minimo + " y " + maximo + " como maximo"); } } while (!(real >= minimo && real <= maximo)); return real; } /** * Pide un double entre en un rango, valida que sea un numero * * @param minimo * @param maximo * @param mensaje * @return double entre un rango introducido por el usuario */ public double pedirDoubleRango(double minimo, double maximo, String mensaje) { double real; //En caso de el minimo sea mas grande, se intercambia if (minimo > maximo) { double aux = minimo; minimo = maximo; maximo = aux; } do { try { System.out.println(mensaje); real = sc.nextDouble(); } catch (InputMismatchException ex) { real = maximo + 1; sc.next(); } if (!(real >= minimo && real <= maximo)) { System.out.println("Error, Introduce un numero double entre " + minimo + " y " + maximo + " como maximo"); } } while (!(real >= minimo && real <= maximo)); return real; } /** * Pide un double entre en un rango, valida que sea un numero * * @param minimo * @param maximo * @param mensaje * @param mensajeError * @return double entre un rango introducido por el usuario */ public double pedirDoubleRango(double minimo, double maximo, String mensaje, String mensajeError) { double real; //En caso de el minimo sea mas grande, se intercambia if (minimo > maximo) { double aux = minimo; minimo = maximo; maximo = aux; } do { try { System.out.println(mensaje); real = sc.nextDouble(); } catch (InputMismatchException ex) { real = maximo + 1; sc.next(); } if (!(real >= minimo && real <= maximo)) { System.out.println(mensajeError); } } while (!(real >= minimo && real <= maximo)); return real; } /** * Pide un double, con un numero de decimales como maximo * * @param decimales * @return double con un double con unos decimales menos que lo indicado */ public double pedirDoubleDecimales(int decimales) { if (decimales < 1) { decimales = 1; } double real = 0; boolean correcto; String[] parteDecimal; do { correcto = true; try { System.out.println("Introduce un numero real double con "+decimales+" decimales como maximo"); real = sc.nextDouble(); } catch (InputMismatchException ex) { correcto = false; sc.next(); } if (!correcto) { System.out.println("Error, introduce un numero real double"); } else { parteDecimal = String.valueOf(real).split("\\."); if (parteDecimal[1].length() > decimales) { correcto = false; System.out.println("Error, el numero de decimales debe ser " + decimales + " como maximo"); } } } while (!correcto); return real; } /** * Pide un double, con un numero de decimales como maximo * * @param decimales * @param mensaje * @return double con un double con unos decimales menos que lo indicado */ public double pedirDoubleDecimales(int decimales, String mensaje) { if (decimales < 1) { decimales = 1; } double real = 0; boolean correcto; String[] parteDecimal; do { correcto = true; try { System.out.println(mensaje); real = sc.nextDouble(); } catch (InputMismatchException ex) { correcto = false; sc.next(); } if (!correcto) { System.out.println("Error, introduce un numero real double"); } else { parteDecimal = String.valueOf(real).split("\\."); if (parteDecimal[1].length() > decimales) { correcto = false; System.out.println("Error, el numero de decimales debe ser " + decimales + " como maximo"); } } } while (!correcto); return real; } /** * Pide un double, con un numero de decimales como maximo * * @param decimales * @param mensaje * @param mensajeError * @return double con un double con unos decimales menos que lo indicado */ public double pedirDoubleDecimales(int decimales, String mensaje, String mensajeError) { if (decimales < 1) { decimales = 1; } double real = 0; boolean correcto; String[] parteDecimal; do { correcto = true; try { System.out.println(mensaje); real = sc.nextDouble(); } catch (InputMismatchException ex) { correcto = false; sc.next(); } if (!correcto) { System.out.println(mensajeError); } else { parteDecimal = String.valueOf(real).split("\\."); if (parteDecimal[1].length() > decimales) { correcto = false; System.out.println("Error, el numero de decimales debe ser " + decimales + " como maximo"); } } } while (!correcto); return real; } /** * Pide un double positivo, con un numero de decimales como maximo * * @param decimales * @return double con un double positivo con unos decimales menos que lo * indicado */ public double pedirDoublePositivoDecimales(int decimales) { double real; String[] parteDecimal; do { try { System.out.println("Introduce un numero real positivo double con "+decimales+" decimales como maximo"); real = sc.nextDouble(); } catch (InputMismatchException ex) { real = -1; sc.next(); } if (real < 0) { System.out.println("Error, introducce un numero real positivo double"); } else { parteDecimal = String.valueOf(real).split("\\."); if (parteDecimal[1].length() > decimales) { real = -1; System.out.println("Error, el numero de decimales debe ser " + decimales); } } } while (real < 0); return real; } /** * Pide un double positivo, con un numero de decimales como maximo * * @param decimales * @param mensaje * @return double con un double positivo con unos decimales menos que lo * indicado */ public double pedirDoublePositivoDecimales(int decimales, String mensaje) { double real; String[] parteDecimal; do { try { System.out.println(mensaje); real = sc.nextDouble(); } catch (InputMismatchException ex) { real = -1; sc.next(); } if (real < 0) { System.out.println("Error, introducce un numero real positivo double"); } else { parteDecimal = String.valueOf(real).split("\\."); if (parteDecimal[1].length() > decimales) { real = -1; System.out.println("Error, el numero de decimales debe ser " + decimales); } } } while (real < 0); return real; } /** * Pide un double positivo, con un numero de decimales como maximo * * @param decimales * @param mensaje * @param mensajeError * @return double con un double positivo con unos decimales menos que lo * indicado */ public double pedirDoublePositivoDecimales(int decimales, String mensaje, String mensajeError) { double real; String[] parteDecimal; do { try { System.out.println(mensaje); real = sc.nextDouble(); } catch (InputMismatchException ex) { real = -1; sc.next(); } if (real < 0) { System.out.println(mensajeError); } else { parteDecimal = String.valueOf(real).split("\\."); if (parteDecimal[1].length() > decimales) { real = -1; System.out.println("Error, el numero de decimales debe ser " + decimales); } } } while (real < 0); return real; } /** * Pide un float, valida que sea un numero * * @return float introducido por el usuario */ public float pedirFloat() { float real = 0; boolean correcto; do { correcto = true; try { System.out.println("Introduce un numero real float"); real = sc.nextFloat(); } catch (InputMismatchException ex) { // En caso de error, se marca como incorrecto correcto = false; sc.next(); } if (!correcto) { System.out.println("Error, introduce un numero real float"); } } while (!correcto); return real; } /** * Pide un float, valida que sea un numero * * @param mensaje * @return float introducido por el usuario */ public float pedirFloat(String mensaje) { float real = 0; boolean correcto; do { correcto = true; try { System.out.println(mensaje); real = sc.nextFloat(); } catch (InputMismatchException ex) { // En caso de error, se marca como incorrecto correcto = false; sc.next(); } if (!correcto) { System.out.println("Error, introduce un numero real float"); } } while (!correcto); return real; } /** * Pide un float, valida que sea un numero * * @param mensaje * @param mensajeError * @return float introducido por el usuario */ public float pedirFloat(String mensaje, String mensajeError) { float real = 0; boolean correcto; do { correcto = true; try { System.out.println(mensaje); real = sc.nextFloat(); } catch (InputMismatchException ex) { // En caso de error, se marca como incorrecto correcto = false; sc.next(); } if (!correcto) { System.out.println(mensajeError); } } while (!correcto); return real; } /** * Pide un float positivo, valida que sea un numero y positivo * * @return float positivo introducido por el usuario */ public float pedirFloatPositivo() { float real; do { try { System.out.println("Introduce un numero real positivo float"); real = sc.nextFloat(); } catch (InputMismatchException ex) { real = -1; sc.next(); } if (real < 0) { System.out.println("Error, introducce un numero real positivo float"); } } while (real < 0); return real; } /** * Pide un float positivo, valida que sea un numero y positivo * * @param mensaje * @return float positivo introducido por el usuario */ public float pedirFloatPositivo(String mensaje) { float real; do { try { System.out.println(mensaje); real = sc.nextFloat(); } catch (InputMismatchException ex) { real = -1; sc.next(); } if (real < 0) { System.out.println("Error, introducce un numero real positivo float"); } } while (real < 0); return real; } /** * Pide un float positivo, valida que sea un numero y positivo * * @param mensaje * @param mensajeError * @return float positivo introducido por el usuario */ public float pedirFloatPositivo(String mensaje, String mensajeError) { float real; do { try { System.out.println(mensaje); real = sc.nextFloat(); } catch (InputMismatchException ex) { real = -1; sc.next(); } if (real < 0) { System.out.println(mensajeError); } } while (real < 0); return real; } /** * Pide un float negativo, valida que sea un numero y negativo * * @return float negativo introducido por el usuario */ public float pedirFloatNegativo() { float real; do { try { System.out.println("Introduce un numero real negativo float"); real = sc.nextFloat(); } catch (InputMismatchException ex) { real = 1; sc.next(); } if (real >= 0) { System.out.println("Error, introducce un numero real negativo float"); } } while (real >= 0); return real; } /** * Pide un float negativo, valida que sea un numero y negativo * * @param mensaje * @return float negativo introducido por el usuario */ public float pedirFloatNegativo(String mensaje) { float real; do { try { System.out.println(mensaje); real = sc.nextFloat(); } catch (InputMismatchException ex) { real = 1; sc.next(); } if (real >= 0) { System.out.println("Error, introducce un numero real negativo float"); } } while (real >= 0); return real; } /** * Pide un float negativo, valida que sea un numero y negativo * * @param mensaje * @param mensajeError * @return float negativo introducido por el usuario */ public float pedirFloatNegativo(String mensaje, String mensajeError) { float real; do { try { System.out.println(mensaje); real = sc.nextFloat(); } catch (InputMismatchException ex) { real = 1; sc.next(); } if (real >= 0) { System.out.println(mensajeError); } } while (real >= 0); return real; } /** * Pide un float entre en un rango, valida que sea un numero * * @param minimo * @param maximo * @return float entre un rango introducido por el usuario */ public float pedirFloatRango(float minimo, float maximo) { float real; //En caso de el minimo sea mas grande, se intercambia if (minimo > maximo) { float aux = minimo; minimo = maximo; maximo = aux; } do { try { System.out.println("Introduce un numero float entre " + minimo + " y " + maximo); real = sc.nextFloat(); } catch (InputMismatchException ex) { real = maximo + 1; sc.next(); } if (!(real >= minimo && real <= maximo)) { System.out.println("Error, Introduce un numero float entre " + minimo + " y " + maximo + " como maximo"); } } while (!(real >= minimo && real <= maximo)); return real; } /** * Pide un float entre en un rango, valida que sea un numero * * @param minimo * @param maximo * @param mensaje * @return float entre un rango introducido por el usuario */ public float pedirFloatRango(float minimo, float maximo, String mensaje) { float real; //En caso de el minimo sea mas grande, se intercambia if (minimo > maximo) { float aux = minimo; minimo = maximo; maximo = aux; } do { try { System.out.println(mensaje); real = sc.nextFloat(); } catch (InputMismatchException ex) { real = maximo + 1; sc.next(); } if (!(real >= minimo && real <= maximo)) { System.out.println("Error, Introduce un numero float entre " + minimo + " y " + maximo + " como maximo"); } } while (!(real >= minimo && real <= maximo)); return real; } /** * Pide un float entre en un rango, valida que sea un numero * * @param minimo * @param maximo * @param mensaje * @param mensajeError * @return float entre un rango introducido por el usuario */ public float pedirFloatRango(float minimo, float maximo, String mensaje, String mensajeError) { float real; //En caso de el minimo sea mas grande, se intercambia if (minimo > maximo) { float aux = minimo; minimo = maximo; maximo = aux; } do { try { System.out.println(mensaje); real = sc.nextFloat(); } catch (InputMismatchException ex) { real = maximo + 1; sc.next(); } if (!(real >= minimo && real <= maximo)) { System.out.println(mensajeError); } } while (!(real >= minimo && real <= maximo)); return real; } /** * Pide un float, con un numero de decimales como maximo * * @param decimales * @return float con unos decimales menos que lo indicado */ public float pedirFloatDecimales(int decimales) { if (decimales < 1) { decimales = 1; } float real = 0; boolean correcto; String[] parteDecimal; do { correcto = true; try { System.out.println("Introduce un numero real float con "+decimales+" decimales como maximo"); real = sc.nextFloat(); } catch (InputMismatchException ex) { correcto = false; sc.next(); } if (!correcto) { System.out.println("Error, introduce un numero real float"); } else { parteDecimal = String.valueOf(real).split("\\."); if (parteDecimal[1].length() > decimales) { correcto = false; System.out.println("Error, el numero de decimales debe ser " + decimales + " como maximo"); } } } while (!correcto); return real; } /** * Pide un float, con un numero de decimales como maximo * * @param decimales * @param mensaje * @return float con unos decimales menos que lo indicado */ public float pedirFloatDecimales(int decimales, String mensaje) { if (decimales < 1) { decimales = 1; } float real = 0; boolean correcto; String[] parteDecimal; do { correcto = true; try { System.out.println(mensaje); real = sc.nextFloat(); } catch (InputMismatchException ex) { correcto = false; sc.next(); } if (!correcto) { System.out.println("Error, introduce un numero real float con "+decimales+" decimales como maximo"); } else { parteDecimal = String.valueOf(real).split("\\."); if (parteDecimal[1].length() > decimales) { correcto = false; System.out.println("Error, el numero de decimales debe ser " + decimales + " como maximo"); } } } while (!correcto); return real; } /** * Pide un float, con un numero de decimales como maximo * * @param decimales * @param mensaje * @param mensajeError * @return float con unos decimales menos que lo indicado */ public float pedirFloatDecimales(int decimales, String mensaje, String mensajeError) { if (decimales < 1) { decimales = 1; } float real = 0; boolean correcto; String[] parteDecimal; do { correcto = true; try { System.out.println(mensaje); real = sc.nextFloat(); } catch (InputMismatchException ex) { correcto = false; sc.next(); } if (!correcto) { System.out.println(mensajeError); } else { parteDecimal = String.valueOf(real).split("\\."); if (parteDecimal[1].length() > decimales) { correcto = false; System.out.println("Error, el numero de decimales debe ser " + decimales + " como maximo"); } } } while (!correcto); return real; } /** * Pide un float positivo, con un numero de decimales como maximo * * @param decimales * @return float positivo con unos decimales menos que lo * indicado */ public float pedirFloatPositivoDecimales(int decimales) { float real; String[] parteDecimal; do { try { System.out.println("Introduce un numero real positivo float con "+decimales+" decimales como maximo"); real = sc.nextFloat(); } catch (InputMismatchException ex) { real = -1; sc.next(); } if (real < 0) { System.out.println("Error, introducce un numero real positivo float"); } else { parteDecimal = String.valueOf(real).split("\\."); if (parteDecimal[1].length() > decimales) { real = -1; System.out.println("Error, el numero de decimales debe ser " + decimales); } } } while (real < 0); return real; } /** * Pide un float positivo, con un numero de decimales como maximo * * @param decimales * @param mensaje * @return double con un float positivo con unos decimales menos que lo * indicado */ public float pedirFloatPositivoDecimales(int decimales, String mensaje) { float real; String[] parteDecimal; do { try { System.out.println(mensaje); real = sc.nextFloat(); } catch (InputMismatchException ex) { real = -1; sc.next(); } if (real < 0) { System.out.println("Error, introducce un numero real positivo float"); } else { parteDecimal = String.valueOf(real).split("\\."); if (parteDecimal[1].length() > decimales) { real = -1; System.out.println("Error, el numero de decimales debe ser " + decimales); } } } while (real < 0); return real; } /** * Pide un float positivo, con un numero de decimales como maximo * * @param decimales * @param mensaje * @param mensajeError * @return float positivo con unos decimales menos que lo * indicado */ public float pedirFloatPositivoDecimales(int decimales, String mensaje, String mensajeError) { float real; String[] parteDecimal; do { try { System.out.println(mensaje); real = sc.nextFloat(); } catch (InputMismatchException ex) { real = -1; sc.next(); } if (real < 0) { System.out.println(mensajeError); } else { parteDecimal = String.valueOf(real).split("\\."); if (parteDecimal[1].length() > decimales) { real = -1; System.out.println("Error, el numero de decimales debe ser " + decimales); } } } while (real < 0); return real; } /** * Pide un char, si tiene mas de un caracter, coge el primero * * @return */ public char pedirChar() { System.out.println("Introduce un caracter (en caso de tener mas de un caracter, se cogera el primer caracter)"); char caracter = sc.next().charAt(0); return caracter; } /** * Pide un char, si tiene mas de un caracter, coge el primero * * @param mensaje * @return */ public char pedirChar(String mensaje) { System.out.println(mensaje); char caracter = sc.next().charAt(0); return caracter; } /** * Pide un booleano, valida que sea un booleano * * @return booleano introducido por el usuario */ public boolean pedirBoolean() { boolean booleano = false, correcto; do { correcto = true; try { System.out.println("Introduce un booleano (true o false)"); booleano = sc.nextBoolean(); } catch (Exception ex) { correcto = false; sc.next(); } if (!correcto) { System.out.println("Error, introduce un valor booleano"); } } while (!correcto); return booleano; } /** * Pide un booleano, valida que sea un booleano * * @param mensaje * @return booleano introducido por el usuario */ public boolean pedirBoolean(String mensaje) { boolean booleano = false, correcto; do { correcto = true; try { System.out.println(mensaje); booleano = sc.nextBoolean(); } catch (Exception ex) { correcto = false; sc.next(); } if (!correcto) { System.out.println("Error, introduce un valor booleano"); } } while (!correcto); return booleano; } /** * Pide un booleano, valida que sea un booleano * * @param mensaje * @param mensajeError * @return booleano introducido por el usuario */ public boolean pedirBoolean(String mensaje, String mensajeError) { boolean booleano = false, correcto; do { correcto = true; try { System.out.println(mensaje); booleano = sc.nextBoolean(); } catch (Exception ex) { correcto = false; sc.next(); } if (!correcto) { System.out.println(mensajeError); } } while (!correcto); return booleano; } /** * Pide al usuario un si o un no, true = si, no = false * * @return booleano introducido por el usuario */ public boolean pedirBooleanSiNo() { boolean correcto, booleano = false; String respuesta = ""; do { correcto = true; try { System.out.println("Introduce Si o No"); respuesta = sc.next(); respuesta = respuesta.toLowerCase().trim(); } catch (Exception ex) { correcto = false; sc.next(); } if (respuesta.equals("si")) { booleano = true; } else if (respuesta.equals("no")) { booleano = false; } else { correcto = false; } if (!(respuesta.equals("si")) || respuesta.equals("no")) { correcto = false; } if (!correcto) { System.out.println("Error, introduce un valor booleano"); } } while (!correcto); return booleano; } /** * Pide al usuario un si o un no, true = si, no = false * * @param mensaje * @return booleano introducido por el usuario */ public boolean pedirBooleanSiNo(String mensaje) { boolean correcto, booleano = false; String respuesta = ""; do { correcto = true; try { System.out.println(mensaje); respuesta = sc.next(); respuesta = respuesta.toLowerCase().trim(); } catch (Exception ex) { correcto = false; sc.next(); } if (respuesta.equals("si")) { booleano = true; } else if (respuesta.equals("no")) { booleano = false; } else { correcto = false; } if (!(respuesta.equals("si")) || respuesta.equals("no")) { correcto = false; } if (!correcto) { System.out.println("Error, introduce un valor booleano"); } } while (!correcto); return booleano; } /** * Pide al usuario un si o un no, true = si, no = false * * @param mensaje * @param mensajeError * @return booleano introducido por el usuario */ public boolean pedirBooleanSiNo(String mensaje, String mensajeError) { boolean correcto, booleano = false; String respuesta = ""; do { correcto = true; try { System.out.println(mensaje); respuesta = sc.next(); respuesta = respuesta.toLowerCase().trim(); } catch (Exception ex) { correcto = false; sc.next(); } if (respuesta.equals("si")) { booleano = true; } else if (respuesta.equals("no")) { booleano = false; } else { correcto = false; } if (!(respuesta.equals("si")) || respuesta.equals("no")) { correcto = false; } if (!correcto) { System.out.println(mensajeError); } } while (!correcto); return booleano; } } |
— Pregunta
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
import listaDinamica.ListaDinamica; public class Pregunta { private String pregunta; private ListaDinamica private int puntos; public Pregunta(String pregunta, ListaDinamica this.pregunta = pregunta; this.respuestas = respuestas; this.puntos = puntos; } public String getPregunta() { return pregunta; } public ListaDinamica return respuestas; } public int getPuntos() { return puntos; } public void mostrarPregunta(){ System.out.println(pregunta); int i=0; while(i<respuestas.size()){ System.out.println("\t"+(i+1)+". "+respuestas.get(i)); i++; } } public boolean comprobarRespuesta(int respuesta){ Respuesta r = respuestas.get(respuesta - 1); if(r!=null){ return r.isCorrecta(); } return false; } } |
— Respuesta
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
public class Respuesta { private String respuesta; private boolean correcta; public Respuesta(String respuesta) { this.respuesta = respuesta; } public String getRespuesta() { return respuesta; } public boolean isCorrecta() { return correcta; } public void setCorrecta(boolean correcta) { this.correcta = correcta; } @Override public String toString() { return respuesta; } } |
— Test
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 |
import Leer.Leer; import java.io.BufferedReader; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import listaDinamica.ListaDinamica; public class Test { //atributos private ListaDinamica private int puntosTotales; private int preguntaActual; //Constructor public Test() { preguntas = new ListaDinamica<>(); puntosTotales = 0; preguntaActual = 0; } //Getter public ListaDinamica return preguntas; } public int getPuntosTotales() { return puntosTotales; } public int getPreguntaActual() { return preguntaActual; } public Pregunta siguientePregunta() { //cojo la siguiente pregunta Pregunta p = preguntas.get(preguntaActual); //si la pregunta es distinto de null, paso la siguiente if (p != null) { preguntaActual++; } return p; } public void reiniciarTest() { preguntaActual = 0; puntosTotales = 0; } public void realizarTest() { //si estan vacias las preguntas, no hacemos nada if (preguntas.isEmpty()) { System.out.println("No hay preguntas"); } else { //Creamos un objeto leer Leer teclado = new Leer(); int i = 0, respuesta; Pregunta p; //recorremos las preguntas while (i < preguntas.size()) { //Cojemos una pregunta p = preguntas.get(i); //La mostramos p.mostrarPregunta(); //Pedimos una respuesta respuesta = teclado.pedirIntRango(1, p.getRespuestas().size(), "Introduce la respuesta"); //Comprobamos si es correcta o no if (p.comprobarRespuesta(respuesta)) { System.out.println("Has acertado"); puntosTotales += p.getPuntos(); } else { System.out.println("No has acertado"); } i++; } } //muestro los puntos System.out.println("Has obtenido " + puntosTotales + " puntos"); } public void cargarFichero(String fichero) throws FileNotFoundException, IOException { //Creo el buffer BufferedReader br = new BufferedReader(new FileReader(fichero)); //variables necesarias String linea; Pregunta p; ListaDinamica String texto_pregunta = ""; int puntosPregunta = 0, opcioncorrecta = 0; boolean pregunta = false, respuesta = false, puntos = false; //leo el fichero while ((linea = br.readLine()) != null) { try { //si empieza por ;P; es una pregunta if (linea.startsWith(";P;")) { texto_pregunta = linea.substring(3); pregunta = true; //marco que ya tengo la pregunta //si tengo la pregunta y empieza por ;R; cojo la respuesta correcta } else if (pregunta && linea.startsWith(";R;")) { opcioncorrecta = Integer.parseInt(linea.substring(3).trim()); respuesta = true; //marco que ya tengo la respuesta //Si la respuesta esta marcada, cojo los puntos } else if (respuesta) { puntosPregunta = Integer.parseInt(linea.trim()); puntos = true; //marco los puntos //Si tengo la pregunta marcada, cojo la respuesta //Lo pongo el ultimo en caso de que no haya nada mas } else if (pregunta) { respuestas.addLast(new Respuesta(linea)); //Si tiene mas de 4 respuestas, lanzo excepcion if (respuestas.size() > 4) { throw new Exception(); } } //Si tenemos marcado la pregunta, la respuesta, los puntos y hay entre 2 y 4 opciones if (pregunta && respuesta && puntos && (respuestas.size() >= 2 && respuestas.size() <= 4)) { //Marcamos la respuesta correcta como la correcta respuestas.get(opcioncorrecta - 1).setCorrecta(true); //creo la pregunta p = new Pregunta(texto_pregunta, respuestas, puntosPregunta); //añado la pregunta preguntas.addLast(p); //reincio pregunta = false; respuesta = false; puntos = false; respuestas = new ListaDinamica<>(); } } catch (Exception ex) { //reincio pregunta = false; respuesta = false; puntos = false; respuestas = new ListaDinamica<>(); } } br.close(); } } |
— Main
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
import java.io.IOException; public class Ejercicio_POO_DDR_13 { public static void main(String[] args) { Test t=new Test(); try { t.cargarFichero("preguntas-incorrecto.txt"); t.realizarTest(); } catch (IOException ex) { System.out.println(ex.getMessage()); } } } |
Espero que os sea de ayuda. Si tenéis dudas, preguntad. Estamos para ayudarte.
Excelente articulo, me encantaría que incluyeran alguno avanzado, de tipo diseño orientado a objetos con java, con ejercicios y resueltos. Desde ya gracias y ojala se pueda hacer lo que les comento!
Un saludo, Traffic Club y El Talco Negro.
Muchas gracias por tú tiempo y tú trabajo me parece genial la forma de enfocar el tema de java y sus ejemplos. Enhorabuena.
En el ejemplo 2, el de la clase Password el compilador da un par de errores que no consigo solventar:
1. Dentro de la clase Password:
public Password (){
this(LONG_DEF);
}
2. Dentro de la clase ejecutable, dentro del bucle for:
listaPassword[i]=new Password(longitud);
Hola, el primero puede ser porque la clase no la has llamado igual que la clase (deben ser iguales) y el segundo a consecuencia del primero.
Si sigues teniendo problemas, puedes enviarme el proyecto a mi direccion de email administrador@discoduroderoer.es y le echo un ojo.
Un saludo y gracias por tu mensaje.
Solucionado. La historia era por el «void» que tenía en el constructor con el parámetro longitud:
public void Password (int longitud){
this.longitud = longitud;
contraseña = generarPassword();
}
que en el constructor sin parámetro no lo tenía:
public Password(){
this.longitud = LONG_DEF;
}
Una vez quitado ese void en el primero ya me compila. Gracias.
hola! alguien me podria ayudar a hacer el programa que genera paswords en c++??
la verdad solo tengo la idea pero no logro hacerlo.
gracias!
El 3º no funciona bien da un par de problemas al compilar
PD: me encanta la pagina
Hola, ya esta solucionado, gracias por avisarme.
Un saludo.
Muy bueno, a finales del año pasado hice un curso (2 meses) y aquí me pongo a 100.
Gracias por compartir. Un saludo.