1.4. Desarrollo del tema.

PROYECTO DE INCENTIVACIÓN A LA

INNOVACION DOCENTE UNIVERSIDAD DE ZARAGOZA

PIIDUZ-2009-3-293

GENERACIÓN DE MATERIAL DOCENTE

ADAPTADO AL EEES PARA LA

ASIGNATURA DE FUNDAMENTOS DE

INFORMÁTICA EN LOS GRADOS DE

INGENIERÍA INDUSTRIAL

PIIDUZ-2009-3-293

2

DISEÑO CURRICULAR................................................................................................. 4

1.1. Contexto ........................................................................................................... 4 1.2. Diseño de la asignatura..................................................................................... 4 1.3. Competencias. .................................................................................................. 5 1.4. Metodología docente ........................................................................................ 6 1.5. Sistema de calificación. .................................................................................... 7 1.6. Temario............................................................................................................. 8

TEMA 0 PRESENTACIÓN............................................................................................. 9 TEMA 1. Arquitectura de computadores: Hardware y Software ................................... 10

1.1. Objetivos......................................................................................................... 10 1.2. Competencias. ................................................................................................ 10

Conceptuales: ......................................................................................................... 10 Prodecimentales:..................................................................................................... 10 Actitudinales:.......................................................................................................... 10

1.3. Tiempos dedicados. ........................................................................................ 10 1.4. Desarrollo del tema......................................................................................... 11 1.4.1. ORGANIZACIÓN Y ARQUITECTURA DEL COMPUTADOR............ 11 1.4.2. SOFTWARE............................................................................................... 12 1.4.3. SISTEMAS OPERATIVOS....................................................................... 13 1.4.4. BASES DE DATOS RELACIONALES.................................................... 19 1.4.5. HARDWARE DEL COMPUTADOR ....................................................... 22

TEMA 2. REDES DE COMPUTADORES. INTERNET.............................................. 23 1.1. Objetivos......................................................................................................... 23 1.2. Competencias. ................................................................................................ 23


1.3. Tiempos dedicados. ........................................................................................ 23 1.4. Desarrollo del tema......................................................................................... 24

TEMA 3.......................................................................................................................... 25 REPRESENTACIÓN DE LA INFORMACIÓN EN LOS COMPUTADORES........... 25

1.1. Objetivos......................................................................................................... 25 1.2. Competencias. ................................................................................................ 25



TEMA 4 CLASES Y OBJETOS.................................................................................... 28 1.5. Objetivos......................................................................................................... 28 1.6. Competencias. ................................................................................................ 28



Problema: Trabajamos con el proyecto “Figuras”.................................................. 29 Problema: Cajero automático I ............................................................................... 30 Problema: Cajero automático II.............................................................................. 31

PIIDUZ-2009-3-293

3

Problema: Booleanos, operadores lógicos if anidados ........................................... 31 Problema: Móviles................................................................................................. 32 Problema: Recapitulación de conceptos ................................................................. 35 Problema: Crear una clase completa. Persona........................................................ 35 Problema: Plataformas Java. Clase Complejo........................................................ 36

TEMA 5 Estructuras de datos y algoritmos. Comunicación entre objetos.................... 37 1.1. Objetivos......................................................................................................... 37 1.2. Competencias. ................................................................................................ 37



Problema: Todo son objetos ................................................................................... 38 Problema: Control del flujo de un programa .......................................................... 40 Problema: Tipos de datos complejos ...................................................................... 41

TEMA 6 Abstracción de datos: Herencia...................................................................... 44 1.1. Objetivos......................................................................................................... 44 1.2. Competencias. ................................................................................................ 44



Problema: Base de datos de CD y DVD................................................................. 45 Problema: Empresa................................................................................................. 49 Problema: Herencia y polimorfismo....................................................................... 50

TEMA 7 Diseño de clases .............................................................................................. 52 1.5. Objetivos......................................................................................................... 52 1.6. Competencias. ................................................................................................ 52



Problema: Criba de Erastótenes.............................................................................. 53 Problema: Descomprimir un fichero. ..................................................................... 55 Problema: Comprimir el fichero............................................................................. 56 Problema: Alquiler de películas. ............................................................................ 56 Problema: Girar una imagen................................................................................... 60

Bibliografía..................................................................................................................... 62

PIIDUZ-2009-3-293

4

DISEÑO CURRICULAR 1.1. Contexto

El Espacio Europeo de Enseñanzas de Educación Superior (EEES) ha promovido en los últimos años un cambio tanto en la estructura de las titulaciones superiores como en las metodologías docentes. En el próximo curso académico 2010-2011, las titulaciones de Ingenierías de la Universidad de Zaragoza se adaptarán a estos cambios con la aparición de los nuevos grados en varias especialidades. En todas las especialidades aparece en el primer curso de la titulación la asignatura de Fundamentos de Informática. Los contenidos de esta asignatura pretenden introducir al alumno a los conceptos básicos de programación y conocimiento de un computador La presente memoria es el fruto del trabajo de un grupo de profesores que en los últimos años han impartido esta asignatura en el Escuela Universitaria de Ingenieros Técnicos de Zaragoza en las especialidades de Química, Electricidad, Diseño Industrial y Mecánica, con la intención de adaptar tantos los contenidos como las metodologías docentes al EEES.

1.2. Diseño de la asignatura. La asignatura de Fundamentos de Informática tiene asignada en todos los nuevos grados de las titulaciones de Ingeniería una carga docente de 6 créditos ECTS, lo que supone 150 horas de trabajo de alumno. Según la directiva de la Universidad de Zaragoza, el 40% de las horas de trabajo de alumno han de ser horas presenciales (clases magistrales, de problemas y prácticas) y el 60% no presenciales (estudio del alumno, horas de examen, trabajos tutorados). La asignatura se ha divido en dos bloques temáticos: el primero se centra en el estudio de los componentes de un ordenador y tratamiento de la información; el segundo aborda la programación del computador usando un lenguaje orientado a objetos. En cursos anteriores, la programación estructurada ha sido el paradigma de programación que se ha utilizado para introducir los conceptos necesarios para el desarrollo de aplicaciones infromáticas. Decimos cambiar este paradigma ya que la programación orientada a objetos (POO) está siendo ampliamente usada para desarrollar programas dirigidos a Internet con el uso del lenguaje de programación Java. Nos parece interesante introducirlos en un lenguaje muy potente aunque el objetivo de la asignatura sea la presentación de conceptos básicos de programación ya que es el punto de partida para posteriormente realizar trabajos con más enjundia. La asignatura se ha divido en siete temas, dos para el primer bloque y cinco para el segundo, más la clase de presentación de la asignatura, tema 0. Los contenidos y objetivos de cada tema se presentarán más adelante en la memoria. En este cuadro se pueden observar la carga de horas presenciales y no presenciales de cada uno de los temas. En la tabla también se añaden al final un aparatado de trabajos tutorados. Estos trabajos serán prácticas que deberán desarrollar los alumnos en grupos de dos o tres personas y que los profesores de la asignatura guiarán mediante tutorías grupales.

PIIDUZ-2009-3-293

5

Horas Tema 0 Tema 1 Tema 2 Tema 3 Tema 4 Tema 5 Tema 6 Tema 7 Trabajos

Presenciales: 1 10 3 2 10 16 6 12 0

No Presenciales 0 15 5 4 10 18 6 12 20

1.3. Competencias. Para la identificación de las competencias que debería adquirir un alumno se ha usado como material de referencia []. En libro del profesor J. Bernal se distinguen tres tipos de competencias: conceptuales, el saber conocimientos; procedimentales, el saber hacer; actitudinales, el saber estar. En la tabla siguiente se detallan las competencias que hemos detectado. CONCEPTUALES PROCEDIMENTALES ACTITUDINALES • Conocer un lenguaje de

programación • Conocer elementos

comunes a los lenguajes de programación

• Conocer los conceptos de abstracción de datos y acciones

• Conocer la representación interna de los datos simples y su agregación

• Conocer los formatos de almacenamiento de datos

• Tener nociones sobre representación de conocimiento

• Conocer aspectos básicos de lógica proposicional

• Aprender a trabajar en grupo

• Conocer la arquitectura y organización de un computador

• Conocer los componentes físicos de un computador

• Conocer la función del S.O • Conocer la arquitectura

básica de redes • Conocer conceptos básicos

sobre Internet • Conocer la filosofía del

software libre • Conocer los conceptos

básicos sobre bases de datos

• Analizar un problema

identificando sus características

• Representar formalmente la especificación de un problema

• Comprender sintáctica y lógicamente y utilizar soluciones desarrolladas en un lenguaje de programación

• Manejar un entorno de desarrollo de programas

• Dadas las especificaciones, implementar el algoritmo solución eficaz y eficiente

• Modificar código escrito para adaptarlo a nuevas situaciones

• Depurar algoritmos para analizar la corrección del algoritmo

• Programar con independencia del lenguaje

• Ser capaz de trabajar en grupo • Organizar y planificar • Desarrollar pensamiento

lógico-deductivo • Ser capaz de resolver

problemas • Desarrollar autonomía para

aprender • Saber leer documentación

técnica, especialmente en inglés

• Expresarse correctamente de forma oral y escrita

• Usar S.O con diferentes interfaces de usuario

• Manejar funciones comunes a varios S.O

• Utilizar Internet como herramienta de

• Valorar la ayuda que

proporciona la documentación

• Poner en tela de juicio los algoritmos y especificaciones que se le presentan

• Asumir y valorar el compromiso con los compañeros en la realización del trabajo en grupo

• Capacidad crítica para discriminar la información relevante para el aprendizaje

• Valorar el uso del software libre/alternativo

PIIDUZ-2009-3-293

6

autoaprendizaje • Adquirir autonomía en el

manejo de herramientas informáticas desconocidas

• Valorar la idoneidad del software/hardware en función del contexto

Utilizar de manera eficiente aplicaciones informáticas.

1.4. Metodología docente Para alcanzar las competencias del ingeniero relacionadas con esta asignatura, y en sintonía con el EEES se desarrollará la asignatura mediante metodologías activas.

El uso de una metodología activa requiere de un aprendizaje procedimental para facilitar el recorrido del alumno. De este modo, es importante diseñar el proceso de aprendizaje basándose en el ciclo de aprendizaje del alumno (ver figura siguiente). Éste se basa en dos fases: vivencia y reflexión.

Introducir una metodología activa en el proceso de enseñanza requiere partir, en cada una de las secuencias del aprendizaje, de la vivencia o experiencia concreta del sujeto. En este caso, pues, es importante presentar el punto de partida teniendo en cuenta los conocimientos previos y el bagaje cultural del alumno. La reflexión, la segunda de las fases, sugiere un procedimiento de mayor complejidad. Requiere de los siguientes pasos:

DE

DU

CC

IÓN

IND

UC

CIÓ

N

Observación reflexiva Reflexionamos sobre ellas y las

observamos desde muchas perspectivas

Experimentación Activa Empleamos todas esas teorías para

tomar decisiones y solucionar problemas

Determinar solución Integramos las observaciones.

Establecemos conceptos y teorías.

Experiencia Concreta Nos involucramos en experiencias nuevas

ACCIÓN

SÍNTESIS

ANÁLISIS

PLANIFI CACIÓN

Es obvio, pues, que la adopción del alumno de un papel más activo en el proceso de enseñanza y aprendizaje, y la aceptación por parte del profesor del abandono de un papel tradicional a un papel de facilitador del aprendizaje, pasa por el trabajo en equipo, la evaluación por pares y la autoevaluación, que provoquen un cambio en la concepción del aprendizaje.

