T.A.P.

Técnicas Actuales de Programación

Curso: 2020/21

Calendario

Septiembre
LMMJV
[1]7891011
[2]1415161718
[3]2122232425
[4]282930  
Octubre
LMMJV
[4]   12
[5]56789
[6]1213141516
[7]1920212223
[8]2627282930
Noviembre
LMMJV
[9]23456
[10]91011lab1213
[11]161718lab1920
[12]2324252627
[13]30    
Diciembre
LMMJV
[13] 12lab34
[14]789lab1011
[15]141516lab1718
 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

Programa

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.

Temario

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)

Prerrequisitos

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

Evaluación

Convocatoria ordinaria

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

Convocatoria extraordinaria

Desarrollo

SEPTIEMBRE

Jueves 10 de septiembre de 2020
  • Presentación usando como apoyo esta misma página web
Viernes 11 de septiembre de 2020

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

Jueves 17 de septiembre de 2020

1.2.- Origen y características de Java

viernes 18 de septiembre de 2020

1.3.- La Máquina Virtual

jueves 24 de septiembre de 2020

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"

Viernes 25 de septiembre de 2020

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

Jueves 1 de octubre de 2020
  • /*continuamos después de hablar de documentación*/ Elementos relacionados:

Comprobamos todo lo anterior desde Netbeans

viernes 02 de octubre de 2020

//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

Construir un interfaz de calculadora simple.
A modo de ejemplo, este mismo:
interfaz de calculadora estrecho    interfaz de calculadora ancho

(Recibidos en cursos anteriores..., más...)

(Recibidos en este curso...)

Jueves 8 de octubre de 2020

TEMA 3 - ELEMENTOS BÁSICOS DEL LENGUAJE

//Hemos visto hasta Identificadores y literales

Viernes 9 de octubre de 2020

//Continuamos donde lo dejamos...
    ...y llegamos a ver "while" y "do-while" a falta de "for".

jueves 15 de octubre de 2020

//Ya tenemos alguna calculadora (ver en el ejercicio planteado el viernes 2)
//Continuamos donde lo dejamos...

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

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: TBD

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

viernes 16 de octubre de 2020

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

jueves 22 de octubre de 2020

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

viernes 23 de octubre de 2020

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

jueves 29 de octubre de 2020

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

viernes 30 de octubre de 2020

//Continuamos donde lo dejamos
//continua pendiente el pequeño video sobre escritura de constructores y métodos de obtención de instancias.

  • Antes de avanzar, volveremos un momento al ejercicio pendiente del cálculo de PI
  • Hablaremos un poco de debugging, comenzando antes de ello por la medición de tiempos de ejecución.
  • Hablaremos también de clases de test

NOVIEMBRE

jueves 05 de noviembre de 2020

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

viernes 06 de noviembre de 2020

//Continuamos con el punto 7.2 donde lo dejamos.

//Hemos comenzado con java.util, dejándolo a punto de hablar de Formatter, etc.

miércoles 11 de noviembre de 2020

Sesión de laboratorio por BBC (enlace en eGela). Guión: Calculadora [pdf]

jueves 12 de noviembre de 2020
  • Trabajamos sobre el ejercicio del laboratorio de ayer. No hay tiempo para llegar resolver completamente (entre otras cosas por algunos descuidos al improvisar la solución) pero queda "encaminado" hacia una solución como pueder ser esta (echad un vistazo al código porque podéis encontrar algunos detalles de interés)
miércoles 18 de noviembre de 2020

Sesión de laboratorio por BBC (enlace en eGela). Guión: Matrices [pdf]

jueves 19 de noviembre de 2020

Examen de test en eGela

viernes 20 de noviembre de 2020

//Continuamos con java.util donde lo dejamos.

jueves 26 de noviembre de 2020

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.

viernes 27 de noviembre de 2020

//Continuamos donde lo dejamos...
//...llegamos a ver una copia simple de ficheros de texto y quedamos en ver codificaciones.

DICIEMBRE

miércoles 02 de diciembre de 2020

Sesión de laboratorio por BBC (enlace en eGela). Guión: Gráficos en GUI [pdf]

jueves 03 de diciembre de 2020

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)

viernes 04 de diciembre de 2020

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

miércoles 09 de diciembre de 2020

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]

jueves 10 de diciembre de 2020

//Continuamos donde lo dejamos con IO el día 27/11

TEMA 9 - Hilos

  • Hilos [pdf]. // Llegamos a ver productores y consumidores. tenemos que ver el cubículo y la ejecución

//Llegamos hasta los niveles de prioridad

viernes 11 de diciembre de 2020

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

miércoles 16 de diciembre de 2020

Sesión de laboratorio por BBC (enlace en eGela). Guión: La torre de Babel (I/O y Colecciones) [pdf]

jueves 17 de diciembre de 2020

//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

viernes 18 de diciembre de 2020

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.

  • Para terminar, echaremos un vistazo a la solución del ejercicio pendiente de los números perfectos.

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.