T.A.P.

Técnicas Actuales de Programación

Curso: 2022/23

Calendario

Septiembre
LMXJV
[1]1213141516
[2]1920212223
[3]2627282930
Octubre
LMXJV
[4]34567
[5]1011121314
[6]1718192021
[7]2425262728
[8]31    
Noviembre
LMXJV
[8] 1234
[9]78lab91011
[10]141516lab1718
[11]2122lab232425
[12]282930lab  
Diciembre
LMXJV
[12]   12
[13]56789
[14]1213141516
[15]192021lab2223
 N  no lectivo,  N  fiesta,  N  estudio,  N  exámenes, N clase futura, N clase pasada, N clase anulada

Clases: {aula: 0.20S} {horario: jueves 10:40-11:30, viernes 9:40-11:30}
Laboratorios: {Aulas (por orden): AI-LU, AI-4, AI-6, AI-4, AI-2} {horario: 15:00-17:30}
Tutorias {con las excepciones que puedan indicarse en GAUR}: Jueves y Viernes de 8:00 a 9:30 y de 12:30 a 14:00

Programa ↡

Evaluación ↡

Desarrollo

SEPTIEMBRE

jueves 15 de septiembre de 2022
  • Presentación usando como apoyo esta misma página web
viernes 16 de septiembre de 2022

TEMA 1 - INTRODUCCIÓN

1.1.- Java, XML (Algorithms + Data Structures = Programs Niklaus Wirth) e Ingeniería del software.

(como ejemplo de uso de XML podéis abrir como zip cualquier archivo de Windows Office -pptx, docx,...-)

jueves 22 de septiembre de 2022

Antes de pasar a lo siguiente, insistiremos en el tema de los datos, viendo HTML en el navegador para hablar de XML de nuevo, así como volviendo a las bases de datos.

viernes 23 de septiembre de 2022

Ayer comenzamos insistiendo en el tema de los datos, y aunque estaba previsto decir algo sobre bases de datos, no lo hice... a ver hoy :-)

jueves 29 de septiembre de 2022

SOBRE HERRAMIENTAS UML

Como he comentado, 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).

viernes 30 de septiembre de 2022

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 (... y desensamblado, decompilación y ofuscación)

OCTUBRE

jueves 06 de octubre de 2022

2.3.- Compilación y ejecución (... y desensamblado, decompilación y ofuscación)

viernes 07 de octubre de 2022

2.4.- Generación de documentación

Adelanto de los puntos 1 y 2 del
TEMA 6 - INTERFACES GRÁFICOS

jueves 13 de octubre de 2022
viernes 14 de octubre de 2022
Construir un interfaz de calculadora simple.
A modo de ejemplo, este mismo:
interfaz de calculadora estrecho    interfaz de calculadora ancho

Recibidos en cursos anteriores

TEMA 3 - ELEMENTOS BÁSICOS DEL LENGUAJE

jueves 20 de octubre de 2022
viernes 21 de octubre de 2022
jueves 27 de octubre de 2022

/*Vemos el equivalente al while-else de Python para terminar con el tema anterior...
    ...y antes de continuar, planteamos un par de ejercicios para practicar sin Orientación a Objetos*/

Obtención del número Pi mediante aproximación por serie.

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.

Una solución: 

private static double pi() {
        double piOctavos = 0.0;
        for (int n = -1; n <= 100_000_000; )  piOctavos += 1.0/(n+=2)/(n+=2);
        return piOctavos * 8;
    }

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).

Obtención de números Perfectos

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

Resultado de la ejecución:
6 = 1+2+3
28 = 1+2+4+7+14
496 = 1+2+4+8+16+31+62+124+248
8128 = 1+2+4+8+16+32+64+127+254+508+1016+2032+4064

Listado de Números Perfectos [wikipedia]

Una solución: (Pendiente una versión mejorada)

TEMA 4 - ELEMENTOS RELACIONADOS CON LA ORIENTACIÓN A OBJETOS

viernes 28 de octubre de 2022

NOVIEMBRE

jueves 03 de noviembre de 2022

Hacemos un inciso para ver el punto 3 del
TEMA 6 - INTERFACES GRÁFICOS

viernes 04 de noviembre de 2022

/* El comportamiento "extraño" de los KeyEvents observado ayer deja de ser extraño cuando se lee la documentación
Continuamos con el ejemplo final del tema de ayer*/

Volvemos al
TEMA 4 - ELEMENTOS RELACIONADOS CON LA ORIENTACIÓN A OBJETOS

    (Zip con el proyecto utilizado en clase con frames emisor-receptores)

martes 08 de noviembre de 2022

Sesión de laboratorio (aula informática AI-LU). Guión: Calculadora [pdf] (con enlace de descarga en el enunciado)

