Hermosillo, Sonora. Agosto de 2020.

Aracely Domínguez Tónix

Genaro Rodríguez Rojo
Marco Antonio López Morales
Olivia Jiménez Celis
Luis Salazar López

Elisa Sofía Valdez Alcorn

Isabel Olea Guerrero
 Directorio

Lic. Amós Benjamín Moreno Ruiz

Director General

Mtro. Jorge Alfonso Rascón Enríquez

Director Académico

Lic. Marco Octavio Hilton Reyes

Director Administrativo

Lic. Arnoldo Rafael Molina Borboa

Director de Finanzas

C.P. Genaro Gómez Carranza

Director de Planeación

Lic. Lauro Grijalva Abreu

Director de Vinculación

Lic. Artemio Guerrero Aguiar

Director del Órgano de Control
Formación Profesional Programación

18 9

4
 ESTRUCTURACIÓN Y DOSIFICACIÓN DE CONTENIDOS DEL SUBMÓDULO I
APLICA LA METODOLOGÍA ESPIRAL CON PROGRAMACIÓN ORIENTADA A
OBJETOS
Competencia de la asignatura: Desarrollar aplicaciones con base en la metodología
espiral utilizando la programación orientada a objetos.
COMPETENCIA DEL
UNIDAD TEMA COMPETENCIAS DEL SUBTEMA
1.1.1 Identifica los conceptos básicos de la
1.1 Conoce los programación orientada a objetos para la
conceptos de clases y solución de problemas reales.
objetos.
1. Identifica los 1.1.2 Identifica los conceptos de clases y
elementos del objetos para la solución de problemas
paradigma de la reales.
programación
1.2 Describe las 1.2.1 Conoce las propiedades de la
orientada a
propiedades de herencia programación orientada a objetos para el
objetos.
y polimorfismo. desarrollo de aplicaciones de una
organización.
1.2.2 Conoce el lenguaje unificado de
modelado UML para la especificación del
software.
2.1.1 Identifica los objetivos del sistema, en
2.1 Emplea las fases el desarrollo de aplicaciones de una
del modelo en espiral organización.
para el desarrollo de
software. 2.1.2 Identifica las fases del modelo en
espiral para el desarrollo de software.
2.2.1 Conoce el lenguaje orientado a
objetos (JAVA) para el desarrollo de
aplicaciones de una organización.
2. Aplica el
2.2.2 Identifica las palabras reservadas,
modelo de espiral
tipos de variables, instrucciones y sintaxis
para el desarrollo
de un lenguaje de programación orientada
de software.
2.2 Utiliza el lenguaje a objetos (JAVA) en el desarrollo de
orientado a objetos aplicaciones de una organización.
(JAVA) para el 2.2.3 Instala y maneja un entorno de
desarrollo de software. programación orientado a objetos,
mediante el uso de una herramienta de
software (Netbeans) para el desarrollo de
aplicaciones de una organización.
2.2.4 Emplea código en un lenguaje de
programación (JAVA) para la resolución de
problemas en el desarrollo de aplicaciones.

5
 3.1.1 Identifica los tipos de pruebas (de
unidad y de integración) que se le aplican al
software del sistema.
3.1 Aplica las pruebas al
software y los métodos 3.1.2 Aplica las pruebas de unidad e
3. Aplica las de implementación del integración al software del sistema en la
pruebas, sistema en la solución solución de problemas reales.
implementa, de problemas reales.
documenta y da 3.1.3 Aplica los métodos de
mantenimiento a implementación del sistema de información
las aplicaciones para la solución de problemas reales.
desarrolladas para 3.2 Genera la 3.2.1 Elabora el Manual técnico y de
la solución de documentación y aplica usuario del sistema en el desarrollo de
problemas. mantenimiento a las aplicaciones en una organización.
aplicaciones 3.2.2 Aplica el mantenimiento a las
desarrolladas en la aplicaciones realizadas en la solución de
solución de problemas problemas reales.
reales.

6
 INTRODUCCIÓN
El presente libro, de la especialidad de programación, denominado Aplica la metodología espiral
con programación orientada a objetos, tiene como propósito desarrollar aplicaciones con base
en la metodología en espiral utilizando la programación orientada a través de un lenguaje de
programación orientado a objetos, para poder así generar el desarrollo de aplicaciones en una
organización.
Este libro es de gran utilidad en tu proceso de aprendizaje, contiene actividades que deberás
realizar de manera individual mientras que, en algunas otras, colaborarás con otros compañeros
formando equipos de trabajo bajo la guía de tu profesor, las cuales serán evaluadas de manera
sumativa. No abarca todos los temas, pero si los principales, por lo que se requiere, consultar
otras fuentes de información para una mayor profundidad de cada uno de ellos.
El libro está estructurado en tres unidades, en la primera unidad se describen los elementos del
paradigma de la programación orientada a objetos, se analizan que es este paradigma, cual ha
sido su evolución, así como los conceptos principales para su aplicación tales como objetos y
clases y las características de estos.
La unidad dos contempla 2 temas principales, la primera de ellas referente al modelo en espiral
para el desarrollo de sistemas y sus generalidades y la segunda al Desarrollo de Software de
aplicación mediante Programación Orientada a Objetos, donde se revisan contenidos como las
características de la POO, el lenguaje JAVA, las palabras reservadas, variables e instrucciones
del Lenguaje JAVA así como la sintaxis de sus sentencias. Además, se da a conocer el entorno
de programación y las principales herramientas del IDE Netbeans para el diseño y codificación
de aplicaciones que resuelvan problemas reales.
En la tercera unidad aborda los temas para la Prueba e Implementación de las aplicaciones,
donde se revisan contenidos como los tipos de pruebas y su aplicación al software, en esencia
pruebas de unidad y de integración del software, además de los métodos de implementación
(directo, paralelo y piloto) de los sistemas de información como su aplicación para la solución de
problemas reales, también se abordan contenidos sobre la documentación y el mantenimiento
de las aplicaciones, refiriéndose principalmente al manual técnico y al manual del usuario, pero
también a los tipos de mantenimiento (correctivo, evolutivo, adaptativo y perfectivo) en las
aplicaciones de software como su aplicación.
En el contenido de estas unidades, se relaciona la teoría con la práctica, a través de ejercicios,
actividades de aprendizaje, instrumentos de evaluación, entre otras actividades encaminados a
apoyarte en el desarrollo de las competencias requeridas para los alumnos que cursan esta
asignatura.
Seguros de que harás de este material, una herramienta de aprendizaje, te invitamos a realizar
siempre tu mayor esfuerzo y dedicación para que logres adquirir las bases necesarias, para tu
éxito académico.

7
8
 UNIDAD I
Identifica los elementos del
paradigma de la programación
orientada a objetos

COMPETENCIAS
Competencias Genéricas

CG 4.1: Expresa ideas y conceptos mediante representaciones lingüísticas, matemáticas o gráficas.

CG 4.2: Aplica distintas estrategias comunicativas según quienes sean sus interlocutores, el contexto en el que
se encuentra y los objetivos que persigue.
CG 8.2: Aporta puntos de vista con apertura y considera los de otras personas de manera reflexiva.
CG 8.3: Asume una actitud constructiva, congruente con los conocimientos y habilidades con los que cuenta
dentro de distintos equipos de trabajo.
CG8: Participa y colabora de manera efectiva en equipos diversos.

Competencias Disciplinares

C1: Identifica, ordena e interpreta las ideas, datos y conceptos explícitos e implícitos en un texto, considerando el
contexto en el que se generó y en el que se recibe.
CE9 Diseña modelos o prototipos para resolver problemas, satisfacer necesidades o demostrar principios
científicos.
M1 Construye e interpreta modelos matemáticos deterministas o aleatorios mediante la aplicación de
procedimientos aritméticos, algebraicos, geométricos9 y variacionales, para la comprensión y análisis de
situaciones reales o formales.
M8 Interpreta tablas, gráficas, mapas, diagramas y textos con símbolos matemáticos y científicos.
 Identifica los conceptos básicos de la programación orientada a objetos para la solución
de problemas reales.
 Identifica los conceptos de clases y objetos para la solución de problemas reales.
 Conoce las propiedades de la programación orientada a objetos para el desarrollo de
aplicaciones de una organización.
 Conoce el lenguaje unificado de modelado UML para la especificación del software.

10
A continuación, se te presenta una serie de cuestionamientos, responde a cada uno de
ellos subrayando la respuesta correcta.
1. Técnica de programación que utiliza los objetos como representación de alguna cosa o
evento del mundo real.
a) Lineal b) Estructurada c) Secuencial
d) Orientada a e) Visual
objetos
2. El paradigma de programación orientado a objetos surge en un Centro de Computación
Noruego en los años. ¿En qué años surgió la POO?
a) 50’s b) 60’s c) 70’s d) 80’s e) 90’s

3. ¿Es la unidad de código compuesto de variables y métodos relacionados?

a) Variable b) Método c) Objeto d) Clases e) Función

4. ¿Es un modelo o prototipo que define las variables y métodos comunes a todos los objetos
de cierta clase?
a) Variable b) Método c) Objeto d) Clases e) Función

5. Son propiedades de la programación orientada a objetos, excepto:

a) Herencia b) Modularidad c) Polimorfismo d) Abstracción e) Lineal

6. ¿Es el proceso de ocultar todos los detalles internos de un objeto del mundo exterior?
a) Lineal b) Encapsulamiento c) Polimorfismo d) Abstracción e) Modularidad

7. Lenguaje gráfico para construir, documentar, visualizar y especificar un software:

a) UML b) XML c) HTML d) GDV e) POO

8. ¿Es el proceso mediante el cual un objeto adquiere las propiedades de otro objeto?
a) Herencia b) Encapsulamiento c) Polimorfismo d) Lineal e) Modularidad

9. ¿Son los datos o variables que caracterizan al objeto y cuyos valores en un momento dado
indican un estado?
a) Variable b) Método c) Objeto d) Clases e) Atributos

10. ¿Son las operaciones que se aplican sobre los objetos y que permiten crearlos, cambiar su
estado o consultar el valor de sus atributos?
a) Variable b) Método c) Objeto d) Clases e) Atributos

11
Conoce los conceptos de clases y objetos
Identifica los conceptos básicos de la programación orientada a objetos para la solución
de problemas reales

En el grupo con tu maestro, realiza una lluvia de ideas para responder los siguientes
cuestionamientos:

1. ¿Qué entiendes por paradigma?

_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
2. ¿Qué es la programación orientada a objetos?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
3. Según la programación orientada a objetos, ¿Qué es un objeto?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________

La Programación Orientada a Objetos, POO (OOP,

Object Oriented Programming, en inglés) es una
técnica de programación que utiliza los objetos como
representación de alguna cosa o evento del mundo
real. La programación orientada a objetos es una
filosofía, es una forma de pensar, es otra forma de
descomponer problemas. Vamos a fijarnos no en lo
que hay que hacer en el problema, sino en cuál es el
escenario real del mismo, y vamos a intentar simular
ese escenario en nuestro programa. Estamos
hablando de una nueva forma de pensar acerca del
proceso de descomposición de problemas y de
desarrollo de soluciones de programación.
La Programación Orientada a Objetos (POO) supone
un cambio en la concepción del mundo de desarrollo
de software, introduciendo un mayor nivel de abstracción que permite mejorar las
características del código final.

12
 La POO surge en un Centro de Computación Noruego en los
años 60’s con la implementación un lenguaje llamado Simula
67 por Krinsten Nygaard y Ole-Johan Dahl. Simula 67 inicia
implementando los conceptos de clases, subclases y rutinas.
La implementación y desarrollo del paradigma orientado a
objetos, está fundamentado en los objetos, en su prioridad a
los objetos y su abstracción como una parte fundamental en la
solución de problemas. Así como definir los métodos,
propiedades y características de los objetos, así como su
relación(interacción).
Historia de la POO
 La POO surge en un Centro de Computación Noruego en los años 60’s con la
implementación un lenguaje llamado Simula 67 por Krinsten Nygaard y Ole-Johan Dahl.
Simula 67 inicia implementando los conceptos de clases, subclases y rutinas.
 En los 70’s Small talk fue el primer lenguaje Orientado a Objetos puro de los lenguajes
Orientados a Objetos, es decir, únicamente utiliza clases y objetos (Java usa tipos de
datos primitivos, o bien los wrappers que son clases que encapsulan tipos de datos
primitivos).
 En los 80’s Bjarne Stroustrup de AT&T Labs., amplió el lenguaje C para crear C++ que
soporta la programación Orientada a Objetos. En esta misma década se desarrollaron
otros lenguajes orientados a Objetos como Objetive C, Common Lisp Object System
(CIOS), object Pascal, Ada y otros.
 Principios de los 90’s se consolida la Orientación a Objetos como una de las mejores
maneras para resolver problemas. Aumenta la necesidad de generar prototipos más
rápidamente (concepto RAD Rapid Aplicaction Developments). Sin esperar a que los
requerimientos iniciales estén totalmente precisos.
 En 1996 surge un desarrollo llamado JAVA (extensión de C++). Su filosofía es
aprovechar el software existente. Facilitar la adaptación del mismo a otros usos
diferentes a los originales sin necesidad de modificar el código ya existente.
 En 1997-98 se desarrollan herramientas ‘CASE’ orientadas a objetos (como el diseño
asistido por computadora).
 Del 98 en adelante, se desarrolla la arquitectura de objetos distribuidos RMI, Corba,
COM, DCOM.
 Actualmente la orientación a objetos parece ser el mejor paradigma, no obstante, no es
una solución a todos los problemas. Trata de eliminar la crisis del software. Entre los
creadores de metodologías orientadas a objetos se encuentran: G. Booch, Rambaught,
Ivar Jacobson y Peter Cheng.

13
De manera individual, los alumnos realziaran una investigacion sobre la evolucion de la
programcion orietnada a obejtos, posteriormente realizaran una liena del tipo.

14
El paradigma orientado a objetos
El paradigma orientado a objetos es útil
cuando el sistema se modela de forma casi
análoga a la realidad, porque así se
simplifica el diseño de alto nivel. Esta
analogía permite que los programadores
tengan más claro cuál es el papel de cada
porción del programa y de los datos, lo que
facilita la creación y el mantenimiento del
sistema. Además, se promueve la
reutilización, pues las similitudes entre
objetos se programan sólo una vez en
forma abstracta y el programador concentra
su esfuerzo en las diferencias concretas.
En la POO podemos, por ejemplo, diseñar el código para un botón virtual genérico que detecta
el "click" del mouse y llama a una función. El código del botón se reutiliza cada vez que
queremos crear un botón, pero con características particulares para cada caso.
En general, el mantenimiento se facilita con el paradigma orientado a objetos, porque el
software queda bien organizado y protegido. De esta manera, un programador entiende mejor el
código de otro y hay menor riesgo de que sus cambios afecten el trabajo de los demás.
También se mejora el desarrollo de software a gran escala. Los equipos de programadores
trabajan sobre objetos diferentes y, posteriormente, se integra el trabajo de todos haciendo uso
de las interfaces (la cara hacia afuera) de los objetos.
Las características principales de la programación estructurada y de la POO. Cabe señalar que
no es mejor una que la otra, sino que su utilidad depende del tipo de sistema que se
desarrollará. Si queremos utilizar la POO en todos los casos, complicaríamos el problema en
lugar de facilitar su solución.

Programación estructurada Programación orientada a objetos

Problemas de naturaleza algorítmica Desarrollo de aplicaciones web y otros
(dada cierta entrada se produce cierta sistemas que se presten al modelo de
salida). objetos.
Se base en estructura de datos. Se basa en objetos, que tienen un estado y
un comportamiento.

La información fluye a través de las Hay interacciones entre los objetos.

estructuras y de llamados a funciones.

15
Ventajas y desventajas de la POO
Ventajas
 Reducción de código redundante, lo que permite un código conciso y sin repeticiones,
en el que los objetos y las clases son fáciles de identificar (Herencia).

 Posibilita reusar código y extenderlo a través de las clases sin necesidad de probarlo.
(Testing).

 La jerarquía y abstracción de los objetos brinda una implementación más detallada,

puntual y coherente.

 La implementación de clases y objetos proporciona una

relación más directa con la realidad al implementar
funciones y métodos como comportamientos de las
entidades.

 Bajo acoplamiento y alta cohesión: Gracias a la

modularidad, cada componente o módulo de un
desarrollo tiene independencia de los demás
componentes.

 Facilidad en el desarrollo y el mantenimiento debido a la

filosofía del paradigma.

Desventajas
 Velocidad de ejecución, ya que un programa
desarrollado con base en la POO suele tener una ejecución
más lenta en comparación a los lenguajes funcionales.

 Se hereda código no usable en la nube clase.

 El uso para tareas simples termina siendo

improductivo, por lo que solo se recomienda para problemas
complejos.

 Curva de aprendizaje, aun cuando no representa

grandes dificultades al momento de codificar un problema, la
comprensión de los conceptos suele representar cierta
complejidad.

16
Con base a la información anteriormente analizada y con ayuda de internet, realiza una tabla de
ventajas y desventajas de la programación orientada a objetos.
Ventajas Desventajas

17
Identifica los conceptos de clases y objetos para la solución de problemas reales

En el grupo con tu maestro, realiza una lluvia de ideas para responder los siguientes
cuestionamientos:

1. Según la programación orientada a objetos, ¿Qué es una clase?

_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
2. Según la programación orientada a objetos, ¿Qué es un atributo?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
3. Según la programación orientada a objetos, ¿Qué es un método?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________

Objetos
Entender que es un objeto es la
clave para entender cualquier
lenguaje orientado a objetos.
Existen muchas definiciones que
se le ha dado al Objeto. Primero
empecemos entendiendo que es
un objeto del mundo real. Un
objeto del mundo real es cualquier
cosa que vemos a nuestro
alrededor. Por ejemplo: una
computadora, un teléfono celular,
un árbol o un automóvil.
Analicemos un poco más a un
objeto del mundo real, como la
computadora. No necesitamos ser
expertos en hardware para saber

18
que una computadora está compuesta internamente por varios componentes: la tarjeta madre,
el chip del procesador, un disco duro, una tarjeta de video, y otras partes más. El trabajo en
conjunto de todos estos componentes hace operar a una computadora.
Internamente, cada uno de estos componentes puede ser sumamente complicados y puede ser
fabricado por diversas compañías con diversos métodos de diseño. Pero nosotros no
necesitamos saber cómo trabajan cada uno de estos componentes, como saber qué hace cada
uno de los chips de la tarjeta madre, o cómo funciona internamente el procesador. Cada
componente es una unidad autónoma, y todo lo que necesitamos saber de adentro es cómo
interactúan entre sí los componentes, saber por ejemplo si el procesador y las memorias son
compatibles con la tarjeta madre, o conocer donde se coloca la tarjeta de video. Cuando
conocemos como interaccionan los componentes entre sí, podremos armar fácilmente una
computadora.
¿Qué tiene que ver esto con la programación? La programación orientada a objetos trabaja de
esta manera. Todo el programa está construido en base a diferentes componentes (Objetos),
cada uno tiene un rol específico en el programa y todos los componentes pueden comunicarse
entre ellos de formas predefinidas.
Todo objeto del mundo real tiene 2 componentes: características o atributos y comportamiento o
métodos.
 Atributos: son los datos o variables que caracterizan al objeto y cuyos valores en un
momento dado indican un estado.
 Métodos: son las operaciones (acciones o funciones) que se aplican sobre los objetos y
que permiten crearlos, cambiar su estado o consultar el valor de sus atributos.
Por ejemplo, los automóviles tienen características (marca, modelo, color, velocidad máxima,
etc.) y comportamiento (encender, apagado, frenar, acelerar, retroceder, llenar combustible,
etc.).

Atributos

Objeto  Marca
 Modelo
 Color,
 Velocidad máxima

Métodos

 Encender
 Apagado
 Frenar
 Acelerar
 Retroceder
 Llenar combustible

19
Los Objetos de Software, al igual que los objetos del mundo real, también tienen características
y comportamientos. Un objeto de software mantiene sus características en una o más
"variables", e implementa su comportamiento con "métodos". Un método es una función o
subrutina asociada a un objeto.
Siguiendo el mismo ejemplo, imaginemos que tenemos estacionado en nuestra cochera un Ford
Focus color azul que corre hasta 260 km/h. Si pasamos ese objeto del mundo real al mundo del
software, tendremos un objeto Automóvil con sus características predeterminadas:

Marca= Ford
Modelo= Focus
Color= Azul
VelocidadMaxima= 260 km/h

Cuando a las características del objeto le ponemos valores decimos que el objeto tiene estados.
Las variables almacenan los estados de un objeto en un determinado momento.
Definición teórica: Un objeto es una unidad de código compuesto de variables y métodos
relacionados.
Clases
En el mundo real, normalmente tenemos muchos
objetos del mismo tipo. Por ejemplo, nuestro teléfono
celular es sólo uno de los miles que hay en el mundo.
Si hablamos en términos de la programación orientada
a objetos, podemos decir que nuestro objeto celular es
una instancia de una clase conocida como "celular".
Los celulares tienen características (marca, modelo,
sistema operativo, pantalla, teclado, etc.) y
comportamientos (hacer y recibir llamadas, enviar
mensajes multimedia, transmisión de datos, etc.).
Cuando se fabrican los celulares, los fabricantes aprovechan el hecho de que los celulares
comparten esas características comunes y construyen modelos o plantillas comunes, para que
a partir de esas se puedan crear muchos equipos celulares del mismo modelo. A ese modelo o
plantilla le llamamos clase, y a los equipos que sacamos a partir de ella la llamamos objetos.

Esto mismo se aplica a los objetos de

software, se puede tener muchos
objetos del mismo tipo y mismas
características.
Definición teórica: La clase es un
modelo o prototipo que define las
variables y métodos comunes a todos
los objetos de cierta clase. También se
puede decir que una clase es una
plantilla genérica para un conjunto de
objetos de similares características.

20
Por otro lado, una instancia de una clase es otra forma de llamar a un objeto. En realidad, no
existe diferencia entre un objeto y una instancia. Sólo que el objeto es un término más general,
pero los objetos y las instancias son ambas representaciones de una clase.
Definición Teórica: Una instancia es un objeto de una clase en particular.

21
Realiza un esquema gráfico con los conceptos de Programación orientada a objetos, clases y
objeto, y ejemplifica.

22
Describe las propiedades de herencia y polimorfismo
Conoce las propiedades de la programación orientada a objetos para el desarrollo
de aplicaciones de una organización.

En el grupo con tu maestro, realiza una lluvia de ideas para responder los siguientes:
cuestionamientos:

1. Según la programación orientada a objetos, ¿Qué es abstracción?

_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
2. Según la programación orientada a objetos, ¿Qué es herencia?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
3. Según la programación orientada a objetos, ¿Qué es polimorfismo?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________

La programación orientada a objetos establece un equilibrio entre la importancia de los

procesos y los datos, mostrando un enfoque más cercano al pensamiento del ser humano.
Las características principales de la programación orientada a objetos son: abstracción,
encapsulación, modularidad, herencia y polimorfismo.

 La abstracción es un proceso mental de

extracción de las características esenciales,
ignorando los detalles superfluos. Resulta
ser muy subjetiva dependiendo del interés
del observador, permitiendo abstracciones
muy diferentes de la misma realidad.

La abstracción proporciona un mecanismo

crucial para permitir que las personas
comprendan, se comuniquen y razonen
sistemas complejos.
En síntesis, la abstracción consiste en reconocer y enfocarse en las características
importantes de una situación u objeto, y filtrar o ignorar todos los detalles no esenciales.

23
 El encapsulamiento es el proceso de ocultar todos los detalles internos de un objeto del
mundo exterior.
Existirán dos partes, una visible que todos tienen acceso y se aporta la funcionalidad, y
una oculta que implementa los detalles internos.

La ventaja principal del encapsulamiento es que proporciona al programador libertad en

la implementación de los detalles del sistema. La única restricción que tendrá el
programador es mantener la interfaz abstracta que vean los usuarios externos.

 La modularidad permite subdividir una aplicación en partes más pequeñas. La

modularidad debe seguir los conceptos de bajo acoplamiento y alta cohesión.

 El acoplamiento entre dos módulos mide el nivel de asociación entre ellos; nos
interesa buscar módulos poco acoplados.

 La cohesión de un módulo mide el grado de conectividad entre los elementos que los
forman; nos interesa buscar una cohesión alta.

24
 La herencia es el proceso mediante el cual un objeto adquiere las propiedades de otro
