Ilovepdf Merged

UNIVERSIDAD TECNOLÓGICA
EMPRESARIAL DE GUAYAQUIL
FACULTAD DE ESTUDIOS ONLINE
2
Índice
1. Introducción ...............................................................................................
2. Objetivos....................................................................................................
3. Desarrollo de unidades ..............................................................................
3.1. Unidad I: Lenguajes de Programación y Algoritmos .........................

3.1.1. Evolución de los lenguajes de programación ...................................
3.1.2. Evolución en relación a la tecnología ...............................................
3.1.3. Evolución en realación a la conceptualización .................................
3.1.3.1 Programación lineal ..........................................................................
3.1.3.2 Programación estructurada ..............................................................
3.1.3.3 Programación orientada a objetos ....................................................
3.1.4 Evolución en relación al enfoque ......................................................
Queda expresamente prohibida la reproducción total o parcial de este contenido

3.1.4.1 Programación procedural .................................................................
3.1.4.2 Programación declarativa .................................................................
3.1.4.3 Programación orientada a objetos ....................................................
3.2. Unidad II: Programación Orientada a Objetos ……… ........................

3.2.1. Introducción .................................... ¡Error! Marcador no definido.
3.2.2. Clase ................................................................................................
3.2.3. Método............................................. ¡Error! Marcador no definido.
3.2.4. Objeto ...............................................................................................
3.2.5. Variables ...........................................................................................
3.2.6. Constructores ...................................................................................
3.2.7. Sobrecarga de métodos ...................................................................
3.2.8. Encapsulamiento ..............................................................................
3.2.9. Interfaz gráfica ..................................................................................
3.2.10. Herencia ...........................................................................................
3.2.11. Sobreescritura y sobrecarga .............................................................
3.2.12. Clases abastractas e interfaces ........................................................
3.2.13. Polimorfismo .....................................................................................
3.2.14. Enlace dinámico, upcasting, downcasting ........................................
3.2.15. Clases envolventes...........................................................................
3.3. Unidad III: Manipulación de archivos, manejo de excepciones y manejo

de colecciones ................................................................................................
3.3.1. Conceptos de flujos de entrada y salida¡Error! Marcador no definido.
3.3.2. Lectura y escritura de archivos .........................................................
3.3.3. Serialización y deserialización de objetos¡Error! Marcador no
definido.
UNIVERSIDAD TECNOLÓGICA EMPRESARIAL DE GUAYAQUIL

3
3.3.4. Definición y tipos de excepciones .....................................................

3.3.5. Manejo de excepciones ....................................................................
3.3.6. Visión general del “framework” de colecciones ................................
3.3.7. Listas ................................................................................................
3.3.8. Conjuntos .........................................................................................
3.3.9. Mapas ...............................................................................................
3.4. Unidad IV: Modelamiento de datos ......................................................

3.4.1. Definiciones de modelamiento, abstracción y representación ..........
3.4.2. Lenguaje UML ..................................................................................
3.4.3. Diagramas UML de estructura y comportamiento.............................
3.4.4. Diagramas de casos de uso .............................................................
3.4.5. Diagramas de clases ........................................................................
3.4.6. Diagramas de objeto.........................................................................

3.4.7. Diagramas de secuencia ..................................................................
3.4.8. Diagramas de comunicación ............................................................
3.4.9. Diagramas de componentes .............................................................
3.4.10. Diagramas de despliegue .................................................................
3.4.11. Diagramas de paquetes ....................................................................
3.4.12. Asociaciones y herencias: carcaterísticas y propiedades .................
3.4.13. Asociaciones compuestas, compartidas y dependencia ...................
4. Estrategias metodológicas ...............................................................................

5. Formas de evaluación ......................................................................................
6. Bibliografía .......................................................................................................

4
INTRODUCCIÓN
El estudio de la Programación y Modelamiento de Datos permiten el desarrollo de

la capacidad analítica e involucra el aprendizaje para dar soluciones a las
problemáticas planteadas tanto en la vida cotidiana como profesional,
principalmente en situaciones en que la lógica e ingenio son la base para crear
soluciones desde cero con un pensamiento estructurado, lógico y creativo.

Por una parte, la programación permite crear herramientas que ayuden a satisfacer
una necesidad. Eso es lo que sucede con las aplicaciones, sitios, programas que
satisfacen una necesidad común. Por lo cual, es importante conocer los algoritmos
que establecen aquellas actividades que se van a realizar de forma coherente para
tener un resultado, es decir, consiste en ordenar una sucesión de ideas, las cuales
son plasmadas en el código con el objetivo de dar una solución.
Por otra, la etapa del modelado es tan importante y necesaria en la programación.

En particular, para la creación de programas sencillos, en la práctica algunas veces
se omite o en su defecto es poco considerada, lo que evidencia una escasa
planificación previa.
Con base en lo anterior, es tan importante el modelado porque expresa en un

lenguaje gráfico lo que se va a desarrollar y se tenga bien definido el proceso que
va a tener el programa y cuando la complejidad aumenta, el mismo debe ser más
estricto. De esta manera, se comunica lo que el sistema está desarrollando de modo
que distintos módulos puedan desarrollarse en diferentes lenguajes de
programación o inclusive un mismo sistema pueda desarrollarse en un lenguaje de
programación y luego en otro. Es por esto por lo que surge la necesidad de
prepararlos en el análisis de notación, herramientas y proceso de desarrollo.
La Unidad I, se titula LENGUAJES DE PROGRAMACIÓN Y ALGORITMOS,

relacionamos el enfoque actual de la programación frente a su continua evolución y
generamos soluciones eficientes a problemáticas planteadas a través del uso de
estrategias de diseño de algoritmos.

5
En la Unidad II, PROGRAMACIÓN ORIENTADA A OBJETOS, relacionamos las

características propias de los objetos con los de la vida real aplicando los conceptos
de abstracción y encapsulamiento de información ofreciendo soluciones eficientes.
En la Unidad III, MANIPULACIÓN DE ARCHIVOS, MANEJO DE EXCEPCIONES Y

MANEJO DE COLECCIONES, : desarrollamos programas usando archivos de
texto y binarios para almacenamiento de datos usando técnicas de serialización de
objetos y captura de excepciones y gestionarlas de forma adecuada; así como
manejo de colecciones.
Y finalmente en la Unidad IV, MODELAMIENTO DE DATOS, analizaremos los

problemas informáticos y realizaremos el diseño del software que permita
resolverlos mediante el Lenguaje Unificado de Modelado (UML).

6
2. Objetivos
Objetivo General:
Analizar y comprender desde la base teórica y práctica las metodologías de
Programación orientada a objetos y diseño de software mediante el modelado de
datos en el transcurso del tiempo.
.
Objetivos específicos:

• Comprender la evolución de los lenguajes de programación,
representaciones y sus principales ventajas frente a su continua evolución.
• Comprender las características de los objetos y sus conceptos principales
para identificar los beneficios de la programación orientada a objetos.
• Comprender las técnicas de serialización de objetos y el uso de diferentes
tipos de estructuras de datos para grandes cantidades de datos.
• Construir diagramas de clases para el diseño y documentación de un
programa orientado a objetos.

7
3. Desarrollo de unidades
3.1. Unidad I: Lenguajes de Programación y Algoritmos
3.1.1. Evolución de los Lenguajes de Programación
La evolución de los lenguajes de programación se ha desarrollado con base en

realizar programas para ordenadores cada vez más sencillos, flexibles y portables.
De hecho, esta constante evolución permite que los lenguajes de programación
sean más robustos por lo cual, permite resolver problemas más complejos.
Asimismo, los lenguajes de programación han evolucionado con respecto a:

Los avances tecnológicos
• Los avances conceptualización
• Los avances en cuanto a enfoque de la programación
3.1.2. Evolución en relación con la tecnología
Un programa de ordenador es una sucesión de instrucciones que se ejecutarán

secuencialmente, es decir, una después de otra. Por tanto, como la forma de
programarlos es introduciendo secuencias de ceros y unos (bits); por lo que, si hay
un error en las sucesiones ingresadas, que son relativamente grandes y además,
una vez cometido un error, poder encontrar y corregir el error puede convertirse en
una tarea difícil e imposible.
En ese sentido, hace muchos años atrás, los microprocesadores, se fabrican para
ser programados, no en binario (secuencia de unos y ceros), sino en hexadecimal
(un número hexadecimal equivale a 16 ceros o unos).
Cronológicamente el primer avance importante vino con la aparición de los
lenguajes ensambladores. A estos lenguajes se los denomina de "bajo nivel", ya
que se hallan estrechamente ligados a la forma de trabajo de la máquina con la que
se programa y se opera con ellos de modo muy similar a como se hace cuando se
trabaja en hexadecimal.
Un lenguaje ensamblador lo que hace es transcribir unos nemónicos (palabras
fáciles de recordar) a la secuencia ceros y unos a los que el nemónico representa y
que sí son entendibles por la máquina.
De hecho, es más fácil de recordar la segunda notación que la primera, haciéndose

