T.A.P.

Técnicas Actuales de Programación

Curso: 2021/22

Calendario

Septiembre
LMXJV
[1]1314151617
[2]2021222324
[3]27282930 
Octubre
LMXJV
[3]    1
[4]45678
[5]1112131415
[6]1819202122
[7]2526272829
Noviembre
LMXJV
[8]12345
[9]8910lab1112
[10]151617lab1819
[11]222324lab2526
[12]2930   
Diciembre
LMXJV
[12]  123
[13]678910
[14]131415lab1617
[15]202122lab2324
 N  no lectivo,  N  fiesta,  N  estudio,  N  exámenes, N clase futura, N clase pasada, N clase anulada

Clases: {aula: 2.2} {horario: jueves 10:40-11:30, viernes 9:40-11:30
Laboratorios: {Aula AI-6} {horario: 15:00-17:30}
Tutorias -con Webex- {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 16 de septiembre de 2021
  • Presentación usando como apoyo esta misma página web
viernes 17 de septiembre de 2021

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 23 de septiembre de 2021
viernes 24 de septiembre de 2021
jueves 30 de septiembre de 2021

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"

OCTUBRE

.
viernes 01 de octubre de 2021

2.1.- Ejemplo inicial: el programa "Hola Mundo"

2.2.- Bibliotecas de clases: su estructura

2.3.- Compilación y ejecución

2.4.- Desensamblado y decompilación

jueves 07 de octubre de 2021

2.5.- Generación de documentación

viernes 08 de octubre de 2021

2.5.- Generación de documentación

  • ...
  • Elementos relacionados:
    • /*continuamos viendo los ejemplos...*/Espacios de nombres (ejemplos aquí)

Veremos todo lo anterior, y alguna otra cuestión básica, con Netbeans sobre el proyecto HolaMundo

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

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

Recibidos en cursos anteriores

viernes 15 de octubre de 2021

TEMA 3 - ELEMENTOS BÁSICOS DEL LENGUAJE

jueves 21 de octubre de 2021
viernes 22 de octubre de 2021

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

jueves 28 de octubre de 2021
/*Antes de continuar con los intefaces, 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: TBD
viernes 29 de octubre de 2021

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

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

jueves 04 de noviembre de 2021

/* Dejamos pendientes los ejemplos de publish/subscribe... los vemos con Netbeans
Previamente una pequeña explicación para entender la idea básica de lo que es un constructor (más adelante lo veremos "a fondo")
Nos fijaremos también en como unos objetos pueden "saber de otros" */

viernes 05 de noviembre de 2021

/*He de corregir un olvido: tras ver el ejemplo del patrón Observador en la asociación de acciones a eventos en el GUI, debí explicar cómo lo facilita la herramienta de diseño de GUIs de Netbeans. Está en las últimas hojas de Comunicación entre componentes, y lo veremos con Netbeans también*/

miércoles 10 de noviembre de 2021

Sesión de laboratorio (aula informática AI6). Guión: Calculadora [pdf]

    (Vídeo con el desarrollo de la estructura de la solución)

jueves 11 de noviembre de 2021

/* Cometí el error de mantener aquí en la web una referencia a que el laboratorio de ayer se llevaría a cabo mediente Webex (lo previsto antes de comenzar el curso), por lo que algunos alumnos se perdieron la sesión. Veremos entonces en clase cómo desarrollar el ejercicio.
La cuestión es si hacerlo hoy o mañana tras el examen... queda a lo que se decida en clase --> Resultado: mañana tras el examen*/

/* Como explicar un poco el tema de los módulos quedó para más adelante porque el tiempo apremia, vamos a ver, muy por encima, cual es la idea general con un pequeño video. */

TEMA 5 - MECANISMO DE TRATAMIENTO DE EXCEPCIONES Y ERRORES

viernes 12 de noviembre de 2021

9:40 - 10:40 examen de test presencial mediante eGela.

Segunda hora: repaso a la primera práctica de laboratorio/* debido a mi error con la convocatoria. No se hará con las demás sin no hay un motivo concreto */

miércoles 17 de noviembre de 2021

Las calificaciones obtenidas en el examen de test se encuentran ya en mis registros y pueden verse en la página Calificaciones. Comprobad que esté todo correcto. A aquellas personas que realizaron el examen en un curso anterior y no me han dado instrucciones al rspecto, les he conservado la nota en caso de ser superior a 5.0. Si quieren ir al examen final con el 100% (anulando el parcial) pueden indicármelo en el plazo de una semana.

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

jueves 18 de noviembre de 2021
viernes 19 de noviembre de 2021

/* En este punto deberíamos volver al ejercicio pendiente del cálculo de PI pero vamos con retraso y ya hemos hecho cosas más complícadas */

  • Hablaremos un poco de debugging
  • Hablaremos también de clases de test

(Terminaremos el tema 6 (punto 6.4) de modo práctico en el próximo laboratorio)
TEMA 7 - EL CONTENIDO DE LA BIBLIOTECA DE CLASES

miércoles 24 de noviembre de 2021

/* publicado, en el día correspondiente, un vídeo desarrollando la estructura de la solución de la práctica "Calculadora" */

Sesión de laboratorio (aula informática AI6). Guión: Gráficos en GUI [pdf]

jueves 25 de noviembre de 2021
viernes 26 de noviembre de 2021

TEMA 8 - Entrada y salida de datos

DICIEMBRE

jueves 02 de diciembre de 2021

Con las prisas, tras ver el último día los arboles de clases disponibles en java.util, pasé a IO dejando de hablar un poco de los genéricos. Lo haremos hoy antes de seguir donde lo dejamos.

viernes 03 de diciembre de 2021
jueves 09 de diciembre de 2021

Clase anulada. Acordaremos una posible recuperación de la hora perdida. (acordado el próximo día 22)

viernes 10 de diciembre de 2021

TEMA 9 - Hilos

  • Hilos [pdf].// Lo dejamos viendo que algo falla en la ejecución paralela
miércoles 15 de diciembre de 2021

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

jueves 16 de diciembre de 2021
  • // Continuamos con... Hilos [pdf].

TEMA 10 - Programación en red

Vemos una introducción al tema en pizarra, para probar mañana un ejemplo

viernes 17 de diciembre de 2021

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.

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

Hemos comentado en clase que, hace algunos años, los alumnos desarrollaron un cliente de "chat". Aquí hay algo de información al respecto.

---> Aquí el Servidor y cliente con intercambio de objetos que no ha llegado a funcionar en clase.
No sé qué sucedía en clase porque ha funcionado sin hacer ningún cambio sustancial.
Después sí que he detectado un error: el servidor siempre recibía el mismo mensaje del cliente... y es que es lógico (despiste mío) porque el proceso de serialización controla si un objeto ya ha sido enviado (independiente de cambios posteriores) y en tal caso el receptor obtiene la referencia al objeto ya recibido. Por tanto he hecho que el objeto enviado sea siempre uno nuevo.

Por lo demás he cambiado los mensajes que muestran cliente y servidor mostrando los objetos intercambiados, para lo que he implementando toString() en la clase Protocolo
miércoles 22 de diciembre de 2021

De 8:40 a 10:30 recuperamos la clase del pasado día 9 y adelantamos la de mañana

    Algunas cosas pendientes:
  • El ejercicio de los números Perfectos está sin analizar.
  • Quedamos en ver un par de maneras de resolver el método findMostSimilars(.) de la práctica del pasado miércoles.

De 15:00 a 17:30 laboratorio

Ejecución paralela y temporizada. [pdf]

Video ejemplo de resultado
jueves 23 de diciembre de 2021

Anulada a petición de los alumnos y ya recuperada ayer.

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.