objeto. La herencia es una característica que permite a las clases definirse a partir de
otras, y así reutilizar su funcionalidad. A la clase padre se le llama superclase, clase
base..., y a la hija subclase, clase derivada....

 El polimorfismo es la propiedad que permite enviar el mismo mensaje a objetos de

diferentes clases, de forma que cada uno de ellos responde a ese mismo mensaje de
modo distinto dependiendo de su implementación.

El polimorfismo como sobrecarga en Java ocurre cuando una clase T tiene múltiples
métodos con el mismo nombre, cada uno de ellos con una signatura (combinación de su
nombre y el tipo y número de argumentos que pasan por los métodos) diferentes.

25
Realiza un esquema gráfico sobre las características principales de la programación orientada a
objetos.

26
Conoce el lenguaje unificado de modelado UML para la especificación del
software

En el grupo con tu maestro, realiza una lluvia de ideas para responder los siguientes
cuestionamientos:

1. ¿Qué es lenguaje unificado de modelado UML?

_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
2. Según el lenguaje unificado de modelado UML, ¿Qué es una asociación?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
3. Según el lenguaje unificado de modelado UML, ¿Qué es agregación?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________

Lenguaje unificado de modelado UML

“Unifield Modeling Language” UML, es un lenguaje gráfico para construir, documentar, visualizar
y especificar un sistema de software.
El propósito de un diagrama de clase es describir las
clases que conforman el modelo de un determinado
sistema. Dado el carácter de refinamiento iterativo que
caracteriza un desarrollo orientado a objetos, el
diagrama de clase va a ser creado y refinado durante
las fases de análisis y diseño, estando presente como
guía en la implementación del sistema.
Los diagramas de clase describen los tipos de objetos
de un sistema, así como los distintos tipos de
relaciones que pueden existir entre ellos. Los
diagramas de clase se convierten así en la técnica más potente para el modelado conceptual de
un sistema software, la cual suele recoger los conceptos clave del modelo de objetos
subyacente al método orientado a objetos.
Las cosas que existen y que nos rodean se agrupan naturalmente en categorías. Una clase es
una categoría o grupo de cosas que tienen atributos (propiedades) y acciones similares.

27
Se puede decir que existen tres perspectivas diferentes desde las cuales se pueden utilizar los
diagramas de clase:
 Conceptual: El diagrama de clase representa los conceptos en el dominio del problema
que se está estudiando. Este modelo debe crearse con la mayor independencia posible
de la implementación final del sistema.

 Especificación o análisis: El diagrama de clase refleja las interfaces de las clases,

pero no su implementación. Aquí las clases aparecen más cercanas a los tipos de datos,
ya que un tipo representa una interfaz que puede tener muchas implementaciones
diferentes.

 Implementación: Esta vista representa las clases tal cual aparecen en el entorno de
implementación.

Con base a la información anterior, realiza un esquema grafico del concepto de diagrama UML,
así como de sus tres distintas perspectivas.

28
Para UML una clase es “una descripción de un conjunto de objetos
que comparten los mismos atributos, operaciones, métodos,
relaciones, y semántica”. De esta forma, un diagrama de clase de
UML puede describir todos los componentes de una clase de una
forma sencilla. Así, el elemento fundamental de los diagramas de
clase es el icono que representa una clase.

Las clases se representan gráficamente por medio de un rectángulo con tres divisiones
internas. Los tres compartimentos alojan el nombre de la clase, sus atributos y sus operaciones,
respectivamente.
En muchos diagramas se omiten los dos compartimentos inferiores. Incluso cuando están
presentes, no muestran todos los atributos y todas las operaciones.
Dependiendo del detalle del diagrama de clase, la notación para un atributo puede indicar su
nombre, su tipo, un valor de inicio y su visibilidad, siendo su sintaxis:

Visibilidad nombre: tipo = valor

 La visibilidad expresa si el atributo o método es visible para el resto de objetos del

diagrama, pudiéndose dar los siguientes casos:

+ Visibilidad pública: Visible por todos los objetos

# Visibilidad protegida: Visible sólo por el objeto y sus descendientes
- Visibilidad privada: Visible sólo por el objeto

 Nombre es el identificador del atributo

 Tipo indica el dominio del atributo
 Valor es un elemento opcional que indica un valor de inicio para el atributo.

Al igual que sucede con los atributos, las operaciones de una clase pueden especificarse con
diferente nivel de detalle según la siguiente sintaxis:

Visibilidad nombre (lista de parámetros): tipo de retorno

29
Por ejemplo, la clase Autos de tres formas diferentes: sin detalles, detalles en el ámbito de
análisis y detalles en el ámbito de implementación.

Autos Conceptual

Autos
Marca
Modelo
Color Análisis o especificación
VelocidaMaxima
Encender ( )
Apagado ( )
Acelerar ( )
Frenar ( )
Retroceder ( )

Autos
+ Marca: string
- Modelo : string
+ Color : string
# VelocidaMaxima: int
+ Encender ( ) :boolean Implementación
+ Apagado ( ) :boolean
+ Acelerar ( ) : int
+ Frenar ( ) : int
+ Retroceder ( )
:boolean

30
Realiza el modelado de las siguientes clases; teléfonos, personas, mascotas; en sus tres
formas diferentes: sin detalles, detalles en el ámbito de análisis y detalles en el ámbito de
implementación.

31
Relaciones en un diagrama de clases
Los diagramas de clases están compuestos por clases y por relaciones entre ellas. Las
relaciones que se pueden usar son Relación de asociación, Relación de dependencia, y
Relación de generalización:
Relación de asociación:
Una asociación es una conexión entre clases, una conexión
semántica (enlace) entre los objetos de dichas clases. Un
tipo especial de asociación es la relación de agregación.
Normalmente una asociación es binaria y bidireccional (se
puede navegar en ambas direcciones). Se dibuja como una
línea sólida entre dos clases. También se puede representar
una asociación binaria y unidireccional, añadiendo una flecha
al final de la línea. Esta flecha indica que la asociación sólo
se puede utilizar en la dirección de la flecha.

Cada asociación puede presentar algunos elementos adicionales que dan detalle a la relación,
como son:
 Nombre: una asociación puede tener un nombre, que se usa para describir la naturaleza
de la relación. Así no hay ambigüedad sobre su significado. Para indicar la dirección en que
se debe leer el nombre se emplea una punta de flecha.

 Rol: cuando una clase participa en una asociación, juega un rol específico en dicha
relación. Se puede designar de forma explícita mediante un nombre a los finales de la línea,
el cual describe la semántica de la asociación en el sentido indicado.

 Multiplicidad: la multiplicidad describe la cardinalidad de la relación, es decir, cuántos

objetos están conectados en una instancia de una asociación (enlace). Cuando se
establece una multiplicidad al final de la línea de una asociación, indica que para cada
objeto de la clase en el lado opuesto existen varios objetos en el otro extremo. El rango
puede ser tres (3), cero-a-uno (0..1), cero-a-muchos (0..* ó *), uno-a-muchos (1..*), etc.
Por ejemplo, la clase persona y la clase mascota:

32
Realiza una investigación sobre los distintos tipos de asociación que pueden existir en un
diagrama de clase.

Asociación
normal

Tipos de
asociación
Agregación
normal

Agregación

Agregación
compartida

Agregación de
composición

33
La agregación es una asociación con unas connotaciones semánticas más definidas: la
agregación es la relación parte-de, que presenta a una entidad como un agregado de partes (en
orientación a objeto, un objeto como agregado de otros objetos). Se grafica con un rombo
diamante vacío.

Ejemplo de una agregación podemos recurrir a la clase Auto, donde un auto se modela como
un agregado de chasis, ruedas, carcasa, asientos, motor, pedales y volante.

La agregación en UML presenta el siguiente matiz, la existencia de las partes agregadas es

independiente de la existencia del objeto agregado, esto es, cuando se crea el objeto agregado
se irán estableciendo las relaciones con cada una de las partes que lo constituyen a medida
que se vayan necesitando. Los objetos que representan las partes del objeto agregado pueden
ya existir o crearse para formar parte del objeto agregado, pero cuando se destruye el objeto
agregado, los objetos que lo forman no tienen por qué ser destruidos, por consiguiente, las
partes pueden sobrevivir a la destrucción del objeto agregado.

Composición es un tipo especial de agregación que denota una fuerte posesión de la Clase
“Todo”, a la Clase “Parte”. Se grafica con un rombo diamante relleno contra la clase que
representa el todo.

34
Realiza el modelado de agregación para las siguientes clases: teléfonos, computadoras y
aviones.

35
Relación de dependencia:
Una dependencia es una conexión semántica entre dos elementos de modelado, uno
independiente y otro dependiente. Un cambio en el elemento independiente afectará al
dependiente. Un elemento de modelado puede ser una clase, paquete, caso de uso, etc.
Los casos más típicos de dependencia son: una clase tiene por parámetro en una operación un
objeto de otra clase; una clase accede a un objeto global de otra clase; o una clase llama a una
operación cuyo ámbito es la clase en otra clase. La relación de dependencia se representa por
una línea discontinua con una flecha en el lado del elemento independiente. Si se utiliza una
etiqueta, entonces se trata de un estereotipo que identifica el tipo de dependencia.

En UML existen ocho estereotipos que se pueden aplicar a las relaciones de dependencia entre
clases:

Estereotipo Descripción
bind Se utiliza cuando se quiere modelar los detalles de las clases contenidas en
plantillas. La relación entre una plantilla que contiene una clase y una
instanciación de dicha clase se podría modelar como una dependencia «bind».
Bind incluye una lista de los argumentos actuales que se aplican a los
argumentos formales de la plantilla.
derive Se utiliza cuando se quiere modelar la relación entre dos atributos o dos
asociaciones, uno de los cuales es concreto y el otro es conceptual. Por
ejemplo, la clase Persona podría tener el atributo fecha-de-cumpleaños (que es
concreto), así como el atributo edad (que se puede derivar a partir del atributo
anterior). Se podría mostrar esta relación mediante una dependencia «derive»,
indicando que edad se deriva a partir de fecha-decumpleaños.
friend Se utiliza cuando se quiere modelar que una clase tenga acceso especial a la
estructura interna de otra clase (incluso a aquellas partes con visibilidad
privada). La dependencia «friend» es una reminiscencia de las clases amigas de
C++.
instanceOf La dependencia «instanceOf» se utiliza cuando se quiere modelar la relación
entre una clase y un objeto en el mismo diagrama, o entre una clase y su
metaclase.
instantiate La dependencia «instantiate» se utiliza cuando se quiere especificar qué
elemento crea objetos de otro.
powertype Se utiliza cuando se quiere modelar clases que encubran a otras clases, tal
como sucede cuando se trata de modelar bases de datos.
refine Se utiliza cuando se quiere modelar clases que son esencialmente la misma,
pero a diferentes niveles de abstracción. Por ejemplo, durante el análisis,
tenemos una clase Cliente que, durante el diseño, vamos a refinar en una clase
Cliente más detallada, es decir, más completa de cara a su implementación.
use Se utiliza cuando se quiere marcar de forma explícita una dependencia como
una relación de uso, en contraste con los matices que proporcionan los otros
estereotipos de dependencia.

36
Relación de generalización
Una generalización es una relación entre un elemento más general y otro más específico. El
elemento más específico puede contener sólo información adicional. Una instancia (un objeto es
una instancia de una clase) del elemento más específico se puede usar si el elemento más
general lo permite.
La generalización normal es una relación de herencia entre clases, entre una general y otra
específica. La clase específica, llamada subclase, hereda todo de la clase general, llamada
superclase. Los atributos, las operaciones y todas las asociaciones son heredadas. Los
atributos y las operaciones con visibilidad pública en la superclase serán también públicos en la
subclase. Los atributos y las operaciones que tengan visibilidad privada también serán
heredados, pero no serán accesibles dentro de la subclase. Para proteger los atributos y las
operaciones de accesos desde fuera de la superclase y de la subclase, los podemos declarar
con visibilidad protegida. No se puede acceder a ellos desde otras clases, pero están
disponibles para la superclase y para cualquiera de sus subclases.
La relación de generalización se representa por una línea continua desde la clase más
específica (subclase) hasta la clase más general (superclase), con un triángulo sin rellenar al
final de la línea en la superclase.
La flecha que representa a la herencia va orientada desde la subclase a la superclase.

Una clase abstracta es aquella que no tiene objetos. Sólo se utiliza para heredar a partir de ella,
es decir, en una clase abstracta se describen los atributos y las operaciones comunes para
otras clases.
Se especifica de forma explícita poniendo {abstracta} dentro del compartimento del nombre de
la clase y debajo de su nombre. Normalmente una clase abstracta tiene operaciones abstractas.
Una operación abstracta es aquella que no tiene método de implementación en la superclase
donde está definida. Se especifica de forma explícita escribiendo {abstracta} después del
nombre de la operación en la superclase.
Lo contrario de una clase abstracta es una clase concreta, lo que significa que es posible crear
objetos a partir de la clase y que tiene implementaciones para todas las operaciones.
La herencia es la típica relación de generalización/especialización entre clases. Cuando de una
superclase se derivan varias subclases existen dos notaciones diferentes, aunque totalmente
equivalentes, para su representación. En la primera forma de representar esta situación se
muestra una superclase a la que llegan tantas flechas como clases derivadas tiene. En la
segunda representación se tiene una única punta de flecha que llega a la superclase, pero a la
base del triángulo que hace de punta de flecha llegan tantos caminos como subclases haya.

37
Por ejemplo, un automóvil y un camión son subclases de VehiculoMotorizado:

Herencia múltiple:

38
Con base a la información analizada anteriormente respecto a las relaciones que se pueden
usar en un diagrama UML (asociación, dependencia, generalización), realiza un esquema
grafico donde representes las ideas principales de cada una de ellas.

Símbolo Representa Descripción

Relación dependiente

Composición

La generalización normal es una

relación de herencia entre clases, entre
una general y otra específica. La clase
específica, llamada subclase, hereda
todo de la clase general, llamada
superclase.

39
Con base a la información analizada anteriormente respecto a las relaciones que se pueden
usar en un diagrama UML (asociación, dependencia, generalización), realiza un esquema
grafico donde representes las ideas principales de cada una de ellas.

40
A continuación, se te presenta una serie de cuestionamientos, responde a cada uno de ellos
subrayando la respuesta correcta.
1. Técnica de programación que utiliza los objetos como representación de alguna cosa o
evento del mundo real.
a) Lineal b) Estructurada c) Secuencial d) Visual e) Orientada a objetos

2. ¿Propiedad de la POO que permite ocultar todos los detalles internos de un objeto del
mundo exterior?
a) Lineal b) Abstracción c) Polimorfismo d) Encapsulamiento e) Modularidad

3. Unidad de código utilizada en POO, compuesta de variables y métodos relacionados:

a) Objeto b) Método c) Variable d) Clases e) Función

4. Consiste en la extracción de características esenciales, ignorando detalles superfluos:

a) Lineal b) Abstracción c) Polimorfismo d) Encapsulamiento e) Modularidad

5. Símbolo utilizado en el lenguaje UML, para representar agregación:

a) b) c) d) e)

6. ¿Es el proceso mediante el cual un objeto adquiere las propiedades de otro objeto?
a) Abstracción b) Encapsulamiento c) Herencia d) Polimorfismo e) Lineal

7. Propiedad de la POO que permite enviar el mismo mensaje a objetos de diferentes clases, y
cada uno de ellos responde a ese mismo mensaje de modo distinto.
a) Lineal b) Encapsulamiento c) Herencia d) Polimorfismo e) Modularidad

8. Símbolo utilizado en el lenguaje UML, para representar la asociación:

a) b) c) d) e)

9. ___________ describe la cardinalidad de la relación, es decir, cuántos objetos están

conectados en una instancia de una asociación:
a) Rol b) Multiplicidad c) Objeto d) Abstracción e) Agregación

10. Símbolo que representa la visibilidad protegida de un atributo:

a) + b) & c) - d) # e) %

41
42
 UNIDAD II
Aplica el modelo de espiral
para el desarrollo de
software

COMPETENCIAS
Competencias Genéricas

CG1: Se conoce y valora a sí mismo y aborda problemas y retos teniendo en cuenta los objetivos que
persigue.
CG4: Escucha, interpreta y emite mensajes pertinentes en distintos contextos mediante la utilización de
medios, códigos y herramientas apropiados.
CG5: Desarrolla innovaciones y propone soluciones a problemas a partir de métodos establecidos.
CG8: Participa y colabora de manera efectiva en equipos diversos.

Competencias Disciplinares

C1 Identifica, ordena e interpreta las ideas, datos y conceptos explícitos e implícitos en un texto,
considerando el contexto en el que se generó y en el que se recibe.
43
CE9: Diseña modelos o prototipos para resolver problemas, satisfacer necesidades o demostrar principios
científicos.
 Identifica los objetivos del sistema, en el desarrollo de aplicaciones de una organización.
 Identifica las fases del modelo en espiral para el desarrollo de software.
 Conoce el lenguaje orientado a objetos (JAVA) para el desarrollo de aplicaciones de una
organización.
 Identifica las palabras reservadas, tipos de variables, instrucciones y sintaxis de un
lenguaje de programación orientada a objetos (JAVA) en el desarrollo de aplicaciones de
una organización.
 Instala y maneja un entorno de programación orientado a objetos, mediante el uso de
una herramienta de software (Netbeans) para el desarrollo de aplicaciones de una
organización.
 Emplea código en un lenguaje de programación (JAVA) para la resolución de problemas
en el desarrollo de aplicaciones.

44
A continuación, se te presenta una serie de cuestionamientos, responde a cada uno de ellos
subrayando la respuesta correcta.
1. Modelo en el que el software se desarrolla en una serie de versiones incrementales, a
medida que se va incrementando las iteraciones las versiones son más completas.
f) Cascada g) Prototipo h) Extrema i) Espiral j) Adaptativo
2. Al conjunto estructurado de las actividades requeridas para realizar un sistema de software
se le denomina proceso de:
a) Diseño b) Integración c) Desarrollo d) Planificación e) Procesos
3. Orden que se le da al programa para realizar una tarea específica, por ejemplo: mostrar un
mensaje en la pantalla:
a) Variable b) Constante c) Comentario d) Sentencia e) Identificador
4. Método que sirve para asignar un valor inicial a un atributo, no regresa nada y solo nos
permite dar acceso a ciertos atributos que deseemos modificar:
a) Setters b) Applets c) Getters d) While e) Return
5. Tipo de programación que expresa un programa como un conjunto de objetos, que
colaboran entre ellos para realizar tareas.
a) POO b) Modular c) Estructurada d) Directa e) Abstracta
6. Verifica su código con las reglas de sintaxis del lenguaje, luego escribe los códigos byte en
archivos .class.
a) Máquina b) Recolector c) Compilador d) Kit de e) Desensamblado
virtual JAVA JAVA desarrollo r JAVA
7. Indica que una clase puede ser utilizada desde cualquier otra clase, con independencia si
están en el mismo paquete o no.
a) Class b) Private c) Static d) Public e) Void
8. Entorno de desarrollo integrado libre y gratuito, sin restricciones de uso, hecho
principalmente para el lenguaje de programación Java:
f) CodeBlocks g) Netbeans h) Junit i) C++ j) JDK
9. Incluye los controles (botones, etiquetas, cajas de texto, etc.) con los que se puede diseñar
la pantalla de la aplicación.
a) Paleta de b) Ventana c) Inspector de d) Ventana de e) Ventana
objetos de salida proyecto administrador propiedades
10. Definen el aspecto gráfico de un control (tamaño, color, posición en la ventana, tipo y
tamaño de letra, etc.):
a) Herramientas b) Propiedades c) Clases d) Objetos e) Eventos

45
Emplea las fases del modelo en espiral para el desarrollo de software
Identifica los objetivos del sistema, en el desarrollo de aplicaciones de una
organización.

En el grupo con tu maestro, realiza una lluvia de ideas para responder los siguientes
cuestionamientos:

1. ¿Qué entiendes por modelo de desarrollo de software?

_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
2. ¿Qué es el modelo de desarrollo de software convencionales?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
3. ¿Qué es el proceso de desarrollo ágil?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________

Modelo de desarrollo de software

Un proceso de desarrollo de software es el
conjunto estructurado de las actividades
requeridas para realizar un sistema de
software. Estas actividades son:
especificación de requerimientos, diseño,
codificación, validación (pruebas) y
mantenimiento. Al proceso de desarrollo de
software también se le conoce como ciclo de
vida del software porque describe la vida de
un producto de software.
Primero nace con la especificación de los
requerimientos, luego se lleva a cabo su
implantación, que consiste en su diseño,
codificación y pruebas, posteriormente el producto se entrega y sigue viviendo durante su
utilización y mantenimiento. En este ciclo se establece una comunicación interactiva entre
cliente y desarrollador en la que el primero solicita servicios y el segundo propone soluciones.

46
El ciclo de vida del sistema de software termina cuando éste se deja de utilizar. Por otra parte,
un modelo de desarrollo de software es una representación abstracta de este proceso. Un
modelo de desarrollo de software determina el orden en el que se llevan a cabo las actividades
del proceso de desarrollo de software, es decir, es el procedimiento que se sigue durante el
proceso. Al modelo de desarrollo también se le llama paradigma del proceso.
Los procesos utilizados para el desarrollo de software se pueden dividir en dos grandes
vertientes los modelos convencionales (prescriptivos de proceso) y de desarrollo ágil.
También llamados “prescriptivos”, determina un conjunto de elementos del
proceso: actividades del marco de trabajo, acciones de ingeniería del
software, tareas, productos del trabajo, aseguramiento de la calidad, y
mecanismos de control de cambio para cada proyecto; cada modelo prescribe
Convencionales también un flujo de trabajo, donde los elementos del proceso se
interrelacionan entre sí.

Combinan una filosofía y un conjunto de directrices de desarrollo. Busca la

satisfacción del cliente y la entrega temprana de software incremental. Utilizan
Desarrollo ágil métodos informales; y una simplicidad general del desarrollo. La
comunicación entre los desarrolladores y los clientes durante el desarrollo del
proyecto es activa y continua.

47
Con base a la informacion analisada anteriormente, los alumnos realiazaran el sigueitne cuadro
sinoptico sobre los modelos de desarrollo del software.

¿Qué es?

Modelos de
Modelo de
desarrollo de desarrollo
software convencional

Modelo de
desarrollo ágil

48
Modelos convencionales
Modelo en cascada

En este tipo de modelo las fases se desarrollan de forma lineal o secuencial. Es ideal cuando se
desea realizar adaptaciones o mejoras bien definidas a software ya existentes, en caso de que
sea nuevo se hace imprescindible que se tengan los requerimientos bien claros y definidos.

Entre los problemas que se presentan con el modelo en cascada se mencionan los siguientes:
 Por lo general los proyectos de desarrollo de software, difícilmente siguen un modelo
secuencial, y a pesar de que este modelo permite realizar iteraciones, se realizan de
manera indirecta, confundiendo al equipo de proyecto, que se encuentra actuando.
 En muchas oportunidades al cliente se le hace difícil definir los requisitos de manera
explícita.
 La primera versión que tendrá el cliente del producto se obtendrá cuando el proyecto se
encuentre muy avanzado, así que un error grave será de gran impacto para el desarrollo
del mismo.

Modelos de procesos incrementales

En ocasiones se tienen bien definido en forma razonable los requisitos iniciales del software,
pero se desea tener con celeridad un grupo de funcionalidades requeridas por el usuario, lo
que conduce a ordenar las entregas de una manera incremental.
a) Modelo incremental.
Esta metodología utiliza el modelo de cascada de forma incremental; permite priorizar las
funcionalidades del sistema requeridas por los usuarios e ir desarrollándolas en función de las

49
necesidades. Pero a diferencia de los modelos evolutivos que veremos más adelante este
modelo se centra en cada entregable a realizar, sin revisar o mejorar funcionalidades
desarrolladas en iteraciones anteriores.

b) Modelo de desarrollo rápido de aplicaciones (DRA).

50
El desarrollo rápido de aplicaciones (DRA) es un proceso de desarrollo incremental que resalta
un ciclo de desarrollo corto. En él las actividades de modelado y construcción se realizan en
forma de escala, teniendo que definir “n” número de equipos que trabajarán en un lapso de
tiempo restringido entre los 60 y 90 días para culminar con la integración de todas las
funcionalidades desarrolladas en la etapa de despliegue.
Esta metodología posee algunos inconvenientes:
 En proyectos grandes escalables se requiere de suficientes recursos humanos para
