Una pequeña introducción….

·                  PROCESOS

- Los procesos que hay en un momento determinado ejecutándose en un ordenador se pueden ver en el administrador de tareas.

Simultáneamente puede haber varios aunque nosotros no nos demos cuenta, esto es debido a los hilos de ejecución que comentaremos más adelante.

Windows es multitarea, puede tener  50 procesos ejecutándose a la vez y nosotros no ser conscientes de ello, aunque realmente no se ejecutan todos a la vez como pensamos, sino que se ejecuta un proceso en cada momento, en un rango de milisegundo, este orden de milisegundos nos hace creer que se hace todo a mogollón en el mismo momento.

Por tanto, podemos concluir con que un proceso hace sus tareas secuencialmente.

·                  Diferencia entre programas y procesos:

-  La diferencia más destacada es que los programas necesitan los procesos  los programas necesitan procesos para funcionar.

En realidad, un programa y un proceso es lo mismo, no hay diferencia entre ambos, son una línea de código que se puede ejecutar.

Un programa es lanzado a mano con una ventanita

* THEADS EN JAVA – Hilo de ejecución

- En un proceso hay hilos de ejecución, los cuales facilitan la ejecución de tareas; (reparte equitativamente el tiempo de ejecución),  de esta forma se pueden ejecutar a la vez , en la práctica son dos hilos haciendo dos tareas;

EJERCICIO 1:

Ø    Clase “DING!” : nos muestra un mensaje ding cada vez que pulsamos la tecla ENTER de nuestro ordenador.

Ø    Clase “DONG!” : nos muestra por pantalla el mensaje dong cada segundo.  

Ø  Clase “DingDongPoor” :nos muestra por pantalla el mensaje ding cada vez que pulsamos la tecla ENTER y el mensaje dong cada segundo.

- Este programa no funciona correctamente puesto que espera a que el usuario pulse la tecla ENTER para mostrar por pantalla el dong una vez pasado 1 segundo.

Si el usuario está sin pulsar ninguna tecla, el programa se queda congelado y no muestra nada.

EJERCICIO 2:

En un sistema donde se están ejecutando dos procesos, cada uno tendrá la mitad del tiempo del tiempo de ejecución total para ejecutarse, es decir, el tiempo de ejecución se reparte entre los procesos de forma equitativa independientemente de los threas que tenga cada proceso.

-   Sinceramente no le hemos pillado mucho el truquillo a esto de los Threads, pero intentaremos explicarlo como buenamente hemos entendido; si hay algún tipo de error o vosotros creéis que lo habéis entendido de una forma más fácil esperamos que nos resolváis las dudas.

Runnable r = new Runnable() —>  Runnable es una interfaz, por lo general no se puede crear un objeto de tipo interfaz.

r= referencia de tipo Runnable.

La línea anterior es una sintaxis válida para crear un objeto cuya clase implementa un objeto de tipo Runnable.

-La clase Thread tiene un método característico start(), de una forma u otra, esta clase está relacionada con Runnable, de esta forma, si sólo quiero imprimir el nombre, lo indico en el método run();

Thread t = new Thread(r); —> obtenemos un objeto tipo r que implementa la interfaz de runnable, y se lo paso al constructor de Thread

t.start(); —> este método se encarga de hacer la bifurcación en un hilo y ejecuta lo que va dentro del método run();

start() crea primero  un thread a parte y ejecuta el otro método.

• Cuando el código del programa principal acaba, se acaba el hilo de ejecución.
• Cuando termina el código del método run(), se termina el hilo.
• Si se termina el código de la raíz, se termina todo, aunque el código del hilo no haya terminado.

PrintThreadName(); —> este código se ejecuta en paralelo con el hilo creado en t.start();

Ø     El programa TwoThreadsSimple, es más sencillo con respecto a la implementación aunque la funcionalidad es la misma;

Alguna de las diferencias son:

.- Implementa directamente en la cabecera de la clase.

.- Crea un objeto de su propia clase y se la pasa como parámetro al constructor de Thread.

Ø    El programa TwoThreadsSimple2: la única diferencia notable es que es una clase que hereda de Thread, después el código es prácticamente el mismo que en la clase TwoThreadsSimple.

Dentro de este código dispongo de la posibilidad de hacer start(), porque estoy en la clase Thread que tiene ese código; implementaremos también el método run().