jueves 10 de noviembre de 2022
viernes 11 de noviembre de 2022

TEMA 5 - MECANISMO DE TRATAMIENTO DE EXCEPCIONES Y ERRORES

miércoles 16 de noviembre de 2022

Veremos en un momento funcionar al recolector de basuras con el código descargable aquí.
Y veremos también una solución a la práctica de la calculadora

Sesión de laboratorio (aula informática AI-4). Guión: Dibujando sobre componentes Swing [pdf]

jueves 17 de noviembre de 2022

/* Comentaremos algo sobre la solución de la calculadora vista ayer en el laboratorio (la solución al "leak" en el constructor) */

viernes 18 de noviembre de 2022

/* En este punto volvemos a los ejercicios pendientes del cálculo de PI y los números Perfectos*/

martes 22 de noviembre de 2022

Echaremos un vistazo rápido a una solución de la práctica anterior

Sesión de laboratorio (aula informática AI-6). Guión: Matrices [pdf]

jueves 24 de noviembre de 2022

(Del tema 6 quedaba el punto 6.4 que se corresponde con lo visto en la sesión de laboratorio -y que revisaremos en el próximo-)
TEMA 7 - EL CONTENIDO DE LA BIBLIOTECA DE CLASES

  • 7.1 - Un vistazo general a las bibliotecas.
  • 7.2 - Object;... /* Nos quedamos a falta de ver Clone() en Object */
viernes 25 de noviembre de 2022
Al comentar System.currentTimeMillis() he mencionado esta comparativa Java/Python
miércoles 30 de noviembre de 2022
  • Hablaremos un poco de debugging
  • Hablaremos también de clases de test

Sesión de laboratorio (aula informática AI-4). Guión: Más con Matrices [pdf]

DICIEMBRE

jueves 01 de diciembre de 2022

Vemos un par de cosas en torno a la clase Matrix y su clase de test

viernes 02 de diciembre de 2022

EXAMEN DE TIPO TEST durante la primera hora

viernes 09 de diciembre de 2022

TEMA 8 - Entrada y salida de datos

jueves 15 de diciembre de 2022
// Dejo aquí un jar que muestra el funcionamiento el los árboles rojo-negro
viernes 16 de diciembre de 2022

TEMA 9 - Hilos

  • Hilos [pdf]. // Hemos llegado a ver el Interbloqueo
miércoles 21 de diciembre de 2022

Sesión de laboratorio (aula informática AI-2). Guión: La torre de Babel (I/O y Colecciones) [pdf]

Subida una solución el día 28 de diciembre

jueves 22 de diciembre de 2022
  • Continuamos con la sincronización Hilos [pdf].

POST CURSO

jueves 22 de diciembre de 2022

TEMA 10 - Programación en red

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 mínimamente 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.

---> Servidor y cliente para pruebas (ligeramente retocados frente a lo visto más arriba).
[descomprimir y ejecutar desde la carpeta "classes" como "java edu.upvehu.gbg.clientserver.ThreadedServer" y "java  edu.upvehu.gbg.clientserver.ThreadedClient"]

Hace algunos años, los alumnos desarrollaron un cliente de "chat". Aquí hay algo de información al respecto.

---> Aquí un Servidor y cliente con intercambio de objetos

miércoles 28 de diciembre de 2022

Olvidé subir una solución a la práctica 5... tarde, pero aquí está.

Extras

Páginas con ejercicios en la Web (aportaciones realizadas por varios alumnos -un agradecimiento general a ellos-).
Directamente relacionados con el curso
Cusiosidades sobre lenguajes e ingeniería del software
No son pocos los alumnos con inquietudes relacionadas con el desarrollo de video juegos

Java Magazine

2011: premiere, nov.-dic.
2012: ene.-feb., mar.-abr., may.-jun., jul.-ago., sep.-oct., nov.-dic.
2013: ene.-feb., mar.-abr., may.-jun., jul.-ago., sep.-oct., nov.-dic.
2014: ene.-feb., mar.-abr., may.-jun., jul.-ago., sep.-oct., nov.-dic.
2015: ene.-feb., mar.-abr., may.-jun., jul.-ago., sep.-oct., nov.-dic.
2016: ene.-feb., mar.-abr., may.-jun., jul.-aug., sep.-oct., nov.-dic.
2017: ene.-feb., mar.-abr., may.-jun., jul.-ago., sep.-oct., nov.-dec.
2018: ene.-feb., mar.-abr., may.-jun., jul.-ago., sep.-oct. nov.-dic.
2019: jan.-feb. no publicado, mar.-abr. may.-jun.
Ya no es descargable como pdf. Pueden localizarse online

"Not So Frequently Asked Questions"
En ocasiones alguna pregunta nada habitual puede ser de interés general....

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.