definir el número correcto de equipos.
 Debe existir compromiso entre los clientes y los desarrolladores de las actividades
rápidas necesarias para completar el sistema en un lapso breve de tiempo
 Esta metodología no es apropiada para cuando se tienen altos riesgos.

Modelos de procesos evolutivos

Para los sistemas complejos, que evolucionan con el tiempo, es necesario utilizar una
metodología que permita que los requisitos del negocio y productos vayan cambiando conforme
se realiza el proyecto. Por lo tanto, una ruta lineal que conduce a un producto final no da
flexibilidad al producto para ir adecuándose a las necesidades reales del cliente.

Los modelos evolutivos permiten a los desarrolladores crear versiones cada vez más complejas
del software. Entre los modelos evolutivos se tiene: la construcción de prototipos, modelos en
espiral y el modelo de desarrollo concurrente.

a) Construcción de prototipos
Este modelo de proceso surge cuando no se tienen detallados los requisitos, como se llevará a
cabo el procesamiento, ni lo que se tendrá al finalizar del mismo. Este modelo permite a los
desarrolladores y clientes comprender en mayor escala lo que se desea buscar con el resultado
de la construcción cuando los requisitos se encuentren cubiertos.

El modelo de construcción de prototipos inicia con la actividad de comunicación, continua con la

realización de un plan rápido y un modelado o diseño rápido, para luego construir el prototipo y
desarrollarlo. Una vez que se tenga listo es entregado al cliente para recibir la retroalimentación
que servirá para aclarar los requisitos o funcionalidades que debe poseer el sistema.
El prototipo sirve para que los clientes vean el sistema real en poco tiempo y los desarrolladores
construir algo de inmediato. Pero la construcción de
prototipos puede poseer algunas desventajas como lo son:

 Por la rapidez en que se está desarrollando el

sistema se puede sacrificar la calidad en la
construcción del mismo, lo que puede lograr que se
dificulte el mantenimiento del mismo a largo plazo.

51
  También por la premura en realizar el prototipo no podemos encontrar con una
utilización del sistema operativo o lenguaje de programación inadecuada, solo porque se
encuentra disponible y es conocido.

La construcción de prototipos sin embrago puede ser efectivo si se definen las reglas
desde un principio, que permita al desarrollador y cliente ponerse de acuerdo a la
construcción del mismo y que sirva como mecanismo para la definición de requisitos.
b) Modelo en espiral
En el modelo en espiral, el software se desarrolla en una serie de versiones increméntales.
Durante las primeras iteraciones. La versión incremental podría ser un modelo en papel o un
prototipo. A medida que se va incrementando el número de iteraciones, se producen versiones
cada vez más completas.

El modelo en espiral se divide en un número de actividades estructurales, también llamadas

regiones de tareas. Generalmente, existen entre tres y seis regiones de tareas. Las cuales son:
Comunicación con el cliente, la planificación, el análisis de riesgo, la ingeniería, la construcción
y adaptación y por último la evaluación del cliente.

c) Modelo de desarrollo concurrente

El modelo de proceso concurrente se puede representar en forma de esquema como una serie
de actividades técnicas importantes, tareas y estados asociados a ellas.

En este modelo se define una serie de acontecimientos que dispararan transiciones de estado
a estado para cada una de las actividades de la ingeniería del software. Es utilizado en todos
los tipos de desarrollo de software y proporciona una visión certera del estado actual del
proyecto.

Cada actividad, acción o tarea dentro de la red existe de manera simultánea con otras. Los
sucesos generados dentro de una actividad dada o algún otro lado de la red de actividad inicia
las transiciones entre los estados de una actividad.

52
Con la información sobre los modelos de desarrollo convencional, completa el siguiente
esquema.

Modelo en
cascada

Esta metodología utiliza

el modelo de cascada
de forma incremental;
permite priorizar las
funcionalidades del
sistema requeridas por
los usuarios e ir
desarrollándolas en
función de las
Modelos necesidades
convencionales Modelo de
desarrollo rápido de
aplicaciones (DRA)

Modelo en espiral

53
Modelos de desarrollo ágil
En la actualidad las condiciones del mercado se mantienen en un constante cambio, haciendo
que las necesidades de los usuarios finales evolucionen, ya que cada día surgen nuevas
amenazas competitivas que emergen sin previo aviso. En muchas ocasiones no es posible
definir por completo los requisitos antes de que se inicie el proyecto.
Las características esenciales del proceso de desarrollo ágil para la mayoría de los proyectos
son las siguientes:
 Dificultad para predecir los requerimientos que persistirán y cuáles cambiarán.
 El diseño y la construcción están intercalados y deben realizarse de manera conjunta de
modo que puedan ser aprobados conforme se crean.
 El análisis, el diseño y la construcción no son predecibles.

El proceso ágil de software debe adaptarse de manera incremental. La idea es que se

mantenga un canal de retroalimentación con el cliente, a través de entregas de prototipos
ejecutable o porción de un sistema operacional, en periodos cortos para que la adaptabilidad
mantenga un buen ritmo con el cambio.

Programación extrema (PE)

Es una de las metodologías de desarrollo de software utilizadas en la actualidad para proyectos
de corto plazo, con un equipo de proyecto pequeño. La metodología consiste en una
programación rápida o extrema, utiliza un enfoque orientado a objetivos, cuya particularidad es
tener como parte del equipo, al usuario final, pues es uno de los requisitos para llegar al éxito
del proyecto.
Esta metodología se encuentra compuesta de cuatro actividades del marco del trabajo:
planeación, diseño, codificación y pruebas.

54
Las características más relevantes de la programación extrema son las siguientes:
 Refabricación: se basa en la utilización repetitiva de código, para lo cual se establecen
patrones, permitiendo mayor flexibilidad al cambio.
 Programación en pares: Consiste en que dos desarrolladores trabajen para un proyecto
en la misma estación de trabajo.
 Pruebas: la fase de prueba se compone de dos tipos, las pruebas de unidad y las
pruebas de aceptación. Las pruebas de unidad se basan en las pruebas realizadas a los
principales procesos y las pruebas de aceptación son realizadas por los clientes y se
enfoca en las características generales del sistema de su parte visible y su funcionalidad
como tal.

Desarrollo adaptativo de software (DAS)

El desarrollo adaptativo de software fue propuesto por Jim Highsmith como una metodología
para desarrollar software y sistemas muy complejos. Se centra en la colaboración humana y la
organización del equipo.

 En la fase de especulación se inicia el desarrollo del proyecto. En ella se utiliza

información como la misión del cliente, las restricciones del proyecto y los requisitos
básicos para definir el conjunto de ciclos en el que se harán los incrementos del
software.

 Para la fase de colaboración se busca que el equipo no solo se comunique o se

encuentren completamente integrados, se desea que exista confianza, donde se pueda
realizar críticas constructivas y ayudar sin resentimientos, trabajar tan duro como sea
posible, comunicar de una forma oportuna los problemas que se presenten para tomar
acciones efectivas y poseer un conjunto de actitudes que contribuyan al trabajo que se
encuentran realizando.

55
  El aprendizaje permite mejorar el entendimiento real sobre la tecnología, los procesos
utilizados y el proyecto. El aprendizaje individual permite al equipo tener mayor
posibilidad de éxito.

Modelo de desarrollo de sistemas dinámicos (MDSD)

El método de desarrollo de sistemas dinámicos permite la construcción de sistemas con
restricción de tiempo, realizando prototipos incrementales en un ambiente de proyecto
controlado.
Este modelo se compone de dos actividades que se realizan primero y consecuente con ellas
se realizan tres ciclos de vida adicionales, las dos actividades primarias son el estudio de
factibilidad en donde se establecen los requisitos básico del negocio y las restricciones
asociadas a la metodología de manera de evaluar si la misma puede ser realizada bajo el
esquema MDSD, y la segunda es el estudio del negocio donde se establecen los
requerimientos funcionales y la arquitectura básica de la aplicación.

 La iteración de modelo funcional, se realizan diversos prototipos incrementales que

permite mostrar al cliente la funcionalidad del sistema. Con cada iteración se recopilan
requisitos adicionales que pueden ir siendo incluidos en el prototipo.

 La iteración de construcción y diseño contribuyen a agregar el valor operativo del

negocio para los usuarios, a través de la construcción de prototipos durante la iteración
del modelo funcional.

 Implementación, los prototipos que vayan surgiendo de la fase de construcción y

diseño, se Irán colocando en ambientes operativos (prototipos operacionales).

56
Con basea a la informacion analisada anteriormente, sobre los modelos de desaallo ágil,
completa el siguiente esquema grafico de conceptos.

¿Qué es?

Programación
extrema (PE)

Desarrollo adaptativo
de software (DAS)
Modelos de
desarrollo ágil

Modelo de desarrollo de
sistemas dinámicos
(MDSD)

57
Identifica las fases del modelo en espiral para el desarrollo de software
El modelo en espiral en el desarrollo de
software es un modelo iterativo, tan
pronto culmina un esfuerzo del desarrollo
por ahí mismo comienza otro; además en
cada ejecución del desarrollo se siguen
cuatro pasos principales:

1. Determinar o fijar los objetivos:

En este paso se definen los objetivos específicos para posteriormente identificar las
limitaciones del proceso y del sistema de software, además se diseña una planificación
detallada de gestión se identifican los riesgos.
2. Análisis del riesgo:
En este paso se efectúa un análisis detallado para cada uno de los riesgos identificados del
proyecto, se definen los pasos a seguir para reducir los riesgos y luego del análisis de estos
riesgos se planean estrategias alternativas.
3. Desarrollar, verificar y validar:
En este tercer paso, después del análisis de riesgo, se eligen un paradigma para el desarrollo
del sistema de software y se lo desarrolla.
4. Planificar:
En este último paso es donde el proyecto se revisa y se toma la decisión si se debe continuar
con un ciclo posterior al de la espiral. Si se decide continuar, se desarrollan los planes para la
siguiente fase del proyecto. Con cada iteración alrededor de la espiral, se crean sucesivas
versiones del software, cada vez más completas y, al final, el sistema de software ya queda
totalmente funcional.
La diferencia principal entre el modelo espiral y los otros modelos que existen, es la evaluación
del riesgo. El riesgo es todo lo que pueda salir mal en un proyecto de desarrollo de software.
Por ejemplo, si queremos utilizar un lenguaje de programación para desarrollar un sistema
operativo, un riesgo posible es que los compiladores utilizables no produzcan un código objeto
eficiente. Los riesgos originan problemas en el proyecto, como el exceso de los costos. Es así
que, la disminución de los riesgos es una actividad muy importante. Un modelo espiral
comienza con la determinación de los objetivos tanto funcionales como de rendimiento.
Después se enumeran algunas formas posibles de alcanzar estos objetivos identificando las
fuentes de riesgos posibles. Luego continuamos con el siguiente paso que es resolver estos
riesgos y llevar a cabo las actividades de desarrollo, para finalizar con la planificación del
siguiente ciclo de la espiral.

58
Características del modelo en espiral para el desarrollo de software
Es considerado como un modelo
evolutivo ya que combina el modelo
clásico con el diseño de prototipos.
Contiene una nueva etapa que es el
análisis de riesgos, no incluida
anteriormente. Este modelo es el
indicado para desarrollar software con
diferentes versiones actualizadas como
se hace con los programas modernos
de PC´s.

La ingeniería puede desarrollarse a

través del ciclo de vida clásico o el de
construcción de prototipos. Este es el
enfoque más realista actualmente. El
modelo en espiral esta compartida en
varias actividades estructurales,
también llamadas regiones de tareas.
Existen seis regiones de tareas que
son:

1. Comunicación con el cliente:

Esta es una tarea requerida para establecer comunicación entre el desarrollador y el cliente.
2. Planificación:
Esta tarea es necesaria aplicarla para poder definir los recursos, el tiempo y otras informaciones
relacionadas con el proyecto, es decir, son todos los requerimientos.
3. Análisis de riesgos:
Esta es una de las tareas principales por lo que se aplica el modelo en espiral, es requerida
para evaluar los riesgos técnicos y otras informaciones relacionadas con el proyecto.
4. Ingeniería:
Esta es una tarea necesaria ya que se requiere construir una o más representaciones de la
aplicación.
5. Construcción y adaptación:
Esta tarea es requerida en el modelo espiral porque se necesita construir, probar, instalar y
proporcionar soporte al usuario.
6. Evaluación del cliente:
Esta también es una tarea principal, necesaria para adquirir la reacción del cliente según la
evaluación de las representaciones del software creadas durante la etapa de ingeniería y la de
implementación creada durante la etapa de instalación.

59
Con base a la información anterior completa la tabla de las distintas regiones de tareas del
modelo en espiral para el desarrollo de software:
Regiones de tareas del modelo en espiral

Comunicación
con el cliente:

Planificación:

Esta tarea es necesaria aplicarla para poder definir los recursos, el

tiempo y otras informaciones relacionadas con el proyecto, es
decir, son todos los requerimientos.

Ingeniería:

Esta tarea es requerida en el modelo espiral porque se necesita

construir, probar, instalar y proporcionar soporte al usuario.

Evaluación
del cliente:

60
Ventajas del modelo en espiral.
 Puede adaptarse y aplicarse a lo largo de la vida del software.
 Como el software evoluciona, a medida que progresa el proceso, el desarrollador y el
cliente comprenden y reaccionan mejor ante riesgos en cada uno de los niveles
evolutivos.
 Permite a quien lo desarrolla aplicar el enfoque de construcción de prototipos en
cualquier etapa de evolución del producto.
 Demanda una consideración directa de los riesgos técnicos en todas las etapas del
proyecto.
 Reduce los riesgos antes de que se conviertan en problemáticos.

Desventajas del modelo en espiral.

 Demostrar al cliente "exigente" (bajo contrato) que el enfoque evolutivo es controlable.
 Requiere gran habilidad y experiencia para valorar el riesgo y saber cuándo detener la
evolución.

Con base a la información anteriormente analizada y con ayuda de internet, realiza una tabla de
ventajas y desventajas del modelo en espiral para el desarrollo de software.
Ventajas Desventajas

61
Utiliza el lenguaje orientado a objetos (JAVA) para el desarrollo de software
Conoce el lenguaje orientado a objetos (JAVA) para el desarrollo de aplicaciones
de una organización.

En el grupo con tu maestro, realiza una lluvia de ideas de los siguientes cuestionamientos:

1. ¿Qué entiendes por programación?

_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
2. ¿Cuál es el objetivo de la programación orientada a objetos?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
3. ¿Qué es un objeto en programación?, menciona un ejemplo.
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________

Lenguaje Orientado a Objetos (JAVA)

El lenguaje de programación, Java aplica la programación orientada a objetos (POO). La POO
define a los programas en términos de “clases de objetos”, objetos que son entidades que
combinan estado (datos), comportamiento (procedimientos o métodos) e identidad (propiedad o
atributo del objeto) que lo diferencia de los demás. La POO expresa un programa como un
conjunto de objetos, que colaboran entre ellos para realizar tareas.
Podríamos decir que las características de los objetos son:
 Los objetos se pueden agrupar para formar las clases.
 El estado de los objetos está determinado por los datos.
 Pueden heredar propiedades o atributos de otros objetos.
 Usando Mensajes un objeto se puede comunicar con otro objeto.
 Los métodos definen el comportamiento de los objetos.
JAVA es un lenguaje de programación orientado a objetos, actualmente es uno de los lenguajes
de programación más utilizados en el mundo.

62
Su evolución viene desde la programación no estructurada, estructurada, modular,
programación que usa objetos y programación orientada a objetos (Visual Basic, .Net y Java).

Java es un lenguaje útil para casi todo tipo de problemas, entre ellos podemos
destacar:
 Aplicaciones Cliente: estas son las que se ejecutan en un solo equipo, sin
necesidad de conectarse a otro equipo.
 Aplicaciones Cliente/Servidor: son programas que necesitan conectarse a
otra máquina (servidor de datos) para solicitar algún servicio.
 Aplicaciones Web: son programas Java que se ejecutan en un servidor de páginas Web
(emplea internet y HTML).
La intención de Java es permitir que los desarrolladores escriban el programa una sola vez y lo
ejecuten en cualquier dispositivo, lo que quiere decir que el código que es ejecutado no requiere
ser recompilado para correr en otro equipo o tecnología.
La tecnología Java se usa para desarrollar aplicaciones con un amplio
alcance de entornos, desde dispositivos del consumidor hasta sistemas
empresariales.
Como cualquier lenguaje de programación, el lenguaje Java tiene su propia
estructura, reglas de sintaxis y paradigma de programación.
Estructuralmente, el lenguaje Java comienza con paquetes. Un
paquete es el mecanismo de espacio de nombres del lenguaje Java.

63
Dentro de los paquetes se encuentran las clases y dentro de las clases se encuentran métodos,
variables, constantes, entre otros.

Elabora un cuadro sinóptico referente al lenguaje de programación orientada a objetos JAVA, a

partir de la información anterior.

64
Elementos de JAVA
El Compilador Java
Cuando se programa en plataforma Java, se escribe el código de origen en archivos .java y
luego los compila. El compilador verifica su código con las reglas de sintaxis del lenguaje, luego
escribe los códigos byte en archivos .class. Los códigos byte son instrucciones estándar
destinadas a ejecutarse en una Máquina virtual Java (JVM). Al agregar este nivel de
abstracción, el compilador Java difiere de los otros compiladores de lenguaje, que escriben
instrucciones apropiadas para el chipset de la CPU en el que el programa se ejecutará.

La JVM
Al momento de la ejecución, la JVM (Java Virtual Machine)
lee e interpreta archivos .class y ejecuta las instrucciones
del programa en la plataforma de hardware nativo para la
que se escribió la JVM.
La JVM interpreta los códigos byte del mismo modo en que
una CPU interpretaría las instrucciones del lenguaje del
conjunto. La diferencia es que la JVM es un software
escrito específicamente para una plataforma particular.
La JVM es el corazón del principio “escrito una vez, ejecutado en cualquier lugar” del lenguaje
Java. Su código se puede ejecutar en cualquier chipset para el cual una implementación
apropiada de la JVM está disponible.
Las JVM están disponibles para las plataformas principales como Linux y Windows y se han
implementado subconjuntos del lenguaje Java en las JVM para teléfonos móviles y aficionados
de chips.

El recolector de basura en Java

Se ejecuta en segundo plano y realiza un seguimiento de cuáles son los objetos que la
aplicación ya no necesita y recupera la memoria que ellos ocupaban. La recogida de basura es
una de las funciones esenciales del rendimiento Java, ya que facilita a los programadores la
creación de programas, una mayor productividad, simplificar el código de las aplicaciones, evita
fallos en tiempo de ejecución con posibilidad de que sean difíciles de depurar, evita en gran
medida las fugas de memoria y fallos graves de seguridad. Libera al programador la gestión de
la memoria, tanto para solicitarla como para devolverla al sistema.

JDK en JAVA
Java Development Kit, es un software que provee herramientas
de Desarrollo para la creación de programas en Java. Puede
instalarse en una Computadora local o en una unidad de Red.
A diferencia de C, por ejemplo, que el código fuente tiene que
ser compilado para cada plataforma, el Kit de Desarrollo de Java
contiene las herramientas y librerías necesarias para crear y
ejecutar applets y aplicaciones en Java.

65
A continuación, se listan algunas de las utilidades que se pueden encontrar en el JDK
 JRE. Es el intérprete en tiempo de ejecución, el cual, permite la ejecución de los
programas Java (*.class) no gráficos (aplicaciones).

 javac. Es el compilador de Java. Se utiliza para compilar archivos de código fuente Java
(habitualmente *.java), en archivos de clases Java ejecutables (*.class).

 jdb. Permite depurar aplicaciones Java. No es un entorno de características visuales,

pero permite encontrar y eliminar los errores de los programas Java con mucha
exactitud.

 javap. Es un desensamblador de Java. Es útil cuando no se tiene el código fuente de

una clase de la que se quisiera saber cómo fue codificada.

 javadoc. Se utiliza para crear documentación en formato HTML a partir del código
fuente Java y los comentarios que contiene.

 java. Es el intérprete de Java. Ejecuta el bytecode a partir de los archivos class.

 appletviewer. Es un visor de applets. En la mayoría de las ocasiones puede utilizarse

en lugar de un Navegador Web.

Una vez instalado el JDK, es necesario definir unos valores, en las llamadas variables de
entorno, con el objeto de configurar las aplicaciones del JDK, para su correcto funcionamiento.
Una variable de entorno es una variable disponible a nivel del sistema operativo, y a la que
cualquier aplicación puede tener acceso.
En el caso del JDK, es necesario definir dos variables de entorno para su correcto
funcionamiento.

Bibliotecas de Clases en Java

Sabemos que Java es un lenguaje de programación con un entorno de ejecución de
aplicaciones como también entorno de ejecución de despliegue de aplicaciones. Es utilizado
para desarrollar applets como aplicaciones.
Java está compuesto de bibliotecas de clases (package) siendo las más importantes:
 Package Lang: compuesta por clases con funcionalidades básicas, arrays, cadenas de
caracteres, entrada/salida, excepciones, etc.

 Package Util: compuesta por clases para utilizadas como números aleatorios, vectores,
propiedades del sistema, etc.

 Package net: compuesta por clases, es usada para la conectividad y trabajo con redes,
URL, etc.

 Package Applet: compuesta por clases, es usada para el desarrollo de aplicaciones

ejecutables en navegadores.

66
  Package Awt y Swing: Awt está compuesta por clases para el desarrollo de interfaces
gráficas de usuario. El paquete swing es el paquete por excelencia para el desarrollo de
los temas del presente curso

Elabora un mapa conceptual acerca del lenguaje de programación JAVA que incluya sus
elementos, bibliotecas y utilidades de JDK.

67
Identifica las palabras reservadas, tipos de variables y sintaxis de un lenguaje de
programación orientada a objetos (JAVA) en el desarrollo de aplicaciones de una
organización.

En el grupo con tu maestro, realiza una lluvia de ideas de los siguientes cuestionamientos:

1. ¿Qué es una variable?

______________________________________________________________
______________________________________________________________
___________________________________________________________
2. ¿Cómo se le llama al nombre que reciben las variables?
______________________________________________________________
______________________________________________________________
___________________________________________________________
3. ¿Qué tipo de variables conoces?
______________________________________________________________
______________________________________________________________
___________________________________________________________
4. ¿A qué se refiere la sintaxis?
______________________________________________________________
______________________________________________________________
___________________________________________________________

Identificadores
Un programa Java está compuesto de diferentes componentes tales como variables,
constantes, métodos, clases, etc. Estos componentes deben de recibir un nombre, pero para
ello existen algunas reglas que se deben de cumplir.
Un identificador es un nombre que identifica a una variable, a un método o función miembro, a
una clase. Todos los lenguajes tienen ciertas reglas para componer los identificadores:
 Todos los identificadores comienzan con una letra, guion bajo o $
 Puede incluir, pero no comenzar por un número
 No puede incluir el carácter espacio en blanco
 Distingue entre letras mayúsculas y minúsculas
 No se pueden utilizar las palabras reservadas como identificadores

68
Además de estas restricciones, hay ciertas convenciones que hacen que el programa sea más
legible, pero que no afectan a la ejecución del programa. La primera y fundamental es la de
encontrar un nombre que sea significativo, de modo que el programa sea lo más legible posible.
Tipo de identificador Convención Ejemplo
Nombre de una clase Comienza con mayúscula String, Rectangulo
Nombre de una función Comienza con minúscula getValue, setColor
Nombre de variable En letras minúsculas altura, nombre
Nombre de constante En letras mayúsculas PI, MAX

Palabras reservadas
Es una palabra que tiene significado “Gramatical Especial”, esto significa que
estas palabras tienen un uso especial para el lenguaje y no pueden ser
utilizadas por el usuario para definir: variables o identificadores, funciones,
objetos, procedimientos y demás elementos de programación.
Como cualquier lenguaje de programación, el lenguaje Java designa ciertas
palabras reservadas que el compilador reconoce como especiales y, como tales,
no se permite usarlas para nombrar sus construcciones Java.
Sorprendentemente la lista de palabras reservadas es muy corta.

Las palabras reservadas se pueden clasificar en las siguientes categorías:

 Tipos de datos: boolean, float, double, int, char
 Sentencias condicionales o iterativas: if, else, switch,for, do, while, continue
 Tratamiento de las excepciones: try, catch, finally, throw
 Estructura de datos: class, interface, implements, extends
 Modificadores y control de acceso: public, private, protected, transient
 Otras: super, null, this.