Se observa que una metodología basada en el aprendizaje basado en problemas encaja perfectamente con el tipo de objetivos marcados anteriormente. Teniendo en cuenta que los alumnos se encuentran en primero de carrera, habrá que ir guiándoles en su camino

PIIDUZ-2009-3-293

7

de aprendizaje, llevando cuidado de darles la oportunidad de descubrir por sí mismos, pero a la vez no soltarles demasiado pronto en dicha aventura. Es decir, todo problema deberá plantear un reto, para que motive al alumno; pero de una complejidad abordable para el mismo, de modo que no le bloquee. Por tanto, la dificultad de dichos problemas tendrá que ir incrementando a lo largo de la asignatura, ya que las herramientas que conocerán los alumnos al principio serán nulas. De cualquier modo, se buscará, siempre que sea posible, que los problemas planteados sean interesantes de por sí para los alumnos y no sólo por los objetivos que les permitan alcanzar.

El proceso general que se utilizará en la mayoría de los casos será el siguiente:

• En primer lugar se les planteará un problema para el que no conozcan todas las herramientas necesarias (bien dándoles un código con estructuras desconocidas por ellos, bien dándoles un enunciado que pueda ser resuelto con lo que conocen pero no de forma eficiente).

• A partir de dicho problema, los alumnos realizarán un trabajo, individualmente o por equipos.

• Tras el trabajo previo, se realizará una puesta en común en la que irán surgiendo las necesidades y dificultades encontradas, que serán resueltas entre todos con la guía del profesor.

• Finalmente, se realizarán actividades de refuerzo y profundización sobre la materia trabajada anteriormente.

En esta metodología, a pesar de que los problemas tratados inicialmente no sean muy complejos, y por lo tanto, en su mayoría, de menor interés para la vida real, permiten al alumno ir descubriendo por sí mismo, de forma intuitiva, la materia así como las necesidades que van apareciendo, de modo que se evita el desinterés generado por la anticipación del profesor cuando explica algo sobre lo que el alumno no ha creado todavía ninguna necesidad. De hecho, va a ser el alumnado el que vaya demandando, si la planificación de las actividades es la adecuada, los nuevos contenidos para poder llevar a cabo la resolución de los diferentes problemas reto. Sin embargo, no hay que perder de vista lo que ya hemos comentado previamente al respecto de que nuestros alumnos se encuentran en primero de carrera, por lo que habrá que estar muy atentos al desarrollo del cuatrimestre para poder observar el correcto funcionamiento del grupo, con esta idea en mente, y con objeto de poder dar más independencia al trabajo del alumno, a pesar que la metodología sea más renovadora, se mantendrá una estructura más o menos clásica, por temas, de forma que la mayoría de los textos a los que pueda acudir el alumno mantengan esa organización.

1.5. Sistema de calificación. La calificación de la asignatura se realizará de forma continua mediante distintas pruebas. La nota final se obtendrá mediante la calificación de tres apartados:

1. Prueba escrita a realizar al final del cuatrimestre (45%)

2. Dos prácticas de diseño donde los alumnos en grupos de dos o tres personas tendrán que implementar una solución a un problema de complejidad media. Estas prácticas tendrán dos fechas de entrega. En la primera entrega se hará una valoración de la práctica señalando los puntos donde se puede mejorar en la

PIIDUZ-2009-3-293

8

segunda entrega. Creemos que es muy interesante que el alumno aprenda de sus errores y pueda corregirlos. En la mayoría de pruebas que presentan solo pueden identificar los errores sin dar la posibilidad de enmendarlos. (30%)

3. Se realizarán ocho pruebas a lo largo del curso (25%):

- seis pruebas escritas que consistirán en presentar alguna de las actividades en las que están divididas cada uno de los temas del temario.

- dos pruebas de tipo test..

1.6. Temario Como se ha indicado en la metodología docente, el temario se ha pensado, sobretodo para el bloque II de programación, para que el alumno resuelva una serie de problemas. Los conceptos teóricos aparecerán tras la resolución de estos problemas. Los problemas propuesto se han inspirado en los siguientes documentos.

• Para los temas 4, 6 se ha usado el libro Object fisrt with Java. A practical introduction using BlueJ [2].

• Para el tema 7, Introducción a la programación en Java [3] • Para el tema 5, Programación, Algoritmos y ejercicios resueltos en Java [4]

Tema 0. Presentación

Tema1. Arquitectura de computadores: Hardware y Software Tema 2. Redes de computadres. Internet Bloque I Tema 3. Representación de la información en el computador. Tema 4. Clases y objetos Tema 5. Estructura de datos y algoritmos. Comunicación entre objetos Tema 6. Abstracción de datos. Herencia.

Bloque II

Tema 7. Diseño de clases.

PIIDUZ-2009-3-293

9

TEMA 0 PRESENTACIÓN

El modelo de enseñanza basado en el aprendizaje exige en los alumnos tres actitudes básicas: colaboración, autonomía y responsabilidad personal. El éxito del proceso depende en gran medida de que se consiga transmitir al alumno esta idea. En el primer curso de la titulación la desorientación del alumnado es mayor, la adaptación a la universidad requiere la asunción de responsabilidades en el proceso de aprendizaje y en nuestro caso, además, del protagonismo del mismo.

La horas estimadas para este tema se dedican a explicar al alumno los siguentes temas de interés para el desarrollo óptimo del proceso educativo:

� Metodología activa: se explicará en qué consiste la metodología del aprendizaje basado en problemas y se incidirá en la necesidad de preparar las actividades, de colaborar en la dinámica, etc.

� Criterios y sistema de evaluación: se informará de los criterios que van a ser utilizados en el curso, la importancia de la evaluación continua que se desarrollará tanto en el modo de autoevaluación como la evaluación de grupos.

� Recursos: Bibliografía recomendada para el curso, el anillo digital docente (ADD), las prácticas en laboratorios y demás datos útiles para el seguimiento con provecho de la asignatura, calendario de actividades, horarios de tutorías, etc.

PIIDUZ-2009-3-293

10

TEMA 1 Arquitectura de computadores:

Hardware y Software 1.1. Objetivos.

• Conocer y comprender los conceptos de organización de un computador.

• Conocer el concepto de Software. • Comprender y utilizar Sistemas Operativos. • Conocer y utilizar Bases de datos Relacionales. • Comprender el Hardware de un Computador.

1.2. Competencias.

Conceptuales: • Conocer la arquitectura y organización de un computador. • Conocer los componentes físicos de un computador. • Conocer la función del S.O. • Conocer la filosofía del software libre. • Conocer los conceptos básicos sobre bases de datos.

Prodecimentales: • Desarrollar autonomía para aprender. • Usar S.O. con diferentes interfaces de usuario. • Manejar funciones comunes a varios S.O. • Valorar la idoneidad del software/hardware en función del contexto.

Actitudinales: • Asumir y valorar el compromiso con los compañeros en la

realización del trabajo en grupo. • Valorar la ayuda que proporciona la documentación. • Perder el miedo al computador. • Valorar el uso del software libre/alternativo.

1.3. Tiempos dedicados.

Horas clases magistrales 5 Horas clases problemas 1 Horas clases prácticas 4 Horas no presenciales 15

PIIDUZ-2009-3-293

11

1.4. Desarrollo del tema.

1.4.1. ORGANIZACIÓN Y ARQUITECTURA DEL COMPUTADOR

Sesión 1 Tipo: magistral Duración: 1h Descripción.

BLOQUE I: Conceptos de organización y de arquitectura.

Concepto de organización y concepto de arquitectura de una máquina compleja.

BLOQUE II: Principales componentes del computador

Estructura jerárquica de los componentes de un computador.

Descripción de arriba a abajo, señalando sus funciones (arquitectura) de cada componente y su estructura (organización).

1.- Funciones y estructura de un computador: CPU, Memoria, Dispositivos I/O y Buses.

2.- Funciones y estructura de una CPU: UC, UAL, Registros y Buses internos.

BLOQUE III: Visión multinivel del computador

Concepto de hardware y de software. Presentación de un computador como “máquina que entiende un lenguaje”. Concepto de lenguaje máquina.

Para facilitar el uso de la máquina, se necesita un lenguaje más acorde al usuario. Para facilitar el diseño de la máquina, se necesita que la traducción entre estos lenguajes sea simple.

Presentación de los 7 (6+1) niveles del computador: Hardware, Microprogramación, Lenguaje máquina, Núcleo del sistema operativo, Ensamblador, Lenguajes de programación de alto nivel y Aplicaciones dedicadas.

PIIDUZ-2009-3-293

12

1.4.2. SOFTWARE

Sesión 2

Tipo: magistral Duración: 1h Descripción.

BLOQUE I: Programa de computador.Concepto de programa. Distinción entre programa ejecutable y programa fuente

BLOQUE II: Traducción a lenguaje máquina

o Compilación o Interpretación o Código intermedio

BLOQUE III: Clasificaciones del software

o Licencia de uso: Software libre y propietario. o Distribución: Freeware, Shareware, Demo, Abandonware, Versión beta. o Interfaz de usuario: Textual, Gráfica. o Funcionalidad del software: Software de control, Utilidades y

Aplicaciones.

BLOQUE IV: Referencias de software libre

o http://es.wikipedia.org/wiki/Portal:Software_libre � Sistemas operativos libres � Navegadores web libres � Entornos de desarrollo integrados libres � etc.

o http://osluz.unizar.es � Directorio de aplicaciones � Manuales

o http://sicuz.unizar.es/gluz2/index.html � Documentación

PIIDUZ-2009-3-293

13

1.4.3. SISTEMAS OPERATIVOS

Sesión 3


BLOQUE I: Concepto de sistema operativo. Principales funciones de un SO: Ejecutar órdenes del usuario y Gestionar los recursos del computador: Periféricos, Dispositivos de almacenamiento, Memoria y CPU.

BLOQUE II: Conceptos fundamentales de SO. Procesos por lotes, interactivos y en tiempo real. Multitarea y Tiempo compartido. Multipuesto vs Multiusuario

BLOQUE III: Componentes principales de los SO. Procesador de mandatos (línea de comandos, GUI), Planificador, Gestor de archivos, Gestor de memoria, Asignador de recursos y Distribuidor

BLOQUE IV: SO más utilizados. Windows, Unix, Linux y Mac OS (ámbito de uso -equipos personales, etc.-, nociones históricas y características principales)

PIIDUZ-2009-3-293

14

Sesión 4

Tipo: prácticas Duración: 2 h. Descripción.

INFORMÁTICA Práctica 1

Sistemas operativos. Interfaz de comandos de

Linux.

Ejercicio 1.- Encuentra el comando que te permita conocer cuál es el directorio de trabajo al iniciar la interfaz de comandos.

Ejercicio 2.- Comando que muestra todo el contenido del directorio de trabajo, incluidos los archivos ocultos. ¿Cómo se identifican?

Ejercicio 3.- Comando que muestra todos los ficheros y carpetas ocultos del directorio actual.

Ejercicio 4.- Comando que muestra los detalles de todos los ficheros y carpetas del directorio actual (incluidos los ocultos). ¿Cómo puede saberse si un archivo corresponde a un fichero o a un directorio? ¿Qué otra información aparece?

PIIDUZ-2009-3-293

15

Ejercicio 5.- Comando que muestra todas las carpetas del directorio precedente (sin cambiar de directorio de trabajo).

