Exp 2 – Semana 4

Arquitectura ASY4231
Guía de Aprendizaje
 Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Índice
Introducción a la semana............................................................................................................3
Resultado de aprendizaje ...........................................................................................................4
El estudiante será capaz de: .............................................................................................. 4

Indicador de logro: .............................................................................................................. 4

Conceptos relevantes .................................................................................................................4

Preguntas activadoras ................................................................................................................4
Actividad .....................................................................................................................................5
La vista lógica .............................................................................................................................6
Diagrama de Clases ........................................................................................................... 6

Implementando la vista lógica en JAVA usando el IDE NetBeans 8.2 ............................. 13

Implementando el sistema de ventas a través de la vista lógica ...................................... 20

Cierre de la semana .................................................................................................................22

Referencias ..............................................................................................................................23
Apunte ......................................................................................................................................24

Duoc UC 2
Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Introducción a la semana

En esta cuarta semana pondremos en práctica

lo aprendido sobre cómo documentar la
arquitectura de nuestro sistema a través de los
distintos diagramas de vistas 4+1.

En esta oportunidad vamos a generar los

diagramas de clases, de comunicación y
secuencia de la vista lógica, a través del uso
de un lenguaje de programación orientado a
objetos, en este caso será Java. Junto con
ello, veremos una alternativa para la creación de clases usando para ello el software starUML,
el cual hemos estado usando para crear los distintos diagramas de vistas 4+1.

Usaremos para la experiencia, algunos de los requisitos funcionales entregados al inicio del
curso y los pondremos en práctica.

Como material asicional, tendrás disponible el video “Implementando vista lógica”, el cual
explicará cómo crear clases a través del software starUML, generando finalmente código Java
para su implementación, que tengan una excelente semana de aprendizaje.

Duoc UC 3
Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Resultado de aprendizaje

El estudiante será capaz de:

RA2. Implementa el modelo arquitectónico en el lenguaje de programación seleccionado para

soportar la solución sistémica requerida por el cliente.

Indicador de logro:

IL5 Implementa la vista lógica del proyecto, en base a los requerimientos funcionales del
proyecto.

Conceptos relevantes

4+1 Objeto Diagrama

Comunicación Secuencia Clase

Atributo Operaciones Relaciones

Preguntas activadoras
• ¿Qué son objetos, y lenguaje orientado a objetos?
• ¿Qué es el diagrama de comunicación y secuencia?
• ¿Qué son las clases?
• ¿Qué son los atributos?
• ¿Qué son las operaciones?

Duoc UC 4
Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Actividad
Implementando la arquitectura - Vista lógica.
En la cuarta semana realizarán una actividad formativa con encargo grupal llamada
"Implementando la arquitectura - Vista lógica" para generar el diagrama de clases, diagrama
de secuencia y diagrama de comunicación.

Duoc UC 5
Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

La vista lógica
Diagrama de Clases
Como ya hemos aprendido, las clases son plantillas que permiten describir las características
y sus comportamientos. Una clase posee datos los que son llamados atributos o propiedades,
y del mismo modo posee funciones, llamadas métodos o acciones que la clase puede realizar.

Las clases no son instancias del objeto, son plantillas, las cuales posteriormente usaremos
creando diferentes instancias de este objeto creado, ejemplo:

Clase Cla_Tipo_Cliente
Atributos
(Rut, nombre, edad)
Métodos
(CrearCliente, ModificarCliente, EliminarCliente)

Cla_Tipo_Cliente miCliente = NEW Cla-Tipo-Cliente(‘12100908-7’,’Juan’, 55);

En este ejemplo, se crea la clase Cla_Tipo_Cliente, luego definimos una instancia de la clase
llamada miCliente, la cual adopta los atributos y métodos de la clase, por lo cual usamos la
clase para definir nuevas instancias de ella y aquellas instancias nuevas, son las que
usaremos en los programas como tal.

En nuestro ejemplo de esta semana, crearemos las clases necesarias para cubrir los
requiermientos RF001 y RF002 del caso de Ventas entregado al inicio del curso.

Recordemos, RF001, el cual corresponde a “Registro del usuario”, en este caso se requiere
que un nuevo cliente pueda registrarse en el sistema, para ello necesitará ciertos datos para
su registro como:

- Rut
- Nombre
Duoc UC 6
Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