69
Comentarios
Un comentario es un texto adicional que se añade al código para explicar su funcionalidad, bien
a otras personas que lean el programa, o al propio autor como recordatorio. Los comentarios
son una parte importante de la documentación de un programa. Los comentarios son ignorados
por el compilador, por lo que no incrementan el tamaño del archivo ejecutable; se pueden, por
tanto, añadir libremente al código para que pueda entenderse mejor.
En Java existen tres tipos de comentarios:
1. Comentarios en una sola línea.
Los comentarios de una sola línea // son los más utilizados, ya que no tenemos que
aprendernos los símbolos de inicio y fin del bloque. En la ventana de edición del Entorno
Integrado de Desarrollo (IDE) los comentarios se distinguen del resto del código por el color del
texto.

2. Comentarios de varias líneas.

Un comentario en varias líneas es un bloque de texto situado entre el símbolo de comienzo del
bloque /*, y otro de terminación de este */.

3. Comentarios de documentación.
Los comentarios de documentación es un bloque de texto situado entre el símbolo de comienzo
del bloque /**, y otro de terminación */. El programa javadoc utiliza estos comentarios para
generar la documentación del código.

70
Sentencias
Una sentencia es una orden que se le da al programa para realizar una tarea específica, esta
puede ser: mostrar un mensaje en la pantalla, declarar o inicializar una variable, llamar a una
función, etc.
Las sentencias acaban con ;, este carácter separa una sentencia de la siguiente.
Normalmente, las sentencias se ponen unas debajo de otras, aunque sentencias cortas pueden
colocarse en una misma línea. He aquí algunos ejemplos de sentencias.

int table, numero, cont=1;

import java.util.scanner;
System.out.println("El primer programa");
private javax.swing.ButtonGroup clasificacion;

Es muy importante para la legibilidad de un programa la colocación de unas líneas debajo de

otras empleando tabuladores. El editor del IDE nos ayudará plenamente en esta tarea sin
apenas percibirlo.

Bloques de código
Un bloque de código es un grupo de sentencias que se comportan como una unidad. Un bloque
de código está limitado por las llaves de apertura { y cierre }. Como ejemplos de bloques de
código tenemos la definición de una clase, la definición de una función miembro, una sentencia
iterativa for, etc.
Por ejemplo:
public pulsaciones() {
initComponents();
}

Variables
Una variable es un nombre de un dato a la que sele asigna
un espacio en memoria donde se guarda el valor asignado a
dicha variable.
Hay varios tipos de variables que requieren distintas cantidades de memoria para
guardar datos.

71
Todas las variables deben declararse antes de ser usadas, declarar una variable consiste en
una sentencia en la que indica el tipo de dato y el nombre de la variable. Una vez declarada se
le podrá asignar valores.
Java tiene varios tipos de variables:
 Variables de instancia
Las variables de instancia o miembros dato se usan para guardar los atributos de un objeto
particular.

 Variables de clase
Las variables de clase o miembros dato estáticos son similares a las variables de instancia, con
la excepción de que los valores que guardan son los mismos para todos los objetos de una
determinada clase. En el siguiente ejemplo, PI es una variable de clase y radio es una variable
de instancia. PI guarda el mismo valor para todos los objetos de la clase Circulo, pero el radio
de cada círculo puede ser diferente

class Circulo{
static final double PI=3.1416;
double radio;
//…
}

 Variables locales
Las variables locales se utilizan dentro de las funciones miembro o métodos. En el lenguaje
Java, las variables locales se declaran en el momento en el que son necesarias. Una variable
local existe desde el momento de su definición hasta el final del bloque en el que se encuentra.
En el siguiente ejemplo area es una variable local a la función calcularArea en la que se guarda
el valor del área de un objeto de la clase Circulo.

Class Circulo{
//…
double calcularArea() {
double area=PI*radio*radio;
return area;
}
}

72
  Variables globales
Cuando en un programa vamos a utilizar las mismas variables para diferentes métodos,
podemos declararlas como Variables Globales y quedarían de la siguiente manera, como
ejemplo:

Es una buena costumbre inicializar las variables en el momento en el que son declaradas.
Veamos algunos ejemplos de declaración de algunas variables
int x=0;
String nombre="Olivia";
double a=6.22, b=0.0, c=-2.4;
boolean bNuevo=true;
int[ ] datos;
Como podemos observar, antes del nombre de cada variable se especifica el tipo de variable.
Las variables pueden ser
 Un tipo de dato primitivo
 El nombre de una clase
 Un array
Las variables son uno de los elementos básicos de un programa, y se deben:

Declarar

Usar Inicializar

73
A continuación, añadimos un listado con los tipos de variables y vectores más comunes en
lenguaje de programación orientado a objetos:
 Variables tipo Char: Estas variables contienen un único carácter, es decir, una letra, un
signo o un número.
 Variables tipo Int: Contienen un número entero.
 Variables tipo float: Contienen un número decimal.
Con precisión de 32 bits.
Variables tipo double: Números con punto decimal
de doble precisión (64 bits).
 Variables tipo String: Contienen cadenas de texto,
es un vector con varias variables del tipo Char. En una
cadena se pueden insertar caracteres especiales
como el tabulador \t o un salto de línea \n.
 Variables del tipo Boolean: Solo pueden contener
"False" o "True".

Métodos
Java nos permite crear o hacer nuestros propios métodos y usarlos sencillamente como
también nos facilita hacer uso de los métodos de otras librerías. Aprender a crear métodos en
Java y usarlos correctamente es de gran importancia, separar nuestro código en módulos y
según las tareas que requerimos.
Cuando se ejecuta un programa orientado a objetos, los objetos están recibiendo, interpretando
y respondiendo mensajes de otros objetos y por lo tanto ejecutando métodos asociados con el
objeto. Los métodos se escriben en una clase de objetos y determinan como tiene que actuar el
objeto cuando recibe el mensaje vinculado con ese método. A su vez un método puede también
enviar mensajes a otros objetos solicitando una acción o información, además los atributos
definidos en la clase permiten almacenar información para dicho objeto.
Existen algunas clases de métodos, por ejemplo, aquellos que reciben la información y
almacenan los datos en las variables globales a los cuales se les llama Setters.
- Setters: Del Inglés Set, que significa establecer, sirve para asignar un valor inicial a un
atributo, el Setter nunca retorna nada (Siempre es void), y solo nos permite dar acceso
público a ciertos atributos que deseemos el usuario pueda modificar.
Otro ejemplo, son aquellos que nos regresan la información almacenada en las variables
globales, los cuales llamaremos Getters.
- Getters: Del inglés Get, que significa obtener, pues nos sirve para obtener (recuperar) el
valor ya asignado a un atributo y utilizarlo para cierto método.
Por último, aquellos que realizan alguna operación con los valores utilizados en la clase y varían
en cada una de las aplicaciones.

74
Elabora un cuadro sinóptico referente a los elementos del lenguaje de programación orientada a
objetos JAVA, a partir de la información anterior.

75
Estructuras
Al aplicar la programación orientada a objetos es importante considerar las condicionantes, los
bucles y funciones que se dan en estos desarrollos, en seguida se explica cada uno de ellos.

 Condicionantes o estructuras selectivas

Del mismo modo que en la vida diaria, en un programa es necesario tomar decisiones basadas
en ciertos hechos y actuar en consecuencia. Para ello se usan los condicionantes o estructuras
selectivas, las cuales son código que indican que, para que cierta parte del programa se
ejecute, deben cumplirse ciertas premisas.
El lenguaje Java tiene una sentencia básica denominada if (si condicional) que realiza una
prueba y permite responder de acuerdo con el resultado.
- La sentencia if:
Si la condición es verdadera, la sentencia se ejecuta, de otro modo, se salta dicha sentencia,
continuando la ejecución del programa con otras sentencias a continuación de ésta. La forma
general de la sentencia if es:
if (condición)
sentencia;
Si el resultado de la prueba es verdadero (true) se ejecuta la
sentencia que sigue a continuación de if, en caso contrario, falso
(false), se salta dicha sentencia, tal como se indica en la figura.

La sentencia puede consistir a su vez, en un conjunto de sentencias

agrupadas en un bloque.
if (condición){
sentencia1;
sentencia2;
}

- La sentencia if...else:
Completa la sentencia if, para realizar una acción alternativa
if (condición)
sentencia1;
else
sentencia2

76
Las dos primeras líneas indican que si la condición es verdadera se ejecuta la sentencia 1. La
palabra clave else, significa que si la condición no es verdadera se ejecuta la sentencia 2, tal
como se ve en la figura.
Dado que las sentencias pueden ser simples o compuestas la forma general de if...else es
if (condición){
sentencia1;
sentencia2;
}else{
sentencia3
sentencia4;
sentencia5;
}

- La sentencia switch:
La sentencia if...else tiene dos ramas, el programa va por
una u otra rama dependiendo del valor verdadero o falso
de la expresión evaluada. A veces, es necesario, elegir
entre varias alternativas, como se muestra en la siguiente
figura

La sentencia condicional switch permite agrupar a un

conjunto de sentencias if...else.

switch(expresion){
case valor1:
sentencia1;
break; //sale de switch
case valor2:
sentencia2;
break; //sale switch
case valor3:
sentencia3;
break; //sale de switch
default:
sentencia4;
}

En la sentencia switch, se compara el valor de una variable o el resultado de evaluar una

expresión, con un conjunto de números enteros valor1, valor2, valor3, ... o con un conjunto de
caracteres, cuando coinciden se ejecuta el bloque de sentencias que están asociadas con dicho
número o carácter constante. Dicho bloque de sentencias no está entre llaves, sino que
empieza en la palabra reservada case y termina en su asociado break. Si el compilador no
encuentra coincidencia, se ejecuta la sentencia default, si es que está presente en el código.

77
  Estructuras repetitivas o bucles
Tan importantes como las sentencias condiciones son las sentencias iterativas o repetitivas. El
lenguaje Java, como la mayoría de los lenguajes, proporciona sentencias que permiten realizar
una tarea una y otra vez hasta que se cumpla una determinada condición, dicha tarea viene
definida por un conjunto de sentencias agrupadas en un bloque. Las sentencias iterativas son
for, while y do...while

- La sentencia for
For es una estructura iterativa para ejecutar un mismo segmento de
código una cantidad de veces deseada; conociendo previamente un
valor de inicio, un tamaño de paso y un valor final para el ciclo. La
forma general que adopta la sentencia for es:
for(inicialización; condición; incremento)
sentencia;

El primer término inicialización, se usa para inicializar una variable índice, que controla el
número de veces que se ejecutará el bucle. La condición representa la condición que ha de ser
satisfecha para que el bucle continúe su ejecución. El incremento representa la cantidad que se
incrementa la variable índice en cada repetición.

- La sentencia while
A la palabra reservada while le sigue una condición encerrada
entre paréntesis. El bloque de sentencias que le siguen se
ejecuta siempre que la condición sea verdadera tal como se ve
en la figura. La forma general que adopta la sentencia while es:

while (condición)
sentencia;

- La sentencia do...while
Como hemos podido ver las sentencias for y while la condición está
al principio del bucle, sin embargo, do...while la condición está al
final del bucle, por lo que el bucle se ejecuta por lo menos. do
marca el comienzo del bucle y while el final de este. La forma
general es:

do{
sentencia;
}while(condición);

78
A continuación, se muestra el mismo programa con cada una de las estructuras repetitivas,
dicho programa imprime los números del 0 al 10.

For While Do While

for (int i = 0; i < 10; i++) { while (i<10) { int i=0;
System.out.println(i); do{
System.out.println(i); i++; System.out.println(i);
} } i++;
}while(i < 10);

 Funciones
Las funciones se crearon para evitar tener que repetir constantemente fragmentos de código.
Las funciones son un conjunto de líneas de código (instrucciones), encapsulados en un bloque,
usualmente reciben parámetros, cuyos valores utilizan para efectuar operaciones y
adicionalmente retornan un valor. En otras palabras, una función puede recibir parámetros o
argumentos (algunas no reciben nada), hace uso de dichos valores recibidos como sea
necesario y retorna un valor usando la instrucción return, si no retorna algo, entonces no es una
función. En java las funciones usan el modificador static.

La sintaxis para declarar una función es la siguiente:

El primer componente corresponde al modificador de acceso, que puede ser public o private, el
segundo componente es el modificador que puede ser final o static (o ambas). La función
siempre retorna algo, por lo tanto, es obligatorio declararle un tipo que puede ser int, boolean o
cualquiera, luego debemos darle un nombre a dicha función, para poder identificarla y llamarla
durante la ejecución, después al interior de paréntesis, podemos poner los argumentos o
parámetros. Luego de la definición se define su funcionamiento entre llaves, que es parte del
cuerpo del método y se ejecuta hasta llegar a un return.

79
Elabora un esquema grafico referente a las estructuras y funciones del lenguaje de
programación orientada a objetos JAVA, a partir de la información anterior.

80
Sintaxis del lenguaje
El lenguaje se basa en pensar que hay en el mundo
real objetos y esos objetos tienen un tipo, o clase. Por
ello el lenguaje se basa en clases, que describen como
son los objetos. Por ejemplo, el lenguaje tiene una
clase que describe ficheros, una que describe cadenas
de texto, o bien nosotros podemos crear clases, como
por ejemplo la clase Persona que describe los datos
que interesan de una persona.
Por ello siempre para comenzar a trabajar con un
programa java hay que crear una clase:
public class TablaMultiplicar{
}

Además, se deben de cumplir las siguientes características:

 La clase se debe de llamar exactamente igual que el fichero que la contiene.
 La clase con el mismo nombre que el fichero, debe de estar precedida de la palabra public.
 Puede haber tantas clases como queramos, pero sólo puede haber una con el modificador
public.
La palabra public, indica que la clase es pública, y por tanto que puede ser utilizada desde
cualquier otra clase, con independencia de si están en el mismo paquete o no. Existen otras
palabras como private, protected y sin especificar que indican que estos métodos no son
accesibles para todos.
Después de la palabra class aparece el nombre de la clase, en este ejemplo TablaMultiplicar, el
cual por convención empieza con mayúscula por ser el nombre de una clase; este nombre no
puede ser el mismo que una palabra clave ni tener el mismo nombre que otras variables.
Cuando se intenta ejecutar una clase java la máquina virtual lo que hace es llamar a un método
especial llamado main que debe de estar dentro de la clase a ejecutar y es dentro de la función
main donde escribiremos el código que queremos que se ejecute.
Por ejemplo:
public class TablaMultiplicar{
public static void main(String arg[]){
int numero = Integer.parseInt(arg[0]);
for(int i = 1 ; i<=10 ; i++){
System.out.println(""+numero+" * "+i+" = "+(i*numero));
}
}
}

81
Instala y maneja el entorno de programación orientado a objetos, mediante el uso
de una herramienta de software (Netbeans) para el desarrollo de aplicaciones de
una organización

En el grupo con tu maestro, realiza una lluvia de ideas de los siguientes cuestionamientos:

1. ¿Qué es JAVA?
________________________________________________________________
______________________________________________________________
2. ¿Qué es JDK y cuáles son sus utilidades?
________________________________________________________________
________________________________________________________________
_____________________________________________________________
3. ¿Qué es NetBeans?.
________________________________________________________________
______________________________________________________________

Instalación del software necesario para el módulo:

• Kit de desarrollo de Java SE 8 (JDK).

1.-Descargar desde Google kit de desarrollo de java SE 8 (JDK).

Teclear la
siguiente
instrucción

Seleccione la
primera opción

82
2.- Aparece la siguiente página.

Seleccione la versión
para Windows según
su equipo de 32 o 64
bits

Una vez descargado

instale el archivo JDK

Nota: Si no tiene el JDK en su equipo, no podrá realizar la instalación del Netbeans, ya que
este software lo requiere, es la plataforma en que trabaja.

• Netbeans 8.0.2.

3.- Descargar el Netbeans IDE 8.0.2 (Software para desarrollar aplicaciones Java).

83
4.-Aparece la siguiente página:

Seleccione la versión completa

gratuita y presione Download,
tardará unos segundos

5.- Comienza la descarga del Netbeans a su equipo.

Descarga el
archivo

Instalar el archivo
netbeans 8.0

Realiza un reporte escrito sobre la instalación de JDK con base en la demostración de la

instalación que realizará el maestro en clase. Entrega un reporte escrito sobre la instalación de
Netbeans con base en la demostración de la instalación que realizará el maestro en clase.

84
Diseña una interfaz gráfica mediante la creación de formularios utilizando
software de aplicación (Netbeans) para el desarrollo de aplicaciones

En el grupo con tu maestro, realiza una lluvia de ideas de los siguientes cuestionamientos:

1. ¿Qué es el área de trabajo?

________________________________________________________________
______________________________________________________________
2. ¿Qué es un objeto?
________________________________________________________________
______________________________________________________________
3. Menciona 3 ejemplos de objetos y que propiedades consideras que debe
tener:
________________________________________________________________
________________________________________________________________
_____________________________________________________________

Investiga tres diferentes fuentes de información en medios electrónicos y entrega un reporte de

forma impresa acerca del IDE Netbeans, sus fortalezas, sus debilidades, versiones anteriores,
etc. Se evaluará la limpieza y contenido.
El IDE Netbeans
Netbeans es un entorno de desarrollo integrado libre y gratuito, sin restricciones de uso, hecho
principalmente para el lenguaje de programación Java.
Es una herramienta para programadores pensada para escribir, compilar, depurar y ejecutar
programas.
La plataforma Netbeans permite que las aplicaciones sean desarrolladas a partir de un conjunto
de componentes de software llamados módulos.
Modularidad de Netbeans: Todas las funciones del IDE son provistas por módulos. Cada
módulo provee una función bien definida, tales como el soporte de Java, edición, o soporte para
el sistema de control de versiones. NetBeans contiene todos los módulos necesarios para el
desarrollo de aplicaciones Java en una sola descarga, permitiéndole al usuario comenzar a
trabajar inmediatamente.

85
Simplifica la gestión de grandes proyectos con el uso de diferentes vistas, asistentes de ayuda,
y estructurando la visualización de manera ordenada, lo que ayuda en el trabajo diario. Una vez
que nos metemos en una clase java, por poner un ejemplo, se nos mostrarán distintas ventanas
con el código, su localización en el proyecto, una lista de los métodos y propiedades (ordenadas
alfabéticamente), también hay una vista que nos presenta las jerarquías que tiene nuestra clase
y otras muchas opciones. Por supuesto personalizable según el gusto de cada usuario.

Elabora un mapa conceptual sobre las características del IDE NetBeans.

86
Entorno de la ventana principal del IDE Netbeans.
Cuando se arranca Netbeans aparece en la pantalla una configuración similar a la mostrada en
la siguiente figura:

En NetBeans no existe la necesidad explícita de compilar, puesto que cuenta con una función
de autocompilado. Según vas escribiendo, el programa comprueba tu ortografía y, si has
cometido una falta, la destaca en rojo sobre la marcha. Si queremos saber el motivo del
problema, bastará con situar el cursor sobre una de las marcas de error.
Si examinamos en detalle la ventana de trabajo, apreciaremos los siguientes elementos:
Ventana Administrador de Proyectos (Área de proyectos)
Permite acceder a los distintos formularios y módulos que componen el proyecto. Desde ella se
puede ver el diseño gráfico de dichos formularios, y también permite editar el código que
contienen.

Ventana de propiedades
Muestra todas las propiedades de un control seleccionado en la aplicación. Mediante esta
ventana es posible cambiar los valores de las propiedades de cada uno de los controles
indicando así sus características antes de ejecutar la aplicación. A medida que se seleccionan
los controles en la aplicación, se puede apreciar que las propiedades que antes mostraba la
ventana desaparecen y muestran las propiedades del control que ha sido seleccionado
actualmente.

87
Caja de Herramientas o Paleta de Objetos
Incluye los controles con los que se puede diseñar la pantalla de la aplicación. Estos controles
pueden ser: botones, etiquetas, cajas de texto, zonas gráficas, etc. Para introducir un control en
el formulario simplemente hay que hacer clic con el botón izquierdo del mouse sobre el control
deseado y colocarlo en el formulario con la posición y el tamaño deseado. Haciendo doble clic
sobre el control es también otra forma de colocar el control en el formulario, quedando este
ubicado en el centro del formulario.

Ventana de salida
Muestra los procesos que se realizan al ejecutar el programa, te indica los posibles errores al
momento de la compilación y corrida de la aplicación java. Esta ventana proporciona un informe
sobre la ejecución del programa, indicando los errores.

El Inspector
En esta ventana se puede ver la lista de los componentes que se emplean en el desarrollo del
proyecto.

Área de trabajo
Es el lugar en el que se realizan los formularios. Se divide en dos modos, según la vista
seleccionada: modo de diseño y modo de código fuente.
 Modo de diseño: En este modo se desarrolla el diseño de los componentes que se van
a visualizar en una ventana.
 Modo de código fuente: En este modo se ingresa el código que determinará la acción
que realizará cada componente insertado en el modo de diseño.

Modo Diseño Modo Código fuente

Creación de proyectos en Netbeans(New Project)

Un proyecto en un IDE cualquiera, es un "contenedor" global donde podemos incluir o crear
todos los archivos que de una u otra forma vayan a ser utilizados en nuestro programa, clases,
interfaces, archivos de texto, imágenes, paquetes, etc.
Un proyecto es un conjunto de archivos que integran una aplicación. Una aplicación sencilla
puede incluir varios archivos, y el proyecto es el conjunto de esos archivos.

88
Un proyecto en un entorno de desarrollo nos permite dar un orden y una clasificación a nuestro
trabajo y a nuestros programas, evitando así que estemos desarrollando algo con los archivos
de diferentes programas mezclados en un mismo lugar. Los proyectos nos permiten mantener
ordenado nuestro espacio de trabajo permitiéndonos ser más ágiles y evitar errores.

A continuación, se realizarán los siguientes pasos para crear un proyecto en NetBeans.

Paso 1. Desde el Escritorio se debe dar doble clic al icono de
NetBeans. Una vez que se abra el programa, se procede a crear un
proyecto.

Paso 2. Para crear un proyecto, se trabaja con la barra de menús dando clic en el menú Archivo
(file) y se selecciona Proyecto Nuevo o Ctrl+Mayus+N o Icono

Paso 3. En el cuadro de dialogo que aparece:

89
Paso 5. Definimos características a la nueva aplicación de java:

En el Administrador de proyectos aparece la siguiente estructura:

Comenzamos a crear la estructura para el proyecto.

Crear paquetes de java (New java Package).

Los paquetes en Java (packages) son la forma en la que Java nos permite agrupar de alguna
manera lógica los componentes de nuestra aplicación que estén relacionados entre sí.
Es donde organizaremos las ventanas, imágenes, sonidos, etc., que contendrá la aplicación.

90
En carpeta Source Package dar Click Derecho- New – Java Package.

En el cuadro de dialogo que se muestra:

Se recomienda crear varios Java Package para organizar los archivos que contendrá nuestra
aplicación. Por ejemplo, una carpeta para las ventanas, para las imágenes, los sonidos, etc.
Que puede contener el proyecto de java a desarrollar.
Un proyecto Java puede estar formado de una sola ventana o varias de ellas depende que tan
complejo o completo deseemos la aplicación.

Realiza un reporte escrito sobre los pasos para crear un proyecto y un paquete en Java.
Entrega un reporte escrito sobre la instalación de Netbeans con base en la demostración de la
instalación que realizará el maestro en clase.

91
Emplea código en un lenguaje de programación (JAVA) para la resolución de
problemas en el desarrollo de aplicaciones

En el grupo con tu maestro, realiza una lluvia de ideas de los siguientes cuestionamientos:

1. ¿Cuál es la diferencia entre paquete y proyecto?

________________________________________________________________
______________________________________________________________
2. ¿Qué es un formulario?
________________________________________________________________
______________________________________________________________
3. ¿Qué es el editor de códigos y como tenemos acceso a el?.
________________________________________________________________
________________________________________________________________
_____________________________________________________________

Un proyecto es un contenedor que incluye todos los archivos que de una u otra forma son
utilizados en nuestro programa, clases, archivos de texto, imágenes, paquetes, etc.

Práctica: Crear un proyecto.

A continuación, se muestra cómo crear una aplicación sin formulario, usando las clases del
paquete swing para ingresos y salida de datos.

● Estando en el entorno de desarrollo NetBeans seleccionamos la opción del menú

archivo y luego la opción Proyecto Nuevo…