Ejercicio 6.- Comando que muestra todas las carpetas del directorio dev que cuelga del raíz en orden alfabético inverso de nombre (sin cambiar de directorio de trabajo).

Ejercicio 7.- Comando que muestra todos los ficheros del directorio dev cuyo nombre contiene un “2”.

Ejercicio 8.- Comando que crea el directorio Practica1DIS y lo selecciona como directorio de trabajo.

Ejercicio 9.- Comando que copia los ficheros de la carpeta /usr/include/ con extensión .h que empiezan por la letra “n” en el directorio de trabajo.

Ejercicio 10.- Comando que crea el directorio Headers en el directorio de trabajo.

PIIDUZ-2009-3-293

16

Ejercicio 11.- Comando que mueve los ficheros de extension .h al directorio Headers.

Ejercicio 12.- Seleccionando Headers como directorio de trabajo, ¿que diferencias encuentras al ejecutar las órdenes head / more / tail sobre el fichero nss.h? ¿Se pueden modificar el número de líneas a mostrar? Acuérdate de regresar a Practica1DIS al terminar este ejercicio.

head:

more:

tail:

Ejercicio 13.- Comando que ejecuta el editor gedit. Utiliza este editor para crear un fichero de texto con el nombre UnTexto.txt (con el contenido que quieras, pero no vacío) en el directorio Practica1DIS. ¿Puedes interactuar con el prompt del sistema mientras el editor se encuentra en ejecución? Una vez guardado el fichero, cierra el editor. ¿Puedes ahora interactuar?

Ejercicio 14.- Comando que ejecuta el editor gedit&. Utiliza este editor para crear un fichero de texto con el nombre DosTextos.txt en el directorio Practica1DIS. ¿Puedes ahora interactuar con el prompt del sistema mientras el editor se encuentra en ejecución? ¿Para qué crees que sirve el colocar & después del nombre de una aplicación?

Ejercicio 15.- Comando que visualiza los procesos que están ejecutándose en la máquina. ¿Qué sucede al pulsar la tecla 1?

PIIDUZ-2009-3-293

17

Ejercicio 16.- ¿Cómo visualizarías sólo tus procesos?

Ejercicio 17.- Comando que “mata” el proceso gedit que creaste en el Ejercicio 14. ¿Puedes matar procesos que no hayas creado tú?

Ejercicio 18.- Dentro del directorio Practica1DIS crea un directorio llamado BackUp. Copia los ficheros de texto y el directorio Headers en su interior. ¿Qué comandos has utilizado?

Ejercicio 19.- Comando que compara los ficheros del directorio Headers y los que acabas de copiar en Backup.

Ejercicio 20.- Copia el fichero UnTexto.txt dentro de Headers. Edita el fichero nlist.h y añade el texto que quieras. Utiliza ahora el comando del Ejercicio 19. ¿Qué sucede?¿En qué se diferencian los dos comandos que comparan archivos en Linux?

Ejercicio 21.- Comando que borra el fichero UnTexto.txt. Comando que borra el contenido del directorio BackUp.

PIIDUZ-2009-3-293

18

Ejercicio 22.- Comando que finaliza la ejecución de la interfaz de comandos de Linux.

¿Linux o Windows? Nos gustaría saber si esta práctica te ha resultado útil e interesante y si hemos conseguido nuestro objetivo. Por favor, no contestes simplemente si o no a las preguntas, nos gustaría saber tu opinión.

¿Has notado muchas diferencias entre la interfaz gráfica de Windows y la de Linux? ¿Crees que Linux puede tener alguna ventaja frente a Windows? ¿Y alguna desventaja? ¿Te atreverías a utilizar indistintamente ambos sistemas operativos a partir de ahora?

¿Conocías la línea de comandos? ¿La habías utilizado alguna vez? ¿Te ha resultado difícil?

¿Has notado alguna diferencia entre Windows y Linux?

¿Tienes alguna sugerencia de cómo podría mejorarse esta práctica?

PIIDUZ-2009-3-293

19

1.4.4. BASES DE DATOS RELACIONALES

Sesión 5


BLOQUE I: Introducción a las BD

¿Para qué sirve una BD? ¿No es lo mismo dato que información? ¿Por qué las BD almacenan datos y no informaciones?

BLOQUE II: Introducción a los SGBD

¿Qué es un Sistema Gestor de Bases de Datos (SGBD)?

Niveles de visión de los datos de una BD

o Nivel interno de la BD: Hace referencia al almacenamiento de los datos. Sólo es “visible” por el SGBD.

o Nivel externo de la BD: Hace referencia a la presentación de los datos a los usuarios. Es el único que ven los usuarios de la BD.

¿Qué es un modelo de datos?

Es un modo de organizar los datos para que puedan representar informaciones.

Todo SGBD sigue un modelo de datos, conforme al que presentan los datos al usuario. El usuario debe conocer ese modelo para poder extraer las informaciones que se corresponden con esos datos presentados de esa forma.

BLOQUE III: Modelo Relacional (35 min -porque hacen falta ejemplos de cada apartado-)

¿Cómo es el Modelo Relacional?

o Una BD Relacional es un conjunto de relaciones. o Una relación es un conjunto de tuplas (listas) de valores, presentado en

forma de tabla (matriz bidimensional) en el que las tuplas son las filas. o Cada columna de esta tabla representa a un atributo (una propiedad) de

un objeto. o Cada fila de esta tabla (tupla de valores) representa a un objeto concreto

(a través de los valores de sus propiedades) de los representados en la relación.

PIIDUZ-2009-3-293

20

¿Qué es la clave primaria de una relación?

Es un conjunto de atributos que identifican a una fila, por lo que no puede haber varias filas de una relación con los mismos valores en estos atributos.

¿Tiene sentido considerar vínculos (asociaciones) entre relaciones?

Es evidente que sí: las filas de una relación «Trabajador» tienen que estar asociadas a las filas de una relación «Empresa» para poder representar el vínculo «Empresa contrata a Trabajador».

¿Qué características tienen estos vínculos entre relaciones?

Hay asociaciones que asocian una fila de una relación con una fila de otra (asociación 1-a-1), y asociaciones que asocian una fila con varias filas de otra (asociación 1-a-muchos, ó 1-a-n, ó 1-a-∞)

¿Como se implementa un vínculo entre relaciones?

Añadiendo a la relación del lado “muchos” la clave primaria de la otra relación, lo que se denomina como clave externa.

¿Qué restricciones debe cumplir una BDR?

o Toda relación debe tener una clave primaria o Una clave externa no puede tener un valor que no lo tenga también su

clave primaria asociada

BLOQUE IV: Lenguajes de consultas (5 min -mera introducción-)

¿Cómo se puede acceder a los datos de una BDR?

Utilizando un lenguaje de consultas: SQL o GQBE Sesión 6

Tipo: problemas Duración: 1h Descripción. Los alumnos practicarán con los comandos: SQL básico ,SELECT …, FROM … JOIN … ON …, WHERE, ORDER BY …, funciones agregadas: COUNT, AVG, SUM ... GQBE básico (+1 práctica)

Con OpenOffice.org Base

PIIDUZ-2009-3-293

21

Sesión 7

Tipo: prácticas Duración: 2 h. Descripción. A partir de la BDR Bibliografía definida a continuación:

Libro

ISBN título idEditorial añoEdición numEdición numPáginas

Cada fila de esta relación representa a un Libro, con los datos de su ISBN, título, identificación de la editorial que lo ha publicado, año de edición, número de edición y número de páginas

Editorial

identificación nombre dirección ciudad

Cada fila de esta relación representa a una Editorial, con los datos de su identificación, nombre, y la dirección y ciudad de su sede principal

Autor

identificación nombre nacionalidad

Cada fila de esta relación representa a un Autor de libro, con los datos de su identificación, nombre y nacionalidad

Escribe

identAutor identLibro

Cada fila de esta relación representa que un Autor ha escrito un libro, con los datos de las identificaciones del autor y del libro

Escribe las consultas SQL que permiten realizar las siguientes tareas:

1. Muestra todos los datos de cada libro 2. Muestra el título y el número de páginas de cada libro 3. Muestra el título y año de edición de los libros con menos de 500 páginas 4. Muestra el nombre de los autores españoles 5. Muestra el nombre y la dirección de las editoriales de Zaragoza 6. Muestra el título, año de edición y número de edición de los libros publicados

por la editorial “Addison-Wesley”

PIIDUZ-2009-3-293

22

7. Muestra el título, año de edición y número de edición de los libros con más de 100 páginas que hayan sido publicados por la editorial “Addison-Wesley”

8. Muestra todos los datos de los libros con más de 100 páginas que hayan sido publicados por la editorial “Addison-Wesley”

9. Muestra el título y año de edición de los libros escritos por autores españoles 10. Muestra el nombre de las editoriales que han publicado libros de autores

españoles 11. Muestra el nombre de las editoriales que han publicado libros de menos de 500

páginas que hayan sido escritos por autores españoles

1.4.5. HARDWARE DEL COMPUTADOR Sesión 8

Tipo: magistral Duración: 2 h. Descripción.

BLOQUE I: Carcasa.Estándares: Semitorre, etc. Barebones, Portátiles, Notebook, HTPC.

BLOQUE II: Componentes internos: Placa base.Microprocesador, Memoria RAM, Memoria ROM (arranque del computador), Chipset, Tarjetas de ampliación (gráfica, red, TV).

BLOQUE III: Soportes de almacenamiento permanente. Disco duro, Ópticos (CD / DVD / BD) y Flash

BLOQUE IV: Conectores de la carcasa. Puertos teclado/ratón, USB, FireWire (i.Link).

BLOQUE V: Periféricos. Teclado, Ratón, Escáner, Impresora (de tinta y láser) y Monitores (pantalla plana: TFT, OLED)

PIIDUZ-2009-3-293

23

TEMA 2 REDES DE COMPUTADORES.

INTERNET

1.1. Objetivos.

• Adquirir conocimientos básicos sobre redes de computadores. • Adquirir conocimientos básicos sobre Internet. • Conocer las capas de Internet. • Conocer los conceptos relacionados con la Web. • Conocer elementos de seguridad en Internet.

1.2. Competencias.

Conceptuales: • Conocer la arquitectura básica de redes. • Conocer conceptos básicos sobre Internet.

Prodecimentales: • Desarrollar autonomía para aprender. • Utilizar Internet como herramienta de autoaprendizaje.


realización del trabajo en grupo. • Valorar la ayuda que proporciona la documentación. • Capacidad crítica para discriminar la información relevante para el

aprendizaje.



PIIDUZ-2009-3-293

24

1.4. Desarrollo del tema. Sesión 1


BLOQUE I: Conceptos básicos de redes. Concepto de red. Tipos de redes.Principales equipos componentes: Ordenador, Terminal, Módem, Router, Hub, Gateway.Medios de transmisión: Cables de cobre, Fibra óptica, Atmósfera.Nociones del modelo OSI: Filosofía del trabajo en capas

BLOQUE II: Conceptos básicos de Internet. Principales características: Estructura jerárquica, descentralizada, Esquema cliente/servidor, Protocolo. Introducción a los servicios de Internet: Información (la Web), Comunicación (eCorreo, Mensajería instantánea, Telefonía IP, Videoconferencia), Transmisión de datos (FTP, P2P).

BLOQUE III: Capas de transporte y de red en Internet. Capa de transporte: Protocolo TCP. Capa de red: Protocolo IP. Direccionamiento: Direcciones IP, IPv4/IPv6, Direcciones IP dinámicas, Servicio DNS