- Correo
- Contraseña

Primero, usaremos starUML para crear la clase

Paso 1: Usando starUML para crear la clase “Cliente”

Como ya hemos visto en starUML, cree la clase cliente, indicando que posee los atributos rut
de tipo Int, nombre, correo y contraseña, estos últimos de tipo String, Figura 1.

Figura 1:
Clase Cliente.

Nota: En la clase cliente se despliegan los atributos +Rut: de tipo Int, +Nombre, +Correo y
+Contraseña, estos últimos de tipo String. Abajo se despliegan +CrearCliente(),
+ModificarCliente() y +EliminarCliente().

Duoc UC 7
Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Paso 2: a partir del diagrama, implementar la clase en Java.

Seleccionar los atributos (Rut, nombre, correo y Contraseña) una a una, primero seleccione
Rut, luego desde el menu principal, hacer clic en Tools, luego “Generate Getters Setters”,
Figura 2, esto agregará los getters y setters requeridos para el atributo Rut, podrá visualizar el
cambio en la estructura de la clase, como se muestra en la figura 3.

Importante

Getters y Setters son métodos que permitirán tener acceso a los atributos de las clases y
así poder manipular sus valores desde el exterior de la clase, en un programa, por
ejemplo.

Figura 2:
Generate Getters Setters.

Nota: En la pestaña Tools, se debe seleccionar “Generate Getters Setters”.

Duoc UC 8
Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Figura 3:
Cambio en la estructura de clases.

Nota: En la clase “Cliente”, podrás editar los atributos.

Repita estos pasos para todos los atributos de la clase, hasta que quede como en la figura 4

Figura 4:
Ejemplo de como debe quedar

Nota: Los atributos de la Clase “Cliente” queda completa con +Rut: de tipo Int, +Nombre,
+Correo y +Contraseña, estos últimos de tipo String. Abajo se despliegan +CrearCliente(),
+ModificarCliente(), +EliminarCliente(), +getRut(value: int), +getNombre(): String, +getNombre
(value:String), +getCorreo(): String, +setCorreo/value:String), +getContraseña(): String, +
setContraseña():String, +setContraseña(value:String).

Duoc UC 9
 Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Es conveniente crear un objeto Package y luego dejar dentro de este la clase recien creada,
como se ve en la figura 5.

Figura 5:
Package conteniendo a la clase Cliente.

Nota: Los atributos de la Clase “Cliente” Están dentro de una carpeta.

Paso 3: Generar el código para JAVA.

Una vez finalizó con la definición de atributos, sus Getters y Setters, grabe el modelo starUML
en una carpeta donde este documentando su sistema. Ahora, generar la clase en Java, para
ello desde el menu principal, selecciones “Tools”, luego “Java” y “Generate Code”, tal como se
aprecia en la figura 6.

Duoc UC 10
Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Figura 6:
Generando código Java

Nota: Dentro de la pestaña Tools, seleccionar “Java” y luego “Generate Code”.

StarUML, nos consultara que modelo vamos a generar, en este caso seleccionaremos el
Package MisClases, luego indicar “OK”, Figura 7, esto abrirá una nueva ventana para solicitar
en que carpeta dejaremos el código, ver Figura 8.

Figura 7:
Selección del Package MisClases.

Nota:En Vista lógica selecciona Misclases.

Duoc UC 11
Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Figura 8
Seleccionar carpeta “sistema”.

Nota: Seleccionar una carpeta donde dejar el código, en nuestro ejemplo escogeré “Sistema”.

Una vez indicada la carpeta, el código fue generado en dicha carpeta, con el explorador de
Windows, dirijase a la carpeta y puede abrir el archivo usando un IDE o bien alguna
herramienta para editar texto. El ejemplo generado se encuentra disponible como anexo al
final de este documento en “ANEXO 1: Código JAVA para la clase Cliente”.

Importante

• Para profundizar un poco más sobre clases, revise el anexo 2, al final de este
documento.
• Para revisar el paso a paso completo, revise el VIDEO “Generando clases”, el cual
se encuentra disponible en el material de esta semana.

Duoc UC 12
Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Implementando la vista lógica en JAVA usando el IDE NetBeans

8.2

A continuación, utilizaremos el IDE Netbeans 8.2, para desarrollar un ejemplo de cómo

