T.A.P.

Técnicas Actuales de Programación

Curso: 2018/19

Calendario

Septiembre
LMMJV
[1]1011121314
[2]1718192021
[3]2425262728
Octubre
LMMJV
[4]12345
[5]89101112
[6]1516171819
[7]2223242526
[8]293031  
Noviembre
LMMJV
[8]   12
[9]56789
[10]121314lab1516
[11]192021lab2223
[12]262728lab2930
Diciembre
LMMJV
[13]34567
[14]101112lab1314
[15]171819lab2021
 N  no lectivo,  N  fiesta,  N  estudio,  N  exámenes, N N clase, N clase anulada

Clases: {aula: 0.20S} {horario: jueves 10:40-11:30, viernes 9:40-11:30
Laboratorios: {aula: AI.1} {horario: 15:00-17:30}
Tutorias: {con las excepciones que se indiquen en GAUR, generalmente, J 8:00-10:00, V 8:00-9:00, JV 12:00-13:30}

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

La última versión estable de Java es la 10 -que ha sustituido a la 9 en sólo 6 meses-, pero nos quedaremos con la 8 porque, a la par de la introducción de la versión 9, 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 la versión actual no ha terminado de implantar algunas de las características que se encontraban en la anterior.

También es cierto que la versión 9 de Java introdujo la posibilidad de organizar todo el desarrollo en módulos (entre otras cosas), y esto está soportado por Netbeans 9 pero no por el 8.

Por otro lado, la versión 8 introdujo, entre otras características, la "programación funcional". No se estudirá esto en el curso (sí se comentará en qué consiste y se pondrá en contexto) porque en la práctica supone introducir una visión muy distinta de la programación más extendida (la "imperativa") y no se dipone de tiempo (que además no sería poco... puede ser un curso aparte).

Con todo ello nos quedamos con que:
        * usaremos básicamente las capacidades de Java 7
        * la programación funcional introducida en Java 8 quedará fuera del temario
        * veremos la estructuración en módulos introducida en Java 9 sin practicarla por falta de un IDE

Documentación de utilidad:
* La referencia definitiva del lenguaje Java {suficiente: versión 7} {actual: versión 10}
* La documentación de la plataforma SE{suficiente: versión 7} {actual: versión 10}
* Los "tutoriales" de 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 13 de septiembre de 2018
Viernes 14 de septiembre de 2018

TEMA 1 - INTRODUCCIÓN

Jueves 20 de septiembre de 2018

Continuamos donde lo dejamos...
... y quedamos a punto de ver la Máquina Virtual

Viernes 21 de septiembre de 2018

Continuamos donde lo dejamos...
... y pasamos a lo siguiente:

TEMA 2 - USO DEL ENTORNO DE DESARROLLO

Qué JDK instalar: definitivamente parece que Netbeans 8 no puede con JDK 10, así que descargaremos el JDK 8
(en realidad se puede usar JDK 10 y "trampear" Netbeans 9 para añadir funcionalidades de Netbeans 8, pero a riesgo de que dé algún problema)

Jueves 27 de septiembre de 2018

Continuamos donde lo dejamos...
... y casi terminamos.

Viernes 28 de septiembre de 2018

Sólo nos ha faltado hacer un "HolaMundo" con Netbeans así que lo hacemos...
Importancia de los comentarios y la documentación; los "TODO"; identificadores: convenio de nombrado, idoneidad; refactoring;
... y pasamos a lo siguiente:

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

OCTUBRE

Jueves 4 de octubre de 2018

Nos quedó pendiente ver los menús en los GUIs... y sigue pendiente para mañana

  • A raíz del ejercicio de la calculadora...
    • Ya tenemos algo
    • Envío de ejercicios (ej. 1), autoría, "deadlines", valoración, y resolución/participación en clase (comentario sobre webs con ejercicios).
    • Recomendaciones de qué hacer y qué no...
      • múltiples main(.) (ej.2), MVC y el JFrame en nuestra aplicación.
      • refactoring, búsquedas, ...
      • identificadores a todos los niveles (convenio de nombrado, idoneidad, ...) espacios de nombres (ejemplos aquí)
viernes 5 de octubre de 2018

Nos sigue quedando pendiente ver los menús en los GUIs...
... y además lo de los espacios de nombres

TEMA 3 - ELEMENTOS BÁSICOS DEL LENGUAJE

Jueves 11 de octubre de 2018

Continuamos donde nos quedamos con los elementos básicos del lenguaje...
(* el pdf ha cambiado ligeramente respecto al día anterior, pero los cambios no afectan a lo ya visto.)
... nos quedamos en los "break", "continue",...

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:
public static double pi() {
        double pi = 0.0;
        for (int i = -1; i <= 100_000_000; )  pi += 2.0/(i+=2)/(i+=2);
        return pi*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 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 [pdf]

Jueves 18 de octubre de 2018

Dedicaremos la hora a "darles vueltas" a los elercicios planteados. (si podemos, terminamos con las sentencias "break", etc...)

Viernes 19 de octubre de 2018

Continuaremos "dando vueltas" a los elercicios planteados, y, terminaremos con las sentencias "break", etc...)

Comprobación de posible optimización por el compilador.

En la clase CalculadorDiversoDeNumerosPerfectos hemos visto el método perfectosMejor() donde hay un limite a un ciclo for que no es preciso calcularlo en cada iteración. No sabemos si el compilador "se da cuenta" y lo evita. Haga las pruebas necesarias para "descubrirlo".
(Ojo, para descubrir un comportamiento así mediante experimentación, lo razonable es hacer pruebas con un código lo más simplificado posible. La rutina perfectosMejor() símplemente ha servido para plantearnos la cuestión)

public static void perfectosMejor(long max){
  for (long candidato=1; candidato<max; candidato++) {
    long suma=1;
    for (int divisor=2;divisor<=Math.sqrt(candidato);divisor++) if (candidato%divisor==0) suma+=divisor+candidato/divisor;
    if (candidato==suma) System.out.println(candidato);
  }
}
Una solución: TBD

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

Jueves 25 de octubre de 2018

El pasado lunes emitieron en "La 2" una película sobre Ramanujan. En la solución del ejercicio sobre PI he añadido algo al respecto
Comentarios sobre el ejercicio propuesto.
Comentados cambios en el pdf de "elementos básicos" (insertada página 6 -matrices-, y cambios en 5 y 18)

Viernes 26 de octubre de 2018

Cambiada la página sobre arrays en el pdf de "elementos básicos" para corregir errores.

Comentario: Hay que tener mucho cuidado con la representación decimal...

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

Solución a un ejercicio encontrado en la WWW.

La propuesta es localizar en la Web alguna página en la que se propongan ejercicios en Java y donde encontremos al menos uno con un "nivel razonable" para el punto en que nos encontramos (o poco más, ya que es fácil auto-aprender). Con esto hacer lo siguiente:

  • Si el "ejercicio razonable" elegido no está resuelto, resolverlo como proyecto Netbeans y enviarlo.
  • Si está resuelto, hacer un proyecto Netbeans con la solución copiada y comprobar su funcionamiento. Añadir un fichero de texto con las observaciones que se consideren pertinentes sobre el código y la ejecución.
  • en todo caso, poner en la cabecera de la clase principal, como comentario, la dirección de la página web encontrada.

Las aportaciones realizadas hasta el momento por varios alumnos (un agradecimiento general a ellos) se encuentran más abajo en la sección "Extras".
Todas tienen su interés, pero mencionaré particularmente las dos primeras de la lista "en inglés" por el hecho de que permiten introducir la solución y someterla test, y esto de los test es algo de lo que tenemos que hablar un poco próximamente (de las clases de test).
Hasta el jueves a las 7:00 se admiten NUEVAS aportaciones

NOVIEMBRE

Jueves 8 de noviembre de 2018
  • Haremos algunos comentarios a raiz del último ejercicio:
    • Ha propiciado avances sore el temario (bien, pero problemático) (ubicuidad del Scanner).
    • El tiempo se echa encima, ¿dónde estamos? (es un curso afectado por las fiestas).
    • Las calificaciones por el momento están al día.
    • Han aparecido las clases de test...
    • ...y eso me hace ver que he saltado la referencia a patrones en wikipedia que está más arriba (ver el patron "Observador" ahí y en siguiente punto).
  • ...volveremos un momento al ejemplo de interacción con un GUI para hacer hincapié en cómo el polimorfismo nos permitió implementar el patron "Observador"...

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

  • ...continuamos donde dejamos el tema 4 //Hemos llegado a comentar los módulos
  • Los módulos introducidos en Java 9 aportan nuevas posibilidades a la arquitectura de las soluciones reforzando el encapsulamiento.[Youtube]
Viernes 9 de noviembre de 2018
  • Quedaron comentarios sin hacer ayer por no haber actualizado esta página web:
    • Las calificaciones por el momento están al día.
    • Han aparecido las clases de test...
  • ...continuamos donde dejamos el tema 4. // dejamos pendientes la enumeraciones (el resto está ya todo visto)
Miércoles 14 de noviembre de 2018 [LABO AI.1, 15:00-17:30]
Enviar las reflexiones planteadas al final de la práctica.

Nada qe añadir :-)