BLOQUE IV: La Web Protocolo HTTP, URI, Navegador web, Página web. Tecnologías: HTML, CSS. Fuente web

BLOQUE V: eCorreo. Doble servicio (envío/recepción), Doble protocolo. Direcciones de correo. Spam

BLOQUE VI: Seguridad en Internet. Confidencialidad: Protocolo SSL. Malware: Virus, Gusano, Troyano, Spyware

Sesión 2

Tipo: prácticas Duración: 2 h. Descripción.

Práctica de Internet: Búsqueda de información en Internet sobre un tema para resolver ejercicios propuestos. El tema de esta práctica reduciría al mínimo la cantidad de horas dedicadas a ese tema. Posibles temas:

• Bases de datos relacionales • Hardware • Internet • Representación multimedia

PIIDUZ-2009-3-293

25

TEMA 3 REPRESENTACIÓN DE LA

INFORMACIÓN EN LOS COMPUTADORES

1.1. Objetivos.

• Adquirir conocimientos básicos sobre aritmética en distintas bases de numeración.

• Comprender distintas formas de representar números. • Comprender distintas formas de representar texto. • Conocer los distintos formatos de almacenar información multimedia.

1.2. Competencias.

Conceptuales: • Conocer la representación interna de los datos simples y su

agregación. • Conocer los formatos de almacenamiento de datos. • Tener nociones sobre representación de conocimiento

Prodecimentales: • Ser capaz de resolver problemas.


realización del trabajo en grupo. • Valorar la ayuda que proporciona la documentación.



PIIDUZ-2009-3-293

26

1.4. Desarrollo del tema. Sesión 1


BLOQUE I: Sistemas de numeración posicional. Cambio de base. Operaciones aritméticas. Complementos.

BLOQUE II: Representación de los números. Enteros: Sin signo, Complemento a 2, Sesgada Reales: Punto flotante (IEEE 754)

BLOQUE III: Representación del texto. Código ASCII. Unicode

BLOQUE IV: Representación de la multimedia. Noción de muestreo. Compresión con pérdida y sin pérdida Sonido: MP3. Imagen: Mapa de bits, GIF, JPEG, PNG. Vídeo: MPEG, DivX, Xvid. Formatos contenedores: AVI Sesión 2

Tipo: problemas Duración: 1 h. Descripción. Problemas de: Cambio de base, representación de enteros y

representación de reales.

1. Escribe en decimal los siguientes números: a. 11100110|2 b. −11100110,011|2 c. 235|8 d. −AC,A|16

2. Escribe en binario los siguientes números escritos en decimal a. 147 b. −147,625 c. 0,1

3. Escribe la representación en 8 bits de los siguientes números enteros escritos en decimal,

a. 111 b) 47 c) –24 d) –127

tanto en complemento a 2 como en representación sesgada con sesgo 2n–1–1

4. Si cada uno de los siguientes dos conjuntos de 8 bits es la representación de un número entero en el computador,

a. 01100110 b) 10101010

averigua de qué número se trata, para las representaciones en complemento a 2 y en representación sesgada con sesgo 2n–1–1

PIIDUZ-2009-3-293

27

5. Escribe la representación en simple precisión de los siguientes números reales: a. 1,1875×23 b. 76,0 c. –1,5 d. –23,5

PIIDUZ-2009-3-293

28

TEMA 4 CLASES Y OBJETOS

1.5. Objetivos. • Conocer qué es una clase y qué es un objeto y saber diferenciarlos. • Conocer qué es un constructor. • Saber qué es un método y para qué sirve. • Definir métodos apropiados a las especificaciones propuestas. • Saber qué es un parámetro, para qué sirve y como se declara. • Conocer tipos de datos primitivos y sus operadores asociados. • Saber aplicar las estructuras básicas de programación como

secuenciación de instrucciones y estructura condicional. • Conocer qué es una variable local, cómo definirla y cómo utilizarla. • Manipular de forma básica el entorno de BlueJ para desarrollar

código java. • Conocer el uso de las clases y objetos y saber interactuar con ellos. • Adquirir cierto grado de autonomía para resolver problemas con las

herramientas presentadas

1.6. Competencias.

Conceptuales: • Conocer un lenguaje de programación • Conocer aspectos básicos de lógica proposicional

Prodecimentales: • Analizar un problema identificando sus características • Representar formalmente la especificación de un problema • Comprender sintáctica y lógicamente y utilizar soluciones

desarrolladas en un lenguaje de programación • Manejar un entorno de desarrollo de programas • Desarrollar pensamiento lógico-deductivo • Ser capaz de resolver problemas

Actitudinales: • Capacidad crítica para discriminar la información relevante para el

aprendizaje • Asumir y valorar el compromiso con los compañeros en la

realización del trabajo en grupo

1.7. Tiempos dedicados. Horas clases magistrales 6

PIIDUZ-2009-3-293

29

Horas clases problemas 2 Horas clases prácticas 2.5 Horas no presenciales 10


Problema: Trabajamos con el proyecto “Figuras” Inicia BlueJ y abre el proyecto Figuras mediante la opción OpenProject

del menú Project. Aparecen definidas las clases círculo, cuadrado y triángulo. Ahora, crea varios objetos o instancias de cada una de estas clases para

ello pulsa el botón derecho del ratón sobre las clases. ¿Cómo se representan los objetos? ¿Cómo se identifican?

Manipula los objetos invocando los métodos que tienen definidos, para ello pulsa el botón derecho del ratón sobre un objeto, p. ej. de la clase círculo, selecciona distintas opciones que aparecen en el menú contextual, ¿qué efecto tienen? Ahora selecciona la opción void makeVisible() y observa el efecto que tiene.

Sigue invocando métodos para los diferentes objetos que has creado. ¿Qué diferencia hay entre los métodos que finalizan con unos paréntesis vacíos y los que tienen definido un parámetro dentro de los paréntesis? ¿Qué es un parámetro?

Modifica el tamaño y el color de un objeto cuadrado ¿qué diferencia básica encuentras en la declaración de los parámetros de ambos métodos? ¿Cómo se traduce esa diferencia cuando al invocar a los métodos? Modifica el tamaño de un triángulo, ¿cuántos parámetros tiene este método?

¿Qué dirías que es el tipo de un dato? ¿Qué tipos de datos han aparecido? ¿Qué ocurre si a un parámetro de un tipo le intentamos dar un valor de otro tipo de dato?

Objetivos:

- Conocer parte del entorno de desarrollo de programas BlueJ: � Herramientas: menú Project (Abrir un proyecto, salvar los

cambios, cerrar, salir), menú Edit (new packadge) � Uso del entorno: Representación de los conceptos y

manipulación de los mismos - Presentar el concepto de clase - Saber crear objetos - Saber invocar métodos - Conocer qué es un parámetro de un método y cómo asignarle un

valor - Presentar los primeros tipos de datos primitivos

• Horas presenciales: 1h

• Horas no presenciales: 1 h

Sesión 1 Tipo: magistral

PIIDUZ-2009-3-293

30

Duración: 1h Descripción: Planteamos el enunciado en forma de guión y proponemos que se intente hacer antes de la clase. En la sesión presencial saldrá un alumno a resolver el problema. El profesor incidirá en los conceptos y las definiciones que vayan apareciendo así como en el propio entorno de desarrollo. Durante la invocación de métodos se mostrará como lanzar el inspector de objetos (Object Inspector), se presentará el concepto de campo y estado de un objeto. Finalmente el profesor detallará el proceso general de trabajo que se seguirá para resolver problemas en dicho entorno. El proyecto con el que se trabajará estará preparado para presentar conceptos básicos como el de clase, de creación de objetos, invocación de métodos la programación en Java. Observación: La descarga e instalación del software BlueJ se habrá realizado como ejercicio en una práctica anterior dedicada a Internet.

Problema: Cajero automático I El proyecto que se proporciona es el “esqueleto” de la solución al

problema de modelar el funcionamiento de un cajero automático de un banco, se pide una cantidad determinada y devuelve el correspondiente número de billetes de 50, de 20 y de 10 que proporcionaría.

Diseña el método que modele la actividad del cajero, deberá tener un parámetro que sea la cantidad de dinero solicitada y deberá devolver el número de billetes de cada tipo que sacará. Supondremos que, ante cualquier cantidad solicitada, en el cajero hay billetes suficientes de cada tipo para poder devolver.

Objetivos:

- Profundizar en el concepto de clase y constructor. - Profundizar en el concepto de objeto, campos del objeto. - Diferenciar los métodos de acceso y de modificación. - Conocer el código fuente de una clase y su estructura. - Introducir en las sentencias simples de programación. - Utilizar la herramienta del editor de código y compilación.


• Horas no presenciales: 1 h

Sesión 2 Tipo: magistral Duración: 1h Descripción: El alumno trabajará previamente a la sesión magistral el diseño del método que plantea el problema. En clase, un voluntario propondrá una solución y se discutirán las posibles alternativas que propongan otros alumnos. Haciendo uso del entorno BlueJ el profesor abrirá el proyecto y probará la solución que se tome como definitiva

PIIDUZ-2009-3-293

31

Problema: Cajero automático II Consideraremos el contexto del ejercicio anterior, pero ahora

consideraremos que el cajero solo atiende peticiones de dinero que sean múltiplos de 10 y que en el cajero hay una cantidad determinada de billetes de 50, otra cantidad de billetes de 20 y otra de 10, además, se tendrá en cuenta que al ejecutar la aplicación y solicitar una cierta cantidad puede ocurrir que falten billetes de algún determinado valor.

Objetivos:

- Afianzar el concepto de clase y de objeto - Diseñar métodos atendiendo a las especificaciones del problema. - Conocer y saber utilizar la estructura if de la programación

condicional. • Horas presenciales: 1 h. • Horas no presenciales: 2 h. Sesión 3 Tipo: magistral Duración: 1h Descripción: Se partirá del proyecto desarrollado en el ejercicio anterior y se propondrá la reescritura de los métodos para que se adapten a los nuevos requisitos del problema.

Problema: Booleanos, operadores lógicos if anidados Considerando que X, Y y Z son números entero escribe mediante una determinada expresión con operadores booleanos las siguientes condiciones expresadas del lenguaje coloquial.

1. “Los tres valores son iguales” 2. “Al menos un valor es distinto de los otros dos” 3. “Únicamente dos de los valores son iguales” 4. “Al menos un valor es positivo” 5. “Z es un valor intermedio de los otros dos” 6. “Ningún valor es positivo” 7. “El valor de x está entre 1 y 5, ambos inclusive” 8. “Los valores Y y Z distan menos de 10 del valor X”

Ahora, expresa una estructura condicional apropiada para modelar la siguiente situación planteada:

1. “Si X es par se incrementará en el valor que tenga la variable Y y ésta disminuirá en el valor de la variable Z, si X es impar se compararán Y y Z, si Y es mayor que Z se dividirá Y a la mitad y Z se duplicará su valor, en caso contrario se duplicará Y y Z se dividirá su valor a la mitad”

Comprueba en cada caso las estructuras que hayas propuesto, para ello considera que las variables X, Y y Z tienen los valores 2, 9 y 5 antes de “ejecutar” la instrucción testeada, ¿qué valores tendrán dichas variables finalmente?

PIIDUZ-2009-3-293

32

Objetivos:

• Horas presenciales: 2 h. • Horas no presenciales: 0 h. Sesión 4 Tipo: magistral Duración: 1 h. Descripción: El alumno trabajará antes de la sesión magistral el diseño del método que plantea el problema. En clase, los alumnos de forma voluntaria propondrán una solución para cada apartado. El profesor, pedirá alternativas para los casos que se puedan dar varias expresiones válidas y se discutirán las posibles alternativas.