el código más inteligible. El principal problema de los lenguajes ensambladores es
que se hallan fuertemente comprometidos con el hardware del computador. Un
programa escrito en lenguaje ensamblador solo podrá ser ejecutado en la máquina
donde fue diseñado.

8
El siguiente avance se dio con los lenguajes de alto nivel.

El proceso de desarrollo de una aplicación con un lenguaje de alto nivel es más
rápido, simple y, por tanto, resulta más fácil detectar y corregir errores. Esto se debe
a dos factores: (a) cada instrucción que se escribe en lenguaje de alto nivel puede
equivaler a cientos de instrucciones en lenguaje ensamblador y (b) la sintaxis de las
instrucciones y los nemónicos que se usan se parecen algo más al lenguaje
cotidiano.
Por ejemplificar, realizar un programa en un lenguaje de alto nivel puede llevar
pocos días, en contraparte, en lenguaje ensamblador es tarea de meses. Sin
embargo, se identifica una problemática que es la portabilidad.
En teoría, un lenguaje de alto nivel es independiente de la máquina donde se
ejecute, el mismo código que se escribe para una máquina puede ser traducido al
lenguaje hexadecimal en esa máquina o en otra cualquiera que disponga de
traductor para ese lenguaje.

Por ejemplo, si yo escribo un programa en lenguaje JAVA para un ordenador, este
mismo programa podría ejecutarse en cualquier otra máquina que tenga un
traductor de JAVA para ella.
3.1.3. Evolución en cuanto a la conceptualización
El primer avance en metodología de programación vino con la Programación

Estructurada, algunos autores incluyen las técnicas de Programación con
Funciones -también llamado procedural, ya que ambos se hallan íntimamente
relacionados.
La programación en ensamblador es lineal, es decir, las instrucciones se ejecutan
en el mismo orden en que se escriben. Podemos, sin embargo, ese orden puede
ser alterado, mediante saltos desde una instrucción a otro lugar del programa
distinto a la instrucción que le sigue a la que se estaba procesando.
Este sistema de trabajo es complicado, dado que, el programador se pierde con
facilidad porque debe ir saltando continuamente a ciertas parte de código.
3.1.3.1 Programación Lineal
Cada línea de programa debe ir precedida de un identificador (una etiqueta, en el

ejemplo están numeradas las instrucciones) para poder referenciarla, para este
ejemplo se han utilizado números, aunque podría utilizarse cualquier otro
identificador:
1. Variable igual a 0
2. Sumar 1 a esa variable
3. Mostrar la variable
4. Si la variable es 100 -> terminar, Si_no -> saltar a 1:
3.1.3.1 Programación Estructurada

9
En la programación estructurada, un programa no debe tener saltos, no es una

buena práctica. Por ejemplo, GOTO <número línea>, lo que no es conveniente si se
requiere un programa que pueda ser ejecutado de forma rápida y clara.
De hecho, cuando el traductor (ya sea intérprete o compilador) cambia el programa
a código máquina, lo convierte a estilo lineal.
Para evitar esto, junto con la programación estructurada aparece un concepto que
permite abarcar programas más amplios con menor esfuerzo: el de función.
Por ejemplificar, un proceso que se repite y en los que sólo cambia algún factor, si
se trata ese proceso como un subprograma al que llama cada vez que lo necesita,
y cada vez que lo llama puede cambiar ese factor, estará reduciendo el margen de
error, al reducir el número de líneas que necesita en el programa, ya que no tiene
que repetir todas esas líneas cada vez que quiera realizar el proceso, con una sola
línea de llamada al subprograma será suficiente; además, de haber algún fallo en
este proceso el error queda en el código de la función.

Así, las funciones reciben y devuelven valores. Simultáneamente al concepto de
función aparece el de variables de ámbito reducido que con un lenguaje
estructurado, las variables son conocidas solo por aquellas partes del programa
donde se programa y que se usen en ámbitos diferentes.
3.1.3.1 Programación Orientada a Objetos
La Programación Orientada a Objetos (POO) ofrece mayor dominio sobre el

programa. Lo analizado hasta este punto, el control del programa era tarea del
programador y tenía que controlar y mantener en su mente cada proceso que se
realizaba y los efectos que pudieran suceder entre distintos procesos, lo que se
denomina colisiones. Esto es posible porque los objetos impiden interactuar sus
datos con otros métodos distintos a los propios.
En programación estructurada, una función trabaja sobre unos datos, y no debería
modificar datos que no le corresponde hacer, pero de eso tiene que encargarse el
programador, en POO es el propio sistema el que impide que esto ocurra. Además,
la reusabilidad del código escrito es mayor que con el uso de funciones e incrementa
la probabilidad.
3.1.4. Evolución en relación con el enfoque
La evolución de los lenguajes de programación, en cuanto a enfoque es también

una evolución conceptual, pero ésta es tan profunda que supone un cambio drástico
en cuanto al modo de concebir el tratamiento de la programación.
En este sentido, y dependiendo del autor a quien se consulte, existen dos o tres
enfoques diferentes:

10
• Programación procedural
• Programación declarativa
• Programación orientada a objetos
3.1.4.1 Programación Procedural
También es conocido como programación modular o programación funcional. La

mayor parte de los lenguajes que se conocen en la actualidad, trabajan de forma
procedural como Java, C, Pascal, BASIC, Cobol, Fortran, APL, entre otros.
Involucra desarrollar un procedimiento que realice una tarea específica y cualquier
dato que el procedimiento necesite usar es gestionado por medio de sus
parámetros.
En ese sentido, el procedimiento puede ver y cambiar el dato recibido, y

opcionalmente devolver un valor al código que lo invocó.
En resumen:
• Los datos y las acciones para realizar sobre ellos son diferentes.
• Los datos que operan sobre los métodos se definen por separado.
Figura 1. Ejemplo de programa procedural
3.1.4.2 Programación Declarativa
La Programación Declarativa, no determina el “cómo”, sino que funciona a un nivel

de abstracción muy alto para programar.
Por su contraparte, la Programación Imperativa determina el “cómo”, es decir cuáles

son los pasos en específico para dar solución a un problema.
.
3.1.4.2 Programación Orientación a Objetos
Algunos autores incluyen la Programación Orientada a Objetos como un nuevo

enfoque porque incluye un conjunto de técnicas. Sin embargo, una técnica no es un
lenguaje de programación por lo que otros autores no concuerdan en incluirla como
un nuevo enfoque.

11
Dicho lo anterior, para aplicar la Programación Orientada a objetos, es necesario

que el lenguaje proporcione una serie de mecanismos inherentes al propio lenguaje.
En definitiva, la Programación Orientada a objetos es casi 100% procedural y es

imperativa.
3.1.5. Introducción a Algoritmos
Es importante, primero considerar la definición de la palabra problema, que es lo

que se intenta dar solución a través de los algoritmos. Según el Diccionario de Real
Academia de la Lengua Española (RAE) lo define como “Planteamiento de una
situación cuya respuesta desconocida debe obtenerse a través de métodos
científicos”.

Entonces, un problema, se puede definir como una situación en la cual se trata de
alcanzar un objetivo utilizando una o diversas estrategias de solución.
Es importante mencionar, que un problema puede ser complejo y según eso puede
considerar dividirse en subproblemas para encontrar la solución al mismo.
3.1.6. Definición
Es un conjunto de instrucciones ordenadas, definidas y finitas para resolver un

problema, realizar un cálculo o desarrollar una tarea. En otras palabras, un algoritmo
es un procedimiento paso a paso para conseguir un objetivo que es dar solución a
una problemática dada.
Inicia con un estado e información, se siguen una serie de pasos ordenados para
llegar a la solución de una situación.
Los pasos para la resolución de un problema son:
1. Diseño del algoritmo: describe la secuencia ordenada de pasos que conducen a

la solución de un problema. (Análisis del problema y desarrollo del algoritmo.)
2. Expresar el algoritmo como un programa en un lenguaje de programación
adecuado. (Fase de desarrollo.)
3. Ejecución y validación del programa por la computadora.
Es importante recordar que, para realizar un programa, primero es necesario el