En este caso, tenemos un programa con dos Threads que acceden a una base de datos en forma de vector , que es un atributo de la clase que los contiene. Se podría acceder al vector desde cualquiera de los hilos, ya que es un elemento compartido para ambos hilos,

 EJERCICIO 3:

 

Condición de Carrera: es la situación producida cuando dos o más threads intentan acceder en el mismo momento al recurso compartido;

Podemos decir, que es el acceso de dos hilos a un determinado elemento.

Esta situación no se puede dar puesto que ambos no van a acceder a la vez, ya que no lo harán a la vez, sino que van por turnos.

Lo que se destaca en la expresión “Condición de Carrera” es la “intención” de ambos Threads en acceder al mismo tiempo.

 

No tenemos ninguna garantía de en que orden los threads

van a ser ejecutados.

…  Continuará ….

 

Como lo prometido es deuda….

… Aquí tenemos el siguiente capítulo

- En la clase “RaceConditionSolved” lo que pretendemos es crear una solución para la condición de carrera, esto se consigue con:

_Introducimos información en la cola desde un hilo, y desde el otro buscamos la información en la misma cola.

 

EJERCICIO 4:

 

El event-dispaching thread se arranca automáticamente cuando llamas por primera vez a cualquiera de estos métodos: setVisible(), show(), pack(). 

ambos métodos se utilizan para hacer visible las aplicaciones gráficas, a unos más y a otros menos, pero a todos nos suenan bastante estos métodos, no es así?  

Como decía en el ejercicio anterior, un hilo introduce información en una cola y otro obtiene esa información;

En este caso, un thread puede añadir un evento a la cola de eventos mediante los siguientes métodos:

-> static void javax.swing.SwingUtilities.invokeLater(Runnable doRun) == encola los eventos en la cola del event-dispaching thread, este evento hace ejecutarse el método run();

-> static void javax.swing.SwingUtilities.invokeAndWait(Runnable doRun)== el evento que se encola, es el que ejecuta el método run(), pero con la diferencia de que bloquea la ejecución del hilo que lo llama hasta que la tarea ha sido realizada. 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

El esperado SWING…..

INTRODUCCIÓN:

- JFrame –> La clase JFrame implementa un objeto ventana, JFrame es una extensión de la clase Frame del paquete AWT.

- JPanel –> Un panel es un contenedor (componente no visible que contiene uno o más componentes)

- JLabel –> Las etiquetas nos permiten mostrar información o mostrar una imagen

EJERCICIO 1:

- En este apartado no hay mucho que hacer en referente a programación pura y dura, lo único que hemos hecho ha sido comentar la función de cada una de las líneas;

Destacando aquellas que pueden ser más raras:

- frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE); —> Con esta línea, cerramos la ventana también en la consola, de esta forma nos sale dentro de la misma consola un fin de ejecución.

- JPanel contentPane = (JPanel) frame.getContentPane(); —-> En esta sentencia, inicializamos un panel a partir de la conversión del panel de ventana.

- frame.setSize(100,50); —> Le damos una dimensión a la ventana; esta sentencia; esto nos sirve para ampliar la ventana, modificando 100 y 50.

Ø Creamos a continuación una clase con una etiqueta en la que cambiemos el color de fondo.

- Utilizamos para cambiar el color de fondo el método setBackground (), pasándole como parámetro Color.color, siendo color= el color que queramos ponerle, en nuestro caso, pusimos el fondo de pantalla de color azul, por lo tanto… pusimos:

label.setBackground(Color.BLUE);

MUY IMPORTANTEEE!!!!

Antes de poner el código anterior tenemos que poner: label.setOpaque(true); si no, no nos saldrá nada, puesto que es como si la ventana fuese trasparente y no se puede pintar.

Ø Creamos la clase HelloWorldGUIDelayed:

En esta clase, conseguimos retener la ejecución durante un tiempo con el código Thread.sleep(10*1000); de esta forma, una vez que lo ejecutamos, tarda 10 segundos en reaccionar.

- No es extraño que deje de funcionar el programa una vez que se termine el código del método main() puesto que existen hilos de ejecución que aún tienen código para ejecutar.

EJERCICIO 2:

Los manejadores de Ventanas:

– Son programas que controlan las ventanas de un entorno gráfico. Estos manejadores permiten al usuario hacer operaciones sobre las ventanas.