implementar la vista lógica en el lenguaje JAVA, para ello usaremos la clase Cliente, creada
en el capítulo anterior, el cual a través de starUML creo un código con la clase.

En esta oportunidad, crearemos la clase directo desde JAVA para visualizar un nuevo método
para implementarla.

Paso 1: Abrir Netbeans 8.2

Como parte del material disponible, existe un video de como instalar Netbeans en tu máquina,
además en el repositorio, está disponible el instalador de Netbeans 8.2 para que lo puedas
utilizar rápidamente.

Abre desde Windows Netbeans 8.2, digitando desde la línea de comandos o a través del
menú de Windows.

Figura 9
Abriendo Netbeans.

Nota: Al seleccionar el programa Netbeans se abrirá y se podrá visibilizar su pantalla de inicio.

Duoc UC 13
Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Una vez en Netbeans, observaremos lo siguiente:

Figura 10
Netbeans.

Nota: Al abrir el programa NetBeans podremos ver el menú completo y sus pestañas.

Paso 2: Crear una pequeña aplicación en Java.

Dirígete al menú “Archivo”, “Proyecto nuevo” y selecciona la categoría “Java” y un tipo de

proyecto “Java Application”, como en la figura 11. Presiona el botón “Siguiente”.

Imagen 11:

Generar un nuevo proyecto Java Applications.

Nota: Al dirigirse al menú “Archivo”, luego “Proyecto nuevo” y selecciona la categoría “Java” y
un tipo de proyecto “Java Application”.
Duoc UC 14
Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Da un nombre a tu proyecto, en mi caso seleccionaré “SistemaVentas”, presionar “Terminar”,

Figura 12:
Crear el proyecto.

Nota: Da un nombre a tu proyecto, en mi caso seleccionaré “SistemaVentas”, presionar

“Terminar”

Netbeans creará el proyecto y ya podemos comenzar a programar, como se ve en la figura

13.

Figura 13:
Proyecto listo para continuar desarrollando.

Nota: Ya se ve la pantalla para comenzar a trabajar en el proyecto y programar.

Duoc UC 15
 Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Paso 3: Crear la clase Cliente

Para crear clases en Java usando Netbeans, haz clic derecho en la carpeta “Paquetes de
Fuentes”, luego en “Nuevo”, finalmente en “Java Package”, esto creará un paquete, ponle un
nombre para continuar, en mi caso usaré “MisClases”, luego presionar “Terminar”. Se podrá
apreciar el resultado en la figura 14.

Figura 14:
El Package “MisClases” fue creado.

Nota: Haz clic derecho en la carpeta “Paquetes de Fuentes”, luego en “Nuevo”, finalmente en
“Java Package”, esto creará un paquete, ponle un nombre para continuar, en mi caso usaré
“MisClases”, luego presionar “Terminar”.

A continuación, vamos a crear una clase, para ello usaremos el nombre Cliente, la cual esta
solicitada en el Requerimiento Funcional RF001.

Haz clic derecho sobre el Package “misClases”, luego “Nuevo” y “Java Class”, escribe el
nombre cliente y luego el botón “Terminar”.

Duoc UC 16
Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Figura 15:
Crear la clase Cliente

Nota: Haz clic derecho sobre el Package “misClases”, luego “Nuevo” y “Java Class”, escribe el
nombre cliente y luego el botón “Terminar”.

Esto creará y dejará disponible el editor para terminar la clase.

Figura 16.
La clase cliente creada.

Nota: Editor disponible para terminar la clase.

Duoc UC 17
Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Termina de escribir la clase, indicando los atributos y sus tipos de datos.

Figura 17:
La clase contiene todos los atributos mencionados en el RF001.

Nota: Termina de escribir la clase, indicando los atributos y sus tipos de datos.

Ahora vamos a hacer clic en el menú principal, en la opción “Fuente”, luego “Insertar código” y
luego “getters”, haz clic en la clase Cliente para seleccionar todos los atributos, el resultado se
aprecia en la figura 18.

Figura 18.
Los getters han sido incorporados.

Duoc UC 18
Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Nota: Es el resultado de hacer clic en el menú principal, en la opción “Fuente”, luego “Insertar
código” y luego “getters”, haz clic en la clase Cliente para seleccionar todos los atributos.