diseño previo de un algoritmo, por lo cual, se concluye que el algoritmo debe existir
para que a partir del mismo pueda desarrollarse un programa.
3.1.7. Algoritmos no relacionados a la informática
Los algoritmos son independientes tanto del lenguaje de programación en que se

expresan y de la computadora que los ejecuta. El algoritmo se puede expresar en

12
un lenguaje diferente de programación y ejecutarse en una computadora distinta;

sin embargo, el algoritmo será siempre el mismo.
Así, por ejemplo, en una analogía con la vida diaria, una receta de un plato de cocina
se puede expresar en español, inglés o francés, pero cualquiera que sea el lenguaje,
los pasos para la elaboración del plato se realizarán sin importar el idioma del
cocinero.

Esta foto de Autor desconocido está
bajo licencia CC BY-SA-NC
Figura 2. Ejemplo de cocina
En la ciencia de la computación y en la programación, los algoritmos son más

importantes que los lenguajes de programación o las computadoras. Un lenguaje
de programación es tan sólo un medio para expresar un algoritmo y una
computadora es sólo un procesador para ejecutarlo. Tanto el lenguaje de
programación como la computadora son los medios para obtener un fin: conseguir
que el algoritmo se ejecute y se efectúe el proceso correspondiente.
Dada la importancia del algoritmo en la ciencia de la computación, un aspecto
relevante será el diseño de algoritmos.
3.1.8. Objetivos
En las ciencias de la computación y Programación, los algoritmos son más

importantes que los lenguajes de programación o las computadoras, por su aporte
inicial en el desarrollo de un sistema o software para solucionar una problemática.
Un lenguaje de programación es un medio para expresar un algoritmo y una
computadora es un procesador para ejecutarlo, es decir, permite conseguir que el
algoritmo se ejecute y efectúe el proceso correspondiente.
Las características fundamentales que debe cumplir todo algoritmo son:

• Un algoritmo debe ser preciso e indicar el orden de realización de cada
paso.

13
• Un algoritmo debe estar definido. Si se sigue un algoritmo dos veces, se

debe obtener el mismo resultado cada vez.
• Un algoritmo debe ser finito. Si se sigue un algoritmo, se debe terminar
en algún momento; o sea, debe tener un número finito de pasos.
La definición de un algoritmo debe describir tres partes: Entrada, Proceso y Salida.
3.1.9. Representaciones
Los Algoritmos se pueden expresar de diversas formas, sin embargo, se destacan

2 formas, que son las más usadas como Pseudocódigo y Diagrama de Flujo.
En Pseudocódigo la secuencia de instrucciones se representa por medio de frases

o proposiciones, mientras que en un Diagrama de Flujo se representa por medio de
gráficos.
Los diagramas de flujo utilizan símbolos geométricos para cada uno de los pasos
que integran el algoritmo. Permite de manera gráfica ilustrar la secuencia de
operaciones que se realizan para resolver un problema.
Los símbolos más utilizados son: inicio y fin del diagrama, actividad, decisión, las
flechas indican la dirección del flujo, el siguiente símbolo la entrada de datos,
también hay un conector para unir el flujo a otra parte del diagrama y por último, el
de impresión o desplegado de información.
Figura 3. Símbolos de Diagrama de Flujo

3.1.10. Pseudocódigo
El pseudocódigo está compuesto por proposiciones no formales en español que

expresan en detalle las instrucciones que inician con el problema hasta su solución.
De hecho, los algoritmos pueden descomponerse en varios subproblemas y la
cantidad de subproblemas depende de la complejidad del problema.

14
Figura 4. Equivalencia de representación entre Diagrama de Flujo y Pseudocódigo
Ejemplo.

Realizar la suma de todos los números pares entre 2 y 1.000.
El problema consiste en sumar 2 + 4 + 6 + 8 ... + 1.000. Se utilizarán las palabras

SUMA y NUMERO (variables, serán denominadas más tarde) para representar las
sumas sucesivas (2+4), (2+4+6), (2+4+6+8), entre otros.
La solución se puede escribir con el siguiente algoritmo:

1. Inicio.
2. Asignar SUMA a 0.
3. Asignar NUMERO a 2.
1. Sumar NUMERO a SUMA. El resultado será el nuevo valor de la suma
(SUMA).
4. Incrementar NUMERO en 2 unidades.
5. Si NUMERO <= 1.000 ir al paso 4; caso contrario, escribir el último valor de
SUMA y terminar el proceso.
6. Fin.
3.2. Unidad II: Programación Orientada a Objetos
3.2.1. Introducción.
Define los programas en términos de “clases de objetos”, objetos que son entidades
que combinan estado (propiedades o datos), comportamiento (procedimientos o
métodos) e identidad (propiedad del objeto que lo diferencia del resto).
Otros autores, definen a la Programación Orientada a objetos en términos de
técnicas que permiten llevar los problemas del mundo real a un sistema informático
con el objetivo de solucionarlos.
Entre las características relevantes de la POO se encuentran: abstracción,
modularidad, encapsulación, herencia y polimorfismo.

15
3.2.2. Clase
Es un molde del que luego se pueden crear múltiples objetos, con similares
características.
Es una plantilla (molde), que define atributos (variables) y métodos (funciones).
Define los atributos y métodos comunes a los objetos de ese tipo, pero luego, cada
objeto tendrá sus propios valores y compartirán las mismas funciones.
La estructura de una clase es:

class [nombre de la clase] {
[atributos o variables de la clase]

[métodos o funciones de la clase]
[main]
}
Contiene:
• Conjunto de atributos comunes: Son privados no accesibles desde afuera
(características).
• Estructura de datos
• Comportamiento por medio de métodos: Son privados o públicos
(comportamiento).
Figura 1. Ejemplo de Clase

3.2.3. Método
Es la parte del objeto que lleva a cabo las operaciones sobre los atributos definidos
para ese objeto.
El objetivo principal es que el objeto agrupar en una sola entidad los datos y las
operaciones y para acceder a los datos privados del objeto se debe utilizar los
métodos que hay definidos para ese objeto.

16
La única forma de gestionar la información del objeto es a través de sus métodos,

es decir, si se requiere conocer el valor de algún atributo, se tiene que utilizar el
método que muestre el valor de ese atributo.
De esta forma, se evita que métodos externos puedan alterar los datos del objeto
de manera inadecuada. Otra forma, de expresarlo es que los datos y los métodos
están encapsulados dentro del objeto.

Figura 2. Representación de método
3.2.4. Objeto
Es un conjunto de variables (o datos) y métodos (o funciones) que están

relacionados entre sí, es decir, tienen algo en común.
Los objetos en programación se usan para modelar objetos o entidades del mundo
real.
Ejemplos:

17
Figura 3. Representación de método

En definitiva, un objeto es la representación en un programa de un concepto, y
contiene toda la información necesaria para abstraerlo (datos que describen sus
atributos y operaciones que pueden realizarse sobre los mismos).
3.2.5. Variables
Una variable en Java es un identificador que representa un espacio de memoria que

contiene información. La información es del tipo con que se declaró la variable.
Hay 2 categorías de tipos para variables, los tipos primitivos (como int, short, byte,
long, char, boolen y double) y las referencias a objetos (como String, Array y otros
objetos).
Java tiene tres tipos de variables:

• De instancia
• De clase
• Locales
• Las variables de instancia: permiten guardar los atributos de un objeto
particular.
• Las variables de clase: permiten guardan el mismo valor, para todos los
objetos de una clase determinada.
• Las variables locales: se utilizan dentro de los métodos, en Java, las variables
locales pueden declararse en el momento en que serán utilizadas, y una
buena práctica es inicializar las variables al momento de declararlas.
3.2.6. Constructores
Un constructor en POO es un conjunto de instrucciones diseñado para inicializar

una instancia de un objeto.

18
Pueden pasar parámetros a un constructor, de la misma forma que en una función.
Sintaxis
<modificador> <nombre_clase> (<argumentos>)

{
<instrucciones>
}
El nombre del constructor deber ser igual que el de la clase. Por lo cual, se diferencia
entre los diferentes constructores que se puede tener en la clase con los otros
métodos.
Los modificadores son los mismo que el de las funciones. Así, para los constructores

se pueden tener modificadores como public, private, y protected.
Los <argumentos> tiene las mismas consideraciones usadas en las funciones,

poniendo su tipo de datos y el nombre del argumento a usar.
Cada clase tiene como mínimo un constructor. Si no se escribe un constructor en el

