T.A.P.
Técnicas Actuales de Programación
Curso: 2024/25
|
|
|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
N no lectivo, N fiesta, N estudio, N exámenes, N clase futura, N clase pasada, N clase anulada |
Clases: {aula: 0.20S} {horario: lunes 12:00-12:50, jueves 10:40-11:30, viernes 9:40-10:30}
Laboratorios: {Laboratorio: aula 0.23} {horario: 14:30-17:00}
Tutorias {con las excepciones que puedan indicarse en GAUR}: Lunes de 13h a 14h, Jueves de 12h a 14h, y Viernes de 11h a 14h
Para cualquier consulta podeéis esribir a german.bordel@ehu.es
Si teneis dificultad con un proyecto, enviadlo como adjunto siguiendo este procedimiento →Enviar proyecto.
SEPTIEMBRE
TEMA 1 - INTRODUCCIÓN
1.1.- ["Algorithms + Data Structures = Programs"
Niklaus Wirth]
→ ¿Sólo necesitamos programas (lenguajes)? no, Programas + Ingeniería del software = Soluciones.
1.2- /*Nos quedamos en la página 4*/ Lenguajes de programación: Origen, situación actual y características deseables (el caso de Java) [pdf]
*** Antes de seguir, volvemos un momento atrás para hablar de bases de datos, que es algo que pasé por alto.
1.2- /*Continuamos desde la página 4 y llegamos a la 16*/ Lenguajes de programación: Origen, situación actual y características deseables (el caso de Java) [pdf]
1.2- /*Continuamos desde la página 17*/ Lenguajes de programación: Origen, situación actual y características deseables (el caso de Java) [pdf]
1.3- Máquina virtual [el concepto (re)nace con Java] [pdf]
1.4- /*Llegamos a ver la página 4*/ Obtención e instalación del software a utilizar [pdf]
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 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 unos 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).
/*Continuamos desde la página 5*/ 1.4- Obtención e instalación del software a utilizar [pdf]
TEMA 2 - USO DEL ENTORNO DE DESARROLLO
2.1.- Ejemplo inicial: el programa "Hola Mundo"
/*Hemos visto hasta la página 4*/"Hola Mundo" y primera aproximación a los conceptos Clase y Objeto [pdf]
aproximación "mecánica" a los conceptos de Clase y Objeto [9 min.]
2.1.- Ejemplo inicial: el programa "Hola Mundo" /*Retomamos desde la página 4*/"Hola Mundo" y primera aproximación a los conceptos Clase y Objeto [pdf]
2.2.- Bibliotecas de clases: su estructura
Bibliotecas de clases [pdf]
Biblioteca de clases [10 min.]
Biblioteca de clases desde la versión 9 -módulos- [5 min.]
2.3.- /*Hemos visto la página 2*/Compilación y ejecución (... y desensamblado, decompilación y ofuscación)
Ejecutables para compilación, etc. [pdf]
2.3.- /*vemos sólo la página 3*/Compilación y ejecución (... y desensamblado, decompilación y ofuscación)
Ejecutables para compilación, etc. [pdf]
/*Vemos la última página que dejamos ayer en un par de minutos*/
2.4.- Generación de documentación
Adelanto de los puntos 1 y 2 del
TEMA 6 - INTERFACES GRÁFICOS
OCTUBRE
/*Estamnos viendo los Layout Managers con ayuda de Netbeans y quedamos en el GridLayout*/
/*Continuamos con los Layout Managers*/
TEMA 3 - ELEMENTOS BÁSICOS DEL LENGUAJE
Aclaraciones sobre el ejercicio de la calculadora y minima introducción a debugging
Insistimos en que los GUIs deben ser redimensionables (al menos mínimamente)
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 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).
Un video interesante sobre la historia del cálculo de Pi (Veritasium@Youtube)Escriba una RUTINA que determine si un número dado es perfecto o no.
public class Numerologia { public static void main(String[] args) { //TODO programar el ciclo para que "n" recorra los valores requeridos y //de este modo poder llamar a "isPerfect(n)" } 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
Insistimos en que el ejercicio de la calculadora pretende que se domine el uso de gestores de layout.
Comentario sobre "como arrancan los interfaces" y el problema de los proyectos que no arrancan el interfaz.
Hacemos un inciso para ver el punto 3 del
TEMA 6 - INTERFACES GRÁFICOS
/*Comentar que la parte2 de la tarea de la calculadora se comenzatrá en el laboratorio*/
/*Comentario sobre eventos en GUIs y el uso de la cola de eventos*/
Volvemos al
TEMA 4 - ELEMENTOS RELACIONADOS CON LA ORIENTACIÓN A OBJETOS
Noviembre
Sesión de laboratorio ❶ (2:30 p.m. laboratorio 0.23). Guión: Calculadora [pdf]
TEMA 5 - MECANISMO DE TRATAMIENTO DE EXCEPCIONES Y ERRORES
Retomando pendiente:
Hemos echado un vistazo a la ejecución con perfilado en Netbeans con el código de ejemplo para monitorizar el Garbage Collector de la página 22 del tema "Elementos relacionados con la Orientación a Objetos"
Vemos en el laboratorio el punto 3 del
TEMA 6 - INTERFACES GRÁFICOS
Sesión de laboratorio ❷ (laboratorio 0.23). Guión: Gráficos en GUIs [pdf]
Retomando pendiente:
Hemos visto cómo orientar la resolución del ejercicio de la calculadora (con un autómata de estados que controle qué teclas son válidas en cada momento),
y hemos visto una solución al cálculo de Pi.
TEMA 7 - EL CONTENIDO DE LA BIBLIOTECA DE CLASES
Sesión de laboratorio ❸ (laboratorio 0.23). Guión: Una clase típica: Matrix [pdf]
/* Lamentablemente retrasamos la práctica prevista (la más interesante), pero nos ha faltado una clase para ver las colecciones. Haremos esta otra... */
Sesión de laboratorio ❹ (laboratorio 0.23). Guión: Usando Netbeans para completar una aplicación con varias clases [pdf]
/* Veremos una solución al ejercicio del laboratorio para "discutir" algunos detalles */
Hemos visto y comentado en el aula unas clases que "se aproximan" a una solución al ejercicio.
En todo caso varios espectos eran claramente mejorables, y de hecho no eran del todo correctas y contenían errores, algunos detectables por las acciones llevadas a acabo en el main
, y otros no.
Esto nos lleva al tema de los "test" a los que se deben someter a las aplicaciones: es un tema pendiente.
Dejo aquí una solución donde esas clases han sido retocadas y corregidas en algunos aspectos, añadiendo algunos comentarios explicativos.
Es una solución a la que cabe dar "más vueltas" aún... p.ej. no nos hemos planteado qué hacer con todo lo relativo a la herencia de Object.
Tampoco hemos pensado de estructurar la solución más allá de lo que ha venido forzado por el enunciado... p.ej. sería razonable definir la clase Persona
en lugar de mezclar sus datos dentro de la clase Abono
.
Diciembre
Haremos el examen de tipo test en eGela
// Dejo aquí un jar que simula el funcionamiento el los árboles rojo-negro
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.