Problema: Móviles. 1. Representamos un objeto móvil en el plano mediante las coordenadas

(x,y) y el vector velocidad (vx,vy). Modificar las partes del código que están incompletas.

public class Movil { /** Coordenada x del móvil*/ private double x; /** Coordenada y del móvil*/ private double x; /**Coordenada x del vector de velocidad*/ private double vx; /**Coordenada y del vector de velocidad*/ private double vy; /** * Constructor por defecto de Movil. * El móvil se sitúa en el origen de coordenada s y el * vector de velocidad es el (1,1) */ public Movil() { x = 0; y = 0; vx = 1; vy = 1; } /** * Modifica la coordenada x del vector velocida d. * @param nvx nueva coordenada x del vector vel ocidad */ public void setVx(double nvx) { vx = nvx; }

PIIDUZ-2009-3-293

33

/** * Modifica la coordenada y del vector velocida d. * @param nvy nueva coordenada y del vector vel ocidad */ public void setVy(double nvy) { vy = nvy; } /** * Mueve el móvil según el sentido de la veloci dad */ public void mover() { x += vx; y += vy; } /** * Retorna cierto si el móvil está parado, esto es, si el vector * de velocidad es nulo. * @return cierto si el vector de velocidad es nulo. */ pubic boolean estaParado() { //FIX } /** * Modifica el vector velocidad 90 grados. */ public void girar90() { //FIX } /** * Modifica el vector velocidad 180 grados. */ public void girar180() { //FIX } /** * Retorna cierto si el móvil se encuentra en u n * rectángulo de dimensiones ancho x alto * cuya esquina superior izquierda esta en (xr, yr) */ public boolean estaDentroRectangulo(double xr, double yr, double ancho, double alto) { //FIX } /** * Retorna cierto si el móvil se encuentra en u n * cuadrado de dimensiones lado x lado * cuya esquina superior izquierda esta en (xr, yr) */ public boolean estaDentroRectangulo(double xr, double yr, double lado)

PIIDUZ-2009-3-293

34

{ //FIX } /** * Retorna la distancia del móvil al punto (xr, yr) */ public double hallarDistancia(double xr, double yr) { //FIX }

2. Introduce en el código anterior dos nuevos construtores: a. Constructor que tiene como argumentos dos reales con las

coordenadas (x,y) del móvil. El vector velocidad tendrá el valor de (1,1)

b. Constructor con cuatro argumentos de tipo real. Los dos primeros representa la posición del móvil y los dos segundos su vector velocidad.

Crea también métodos observadores para todos los campos de la clase.

Objetivos: - Llamar a métodos de una clase dentro de la misma. - Construir varios constructores en la misma clase. - Afianzar el uso de los operadores lógicos. - Usar funciones matemáticas del paquete Math.

• Horas presenciales: 2 h. • Horas no presenciales: 3 h. Sesión 5 Tipo: magistral Duración: 1h Descripción: Se propondrá a los alumnos que resuelvan la primera parte del enunciado anterior antes de la sesión. Durante la sesión, se invitará a un alumno a que resuelva el problema en la pizarra para su posterior discusión. Sesión 6 Tipo: magistral Duración: 1h Descripción: Se propondrá a los alumnos que resuelvan la segunda parte del enunciado anterior antes de la sesión. Durante la sesión, se invitará a un alumno a que resuelva el problema en la pizarra para su posterior discusión.

PIIDUZ-2009-3-293

35

Problema: Recapitulación de conceptos Presentación con transparencias de los conceptos y definiciones vistos

sobre el tema en clase.

Objetivos: - Profundizar en los conceptos vistos en las sesiones anteriores


• Horas no presenciales: 0h. Sesión 7 Tipo: magistral Duración: 1h Descripción: El profesor mostrará transparencias en las que se recojan todos los conceptos que hayan aparecido en las clases anteriores.

Problema: Crear una clase completa. Persona Crear la clase Persona con las siguientes especificaciones. La clase tendrá

campos para representar el nombre, edad y peso de la persona. Dispondrá de un constructor para dar valor a todos los campos de la clase. Los métodos serán:

• Métodos para observar y modificar todos los campos. • public double hallarIMC(): retorna el índice de masa corporal. Se calcula

dividiendo la edad por el peso al cuadrado. • public boolean estaEnForma():si la persona tiene una edad comprendida

en el intervalo [0,16], supondremos que siempre está en forma. Si la edad está en (16,40], estará en forma si el índice de masa corporal es menor o igual que 25. Si tiene más de 40 años, estará en forma si el índice de masa corporal multiplicado por 1.2 es menor o igual que 27.

• public void sumaEdad(int add): suma a la edad de la persona add años. • public void sumaPeso(double add): suma al peso add kilos.

Objetivos: - Crear clases completas simples dadas unas especificaciones.


• Horas no presenciales: 1 h. Sesión 7 Tipo: problemas. Duración: 1h Descripción: Los alumnos intentarán resolver el problema antes de la sesión. En grupos de tres personas, los alumnos implementarán un programa poniendo sus soluciones. Al final de la sesión el profesor mostrará una solución para que cada grupo valore la corrección de su propia solución.

PIIDUZ-2009-3-293

36

Destacar que será la primera clase completa que tendrán que implementar los alumnos. Hasta el momento, solo habrán completado clases.

Problema: Plataformas Java. Clase Complejo. Ejercicio guiado en el que se describa casa parte y elemento que llevará

a definir una clase.

Objetivos: - Presentar la plataforma Java2 SE enmarcada dentro del resto de

plataformas Java2 ME, Java2 EE. - Crear clases completas simples dadas unas especificaciones.

• Horas presenciales: 2.5 h. • Horas no presenciales: 2 h. Sesión 9 Crear la clase Complejo dentro del paquete aritmetica para representar números complejo tanto en forma binomial como en polar. La clase tendrá los siguientes campos:

• Dos números reales para guardar las coordenadas del complejo. • Un booleano, esBinario. Si el valor de este campo es true, las

coordenadas están en forma binomial, si es false, en polares. Los constructores de la clase serán:

• Constructor por defecto: se construye el complejo (0,0) en forma binomial.

• Constructor con dos argumentos de tipo real y otro de tipo booleano para dar valor a los campos de la clase.

Los métodos de la clase serán • Método para modificar el campo esBinario. • Métodos observadores de todos los campos. • Método public String toString() que retorna una cadena de caracteres

con la información del complejo. Si el número está en forma binomial, el formato de salida será (x,y). Si está en forma polar, [x,y].

Tipo: prácticas Duración: 2.5 h. Descripción: Al inicio de la sesión de prácticas se presentará mediante transparencias el marco donde se encuadra la plataforma de Java en la que se trabajará a lo largo de todo el curso. Seguidamente los alumnos implementarán la clase pedida en el enunciado usando el entorno de programación BlueJ.

PIIDUZ-2009-3-293

37

TEMA 5 Estructuras de datos y algoritmos.

Comunicación entre objetos 1.1. Objetivos.

• El lenguaje vehicular de la asignatura, Java, asume que sólo vamos a realizar programación orientada a objetos. Esto implica que hay que asentar los conceptos relacionados con la programación orientada objetos como base para los siguientes temas.

• Entender la importancia del problema de la ordenación, búsqueda en inserción de datos y la necesidad de contar con algoritmos eficientes para llevarla a cabo.

• Conozca los tipos de estructuras iterativas existentes, su estructura y su funcionalidad.

• Sepa distinguir los diferentes tipos de estructuras iterativas existentes, y sea capaz de identificar los elementos comunes y sus diferencias.

• Sea capaz de seleccionar el tipo de estructura iterativa más adecuada a cada problema que se requiera de estas estructuras para su resolución

• Aprender y saber usar las distintas técnicas algorítmicas sobre arrays. • Aprender y saber usar algoritmos más avanzados sobre arrays. • Saber elegir el algoritmo más adecuado a las necesidades de un problema

concreto • Aprender a utilizar algunas formas de medir y comparar la eficiencia de

algoritmos de ordenación. • Desarrollar la capacidad de abstracción

1.2. Competencias.

Conceptuales: • Conocer un lenguaje de programación. • Conocer elementos comunes a los lenguajes de programación. • Conocer los conceptos de abstracción de datos y acciones. • Conocer los conceptos de comunicación de mensajes entre los

elementos de un programa.

Prodecimentales: • Comprender sintáctica y lógicamente, y utilizar soluciones

desarrolladas en un lenguaje de programación. • Dadas las especificaciones, identificar que un programa utiliza listas

de datos, seleccionar el algoritmo genérico para listas más eficiente en relación al problema, e implementarlo de forma eficaz.

• Modificar código pre-existente para adaptarlo a nuevas situaciones.

PIIDUZ-2009-3-293

38

• Depurar algoritmos para analizar la corrección del algoritmo. • Programar con independencia al lenguaje de programación vehicular.

Actitudinales: • Valorar la ayuda que proporciona la documentación. • Poner en tela de juicio los algoritmos para listas y las

especificaciones que se le presentan.




Problema: Todo son objetos El lenguaje vehicular de la asignatura, Java, asume que sólo vamos a realizar programación orientada a objetos. Esto implica que hay que asentar los conceptos relacionados con la programación orientada objetos como base para los siguientes temas.

Objetivos:

- Desarrollar la habilidad para hacer programas básicos en Java. • Horas presenciales 5.5 h. • Horas no-presenciales: 2 h. Sesión 1 Tipo: magistral Duración: 1h Descripción: La presentación magistral introducirá al alumno los siguientes conceptos:

• Un programa es una colección de objetos. El alumno aprenderá que un objeto es una variable “especial” que almacena datos y que puede realizar operaciones sobre dichos datos si se lo pedimos. Cada objeto tiene un tipo, es decir, cada objeto es instancia de una clase. El alumno aprenderá que los objetos se crean utilizando el operador “new” con una clase, que es una abstracción de datos.

• Los objetos que se comunican entre sí mediante mensajes, llamados “métodos”. Todos los objetos de un mismo tipo reciben el mismo tipo de mensajes. El alumno aprenderá cómo se crea un método en Java, y a llamar un método desde dentro de la clase. También aprenderá a utilizar el operador “.” seguido del nombre del método y sus parámetros para llamar a alguna operación desde fuera de la clase.

PIIDUZ-2009-3-293

39

Evaluación: 5 preguntas tipo test. Sesión 2 Tipo: magistral Duración: 1h Descripción: La presentación magistral introducirá al alumno los siguientes conceptos:

• Cada objeto está hecho de otros objetos, que se denominan “campos”. El alumno aprenderá cómo se define un campo. El alumno aprenderá a usar campos dentro de una clase. El alumno aprenderá que el operador “.” también da acceso a objetos. El alumno aprenderá que existe la referencia “this” en Java para poderse referirse al propio objeto dentro de un método cuando la definición de ese método entra en conflicto con la definición de un “campo”.

• Encapsulación. Se pueden establecer restricciones al acceso a campos y métodos por parte de otros objetos. Se introduce el concepto “package” y que por defecto el acceso está limitado a los objetos del mismo paquete. Se introduce el concepto de modificador. El máximo nivel de ocultamiento se obtiene con el modificador “private”. No hay ocultamiento si se utiliza el modificador “public”. Hay un modificador adicional, “protected”, similar al “private”, pero que permite que el acceso a objetos relacionados por herencia (concepto que se desarrollará en temas posteriores).

Evaluación: 5 preguntas tipo test. Sesión 3 Tipo: problemas Duración: 1h Descripción: Los problemas desarrollados afianzarán el conocimiento de:

• La estructura de una clase de Java. • La definición de los miembros de una clase. • El uso de los miembros de una clase desde dentro de la clase y desde

otra clase • La definición de los campos de una clase. • El uso de los campos de una clase desde dentro de la clase y desde

otra clase. • El uso de modificadores para controlar el acceso a un método o a un

campo. Evaluación: 5 preguntas tipo test. Sesión 4 Tipo: prácticas Duración: 2,5h Descripción: Compilación y ejecución de Java

• Ejercicio: Instalación del JDK de Java. • Ejercicio: Creación de un programa básico de Java. El primer

programa Java: “Hola mundo”.

PIIDUZ-2009-3-293

40

• Ejercicio: Compilación del programa “Hola mundo”. Introducción y demostración práctica del concepto “Máquina Virtual”.

• Ejercicio: Ejecución del programa “Hola mundo” • Ejercicio: Conversión de una clase Java en un objeto ejecutable. • Ejercicio: Creación, compilación y ejecución de un programa con 2

clases.

Problema: Control del flujo de un programa Se desarrollarán problemas para el desarrollo de un control del flujo de un programa en Java.

- Desarrollar la habilidad para hacer programas básicos en Java.

• Horas presenciales 3 h. • Horas no-presenciales: 4 h. Sesión 5: Estructuras iterativas Tipo: magistral Duración: 1h Descripción: Se detallarán los diferentes tipos de estructuras condicionales existentes en Java Comparativa while, do while.

• No se indica a priori cuantas veces se va a ejecutar (si está mal programado pueden ser infinitas)

• While puede no ejecutarse (condición falsa al inicio) • Do-while siempre se ejecuta una vez • La condición es la misma en ambos casos Comparativa for, for-each.

• Se sabe a priori cuantas veces se va a ejecutar • En el for se indica condición de salida e incrementos • El for each solo se aplica a clases que extienden el interfaz collection, se

ejecuta tantas veces como elementos hay en la colección. (aquí hay cosas que todavía no saben, dejar detalles para más adelante)

Contar sentencia break/continue; Se planteará uno/dos ejercicio que se tenga que resolver con while, o do-while. Uno más adecuado con while y otro más adecuado con do-while.Se corregirá en la siguiente clase. Sesión 6 Tipo: problemas Duración: 1 h Descripción: Ejemplo de uso del while, do while, for • Ejercicio 1: Solicitar un número al usuario y comprobar que esté en un

rango dado.

PIIDUZ-2009-3-293

41

• Ejercicio 2: Mostrar los 10 primeros números primos mayores que 1000. • Ejercicio 3: Realizar el sumatorio de los números del 1 al 100.

1. Mejora 1: los limites inferior y superior los tiene que sumarse 2. Mejora 2: solo sumar los números pares

• Ejercicio 4: mostrar todos los números primos contenidos en el rango del 1 al 100

• Escribir un programa en Pascal que calcule cuantos años tarda en duplicarse un capital depositado al 5% de interés anual

• Escribir un programa en Pascal que calcule el factorial de un número Sesión 7: Tipo: problemas Duración: 1 h Descripción: Resolución de problemas contados previamente • Ejercicio 5: leer 10 enteros, guardarlos en un int[] y sumarlos • Ejercicio 6: leer 10 enteros, guardarlos en una lista y sumarlos • Ejercicio 7: leer 10 cadenas y guardarlas en una hashtable indexadas por

su posición, luego permitir preguntar por la posición y recuperar valor asociado

• Escribir un programa en Pascal que calcule la media de los valores contenidos en él una lista y en un array

Problema: Tipos de datos complejos Para realizar algunas tareas se necesita definir tipos de datos completos. El ejemplo paradigmático son las listas. Java ofrece dos posibilidades, utilizar la primitiva “array” o utilizar la clase List.

• Horas presenciales: 6 h.

• Horas no presenciales:12 h.

Sesión 8 y 9 Tipo: magistral Duración: 2h Descripción: La presentación magistral introducirá al alumno los siguientes conceptos:

• Creación y uso de arrays unidimensionales. El alumno aprenderá los operadores [] y length. El alumno aprenderá a distinguir el concepto de asignación de objetos del de copia de objetos.

• Creación y uso de arrays multidimensionales. El alumno aprenderá a crear arrays multidimensionales y a operar correctamente un array de dimensión 2.

• Estructuras de datos, recordar arrays, incluir Listas y Hashtables

PIIDUZ-2009-3-293

42

Sesión 10: Algoritmos sobre arrays: presentación Tipo: magistral Duración: 1h Descripción: La presentación magistral introducirá al alumno los siguientes conceptos:

• Interés por los ‘conjuntos ordenados de elementos’. Hacer ver al alumno que, en su vida diaria, la relación ordenada de elementos tiene gran importancia, por ejemplo, en actividades cotidianas como buscar números de teléfonos en una agenda. Lo mismo ocurre en diccionarios, enciclopedias, ficheros de bibliotecas, etc.

• Conocimiento de la existencia diferentes técnicas de ordenación/búsqueda. Estudio de diferentes modos de ordenación y búsqueda. Conocer diferentes técnicas de cálculo de la eficiencia de algoritmos sobre arrays.

Evaluación: 5 preguntas tipo test. Sesión 11: Implementación de algoritmos de búsqueda Tipo: magistral Duración: 1h Descripción: La presentación magistral introducirá al alumno los siguientes conceptos:

• Búsqueda secuencial • Búsqueda binaria • Análisis de eficiencia: teórica y experimental

A través de la explicación de ejercicios como:

• Estudio de las trazas de los algoritmos de búsqueda • Dado un array de n elementos reales, diseñar el algoritmo que calcule

y la media de los elementos (búsqueda secuencial hasta el final) • Realizar un programa que compare el tiempo de cálculo de las

búsquedas secuencial y binaria en un problema sencillo • Programa de consulta de teléfonos. Las consultas han de realizarse

por nombre y por número de teléfono.

Evaluación: 5 preguntas tipo test. Sesión 12: Implementación de algoritmos de inserció n Tipo: magistrales Duración: 1h Descripción: Los problemas desarrollados afianzarán el conocimiento de:

• Inserción de elementos en un array ordenado • Inserción de elementos en un array no ordenado

A través de la explicación de ejercicios como:

• Estudio de las trazas de los algoritmos de inserción

PIIDUZ-2009-3-293

43

• Diseñar un programa para insertar un duplicado de todos los números impares de un array

• Escribir una función que elimine los elementos duplicados de un vector ordenado.

Evaluación: 5 preguntas tipo test. Sesión 13: Implementación de algoritmos de ordenaci ón: Tipo: magistrales Duración: 1h Descripción: Los problemas desarrollados afianzarán el conocimiento de:

• Método de la burbuja • Método de inserción directa • Método de selección directa

A través de la explicación de ejercicios como: • Escribir un programa que genere un vector de 20 números aleatorios

de 1 a 100 y realizar la ordenación del vector por los tres medios • Ordenar un array con información sobre una compañía de informática

por diferentes criterios (nombre del empleado, las ventas efectuadas por el mismo y el número de años de antigüedad en la compañía.

• Calcular medidas de eficiencia de cada algoritmo en un mismo problema

Evaluación: 5 preguntas tipo test. Sesión 14 Tipo: prácticas Duración: 2,5h

• Letras de una frase. Realizar un programa que pida al usuario que

introduzca por teclado una cadena de texto sin acentos, y calcule y muestre por pantalla la frecuencia de aparición de cada letra, desde la ‘a’ hasta la ‘z’.

• Diagonales de una matriz. Crea un programa que pida al usuario que introduzca una matriz cuadrada de tamaño 4 x 4. A continuación, el programa calculará cuál es el mayor elemento de la diagonal principal y cuál el menor elemento de la diagonal secundaria.

• Ordenación de vectores. Crea un programa que pida al usuario un vector de números reales de tamaño n, y que muestre por pantalla el vector ordenado de menor a mayor. Utiliza el método de selección, el de la burbuja, o el de inserción para ordenar el vector.

PIIDUZ-2009-3-293

44

TEMA 6 Abstracción de datos: Herencia

1.1. Objetivos. • Comprender los conocimientos básicos de la herencia. • Uso de la palabra clave extends. • Uso de constructores relacionado con la herencia. • Utilización de la palabra clave super en constructores y métodos. • Redefinición de métodos de la super clase en las clases derivadas. • Comprensión y uso de las clases abstractas. • Uso de la palabra clave abstract en clases y métodos. • Usar el paquete JUnit para crear bancos de pruebas. • Conocer la conexión de este paquete con el entorno de programación Bluej. • Usar el entorno de programción Bluej para probar la corrección del código.

1.2. Competencias.

Conceptuales: • Conocer un lenguaje de programación • Conocer los conceptos de abstracción de datos y acciones • Aprender a trabajar en grupo

Prodecimentales: • Manejar un entorno de desarrollo de programas • Depurar algoritmos para analizar la corrección del algoritmo • Modificar código escrito para adaptarlo a nuevas situaciones • Analizar un problema identificando sus características


realización del trabajo en grupo • Valorar la ayuda que proporciona la documentación


Horas clases magistrales 2 Horas clases problemas 2 Horas clases prácticas 2.5 Horas no presenciales 6

PIIDUZ-2009-3-293

45


Problema: Base de datos de CD y DVD. En el proyecto proyMisAudios disponemos de las clases siguientes para simular una pequeña base de datos para guardar información sobre los CD, DVD que un usuario tiene en su casa:

• Clase CD: contiene campos para guardar título y duración , si se tiene prestado a un amigo o no, un comentario, el artista que interpreta el CD y el número de canciones que contiene.

• Clase DVD: contiene campos para guardar título y duración , si se tiene prestado a un amigo o no, un comentario y el director de la película.

• Clase BaseDatos: contiene dos campos, una lista para guardar los CD y otra para los DVD. También tiene métodos para añadir un CD o DVD nuevo a la lista e imprimir por pantalla la información referente a todos los elementos guardados.

Modificar estas clases haciendo uso de la derivación de modo que la clase BaseDatos contenga una única lista donde guardar tanto los CD y DVD. Añadir un método para que liste todos los CD o DVD que contengan en su título una cadena de caracteres dada. Código de las clases: package miscosas; /** * Clase para representar cds. * * @author * @version 0.0.1 */ public class CD { private String titulo; private int duracion; private boolean estaPrestado; private String comentario; private String artista; private int numeroCanciones; /** * Constructor for objects of class CD */ public CD(String tit, int dur, boolean pres, St ring coment, String art, int totalCanciones) { titulo = tit; duracion = dur; estaPrestado = pres; comentario = coment; artista = art; numeroCanciones = totalCanciones; } /** * Modifica el comentario al CD * @param comment el comentario a introducir */ public void setComentario(String comment) { comentario = comment; } /** * @return El comentario del CD */

PIIDUZ-2009-3-293

46

public String getComentario() { return comentario; } /** * Pone el boolean indicadndo si esta prestado el CD * @param pres true si está prestado. False, ca so contrario */ public void setEstaPrestado(boolean pres) { estaPrestado = pres; } /** * @return si está prestado o no el CD */ public boolean getEstaPrestado() { return estaPrestado; } /** * @return el artista que interpreta el CD */ public String getArtista() { return artista; } /** * @return el número de canciones del CD */ public int getNumeroCanciones() { return numeroCanciones; } /** * @return un string con los datos del CD */ public String toString() { String res = "Titulo: " + titulo + "\n"; res += "Duración: " + duracion + "\n"; res += "Prestado: "; if (estaPrestado) { res += "SI\n"; } else { res += "NO\n"; } res += "Comentario: " + comentario + "\n"; return res; } } package miscosas; /** * Clase para representar dvds * * @author (your name) * @version (a version number or a date) */ public class DVD { private String titulo; private int duracion; private boolean estaPrestado; private String comentario; private String director; /** * Constructor for objects of class DVD */ public DVD(String t, int d, boolean pres, Strin g coment, String dire)

PIIDUZ-2009-3-293

47

{ titulo = t; duracion = d; estaPrestado = pres; comentario = coment; director = dire; } /** * Modifica el comentario al DVD * @param comment el comentario a introducir */ public void setComentario(String comment) { comentario = comment; } /** * @return El comentario del DVD */ public String getComentario() { return comentario; } /** * Pone el boolean indicadndo si esta prestado el DVD * @param pres true si está prestado. False, ca so contrario */ public void setEstaPrestado(boolean pres) { estaPrestado = pres; } /** * @return si está prestado o no el DVD */ public boolean getEstaPrestado() { return estaPrestado; } /** * @return el director del DVD */ public String getDirector() { return director; } /** * @return un string con los datos del DVD */ public String toString() { String res = "Titulo: " + titulo + "\n"; res += "Duración: " + duracion + "\n"; res += "Prestado: "; if (estaPrestado) { res += "SI\n"; } else { res += "NO\n"; } res += "Comentario: " + comentario + "\n"; return res; } } package miscosas; import java.util.*; /** * Clase para guardar y mostrar los CD y DVD. * * @author

PIIDUZ-2009-3-293

48

* @version 0.0.1 */ public class BaseDatos { private ArrayList<CD> misCDs; private ArrayList<DVD> misDVDs; /** * Construye un base de datos vacía. */ public BaseDatos() { misCDs = new ArrayList<CD>(); misDVDs = new ArrayList<DVD>(); } /** * Introduce un CD en la base de datos * @param unCD el CD a introducir */ public void addCD(CD unCD) { misCDs.add(unCD); } /** * Introduce un DVD en la base de datos * @param unDVD el DVD a introducir */ public void addDVD(DVD unDVD) { misDVDs.add(unDVD); } /** * Lista por pantalla la información de todos l os CD y DVD de la base de datos */ public void listar() { for (CD cd : misCDs) { System.out.println(cd); } for (DVD dvd : misDVDs) { System.out.println(dvd); } } }

Objetivos:

- Comprender los conocimientos básicos de la herencia. - Uso de la palabra clave extends.

- Uso de constructores relacionado con la herencia. - Utilización de la palabra clave super en constructores y métodos. - Redefinición de métodos de la super clase en las clases derivadas. - Comprensión y uso del concepto de polimorfismo.


• Horas no presenciales: 1 h.

Sesión 1 Tipo: magistral Duración: 1 h. Descripción: Presentación de los conceptos básicos del mecanismo de herencia mediante transparencias.

PIIDUZ-2009-3-293

49

Sesión 2 Tipo: magistral Duración: 1 h. Descripción: Se explicarán los conceptos básicos de la herencia mediante el enunciado del problema anterior.

Problema: Empresa. 1. Crear la clase Empleado para representar los datos de un trabajador de una

empresa: � La clase tendrá tres campos: un String con el nombre y apellidos, un entero

que representa el año de inicio de contrato y otro String para el DNI. � Constructor con los argumentos necesarios para dar valor a los tres campos; � Métodos para observar y modificar cada uno de los campos de la clase. � Método toString() que retorna un String con todos los datos del empleado.

En la empresa hay tres tipos categorías de empleados: � categoría A: estos trabajadores son eventuales, el sueldo es de 1000 euros al

mes y es necesario conocer la fecha de fin de contrato; � categoría B: son trabajadores fijos. El sueldo se calcula teniendo en cuenta

un campo de tipo entero aumento, propio de cada empleado, según la fórmula:

sueldo = 1300 + aumento*10 euros;

� categoría C: son también trabajadores fijos. El sueldo se calcula según el número de años trabajados: partiendo de 1500 euros, el sueldo aumenta un cinco por ciento cada año trabajado.

Crear clase por derivación de la clase Empleado para representar los tipos de empleado añadiendo en cada una de las clases creadas el método hallarSueldo() para hallar el sueldo del empleado.

Observación: para conocer el año actual se puede usar la clase Calenadar del paquete java.util :

Calendar d = Calendar.getInstance(); //d es fecha y hora actual

int añoActual = f.get(Calendar.YEAR); // año actual

2. Queremos guardar en un array de Empleado varios empleados de distintas categorías y hallar el sueldo de cada uno de ellos. ¿Qué modificaciones harías en la clase Empleado para poder hacer esta tarea?

Objetivos:

- Reforzar los conceptos básicos del mecanismo de herencia. - Comprensión y uso de las clases abstractas. - Uso de la palabra clave abstract en clases y métodos.



PIIDUZ-2009-3-293

50

Sesión 3 Tipo: problemas Duración: 1 h. Descripción: En grupos de tres personas trabajarán el enunciado del problema. El profesor recordará brevemente al inicio de la clase los conceptos relacionados con la herencia de modo que el alumno intente resolver por si mismo el problema con la ayuda de sus compañeros. Sesión 4 Tipo: problemas Duración: 1 h. Descripción: En grupos de tres personas trabajarán el enunciado del problema. El profesor recordará brevemente al inicio de la clase los conceptos relacionados con las clases abstractas de modo que el alumno intente resolver por si mismo el problema con la ayuda de sus compañeros.

Problema: Herencia y polimorfismo. 1. Crear las clases necesarias para representar los siguientes tipos de figuras en el

plano: círculos, rectángulos y tríangulos equiláteros. Cada una de estas figuras vendrá determinada por su centro geométrico y

• El radio, para el círculo; • Ancho y alto, para el rectángulo; • Lado, para el triángulo equilátero.

Cada figura tendrá métodos para hallar su área e imprimir la información de la figura, a parte de los constructores, métodos observadores y modificadores habituales. Crear una clase BolsaFiguras donde se puedan añadir tantas figuras como se quiera en una única lista. La clase también tendrá métodos para hallar la suma total de las áreas de todas las figuras guardas y para imprimir los datos de todas las figuras.

Objetivos:

- Reforzar los conceptos del mecanismo de herencia aparecidos a lo largo del tema.

- Usar el paquete JUnit para crear bancos de pruebas. - Conocer la conexión de este paquete con el entorno de programación

Bluej. - Usar el entorno de programción Bluej para probar la corrección del

código.

• Horas presenciales: 2.5 h.


Sesión 5 Tipo: prácticas Duración: 2.5 h. Descripción: En grupos de tres personas trabajarán el enunciado del problema. El profesor recordará brevemente al inicio de la clase los

PIIDUZ-2009-3-293

51

conceptos relacionados con la herencia de modo que el alumno intente resolver por si mismo el problema con la ayuda de sus compañeros.

PIIDUZ-2009-3-293

52

TEMA 7 Diseño de clases

1.5. Objetivos. • Comprender qué es el acoplamiento y, en caso de existir, qué

dificultades representa a la hora del mantenimiento del código. • Reconocer código mal implementado. • Refactorizar: mejorar el código ya implementado. • Conocer y usar la estructura try..catch • Conocer y capturar excepciones de tipo RuntimeException • Valorar la utilidad de la captura de excepciones. • Conocer y usar Streams: Strems orientados a leer y escribir bytes,

streams orientados a escribir caracteres. • Gestionar excepciones generadas por los Streams. • Comprender la propagación de excepciones y el uso de la cláusula

throws

1.6. Competencias.

Conceptuales: • Conocer un lenguaje de programación. • Conocer los conceptos de abstracción de datos y acciones. • Aprender a trabajar en grupo.

Prodecimentales: • Depurar algoritmos para analizar la corrección del algoritmo. • Modificar código escrito para adaptarlo a nuevas situaciones. • Analizar un problema identificando sus características. • Organizar y planificar. • Desarrollar autonomía para aprender. • Comprender sintáctica y lógicamente y utilizar soluciones

desarrolladas en un lenguaje de programación.


realización del trabajo en grupo. • Poner en tela de juicio los algoritmos y especificaciones que se le

presentan. • Capacidad crítica para discriminar la información relevante para el

aprendizaje.


PIIDUZ-2009-3-293

53



Problema: Criba de Erastótenes. <Enunciado del problema>

1. Se da el siguiente ejemplo de una clase java que sirve para calcular y mostrar por la pantalla todos los números primos entre 1 y max utilizando la criba de Eratóstenes. Intenta mejorar la solución.

/** * Clase para generar y mostrar en la pantalla todo s * los números primos de 1 hasta un número máximo * especificado por el usuario. Como algoritmo se u tiliza * la criba de Eratóstenes. * * Eratóstenes de Cirene (276 a.C., Cirene, Libia – 194 * a.C., Alejandría, Egipto) fue el primer hombre q ue * calculó la circunferencia de la Tierra. También * se le conoce por su trabajo con calendarios que ya * incluían años bisiestos y por dirigir la mítica * biblioteca de Alejandría. * * El algoritmo es bastante simple: Dado un vector de * enteros empezando en 2, se tachan todos los múlt iplos * de 2. A continuación, se encuentra el siguiente * entero no tachado y se tachan todos sus múltiplo s. El * proceso se repite hasta que se pasa de la raíz c uadrada * del valor máximo. Todos los números que queden s in * tachar son números primos. * * @author (alumno) * @version (1.0) */ public class Criba { public int max; public int i,j; public int[] primos; public void generarPrimos() { if (max >= 2) { // Declaraciones int dim = max + 1; // Tamaño del array boolean[] esPrimo = new boolean[dim]; // Inicializar el array for (i=0; i<dim; i++) esPrimo[i] = true; // Eliminar el 0 y el 1, que no son pri mos esPrimo[0] = esPrimo[1] = false; // Criba

PIIDUZ-2009-3-293

54

for (i=2; i<Math.sqrt(dim)+1; i++) { if (esPrimo[i]) { // Eliminar los múltiplos de i for (j=2*i; j<dim; j+=i) esPrimo[j] = false; } } // ¿Cuántos primos hay? int cuenta = 0; for (i=0; i<dim; i++) { if (esPrimo[i]) { cuenta++; } } // Rellenar el vector de números primos primos = new int[cuenta]; for (i=0, j=0; i<dim; i++) { if (esPrimo[i]) { primos[j] = i; j++; } } // Mostrar los números primos existente s en el intervalo for (i=0; i<j; i++) { System.out.print(" "+primos[i]); } System.out.println(); } else { // max < 2 primos = new int[0]; // Vector vacío // Mostrar los números primos existente s en el intervalo System.out.println("No hay primos en el intervalo"); } } public static void main(String args[]){ Criba c = new Criba(); c.max = 100; c.generarPrimos(); } }

2. Modifica el programa para que el usuario pueda meter el número max por teclado. Se controlará los errores de entrada, esto es, el programa pedirá que se introduzca un número hasta que la cadena de caracteres tecleada por el usuario represente un entero.

Objetivos:

- Comprender qué es el acoplamiento y, en caso de existir, qué dificultades representa a la hora del mantenimiento del código.

- Reconocer código mal implementado. - Refactorizar: mejorar el código ya implementado. - Conocer y usar la estructura try..catch

- Conocer y capturar excepciones de tipo RuntimeException

- Valorar la utilidad de la captura de excepciones.



PIIDUZ-2009-3-293

55

Sesión 1 Tipo: magistral Duración: 1 h. Descripción: Se presenta previamente a los alumnos un ejemplo de código mal implementado. Los alumnos tendrán que intentar reconocer los errores y mejorarlo antes de la sesión. Durante la sesión, se explicarán las mejoras introduciendo los conceptos de acoplamiento y refactorización. Sesión 2 Tipo: magistral Duración: 1 h. Descripción: Se explicarán los conceptos relativos a la captura de excepciones, en particular, las excepciones que derivan de RuntimeExcpetion.

Problema: Descomprimir un fichero. Crear la clase Descompresor para descomprimir ficheros de bytes que han sido comprimidos con el siguiente algoritmo:

• elegimos un byte, sep, que utilizaremos como marca de separación en la compresión;

• si en el fichero original aparece n veces consecutivas con n>3 el byte b ≠ sep, o si b = sep (en este caso da igual el valor de n) , en el fichero comprimido se escribe \nb;

• en otro caso, en el fichero comprimido se escribe el propio byte b. Por ejemplo, si usamos como byte separador \’ y en el fichero original tenemos la secuencia

aaaabb\a\\cccccc

la secuencia comprimida será \4abb\1\a\2\\6c

La clase Descompresor tendrá un campo para guardar el separador sep. Además dispondrá de métodos para:

• modificar y observar el campo; • void descomprimir (InputStream, OutputStream): lee todos los bytes posibles

del InputStream y los escribe descomprimidos en el OutputStream. Crear un programa principal donde se descomprima el fichero imagen.mcp en el fichero imagen2.bmp. Para comprobar la corrección del método, el fichero resultante de la descompresión debe ser igual a imagen.bmp.

Objetivos:

- Conocer y usar Streams: Strems orientados a leer y escribir bytes, streams orientados a escribir caracteres.

- Gestionar excepciones generadas por los Streams. - Comprender la propagación de excepciones y el uso de la cláusula

throws

PIIDUZ-2009-3-293

56



Sesión 3 Tipo: magistral Duración: 1 h. Descripción: Se presenta mediante transparencias los conceptos de Streams y excepciones relacionadas con ésta. Los streams que se manejarán son streams orientados a leer y escribir byes y a escribir caracteres. Sesión 4 Tipo: problemas Duración: 1 h. Descripción: Se plantea el problema de cómo comprimir un fichero de bytes. Los alumnos intentarán resolver el problema con la ayuda del profesor y sus compañeros.

Problema: Comprimir el fichero. Modificar la clase Descompresor de la actividad anterior para que se pueda comprimir cualquier fichero de bytes.

Objetivos:

- Reforzar los conocimientos sobre streams y excepciones incidiendo en su uso.



Sesión 5 Tipo: prácticas Duración: 2.5 h. Descripción: Al inicio de la clase de práctica, implementarán en el ordenador la solución al problema de la sesión anterior comprobando su correcto funcionamiento. A continuación, deberán implementar el algoritmo de descompresión y comprobar que el fichero original es el mismo que tras el proceso de compresión-descompresión.

Problema: Alquiler de películas. Se debe desarrollar una aplicación que gestione los préstamos en un videoclub. Para cada préstamo, o alquiler, se debe calcular el precio a pagar por el socio y la cantidad de puntos conseguidos en esa transacción. El precio a pagar depende del tipo de película, de modo que la tarifa normal tiene un precio base de 2 euros. Además, en caso de que se supere el límite de tiempo de dos días, se añadirá al precio una penalización. Dicha penalización será de 1.5 euros por cada día que sobrepase el límite. La tarifa infantil tiene una base de 1.5 euros, y se

PIIDUZ-2009-3-293

57

penaliza con 1.5 euros por cada día que supere el límite de tres días. Las películas con tarifa de estreno no tienen base, sino que simplemente se pagan a 3 euros por día de alquiler. El recuento para el programa de puntos consiste en añadir al cliente un punto por cada alquiler. Si además la película es de estreno, por cada día de alquiler se añadirá un punto más.

a) Se ha desarrollado una primera solución a este enunciado, de modo que en ella se deberían mejorar varios aspectos. Por tanto, se pide refactorizar el código que a continuación se presenta.

public class DVD { // Constantes simbólicas public static final int INFANTIL = 2; public static final int NORMAL = 0; public static final int NOVEDAD = 1; // Variables de instancia private String titulo; private int tipo; // Constructor public DVD (String paramTitulo, int parmTipo) { titulo = paramTitulo; tipo = paramTipo; } // Acceso a las variables de instancia Public int getTipo() {

return tipo; } Public void setTipo(int paramTipo) { tipo = paramTipo; } public String getTitulo() { return titulo; }

} public class Alquiler { private DVD dvd; private int tiempo; public Alquiler(DVD paramDVD, int paramTiempo)

PIIDUZ-2009-3-293

58

{ dvd = paramDVD; tiempo = paramTiempo; } public int getTiempo() { Return tiempo; } public DVD getDVD() { return dvd; } } import java.util.*; public class Cliente { // Variables de instancia private String nombre; private Vector alquilires = new ArrayList<Alquiler >; // Constructor public Cliente (String paramNombre) { nombre = paramNombre; } // Registrar alquiler public void nuevoAlquiler(Alquiler paramAlquiler) { alquileres.add(paramAlquiler); } // Emitir un informe del cliente public String informe() { double total; double importe; int puntos; int i; Alquiler alquiler; String salida; total = 0 ; puntos = 0 ; salida = ``Informe para ´´ + getNombre() + ``\n´´ ; // Recorrido del vector de alquileres for (i=0 ; i < alquileres.size() ; i++) { importe = 0 ; alquiler = (Alquiler) alquileres.ger(i); // Importe del alquiler

PIIDUZ-2009-3-293

59

switch (alquiler.getDVD().getTipo()) {

case DVD.NORMAL: importe += 2 ; if (alquiler.getTiempo() > 2) importe+=(alquiler.getTiempo()–2)*1.5; break; case DVD.NOVEDAD: importe += alquiler.getTiempo()*3 ; break; case DVD.INFANTIL: importe += 1.5; if (alquiler.gettiempo()>3) importe +=(alquiler.getTiempo()-3)*1.5; break ;

}

// Programa de puntos

puntos++ ;

if ( (alquiler.getDVD().getTipo()==DVD.NOVEDAD) && (alquiler.getTiempo() > 1) )

puntos ++ ; // Bonificación

// Mostrar detalles del alquiler

salida += ``\t´´ + alquiler.getDVD().getTitulo() +``\t´´ + String.valueOf(importe) + `` €\n´´ ;

// Acumular total total += importe; } // Pie de informe salida += ``IMPORTE TOTAL = ´´

+ String.valueOf(total) + `` €\n´´; salida += ``Dispone de ´´

+ String.valueOf(puntos) + `` puntos\n´´; return salida; } }

b) Tal como vemos en el enunciado, las distintas tarifas tienen características en común. Por eso otra mejora en la que tal vez no hayas pensado, consiste en reorganizar la jerarquía de clases teniendo en cuenta los rasgos comunes que se utilizan para establecer los precios según las distintas tarifas (base, límite y penalización). Aplica dicha mejora al código obtenido en el apartado anterior.

c) Se quiere obtener un catálogo con todas las películas de las distintas sucursales.

Para ello sería de utilidad un algoritmo que permita añadir, en un stream de caracteres, el título de cada película en una línea diferente. Implementa dicho

PIIDUZ-2009-3-293

60

algoritmo, teniendo en cuenta que se debe hacer una buena gestión de excepciones.

Objetivos:

- Reforzar los conocimientos sobre streams. - Reforzar los conocimientos sobre herencia y polimorfismo. - Reforzar los conocimientos sobre manejo de excepciones. - Refactorizar código.



Sesión 6 Tipo: magistral Duración: 1 h. Descripción: Los alumnos dispondrán del enunciado antes de la sesión. Durante la clase se propondrá que algún alumno resuelva parte del enunciado para posteriormente discutir la solución. Sesión 7 Tipo: problemas Duración: 1 h. Descripción: Los alumnos dispondrán del enunciado antes de la sesión. Durante la clase se propondrá que algún alumno resuelva parte del enunciado para posteriormente discutir la solución. Sesión 8 Tipo: magistral Duración: 1 h. Descripción: Los alumnos dispondrán del enunciado antes de la sesión. Durante la clase se propondrá que algún alumno resuelva parte del enunciado para posteriormente discutir la solución.

Problema: Girar una imagen. Los ficheros con formato bmp de 24 bits tienen las siguientes características:

• los primeros 54 bytes son diferentes cabeceras, donde entre otros datos, se almacena la anchura y altura de la imagen;

• los siguientes bytes hasta el final del fichero son la información de la imagen, tres bytes por cada píxel.

Por ejemplo, si disponemos de una imagen con tamaño de 40x40 píxeles, el fichero bmp de 24 bits tendría 54 bytes de cabeceras más 40x40x3=4800 bytes de información de la imagen. Para realizar esta práctica vamos a suponer que todas las imágenes de las disponemos son de 40x40 píxeles con formato bmp de 24 bits. Para crear una imagen con estas características podemos usar el programa “paint”. Al abrir el programa, pincharemos

PIIDUZ-2009-3-293

61

dentro del menú en “Imagen->Atributos” y escribiremos en los campos Ancho y Alto, 40, asegurándonos que las unidades son Píxeles.

Una vez modificados los atributos para que sea una imagen de 40x40, la dibujamos y guardamos como “Mapa de bits de 24 bits (*.bmp, *.dib)”. El objetivo de la práctica es crear las clases necesarias para rotar 180º una imagen con este formato. Para resolver el problema, crear dos clases:

• Píxel: con tres campos de tipo bytes y métodos para observar y modificar los campos.

• Imagen: con dos campos, un array de 54 bytes para guardar la cabecera de un fichero bmp y una matriz 40x40 de Píxel. Dispondrá de los métodos:

o void cargarImagen(InputStream): da valor a los campos desde el stream o void volvarImagen(OutputStream): escribe en un stream los datos de la

imagen guardada en los campos. o void rotar180(): rota 180º la imagen guardada en los campos.

Objetivos:

- Reforzar los conocimientos sobre streams y excepciones incidiendo en su uso.



Sesión 9 Tipo: prácticas Duración: 2.5 h. Descripción: Los alumnos se juntarán en grupos de 4 ó 5 personas y resolverán el enunciado del problema. Se calificará la práctica mediante una entrevista donde estarán todos los miembros del grupo. La calificación del grupo será la del miembro que haya obtenido menor nota en la entrevista.

PIIDUZ-2009-3-293

62

Bibliografía 1. J. L. Bernal. (2006). Diseño Curricular en la enseñanza universitaria desde la

perspectiva de los ECTS. ICE: Universidad de Zaragoza. 2. David J. Barnes, Michael Kölling. Object fisrt with Java. A practical introduction

using BlueJ. 4 Ed. Prentice Hall / Pearson Education, 2008. 3. F. Berzal. Introducción a la programación en Java. http://elvex.ugr.es/decsai/java/ 4. D. Camacho et al. Programación, Algoritmos y ejercicios resueltos en Java. 1 Ed.

Prentice Hall / Pearson Education, 2003.

1.4. Desarrollo del tema.

Documents

Transcript of 1.4. Desarrollo del tema.