código fuente, el lenguaje de programación ofrece uno. Este constructor no tiene
parámetros y tiene un cuerpo vacío, es decir, no tiene instrucciones.
Por defecto, el constructor se habilita cuando se crean instancias de los objetos pero
si se especifica un constructor, el constructor por defecto ya no se aplica.
Si todos los constructores tienen parámetros y se hace una llamada a la clase sin
argumentos, no se espera que el constructor por defecto se ejecute, porque se ha
perdido. Así que causaría en error de compilación.
3.2.7. Sobrecarga de métodos
La sobrecarga de Métodos está dada por métodos y constructores, los destructores

no se pueden sobrecargar ya que sólo debe haber uno por clase.
La sobrecarga de métodos hace que un mismo nombre pueda representar distintos

métodos con distinto tipo y número de parámetros, manejados dentro de la misma
clase. En el ámbito de la POO, la sobrecarga de métodos se refiere a la posibilidad
de tener dos o más métodos con el mismo nombre, pero distinta funcionalidad. Es
decir, dos o más métodos con el mismo nombre realizan acciones diferentes y el
compilador usará una u otra dependiendo de los parámetros usados. Esto también
se aplica a los constructores.
Se pueden diferenciar varios métodos sobrecargados a través de sus parámetros,

ya sea por la cantidad, el tipo o el orden de los mismos.

19
Una clase puede tener distinto comportamiento dependiendo de cual método

sobrecargado se use, a esta característica se le conoce como Polimorfismo por
sobrecarga. La palabra Polimorfismo viene de la capacidad que tiene una clase de
cambiar su comportamiento. En el caso del polimorfismo por sobrecarga, el cambio
del comportamiento de una clase se define sobrecargando los métodos necesarios
para lograr el polimorfismo.
3.2.8. Encapsulamiento
El encapsulamiento es utilizado para ocultar detalles no relevantes de otros objetos.

El encapsulamiento provee los siguientes beneficios.
• Modularidad: el código fuente de un objeto puede ser escrito, así como darle

mantenimiento, independientemente del código fuente de otros objetos. Así
mismo, un objeto puede ser utilizado en otras partes del código sin alterar su
estado y conducta.
• Ocultamiento de la información: un objeto tiene una interfaz pública que otros
objetos pueden utilizar para comunicarse con él. Pero el objeto puede
mantener información y métodos privados.
Los objetos proveen el beneficio de la modularidad y el ocultamiento de la

información. Las clases proveen el beneficio de la reutilización. Los programadores
de software utilizan la misma clase y por lo tanto el mismo código para crear objetos.
En las implementaciones orientadas a objetos se percibe un objeto como un

paquete de datos y procedimientos que se pueden llevar a cabo con estos datos.
Esto encapsula los datos y los procedimientos.
Por otra parte, los atributos son variables comunes en cada objeto de una clase y
cada uno de ellos puede tener un valor asociado, para cada variable, diferente al
que tienen para esa misma variable los demás objetos.
Los métodos, por su parte, pertenecen a la clase y no se almacenan en cada objeto

garantizando la reutilización de código.
3.2.9. Interfaz gráfica
Los lenguajes de programación permiten trabajar con librerías para las interfaces
gráficas de usuario (GUI): AWT y Swing, como ventanas, cuadros de diálogo, barras
de herramientas, botones, listas desplegables y otros elementos que ya hemos
usado.
Las aplicaciones son conducidas por eventos y se desarrollan haciendo uso de las
clases que para ello nos ofrece el API de Java.

20
Interfaz gráfica se refiere a la posibilidad de crear ventanas, botones, menús, entre

otros. Es decir, representa la información de un programa a través de estas
características, consiste en brindar un entorno visual.

Figura 4. Diagrama de Interfaz gráfica
En el caso de AWT, la creación, visualización y gestión de los elementos gráficos

depende del sistema operativo, quien gestiona la interacción sobre los elementos.
En el caso de Swing, es Java quien visualiza y gestiona la interacción del usuario

sobre los elementos de la interfaz gráfica.
Figura 5. Componentes de Interfaz gráfica diferentes por sistema operativo
Existen clases en AWT como en Swing que tienen la misma finalidad. Por ejemplo,
en ambas librerías se tiene una clase para crear ventana Frame en el caso de AWT
y JFrame en el caso de Swing, su nombre empieza por J.

21
Figura 6. Componentes de Interfaz gráfica AWT

3.2.10. Herencia
Es una propiedad que permite que los objetos sean creados a partir de otros ya
existentes, obteniendo características (métodos y atributos) similares a los ya
existentes.
Es la relación entre una clase general y otra clase más específica.

Es un mecanismo que permite crear clases derivadas a partir de clase padre o
superclase, que permite compartir automáticamente métodos y datos entre clases
subclases y objetos.
Figura 7. Representación de herencia
3.2.11. Sobreescritura y sobrecarga
Java por ser un lenguaje orientado a objetos permite la sobrecarga y sobreescritura

de métodos.
En Java sobrecargar un método es tener dos o más métodos con el mismo nombre,
pero con diferentes tipos de parámetros u operaciones, es tarea del compilador

22
saber usar un método u el otro dependiendo del tipo de dato que se le pase como
parámetro.
Por otro lado, se tiene la sobreescritura de métodos, que está relacionada con la
herencia de clases en Java. Por lo cual, una subclase hereda todos los métodos de
su clase padre, estos métodos son accesibles a dicha subclase a menos que la
subclase sobrescriba los métodos.
Ene se sentido, se establece que una subclase está sobrescribiendo un método de

su clase padre cuando esta defina un método con las mismas características que el
método de la superclase, para lo cual, la estructura del método , debe ser igual a la
estructura de la superclase, debe tener el mismo nombre y debe retornar el mismo
tipo de dato y no podrá tener un tipo de acceso más restrictivo que el original.

Figura 8. Ejemplo de sobrecarga y sobreescritura
3.2.12. Clases abstractas e interfaces
Las clases abstractas son aquellas que no se pueden identificar con algo
'específico', porque no existen en el mundo real, pero sí poseen determinadas
características que son comunes en otras clases que pueden ser creadas a partir
de ellas.
Para comprender mejor, un ejemplo de clase abstracta sería una clase llamada
Vehículo: todos ellos realizan acciones similares como arrancar, acelerar, frenar,
entre otros.
Sin embargo, existen muchos tipos de carros que son diferentes y que se comportan
de forma totalmente distinta, por ejemplo: el proceso de arrancar no se realiza
siguiendo los mismos pasos, unos tienen que despegar y volar como los aviones.
Es decir, en el mundo real no existe un objeto 'vehículo' como tal, sino que hay
diferentes tipos de vehículo, pero, aunque poseen características comunes o

23
similares y realizan las mismas acciones lo hacen de forma muy diferente y ciertas
acciones específicas según su tipo.
Conviene subrayar que una clase abstracta no representa algo concreto, por lo cual,
no puede ser instanciada, no se puede crear un objeto a partir de ella, pero sí es
posible crear otras clases en base a su definición.
Interfaz
La interfaz define un conjunto de métodos y una clase de objetos puede implementar

una o varias interfaces.
Por mencionar:
La interfaz Volante ofrece los métodos:
•

Girar a la izquierda
• Girar a la derecha
La interfaz PedalAcelerador ofrece los métodos:
• Pisar acelerador
• Sin Acelerador
La clase Carro implementa las interfaces Volante y PedalAcelerador.
3.2.13. Enlace dinámico, upcasting, downcasting
Enlace dinámico
El enlace dinámico es un mecanismo por el cual se escoge, en tiempo de ejecución,

el método que responderá a un determinado mensaje con base en el tipo de valor
que contiene la variable en tiempo de ejecución. Es útil cuando este no puede ser
determinado de forma estática, es decir, en tiempo de compilación.
Upcasting y Downcasting
Upcasting es casting a un supertipo, mientras que downcasting es casting a un

subtipo. Upcasting siempre está permitido sin necesidad de realizar alguna
especificación explícitamente, pero downcasting implica una comprobación de tipo
y puede lanzar un ClassCastException, para lo cual, se puede usar el operador
instanceof para verificar el tipo de tiempo de ejecución del objeto antes de realizar
el cast, lo que le permite evitar ClassCastException.
3.2.13. Polimorfismo

24
Se refiere a la posibilidad de definir clases diferentes que tienen métodos o atributos