92
● Al momento de seleccionar Proyecto Nuevo se visualiza la siguiente ventana:

● Seleccionamos para Categorias Java y para Proyectos Java Application y luego damos
click en el botón Siguiente.

● Usamos el botón de comando Examinar para crear una carpeta en la cual se colocarán los
ejercicios. En Nombre Proyecto colocamos el nombre del proyecto.

93
● En el entorno de NetBeans, una clase creada, crea un método que tiene el mismo nombre
de la clase a la que se denomina método constructor y toda programación hecha en este
método se ejecutará primero antes que el método main. NetBeans generará un paquete
(Package) denominado ejercicios y dentro de ella se mostrará la clase de acceso público. El
entorno de desarrollo de NetBeans después de dar click en el botón Terminar queda así:

El código se introduce en la sección del área de trabajo.

● La sección del área de trabajo trae el nombre del paquete generado (package), que es el
lugar en el que agregaremos los paquetes necesarios para nuestro ejercicio.

● Después trae la sección de public class, que determina quién puede acceder a las clases o
propiedades y métodos de una clase.

● Y después el public static void main, el cual es el método que se ejecutara primero y queda
dentro de la public class.

Nota: el texto en gris que aparece en gris son comentarios, los cuales son cualquier información
que se escribe el en programa para proporcionar información de cualquier tipo y no tienen
ningún efecto sobre el comportamiento del programa, es decir, se pueden borrar. Cuando el
comentario es de una solo línea se agrega después de una doble diagonal //comentario, pero
cuando el espacio a ocupar es mayor a una línea entonces se anota el comentario dentro de los
símbolos /* comentario */

94
Crear un proyecto utilizando la Consola NetBeans
Una vez creado el proyecto, agregaremos el código necesario para su funcionamiento:
 Sección package
Haremos un llamado al paquete java.util.Scanner, que permitirá leer valores de entrada de
varios tipos, quedando de la siguiente manera:
package ejemplo;
import java.util.Scanner;

Como se señaló previamente, la parte gris solo son parte de los comentarios, por lo que se
puede borrar o aprovecharse para incluir alguna información como el nombre del autor.

 Posteriormente se trabajará en la sección principal (main).

En esta sección se introduce el código de la aplicación que vamos a crear.

Lo primero que haremos será declarar el objeto de entrada estándar predefinido

Scanner leer=new Scanner(System.in);
Nota: es importante recordar que NetBeans distingue entre mayúsculas y minúsculas, por lo
que es importante respetar la sintaxis, en este ejemplo, la palabra leer puede ser sustituida con
cualquier nombre.

 Una vez declarado el objeto se procede a declarar el resto de las variables y a escribir el
resto del código del programa.

Es necesario tomar en cuenta que:

- Para crear un objeto de clase Scanner, normalmente pasamos el objeto predefinido
System.in, que representa el flujo de entrada estándar.
- Para leer valores numéricos de un determinado tipo de datos XYZ, la función que se
utilizará es nextXYZ(). Por ejemplo, para leer un valor de tipo int, podemos usar
nextInt(), para un float nextFloat(), etc.
- Para leer cadenas (strings), usamos nextLine().
- Para leer un solo carácter, se usa next().
- Para solicitar un dato utilizaremos el objeto System.out acompañado de la instrucción
print o printl.

95
Práctica 1:
Veamos ahora un ejemplo de consola que permita leer el nombre de una persona y al final
imprima un mensaje que diga bienvenido seguido del nombre introducido.

Siguiendo las instrucciones:

- Importar el paquete java.util.Scanner para la lectura de datos
- Declarar el objeto de entrada predefinido Scanner leer=new Scanner (System.in);
- Declarar el resto de las variables, para este ejemplo solo la variable nom de tipo String
- Escribir las instrucciones para que el programa haga lo que se solicita, para este caso
solicita se introduzca un nombre utilizando System.out.println, posteriormente se lee el
nombre y al ser esta una variable String se utiliza la función nextLine() y por ultimo se
imprime el resultado a través de println en este caso con una concatenación “+” entre un
mensaje y una variable.
Una vez concluido se ejecuta y veremos su reproducción en consola.

96
Práctica 2:
A continuación, se muestra un ejemplo de un programa utilizando consola, en este, el programa
solicita 3 calificaciones e imprime su promedio.

97
Realiza los siguientes proyectos utilizando la consola de NetBeans
1. Calcule el total a pagar en la compra de 2 artículos con diferente precio, si se sabe que en la
tienda hay un descuento del 15% sobre el total de la compra. Deberá imprimir el total de la
compra, el descuento y el total a pagar.

2. Que solicita 2 números e imprima cuál de los dos números es mayor, en caso de ser
números iguales deberá imprimir un mensaje que diga “ambos números son iguales”.

3. Que solicite 2 números y posteriormente despliegue un menú con opciones del 1 al 4 que
incluyan las operaciones de suma, resta, multiplicación y división respectivamente además de
un mensaje que solicite una opción, una vez elegida la opción deberá mostrar el resultado de la
operación elegida con los dos números leídos.

98
Crear un proyecto utilizando ventanas de dialogo (JOptionPane)
Una vez creado el proyecto, agregaremos el código necesario para su funcionamiento:
 Sección package
Haremos un llamado al paquete javax.swing.*; que permitirá poder crear ingresos y salida de
datos a través de cajas de mensaje, quedando de la siguiente manera:
package ejemplo;
import javax.swing.*;
/*
@Luis López
*/
- En esta sección podemos utilizar el método showMessageDialog de la clase
JOptionPane que permite mostrar en una caja de mensaje la información que el usuario
desee.

public static void main(String[ ] args) {

JOptionPane.showMessageDialog(null,"BIENVENIDO ");
}

- También utilizamos el método showInputDialog de la clase JOptionPane que a su vez

pertenece al paquete swing, que mostrará una caja de mensaje para la lectura de datos.
Es importante señalar que para la lectura de datos se debe declarar previamente la variable
según su tipo, por ejemplo, si se leerá un dato de tipo cadena como el nombre, entonces la
lectura es:
 Posteriormente se trabajará en la sección principal (main)

public static void main(String[ ] args) {

String nombre;
nombre=(JOptionPane.showInputDialog("Ingrese su nombre:"));
}

99
Si el dato a leer es de algún tipo distinto a String, deberá convertirse el tipo de dato de la
siguiente manera:
public static void main(String[ ] args) {
int edad;
edad=Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese la edad: "));
}

Con el método showInputDialog podemos combinar en la caja de mensaje datos leídos con
mensajes, por ejemplo:

public static void main(String[ ] args) {

String nombre;
nombre=(JOptionPane.showInputDialog("Ingrese su nombre:"));
JOptionPane.showMessageDialog(null,"Bienvenido "+nombre);
}

100
Práctica 1: Crear un proyecto sin Formulario usando JOptionPane
Desarrolla una aplicación para calcular la suma de dos números utilizando jOptionPane.

Para este proyecto se realizó lo siguiente:

 En los comentarios se usó el espacio para agregar de que trata el programa y el nombre
del autor.
 En la sección package se importó javax.swing.*
 Y en la sección principal (main) se utilizaron métodos de la clase JOptionPane.
- showInputDialog para leer datos
- showMessageDialog para mostrar datos.

Una vez que ejecutamos el programa se visualiza de la siguiente manera:

 Solicita la introducción de los números solicitados con showInputDialog:

101
  Muestra el resultado del cálculo de la suma:

Realiza los siguientes proyectos utilizando jOptionPane

1. Que solicite una contraseña a través de un jOptionPane y que despliegue un mensaje de
“ERROR” o “CORRECTO” en un nuevo jOptionPane. La contraseña para este ejemplo es 1234.

2. Que ayude a una empresa a calcular los nuevos salarios de los trabajadores con un
porcentaje de incremento de la siguiente manera:
a) De 0 a $9 000 20%
b) De $9 000 a $15 000 10%
c) De $15 000 a $20 000 5%
d) Más de $20 000 3%

El programa deberá contener 3 jOptionPane, en el primero de ellos se mostrara un menú en el

que se elegirá el tipo de salario en el segundo se solicitara el salario actual y en el tercero
mostrará el nuevo salario.

102
3. Que calcule el factorial de un número, sabiendo que el factorial se obtiene multiplicando dicho
numero por todos los números menores a él, es decir, el factorial de 5 es 5x4x3x2x1.

Crear Ventanas-Formularios (Jframe Form…).

En NetBeans un formulario es una ventana. Un formulario puede ser considerado como una
especie de contenedor para los controles u objetos. Una aplicación puede tener uno o varios
formularios (ventanas), pero un único formulario puede ser suficiente para la creación de una
aplicación sencilla. Los formularios deben también tener un nombre que permita hacerse
referencia a él.

a) Seleccionamos carpeta donde vamos a guardar las ventanas de la aplicación.

Click derecho-New- Jframe Form.. Escribimos el nombre de la ventana (Class Name…)

103
 b) Aparece el formulario en modo de Diseño en el área de trabajo de Netbeans.

Crear un proyecto usando Formulario (jFrame)

Objetos, Propiedades y Clase
Un control u objeto es cada uno de los elementos gráficos que pueden formar parte de una
aplicación típica, por ejemplo, los botones de comando, casillas de verificación, barras de
desplazamiento, cuadros de texto, los botones de opción, etc. y todos ellos van contenidos en
una ventana que se le conoce como formulario.
En un programa o formulario, puede haber varios botones, cada uno de los cuales es un objeto
que pertenece a una clase de los controles (Button), esto es, la clase es la entidad genérica a la
que pertenece un control.
Cada formulario y cada tipo de control tienen un conjunto de propiedades que definen su
aspecto gráfico (tamaño, color, posición en la ventana, tipo y tamaño de letra, etc.) y su forma
de responder a las acciones (eventos) del usuario. Cada propiedad tiene un nombre que viene
ya definido por el lenguaje.
Casi todas las propiedades de los objetos pueden establecerse en tiempo de diseño y también
casi siempre en tiempo de ejecución. En este segundo caso se accede a sus valores por medio
de las sentencias del programa en forma análoga a como se accede a cualquier variable en un
lenguaje de programación. Para ciertas propiedades ésta es la única forma de acceder a ellos.

Nombre de los Objetos

Al realizar los formularios, hay algunas propiedades de los objetos que necesitarás cambiar.
Una propiedad muy importante es la propiedad nombre, ya que ésta permite identificar un
objeto del resto.

104
En principio cada objeto de Netbeans debe tener un nombre, por medio del cual se hace
referencia a dicho objeto. El nombre (variable name) puede ser el que el usuario desee, e
incluso Netbeans proporciona nombres por defecto para los diversos controles. Estos nombres
por defecto hacen referencia al tipo de control y van seguido de un número que se incrementa a
medida que se van introduciendo más controles de ese mismo tipo en el formulario, por
ejemplo, jtextfield1 para una caja de texto, jtextfield2 para otra caja, etc.
Los nombres por defectos no son adecuados porque sólo hacen referencia al tipo de control,
pero no al uso que de dicho control está haciendo el programador. Por ejemplo, si se agregan
dos botones a una aplicación (jbotton1, jbotton2) uno para salir de la aplicación y otro para
guardar los cambios hechos en la aplicación.
Para asignar los nombres a los controles existe una convención ampliamente aceptada que es
la siguiente:
Es recomendable que coloques un prefijo de tres letras a cada nombre de objeto que asignes,
que lo describa, por ejemplo, para un cuadro de texto, puedes incluir txt, para un botón btn, para
una etiqueta lbl, etc.,
Seguido de otras letras (la primera en mayúscula) libremente escogidas por el usuario, que
tienen que hacer referencia al uso que se va a dar a ese control. Por ejemplo, el botón de
cerrar lleve por nombre “btnCerrar” y el botón de guardar “btnGuardar”.

Paleta de Objetos (Palette)

105
Utilizaremos la paleta (palette) para agregar los objetos al formulario. Simplemente
seleccionamos el objeto y arrastramos en el lugar que deseamos que aparezca en el formulario.
Icono Nombre Función
Etiqueta Son elementos no editables. Muestran información o datos
de variables
Botón Realizan tareas cuando se hace clic en ellos, como enviar
o restablecer formularios.
Casilla de activación Admiten múltiples respuestas en un solo grupo de
opciones, se puede seleccionar más de una casilla.
Grupo de botones Agrupa botones de opción, lo que permite poder
seleccionar solamente uno de ese grupo
Área de texto Permite incorporar más de una línea de texto dentro de su
área, puede ser editable o de solo lectura.
Botón de opción Opciones exclusivas de elección. Al seleccionar un botón
en un grupo, se anula la selección de todos los demás.
Campo de texto Es un componente utilizado para la captura de datos, estos
son casi indispensables en una aplicación.
Panel Objetos contenedores, agrupan otros objetos como
botones, campos de texto, etiquetas, etc.

A continuación, se muestran algunas de las más comunes en cada uno de los objetos:
Objeto de control Etiqueta (JLabel)
Un objeto de control Jlabel permite dibujar en el formulario una etiqueta, entendiéndose como
etiqueta una expresión estática que se quiere colocar. También es usado para mostrar los
resultados de un proceso.
Propiedades más usadas:
● Text: Contiene el valor que se
visualizará en el formulario.
● Font: Permite establecer el tipo de
letra de la expresión a mostrar en el
formulario.
● Border: Para establecer el tipo de
borde de la etiqueta.
● Enabled: Para habilitar o inhabilitar el
uso del objeto de control.

Objeto de control Campo de texto (JTextField)

Un objeto de control JTextField permite dibujar en el formulario un cuadro o campo de texto, es
decir, una caja que permite la introducción de un dato o valor. Este objeto es utilizado para el
ingreso de datos.

106
Propiedades más usadas:
● Text: Contiene el valor o dato introducido en el cuadro de texto.
● Font: Permite establecer el tipo de letra del texto en la caja.
● Border: Para establecer el tipo de borde del cuadro de texto.
● Enabled: Para habilitar o inhabilitar el uso del objeto de control.

Métodos más usados:

● getText(): Permite obtener el texto

introducido en el cuadro de texto.
● setText(): Permite colocar un texto en
el objeto JTextField.
● requestFocus(): permite asignar el
cursor al objeto de control.

Objeto de control Botón (JButton)

Un objeto de control JButton permite dibujar en el formulario un objeto que contiene un proceso
a ejecutar. Se utiliza comúnmente para llevar a cabo procesos específicos según la naturaleza
de la aplicación.

Propiedades más usadas:

● Text: Contiene el valor o dato introducido en el cuadro de texto.
● Font: Permite establecer el tipo de letra del texto en la caja.
● Enabled: Para habilitar o inhabilitar el uso del objeto de control.

Evento más usado:

● ActionPerformed: Se lleva a cabo cuando el usuario da click sobre el objeto JButton.

Objeto de control Lista desplegable (JComboBox)

Un objeto de control JComboBox permite dibujar en el formulario una lista desplegable, la cual
contiene opciones (ítems). ComboBox significa “cuadro combinado” porque combina un cuadro
de texto con una caja de lista. Tiene la particularidad de que se debe seleccionar un botón de
comando de despliegue y luego seleccionar la opción o ítem. Una vez dado clic en el botón de
despliegue se muestra las opciones o ítems del objeto.

107
Propiedades más usadas:
● Model: Permite establecer los ítems de la caja de lista.
● Font: Permite establecer el tipo de letra en el objeto de control.
● Enabled: Para habilitar o inhabilitar el uso del objeto de control.
● getSelectedIndex: Contiene el índice del ítem seleccionado
● setSelectedItem: Contiene el ítem seleccionado

Métodos más usados:

● setModel(): Vincula una variable objeto de tipo model a un objeto de control JList.
● getItemAt(): Devuelve el ítem que está en el índice que se especifica.
● getSelectedIndex(): Contiene el valor del índice actual del ítem seleccionado de la caja de
lista. El índice es un valor numérico correlativo no visible que va desde 0.

Evento más usado:

● ValueChanged(): Sucede cuando el usuario selecciona un ítem de la caja de lista.

108
Elabora un cuadro sinóptico sobre los principales objetos contenidos en la paleta de objetos de
Netbeans, incluye su definición, así como sus propiedades, métodos y/o eventos más usados.

109
Crea un formulario en Netbeans que contenga al menos 10 objetos, modifica sus propiedades y
el nombre de sus variables, envía un reporte en Word que incluya la imagen del formulario y la
descripción de cada uno de los elementos especificando el tipo de objeto, imagen, nombre de
variable y propiedades modificadas, por ejemplo:

Objeto Imagen Nombre de variable Propiedades modificadas

1 Etiqueta lblApellido Font, border, text, foreground

Practica 1: Crear un proyecto con Formulario usando jLabel, jTextField y jButton.

Aplicación que solicite la calificación de 3 parciales a través de cuadros de texto. Incluya un
botón para calcular el promedio en otro cuadro de texto, un botón que me permita imprimir el
estatus (aprobado o reprobado) del alumno en una etiqueta según su promedio, e incluya un
botón para limpiar el formulario y otro para salir.
a) Creamos un formulario con: 6 etiquetas, 4 cuadros de texto y 4 botones.
b) Cambiamos el nombre de la variable a cada uno de los objetos, así como sus
propiedades de texto, color, borde y fuente para que tenga un diseño como el siguiente:

110
 c) Agregamos el código para cada uno de los botones
Código para el botón calcular (btnCalcular)
private void btnCalcularActionPerformed(java.awt.event.ActionEvent evt) {
double parcial1, parcial2, parcial3, promedio;
parcial1=Double.parseDouble(txtParcial1.getText());
parcial2=Double.parseDouble(txtParcial2.getText());
parcial3=Double.parseDouble(txtParcial3.getText());
promedio=(parcial1+parcial2+parcial3)/3;
txtPromedio.setText(String.valueOf(promedio));
}
Una vez declaradas las variables de memoria, a la variable parcial1 se le asigna el valor
introducido en el cuadro de texto txtParcial1. El método getText() permite obtener el dato
introducido y con el método parseDouble de la clase Double es convertido a numérico decimal.
Se hace lo mismo para las variables parcial2 y parcial3. Para mostrar el cálculo de promedio se
utiliza el método setText del cuadro de texto txtPromedio que permite visualizar el contenido de
la variable promedio. A la variable se le aplica el método valueOf de la clase String para
convertir el dato promedio en cadena de caracteres.

Código para el botón estatus (btnEstatus)

private void btnEstatusActionPerformed(java.awt.event.ActionEvent evt) {
double promedio;
promedio=Double.parseDouble(txtPromedio.getText());
if (promedio>=6)
lblEstatus.setText("Aprobado");
else
lblEstatus.setText("Reprobado");
}
Obtenemos el dato del txtPromedio con getText() y parseDouble, después se coloca el texto
Aprobado o reprobado en la etiqueta lblEstatus, para ello utilizamos setText, a diferencia del
btnCalcular en este no utilizamos valueOf ya que el valor a introducir es una cadena.

Código para el botón limpiar (btnLimpiar)

private void btnLimpiarActionPerformed(java.awt.event.ActionEvent evt) {
txtParcial1.setText("");
txtParcial2.setText("");
txtParcial3.setText("");
txtPromedio.setText("");
txtParcial1.requestFocus();
}
Se limpian los cuadros de textos a través del método setText() y con el método requestFocus()
se pasa el cursor al objeto de control txtParcial1.

111
Código para el botón salir (btnSalir)
private void btnSalirActionPerformed(java.awt.event.ActionEvent evt) {
dispose();
}
El método dispose() permite descargar el formulario y terminar la ejecución de la aplicación.

d) Ejecutamos la aplicación seleccionando nuestro proyecto y al dar clic en el botón

derecho elegimos Ejecutar Archivo

Se muestra el formulario diseñado en etapa de ejecución, esto es para que se interactúe con el
formulario.
Al ejecutar el formulario podemos observar que el formulario sale con los objetos de control
cercano a los bordes del formulario y el mismo formulario se visualiza pegado en la parte
superior izquierda de la pantalla del computador. Podemos modificar esto agregando dos líneas
de código en el método constructor de la clase promedio.

public class promedio extends javax.swing.JFrame {

public promedio( ) {
initComponents();
setSize (400,400);
setLocation (250,250);
}
El método setSize() permite establecer el tamaño del formulario y el método setLocation()
permite ubicar el formulario dentro de la pantalla. Los valores dentro de los paréntesis se
modifican según se desee la ubicación y tamaño de formulario.

112
Práctica 2: Crear un proyecto con Formulario usando jRadioButton y jButtonGroup.
Crea una aplicación que permita cambiar el texto y color de dos cuadros de texto a través del
uso de botones de opción (jRadioButton), los colores a los que se podrán cambiar son rojos,
verdes y azules. Deberá incluir además 2 botones, el primero que me permita borrar opciones
seleccionadas, así como el contenido de los botones y el otro para salir del programa.
a) Agregamos los objetos necesarios y modificamos el nombre de la variable, así como las
propiedades de texto, color y fuente para que tenga un diseño como el siguiente:

Algo que se debe considerar a la hora de incluir botones de opción, es que al momento de
hacer la ejecución solo se puede elegir una de las opciones, por lo que habrá que colocar los
botones de opción dentro de un grupo de botones, para ello solo se arrastrara la herramienta al
formulario, al hacerlo no aparecerá ningún objeto sobre el formulario por lo que una vez que la
hayamos colocado debemos cambiarle en nombre de variable en la ventana código.
Cuando ya esté creado el grupo de botones debemos agregar cada uno de los botones al grupo
a través de la propiedad buttonGroup.

b) Agregamos el código para los botones y botones de opción

private void btnRojoActionPerformed(java.awt.event.ActionEvent evt) {
txtTexto.setText("Rojo");
txtColor.setBackground(new java.awt.Color(204,0,0));
}
private void btnAzulActionPerformed(java.awt.event.ActionEvent evt) {
txtTexto.setText("Azul");
txtColor.setBackground(new java.awt.Color(0,51,255));
}
private void btnVerdeActionPerformed(java.awt.event.ActionEvent evt) {
txtTexto.setText("Verde");
txtColor.setBackground(new java.awt.Color(105,255,102));
}

113
Colocamos en el objeto txtTexto el nombre del color seleccionado con el método setText y en el
objeto txtColor con el método setBackground se añade color de fondo al cuadro de texto
haciendo un llamado a la clase java.awt.Color la cual permite asignar un color según el formato
RGB mismo que se logra anotando entre paréntesis 3 números comprendidos entre el 0 y 255,
por ejemplo (255,255,255) que es en realidad el color blanco.

Para el botón Nuevo, agregamos el siguiente código:

private void btnNuevoActionPerformed(java.awt.event.ActionEvent evt) {
txtTexto.setText("");
txtColor.setBackground(new java.awt.Color(255,255,255));
btgColor.clearSelection();
}

Al igual que en botones de opción cambiamos el texto y el color de los objetos txtTexto y
txtColor pero además borramos cualquier selección de botón de opción con el método
setSelection() sobre el grupo de botones btgColor.

Para el botón salir (btnSalir) utilizamos el código:

private void btnSalirActionPerformed(java.awt.event.ActionEvent evt) {
dispose();
}

Ejecutamos la aplicación dando clic derecho en el nombre de nuestro formulario y eligiendo la

opción ejecutar archivo.
Si lo deseamos podemos cambiar el tamaño de nuestro formulario y su ubicación en pantalla
utilizando los métodos setSize() y setLocation () respectivamente.

114
Práctica 3: Crear un proyecto con Formulario usando jComboBox e imágenes.
Crea una aplicación que tiene como título las estaciones del año, deberá incluir 1 etiqueta una
para colocar la imagen de la estación seleccionada y 2 cuadros de texto para colocar la fecha
de inicio y fin de esta. La estación será seleccionada a través de una lista desplegable.
Antes de empezar con el diseño del formulario crearemos en nuestro proyecto un paquete con
el nombre imagen, en el cual colocaremos todas las imágenes a utilizar en este proyecto, para
ello damos clic derecho en nuestro proyecto y seleccionamos la opción Nuevo… Java
Package...

Una vez creado el paquete arrastraremos las imágenes que vayamos a utilizar. De acuerdo con
el método que utilizaremos, el formato puede ser JPG, PNG o GIF.

c) Crear el formulario con los objetos necesarios y cambiamos el nombre de variable a

cada uno de los objetos, así como sus propiedades de texto, color, borde, imagen y
fuente para que tenga un diseño como el siguiente:

115
 d) El código de la lista desplegable o jComboBox quedaría de la siguiente manera:

Se inicia asignándole a una variable de tipo entero llamada indice el valor del índice actual del
ítem seleccionado en la lista desplegable a través del método getSelectedIndex().
Después utilizamos la estructura selectiva múltiple switch para que evalúe cuál de los ítems ha
sido seleccionado; sabiendo que, al primer elemento de la lista desplegable, en este caso la
opción estaciones le corresponde el índice 0.
Dentro de cada una de las opciones se cambia el contenido de los cuadros de textos txtinicio y
txtfin. Y se agrega una imagen a lblImagen con el método setIcon(), al cual hay que pasarle
nuestra imagen como argumento utilizando new javax.swing.ImageIcon(URL
location).getImage() donde el argumento location lo obtenemos a través del método
getClass().getResource(). La URL de la imagen lleva el nombre de la carpeta que contiene las
imágenes, nombre del archivo y extensión.
e) Ejecutar el proyecto dando clic derecho en nuestro formulario y eligiendo Ejecutar
Archivo.

116
Práctica 4: Crear un proyecto con Formulario usando jCheckBox.
Crea una aplicación que permita seleccionar varios pasatiempos de una lista, una vez
seleccionados y tras presionar un botón, deberá aparecer en una etiqueta un mensaje que diga
pasatiempos favoritos acompañado de los pasatiempos seleccionados.

a) Diseñar el formulario con los objetos necesarios y cambiamos el nombre de variable a

cada uno de los objetos, así como sus propiedades de texto, color, borde y fuente para
que tenga un diseño como el siguiente:

*
b) Agregamos el código para cada uno de los botones
Código para el botonOk
private void btnOkActionPerformed(java.awt.event.ActionEvent evt) {
String mensaje="Pasatiempos favoritos: ";
if (chkTv.isSelected())
mensaje=mensaje+"*Tv ";
if (chkBailar.isSelected())
mensaje=mensaje+"*Bailar ";
if (chkGym.isSelected())
mensaje=mensaje+"*Gym ";
if (chkLeer.isSelected())
mensaje=mensaje+"*Leer ";
if (chkJugar.isSelected())
mensaje=mensaje+"*Jugar ";
if (chkMusica.isSelected())
mensaje=mensaje+"*Musica ";
if (chkRedes.isSelected()) {
mensaje=mensaje+"*Redes Sociales ";
lblPasatiempo.setText(mensaje);
}

117
Iniciamos con la declaración de la variable mensaje a la cual se le agregará el texto para la
etiqueta lblPasatiempo misma que será colocada utilizando el método setText. Para logar esto
se ira evaluando con una estructura selectiva si los jCheckBox están seleccionados utilizando el
método is.Selected().

Código para el botonLimpiar

private void btnLimpiarActionPerformed(java.awt.event.ActionEvent evt) {
chkMusica.setSelected(false);
chkJugar.setSelected(false);
chkLeer.setSelected(false);
chkRedes.setSelected(false);
chkGym.setSelected(false);
chkBailar.setSelected(false);
chkTv.setSelected(false);
lblPasatiempo.setText("");
}

Limpiamos cada uno de los jCheckbox utilizando el método setSelected() con la expresión false
y para la etiqueta usamos el método setText().
c) Ejecutar el proyecto dando clic derecho en nuestro formulario y eligiendo Ejecutar
Archivo.

118
Práctica 5: Crear un proyecto con Formulario usando jMenuBar, jMenu y jItemMenu.
Aplicación que permita calcular el área y perímetro del circulo y el rectángulo. La aplicación
tendrá una pantalla principal (formulario) que contendrá una barra de menú con un menú
llamado figuras, mismo que contendrá 3 ítems, un ítem nos dará acceso a un formulario que
nos permita calcular los datos del círculo, otro los del rectángulo y el tercer ítem tendrá la opción
salir.
a) Diseñar el formulario del menú principal insertando una barra de menú, misma que
elegiremos en la paleta de objetos en la opción Menús Swing. La jMenuBar, tendrá 3
opciones del tipo jMenu, los cuales nombraremos según su contenido y de igual forma
cambiaremos el nombre de la variable.

Añadiremos además una imagen en una etiqueta en el formulario principal para que
tenga un diseño similar al siguiente:

b) Agregar el código a cada una de los jMenuItem

private void itmRectanguloActionPerformed(java.awt.event.ActionEvent evt) {
Rectangulo obj=new Rectangulo();
obj.setVisible(true);
dispose();
}
private void itmCirculoActionPerformed(java.awt.event.ActionEvent evt) {
circulo obj=new circulo();
obj.setVisible(true);
dispose();
}
private void itmSalirActionPerformed(java.awt.event.ActionEvent evt) {
System.exit(0);
}

Lo primero que se hace en el item Rectángulo y Circulo es crear un objeto que conecta con
cada uno de los formularios y posteriormente se utiliza el método setVisible para poder
visualizar la ventana o formulario, al final se agrega el método dispose() para cerrar el
formulario actual y solo tener un formulario activo. En el caso del itmSalir se utiliza la opción
System.exit(0).

119
 c) Diseñar los formularios circulo y rectángulo para calcular el área y perímetro de cada
uno de ellos dando un diseño similar a los siguientes:

d) Introducir el código en los botones calcular y menu principal respectivamente, para el

caso del circulo el código sería el siguiente:

Y para el rectángulo:

Ambos utilizan los métodos getText(), setText(), setVisible(), dispose(), etc.

120
Realiza los siguientes proyectos utilizando Formularios
1. Aplicación que permita calcular la colegiatura de un alumno, la cual está en función del
número de materias cursadas y el costo de estas, por lo cual deberá solicitar estos datos a
través de campos de texto.
Para motivar al estudiante la institución maneja un incentivo acorde al promedio del semestre
anterior:
 Si el promedio es 9 o superior obtiene descuento del 25% y no paga IVA.
 Si el promedio es 8 obtiene un descuento del de 15% y paga IVA.
 Si el promedio es menor a 7 no obtiene descuento y paga IVA.
La aplicación deberá mostrar en campos de texto el subtotal, descuento, IVA y total. El
promedio deberá mostrarse en una lista desplegable con números enteros del 6 al 10 y deberá
incluir botón de calcular, nuevo y salir.

121
2. Aplicación para una casa de cambio que presente una pantalla inicial con 2 botones que
permitan elegir el tipo de conversión y un botón para salir de la aplicación.

Dependiendo de la opción elegida se abrirá en cada caso un nuevo formulario que solicitará el
tipo de cambio y la cantidad a cambiar y mostrará el total. Incluirá además un botón que le
permita regresar al menú principal.

122
A continuación, se te presenta una serie de cuestionamientos, responde a cada uno de ellos
subrayando la respuesta correcta.
1. Modelo en el que el software se desarrolla en una serie de versiones incrementales, a
medida que se va incrementando las iteraciones las versiones son más completas.
a) Cascada b) Prototipo c) Extrema d) Espiral e) Adaptativo
2. Al conjunto estructurado de las actividades requeridas para realizar un sistema de software
se le denomina proceso de:
a) Diseño b) Integración c) Desarrollo d) Planificación e) Procesos
3. Orden que se le da al programa para realizar una tarea específica, por ejemplo: mostrar un
mensaje en la pantalla:
a) Variable b) Constante c) Comentario d) Sentencia e) Identificador
4. Método que sirve para asignar un valor inicial a un atributo, no regresa nada y solo nos
permite dar acceso a ciertos atributos que deseemos modificar:
a) Setters b) Applets c) Getters d) While e) Return
5. Tipo de programación que expresa un programa como un conjunto de objetos, que
colaboran entre ellos para realizar tareas.
a) POO b) Modular c) Estructurada d) Directa e) Abstracta
6. Verifica su código con las reglas de sintaxis del lenguaje, luego escribe los códigos byte en
archivos .class.
a) Máquina b) Recolector c) Compilador d) Kit de e) Desensamblado
virtual JAVA JAVA desarrollo r JAVA
7. Indica que una clase puede ser utilizada desde cualquier otra clase, con independencia si
están en el mismo paquete o no.
a) Class b) Private c) Static d) Public e) Void
8. Entorno de desarrollo integrado libre y gratuito, sin restricciones de uso, hecho
principalmente para el lenguaje de programación Java:
a) CodeBlocks b) Netbeans c) Junit d) C++ e) JDK
9. Incluye los controles (botones, etiquetas, cajas de texto, etc.) con los que se puede diseñar
la pantalla de la aplicación.
a) Paleta de b) Ventana c) Inspector de d) Ventana de e) Ventana
objetos de salida proyecto administrador propiedades
10. Definen el aspecto gráfico de un control (tamaño, color, posición en la ventana, tipo y
tamaño de letra, etc.).
a) Herramientas b) Propiedades c) Clases d) Objetos e) Eventos

123
124
 UNIDAD III
Prueba, implementa y
documenta las aplicaciones
desarrolladas

COMPETENCIAS
Competencias Genéricas

CG1: Se conoce y valora a sí mismo y aborda problemas y retos teniendo en cuenta los objetivos que
persigue.
CG4: Escucha, interpreta y emite mensajes pertinentes en distintos contextos mediante la utilización de
medios, códigos y herramientas apropiados.
CG5: Desarrolla innovaciones y propone soluciones a problemas a partir de métodos establecidos.
CG8: Participa y colabora de manera efectiva en equipos diversos.

Competencias Disciplinares
C1. Identifica, ordena e interpreta las ideas, datos y conceptos explícitos e implícitos en un texto,
considerando el contexto en el que se generó y en el que se recibe.
CE9: Diseña modelos o prototipos para resolver problemas,
125 satisfacer necesidades o demostrar principios
científicos.
 Identifica los tipos de pruebas (de unidad y de integración) que se le aplican al software
del sistema en la solución de problemas reales.
 Aplica las pruebas de unidad e integración al software del sistema en la solución de
problemas reales.
 Conoce los métodos de implementación (directo, paralelo y piloto) del sistema de
información para la solución de problemas reales.
 Aplica los métodos de implementación del sistema de información para la solución de
problemas reales.
 Elabora el Manual técnico y del usuario del sistema en el desarrollo de aplicaciones en
una organización.
 Identifica los tipos de mantenimiento a las aplicaciones desarrolladas (correctivo,
evolutivo, adaptativo y perfectivo) en la solución de problemas reales.
 Aplica el mantenimiento a las aplicaciones realizadas en la solución de problemas
reales.

126
A continuación, se te presenta una serie de cuestionamientos, responde a cada uno de ellos
subrayando la respuesta correcta.
1. Permite detectar la presencia de errores que pudieran generar las entradas o salidas de
datos y comportamientos inapropiados durante la ejecución de un programa:
a) Prueba b) Diseño c) Implantación d) Desarrollo e) Documentación
2. Tipo de prueba que se focaliza en ejecutar cada módulo o unidad mínima a ser probada:
a) Integración b) Unitaria c) Aceptación d) Funcional e) Procesos
3. Determina que funcionalidades del producto y/o software serán probadas durante el
transcurso de la prueba:
a) Alcance b) Tipos c) Estrategia d) Criterio de salida e) Diseño
4. Conjunto de clases (framework) que permite realizar la ejecución de clases Java de manera
controlada, para evaluar el funcionamiento de cada uno de los métodos.
a) Javadoc b) Applets c) jUnit d) SilkTest e) WinRunner
5. Método de implantación que consiste en la sustitución del viejo sistema por el nuevo de
forma inmediata.
a) Piloto b) Paralelo c) Exacto d) Directo e) Abstracto
6. Consiste en preparar a los usuarios del sistema y se debe llevar a cabo usando manuales o
instructivos realizados durante el diseño.
a) Adiestramiento b) Pruebas c) Aceptación d) Conversión e) Liberación
7. Contiene toda la información sobre los recursos utilizados por el proyecto, llevan una
descripción detallada sobre las características físicas y técnicas de cada elemento.
a) Manual b) Manual de c) Instructivo d) índice e) Contenido
técnico usuario

8. Considera la relación de los capítulos y páginas correspondientes que forman parte del
documento.
a) Introducción b) Índice c) Instructivo d) Referencia e) Contenido
9. Tipo de mantenimiento que consiste en la revisión constante del software para detectar posibles
focos de problemas que puedan surgir en el futuro.
a) Perfectivo b) Adaptativo c) Evolutivo d) Preventivo e) Correctivo
10. Tipo de mantenimiento que ocurre cuando el usuario solicita agregar nuevas funcionalidades no
contempladas al momento de la implementación del software:
a) Perfectivo b) Adaptativo c) Evolutivo d) Preventivo e) Correctivo

127
Aplica las pruebas al software del sistema en la solución de problemas reales.
Identifica los tipos de pruebas (de unidad y de integración) que se le aplican al
software del sistema

En el grupo con tu maestro, realiza una lluvia de ideas de los siguientes cuestionamientos:

1. ¿Qué es una prueba de software?

_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
2. ¿Cómo debe ser el proceso de prueba?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
3. ¿Quién debe llevar a cabo el proceso de prueba?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________

Pruebas de software
Unas de las vías más importantes para determinar el estado de la calidad de un producto de
software es el proceso de pruebas. Estas están dirigidas a componentes del sistema en su
totalidad, con el objetivo de medir el grado en que cumple con los requerimientos. En ellas se
usan casos de prueba, especificados de forma estructurada mediante técnicas.
La prueba es una actividad fundamental en muchos procesos de desarrollo, incluyendo el del
software. Estas permiten detectar la presencia de errores que pudieran generar las entradas o
salidas de datos y comportamientos inapropiados durante su ejecución.
Una prueba puede definirse como una actividad en la cual un sistema o componente es
ejecutado bajo condiciones específicas, se observan o almacenan los resultados y se realiza
una evaluación de algún aspecto del sistema o componente.
Al aplicarles las pruebas al software se deben seguir un conjunto de estrategias para lograr que
estas se hagan en el menor tiempo posible y con la calidad requerida, además de garantizar
que arrojen los resultados esperados.

128
Niveles de prueba que se le aplican al software del sistema

En un proceso de prueba formal, suelen confundirse con mucha

facilidad, los niveles de pruebas con los tipos de prueba, y a pesar
de que se encuentren íntimamente relacionadas, tienen
connotaciones diferentes en el proceso.
Las pruebas pueden ejecutarse en cualquier punto del proceso de
desarrollo de software, y es aquí donde los niveles de prueba nos
permiten entender con claridad los diferentes puntos o etapas en
donde pueden ejecutarse ciertos tipos de prueba.
La terminología apropiada para referirse a los diferentes niveles
es: pruebas unitarias, pruebas de integración, pruebas de sistema
y pruebas de aceptación. En cada uno de estos niveles de prueba, se podrán ejecutar
diferentes tipos de prueba tales como: pruebas funcionales, no funcionales, de arquitectura y
asociadas el cambio de los productos.
A continuación, una breve descripción de cada nivel de prueba:

Pruebas Unitarias o de Componente:

Son ejecutadas por el equipo de desarrollo, consisten en
la ejecución de actividades que permitan verificar que los
componentes unitarios están codificados bajo
condiciones de robustez, esto es, soportando el ingreso
de datos erróneos o inesperados y demostrando así la
capacidad de tratar errores de manera controlada.

 Objetivo:
- Se focaliza en ejecutar cada módulo o unidad mínima a ser probada, por ejemplo,
una clase, lo que provee un mejor modo de manejar la integración de las unidades
en componentes mayores.
- Busca asegurar que el código funciona de acuerdo con las especificaciones y que el
módulo lógico es válido.

 Descripción de la prueba:
- Particionar los módulos en pruebas en unidades lógicas fáciles de probar.
- Por cada unidad hay que definir los casos de prueba.
- Los casos de prueba deben diseñarse de forma tal que se recorran todos los
caminos de ejecución posibles dentro del código bajo prueba.

 Técnica:
- Comparar el resultado esperado con el resultado obtenido.
- Si existen errores, reportarlos.

129
Pruebas de Integración:

Este tipo de pruebas son ejecutadas por el equipo de desarrollo y

consisten en la comprobación de que los elementos del software que
interactúan entre sí funcionan de manera correcta.
 Objetivo:
- Identificar errores producidos por la combinación de programas probados
unitariamente.
- Verificar que las interfaces entre las entidades externas (usuarios) y las aplicaciones
funcionan correctamente.
- Verificar que las especificaciones de diseño sean alcanzadas.

 Descripción de la prueba:
- Describe cómo verificar que las interfaces entre las componentes de software
funcionan correctamente.
- Decide qué acciones tomar cuando se descubren problemas.

 Técnica:
- Top-down. Verifica que los módulos de nivel superior llaman a los de nivel inferior de
manera correcta, con los parámetros correctos.
- Down-top. Verifica que los módulos de nivel inferior llaman a los de nivel superior
con los parámetros correctos.

Pruebas de Sistema:

Este tipo de pruebas deben ser ejecutadas idealmente por

un equipo de pruebas ajeno al equipo de desarrollo.
La obligación de este equipo consiste en la ejecución de
actividades de prueba en donde se debe verificar que la
funcionalidad total de un sistema fue implementada de
acuerdo con los documentos de especificación definidos
en el proyecto.
La prueba de sistema es compleja porque intenta validar
un número de características al mismo tiempo, a
diferencia de otras pruebas que sólo se centran en uno o
dos aspectos del sistema al mismo tiempo.
 Objetivo:
- Asegurar la apropiada navegación dentro del sistema, ingreso de datos,
procesamiento y recuperación.
 Descripción de la prueba:
- El objetivo de estas pruebas es verificar el ingreso, procesamiento y recuperación
apropiado de datos.
- Verificar el sistema (y sus procesos internos), la interacción con las aplicaciones que
lo usan vía GUI y analizar las salidas o resultados.
- En esta prueba se determina qué pruebas de Sistema (usabilidad, volumen,
desempeño, etc.) asegurarán que la aplicación alcanzará sus objetivos de negocio.

130
  Técnica:
- Ejecute cada caso de uso o función utilizando datos válidos e inválidos, para verificar
que: los resultados esperados ocurren cuando se utiliza un dato válido y que los
mensajes de error o de advertencia aparecen en el momento adecuado, cuando se
utiliza un dato inválido.

Pruebas de Aceptación:
La prueba de aceptación es ejecutada antes de que la
aplicación sea instalada dentro de un ambiente de
producción.
Es generalmente desarrollada y ejecutada por el cliente
o un especialista de la aplicación y es conducida a
determinar como el sistema satisface sus criterios de
aceptación validando los requisitos que han sido
levantados para el desarrollo, incluyendo a
documentación y procesos de negocio.
Basado en esta prueba el cliente determina si acepta o
rechaza el sistema.

 Objetivo:
- Determinación por parte del cliente de la aceptación o rechazo del sistema
desarrollado.

 Descripción de la prueba:
- Estas pruebas están destinadas a probar que el producto está listo para el uso
operativo. Suelen ser un subconjunto de las pruebas de Sistema.
- Sirve para que el usuario pueda validar si el producto final se ajusta a los requisitos
fijados, es decir, si el producto está listo para ser implantado para el uso operativo en
el entorno del usuario.

 Técnica:
- Realización de los documentos de planes de prueba de aceptación y especificación,
basados en los criterios de aceptación del cliente.
- Han de ser planificados, organizados y formalizados de manera que se determine el
cumplimiento de los requisitos del sistema.

131
Elabora una tabla comparativa en la que describas brevemente lo que se te solicita de cada uno
de los niveles de prueba.

Nivel de Prueba Prueba de Prueba de Prueba de

prueba unitaria integración sistema aceptación
Concepto

Objetivo

Descripción

Técnica

132
Metodología de pruebas

Un proceso de prueba formal, está compuesto, cuando menos por las siguientes etapas:

1. Planeación de Pruebas.

Es la etapa en donde se ejecutan las primeras actividades correspondientes al proceso de

pruebas y tiene como resultado un plan de pruebas el cual considera:
 Alcance de la prueba: determina que funcionalidades del producto y/o software serán
probadas durante el transcurso de la prueba. Este listado de funcionalidades se extrae
con base a un análisis de riesgos realizado de manera previa, que tienen en cuenta
variables tales como el impacto que podría ocasionar la falla de una funcionalidad y la
probabilidad de falla de una funcionalidad.

 Tipos de Prueba: No todos los productos de software requieren la aplicación de todos

los tipos de pruebas que existen, por esta razón, es estrictamente necesario que el líder
de pruebas se plantee preguntas que le permitan determinar qué tipos de prueba son
aplicables al proyecto. Los posibles tipos de prueba a aplicar son: pruebas de
rendimiento, pruebas de carga, pruebas funcionales, entre otros.

 Estrategia de Pruebas: teniendo en cuenta que no es viable probar con base a todas
las posibles combinaciones de datos, es necesario determinar a través de un análisis de
riesgos sobre que funcionalidades debemos centrar nuestra atención. Adicionalmente,
se debe indicar los niveles de pruebas que aplicaremos y la intensidad o profundidad
para cada nivel de pruebas definido. También es importante definir criterios de entrada
y salida para cada ciclo de prueba a ejecutar.

 Criterios de Salida: definir de manera formal, bajo qué condiciones se puede

considerar que una actividad de pruebas fue finalizada. Algunos ejemplos de criterios de
salida son: porcentaje de funcionalidades de alto riesgo probadas con éxito, número
defectos críticos y/o mayores aceptados, etc.

 Otros aspectos: Se debe incluir una estimación de tiempos, roles y/o recursos del
proceso, la preparación del entorno de pruebas, cronograma base, etc.

133
 2. Diseño de Pruebas

Una vez elaborado y aprobado el plan de pruebas, el equipo de trabajo debe iniciar el análisis
de toda la documentación existente con respecto al sistema, con el objeto de iniciar el diseño de
los casos de prueba.
Los entregables claves para iniciar este diseño pueden ser:
 Casos de uso
 Historias de usuario
 Arquitectura del sistema
 Diseños
 Manuales de usuario
 Manuales técnicos
El diseño de los casos debe considerar la elaboración de casos
positivos y negativos. Los casos de prueba negativos permiten validar cómo se comporta el
sistema ante situaciones atípicas y permite verificar la robustez del sistema, atributo que
constituye uno de los requerimientos no funcionales indispensable para cualquier software.
Por último, es necesario definir cuáles son los datos de prueba necesarios para la ejecución de
los casos de prueba diseñados.

3. Implementación y Ejecución de Pruebas

La ejecución de pruebas debe iniciar con la creación de los datos

de prueba necesarios para ejecutar los casos de prueba
diseñados.
La ejecución de estos casos puede realizarse de manera manual
o automatizada; en cualquiera de los casos, cuando se detecte
un fallo en el sistema, este debe ser documentado y registrado
en una herramienta que permita gestionar los defectos.
Una vez el defecto ha sido corregido por la firma desarrolladora en su respectivo proceso de
depuración, es necesario realizar un re-test que permita confirmar que el defecto fue
solucionado de manera exitosa.
Por último, es indispensable ejecutar un ciclo de regresión que nos permita garantizar, que los
defectos corregidos en el proceso de depuración de la firma no hayan desencadenado otros
tipos de defectos en el sistema.

4. Evaluación de Criterios de Salida

Los criterios de salida son necesarios para determinar si es posible dar

por finalizado un ciclo de pruebas. Para esto, es conveniente definir una
serie de métricas que permitirán al finalizar un proceso de pruebas
comparar los resultados obtenidos contra las definidas, sí los resultados
obtenidos no superan las métricas definidas no es posible continuar con el
siguiente ciclo de pruebas.
Existen varios tipos de criterios de salida dentro de los cuales se pueden mencionar:
cubrimiento de funcionalidades en general, cubrimiento de funcionalidades críticas para el
sistema, Número de defectos críticos y mayores detectados, etc.
También es importante aclarar que el proceso de pruebas puede ser suspendido y/o paralizado
debido a aspectos relacionados con el presupuesto, la calidad mínima del sistema requerida
para el inicio formal de pruebas.

134
Cierre del proceso
Durante este periodo de cierre el cual históricamente se ha comprobado que se le destina muy
poco tiempo en la planeación, se deben cerrar las incidencias reportadas, se debe verificar si
los entregables planeados han sido entregados y aprobados, se deben finalizar y aprobar los
documentos de soporte de prueba, analizar las lecciones aprendidas para aplicar en futuros
proyectos, etc.

Elabora un cuadro sinóptico referente a la metodología de pruebas de software, a partir de la

información anterior.

135
Principios fundamentales del proceso de pruebas

A continuación, se dan a conocer 5 principios fundamentales, para los equipos o personas que,
hasta ahora, incursionan en metodologías de pruebas.

1. Las pruebas exhaustivas no son viables:

