T.A.P.
Técnicas Actuales de Programación
Curso: 2020/21
|
|
|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
N no lectivo, N fiesta, N estudio, N exámenes, N N clase, N clase anulada |
Clases: {aula: 2.2} {horario: jueves 10:40-11:30, viernes 9:40-11:30
Laboratorios: {En remoto con Black Board Collaborator -link pendiente-} {horario: 15:00-17:30}
Tutorias: {con las excepciones que se indiquen en GAUR, JV 8:00..9:30, J 11:30..13:00, V 12:00..13:30. con Black Board Collaborator
El programa de la asignatura se corresponde casi en su totalidad con un curso de Java, puesto que es posiblemente el lenguaje que mejor soporta las técnicas actuales de programación. A lo largo del desarrollo del curso se irán destacando las técnicas que Java incluye o facilita.
Desde que apareció Java, allá por 1995, la secuencia de versiones ha sido muy llevadera y "considerada" con los usuarios (compatibilidades absolutas en todos los sentidos). Desde hace poco tiempo el modelo ha cambiado para dar respuesta más rápida a las nuevas características que se hacen necesarias (es algo que está sucediendo en multitud de desarrollos, no sólo en Java). Esto supone la capacidad de estar mucho mas "al día", pero es una incomodidad ya que requiere cambios muy frecuentes (cada 6 meses). (quien quiera detalles puede ver esto)
La última versión estable de Java es la 14, y será sustituida por la 15 en cuanto comencemos el curso. No obstante, para el contenido del curso es suficiente con la versión 7. Las capacidades añadidas desde la versión 8 van más allá de lo que es un curso de Java como medio de ver técnicas comunes en el desarrollo actual de software. No obstante, algunas cuestiones aportadas por dichas versiones posteriores serán comentadas en clase.
Por otro lado, a la par de la introducción de la versión 9 de Java, el mantenimiento del entorno de desarrollo que utilizaremos (Netbeans) pasó de manos de Oracle (la empresa propietaria de Java) a Apache (fundación para desarrollo de software libre), y después de un cierto tiempo de adaptación, parece que la versión actual (12.0) tiene implantadas todas las características que se encontraban en la que nos resultaba adecuada anteriormente (la 8).
Con todo ello nos quedamos con que:
* Instalaremos Java 14
y Netbeans 12.0 (con lo que tenemos plataforma e IDE "más que de sobra")
* comentaremos algunas características interesantes de versiones posteriores
Documentación de utilidad (más documentación en el apartado "Extras"):
* La referencia definitiva del lenguaje Java {suficiente: versión 7}
{actual: versión 14}
* La documentación de la plataforma SE{suficiente: versión 7}
{actual: versión 14}
* Los "tutoriales" de Java (se quedaron en Java 8, pro como se ha dicho, es más que suficiente)
Es necesario saber programar (mejor “con soltura”) en un lenguaje cualquiera.
Es conveniente hacerlo con “conocimiento de causa”, es decir sabiendo de algorítmica y de estructuras de datos.
Si se parte de cero, la Wikiversity nos puede ayudar:
* Comenzar con Introduction to Computer Science"
Los 5 primeros capítulos son de "cultura general", pero a partir del sexto es una introducción interesante a la solución de problemas con programación.
* Continuar con "Introduction to Programming".
* Seguir con "Introduction to Algorithms"
Es conveniente seguir con "estructuras de datos", ya que es fundamental para programar con un conocimiento de los elementos que se utilizan, pero en la Wikiversity se desarrolla en lenguaje C, y no es adecuado a nuestro caso. En el curso veremos unas cuantas estructuras de un modo que podríamos llamar "usuario".
De este modo, se cuenta con unas bases de programación, y si se quiere empezar a ver el lenguaje Java también con la Wikiversity: Introduction to Programming in Java".
Acceso al estado de evaluación personalizado
Nota: antes de entregar cualquier ejercicio hay que, por lo menos, "adecentar" el código. Lo correcto sería incluso escribir la documentación, pero por lo menos hay que dejarlo "listo para revista": eliminar ficheros abandonados, lineas de código de prueba, etc...
SEPTIEMBRE
TEMA 1 - INTRODUCCIÓN
1.1.- Java, XML e Ingeniería del software.
(como ejemplo de uso de XML podéis abrir como zip cualquier archivo de Windows Office -pptx, docx,...-)
1.2.- Origen y características de Java
1.3.- La Máquina Virtual
1.4.- Obtención e instalación del software
SOBRE HERRAMIENTAS UML
Os comenté que no disponemos de buenas herramientas para trabajar con UML. En todo caso se puede encontrar alguna que supuestamente funciona, pero que son extremadamente caras (las usan algunas grandes corporaciones). Quiero dejar claro que me refiero a herramientas para generar código y hacer ciclo cerrado UML->código->UML, no meramente para dibujar diagramas. Para dibujar sí que existen algunas aplicaciones, y cada vez van apareciendo más, sobre todo últimamente con soporte en la web (online). Evidentemente tienen la misma función de ayuda al desarrollo (particularmente en equipo, donde se comparten ideas y realizan presentaciones), pero a lo que me refería era, como os digo, a su integración con el resto de herramientas.
Las herramientas definitivas pudieron ser las de Rational Software, empresa desde la que se creo UML, pero fue comprada en 2008 por IBM que parece no tener mucho interés en su mantenimiento aunque las siga comercializando. En el tweet de al lado vemos a Grady Booch, uno de los padres de UML y director científico de desarrollo de software de IBM, diciendo que usa StarUML, (en combinación con el IDE CLion para C/C++, y no sé si podrá integrarse con Netbeans -hace 10 años sí, pero todo ha cambiado mucho-).
Una herramienta bastante potente que se integra con los diferentes IDEs (no de modo sencillo) es Visual Paradigm. Sin ser excesivamente cara, tampoco es barata.
En este momento me parece particularmente interesante Modelio por ser un desarrollo en código abierto que ha dado lugar a un "store" en el que presumiblemente se iran encontrando utilidades interesantes (al parecer ahora mismo existe una que permite la generación de código Java, aunque es de pago dentro de una versión comercial de Modelio).
TEMA 2 - USO DEL ENTORNO DE DESARROLLO
2.1.- Ejemplo inicial: el programa "Hola Mundo"
2.2.- Bibliotecas de clases: su estructura
2.3.- Compilación y ejecución
2.4.- Desesamblado y ejecución
2.5.- Generación de documentación
OCTUBRE
Comprobamos todo lo anterior desde Netbeans
//Vemos lo referente a Espacios de Nobres añadido al día 1
Adelanto de los puntos 1 y 2 del
TEMA 6 - INTERFACES GRÁFICOS
(Recibidos en cursos anteriores..., más...)
TEMA 3 - ELEMENTOS BÁSICOS DEL LENGUAJE
//Hemos visto hasta Identificadores y literales
//Continuamos donde lo dejamos...
...y llegamos a ver "while" y "do-while" a falta de "for".
//Ya tenemos alguna calculadora (ver en el ejercicio planteado el viernes 2)
//Continuamos donde lo dejamos...
Se trata de calcular el número π con precisión de cuatro decimales mediante la serie:
La especificación de cuatro decimales hace referencia al criterio de parada en la suma de términos de
la serie, no a la presentación de la solución, que se hará normalmente mediante System.out.println(.)
y que nos mostrará un número de decimales que no podemos controlar por ahora.
private static double pi() { double piCuartos = 0.0; for (int n = -1; i <= 100_000_000; ) piCuartos += 2.0/(n+=2)/(n+=2); return piCuartos * 4; }
Los programas que se utilizan para calcular PI con un número de decimales extremadamente alto utilizan series evolucionadas a partir de la sorprendente fórmula descubierta por Ramanujan ("El hombre que conocía el infinito") en 1910 y demostrada no hace mucho tiempo:
Su convergencia es exponencial y ya el primer término aporta 6 decimales. Puede ser un buen ejercicio utilizar esta fórmula para el cálculo de PI, aunque enseguida se verá que es "demasiado buena" para lo que podemos hacer con variables primitivas (e incluso con otros recursos que nos aporta Java).
Escriba una RUTINA que determine si un número dado es perfecto o no.
static boolean isPerfect(long n) { //TODO hacer lo necesario para que "isPerfect" retorne "true" o "false" si n es perfecto o no. }
Un número perfecto es un entero positivo igual a la suma de sus divisores propios. Los divisores propios de un entero positivo son todos sus divisores a excepción de sí mismo. (Ejemplo de número perfecto: el 6, porque sus divisores propios son 1, 2 y 3 y 6=1+2+3.)
Utilizando dicha rutina debera obtener una lista de números perfectos entre el 1 y el 100.000
Listado de Números Perfectos [wikipedia]
TEMA 4 - ELEMENTOS RELACIONADOS CON LA ORIENTACIÓN A OBJETOS
//Hemos visto hasta estructura de la definición de clase, sólo package e imports
//Continuamos donde lo dejamos...
Hacemos un inciso para ver el punto 3 del
TEMA 6 - INTERFACES GRÁFICOS
//Llegamos a (sólo) ver el ejemplo hecho a mano.
//Comento la intención de los ejemplos en el documento anterior y continuamos donde lo dejamos el día 15...
Volvemos al
TEMA 4 - ELEMENTOS RELACIONADOS CON LA ORIENTACIÓN A OBJETOS
//Vimos el encapsulamiento.
//Comentario sobre vídeos (y uno sobre módulos), y dibujo de accesibilidad, y continuamos donde lo dejamos ayer...
// ... y terminamos con el tema 4.
//un pequeño video retocando un ejercicio recibido.
//y otro sobre módulos en las bibliotecas del JDK, como os dije que sería todo lo más que veríamos al respecto.
TEMA 5 - MECANISMO DE TRATAMIENTO DE EXCEPCIONES Y ERRORES
//Hemos llegado a ver cómo se puede arrojar los "problemas" hasta el main
, sin ver aún cómo "pasar de ellos" sin que la ejecución termine.
//Continuamos donde lo dejamos
//continua pendiente el pequeño video sobre escritura de constructores y métodos de obtención de instancias.
NOVIEMBRE
(Terminaremos el tema 6 (punto 6.4) de modo práctico en una clase de laboratorio)
TEMA 7 - EL CONTENIDO DE LA BIBLIOTECA DE CLASES
Los primeros apartados de este tema consisten en el estudio de diversas clases imprescindibles por diversos motivos. Usaremos la versión 7 de la documentación, porque la 8 se complica en exceso en determinados puntos (principalmente Colecciones, que veremos más adelante) y se sale de lo que podemos hacer en un curso con el tiempo disponible (es programación funcional).
//Nos quedamos viendo los "equals" y "hash" propuestos por Netbeans.
//Continuamos con el punto 7.2 donde lo dejamos.
//Hemos comenzado con java.util, dejándolo a punto de hablar de Formatter, etc.
Sesión de laboratorio por BBC (enlace en eGela). Guión: Calculadora [pdf]
Sesión de laboratorio por BBC (enlace en eGela). Guión: Matrices [pdf]
Examen de test en eGela
//Continuamos con java.util donde lo dejamos.
TEMA 8 - Entrada y salida de datos
//Nos quedamos a punto terminar de ver los "sinks" con las clases para tratar streams bite->char y object.
//Continuamos donde lo dejamos...
//...llegamos a ver una copia simple de ficheros de texto y quedamos en ver codificaciones.
DICIEMBRE
Sesión de laboratorio por BBC (enlace en eGela). Guión: Gráficos en GUI [pdf]
Hemos comprobado los "Charset" y analizado cómo se pueden leer ficheros de texto con diferentes codificaciones usando un programa-demo.<\br> (el proyecto es descargable abajo, en la clase de mañana)
Añadimos al programa-demo de ayer, otro de uso de ArrayList y LinkedList con perfilado de ejecución, otro de uso de ZipFile, y otro de uso de expresiones regulares y alguna cosa más. Todo se encuentra como cuatro clases ejecutables dentro de este proyecto
Sesión de laboratorio por BBC (enlace en eGela). Guión:
Usando las ayudas de Netbeans para completar una aplicación [pdf]
[clase como txt]
//Continuamos donde lo dejamos con IO el día 27/11
TEMA 9 - Hilos
//Llegamos hasta los niveles de prioridad
//Continuamos donde lo dejamos, con un comentario previo sobre mantenimiento de código y sobre "hardcoding", a raíz de la práctica del pasado miércoles.
//Llegamos a ver la primera ejecución productores->consumidores y el error de falta de sincronización en los println.
Sesión de laboratorio por BBC (enlace en eGela). Guión: La torre de Babel (I/O y Colecciones) [pdf]
//Terminamos con el tema de hilos y vemos una introducción al siguiente tema
TEMA 10 - Programación en red
Vemos una introducción al tema en pizarra, para probar mañana un ejemplo
Veremos un ejemplo simple de aplicación cliente-servidor. Se tratará simplemente, en primer lugar, de establecer la conexión y enviar Strings desde el cliente al servidor, para, más adelante, completar este ejemplo con la posibilidad de atender a multiples clientes y establecer el la comunicación de Strings en ambos sentidos.
En el siguiente recuadro tenemos el código de un servidor mínimo. En la línea 6 se instancia un objeto ServerSocket
"escuchando" al puerto 6000(puertos), y posteriormente se entra en un ciclo infinito. La primera acción de este ciclo es esperar a un cliente (línea 8). Cuando surje, el método accept
nos devuelve una conexión ("s") con él (un socket
). Al objeto "s" le pedimos los streams de entrada y de salida en las líneas 11 y 12, que después recubrimos convenientemente a nuestras necesidades actuales como un BufferedReader
y un PrintStream
en 13 y 14 (podríamos haber prescindido de todo lo referente a salida puestoq ue este ejemplo no hara uso de ella, pero lo ponemos para mostrar el procedimiento habitual).
Una vez que disponemos de los streams podemos "leer" lo que nos envie el cliente e igualmente "escribirle". En este ejemplo nos limitamos a un bucle de lectura (líneas 17-19) del Reader
sin que exista ninguna particularidad por el hecho de que el origen de los datos sea una máquina diferente. En el ejemplo se consulta si el contenido de la String
recibida es "exit" para terminar el ciclo de lectura. En tal caso se cierra el Socket
(línea 21) terminando el código del ciclo general y volviendo por tanto al punto de espera a un nuevo cliente (línea 8).
Observesé que en este ejemplo la conexión termina por cierre del Socket
por parte del servidor. Lo mismo podría haberse hecho desde el cliente, lo que resultaría en una excepción en la lectura del Reader
. Podía haberse establecido éste como mecanismo de terminación. En todo caso en una aplicación correcta habría de tenerse en cuenta esta posibilidad de cierre de la conexión or parte del cliente, de modo que habrá de atenderse a la excepción que aquí se arroja.
1 import java.io.*; 2 import java.net.*; 3 4 public class Server { 5 public static void main(String[] args)throws IOException{ 6 ServerSocket ss=new ServerSocket(6000); 7 do { 8 Socket s=ss.accept(); 9 System.out.println("\n\n***Conexion establecida con: "+s); 10 11 InputStream is=s.getInputStream(); 12 OutputStream os=s.getOutputStream(); 13 14 BufferedReader br=new BufferedReader(new InputStreamReader(is)); 15 PrintStream ps=new PrintStream(os); 16 String query; 17 while (!(query=br.readLine()).equals("exit")) { 18 System.out.println("He recibido: "+query); 19 } 20 System.out.println("***Cerrando conexion con: "+s+"\n\n"); 21 s.close(); 22 } while (true); 23 } 24 }
El cliente, para establecer una conexión con el servidor conocido, instancia directamente un Socket
indicando la dirección de la máquina del servidor (como texto) y el número de puerto (línea 7). Del mismo modo que en el caso del servidor, el Socket
permite acceder a los streams de entrada y salida que, a continuación, son recubiertos adecuadamente (9-10, 12-13).
Este cliente se limita a leer el teclado línea a línea y enviar la String
al servidor, para lo cual recubre el System.in
con un BufferedReader
y en un ciclo infinito lee de teclado, escribe en el PrintStream
que recubre al stream de salida del Socket
y controla si el texto es "exit" para terminar en tal caso.
1 import java.io.*; 2 import java.net.*; 3 4 public class Client { 5 6 public static void main(String[] args) throws UnknownHostException, IOException { 7 Socket s=new Socket("127.0.0.1",6000); 8 9 InputStream is=s.getInputStream(); 10 OutputStream os=s.getOutputStream(); 11 12 BufferedReader br=new BufferedReader(new InputStreamReader(is)); 13 PrintStream ps=new PrintStream(os); 14 15 BufferedReader teclado=new BufferedReader(new InputStreamReader(System.in)); 16 String q; 17 do { q=teclado.readLine(); 18 ps.println(q); 19 if (q.equals("exit")) System.exit(0); 20 } while (true); 21 } 22 }
Una vez vistos el servidor y el cliente anteriores, vamos a añadir un par de características necesarias para que sean minimamente de utilidad.
En primer lugar, el servidor sólo es capaz de servir a un cliente, de modo que si un segundo cliente pretende conectar, como el servidor no se encuentra en el accept
, no obtiene respuesta. Para ello es necesario que el servidor tenga capacidad para llevar a cabo un hilo de ejecución asociado a cada cliente, de modo que lo que hacemos es instanciar un nuevo objeto cada vez que se retorna del accept
, dándole el Socket
y delegando en él toda la relación con el cliente.
La clase ThreadedSocket
extiende Thread
y en su método run
se encarga de obtener los streams, recubrirlos adecuadamente y mantener el ciclo de comunicación con el cliente.
1 import java.io.*; 2 import java.net.*; 3 4 public class ThreadedServer { 5 public static void main(String[] args)throws IOException{ 6 ServerSocket ss=new ServerSocket(6000); 7 do { 8 Socket s=ss.accept(); 9 new ThreadedSocket(s); 10 } while (true); 11 } 12 } 13 14 class ThreadedSocket extends Thread { 15 Socket s; 16 ThreadedSocket(Socket s){super(); this.s=s; start();} 17 18 public void run() { 19 System.out.println("\n\n***Conexion establecida con: "+s); 20 21 try{ 22 InputStream is=s.getInputStream(); 23 OutputStream os=s.getOutputStream(); 24 25 BufferedReader br=new BufferedReader(new InputStreamReader(is)); 26 PrintStream ps=new PrintStream(os); 27 ps.println("OK"); 28 String query; 29 while (!(query=br.readLine()).equals("exit")) { 30 System.out.println("He recibido: "+query); 31 ps.println("OK"); 32 } 33 System.out.println("***Cerrando conexion con: "+s+"\n\n"); 34 s.close(); 35 } catch (Exception e) { 36 } 37 } 38 }
En nuestro ejemplo inicial, el cliente sólo era capaz de enviar lineas de texto al servidor, pero normalmente un cliente también tendrá que recibir información, de modo que en este caso también hay tareas a llevar a cabo en paralelo: la que ya llevabamos a cabo -copiar del teclado al servidor- y la nueva -copiar del servidor a la salida estándar-.
Para llevar a cabo la nueva tarea definimos una clase (lo hacemos de modo local a la rutina main
) que se encargará automáticamente de realizar el "eco" de lo recibido del servidor en la salida estándar. De este modo la simple instanciación de un objeto de esta clase nos basta para completar la funcionalidad buscada.
1 import java.io.*; 2 import java.net.*; 3 4 public class ThreadedClient { 5 6 public static void main(String[] args) throws UnknownHostException, IOException { 7 Socket s=new Socket("127.0.0.1",6000); 8 9 InputStream is=s.getInputStream(); 10 final BufferedReader br=new BufferedReader(new InputStreamReader(is)); 11 class Echo extends Thread{ 12 Echo(){setDaemon(true);start();} 13 public void run(){ 14 try {while (true)System.out.println(br.readLine());}catch (IOException e){}} 15 } 16 Echo e=new Echo(); 17 18 PrintStream ps=new PrintStream(s.getOutputStream()); 19 BufferedReader teclado=new BufferedReader(new InputStreamReader(System.in)); 20 String q; 21 do {q=teclado.readLine(); 22 ps.println(q); 23 if (q.equals("exit")) System.exit(0); 24 } while (true); 25 } 26 }
Se ha visto un ejemplo mínimo y se han añadido las dos funcionalidades necesarias para que tengamos la posibilidad de mantener un intercambio de frases entre un conjunto indeterminado de clientes y el servidor. Esto ha sido muy sencillo entre otras cosas porque no ha sido necesario establecer sincronismos entre hilos (no hay cooperación) ni un protocolo de comunicación (sólo se han cruzado cadenas de texto, no mensajes con diferentes contenidos).
Un modo muy sencillo de establecer comunicaciones cliente-servidor mediante un protocolo consiste en intercambiar objetos (en lugar de textos) recubriendo los streams con ObjectInputStream
y ObjectOutputStream
, de modo que la complejidad del protocolo queda embebida en la estructura de los objetos.
He diseñado mi propio tipo de letra. ¿Cómo puedo incluirlo en mi aplicación?
El mundo del diseño de "Fonts" (cosa de las Bellas Artes) y su uso en computadoras no es trivial. Todo lo necesario para el uso con Java se encuentra en el correspondiente tutorial de Oracle. Como respuesta concreta a cómo contar con un tipo de letra propio, se puede entresacar del mismo este sencillo código:
try { GraphicsEnvironment. getLocalGraphicsEnvironment(). registerFont(Font.createFont(Font.TRUETYPE_FONT, new File("A.ttf")); } catch (IOException|FontFormatException e) { /*Handle exception*/ }
donde se añade al entorno gráfico una nueva "font" que, en concreto, es de tipo "trueType" y se lee de un fichero (puede ser de otro tipo y en general leerse de cualquier "Stream" -véase documentación de Font.createFont-)
Quiero hacer un GUI de calculadora que pueda cambiar entre estándar y científica. ¿Cómo lo hago?
La manera más razonable puede ser agrupar en un par de paneles los botones que deben aparecer y desaparecer en cada caso para proceder a quitar y poner dichos paneles cuando se seleccione un modo u otro.
La siguiente imagen muestra una estructura sencilla de ejemplo: el "frame" lleva un "menuBar" donde se encuentran las dos opciones de paso de un modo a otro. Además hay un panel ("contenedorComun") para los botones que no varian entre ambos modos (componentes no visibles en la imagen) y un contenedor para intercambiar botoneras ("contenedorParaIntercambios"). Inicialmente este contenedor lleva dentro el panel de la calculadora estandar, pero se podrá intercambiar con el contenedor de la botonera cientifica que está "aparcado" en la sección "Other Components".
El modo de hacer el intercambio es extremadamente sencillo: basta con asociar a cada opción de menú su acción correspondiente como se ve en la siguiente imagen. No es otra cosa que sacar todo lo que haya en el panel (la botonera actual) y meter la botonera seleccionada. Una vez hecho esto terminamos con un "pack()" que le dice al "layoutManager" que haga su labor (que "empaquete" convenientemente el contenido)
(nota.- en sentido estricto el panel "contenedorParaIntercambios" es innecesario, pero se ha puesto por clarificar el ejemplo.)
Estoy dibujando histogramas en un JPanel... ¿Cómo puedo centrar el texto de una etiqueta?
Para esto hay que manejar la "métrica" de la fuente de texto que se usa en cada momento. La métrica de una fuente tiene que ver con una serie de conceptos medibles.
En el método paint(Graphics g)
se puede acceder a la fuente a través g.getFont()
/ g.setFont()
, y la métrica se obtiene mediante g.getFontMetrix()
.
Es sencillo conocer la anchura de una String con la metrica activa en un momento dado: simplemente basta con usar g.getFontMetrics.stringWidth("Texto a dibujar")
, que nos da el número de pixels que ocupará.
El siguiente ejemplo muestra una String
centrada en un punto (200,100) -con la coordenada Y en su línea base- y unas líneas cruzadas en dicho punto para comprobar que "funciona" correctamente.