denominados de forma idéntica, pero que se comportan de manera distinta.
La palabra polimorfismo proviene del griego "polys" (muchos) y "morfo" (forma), y
quiere decir "cualidad de tener muchas formas".
El concepto de polimorfismo se puede aplicar tanto a funciones como a tipos de
datos. Así nacen los conceptos de funciones y tipos polimórficos. Las primeras son
aquellas funciones que pueden evaluarse o ser aplicadas a diferentes tipos de datos
de forma indistinta; los tipos polimórficos, por su parte, son aquellos tipos de datos
que contienen al menos un elemento cuyo tipo no está especificado.
Ejemplo: saludo entre dos personas. Puedes pensar entonces en la clase llamada
Persona y cada persona tiene la habilidad de hablar. Pero como sucede en la vida
real, las personas pueden hablar diferentes idiomas. Entonces, se tendrá un método
llamado saludo.

Una persona que habla inglés saludará a otra que habla español. Es exactamente
el mismo método “saludar”, pero el resultado es diferente. Por eso, se requiere
métodos que tengan nombres iguales, pero comportamientos diferentes.
Hi
Hola
Figura 9. Ejemplo de Polimorfismo
3.2.14. Clases envolventes
Se tienen las clases envolventes que tienen dos principales funciones en java:
• Proveen un mecanismo para envolver valores primitivos en un objeto, de esta

manera pueden tener actividades que son reservados solo para los objetos.
Por ejemplo: ser agregados a una colección.

25
• Proveen útiles funciones para realizar conversiones: a cadena, cambiar de

base numérica (octal, hexadecimal), u otros tipos primitivos.
Existe para cada tipo primitivo una clase envolvente, nombrada igual que su dato
primitivo pero su nombre empieza con mayúscula.
3.3. Unidad III: Manipulación de archivos, manejo de excepciones y manejo de

colecciones
3.3.1. Conceptos de flujos de entrada y salida.

Un flujo(stream) es un conjunto de datos de una fuente o de un destino.
Un origen de datos inicia con flujos de datos, también llamado flujo de entrada (input
stream). Un destino de flujo termina con información de datos, también llamado flujo
de salida (output stream).
El origen y el destino de ambos son nodos de flujo (node streams). Los tipos de
nodo de flujos son:
• Archivos
• Memoria
• Sockets
• Tuberías (pipes) entre hilos
• Procesos
La tecnología Java es compatible con dos tipos de flujos: caracteres y byte.

• Entrada y salida de caracteres de datos está a cargo de writer and
Reader.
• Entrada y salida de bytes de datos está a cargo de OutputStream and
InputStream.

26

Figura 1. Clases para la gestión de archivos y directorios
Figura 2. Clases InputStream y OutputStream
3.3.2. Lectura y escritura de archivos
La clase java.io.File encapsula el acceso a la información acerca del archivo o

directorio dentro del sistema de archivos, en el que se obtienen información de
atributos acerca de un archivo, listar las entradas de un directorio y rendimiento
básico de operaciones del sistema de archivos como eliminar un archivo o crear un
directorio.

27
La clase File gestiona algunas tareas, no provee directamente el acceso de la

lectura‐escritura de datos. Esta última fase se especializa en los streams para este
propósito.
Files and File I/O
• Creación de los objetos File

• Gestionar objectos File
• Leer y escribir flujos en los archivos
Creación un nuevo objecto File

La clase File provee:
• File miArchivo;
• miArchivo = new File(“archivo.txt”);
• miArchivo = new File(“MisDocs”, “archivo.txt”);

Los directorios son tratados tal como archivos en Java. La clase File soporta
métodos para recuperar un arreglo de archivo en el directorio, como se muestra a
continuación:
File miDir = new File(“MiDocs”);

miArchivo = new File(miDir, “archivo.txt”);
Información de File:
• String getName()
• String getPath()
• String getAbsolutePath()
• String getParent()
• long lastModified()
• long length()
Modificación de File:
• boolean renameTo(File newName)
• Boolean delete()
Directorio:
• Boolean mkdir()
• String[] list()
Stream - Byte Streams - Character Streams

• Flujo Origen - InputStream - Reader
• Flujo Destino - OutPutStream - Writer
Tres métodos básicos de read (en InputStream) son:

• int read()

28
• int read(byte[] buffer)

• int read(byte[] buffer, int offset, int length)
Otros métodos incluidos son:

• void close()
• int available()
• long skip(long n)
• boolean markSupported()
• void mark(int readlimit)
• void reset()
3.3.3. Serialización y deserialización de objetos
Java facilita el almacenamiento y transmisión del estado de un objeto mediante un

mecanismo conocido con el nombre de serialización.
La serialización de un objeto consiste en generar una secuencia de bytes para su
almacenamiento o transmisión. Posteriormente, mediante la deserialización,
devuelve el estado original del objeto y el mismo se puede reconstruir.
Para que un objeto sea serializable, ha de implementar la interfaz
java.io.Serializable (marcar el objeto como serializable).
import java.io.Serializable;
import java.util.Date;
public class Contacto implements Serializable
{
private String nombre;
private String telefono;
private String email;
private String direccion;
private Date nacimiento;
private int grupo;
private double deuda;
…
}
Para que un objeto sea serializable, todas sus variables de instancia deben ser
serializables. De hecho, todos los tipos primitivos en Java son serializables por
defecto.
3.3.4. Definición y tipo de excepciones

29
Las excepciones son situaciones no esperadas que pueden ocurrir durante la

ejecución de las aplicaciones, como, por ejemplo, acceder a una posición de un
arreglo fuera de rango o posición.
Java proporciona un mecanismo de gestión de excepciones en los casos en los que

se puedan gestionar. De hecho, la definición de excepciones propias se hace a
través del mecanismo de extensión de clases, la Herencia.
Java representa las excepciones como clases y existe una jerarquía de clases que
representan errores en Java.

Figura 3. Jerarquía de clases de excepciones Java
3.3.5. Manejo de excepciones
Java proporciona un mecanismo para la gestión de excepciones: los bloques

try...catch[...finally (opcional)].
try{
FileReader fichero = new FileReader("nombre del fichero");
} catch (FileNotFoundException e) {
e.printStackTrace();
}
3.3.6. Visión general del "framework" de colecciones
El Java Framework Collections (JCF) o por su traducción al español, Estructura de

colecciones de Java, es un conjunto de clases e interfaces que contribuyen a las
capacidades del lenguaje en relación con las estructuras de datos.

30
Es decir, dichas colecciones no forman parte del lenguaje en sí, sino que son clases
definidas en el paquete java.util. Para crear una colección usaremos la siguiente
estructura:
Coleccion<Clase> nombre = new Coleccion<Clase>();
Donde Coleccion es una clase de este framework que queramos utilizar según la
estructura de almacenamiento que nos interese y Clase representa el tipo de datos
a almacenar.
Hay tres tipos de colecciones: Listas, Conjuntos y mapas.

3.3.7. Listas
Listas: estructura secuencial, donde cada elemento tiene un índice o posición. Se

utiliza la interfaz List<E>. Se puede utilizar las siguientes implementaciones:
• ArrayList<E> (acceso rápido),
• LinkedList<E>(inserciones/borrado rápidas),
• Stack<E> (pila), Vector<E> (obsoleto)
3.3.8. Conjuntos
Conjunto: los elementos no siguen un orden y no se permiten duplicados. Se define
la interfaz Set<E>. Se peude utilizar las siguientes implementaciones:
• HashSet<E> (implementación con tabla hash).
• LinkedHashSet<E> (tabla hash +doble lista enlazada)
• TreeSet<E> (implementación con árbol)
3.3.9. Mapas
Diccionario o Matriz asociativa: cada elemento tiene asociado una clave que se
usa para recuperarlo. Se utiliza la interfaz Map<K,V> y se pueden utilizar las
siguientes implementaciones:
• HashMap<K,V>
• TreeMap<K,V>
• LinkedHashMap<K,V>

31

Figura 4. Diagrama de flujo – manejo de colecciones
Unidad IV: Modelamiento de datos
3.4.1. Definiciones de modelamiento, abstracción y representación.
La ingeniería software debe basarse en el modelado como una parte fundamental

de todas las actividades que conducen a la producción de software de calidad.
¿Qué es un modelo?
“Es una simplificación de la realidad”. Proporciona los planos de un sistema,
incluyendo aquellos elementos que tienen gran influencia y omite aquellos que no
son relevantes para el nivel de abstracción dado.
Tipos de modelo:
• Modelo Estructural: Destaca la organización del sistema software.
• Modelo de Comportamiento: Resalta la dinámica del software.
Objetivos:
• Visualizar qué y cómo será el software.
• Especificar la estructura o el comportamiento de un sistema.
• Proporcionar una guía para el desarrollo del software.