Para proyectos cuyo número de casos de uso o historias de usuario desarrolladas sea
considerable, se requeriría de una inversión muy alta en cuanto a tiempo y recursos necesarios
para cubrir pruebas sobre todas las funcionalidades del sistema; por esta razón, es conveniente
realizar un análisis de riesgos de todas las funcionalidades y determinar cuáles serán objeto de
prueba y cuáles no. Ninguna funcionalidad que haga parte del ciclo de negocio del aplicativo
debe quedar por fuera de esta revisión. Por otra parte, es necesario evitar para el caso de
funcionalidades complejas, escribir (n) casos de prueba, que cubran todas las posibles
combinaciones de entrada y salida que puede llegar a tener las funcionalidades. Por las
razones ya mencionadas, es altamente sugerible diseñar y ejecutar pruebas de muestra, las
cuales sean elegidas bajo criterios de experiencia y/o aleatoriedad.

2. El proceso no puede demostrar la ausencia de defectos:

Independientemente de la rigurosidad con la que se haya planeado el proceso de pruebas de
un producto, nunca será posible garantizar al ejecutar este proceso, la ausencia total de
defectos de un producto en su paso a producción. Por lo anterior, un proceso de pruebas
planeado puede garantizar una reducción significativa de los posibles fallos y/o defectos del
software, pero nunca podrá garantizar que el software no fallará en su ambiente de producción.

3. Inicio temprano de pruebas:

Las actividades de un proceso de pruebas deben ser incorporadas desde las etapas
de análisis y diseño, y los documentos de especificación y de diseño, deben ser sometidos a
revisiones, lo que ayudará a detectar problemas en la lógica del negocio antes de que se
escriba una sola línea de código. Por lo que cuanto más temprano se detecte un defecto bien
sea sobre los entregables de especificación y diseño o sobre el producto, menos costoso será
para el equipo dar solución a dichos incidentes.

4. Las pruebas no garantizan la calidad del Software:

Una buena práctica que ayuda a mitigar el riesgo de que el usuario final no esté satisfecho con
el producto, es involucrarlo desde instancias tempranas en el proceso y tener en cuenta sus
apreciaciones para generar una retroalimentación a tiempo.

5. Ejecución de pruebas bajo diferentes condiciones:

Por cada ciclo de prueba ejecutado, se deben generar diferentes tipos de condiciones basados
principalmente en la variabilidad de los datos de entrada y demás datos utilizados. No es
conveniente, ejecutar en cada ciclo, los casos de prueba basados en los mismos datos del ciclo
anterior, dado que, con seguridad, se obtendrán los mismos resultados. En conclusión, ejecutar
ciclos bajo diferentes tipos de condiciones, permitirá identificar posibles fallos en el sistema, que
antes no eran fácilmente reproducibles.

136
Tipos de pruebas

Pruebas Unitarias
Al desarrollar un nuevo software o sistema de
información, la primera etapa de pruebas a
considerar es la etapa de pruebas unitarias o
también llamada pruebas de caja blanca (White
Box), estás pruebas también son llamadas
pruebas modulares ya que nos permiten
determinar si un módulo del programa está listo
y correctamente terminado.

Los principales factores para considerar al

inicio de las pruebas son el tamaño del módulo
y su funcionalidad, ya que, si los módulos son muy grandes y contienen muchas
funcionalidades, estos se volverán más complejos de probar y al encontrar algún error será más
difícil ubicar la funcionalidad defectuosa y corregirla, por lo anterior el analista de pruebas podrá
recomendar que un módulo muy complejo sea separado en 2 o 3 módulos más sencillos.

Este tipo de pruebas debe ser realizado por personal

especializado en Software testing, el cual debe estar
familiarizado en el uso de herramientas de depuración y
pruebas, así como conocer el lenguaje de programación en
el que se está desarrollando la aplicación, en la actualidad
existen una gran cantidad de herramientas que apoyan la
labor del analista de pruebas, algunas de las herramientas
que se utilizan para pruebas unitarias son: JUnit, La Suite de Mercury, CPPUnit etc.

No es un requisito indispensable la culminación de todos los módulos del sistema para iniciar
las pruebas, generalmente las pruebas modulares y las pruebas integrales se solapan; en la
actualidad algunas metodologías consideran oportuno iniciar la etapa de pruebas unitarias poco
después del desarrollo.

En esta imagen se muestra lo que se

considera una representación clásica de
Software Testing White Box o pruebas de
caja blanca, en este tipo de pruebas el cubo
representaría un sistema en donde se
pueden observar los diversos componentes
que forman parte del mismo, cada uno de
estos componentes debe ser probado en su
totalidad (óvalos), y también sus interfases o
comunicaciones con los demás componentes (flechas), este tipo de pruebas también son
llamadas pruebas de caja de cristal ya que este último término representa mejor el tipo de
pruebas.

Para este tipo de pruebas se deben tener claros los siguientes aspectos:
 Los datos de entrada son conocidos por el Analista de Pruebas y deben ser precisos, ya
que los resultados de las pruebas dependen de estos.
 Se debe conocer que componentes interactúan en cada caso de prueba.

137
  Conocer de antemano que resultados debe devolver el componente según los datos de
entrada utilizados en la prueba.
 Comparar los datos obtenidos en la prueba con los datos esperados, si son idénticos
podemos decir que el módulo supero la prueba y empieza la siguiente.

Luego de tener una buena cantidad de módulos independientes probados el siguiente paso es
integrarlos, las principales formas de integración que existen son:

1. Integración Incremental
En su realización se debe combinar o unir el siguiente módulo que se debe probar con el
conjunto de módulos ya probados. El número de módulos se incrementa progresivamente hasta
formar el programa completo. Esto se puede realizar de 2 formas:

 Integración Incremental Ascendente:

En este tipo de integración se combinan los módulos de más bajo nivel en grupos que realizan
alguna subfunción específica. A través de un driver (módulo impulsor) se simulan llamadas a los
módulos, se introducen los datos de prueba y se recogen los resultados. Cada grupo se prueba
usando su driver (test integrador), y este luego es sustituido por los módulos de nivel superior
en la jerarquía. En el último paso se prueba el programa completo con sus entradas y salidas
reales.
 Integración Incremental Descendente.
Inicia del módulo de control principal (de mayor nivel) para luego ir incorporando los módulos
subordinados progresivamente. El módulo de mayor nivel hace de impulsor y se escriben
módulos ficticios simulando a los subordinados, que serán llamados por el módulo de control
superior. Después, se prueba cada vez que se incorpora un módulo nuevo al conjunto ya
engarzado. Al terminar cada prueba, sustituir un módulo ficticio subordinado por el real que
reemplazaba, según el orden elegido. Por último, se esciben los módulos ficticios subordinados
que se necesiten para la prueba del nuevo módulo incorporado.

2. Integración No Incremental
La integración no incremental es bastante sencilla y generalmente se recomienda para
proyectos de pequeños. Consiste en probar cada módulo por separado de manera similar a la
integración incremental pero una vez de terminar con los módulos independientes, se continúa
probándolos todos juntos como un todo. La única ventaja es que no se necesita ningún tipo de
trabajo adicional: ni planificar el orden de integración, ni crear módulos impulsores, ni crear
módulos ficticios subordinados. Y entre sus principales deventajas se encuentra que no se tiene
noción de comunicación de los módulos hasta el final, no hay un producto para mostrar, la
cantidad de errores y sus causas, etc.

Pruebas funcionales

Se denominan pruebas funcionales o Functional Testing, a las pruebas de

software que tienen por objetivo probar que los sistemas desarrollados, cumplan
con las funciones específicas para los cuales han sido creados, es común que
este tipo de pruebas sean desarrolladas por analistas de pruebas con apoyo de
algunos usuarios finales, esta etapa suele ser la última etapa de pruebas y al dar
conformidad sobre esta el paso siguiente es el pase a producción.

138
A este tipo de pruebas se les denomina también pruebas de comportamiento o pruebas de caja
negra, ya que los testers o analistas de pruebas, no enfocan su atención a como se generan las
respuestas del sistema, básicamente el enfoque de este tipo de prueba se basa en el análisis
de los datos de entrada y en los de salida.

Las pruebas funcionales en la mayoría de los casos son realizadas

manualmente por el analista de pruebas, también es posible automatizar
este tipo de pruebas utilizando herramientas como WinRunner o SilkTest las
cuales permiten generar scripts conforme nosotros hagamos interacciones
con el aplicativo a probar.

La automatización de pruebas puede resultar compleja y solo la recomendaría en algunas

funcionalidades específicas, por ejemplo, en las pantallas que tendrán mayor uso, generalmente
pantallas de ingreso de datos. Se debe tener en cuenta que el costo de estas licencias suele ser
bastante elevado.

En muchas empresas, solo se aplican pruebas de tipo funcional a los sistemas, dado que son
las que los usuarios comprenden mejor, pero en los últimos años, también se utilizan pruebas
unitarias en la mayoría de los aplicativos desarrollados, siendo las pruebas unitarias una
primera etapa y las pruebas funcionales la segunda y definitiva en la que se da la conformidad
del sistema.

Los sistemas que han pasado por pruebas unitarias tienen un menor tiempo de pruebas
funcionales, este comportamiento es obvio, ya que las pruebas unitarias nos permiten encontrar
los errores más evidentes y fáciles de corregir, en la etapa de pruebas funcionales el sistema
debería estar bastante estable y con muy pocos errores críticos. Si un sistema llega a la etapa
de pruebas funcionales con demasiados errores críticos y/o bloqueantes, se debería devolver el
sistema a la etapa de pruebas unitarias ya que resulta muy poco productivo realizar pruebas
funcionales con sistemas inestables, el avance es demasiado lento y el analista de pruebas no
podrá apoyar mucho en la resolución de los errores ya que en esta etapa solo se centra la
atención en las entradas y salidas, y no en la lógica intermedia, (Black Box – Caja Negra).

139
Aplica las pruebas de unidad e integración al software del sistema en la solución
de problemas reales

En el grupo con tu maestro, realiza una lluvia de ideas de los siguientes cuestionamientos:

1. ¿Porque es importante realizar las pruebas de software?

_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
2. ¿Qué tipo de prueba recomendarías realizar al software?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
3. Menciona al menos dos herramientas para realiza prueba de software
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________

Como regla de la programación se resalta que, si no desarrollamos código de calidad y no se

realizan pruebas, los tiempos de desarrollo se podrán disparar enormemente; tiempo de
integración, tiempo de depuración, tiempo de incidencias, etcétera. Pero hay un problema
mayor; la pérdida de confianza del cliente. Un producto de baja calidad, lleno de incidencias es
la peor tarjeta de presentación.
Las pruebas fomentan el cambio y la refactorización. Si se considera que el código es mejorable
podemos cambiarlo sin ningún problema.
En las pruebas se simulan las dependencias lo que nos permite que podemos probar nuestro
código sin disponer del resto de módulos. Además, permiten comprender mejor qué hace un
módulo y que se espera de él.
Si partimos de la prueba unitaria podemos centrarnos en corregir el error de una forma más
rápida y lógica, asegurándonos que todo funciona según lo esperado, por ello se deben ir
escribiendo a medida que se desarrolla el software lo que nos permite asegurar que el módulo
queda terminado correctamente, libre de incidencias.
La realización de pruebas unitarias debe ser un proceso obligatorio en nuestros desarrollos y
que no queden a la voluntad del desarrollador, dejar la implementación de pruebas para el final
no es realista, ya que las pruebas nunca se llegarán a implementar y si lo hacen, serán de una
baja calidad.
Por otro lado, hay que tener en cuenta que cuando más larga sea la vida de la aplicación más
beneficios se obtendrán del sistema de pruebas unitarias. Muchos productos tienen un

140
mantenimiento evolutivo que implica el desarrollo de nuevas funcionalidades y la corrección de
incidencias. Sin un proceso adecuado de pruebas unitarias, los tiempos de pruebas se
dispararán en fases posteriores, ya que será necesario probar y corregir tanto las nuevas
funcionalidades como las funcionalidades ya existentes.
Una pregunta común es, si aparte de la implementación debes crear otro programa para
probarlo, en realidad, la respuesta es no, ya que existen librerías que te ayudan a desarrollar las
pruebas rápidamente. Es más, IDE´s como Netbeans incluyen atajos y opciones para generar y
ejecutar las pruebas.

La siguiente imagen muestra cómo el proyecto por default de Netbeans ya incluye folders y
librerías para desarrollar pruebas.

141
Probar una lista que tiene como tipo de datos enteros e insertar los valores en orden:

Suponiendo que los métodos iniciales de la lista son los siguientes:

public class ListaDoble {

public void insertar(int n){...}
public NodoDoble remover(int valor){...}
public boolean isEmpty(){...}
public static void main(String args[]){...}
}
Primero, borrar el método main, ya que eso está fuera de las responsabilidades de la clase. Se
realizan tambien dos cambios a la clase:

1. Agregar una variable privada que mantenga el número de elementos en la lista:

numElementos. Se incrementará cuando se inserte un elemento y se decrementará en
el método remover.

2. Adicionar un método que nos retorne la lista como un arreglo de enteros. Esta es una
posible implementación:

public int[] toArray(){

int[] array = new int[numElementos];
int i = 0;
NodoDoble auxiliar = inicio;
while (auxiliar != null) {
array[i] = auxiliar.getDatos();
auxiliar = auxiliar.getSiguienteNodo();
i++;
}
return array;
}

142
Ahora veras lo rápido y fácil que es agregar una prueba:
1. Da clic derecho en la clase que queremos probar, selecciona la opción Tools
(Herramientas) > Create JUnit Tests

2. Aparece un diálogo con opciones para crear la clase que ejecutará las pruebas. Para esta
prueba se selecciona lo mínimo, como puedes ver en la figura.

143
3. Borra el método por default que genera Netbeans y agrega el siguiente método.
@Test
public void testEscenario01() {
ListaDoble lista = new ListaDoble();
// La lista debe estar vacia al inicio
assertTrue(lista.isEmpty());

// Insertemos 5 elementos
lista.insertar(100);
lista.insertar(50);
lista.insertar(200);
lista.insertar(-50);
lista.insertar(0);
assertArrayEquals(lista.toArray(),
new int[]{-50,0,50,100,200});
}

Como se puede ver, este método crea una instancia de ListaDoble. Los métodos assert son
parte de la librería JUnit, y sirven para verificar si cierta condición se cumple. Por ejemplo,
recién creada la lista, se espera que esté vacía, esto lo logramos con
assertTrue(lista.isEmpty()). Después insertamos 5 elementos y verificamos con
assertArrayEquals que el contenido de la lista sea igual al arreglo que pasamos como segundo
parámetro. Nota que el segundo arreglo está ordenado, ya que es lo que esperamos de la lista.

4. Para ejecutar la prueba, simplemente da clic derecho en el archivo de prueba (en este caso
ListaDobleTest) y selecciona Test File

144
Si tu implementación es correcta, aparecerá un mensaje como el siguiente:

La siguiente imagen, se mostraría si existiese algún error en la prueba para ver la salida de
JUnit.

Este ejemplo lleva a reflexionar, que pueden existir errores tanto en la implementación como en
la prueba. Pero es importante notar que sin pruebas confiamos totalmente en la
implementación. Si hay un error al correr las pruebas, el error puede estar en la implementación
o en las pruebas. Si las pruebas corrieron exitosamente, entonces la implementación cumple
con los casos presentados en las pruebas; en otras palabras, puede que tanto la
implementación como las pruebas estén mal. Obviamente, es más difícil equivocarse en dos
lugares (implementación y pruebas) que sólo en uno.

145
También es importante mencionar que las pruebas sólo garantizan que nuestro programa
cumple con los escenarios mencionados, más no que está 100% libre de errores.
El objetivo no es crear tantas pruebas como sea posible. Más bien, es crear el mínimo número
de pruebas que cubran el mayor número de casos o escenarios de nuestra implementación.
Con esto en mente, es recomendable crear escenarios que se complementen.
Si creas tus pruebas unitarias, entonces cada vez que las ejecutes estarás evaluando todos los
escenarios en un abrir y cerrar de ojos. Esto te ayuda a tener más confianza al realizar cambios
o mejoras en tu implementación, ya que puedes ir probando continuamente para validar si algo
deja de funcionar o si algo ya está funcionando.

De una aplicación sugerida por el docente, crea en Netbeans, una prueba unitaria a las clases o
métodos que esta contenga; generando a su vez el reporte correspondiente de práctica para
entregar a tu profesor.

JUnit es un conjunto de clases (framework) que

permite realizar la ejecución de clases Java de
manera controlada, para poder evaluar si el
funcionamiento de cada uno de los métodos de la
clase se comporta como se espera. Es decir, en
función de algún valor de entrada se evalúa el valor
de retorno esperado; si la clase cumple con la
especificación, entonces JUnit devolverá que el
método de la clase pasó exitosamente la prueba; en
caso de que el valor esperado sea diferente al que regresó el método durante la ejecución,
JUnit devolverá un fallo en el método correspondiente.
JUnit es utilizado en programación para hacer pruebas unitarias de aplicaciones Java.
JUnit es también un medio de controlar las pruebas de regresión, necesarias cuando una parte
del código ha sido modificado y se desea ver que el nuevo código cumple con los
requerimientos anteriores y que no se ha alterado su funcionalidad después de la nueva
modificación.

146
Realiza una investigación y entrega a tu profesor un documento escrito, el cual contenga el
proceso de instalación y configuración de JUnit en Netbeas, con el fin de crear y aplicar pruebas
a los programas.

En la actualidad las herramientas de desarrollo como Netbeans cuentan con plug-ins que
permiten que la generación de las plantillas necesarias para la creación de las pruebas
automáticas de una clase Java, facilitando al programador enfocarse en la prueba y el resultado
esperado, y dejando a la herramienta la creación de las clases que permiten coordinar las
pruebas.
Un método Assert es un método de JUnit que realiza una prueba y que retorna un
“AssertionFailedError” si la prueba fallo.

147
Para esta práctica se utilizará Netbeans versión 5.0 el cual ya trae integrado Junit versión 3.8.1.
Para realizar una clase de pruebas unitarias en Netbeans, seleccionamos la clase a la cual le
queremos realizar las pruebas, le damos click derecho y nos vamos a “Tools”, luego en el
submenú que aparecerá se escoge la opción de “Create JUnit Tests”.

Ahora aparecerá una ventana con una serie de opciones, en este caso dejamos las opciones
default y le damos click a “OK”.

148
Automáticamente se creará la clase de pruebas para la clase que se seleccionara, se creara un
método de prueba por cada método que tengamos en nuestra clase original.

A continuación, se presenta una prueba de ejemplo:

public void testMete_pila() {

int expResult = 0;
int resultado = test.mete_pila(8);
System.out.println(“mete_pila=”+resultado);
assertNotSame(expResult, resultado);
}
Y a continuación se muestra el método original:
public int mete_pila(int a) {
this.pila.push(a);
return this.pila.size();
}

Se puede ver que esta prueba nos retorna verdadera ya que la pila no estará vacía, por lo que
la prueba será exitosa.

Después de que se escriben las pruebas para cada método, se deben de correr las pruebas
para ver si nuestro código está correcto.

Para realizarlo, se selecciona “Run” y en el menú escogemos “Test

<nombre_de_la_aplicacion>”.

149
Se generarán los resultados de la prueba y aparecerán en la parte de abajo de la pantalla:

Durante las pruebas de integración que se hacen en el ciclo de vida de desarrollo de software,
los componentes de software individuales se combinan y luego se prueban en su conjunto. En
una aplicación Web Java™ Enterprise Edition (JEE), los componentes de software son, por lo
general, páginas HTML o JavaServer™ Pages (JSP), bibliotecas Javascript, servlets, módulos
Java, controladores de bases de datos, etc.
La fase de pruebas de integración tiene lugar después de la fase de desarrollo, cuando se
realizan las pruebas unitarias de los componentes de software individuales, y antes de las
pruebas de aceptación del cliente.
La fase de pruebas de integración tiene por objeto garantizar que el software esté listo para la
ejecución de pruebas beta con los usuarios finales. Probar aplicaciones manualmente es una
tarea que suele presentar errores. La automatización de las pruebas elimina estos errores;
además, como el proceso no requiere la introducción de datos de prueba, es más eficaz y
rápido.

Crea una tabla comparativa en la que plasmes, las principales diferencias, ventajas y
desventajas entre las pruebas unitarias y de integración. Entrega el producto a tu profesor para
que sea evaluado de acuerdo con lo establecido.

150
Aplica los métodos de implementación del sistema de información para la
solución de problemas reales

En el grupo con tu maestro, realiza una lluvia de ideas de los siguientes cuestionamientos:

1. ¿Qué es la implementación de software?

________________________________________________________________
______________________________________________________________
2. ¿Qué acciones crees que se deben realizar antes de la implementación?
________________________________________________________________
______________________________________________________________
3. ¿Cuáles son los métodos de implementación?
________________________________________________________________
______________________________________________________________

El proceso de implantación constituye el último eslabón de la metodología de desarrollo de

implantación del proyecto y es posterior al proceso de prueba.
Al igual que con los procesos de desarrollo y prueba, la complejidad depende de las
características de la tecnología. Si se trata de un producto estándar, la implantación puede ser
relativamente fácil. Los usuarios también pueden estar relativamente familiarizados con ella si
no difiere sustancialmente de la que se utilizaba con anterioridad. Sin embargo, cuando se trata
de una nueva tecnología, que no ha sido aplicada con anterioridad o es muy diferente de las
prácticas previas, el proceso de implantación debe ser manejado con extremo cuidado y con
atención en los detalles.
La estrategia de implantación, que debe ser explicitada en el plan integral de administración del
proyecto, fijará los pasos necesarios para probar la nueva tecnología. Cuando el nuevo sistema
ha sido probado en forma exhaustiva, es posible que el sistema anterior sea reemplazado por el
nuevo; sin embargo, se debe utilizar un método bien definido y planeado para evitar problemas
durante dicho cambio.
Existen tres métodos principales para el cambio de sistemas:
 CAMBIO DIRECTO: Con este método el nuevo sistema sustituye al viejo en forma
inmediata. Existe el riesgo de que se presenten serios problemas en caso de que el
nuevo sistema proporciones resultados incorrectos, ya
que el usuario se queda sin herramientas para realizar
sus operaciones.

151
  PRODUCCIÓN EN PARALELO. Con esta práctica tanto el nuevo como el viejo sistema
son procesados concurrentemente por un lapso
determinado. Los resultados obtenidos se van verificando y
el nuevo sistema se libera hasta que proporcione por lo
menos los mismos resultados que el sistema anterior. La
mayor desventaja de este método es la duplicación de
esfuerzo tanto del departamento de sistemas.

 PRODUCCIÓN PILOTO. Pone a prueba el nuevo sistema sólo en una parte de la

organización. Al comprobar su efectividad, se implementa en el resto de la organización.
El método es menos costoso que el paralelo, aunque
más riesgoso. Pero en este caso el riesgo es
controlable al limitarse a ciertas áreas, sin afectar toda
la empresa.

La implementación de los sistemas de información es una tarea en la cual participan varios

actores, y cada uno de ellos se encarga de generar las acciones propias de la etapa que les
corresponde.

Independientemente del modelo o método de implementación del software que sea elegido en
la empresa, siempre deben de tener en cuenta las fases de implementación:

En el centro de cómputo, con la guía de tu profesor, utilizando Netbeans genera la interfaz de

un Sistema para el Cobro de productos que son vendidos en la cooperativa escolar, una vez
diseñada esta aplicación (sencilla), realiza la implementación de esta (simuladamente)
siguiendo uno de los métodos vistos antes, pero sin descuidar ninguna de las fases de la
implementación. Genera el reporte de práctica correspondiente.

152
Genera la documentación y aplica mantenimiento a las aplicaciones desarrolladas
en la solución de problemas reales

Elabora el Manual técnico y del usuario del sistema en el desarrollo de

aplicaciones en una organización.

En el grupo con tu maestro, realiza una lluvia de ideas de los siguientes cuestionamientos:

1. ¿Qué es un manual?
________________________________________________________________
________________________________________________________________
2. ¿Qué información viene en los manuales?
________________________________________________________________
________________________________________________________________

Toda la documentación que se relacione con un sistema ya sea impresa o digital, sencilla o
compleja, debe reunir los siguientes requisitos básicos:
 Ser rotulada con claridad y bien organizada en carpetas e índice, con secciones