Por tanto, un programa gráfico tendrá que tener las siguientes interfaces de comunicación.

- Métodos necesarios para hacer posible esta comunicación entre ventana y manejador:

• setVisible(boolean b)= necesita que le pasemos true para que se haga visible, si no lo hacemos no nos mostrará la pantalla de ninguna de las maneras.

• setLocation(int x, int y)= indicamos el punto (coordenadas)donde queremos que nos aparezca situada la ventana.

• setUndecorated(boolean b)= nos referimos a la decoración de la ventana(barra de título y botones para manejarla)

• setExtendedEstate(int state)= estados en los que puede estar una ventana, como icono, oculta…

• setDefaultLookAndFeelDecorated(boolean b)= cambio de la decoración de la ventana.

• setDefaultCloseOperation(int operation)=configuración del comportamiento de una ventana cuando cerramos, o hacer una operación alternativa.

Ø Creamos la clase HelloWorldGUIDeaf:

- En esta clase hacemos que ignore el mensaje de cierre del manejador de ventanas, de esta forma, cuando pulsamos el aspa para cerrar no nos hará nada.

Cerrar la ventana, no significa cerrar el programa, esto lo vemos cuando no incluimos frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Si cerramos el programa, lo hará también la ventana.

En este caso, cuando incorporamos un código que haga al programa ignorar la petición de cierre de la ventana, tendremos que situarnos sobre la ventana de la consola (programa) e introducir el comando ctrl+supr, de esta forma se cerrará la ventana automáticamente.

Ø En la clase HelloWorldGUIUndecorated obtenemos una ventana un tanto simple con los bordes tipo desteñidos

EJERCICIO 3:

Ø Creamos ahora una clase CompassSimple,

- La única diferencia que encontramos es que tenemos que cambiar el color de la letra que va dentro de la etiqueta, esto lo conseguimos con setForeground(Color.WHITE);

Y nos piden también maximizar la ventana al tamaño completo —> ventana.pack();

- Ahora queremos colocar una etiqueta en cada uno de los puntos cardinales, esto lo conseguimos con BorderLayout,

labelNorth.setLayout(new BorderLayout());

y a la hora de añadirlo al panel principal le indicamos dónde queremos que lo coloque concretamente: contentPane.add(“North”,labelNorth);

en ese ejemplo lo colocaría en la parte de arriba (Norte ) de la ventana.

Ø Para implementar la clase CompassMuchBetter, en la que introducimos la imagen, tenemos que hacer un cambio de formato en la imagen puesto que hasta ahora sabemos que swing sólo soporta formato de imagen .gif,

Esta clase, utiliza setHorizontalAlignment() y setVerticalAlignment() para centrar las etiquetas.

Ø Llegados a este punto, se van complicando las cosas y comenzamos a tener algunas dudas serias, como por ejemplo, cómo implementar la clase HelloWorldGUICentered, la cual nos pide que nos muestre una ventana justo en medio de la pantalla y que utilicemos JFrame.getToolkit().getScreenSize(), no sabemos realmente cómo hacerlo, por lo que os pedimos consejos para resolver nuestras dudas.

Esta semanita hemos dado en las clases de teoría un nuevo concepto:

Cola y Pila;

Cola —> es una estructura de datos que almacena elementos, marcando un orden de llegada y salida de elementos.

Esto se refleja en que el primer elemento que llegue a la cola es el primero en salir.

Esta clase tiene dos métodos principalmente:

 encolar(); —> Inserta un elemento en la cola

 desencolar(); —> Saca elementos de la cola, en base al orden de llegada.

aunque normalmente se suelen implementar otros métodos que nos van a ayudar a la hora de introducir elementos en esta estructura como son:

estaVacía();

estaLlena();

Pila —>  es una estructura de almacenamiento de elementos que permite apilar dichos elementos uno encima de otro.

Viendo esta estructura, lógicamente el último elemento en entrar será el primero en salir ya que cada elemento se va colocando encima del primero, por tanto, a la hora de sacar, se sacará el último que se introdujo.

Los métodos principales que contendrá esta clase serán:

ü      Apilar();

ü      Desafilar();

Al igual que en la estructura anterior, debemos saber si la pila está llena o vacía, por lo que se implementarán adicionalmente los dos siguientes métodos:

ü      estaVacía();