32
• Documentar las decisiones adoptadas.
Abstracción
La abstracción es un principio muy importante en el modelado. Consiste en tener en
cuenta únicamente las propiedades pertinentes de un objeto para un problema
concreto. Los objetos utilizados en UML son abstracciones del mundo real.
Ejemplo:

Figura 1. Ejemplo abstracción.
Representación
Existen dos clasificaciones de diagramas:

• Diagramas estructurales
• Diagramas de comportamiento.
Todos los diagramas UML están contenidos en esta clasificación.
3.4.2. Lenguaje UML
UML (Unified Modeling Language) es un lenguaje que permite modelar, construir y

documentar los elementos que forman un sistema software orientado a objetos. De
hecho, se ha convertido en un estándar.
3.4.3 Diagramas UML de estructura y comportamiento
Según su clasificación.

33

Figura 2. Tipos de diagramas UML
3.4.4. Diagramas de caso de uso
Es un tipo de diagrama de comportamiento y muestra una descripción secuencial

de acciones que el software ejecuta y que tiene es ejecutada por un actor en
específico.
Es decir, permite visualizar los diferentes tipos de roles en un sistema y cómo esos
roles interactúan con el sistema.
Los diagramas de caso de uso consisten en 4 objetos.
• Actor
• Caso de uso
• Sistema
• Paquete
Actor
El actor en un diagrama de caso de uso que representa a cualquier entidad que
desempeñe un papel en un sistema determinado. Puede ser una persona, una
organización o un sistema externo.

34
Caso de uso
Un caso de uso representa una función o una acción dentro del sistema. Está
dibujado como un óvalo y nombrado con la función.
Sistema
El sistema se utiliza para definir el alcance del caso de uso y se dibuja como un
rectángulo. Este es un elemento opcional.
Paquete
El paquete es otro elemento opcional que es extremadamente útil en diagramas
complejos. De manera similar a los diagramas de clase, los paquetes se utilizan
para agrupar los casos de uso.

Figura 3. Elementos del diagrama de casos de uso UML
3.4.5. Diagramas de clases
Es una descripción de un conjunto de objetos que comparten los mismos atributos,

operaciones, relaciones y semántica.
Una clase se representa mediante una caja subdividida en tres partes:

• En la superior se muestra el nombre de la clase.
• En la media: los atributos
• En la inferior: las operaciones.
Una clase puede representarse con los detalles como atributos y operaciones
suprimidos, con solo un rectángulo con el nombre de la clase.

35

Figura 4. Representación Diagrama de Clases UML
3.4.6. Diagramas de objetos
Un objeto se representa de la misma forma que una clase. En la parte superior

aparece el nombre del objeto con el nombre de la clase subrayados, según la
siguiente sintaxis:
nombre_del_objeto: nombre_de_la_clase
Puede representarse un objeto sin un nombre específico, entonces sólo aparece el

nombre de la clase.

36

Figura 4. Representación Diagrama de Objetos UML
3.4.7. Diagramas de secuencia
Un diagrama de Secuencia muestra una interacción ordenada según la secuencia

temporal de eventos. En particular, muestra los objetos participantes en la
interacción y los mensajes que intercambian ordenados según su secuencia en el
tiempo.
El eje vertical representa el tiempo, y en el eje horizontal se encuentran los objetos

y actores participantes en la interacción, sin un orden.
Cada objeto o actor tiene una línea vertical y los mensajes se representan mediante
flechas entre los distintos objetos. El tiempo está determinado de arriba hacia abajo.
Asimismo, se pueden incluir etiquetas (como descripciones de acciones) en el

margen izquierdo o en las transiciones.

37
Figura 4. Representación Diagrama de Secuencia UML
3.4.8. Diagramas de comunicación
También conocido como diagrama de colaboración. Se resalta en este diagrama,

la organización estructural de los objetos que intercambian los mensajes.

Figura 5. Representación Diagrama de Comunicación UML
3.4.9. Diagramas de componentes
Es importante mencionar que, en este diagrama, se destacan los componentes que

pertenecen al mundo real, es decir, representan un bloque de construcción al
modelar aspectos físicos de un sistema.
Una característica básica de un componente es que: “debe definir una abstracción
precisa con una interfaz bien definida y permitiendo reemplazar fácilmente los
componentes más viejos con otros más nuevos y compatibles”.
En UML todos los elementos físicos se modelan como componentes.
Figura 6. Representación Diagrama de Componentes UML
3.4.10. Diagramas de despliegue
Nodos

38
Como los componentes, los nodos también pertenecen al mundo real. Se define
como un elemento físico, que existe en tiempo de ejecución y representa un recurso
que generalmente tiene memoria y capacidad de procesamiento.
Los nodos sirven para modelar la topología del hardware sobre el que se ejecuta el
sistema.
Asimismo, un nodo puede representar un procesador o un dispositivo sobre el que
se pueden desplegar los componentes.
Un nodo debe tener un nombre asignado que lo distinga del resto de nodos.

Figura 7. Representación Diagrama de Despliegue UML
3.4.11. Diagramas de paquetes
La forma que tiene UML de agrupar elementos en subsistemas es a través del uso
de paquetes, agrupando los paquetes y formando jerarquías de paquetes. De
hecho, un sistema que no tenga necesidad de ser descompuesto en subsistemas
se puede considerar como con un único paquete.
Figura 8. Representación Diagrama de Paquetes UML
Agrupación en paquetes
Hay una serie de reglas que pueden ser de utilidad a la hora de agrupar los
diferentes elementos en paquetes.
• Conviene agrupar elementos que proporcionen un mismo servicio.
• Los elementos que se agrupen en un mismo paquete deben presentar
un alto grado de cohesión, es decir, deben estar relacionados.

39
• Los elementos que estén en diferentes paquetes deben tener poca

relación, es decir deben colaborar entre sí, lo menos posible.
3.4.12. Asociaciones y herencias: características y propiedades
Son un conjunto de enlaces, los cuales son conexiones entre objetos. La asociación
se representa con una línea continua, posiblemente dirigida, que a veces incluye
una etiqueta. A menudo, se incluyen otros elementos para indicar la multiplicidad y
roles de los objetos involucrados.

Tabla 1. Multiplicidad en las asociaciones
Figura 9. Representación de Multiplicidad - Diagrama de Clases UML
Herencia o generalización
Es la asociación de objetos representadas por clases en UML con características y

operaciones que puedan heredarse entre ellos.
Por mencionar: una radio, televisor y lavadora tienen atributos y operaciones en

común como tener un interruptor, un cable de energía eléctrica, operaciones de
encendido y apagado que los identifican como parte de la superclase
Electrodomésticos.
En la POO se define esto como herencia y en UML se denomina generalización, la

cual está representada por una línea continua que va desde la clase subordinada
hasta la clase principal o clase “padre” conectada por un rectángulo vacío.

40
Figura 10. Representación de asociación Generalización - Diagrama de Clases

UML
3.4.13 . Asociaciones compuestas, compartidas y dependencia
Es cuando un elemento independiente puede afectar a otro elemento dependiente.

Es decir, un cambio en la especificación de una clase puede afectar a otra que la
utiliza y se representa como una línea discontinua que a veces incluye una etiqueta.
Figura 10. Representación de asociación dependencia - Diagrama de Clases UML
4.Estrategias Metodológicas
La comprensión de la materia, requiere de una combinación entre la teoría y la

práctica, es por eso que, para el acompañamiento de las clases de esta materia, es
importante que los alumnos realicen un análisis continuo. Además de las clases,
talleres y controles por parte del maestro, el estudiante debe realizar un estudio
autónomo a través de aplicación a casos reales de lo aprendido.
Evaluación de aprendizaje: se realizará a través de análisis de casos,
evaluaciones periódicas, elaboración de tareas, talleres y exámenes parciales.

41
4.1. Formas de Evaluación
Primer Parcial
Componente Actividad Peso Calificación
Docencia Actividades en línea (forma no
10% 2
simultánea – Foro académico)
Actividades en línea (en tiempo real
10% 2
– Clase en vivo)
Trabajo Actividades o tareas: Talleres,
Autónomo ensayos, investigaciones, análisis 30% 6
de casos, ejercicios, etc.
Prácticas de Evaluación por unidad 20% 4