claramente indicadas.
 Los diagramas deberán ser claros, no aglomerados y la escritura debe ser legible.
 La documentación deberá ser completa.
 Se incluirá una leyenda o explicación de los términos utilizados.
 La documentación siempre se conserva actualizada.
El estilo de redacción de los manuales de documentación debe:

Para iniciar los trabajos que conducen a la integración de un manual, es indispensable

designarse a un coordinador, auxiliado por un equipo técnico, al que se le debe encomendar la
conducción del proyecto en sus fases de diseño, implantación y actualización.
Para el manejo de los sistemas de información que son desarrollados hoy en día se requiere un
manual que guie a las personas que utilizaran los procedimientos que se crearon. Todo con el
propósito de conducirlos paso a paso en el manejo del sistema.

153
Consideraciones para la realización de un manual:
 Compatible con la documentación existente: Explica los procedimientos anteriores y los
actuales, definiendo diferencias y similitudes de la documentación existente.
 Entendible por otros en la organización. La redacción del manual debe ser lo más
práctico posible para que cualquier persona pueda entenderlo.
 Permita regresar a trabajar en el sistema después de un periodo sin usarlo: que permita
la comprensión y clarifique dudas en el manejo de los procedimientos.
 Conveniente para el tamaño de sistema en que está trabajando: Debe contener toda la
documentación necesaria para la comprensión y operación de los usuarios.
 Permita la fácil modificación: Una de las opciones que deben manejar los sistemas y sus
manuales en la libre transportabilidad y flexibilidad para el crecimiento y mejoras de los
sistemas.

Manual técnico
El manual técnico contiene toda la información sobre los recursos utilizados por el proyecto,
llevan una descripción muy bien detallada sobre las características físicas y técnicas de cada
elemento.
Su extensión depende de la cantidad de recursos y equipo utilizado y generalmente se presenta
en forma de fichas técnicas en donde se describe cada una las características de cada recurso.
La estructura del documento del manual técnico incluye los siguientes elementos:
1. Índice.
Considera la relación de los capítulos y páginas correspondientes que forman parte del
documento.
2. Introducción.
Presenta una breve descripción del sistema desarrollado que contemple el ámbito
abarcado, cuál es su función principal y un detalle de las funciones.
3. Contenido técnico
 Definición de reglas del negocio implementadas en el sistema desarrollado.
 Diagramas de flujo de datos, junto con su respectivo diccionario de datos.
 Controles de auditoría implementados en el sistema.
 Descripción de campos requeridos con presentación de pantallas.
 Requerimientos de interfaz con otros sistemas.
 Modelo lógico de datos, diagrama entidad-relación.
 Modelo de datos físico, junto con su respectivo diccionario de datos.
 Matriz de procesos versus organización.
 Matriz de programas versus entidades.
 Plataforma de usuarios. Describe los requerimientos mínimos de hardware y
software para que el sistema se pueda instalar y ejecutar correctamente.
 Mapa de navegación. Muestra de forma gráfica la interconexión entre cada una de
las pantallas del sistema. Muestran menús, submenús y pantallas.
 Descripción gráfica del mapa de navegación. Describe paso a paso los procesos,
pantallas, botones, etc., así como el código de cada rutina.

154
Elabora un cuadro sinóptico que represente la conceptualización y elementos básicos del
manual técnico.

Desarrolla la interfaz gráfica del sistema de información solicitado por tu docente, así como el
manual técnico, cumpliendo con los requerimientos establecidos para su elaboración.

155
Manual del usuario
El manual de usuario es una guía escrita en formato impreso o documentos electrónicos que
proporcionan instrucciones de cómo utilizar el sistema informático.
Consiste en exponer los procesos que el usuario puede realizar con el sistema detallando las
características de los programas y la forma de acceder e introducir información.
Permite a los usuarios conocer las actividades que deberán desarrollar para la consecución de
los objetivos del sistema.
Reúne información, normas y documentación necesaria para que el usuario conozca y utilice
adecuadamente la aplicación desarrollada.
Facilita el conocimiento de que documentos pueden ser ingresados y su formato, las
operaciones de entrada, proceso y salida de datos, etc.

Para diseñar un manual de usuario considerar los siguientes aspectos:

1. Crear la documentación de usuario apropiada considerando quién es el usuario.
2. Componentes del manual de usuario:
a. Portada y carátulas
b. Índice
c. Instrucciones o procedimientos y materiales de consulta
d. Imágenes gráficas para respaldar al texto cuando sea necesario
3. Diseñar un manual de usuario legible
En el contenido se debe considerar los siguientes aspectos:
 Diagrama general del sistema. Muestra el flujo general de la información y de las
actividades que se realizan en el sistema. Proporciona una visión general de este.
 Diagrama particular detallado. Deben especificarse los archivos de entrada, salida, los
resultados, revisiones y procesos manuales.
 Explicación genérica de las fases del sistema. Explica en forma específica todas las
operaciones que aparecen representadas en cada una de las fases.
 Instalación del Sistema. La instalación del sistema proporciona detalles completos
sobre la forma de instalar el sistema en un ambiente particular.
 Iniciación al uso del sistema. Indica cómo iniciarse en el sistema y cómo utilizar sus
cualidades comunes. Indicar cómo salir de un problema o mal funcionamiento.
 Manual de Referencia. Documento definitivo de cara al usuario y debe ser completo.
Describe con detalle las cualidades del sistema y su uso, los informes de error
generados y las situaciones en que surgen esos errores.

Para la elaboración de un manual de usuario se deberán de integrar los siguientes apartados

normativos:

156
Elabora un cuadro sinóptico que represente la conceptualización, elementos básicos y
contenido del manual de usuario.

Completa la siguiente tabla anotando con las diferencias y coincidencias que encuentres entre
los manuales técnicos y de usuario.

Diferencias Coincidencias

Manual Técnico
vs
Manual de usuario

157
Aplica el mantenimiento a las aplicaciones realizadas en la solución de problemas
reales.

ipos de mantenimiento a las aplicaciones desarrolladas (correctivo, evolutivo,

adaptativo y perfectivo).

Una vez instalado el sistema hay que darle mantenimiento, lo cual

implica que tal vez haya que realizar modificaciones en los
programas de computadora y mantenerlos actualizados.
Las estimaciones del tiempo invertido por los departamentos en el
mante nimiento varían desde un 48 hasta un 60 por ciento del
tiempo total invertido en el desarrollo de los sistemas.
El mantenimiento se lleva a cabo por dos razones:
1. Corregir errores de software. Sin importar qué tan
minuciosas sean las pruebas en el sistema, se pueden
infiltrar errores o ‘bugs’ en los programas computacionales los cuales se deben corregir
a medida que se van detectando.
2. Mejorar las capacidades del software en respuesta a las necesidades cambiantes de la
organización, que por lo general implica:
 Solicitud de características adicionales por parte de los usuarios
 La empresa cambia con el tiempo.
 El hardware y el software cambian a un ritmo acelerado.
A lo largo de su vida útil, la aplicación puede necesitar modificaciones por distintas razones, que
determinan diferentes tipos de mantenimiento:
 Mantenimiento preventivo. Consiste en la revisión constante del software para detectar
posibles focos de problemas que puedan surgir en el futuro.
 Mantenimiento predictivo. Evalúa el flujo de ejecución del programa para predecir con
certeza el momento en el que se producirá la falla, y así determinar cuándo es adecuado
realizar los ajustes correspondientes.
 Mantenimiento correctivo. Corrige los defectos encontrados en el software, y que originan
un comportamiento distinto al deseado. Estas fallas pueden ser de procesamiento,
rendimiento, programación, seguridad o estabilidad, entre otras.
 Mantenimiento adaptativo. Si se requiere cambiar el entorno de uso de la aplicación, puede
ser indispensable modificarla para mantener su plena funcionalidad.
 Mantenimiento evolutivo. Es este caso, la adaptación resulta prácticamente obligatoria, ya
que de lo contrario el programa quedaría obsoleto con el paso del tiempo.
 Mantenimiento perfectivo. Ocurre cuando el usuario solicita agregar nuevas funcionalidades
no contempladas al momento de la implementación del software.
El permanente mantenimiento del software puede asegurar su funcionalidad durante muchos años,
ahorrando tiempo y costo económico de una migración total hacia una nueva aplicación.
En resumen, el mantenimiento es un proceso continuo que se realiza a lo largo del ciclo de vida
de un sistema de información. Una vez que se instala el sistema de información, por lo general
el mantenimiento implica corregir los errores del programa que no se habían detectado antes.
Una vez corregidos, el sistema se acerca a un estado estable para proveer un servicio confiable
a sus usuarios. Sin embargo, a medida que pasa el tiempo y evolucionan tanto la empresa
como la tecnología, el esfuerzo de mantenimiento aumenta en forma considerable.

158
Mantenimiento a las aplicaciones realizadas en la solución de problemas reales
Mientras que el cambio tecnológico afecta indirectamente a los
sistemas software, el entorno de trabajo y los usuarios lo hacen
directamente, produciendo demandas de mantenimiento adaptativo
y perfectivo respectivamente.

A pesar de las pruebas y verificaciones que aparecen en etapas

anteriores del ciclo de vida del software, los programas pueden
tener defectos. El mantenimiento correctivo tiene por objetivo localizar y eliminar los posibles
defectos de los programas.

Un defecto en un sistema es una característica del sistema con el potencial de causar un fallo.
Un fallo ocurre cuando el comportamiento de un sistema es diferente del establecido en la
especificación. Entre otros, los fallos en el software pueden ser de:
 Procesamiento, por ejemplo, salidas incorrectas de un programa.
 Rendimiento, por ejemplo, tiempo de respuesta alto en búsqueda de información.
 Programación, por ejemplo, inconsistencias en el diseño de un programa.
 Documentación, por ejemplo, inconsistencias entre la funcionalidad y el manual.
En el mantenimiento adaptativo las actividades consisten en la modificación de un programa
debido a cambios en el entorno (hardware o software) en el cual se ejecuta. Los cambios
pueden afectar a:
 Sistema operativo (cambio a uno más moderno),
 Arquitectura física del sistema informático (paso de una arquitectura de red a otra)
 Entorno de desarrollo del software (incorporación de nuevas herramientas)
La envergadura del cambio necesario puede ser muy diferente: desde un pequeño retoque en la
estructura de un módulo hasta tener que reescribir prácticamente todo el programa para su
ejecución en un ambiente distribuido en una red.
Los cambios en el entorno software pueden ser de dos clases:
El mantenimiento perfectivo, genera cambios en la especificación, normalmente debidos a
cambios en los requerimientos de un producto software, implican un nuevo tipo de
mantenimiento llamado perfectivo. Desde algo tan simple como cambiar el formato de impresión
de un informe, hasta la incorporación de un nuevo módulo funcional.
Podemos definir el mantenimiento perfectivo como el conjunto de actividades para mejorar
(Mantenimiento de eficiencia) o añadir nuevas funcionalidades (Mantenimiento de ampliación)
requeridas por el usuario

El mantenimiento evolutivo consiste en la modificación del software para mejorar las

propiedades de dicho software (por ejemplo, aumentando su calidad y/o su mantenibilidad) sin
alterar sus especificaciones funcionales. Algunas maneras de hacerlo son:
 Incluir sentencias que comprueben la validez de los datos de entrada,
 Reestructurar los programas para mejorar su legibilidad, o
 Incluir nuevos comentarios que faciliten la posterior comprensión del programa.

159
Elabora un mapa conceptual acerca del concepto, objetivos y tipos de mantenimiento de
sistemas de información.

En el centro de cómputo, con la guía de tu profesor, genera la interfaz de un Sistema para el

Cobro de productos que son vendidos en la cooperativa escolar utilizando Netbeans, una vez
diseñada esta aplicación (sencilla), realiza la implementación de esta (simuladamente). A
continuación, realiza uno de los tipos de mantenimiento a la aplicación (el de tu elección).
Genera el reporte de práctica correspondiente.

160
A continuación, se te presenta una serie de cuestionamientos, responde a cada uno de ellos
subrayando la respuesta correcta.
1. Permite detectar la presencia de errores que pudieran generar las entradas o salidas de
datos y comportamientos inapropiados durante la ejecución de un programa:
a) Prueba b) Mantenimiento c) Implantación d) Desarrollo e) Documentación
2. Tipo de prueba que se focaliza en ejecutar cada módulo o unidad mínima a ser probada:
a) Integración b) Unitaria c) Aceptación d) Funcional e) Procesos
3. Determina que funcionalidades del producto y/o software serán probadas durante el
transcurso de la prueba:
a) Alcance b) Tipos c) Estrategia d) Criterio de salida e) Diseño
4. Conjunto de clases (framework) que permite realizar la ejecución de clases Java de manera
controlada, para evaluar el funcionamiento de cada uno de los métodos.
a) Javadoc b) Applets c) jUnit d) SilkTest e) WinRunner
5. Método de implantación que consiste en la sustitución del viejo sistema por el nuevo de
forma inmediata.
a) Piloto b) Paralelo c) Exacto d) Directo e) Abstracto
6. Consiste en preparar a los usuarios del sistema y se debe llevar a cabo usando manuales o
instructivos realizados durante el diseño.
a) Adiestramiento b) Pruebas c) Aceptación d) Conversión e) Liberación
7. Contiene toda la información sobre los recursos utilizados por el proyecto, llevan una
descripción detallada sobre las características físicas y técnicas de cada elemento.
a) Manual técnico
b) Manual de usuario
c) Instructivo
d) Índice
e) Procedimiento

8. Considera la relación de los capítulos y páginas correspondientes que forman parte del
documento.
a) Introducción b) Índice c) Instructivo d) Referencia e) Contenido
9. Tipo de mantenimiento que consiste en la revisión constante del software para detectar posibles
focos de problemas que puedan surgir en el futuro.
a) Perfectivo b) Adaptativo c) Evolutivo d) Preventivo e) Correctivo
10. Tipo de mantenimiento que ocurre cuando el usuario solicita agregar nuevas funcionalidades no
contempladas al momento de la implementación del software:
a) Perfectivo b) Adaptativo c) Evolutivo d) Preventivo e) Correctivo

161
 INSTRUMENTOS DE EVALUACION

Lista de cotejo para evaluar tareas

Lista de cotejo para evaluar ejercicios

162
Lista de cotejo de evaluación de un cuadro sinóptico

Lista de cotejo de evaluación del manual técnico

163
Lista de cotejo de evaluación del manual del usuario

164
 GLOSARIO
ABSTRACCIÓN: es el proceso en el cual separamos las propiedades más importantes de un
objeto, de las que no lo son.
APLICACIÓN: cualquier programa que corra en un sistema operativo y que haga una función
específica para un usuario. Por ejemplo, procesadores de palabras, bases de datos, agendas
electrónicas, etc.
APLICACIONES CLIENTE: estas son las que se ejecutan en un solo equipo, sin necesidad de
conectarse a otro equipo.
APLICACIONES CLIENTE/SERVIDOR: son programas que necesitan conectarse a otra
máquina (servidor de datos) para solicitar algún servicio.
APLICACIONES WEB: son programas Java que se ejecutan en un servidor de páginas Web
(emplea internet y HTML).
ASIGNACIÓN: es la acción de poner en una variable un valor, él contenido de otra variable o el
resultado de evaluar una expresión aritmética, en los lenguajes se representa con el signo igual.
ASOCIACIÓN: es una conexión entre clases, una conexión semántica (enlace) entre los
objetos de dichas clases.
CLASE: es una plantilla que define las variables y los métodos que son comunes para todos los
objetos de un cierto tipo.
COMPILADOR: es un programa informático que traduce un programa escrito en un lenguaje de
programación a otro lenguaje de programación, generando un programa equivalente que la
máquina (computadora) será capaz de interpretar.
DATOS: son los valores que se procesan en un programa para producir un resultado. Pueden
ser de varios tipos: numéricos, alfabéticos, alfanuméricos y lógicos. Son símbolos no aleatorios
que representan valores de atributos o sucesos.
DEPENDENCIA: es una conexión semántica entre dos elementos de modelado, uno
independiente y otro dependiente.
DETERMINACIÓN DE REQUERIMIENTOS: es el estudio de un sistema para conocer cómo
trabaja y dónde es necesario efectuar mejoras.
DIAGRAMA DE CLASE: muestra un conjunto de clases, interfaces, y colaboraciones y sus
relaciones entre ellos.
DIAGRAMA: es la representación gráfica de un proceso, algoritmo o actividades.
ENCAPSULAMIENTO: es el proceso de ocultar todos los detalles internos de un objeto del
mundo exterior.
GENERALIZACION: es una relación entre un elemento más general y otro más específico. El
elemento más específico puede contener sólo información adicional.
HERENCIA: es un proceso mediante el cual un objeto puede adquirir las propiedades de otro
objeto.
IDENTIFICADOR: es un nombre que identifica a una variable, a un método o función miembro,
a una clase.
IMPLEMENTACIÓN: es la instalación de una aplicación informática, realización o ejecución de
un plan, idea, modelo, científico, diseño, especificación, estándar, algoritmo o política.

165
INFORMACIÓN: es un conjunto organizado de datos procesados, que constituyen un mensaje
sobre un determinado ente o fenómeno.
INSTANCEOF: dependencia que se utiliza cuando se quiere modelar la relación entre una clase
y un objeto en el mismo diagrama, o entre una clase y su metaclase.
INSTANTIATE: dependencia que se utiliza cuando se quiere especificar qué elemento crea
objetos de otro.
INTERFAZ: es lo que se conoce como “superficie de contacto”, se utiliza para nombrar a la
conexión funcional entre dos sistemas, dispositivos o componentes de cualquier tipo, que
proporciona una comunicación de distintos niveles, permitiendo el intercambio de información.
LENGUAJE DE PROGRAMACIÓN: es un idioma artificial diseñado para expresar
computaciones que pueden ser llevadas a cabo por máquinas como las computadoras. Pueden
usarse para crear programas que controlen el comportamiento físico y lógico de una máquina,
para expresar algoritmos con precisión, o como modo de comunicación humana.
LENGUAJE ORIENTADO A OBJETOS: un lenguaje de programación orientado a objetos
(OOP Object Oriented Programming) usado para desarrollar programas que crean y usan
objetos para desempeñar tareas de procesamiento de información.
LENGUAJE: es considerado cualquier tipo de código estructurado utilizado para comunicarse y
en programación sirve para que las computadoras entiendan o traduzcan las instrucciones que
se le envían mediante un programa.
MANUAL: se denomina manual a toda guía de instrucciones que sirve para el uso de un
dispositivo, la corrección de problemas o el establecimiento de procedimientos de trabajo.
MÁQUINA VIRTUAL JAVA: la JVM interpreta los códigos byte del mismo modo en que una
CPU interpretaría las instrucciones del lenguaje del conjunto.
MÉTODO: se refiere al medio utilizado para llegar a un fin.
MODULAR: es un conjunto de técnicas utilizadas para transformar información.
MODULARIDAD: nos permite poder modificar las características de la clase que definen a un
objeto, de forma independiente de las demás clases en la aplicación.
MULTIPLICIDAD: describe la cardinalidad de la relación, es decir, cuántos objetos están
conectados en una instancia de una asociación (enlace).
NETBEANS: es un entorno de desarrollo integrado (IDE), modular, de base estándar
(normalizado), escrito en el lenguaje de programación Java, números y signos de puntuación.
OBJETO: es una entidad caracterizada por sus atributos propios y cuyo comportamiento está
determinado por las acciones o funciones que pueden modificarlo, así como también las
acciones que requiere de otros objetos.
PLATAFORMA: es un gran software que sirve como base para ejecutar determinadas
aplicaciones con este.
POLIMORFISMO: Significa que un nombre se puede utilizar para especificar una clase
genérica de acciones.
PROCESO: es un conjunto de actividades o eventos que pueden estar coordinados u
organizados para realizar una tarea, bajo ciertas condiciones.
PROGRAMA: secuencia de instrucciones que realizan una tarea específica.

166
PROGRAMACIÓN: técnicas destinadas a la resolución de un problema, usando para ello los
lenguajes de programación. Se manejan estructuras lógicas de los tipos: secuencial, condicional
e iterativa.
PROGRAMAR: en programación se considera utilizar algún lenguaje de programación en
computadoras que permita decirle a la computadora lo que debe realizar.
SECUENCIAS: se refieren a la sucesión o conjunto de elementos encadenados y que
dependen unos de otros.
SISTEMA DE INFORMACIÓN: es un conjunto de elementos que interactúan entre sí con el fin
de apoyar las actividades de una empresa o negocio.
SISTEMA: es un conjunto de componentes que interactúan entre sí para lograr un objetivo
común.
UML: usa los diagramas de clase para visualizar el aspecto estático de esa construcción de
bloques y sus relaciones y especificar esos detalles para la construcción.
VARIABLE: en programación es una entidad dedicada a contener valores que pueden cambiar.

167
 BIBLIOGRAFÍA
Deitel, H. M., & Deitel, P. J. (2005). Como programar en Java (6ª. ed.). México: Pearson
Educación.
Medina, N. (2016).Programación orientada a objetos con Java. México: Alfaomega.
López, I. (2017).Curso avanzado de Java-Manual práctico. México: Alfaomega.
S. Pressman, R. (2010). Ingeniería del software un enfoque práctico. México, D. F.: McGrawHill.

REFERENCIAS DE INTERNET

Abad, J. (30 de 05 de 2020). Obtenido de https://ing-sw.blogspot.com/2005/04/tipos-de-

pruebas-de-software.html
Álvarez Jesús (2010). Manual de creación de interfaces de usuario en Netbeans. Recuperado el
30 de mayo de 2020 de la página: https://silo.tips/download/manual-de-creacion-de-interfaces-
de-usuario-en-netbeans
Bernal, B. J. (30 de 05 de 2020). Obtenido de
https://www.etsisi.upm.es/sites/default/files/curso_2013_14/MASTER/MIW.JEE.POOJ.pdf
Cervantes Ojeda, J., & Gómez Fuentes, M. (2012). Taxonomía de los modelos y metodologías
de desarrollo de software más utilizado. Red de Revistas Científicas de América Latina, el
Caribe, España y Portugal.
eXES. (30 de 05 de 2020). Obtenido de eXES: https://www.mundojava.net/sintaxis-del-
lenguaje.html?Pg=java_inicial_4_3.html
Franco, G. A. (30 de 05 de 2020). Obtenido de
http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/introduccion/primero.htm
García Peñalvo, F. J., & Pardo Aguilar, C. (30 de 05 de 2020). Obtenido de
https://pdfs.semanticscholar.org/4da7/45320ba68e3dafba73a96378ebf04c9f3610.pdf
Larin-Fonseca, R. (30 de 05 de 2020). ResearchGate. Obtenido de ResearchGate:
https://www.researchgate.net/publication/280091702_Introduccion_a_la_Programacion_Orienta
da_a_Objetos
Meza, G. J. (30 de 05 de 2020). ProgramarYa. Obtenido de ProgramarYa:
https://www.programarya.com/Cursos/Java
Moreno Bernal, S. D., & Orjuela Velandia, C. C. (30 de 05 de 2020). Obtenido de
https://ferestrepoca.github.io/paradigmas-de-programacion/poo/poo_teoria/2017-1POO.pdf
Otero Vidal, M. (30 de 05 de 2020). Obtenido de
http://www.vc.ehu.es/jiwotvim/IngenieriaSoftware/Teoria/BloqueII/UML-3.pdf
Rojas, D. (30 de 05 de 2020). issuu. Obtenido de issuu:
https://issuu.com/diegorojas88/docs/programacion_orientada_a_objetos
Roldán, Á. (30 de 05 de 2020). Ciberaula. Obtenido de CiberAula:
https://www.ciberaula.com/cursos/java/programacion_orientada_objetos.php
Rosales V, M. (2016). https://www.academia.edu/30146775/modelo_espiral. Obtenido de
https://www.academia.edu/30146775/modelo_espiral:

168
Salcedo Quiñonez, M. G. (30 de 05 de 2020). Mexico Documents. Obtenido de Mexico
Documents: https://vdocuments.mx/tema-1-presentacion-e-introduccion-programacion-
visual.html
Villarreal, J. (30 de 05 de 2020). Obtenido de
https://sites.google.com/site/programacionbasicajava/home/programacion-orientada-a-objetos
Zapata, J. (30 de 05 de 2020). Pruebas de software. Obtenido de Pruebas de software:
https://pruebasdelsoftware.wordpress.com/
(30 de 05 de 2020). Obtenido de
https://www.teatroabadia.com/es/uploads/documentos/iagramas_del_uml.pdf

169