ü      estaLlena();

Ambas estructuras son muy recomendadas a la hora de realizar el juego adicional para esta asignatura puesto que puede ser interesante tener una cola o una pila para ir guardando la información en una estructura de datos.

A la hora de programar nuestro juego hemos utilizado (en un primer momento) una estructura de datos pila.Directamente nos emocionamos un poquito y nos pusimos a programar sin haber visto antes que esta clase se llamaba Stack; creamos un atributo de tipo Pila y a la hora de compilar nos daba error y más tarde hemos entendido por qué nos daba error.

Ø      Lo primero: nos faltaba el famoso… import…  en realidad no habíamos puesto   java.util.*; (generalmente se pone así puesto que de esta forma (con *) coge todas las clases de java.util) aunque también podríamos haber puesto:

import  java.util.Stack;

Ø      Lo segundo: Pila = Stack, no existe una clase Pila como tal sino que es la clase Stack, por tanto tendríamos que haber puesto

Stack nombreAtributo;

- Es una cosa sencillísima, pero estamos seguras de que hay más gente que ha puesto eso o lo estaba pensando.

CLASE COLA;

Para implementar esta clase hemos utilizado los atributos: tamaño, último y un array de elementos de tipo int.

Inicializamos último a -1, ya tenemos en cuenta que cuando último sea 0 se referirá a la primera posición de la cola.

Definimos los dos métodos principales:

encolar();

En este método vamos añadiendo los elementos que nos van entrando en la cola0.

desencolar();

Este método saca elementos de la cola.

Como el último elemento en entrar en la cola es el último en salir, este método recorre un bucle en el que  va cambiando  el elemento de una posición determinada a la posición anterior.

Para comprobar el estado de la cola implementamos los siguientes métodos:

estaVacia();

Compara que el atributo último sea igual -1, si esto  es así, significa que no se ha añadido ningún elemento y por tanto la cola está vacía, por lo que devolvería true.

estaLlena();

Comprueba que el índice que nos indica la posición del último elemento sea igual al tamaño.

De esta forma, si esto se cumple nos devolvería true, mientras que si no se cumple devolvería false.

- Hemos introducido un método mostrar() para ir viendo el estado de la cola en cada momento.

Lo hemos comprobado con una cola de 3 elementos, y para asegurarnos de que cada paso va saliendo bien, incluimos System.out’s

ü      En el caso del tetris tendríamos que hacer una cola de piezas e irla rellenando con cada una de las piezas del juego, no habría que hacer muchos cambios sobre la clase cola que hemos implementado, únicamente cambiando el int por Pieza.

ü       La clase pieza tendrá como atributos el tipo de pieza y las coordenadas (x, y), como métodos tendrá mover() y toString();

No tenemos claro a qué se refiere el método mover, es decir si se refiere a cambiar la posición (rotar) o al movimiento a lo largo del tablero.

El método toString(); nos facilita la información del objeto Pieza.

 Esta semana se nos ha acumulado un poquito el trabajo, pero con paciencia y ganas se va llevando todo.Hemos tenido varias dudas durante la realización de la práctica, pero con la ayuda del profesor se han ido solucionando;

Somos conscientes de que hay cosas que tal vez las hayamos ido haciendo de la forma cutre, por tanto agradeceríamos que nos aconsejaseis sobre cómo hacerlo de una forma más sencilla y válida.

Ejercicio 0   — >  INTRODUCCIÓN 

En esta práctica se supone que conocemos el concepto de herencia y su aplicación, por ello comienza con la definición de POLIMORFISMO que está relacionado con la herencia.

El Polimorfismo se basa en conseguir que los objetos se comporten de una forma u otra en función de la clase a la que pertenezcan; la herencia nos permite tener referencia a la clase base y por tanto una colección de objetos.

-Tenemos dos tipos de Polimorfismo:

• de Clase –Herencia: cuando un objeto puede comportarse como objeto de otras clases.

Un ejemplo es el rectángulo, que puede comportarse como un rectángulo y como una figura.

-         La herencia nos permite crear polimorfismo de clase.

• de Método: cuando llamamos a dos métodos con el mismo nombre y les pasamos distintos argumentos, sobrecargar (SÓLO de métodos).

El modificador de acceso abstract se utiliza para dejar métodos sin implementar, generalmente se utiliza en la herencia, de esta forma obliga a las clases que heredan a implementarlos.