Ahora la clase toma forma con los getters como se aprecia en la figura 19.

Figura 19:
Netbeans ha agregado los getters.

Nota: La clase toma forma con los getters.

Ahora realiza la misma operación anterior, pero esta vez escoge “Setters”, para luego terminar
la clase, tal como se aprecia en la figura 20.

Figura 20:
Clase terminada con sus respectivos getters y Setters.

Nota: Se realiza la misma operación anterior, pero esta vez se escoge “setters”, para luego
terminar la clase.

Duoc UC 19
Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Finalmente recuerda guardar tu proyecto, ahora puedes continuar con el desarrollo de tu

aplicación.

Implementando el sistema de ventas a través de la vista lógica

A continuación, realizarán una actividad práctica en la cual, deberán completar el resto de las
clases que sus requisitos funcionales requieran, recuerda hacer este caso con tu grupo, así
podrán entender bien como colaborativamente un sistema es construido.

Pueden revisar en profundidad el ejercicio, a través de la visualización de estos 2 videos que

se podrán encontrar en el material de la semana 4, Creando Clases con starUML y Creando
Clases con Java y Netbeans.

Video

En el video “Creando clases con starUML” podrás revisar en profundidad el ejercicio

https://videosduoc.duoc.cl/media/t/1_jvshiokf

Podrás también hacerlo en el video “Creando clases con Java y Netbeans”:

https://videosduoc.duoc.cl/media/t/1_gd1g2g9l

Una vez creado el resto de las clases faltantes, genere los diagramas de comunicación y
secuencia, usando para ello lo aprendido en la semana 2, y visualizando el video “Generación
de la vista lógica, diagrama de comunicación” y “Generación de la vista lógica, diagrama de
secuencia”.

Duoc UC 20
Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Video

Para generar los diagramas de clases, puedes volver a ver el siguiente vieo “Vista Lógica –
Diagrama de clases”: https://videosduoc.duoc.cl/media/t/1_fimgq6hl

Para generar los diagramas de comunicación, puedes volver a ver el siguiente video “Vista
Lógica – Diagrama de Comunicaciones”: https://videosduoc.duoc.cl/media/t/1_shmfjfyc

Para generar los diagramas de secuencia, puedes volver a ver el siguiente video “Vista Lógica
– Diagrama de secuencia”: https://videosduoc.duoc.cl/media/t/1_u11wmj0i

Duoc UC 21
 Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Cierre de la semana
Durante esta cuarta semana, has aprendido a documentar la vista lógica, en especial los
diagramas de clases los cuales nos muestras los
componentes de nuestro sistema, clases, datos,
métodos, comunicaciones y relaciones, se
realizó un paso a paso de como generar clases a
través del software starUML y con Netbeans en
un proyecto Java.

Durante las siguientes semanas, ganarán un

mayor conocimiento en la arquitectura de
software, profundizando en temas como la
implementación de la vista de comportamiento,
diagrama de entidad relación, y también podrás
construir el primer diagrama del modelo de datos del sistema, que tengan una excelente
semana.

Duoc UC 22
Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Referencias

Gana J. (2023). Paso a paso de cómo crear una clase usando starUML.

Gana J. (2023). Paso a paso de cómo crear una clase usando Java y Netbeans.

Gana J. (2023). Paso a paso de cómo crear clases.

Gana J. (2023). Paso a paso de cómo crear Diagrama de secuencia.

Gana J. (2023). Paso a paso de cómo crear el diagrama de comunicación.

Duoc UC 23
Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Apunte

___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________

Duoc UC 24
 Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

Duoc UC

Facilitador disciplinar: Juan Alberto Gana.

Asesor par: Domingo Sanz.
Reservados todos los derechos Fundación Instituto Profesional Duoc UC. No se permite copiar, reproducir,
reeditar, descargar, publicar, emitir, difundir, de forma total o parcial la presente obra, ni su incorporación a un
sistema informático, ni su transmisión en cualquier forma o por cualquier medio (electrónico, mecánico, fotocopia,

Duoc UC 25
 Arquitectura – Semana 4
Implementando la arquitectura - Vista lógica

grabación u otros) sin autorización previa y por escrito de Fundación Instituto Profesional Duoc UC La infracción
de dichos derechos puede constituir un delito contra la propiedad intelectual.

Duoc UC 26