Jueves 15 de noviembre de 2018
  • Comentario inicial: el problema del pasado viernes con los ambitos de acceso en la reescritura de métodos era trivial... lo vemos.
  • Ya puestos... vamos a ver también un ejemplo mínimo de test de una rutina dentro de una clase de test.
  • ...continuamos donde dejamos el tema 4.
Viernes 16 de noviembre de 2018

TEMA 5 - MECANISMO DE TRATAMIENTO DE EXCEPCIONES Y ERRORES

Miércoles 21 de noviembre de 2018 [LABO AI.1, 15:00-17:30]
  • No lo dice el enunciado, pero las situaciones de excepción/error se han de tratar con el mecanismo ya visto.
Completar (a discreción) la práctica y añadir la posibilidad de que las matrices sean "Inmutables".

Nada qe añadir :-)

Jueves 22 de noviembre de 2018
  • A raíz de la práctica con matrices: Java no tiene sobrecarga de operdores, lo que fue una opción personal de James Gosling de la que se arrepiente. Puede leerse en la sexta pregunta de esta magnífica entrevista que le hacen junto a Dennis Ritchie (C) y Bjarne Stroustrup (C++).

Finalizamos con el punto 3 del
TEMA 6 - INTERFACES GRÁFICOS

  • Sabemos usar Netbeans para montar GUIs. No hemos visto Swing a fondo, pero echamos un vistazo a la demo
  • Tiene interés saber "dibujar" en nuestros GUIs (inicialmente sobre "Canvas", pero en general sobre cualquier componente y en particular sobre un "JPanel"). Lo haremos con la próxima práctica.
  • En todo caso JavaFX es la solución más actualizada para los GUIs, y aunque no lo estudiemos podemos ver también la demo. (en Netbeans las aplicaciones con JavaFX son un tipo específico de aplicación)