aplicación y
Evaluación Acumulativa 30% 6
experimentación
Totales 100% 20
Segundo Parcial
Componente Actividad Peso Calificación
Docencia Actividades en línea (forma no
10% 2
simultánea – Foro académico)
Actividades en línea (en tiempo real
10% 2
– Clase en vivo)
Trabajo Actividades o tareas: Talleres,
Autónomo ensayos, investigaciones, análisis 30% 6
de casos, ejercicios, etc.
Prácticas de Evaluación por unidad 10% 2
aplicación y
Evaluación final 40% 8
experimentación
Totales 100% 20
Nota mínima por asignatura para aprobar 15/20

Constancia de uso de la plataforma al menos del 75%

42
5. Bibliografía
- Deitel, Paul J. & Deitel, Harvey M. (2018). Java how to program. Early
objects. Eleventh Edition. Ediciones Pearson. New York, EEUU.
- Jimenez, C. (2015). UML Aplicaciones en Java y C++. Editorial Ra-ma.
- Vélez, J., Peña, A., Gortazar, P., Sánchez, A. (2011). Diseñar y
programar, todo es empezar: Una introducción a la Programación
Orientada a Objetos usando UML y Java. Editorial DYKINSON. Ciudad
de Madrid, España.

PROGRAMACIÓN Y MODELAMIENTO
DE DATOS
Mgs. Gabriela Montesdeoca Vásquez

AUTOR DEL CONTENIDO
Unidad I: Lenguajes de programación y algoritmos
1.1 Introducción
1.2 Evolución en relación a la tecnología
1.3 Evolución en relación a la conceptualización
1.4 Evolución en relación al enfoque
Objetivo
Comprender la evolución de los

lenguajes de programación,
representaciones y sus principales
ventajas frente a su continua
evolución.
1.1 Introducción
¿Por qué usar un lenguaje de programación?
• Hay un problema que requiere solución

• El desarrollador piensa en una solución, diseña un algoritmo, usa un
lenguaje de programación y desarrolla la solución.
1.1 Introducción
• Los lenguajes de programación son herramientas.

• Permiten desarrollar un programa para computadora.
• Dar solución a un problema dado mediante un programa.
1.1 Introducción
Los lenguajes de programación están

compuestos de un conjunto de
símbolos, reglas de sintaxis y
semántica que definen la estructura
principal del lenguaje y le dan un
significado a sus elementos y
expresiones.
1.1 Introducción
¿Cuántos lenguajes de programación hay?
Varios autores no coinciden con exactitud

en la cantidad actual de lenguajes de
programación, sin embargo, lo que si
pueden afirmar es que son innumerables
lenguajes de programación a lo largo de la
historia hasta la actualidad.
Asimismo, la evolución de los lenguajes de

programación se basa principalmente en
la necesidad de realizar programas para
ordenadores con mayor facilidad,
flexibilidad y portabilidad.
Evolución
La evolución de los lenguajes, ha sido impulsada por:
• Los avances tecnológicos

• Los avances conceptuales
• Los avances en relación con el enfoque de la programación
Avances tecnológicos
Lenguajes de alto nivel

Los lenguajes de programación de alto
nivel se caracterizan porque su estructura
semántica es muy similar a la forma como
escriben los humanos, lo que permite
codificar los algoritmos de manera más
natural, en lugar de codificarlos en el
lenguaje binario de las máquinas, o a nivel
de lenguaje ensamblador.
Lenguaje máquina
Este lenguaje se compone de un conjunto
de instrucciones que determinan acciones
que serán realizadas por la máquina. Y un
programa de computadora consiste en una
cadena de estas instrucciones de lenguaje
de máquina (más los datos).
Normalmente, estas instrucciones son
ejecutadas en memoria (alta velocidad), en
secuencia, con eventuales cambios de flujo
causados por el propio programa o
eventos externos.
Lenguaje máquina
El lenguaje máquina es específico de cada
máquina o arquitectura de la máquina,
aunque el conjunto de instrucciones
disponibles pueda ser similar entre ellas.
Lenguajes de bajo nivel

Un lenguaje de programación de bajo nivel
es el que proporciona poca o ninguna
abstracción del microprocesador de una
computadora. Consecuentemente, su
trasladado al lenguaje máquina es fácil. El
término ensamblador (del inglés
assembler)
Lenguajes de bajo nivel

se refiere a un tipo de programa
informático encargado de traducir los
nemotécnicos de un archivo fuente,
escrito en un lenguaje ensamblador, a un
archivo objeto que contiene código
máquina ejecutable directamente por la
máquina para la que se ha generado.
Conceptualización
Programación Lineal
Esta primera etapa se caracteriza por
programas muy lineales, con una sola línea
principal de ejecución, y por una clara
orientación hacia ingenieros y científicos.
En estos lenguajes no existe una
separación clara entre datos y programas,
y como mecanismo de reutilización de
código se propone la biblioteca de
funciones.
Conceptualización
Programación Estructurada
La programación estructurada se basa en
un teorema de Dijkstra que demuestra que
cualquier programa de computadora
puede escribirse con un lenguaje que
permita la ejecución secuencial de
instrucciones, la instrucción condicional y
la realización de bucles de instrucciones.
Conceptualización
Sin embargo, estos lenguajes aún no
formalizan mecanismos de protección
adecuados para evitar violaciones en los
protocolos de acceso a los datos. Tampoco
añaden ningún mecanismo de reutilización
de código distinto a las bibliotecas de
funciones.
Conceptualización
Conceptualización
Programación Orientada a Objetos
Estos lenguajes están especialmente

diseñados para adaptarse a la
descomposición orientada a objetos. Para
ello, existen mecanismos que permiten
restringir el acceso a los datos que forman
parte de los objetos.
Conceptualización
Es responsabilidad de cada objeto el

mantenimiento de sus datos, y el resto de
objetos que interaccionan con él lo hace a
través de una interfaz bien definida.
También aparece en estos lenguajes el
mecanismo de herencia que permite la
reutilización de código de una manera
controlada.
Programación Procedural
Se basa en la modularidad de los programas. Es decir, que un problema
puede dividirse en varias tareas que permitan su resolución y con esto
se disminuye la complejidad del problema a resolver.
El paradigma procedimental aporta ventajas cuando son tareas sencillas

que se pueden describir con unos pocos pasos, o cuando es importante
optimizar la velocidad de ejecución.
Programación Declarativa
La programación declarativa permite crear programas más compactos,

reutilizables y thread safe. No determina el “cómo”, sino que funciona a
un nivel de abstracción muy alto para programar.
Vs.
La programación imperativa permite especificar paso por paso. Se
especifica las variables a usar, qué bucles y sentencias, entre otros. Es
decir, se construye un programa basado en un algoritmo muy concreto
para solventar un problema.
Expresa en forma de relaciones entre objetos y responsabilidades de
cada uno.
Referencias bibliográficas
• Vélez, J., Peña, A., Gortazar, P., Sánchez, A. (2011). Diseñar y
programar, todo es empezar: Una introducción a la Programación
Orientada a Objetos usando UML y Java. Editorial DYKINSON. Ciudad
de Madrid, España.
• Deitel, Paul J. & Deitel, Harvey M. (2018). Java how to program. Early
objects. Eleventh Edition. Ediciones Pearson. New York, EEUU.
La educación es el arma más
poderosa que puedas usar
para cambiar el mundo.
Nelson Mandela
FIN DE LA CLASE 1
UNIDAD 1
PROGRAMACIÓN Y MODELAMIENTO
DE DATOS
Mgs. Gabriela Montesdeoca Vásquez

AUTOR DEL CONTENIDO
Unidad I: Lenguajes de programación y algoritmos
1.5 Introducción a Algoritmos

1.6 Definición
1.7 Algoritmos no relacionados con la Informática
1.8 Objetivos
1.9 Representaciones
Objetivo
Comprender el proceso de análisis

de problemas y diseño de algoritmo
para dar soluciones.
1.5 Introducción a Algoritmos
Para solucionar problemas se debe tener en cuenta:
• Estado inicial: objetivo a conseguir

• Recursos: elementos a utilizar
• Estado final: solución
1.6 Definición
Es el conjunto de pasos definidos, ordenados y finitos en forma lógica
que se ejecutan para llevar a cabo una actividad o resolver un
problema.
En programación, un algoritmo supone el paso previo a ponerse a
escribir el código.
1.6 Definición
Partes
Las tres partes de un algoritmo son:
Input (entrada)
Información que damos al algoritmo con la que va a trabajar para
ofrecer la solución esperada, valores de entrada.
Proceso
Conjunto de pasos para que, a partir de los datos de entrada, llegue a la
solución de la situación.
Output (salida)
Resultados, a partir de la transformación de los valores de entrada
durante el proceso.
1.6 Definición
Características
Los algoritmos presentan una serie

