POR FIN NUESTRO JUEGO 50 x 15 ENTREGADO Y PRESENTADO!!!!!!!
Después de 3 mesecitos…muchos quebraderos de cabeza y horas de esfuerzo….el juego se acabó!!Mi compañera y yo casi no nos lo podíamos creer!!!! Esperamos que el juego nos ayude a aprobar la asignatura, con él hemos podido aclarar muchos conceptos que no estaban del todo claros y también aprender otros nuevos sobre todo relacionados con la interfaz gráfica y JMF. Queremos explicar a los visitantes de nuestro blog nuestro juego!!!
Simplemente vamos a describir cada una de nuestras clases brevemente:
- Clase Juego: Es la única clase que contiene el main y es la encargada de iniciar el juego.
- Clase Pregunta: en ella se basa la estructura de todo el juego. En su constructor le pasamos como parámetros: la pregunta, la respuesta correcta, y las 4 posibles respuestas. Sólo contiene los métodos de acceso, para posteriormente poder acceder a estos parámetros desde cualquier clase.
- Clase Reproductor: implementa la interfaz ControllerListener. El constructor de esta clase tiene como parámetro la URL y es la encargada de crear el player y de añadirle el escuchador. En esta clase están implementados los métodos del manejo del evento (public synchronized void controllerUpdate(ControllerEvent event)) y también los de empezar y parar la reproducción.
Como sabemos el juego 50×15 consta de 15 preguntas, cada una de ellas con 1 nivel de dificultad mayor. En nuestro caso, hemos dividido las 15 preguntas en 3 niveles de dificultad; por ello tenemos 3 clases Nivel:
- Clase Nivel1, Clase Nivel2 yClase Nivel3
Estas 3 clases tienen la misma estructura: en ellas creamos 15 objetos de la clase Pregunta con distintos niveles de complejidad (dependiendo de la clase en la que estemos vamos aumentando el nivel de dificultad); y asignamos los objetos Pregunta creados a cada una de las posiciones del array que hemos denominado arrayPreg[]. Posteriormente, con el método rellenaArrayNx() lo que hacemos es seleccionar 5 preguntas del arrayPreg[] que no se repitan y guardarlo en un nuevo array denominado definitivasNx[]. Por lo tanto, lo que conseguimos con este método es 1 array con 5 preguntas de cada nivel. Posteriormente, en la clase PantallaPreg uniremos estos 3 arrays de 5 preguntas en un array denominado juntos[] que contendrá las 15 preguntas propuestas al jugador.
A continuación, describimos las clases relacionadas con las pantallas del juego:
Estas pantallas heredan de JFrame e implementan ActionListener; por lo tanto, en todas ellas manejamos los eventos provocados al pulsar los botones dentro del método: public void actionPerformed (ActionEvent e).
- Clase Pantalla1: Es la pantalla de introducción al juego; en ella podemos seleccionar ver la ayuda, comenzar el juego o salir.
- Clase PantallaAyuda: implementamos una nueva pantalla en la que vamos a mostrar la ayuda del juego. En este caso usamos el BorderLayout para organizar los componentes. Tenemos 2 paneles: uno para el TextArea con la ayuda y las 2 JLabel y otro para el botón de volver.
- Clase PantallaNombre: en ella creamos otra nueva pantalla que permite al jugador insertar su nombre. Destacamos el método dameNombre(), que devuelve el nombre del concursante, que será necesario para la siguiente pantalla del juego, que llamará al jugador por su nombre.
- Clase PantallaComenzar: en esta clase usamos el BoxLayout en filas (Y_AXIS) para colocar los componentes, en ella creamos otra nueva pantalla para desear suerte al jugador. En el constructor de la clase pasamos como parámetro el nombre del concursante introducido en la pantalla anterior y también una referencia de la clase Pantalla1 para poder ocultar esta ventana y visualizar solamente la pantalla actual.
- Clase PantallaFallar: en ella creamos otra ventana que aparecerá en el caso de que el jugador conteste incorrectamente una pregunta, en ella se informa al jugador del premio obtenido. Permite al jugador volver a jugar, salir del juego o ver los créditos. Si el jugador pulsa el botón de créditos aparecerá una ventana modal, en este caso se trata de un JOptionPane de información con nuestros nombres. Para obtener el dinero acumulado por el jugador llamamos a un método denominado calcularDinero()en el que pasamos como parámetro una variable denominada contador respuestas que es la que determina, el dinero correspondiente.
- Clase PantallaPlantarse: aparecerá otra nueva ventana cuando el jugador decida plantarse. Como dependiendo del número de pregunta en la que se encuentre el jugador se llevará mas o menos dinero, usamos el método dameDinero en el que pasamos como parámetro la variable numPregunta para así obtener el dinero en este caso.
- Clase PantallaGanar: Es la última pantalla del juego si el jugador es capaz de contestar correctamente la ronda de 15 preguntas propuestas. En este caso, el dinero acumulado por el jugador es fijo; será siempre de 300.000 euros. Sólo permite al jugador salir del juego.
CLASES PANTALLAS COMODINES:
Desde estas clases simplemente elaboramos la interfaz grafica de las pantallas correspondientes a cada comodín, utilizando Swing.
Los métodos que calculan el mensaje que aparecerá en cada pantalla se encuentran en la clase PantallaPreg, y es desde allí donde asignamos el valor de dichos mensajes a la etiqueta correspondiente mediante la llamada :
PantallaComodin50 comodin50=new PantallaComodin50(“Comodin 50:50″);
comodin50.etiqueta1.setText(comodin50_50(juntos[s-1].dameRespOk()));
Que se encuentra dentro del public void actionPerformed(ActionEvent e)
1. Creamos un objeto de PantallaComodinLlamada al que llamamos comodin50 para poder acceder a la etiqueta1
2. El método comodin50_50 devuelve un String , pasándole como parametro la respueta correcta.
3. Para acceder a la respuesta correcta llamamos al array juntos[nº pregunta].dameRespOk para que nos dé la respuesta correcta adecuada a la pregunta en la que está el jugador.
4. El String devuelto por el método comodin50_50 lo metemos en la etiqueta1 mediante el setText.
Los métodos principales de los comodines son los que devuelven el String correspondiente y son los siguientes:
o String comodin50_50(String respuestasOk){…}: devolverá la respuesta correcta y otra aleatoria entre las restantes mediante llamadas al Math.Random().Nos parece demasiado enrevesado explicar el código de todos los comodines…pero si a alguien le interesara alguno en particular no tendríamos inconveniente en explicar su funcionamiento.
o String calculaPorcentajes(String respuestasOk){ …}hemos elaborado el código de manera que siempre dé la respuesta correcta el porcentaje más alto, sin embargo, este no será siempre el mismo. Al igual que en el método anterior el Math.Random nos ayudó mucho para devolver el resto de los porcentajes. El objetivo era tener porcentajes aleatorios (siempre diferentes) pero de manera que la respuesta correcta siempre fuera mayor y que la suma d todos fuera 100. Se consiguió el objetivo.
o String comodinLlamada(String respuestasOk){…}: en este método simplemente introducimos 5 posibles respuestas . la resp3 siempre dará la correcta, la resp 4 no dará ninguna pista, y la resp1 resp2 y resp5 dará una respuesta con un 80% de posibilidades de ser la correcta. Esto dará lugar a posibles engaños. El hecho de que salga una respuesta u otra también esta controlado por tantos por ciento;
- Clase pantallaPreg: contiene lo siguiente:
o Implementación en el constructor de la interfaz grafica de la pantalla principal, la que estará visible durante la ronda de preguntas.
o public Pregunta[] dameArray(){…}: Método que devuelve el array juntos[ ] con las 15 preguntas de los 3 niveles que aparecerán a lo largo del juego
o Los 3 metodos antes citados: String comodin50_50(String respuestasOk){…}, String calculaPorcentajes(String respuestasOk){ …} y String comodinLlamada(String respuestasOk){…}
o public int dameNumPregunta(){}: sirve para poder averiguar en qué numero de pregunta se encuentra el jugador a cualquier altura del juego, lo necesitábamos dado que el numero va cambiando dentro del ActionPerformer y necesitábamos sacar fuera esa variable para poder utilizarla en otros métodos, como el siguiente.
o int dameDinero(int numPregunta){ Calcula el dinero por el que se juega en función de la pregunta en la que se encuentre (etiqueta de información)
o public String [] dameArrayInfo(){…}:Controla el mensaje de información que va variando en función de la pregunta en la que se encuentre .
o public URL dameCancionX(){…}devuelve una url para luego pasársela como parámetro en la clase Reproductor y así poder controlar que sonido queremos en cada momento. Funcionaria asi:
o public void actionPerformed(ActionEvent e){…}: desde este método se manejan todos los eventos durante la ronda de preguntas:
o qué pasa si pulsamos la respuesta correcta—siguiente preg + aplausos
o qué pasa si pulsamos la respuesta incorrecta—pantallaFallar
o qué pasa si pedimos algún comodín—pantallaComodinx + sonido
o qué pasa si pulsamos el plantarnos—pantallaPlantarse
o qué pasa si acertamos la pregunta 15—pantallaGanar + sonido
o desde aquí además de controlar que pase o no la pregunta siguiente, controlamos que el mensaje de información vaya cambiando o detalles como que los comodines una vez usados se deshabiliten.
Ya conocéis un poco más nuestro juego!!!! Si queréis verlo no tenéis más que pedirlo!!!
¡¡¡MEMORIA PRIMERA ENTREGA JUEGO!!!
El 50 x 15 es un juego basado en contestar a 15 preguntas (con mayor dificultad a medida que se avanza de pregunta), con la posibilidad de utilizar 3 comodines que faciliten al jugador contestar correctamente. Dicho jugador puede plantarse en cualquier momento.
1. Diagrama de clases:
Nuestro juego consta de 8 clases, que pasaremos a explicar brevemente:
- Una clase principal denominada Juego que contiene el método main, a partir de la cual manejamos el funcionamiento del juego; utilizando todos los métodos creados en las clases citadas a continuación.
-
Una clase Pregunta formada por los atributos (pregunta, respuesta correcta, respuesta a, respuesta b, respuesta c, respuesta d), el constructor (en el que le pasamos como parámetros todos los atributos)y los métodos de acceso. Esta clase sirve para crear los objetos posteriormente en las clases Nivel1, Nivel2 y Nivel3.
- Tres clases denominadas Nivel1, Nivel2 y Nivel3 en las que creamos objetos Pregunta de distintas dificultades. Cada clase contiene un array de 15 objetos Pregunta de los cuales se seleccionarán 5 objetos que guardamos en otro array denominado definitivasNx (dependiendo de la clase en la que estemos). Una vez elegidos los 5 objetos en cada clase; pasamos a tener un array de 15, que serán las preguntas definitivas que aparecerán por la consola al empezar a jugar (este array, llamado juntos, está implementado en la clase Juego).
- Una clase Comodines en la que aparecen los 3 métodos correspondientes a los 3 comodines del juego implementados (comodín del público, comodín de la llamada, comodín 50:50). Estos comodines no son 100% fiables, es decir, en un gran porcentaje darán la respuesta correcta, pero pueden engañar al jugador.
- Una clase Operaciones que se encarga de calcular el dinero acumulado por el jugador y gestiona cúal será el premio obtenido dependiendo de si éste se planta o falla la respuesta.
- Una clase Pantallas donde implementamos las distintas pantallas que van saliendo desde el inicio hasta el final del juego por la consola; es decir desde la bienvenida hasta que el jugador acaba su partida.
2. Diagramas de funcionamiento:
Ahora pasamos a explicar los diferentes estados de nuestro juego:
- Estado 1: Pantalla de bienvenida al juego, con la opción de ver las reglas del juego (a través de Ayuda) o pasar al siguiente estado.
- Estado 2: Pantalla donde el jugador puede elegir entre comenzar la partida o salir.
- Estado 3: Pantalla en la que el jugador introduce su nombre.
- Sub-estado 3.1: Se reproduce un mensaje deseando suerte al jugador.
- Estado 4: Comienzan la ronda de preguntas.
- Estado 5: Fin del juego; ya sea porque el jugador ha fallado la respuesta, se ha plantado o ha superado el juego al completo respondiendo correctamente a las 15 preguntas.
3. Diagrama de despliegue:
- El código fuente, necesario para generar el ejecutable se encuentra en la carpeta /JUEGO/ del fichero 50×15.zip.
- Ejecutar el juego con java Juego.
- A esta memoria se puede acceder desde nuestro blog, con la siguiente url: http://mariayaurora.wordpress.com/
4. Cosas pendientes:
En cuanto a la algoritmia del juego, estamos trabajando aún en estas cuestiones:
- Controlar lo que introducimos por teclado en estos dos casos:
- En las pantallas iniciales: Queremos que salga un mensaje de tipo “Valor incorrecto, introduzca otra letra válida”.Sin embargo, en la versión actual se nos va directamente al estado 4 antes citado.
- Si nos encontramos en la ronda de preguntas únicamente se puede introducir a, b, c, d, p, c1, c2 y c3. En caso contrario, deberá aparecer otro mensaje del tipo “Valor incorrecto, introduzca un valor correcto” (de momento, lo interpreta como una respuesta incorrecta y se sale del juego)
- En el estado 2, la opción de salir todavía no funciona.
- Hemos seleccionado las 15 preguntas (diferenciando niveles de dificultad) aleatoriamente; esto puede provocar la repetición de preguntas en una misma ronda. Queremos evitar dichas repeticiones.
En cuanto a la interfaz gráfica estamos esperando dar la parte teórica en clase para introducirlo en el juego.
¡¡Lo prometido es deuda!!
Cierto es que vamos un poco (bastante) retrasadas con el blog…pero tuvimos problemas con nuestros ordenadores domésticos y hasta después de semana santa nos ha sido muy difícil ponernos al día. Esperemos coger el ritmo de la gente lo más rápidamente posible.
En este comentario no pondremos demasiado código, dado que ya la mayoría de vosotros tenéis echas estas prácticas y…las soluciones están colgadas, no creemos que fuera de gran ayuda. Nos limitaremos a recalcar lo que desde nuestro punto de vista fue más importante:
PRÁCTICA 2:
· Como crear una carpeta desde la consola: hasta esta práctica era algo que desconocíamos, y que es tan simple como escribir: C:>mkdir C:\TEMP\TSIOCA (En el caso de crear una carpeta llamada TSIOCA dentro del directorio TEMP).Suponemos que mkdir significa make dir, es decir, hacer dirección….si no es asi…es una forma fácil de recordarlo.
· Como añadir el Classpath: es un código fácil, solo tienes que saber un poquito de inglés y todo te será más fácil de recordar : C:\>set CLASSPATH=C:\TEMP\TSIOCA; %CLASSPATH% con escribir set (pon) CLASSPATH=DIRECTORIO; %CLASSPATH%
o Si no reconoce javac: deberemos buscar la ruta de javac.exe y agregarla
· Método que permita generar valores aleatorios: nos parecía importante recalcar este método. Conviene no olvidar el Math.random() porque nunca sabes cuándo vas a tener que acudir a él, por ejemplo para el juego nosotras lo hemos tenido muyyy presente, quizás alguno de vosotros no lo uséis…pero teniendo en cuenta que en muchos juegos intervienen dados…utilizar este método es una forma sencilla de generar la tirada de un dado. Si alguien lo necesita y no sabe cómo hacerlo que se ponga en contacto con nosotras.
//genera un número aleatorio:
public class Aleatorio{
public static void main (String args []){
double x=Math.random(); //crea una variable del tipo double y se le asigna un numero aleatorio de 0 a 1
System.out.println(x);//imprime ese número aleatorio obtenido
}
· Aserciones y trazas de depuración: vamos a contaros un “secretillo”…en realidad en clase nos dijeron que esto no se usa demasiado a la hora de la verdad…no sabemos si no lo usaremos por nuestro bajo nivel o porque realmente no es útil…pero la verdad es que nosotras nos liamos un poco con esto pero se puede solucionar igualmente con excepciones, que es como hemos resuelto los ejercicios propuestos..:SCreemos que las aserciones no son muy útiles ya que cuando se produce un error, se finaliza la ejecución del programa y esto no siempre nos va a interesar.
En nuestro caso, siempre que aparecen errores usamos trazas de depuración; puesto que es mucho más fácil su utilización y vemos más claramente dónde falla el programa.
Llegamos al ejercicio 3, empezamos a leer y … cúal es nuestra sorpresa??? nos cuentan un poco la teoría sobre las excepciones!!!!y luego…EJERCICIO DE FICHEROS!!!!!!!!!!!!!!!!!Pero…no puede ser (pensamos)!!!!Seguimos sin saber cómo usarlos…por lo tanto el ejercicio 3…nada de nada.
· Ejercicio 4!!!!! Seguimos con las excepciones: java.lang. ArithmeticException, java.lang.ArrayIndexOutOfBoundsException, java.lang.NumberFormatException… qué locura!!!! Decidimos mirarnos por nuestra cuenta un poco las excepciones (para intentar aclarar un poco las ideas) y lo que más nos sorprende es que podemos lanzar nuestras propias excepciones, extendiendo de la clase System.exception.
· Cuidado con las referencias a null!!!: A veces pensamos que una variable puesta a null, es equivalente a 0, pero NO!! Si tenemos la variable. String var=null, y luego queremos averiguar su longitud con var.length()….dará error!! Null no tiene longitud…seria más parecido a vacío que a 0. Aunque parezca que pueda estar bien porque compile al ejecutar dará un error.
· Funciones ValueOf():Llegamos a la class ExcepciónApp y nos encontramos con “ respuesta=String.valueOf(cociente);” y decidimos buscar qué significaba; puesto que ni nos sonaba. ValueOf() es un método que se usa para la conversión de tipos de datos!!!!Podemos pasar cualquier tipo de dato básico a String!!!
· Ahorcado: pff pff pfff….sinceramente….no nos salió, tuvimos que mirar las soluciones, creemos que de momento ejercicios cortitos y por separado no nos dan “demasiado” miedo…pero hacer un ahorcado!!!!así a primera vista…Solo la idea nos aturdió un poco…la dificultad la encontramos al empezar…porque una vez publicada la solución no hay grandes problemas, era el primer programa un poco serio que había que empezar desde el public class Ahoracado e implementar todo sin que nos dieran nada de código.
PRÁCTICA 3:
Seguimos con el “estilo” de la practica anterior:
· Atributo/Metodo Estático (Static) : Existe un tipo de atributo/método llamado estático que son compartidos por todos los objetos de la misma clase. Se les llaman atributos/métodos de clase. Su valor/código no modifica el estado de ningún objeto particular sino más bien de la clase de objetos como un todo. Para acceder al atributo a través de la clase: punto.contador, suponiendo que punto sea el nombre de la clase y contador el nombre del atributo estático.
· Diferencia entre constructores y métodos: si os fijáis la sintaxis para hacer un método y un constructor es parecida:
o public Punto(double x, double y)àconstructorà modificadorDeAcceso Nombre(parámetros)
o public double distanciaAlOrigen() àmétodo à modificadorDeAcceso TipoRetorno Nombre(parámetros)
La diferencia es que un constructor nunca tiene Tipo de retorno.
· método toString(): al igual que destacábamos el math.ramdom(), el método toString () (aunque normalmente- y no se porqué- no nos gusta demasiado)se utiliza mucho, asique mejor entenderlo bien. Devuelve una cadena con la representación del objeto.
public String toString() { return “(“+x+”, “+y+”)”;
Todo lo que quieres que devuelva ha de ir en el return, luego ya veremos lo que hacemos con el valor del String devuelto, porque no siempre interesa sacarlo por pantalla que es el uso que más le damos.
· Pasar por valor: cuando pasamos como parámetro en un método una copia del argumento o del parámetro se dice que se esta pasando por valor. Y ahora un poquito de código…
· Ejercicio 2: clase Atributo (clase método y constructor parecidas)
public Atributo(String nombre, String tipo, int modificadores ) {
this.nombre= nombre;
this.tipo=tipo;
this.modificadores= modificadores; }
public String toString () {
String a=”ATRIBUTO : NOMBRE= “+nombre+” TIPO= “+tipo+” MODIFICADOR ACCESO= “+ Modificador.toString(modificadores);
return a; }
· Ejercicio 4: clase Clase. Teníamos que implementar lo siguiente:
public Atributo[] getAtributos() { return atributos; }
public Constructor[] getConstructores() { return constructores; }
public Metodo[] getMetodos() { return metodos; }
public String toString() {
String a= “CLASE:”+ this.nombre;
for (int i=0; i<atributos.length; i++){ a= a + atributos[i].toString() }
for (int j=0; j<metodos.length; j++){a= a + metodos[j].toString(); }
for (int t=0; t<constructores.length; t++){ a= a + constructores[t].toString();}return a;}
Explicamos el constructor:
Package java.lang.reflect : Provides classes and interfaces for obtaining reflective information about classes and objects. (Viene a decir que este paquete sirve para obtener información sobre clases y objetos)
public Clase( Object o) {
this.nombre = o.getClass().getName(); //obtiene el nombre de o, que será del tipo Clase
//OBTIENE EL NUMERO DE ATRIBUTOS CONSTRUCTORES Y METODOS QUE HABRÁ PARA PODER DETERMINAR LA LONGITUD DE LOS RESPECTIVO ARRAYS.
int numAtributos = o.getClass().getDeclaredFields().length;
int numConstructores = o.getClass().getConstructors().length;
int numMetodos = o.getClass().getDeclaredMethods().length;
//CREA LOS ARRAYS DE ATRIBUTOS, CONSTRUCTORES Y METODOS DE LA LONG ANTES CALCULADA
atributos = new Atributo[numAtributos];
constructores = new Constructor[numConstructores];
metodos = new Metodo[numMetodos];
//OBTIENE LAS CARACTERISTICAS (ATRIBUTOS DE LA CLASE ATRIBUTO) DE CADA ATRIBUTO(NOMBRE, TIPO Y MODIFICADOR)
for ( int i=0; i<numAtributos ; i++) {
Field f = o.getClass().getDeclaredFields()[i];
atributos[i] = new Atributo(f.getName(),f.getType().getName(),f.getModifiers()); }
//OBTIENE LAS CARACTERISTICAS (ATRIBUTOS DE LA CLASE CONSTRUCTOR) DE CADA CONSTRUCTOR(NOMBRE Y MODIFICADOR)
for ( int i=0; i<numConstructores ; i++) {
java.lang.reflect.Constructor c = o.getClass().getConstructors()[i];
constructores[i] = new Constructor(c.getName(),c.getModifiers()); }
//OBTIENE LAS CARACTERISTICAS (ATRIBUTOS DE LA CLASE METODO) DE CADA METODO(NOMBRE, TIPO RETORNO Y MODIFICADOR)
for ( int i=0; i<numMetodos ; i++) {
Method m = o.getClass().getDeclaredMethods()[i];
metodos[i] = new Metodo(m.getName(), m.getModifiers(), m.getReturnType().getName()); }
}
· Ejercicio 5. La clase AnalizadorObjeto: no lo supimos sacar y aun mirando la solución hay cosas que no llegamos a entender bien. Si alguien pudiera explicarnos a rasgos generales este apartado lo agradeceríamos…es que hemos estado buscando por diferentes blogs y no hemos encontrado la solución explicada.
UN POCO TARDONAS…
Después de las vacaciones comentaremos las prácticas 2, 3 y 4!!! lo prometemos!!!jeje
Más vale tarde que nunca…Práctica 0
Hola, a pesar de la tardanza….vamos a comentar la primera práctica de la asignatura.
En un principio no nos asustamos demasiado…el ejercicio 0 prácticamente lo hizo el profesor dado que estábamos bastante perdidos con el Path, el jre….etc, no nos eran demasiado familiares estos conceptos, pero con las explicaciones “pareció”que nos quedó claro….aunque nunca se sabe cuando nos volverán a surgir dudas sobre estos temas.
Ejercicio 1: Sin problemas damos un repaso a los bucles, nos viene bastante bien para refrescar la memoria. En el punto 4 se nos ocurre comprobar si el número de veces que se imprime “Hello World!” es el correcto, ya que no nos fiamos mucho…pero obviamente no íbamos a contar uno por uno la frase, por lo tanto, usamos el siguiente código:
public class HelloWorld200{
public static void main(String[ ] args){
for(int i=1; i<201;i++)
System.out.println (“HelloWorld!!”+ ” ” +i); }
}
De esta manera cada “HelloWorld!” aparece numerado y así, comprobamos que efectivamente lo imprimía 200 veces.
Ejercicio 2: De momento va bien la cosa…nos ilusionamos porque parece que va saliendo algo (¿¿¿durará mucho la ilusión???…) LLegados al punto 5 hicimos el ejercicio tanto con el espacio extra y sin él, que era el objetivo.
Empieza lo serio…ya intuíamos que no duraría mucho la ilusión
Ejercicio 3: Comenzamos leyendo el enunciado y la verdad es que en un principio nos asustamos un poco, tanta teoría…..pero bueno, lo peor fue ver el código propuesto capturando excepciones, en fin….pensamos: ¡si no lo hemos dado! (bueno vale, nosotras sí porque somos repetidoras, pero vamos, está olvidado)
Creemos que el mayor impedimento en estos ejercicios es que no entendemos el código propuesto, su funcionamiento… porque incluye sentencias que aunque nos resultan familiares, no controlamos lo suficiente. Por ejemplo: la captura y lanzamiento de excepciones, el System.out.write , el System.err.println(e),el significado de importar paquetes….cosas que posiblemente no tienen gran dificultad, pero nos son desconocidas.
A pesar de esto, intentaremos profundizar en estos temas, y lograr entender todos estos conceptos porque seguramente tendremos que aplicarlos en próximas prácticas, incluso en nuestro juego.
Una vez perdidas en el ejercicio 4, 5 y 6 decidimos pasar al 7 que es mas teórico y no fue mal, pero gracias a la ayuda de google, wikipedia, etc (aunque nuestro nivel de inglés deja mucho que desear) pero nos gustaría responder abiertamente a la última pregunta, la 9:
¿¿Crees que leer códigos de otros puede ser una buena manera de aprender a programar??
Indiscutiblemente ¡NO!, desde nuestro punto de vista la única forma de aprender a programar es empezar desde 0, es decir, no partir de un código ya escrito, porque como nos pasaba en ejercicios anteriores (en los que nos dabais el código de partida) te puedes encontrar con excepciones, Buffereader, paquetes, métodos desconocidos para nosotros etc. que dificulten la comprensión del programa y provocan nuestro bloqueo inmediato.
¿Vosotros que opinais? ¿Os sirven de ayuda?
Lo importante es participar…¬¬
¡¡¡ HOLA A TODOS !!!
Somos María y Aurora y esperamos que esto nos sirva para poder entender mejor dudillas de las prácticas, ejercicios de clase, el juego….bueno ya sabeis…que empezamos con muchas esperanzas y a ver como acaba la cosa.
Ánimo!!!!!! y para los que estén en primera convocatoria…no abandoneis!! jeje
Hello world!
Welcome to WordPress.com. This is your first post. Edit or delete it and start blogging!