método abstracto => no tienen implementación
una clase abstracta es una clase que tiene algún método abstracto.

(cuando sabemos qué queremos hacer, pero no sabemos como hacerlo, de esta fora nos creamos clases y métodos abstractos )
Una clase abstracta no es instancial, exige que sea implementada en las clases derivadas, por lo que serán las clases derivadas las que serán las instanciables.

Otro concepto que se utiliza en esta práctica es INTERFACE.

- Una interface es una clase puramente abstracta, sólo define un comportamiento.

En un interfaz SÓLO se declaran los métodos, los atributos son constantes de tipo final y static.

Con un interfaz se puede extender utilizando herencia y se puede implementar dando lugar a una clase.

Si heredo de una clase que tiene métodos abstractos, tendremos que implementarlos en la clase que hereda
ventajas de los interfaces es que podemos implementar varios interfaces
es una forma de hacer herencia múltiple.

* Cómo Java es capaz de saber a qué método invocar para cada elemento del array  a la hora de realizar la invocación a un método.

Con el late binding o enlace tardío, la invocacion del método se hace en tiempo de ejecución, en este momento es cuando java sabe a qué método se refiere, para ellos se fija en el tipo de parámetro que nos pasan.

Un ejemplo a modo de aclaración sería el siguiente:

         Miembro m = new  Atributo(“3″,”2″);
          m.metodo(3.0);

tengo que llamar al método de m

- ¿De qué tipo es?

Es de tipo atributo, entonces..

- ¿A qué método llamo?

… pues me fijo en el parámetro que me pasan.

EJERCICIO 1: 

En este apartado lo único que nos pedían era sobrescribir el método toString() de las clases implementadas en la práctica 1 por lo tanto no tenía mucha dificultad, simplemente bastaba con poner super.toString(); salvo en alguna que otra clase en la que se definían algunos atributos más de los que había en la clase base y teníamos que añadirlo a la cadena de caracteres originada por el método

toString().

EJERCICIO 2: 

No sabemos cómo realizar este apartado por tanto pediríamos que nos ayudaseis para poner implementar la clase Almacenable.

EJERCICIO 3: 

Apartado 3.1; 

-         CLASE COMPONTENTE GRÁFICO 

EJERCICIO 0: 

Nos centraremos en comentar los conceptos y curiosidades de esta parte del ejercicio: -         El atributo contador tiene de especial que es estático, es decir, que lleva delante la palabra reservada static

Lo característico que tiene el ser un atributo estático es que: 

-         Si accedes desde fuera de la clase ponemos: nombreClase.nombreAtributo. 

-         Si accedes desde dentro de la clase ponemos: nombreObjeto.nombreAtributo. 

* El modificador static se utiliza para el caso en el que tenemos varios objetos con el mismo valor, si se modifican a lo largo de la clase, sólo bastaría con cambiar la variable estática creada anteriormente, de esta forma se simplificaría el uso.

Un caso en el que nos podría ser muy útil este modificador, es en una clase que nos diga la cantidad de objetos que se han creado basándose en ella.

Podemos meter una línea de código en el constructor que incremente la variable contador con el modificador static, y así cada vez que se declare un objeto el contador se incrementará.   

* Desde cualquier objeto podremos consultar el valor del contador. El código sería algo así: 

class Clase { 

static int contador;  

Clase() {  

contador++; 

}   i

nt getContador() {  

return contador; 

}

} 

            ——————————————- 0 —————————————– 

class Codigo { 

public static void main(String[] args) {  

Clase uno = new Clase();  

Clase dos = new Clase();  

Clase tres = new Clase();  

Clase cuatro = new Clase();  

System.out.println(“Hemos declarado ” + uno.getContador() + “objetos.”); 

}

}

  Ventajas: 

-Simplificación a la hora de programar

-Ahorro de memoria  

¿Cómo se destruye un objeto en java? 

-         Se consigue con la eliminación de la referencia al objeto, de esta forma, el recolector de basura eliminará los objetos que estén sin referenciar.  

-         Un constructor JAMÁS tendrá un tipo de retorno.  

* Volviendo al método toString(), decíamos que devuelve una cadena de caracteres, podemos decir que es una representación textual de un objeto.

Normalmente haremos métodos toString(), de esta forma, cuando vayamos a utilizarlos, si se llama desde una clase distinta a la que está el método, pondremos