Viernes 23 de noviembre de 2018

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) y se sale de lo que podemos hacer en un curso con el tiempo disponible y en que no vemos programación funcional.
(ni qué decir de la versión 11, aunque en este caso no complica en exceso la API frente a la versión 8)
Un acceso "agradable" a la documentación de la versión 11 se encuentra aquí
  • Segunda hora: examen de test. Iremos al AULA 2.5
Miércoles 28 de noviembre de 2018 [LABO AI.1, 15:00-17:30]
Variante de JPanel "especial"

Fabricar otra subclase de JPanel con un método que pueda recibir un array dobles y representarlos como histograma.
Cuidar un poco la presentación para que no resulte "desagradable".

Como idea "extra": el mismo panel podría incluir un slider (llevarlo ya integrado) de modo que al desplazarlo permitiría variar el ancho y la separación de las baras del histograma.

Más ideas "extras": pueden hacerse paneles similares para "diagramas de tarta", otros tipos de gráficas; también para otros "gadgets"... velocímetros, relojes,...

Como ejemplo: la mejor solución obtenida el curso pasado para este ejercicio.

Jueves 29 de noviembre de 2018
  • Resolveremos la práctica del laboratorio
  • Continuamos donde nos quedamos: profundizando en equals(.)-hashCode()-clone() (volver al hashCode() generado por NetBeans)
Viernes 30 de noviembre de 2018
  • Continuamos donde nos quedamos: profundizando en clone()

La práctica siguiente nos obliga a adelantar el
TEMA 8 - Entrada y salida de datos

DICIEMBRE

Miércoles 12 de diciembre de 2018 [LABO AI.1, 15:00-17:30]
  • Hablamos de Listas y Mapas antes de empezar la práctica
Completar la práctica

Sin más ;)

Proyecto para probar comparadores
Jueves 13 de diciembre de 2018
  • Continuamos con IO donde lo dejamos

Volvemos hacia atrás para ver el
TEMA 7 - EL CONTENIDO DE LA BIBLIOTECA DE CLASES

Viernes 14 de diciembre de 2018

TEMA 9 - Hilos

Miércoles 19 de diciembre de 2018 [LABO AI.1, 15:00-17:30]
Video ejemplo de resultado
Jueves 20 de diciembre de 2018
  • Continuamos con Hilos donde lo dejamos
Viernes 21 de diciembre de 2018
  • Volveremos al ejercicio sobre Perfectos para ver la solución con hilos (usa ThreadPoolExecutor)

TEMA 10 - Cliente/servidor

Cuestiones que han quedado fuera por falta de tiempo.
  • acceso a URLs y...
  • expresiones regulares "arañando" esta web
    Aquí [zip] un proyecto Netbeans con una sencilla clase para hacer "scraping" y otra con una prueba concreta.
    Sin complicarlo casi nada he "añadido" algunas cosas que pueden ser interesantes: la clase se ajusta al patrón "Iterator", se usa un "logger" para registrar mensajes de advertencia,...
    Mirad el código para ver cómo funciona. Para entender su comportamiento la documentación en HTML es más clara.
  • Uso del debugger y del profiler

No programado pero interesante: Bases de datos

  • Ejemplo de acceso a base de datos con MySQL
    • (instalador de MySQL).
    • Los ficheros de texto a procesar son los del alineamiento fonético de voz y actas de las sesiones del Parlamento Vasco de los días: 1, 11, 14, 15 de diciembre de 2017. No es preciso "bajarlos", accederemos a ellos directamente desde el programa.
    • Es necesario el driver JDBC para MySQL
    • La base de datos se ha construido con:
      create database actaspv;
      use actaspv;
      CREATE TABLE estadisticas (
        `id` VARCHAR(8) NOT NULL,
        `numPalabras` INT NOT NULL,
        `validas` INT NOT NULL,
        `media` DOUBLE NOT NULL,
        `desviacionTipica` DOUBLE NOT NULL,
        PRIMARY KEY (`id`),
        UNIQUE INDEX `id_UNIQUE` (`id` ASC));
                       
    • Una solución como proyecto Netbeans, y su javadoc.

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.