de características comunes.
Precisos Objetivos, sin
ambigüedad
Secuencia clara y
Ordenados
precisa
Finitos Número determinado
de pasos
Solución determinada
Concretos para la situación o
problema planteados
Mismo algoritmo debe
Definidos dar el mismo resultado
al recibir la misma
entrada.
1.6 Definición
Partes
1.6 Definición
Partes
Análisis del problema
• Leer la longitud de los dos catetos y calcular la hipotenusa.
• Teorema de Pitágoras
• Variables de entrada: cateto 1, cateto 2
• Variables de salida: hipotenusa
Diseño del algoritmo
• Leer la longitud de los catetos
• Calcular hipotenusa (En un triángulo rectángulo el cuadrado de la
hipotenusa es igual a la suma de los cuadrados de los catetos). Por lo
tanto, la hipotenusa es igual a la raíz cuadrada de la suma de los
cuadrados de los catetos.
• Mostrar la hipotenusa
1.6 Definición
Partes
Programa en Java
1.7 Algoritmos no relacionados con la Informática
Los algoritmos no son algo exclusivo en el ámbito de la Informática.
1.8 Objetivos
¿Cuál es el objetivo de un algoritmo?

• Diseñar estrategias de solución
• Resolución de problemas
• Facilitar el proceso de la escritura de un código fuente
• Complejidad temporal: Menor tiempo en resolver el problema
• Complejidad espacial: Menos memoria, necesite
• Independiente de cualquier lenguaje de programación
Los Algoritmos se puede expresar de muchas formas, pero en esta guía
se tratarán las dos formas más conocidas:
Pseudocódigo
Secuencia de instrucciones se representa por medio de frases o proposiciones. El
pseudocódigo está compuesto por proposiciones informales en español que permiten
expresar detalladamente las instrucciones que llevan desde un Estado inicial
(problema) hasta un resultado deseado (solución).
Ejemplo:
1. Se desea diseñar un algoritmo para saber si un número es
primo o no.
2. Un número es primo si sólo puede dividirse por sí mismo y
por la unidad (es decir, no tiene más divisores que él mismo
y la unidad).
3. Por ejemplo, 9, 8, 6, 4, 12, 16, 20, etc., no son primos, ya
que son divisibles por números distintos a ellos mismos y a
la unidad. Así, 9 es divisible por 3, 8 lo es por 2, etc.
4. El algoritmo de resolución del problema pasa por dividir
sucesivamente el número por 2, 3, 4, etc.
Pseudocódigo
1.Inicio.
2.Poner X igual a 2 (x = 2, x variable que representa a
los divisores del número que se busca N).
3.Dividir N por X (N/X).
4.Si el resultado de N/X es entero, entonces N es un
número primo y bifurcar al punto 7; en caso
contrario, continuar el proceso.
5. Suma 1 a X (X ← X + 1).
6. Si X es igual a N, entonces N es un número
primo; en caso contrario, bifurcar al punto 3.
7. Fin.
Diagramas de flujo
Se representa por medio de gráficos.
Los Diagramas de Flujo son una de las técnicas más
utilizadas para representar gráficamente la secuencia
de instrucciones de un Algoritmo.
Estas instrucciones están compuestas por operaciones,
decisiones lógicas y ciclos repetitivos, entre otros.
La solución de un problema puede contener varios
conjuntos de instrucciones (procedimientos o
métodos) que tienen como finalidad ejecutar cada uno
de los procesos necesarios para llegar a la solución de
un problema a partir de los datos disponibles (estado
inicial).
Diagramas de flujo
Referencias bibliográficas
• Boisgontier, H. (2020). Algoritmia. De las bases a la Programación
Orientada a Objetos en Java. Editorial Eni. Ciudad de Orsay, Francia.
• Jimenez, J., Jimenez, E. & Alvarado, L. (2014). Fundamentos de
Programación, Ed. Alfaomega, México.
La educación es el arma más
poderosa que puedas usar
para cambiar el mundo.
Nelson Mandela
FIN DE LA CLASE 2
UNIDAD 1

Ilovepdf Merged

Cargado por

Copyright:

Formatos disponibles

Ilovepdf Merged

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Ilovepdf Merged

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD TECNOLÓGICA

3.1. Unidad I: Lenguajes de Programación y Algoritmos .........................

Queda expresamente prohibida la reproducción total o parcial de este contenido

3.2. Unidad II: Programación Orientada a Objetos ……… ........................

3.3. Unidad III: Manipulación de archivos, manejo de excepciones y manejo

UNIVERSIDAD TECNOLÓGICA EMPRESARIAL DE GUAYAQUIL

3.3.4. Definición y tipos de excepciones .....................................................

3.4. Unidad IV: Modelamiento de datos ......................................................

Queda expresamente prohibida la reproducción total o parcial de este contenido

4. Estrategias metodológicas ...............................................................................

UNIVERSIDAD TECNOLÓGICA EMPRESARIAL DE GUAYAQUIL

El estudio de la Programación y Modelamiento de Datos permiten el desarrollo de

Queda expresamente prohibida la reproducción total o parcial de este contenido

Por otra, la etapa del modelado es tan importante y necesaria en la programación.

Con base en lo anterior, es tan importante el modelado porque expresa en un

La Unidad I, se titula LENGUAJES DE PROGRAMACIÓN Y ALGORITMOS,

UNIVERSIDAD TECNOLÓGICA EMPRESARIAL DE GUAYAQUIL

En la Unidad II, PROGRAMACIÓN ORIENTADA A OBJETOS, relacionamos las

En la Unidad III, MANIPULACIÓN DE ARCHIVOS, MANEJO DE EXCEPCIONES Y

Y finalmente en la Unidad IV, MODELAMIENTO DE DATOS, analizaremos los

Queda expresamente prohibida la reproducción total o parcial de este contenido

UNIVERSIDAD TECNOLÓGICA EMPRESARIAL DE GUAYAQUIL

Queda expresamente prohibida la reproducción total o parcial de este contenido

UNIVERSIDAD TECNOLÓGICA EMPRESARIAL DE GUAYAQUIL

La evolución de los lenguajes de programación se ha desarrollado con base en

Queda expresamente prohibida la reproducción total o parcial de este contenido

3.1.2. Evolución en relación con la tecnología

Un programa de ordenador es una sucesión de instrucciones que se ejecutarán

De hecho, es más fácil de recordar la segunda notación que la primera, haciéndose

UNIVERSIDAD TECNOLÓGICA EMPRESARIAL DE GUAYAQUIL

El siguiente avance se dio con los lenguajes de alto nivel.

Queda expresamente prohibida la reproducción total o parcial de este contenido

3.1.3. Evolución en cuanto a la conceptualización

El primer avance en metodología de programación vino con la Programación

3.1.3.1 Programación Lineal

Cada línea de programa debe ir precedida de un identificador (una etiqueta, en el

3.1.3.1 Programación Estructurada

UNIVERSIDAD TECNOLÓGICA EMPRESARIAL DE GUAYAQUIL

En la programación estructurada, un programa no debe tener saltos, no es una

Queda expresamente prohibida la reproducción total o parcial de este contenido

3.1.3.1 Programación Orientada a Objetos

La Programación Orientada a Objetos (POO) ofrece mayor dominio sobre el

3.1.4. Evolución en relación con el enfoque

La evolución de los lenguajes de programación, en cuanto a enfoque es también

UNIVERSIDAD TECNOLÓGICA EMPRESARIAL DE GUAYAQUIL

3.1.4.1 Programación Procedural

También es conocido como programación modular o programación funcional. La

Queda expresamente prohibida la reproducción total o parcial de este contenido

Figura 1. Ejemplo de programa procedural

3.1.4.2 Programación Declarativa

La Programación Declarativa, no determina el “cómo”, sino que funciona a un nivel

Por su contraparte, la Programación Imperativa determina el “cómo”, es decir cuáles

3.1.4.2 Programación Orientación a Objetos

Algunos autores incluyen la Programación Orientada a Objetos como un nuevo

UNIVERSIDAD TECNOLÓGICA EMPRESARIAL DE GUAYAQUIL

Dicho lo anterior, para aplicar la Programación Orientada a objetos, es necesario

En definitiva, la Programación Orientada a objetos es casi 100% procedural y es

3.1.5. Introducción a Algoritmos

Es importante, primero considerar la definición de la palabra problema, que es lo