nombreClase(donde está el método).toString();

 EJERCICIO 1: 

Las Cuestiones para responder en casa:

• Programa una clase ModificadorPrueba cuyo método “main” imprima por pantalla todos los posibles valores de salida del método toString() que hemos definido en este ejercicio.

- Nosotras hemos entendido que se nos pide que imprimamos de una vez todos los literales que corresponden a los posibles valores que se le pasan al metodo toString()Para ello hemos  creado un array en el cual se nos calcula los numeros que corresponden a cada literal.

Lo que hacemos es ir rellenando el array de la siguiente manera: (siendo nuestro array un array de enteros llamado  “num”) NOTA: Para realizar esta operación hemos tenido que importar el paquete de la clase Math

          for(int i=0; i<num.length; i++){            num[i]=(int)Math.pow(2, i);

         }

- Por ultimo lo que tenemos que hacer es imprimirlo, para ello creamos otro bucle for, de manera que en cada iteración nos imprima el literal correspondiente al valor almacenado en la posición i del array

          for (int i=0;i<num.length;i++){           

System.out.println(num[i]+”:”+Modificador.toString(num[i]));           

}

• ¿Que crees que debería pasar si al método toString()  se le pasa, como argumento, un número mayor que el número máximo de posibles combinaciones de modificadores de acceso que has calculado en la primera  pregunta?

      Si le pasamos un numero mayor que el número máximo de posibles combinaciones de modificadores de acceso no nos imprimiría nada en las  posiciones que no tienen asignado ningún modificador(se imprimiría una cadena vacía).

Ejercicio 2.  La clase Atributo

 Tenemos que implementar el constructor y el metodo toString() de la clase atributo.Para ello hemos hecho lo siguiente:

• en el CONSTRUCTOR simplemente hemos igualado el valor de los parámetros que se le pasan al constructor, a los atributos de la clase.

En el toString()  lo único que hemos hecho es crear una variable de tipo String y en ella hemos ido concatenando lo que se nos pedía  a la salida del método(cuando llegamos a la parte en la que hay que agregar el modificador de acceso, como nuestro atributo es un int, lo que hacemos es llamar al método toString de la clase Modificador –método que nos pasa a String-).

Después hemos devuelto ese String. p

ublic String toString() {        

String s = “ATRIBUTO : NOMBRE= “+nombre+” TIPO =java.lang.String MODIFICADOR”+” ACCESO = ” + Modificador.toString( modificadores );       

  return s;  

EJERCICIO 3 

- En esta parte no hemos hecho nada relevante, lo único que nos pedían era implementar los métodos  de la clase Método y Constructor.

Lo único complicado que se nos podía presentar era implementar el método toString(),

En nuestro caso, hemos definido una variable s de tipo String, a la cual le hemos pasado los parámetros que queríamos que nos devolviese (return s)

Como es costumbre nuestra, creamos un main para probar que está todo correcto en la clase, nos hemos creado un objeto y con un System.out.println(objeto.toString);

hemos sacado por pantalla la información que nos pedían. 

En el main hemos utilizado la siguiente forma de resolución:

(Hemos igualado cada uno de los parámetros a una de las entradas por teclado en la ventana de comandos)         

 String nombre =args[0];        

int modificador = Integer.parseInt(args[1]);        

String tipoRetorno=args[2]; 

De esta forma, a la hora de ejecutar haríamos:

java Metodo   “nombre”    “nºmodificador”    “tipoRetorno” 

En el lugar ocupado por las comillas directamente iría el nombre o dato correspondiente. 

* Creemos que es una forma para resolverlo, pero aceptaríamos más propuestas, estamos aquí para aprender, comparar y  compartir opiniones.

- Durante la realización de esta práctia nos han surgido gran cantidad de problemas debido a la gran cantidad de dudas que hemos ido teniendo.Aún no la hemos terminado pero estamos en ello como dos campeonas

- En primer lugar haremos una introducción teórica de los conceptos dados en clase.

Aserciones: explican nuestras suposiciones para que un programa sea más fácil de interpretar por personas distintas al programador; son predicados que se resuelven a cierto o falso.

También entendemos como aserción las comprobaciones a la hora de ejecutar un programa, tales como un if. (tenemos dudas sobre esa aplicación, es decir, si se refiere a una aserción).

- Otros métodos usados por el programador para ver dónde está exáctamente el fallo en su programa es incluir un System.out.println que nos vaya indicando lo que nuestro programa va haciendo en cada momento a esta herramienta se le denomina Traza de depuración.

- Las Excepciones están destinadas a la corrección y detección de errores.Podemos lanzar las excepciones o capturarlas y tratarlas.

- Es más adecuado capturarlas y tratarlas con try-catch puesto que si las lanzamos éstas se propagan y si no son tratadas en ninguna parte del código llegan al main y el programa da error.

- Después de esta introducción comenzamos a comentar los ejercicios que hemos realizado con más o menos éxito

Para el cálculo de una ecuación de segundo grado, necesitaríamos métodos tales como:

sqrt() = nos calcula la raíz cuadrada de un número(de tipo double), el resultado es esta operación es también de tipo double.

pow() = en este método le pasamos como parámetros la base y el exponente, de esta forma obtendremos el resultado de una potencia, tanto los parámetros como resultados devueltos son de tipo double.

- Podríamos también utilizar el  método hypot ()  de la siguiente forma:public static double hypot(double x, double y) devuelve sqrt(x2 +y2) = la raíz cuadrada de x.^2 e y.^2

- Para Generar un número aleatorio utilizaremos el método random()  de la clase Math, o bien crear un objeto de la clase Random y llamar al método. nextDouble();

Hay que tener cuidado puesto que en ambos casos los valores que nos dan van de 0.0 a 1.0, por lo tanto tendremos que multiplicarlos por una cifra para tener un rango mayor.

-Preguntas Teóricas:

Seguro que nunca os habeis preguntado….

¿Por qué System.exit tiene como parámetro un 1  ó un 0?

es decir: System.exit(1) ó System.exit(0);

Pues bien: 

- el método exit hace que el programa termine.Puede terminar exitosamente o con un fallo cuando el programa sale.- si el exit llevo un 0 = terminó bien, ha funcionado correctamente

- si el exit es igual a 1 terminó con fallo,no ha funcionado correctamente, por lo que deberíamos mirar dónde está el fallo.

Respecto al ejercicio 2: 

En vez de poner System.out.println(“Error: valor negativo de x”) , deberíamos haber puesto.System.err, puesto que es la salida de error estándar, y al tratarse de un error es aconsejable que lo tramite esta salida.

Respuestas a las preguntas pedidas:

No compila correctamente puesto que hemos intentado dividir un número entre 0 (indeterminación) y nos ha salido una excepción del tipo ArithmeticException debido a que en java no está registrada la división por 0.

Ha finalizado en la sentencia b+=c/d, esto lo sabemos porque el mensaje mostrado antes de que nos saliese el fallo ha sido  el de la línea de código anterior, y no ha llegado a mostrar el mensaje que indicaba el correcto funcionamiento.

- Para solucionarlo hemos introducido una comprobación con un if poniendole como condición que si d==0, nos mostrase un mensaje de error y saliera del programa con el System.exit(1).

Si esa condición no se cumple, que haga la división (puesto que el denominador es distinto de 0 y se puede realizar el cociente).

No hemos llegado a programar la clase LogTrace puesto que no entendemos los métodos

assertion(boolean condicion, String mensaje) y log(String mensaje)  agradeceríamos vuestros comentarios  para entenderlos, porque aun buscando en el API  no hemos logrado hacer el ejercicio.

- ¿Qué excepción salta cuando accedemos a una posición no especificada en un array?

Nos sale una excepción del tipo  java.lang.ArrayIndexOutOfBoundsException: dato erroróneo

¿Se os ocurre alguna forma de controlar este problema?

-Para controlar este problema, tendríamos que comprobar que la posición a la que queremos acceder del array no sea menor que 0 ni >= que longitud del array.

¿Qué sucede si hacemos uso de una referencia que está puesta a null?

- Nos saldría una excepción del tipo NullPointerException.

Esperamos vuestros comentarios para poder continuar con la practica ^^

Un saludo,

Jessica y Bea

 Después de haber ido al laboratorio y realizar la práctica, en parte, nos hemos dado cuenta de que aún hay conceptos que necesitamos repasar.

Únicamente hemos llegado hasta el ejercicio 3, pero continuaremos a lo largo de la semana trabajando sobre esta práctica.

Conceptos a destacar del Ejercicio 0;

- path= camino que contiene una lista de directorios donde podemos encontrar el programa a ejecutar en un determinado momento.

- jre= máquina virtual de java (entorno de ejecución de java) 

- URL del API de la versión 6.0 de java :

 http://java.sun.com/javase/6/docs/api/

- Cada versión tiene su url diferente. 

- En el primer ejercicio simplemente implementamos un bucle for que va desde 0 200, en nuestro caso le hemos incluido en la sentencia System.out.print() la variable i usada en el bucle para indicarnos que ciertamente se está imprimiendo por pantalla las 200 veces el mensaje HelloWorld.

(No sería necesario incluirlo, pero en ocasiones viene bien demostrarlo)

Respecto al segundo ejercicio,  lo primero que hicimos al programar el                                   - EchoArgsReverse, fue:

àPara asegurarnos de que estamos trabajando con el tamaño correcto del array le hemos introducido una sentencia Sytem.out.print() para que nos muestre la longitud.

àRecorremos el array de forma inversa, para que a la hora de imprimir nos muestre en primer lugar el último dato introducido por teclado.

àA la hora de cambiar  el orden de la numeración, simplemente hemos restado a la última posición del array, la posición actual en la que se encuentra.

-         Problemas presentados:

àEn un primer momento no nos salía nada cuando ejecutábamos ya que la condición del for estaba mal formulada. El fallo era que en vez de poner i>-1 (ya que siempre va a ser mayor, teniendo en cuenta que la longitud es 4), poníamos i<-1 y eso nunca se cumplía por lo que se salía siempre del for y no imprimía nada.

-         Para el programa que tenia que imprimir el espacio al final, al principio encontramos una solución un poco “cutre” que era recorrer el array hasta la penúltima posición, mostrándonos por pantalla lo que había en cada posición más el espacio.

Como para la última posición no nos interesaba que se imprimiera el espacio, lo que hicimos fue imprimirla a parte, sin el espacio (con una sentencia System.out).

Después se nos ocurrió, que sería mejor evaluar dentro del for si nos encontrábamos en la ultima posición ( en cuyo caso, no imprimíamos espacio) o si era otra ( entonces si se imprimía un espacio).

Esto lo hemos hecho con un if- else dentro del for.

Ejercicio 3

àCreemos que la comparación de b con -1 se debe a lo siguiente:

Tenemos una variable b que al principio la ponemos a -1. Este valor cambia a medida que vamos introduciendo los distintos caracteres( cada uno caracterizado por un int).

El -1 es para identificar si hemos terminado de escribir, es decir si hemos pulsado enter, por eso nos hace la comparación si b == -1.

 Si ésta se cumple, y salimos del bucle (con el break).

if (b == -1)

break;

Si no se cumple, saca por pantalla lo q hemos escrito, y comienza la siguiente iteración

System.out.write(b);

à ahora nos tocaba programar, pero estamos teniendo bastantes problemas con este ejercicio. El primero de ellos es la comprensión, porque no sabemos  a que se refiere exactamente la frase: “que mande a su salida estándar el número de bytes de su entrada estándar.” Estamos dudando si tenemos que mandar el byte que le corresponde a cada carácter que nos introduzcan o el numero de caracteres que se han introducido :S

Pensamos que tal vez se podría hacer con una sentencia switch, dándole a cada letra un valor pero puede ser una carga demasiado grande, puesto que hay un número elevado de letras y por tanto habría  un número elevado de case’s.

Por otra parte, también podríamos hacer una suma de los caracteres que se han introducido pero a la hora de igualar la variable b a un número no podemos puesto que b de tipo carácter, habría que hacer un cambio de tipo.

Aceptaríamos algún comentario para poder continuar con los siguientes apartados puesto que nos hemos quedado encasquilladas aquí y no sabemos cómo continuar; ideas no nos faltan pero no sabemos llevarlas a cabo.

A lo largo de esta semana continuaremos realizando la práctica con las ideas que nos vayan surgiendo y con vuestros comentarios, de esta forma podremos incluir los comentarios y tal vez nos pueda servir a más de uno para entender mejor la asignatura.

Esperamos que nuestros siguientes posts nos sean útiles tanto a nosotras como al resto de alumnos para entender mejor la asignatura.

Un saludo

Bea y Jéssica