0

SENA

ANALISIS Y DESARROLLO DE SISTEMAS DE INFORMACION

RESULTADO DE APRENDIZAJE

CONSTRUIR EL PROTOTIPO DEL SISTEMA DE INFORMACIÓN, A PARTIR DEL ANÁLISIS

DE LAS CARACTERÍSTICAS FUNCIONALES DEL SISTEMA EN RELACIÓN CON
FACILIDAD DE MANEJO, FUNCIONALIDAD Y EXPERIENCIA DEL USUARIO, APOYADO
EN SOFTWARE APLICADO SEGÚN PROTOCOLOS DE DISEÑO. 2 HORAS RESULTADO
FINAL

EVIDENCIA
MANUAL DE INSTRUMETOS PROGRAMCION ORIENTADA A OBJETOS JAVASCRIPT CON
EL MODELO LOGICO DEL PROYECTO FORMATIVO.

TUTOR
RAMON EMILIO GONZALEZ RODRIGUEZ

APRENDIZ
MARIA ENITH MOSQUERA CARDENAS
BOGOTA D.C.
SENA CENTRO DE DISEÑO Y METROLOGÍA
Mayo de 2023
 1

TABLA DE CONTENIDO

PROGRAMACIÓN ORIENTADO A OBJETOS---------------------- pág. 3

Ejercicio_1_UML_Clase------------------------------------------- pág. 5
OBJETOS NOTACIÓN LITERAL---------------------------------------pág. 7

FUNCIÓN CONSTRUCTORA ----------------------------------------- pág. 9

HERENCIA----------------------------------------------------------- pág. 13

ENCAPSULAMIENTO------------------------------------------------- pág. 23

POLIMORFISMO----------------------------------------------------- pág. 27

PROTOTIPOS-------------------------------------------------------- pág. 29
 2

INTRODUCCIÓN

La Programación Orientada a Objetos (POO) es un paradigma de programación que se basa

en la creación y manipulación de objetos. En este enfoque, los objetos son entidades que
encapsulan datos y funcionalidades relacionadas, permitiendo una mayor modularidad y
reutilización de código. En este documento, exploraremos los conceptos fundamentales de
la POO y su aplicación en el desarrollo de software.
 3

PROGRAMACIÓN ORIENTADO A OBJETOS

La Programación orientada a objetos u OOP según sus siglas en inglés, es un paradigma

o ejemplo de programación que viene a innovar la forma de obtener resultados. Los
objetos manipulan los datos de entrada para la obtención de datos de salida específicos,
donde cada objeto ofrece una funcionalidad especial. Como por ejemplo la clase aprendiz
que pide unos datos de entrada como el, código (17), nombre (Tobías) y apellido
(González). Clase es un modelo de Aprendiz que tiene un conjunto de atributos, y
métodos apropiados para operar con dichos atributos o propiedades código, nombre y
apellido.

Un objeto es todo aquello que tiene propiedades (datos) y métodos (registro). Las
propiedades permiten guardar datos del objeto, cumplen la misma función que una
variable; mientras que los métodos permiten realizar operaciones, cumplen la mismo
que una función.
 4

Un aprendiz puede ser un objeto porque tiene propiedades, valores. Un aprendiz tiene
un código, nombre, un apellido, si es hombre o mujer, etc.; y estas serían algunas de las
propiedades de un objeto aprendiz. Pero también tiene métodos o comportamientos,
como estudiar, jugar, molestar etc.
CLASES Y OBJETOS
Para crear clases y objetos de JavaScript debemos diferenciar entre un objeto y clase,
además de entender que es un atributo, método y constructor
Funcional.
Son básicamente tres conceptos:
• Atributos.
• Métodos.
• Constructor.
 5

Ejercicio_1_UML_Clase; Diseñar en UML la clase Aprendiz con los atributos código,

nombre, apellido. Y el método registro, se asume que se debe crear el constructor que
recibe los parámetros de entrada.

Ejercicio 2 Clase Objeto.html Crear en JavaScript la clase de Aprendiz con los atributos de
código, nombre y apellido. Y el método registro debe anunciar una alerta “Usted está matriculado
al programa de ADSI”, y se asume que se debe crear el constructor que recibe los parámetros de
entrada. Crear tres objetos de sus compañeros de clase.
 6

Ejercicio_3_UML_Clase; Diseñar en UML una super clase según su proyecto formativo (según
el modelo lógico revisado el trimestre anterior) con los atributos. Y el método y/o métodos con
su respectivo constructor que recibe los parámetros de entrada.

OBJETOS NOTACIÓN LITERAL

Se denomina objeto literal al objeto cuyas propiedades están declaradas textualmente en el

código. Los objetos pueden almacenar métodos en su interior. Para acceder a las propiedades de
un objeto dentro de un método es necesario usar la palabra reservada this por scope de las
variables. 26 los objetos en JavaScript nos ayudan a agregar información. Un objeto no es más
que un conjunto de propiedades en donde cada propiedad está compuesta de una llave y un
valor. Veamos un primer ejemplo con base al ejercicio 1:

Ejercicio_5 con base al ejercicio 1 que tiene diseñado el UML de la clase aprendiz, diseñar un
objeto llamado Aprendiz_nelson, con las constantes del código, nombre y apellido. Se debe crear
un método llamado registro.
 7

Ejercicio_6 con base al ejercicio 3 que tiene diseñado el UML de su proyecto formativo, diseñar
un objeto. Con sus respectivas variables y sus métodos y aplicar loque se acabó de explicar en la
sesión de clase.

Ejercicio_7_Funcion_Constructora. Crear la función constructora llamada Aprendiz con las

propiedades y/o atributos código, nombre, apellido y la función registro que debe ser publica
que, se debe tener la alerta “Usted está matriculado al programa de ADSI”. Creamos objeto
Aprendiz_Nelson y le asignamos valores.
 8

Nota: Un objeto prototipo del objeto puede tener a su vez otro objeto prototipo, el
cual hereda métodos y propiedades, así sucesivamente. Como se observa en el objeto.

FUNCIÓN CONSTRUCTORA

Las funciones de constructor son funciones diseñadas para construir un nuevo objeto. Dentro de
una función constructora, la palabra clave THIS se refiere a un objeto recién creado, que se
pueden asignar valores a. Las funciones del constructor "devuelve" este nuevo objeto
automáticamente. JavaScript no tiene una notación formal de clase y recurre a las funciones
constructoras para este fin. Mencionar también que JavaScript utiliza los prototipos de los objetos
para propagar la herencia, algo que sin duda cuesta entender al principio y al que dedicaremos
un artículo independiente más adelante.
 9

GETTING Y SETTING

Utilidad aparte, en la práctica son simplemente métodos que te permite acceder a datos de los
objetos, para leerlos o asignar nuevos valores. El setter lo que hace es asignar un valor y el getter
se encarga de recibir un valor.

Para los que no han oído hablar sobre éstos, los getters y los setters son construcciones habituales
de los objetos que permiten acceder a valores o propiedades, sin revelar la forma de
implementación de las clases. En pocas palabras, permiten encapsular los objetos y evitar
mantenimiento de las aplicaciones cuando la forma de implementar esos objetos cambia.

Utilidad aparte, en la práctica son simplemente métodos que te permite acceder a datos de los
objetos, para leerlos o asignar nuevos valores. El setter lo que hace es asignar un valor y el getter
se encarga de recibir un valor.

Ejercicio_9_UML_Clase; Diseñar en UML la clase Aprendiz con los atributos código, nombre,
apellido. Y los métodos get y set se asume que se debe crear el constructor que recibe los
parámetros de entrada.

Ejercicio 10 Clase Objeto.html Crear en JavaScript la clase de Aprendiz con los atributos de
código, nombre y apellido Y los métodos get y set se asume que se debe crear el constructor
que recibe los parámetros de entrada.
 10

11.Diseñar el UML de una superclase de su proyecto formativo según lo visto en clase.

12.Con base en el ejercicio 11 elaborar el script con sus atributos y sus métodos GET y SET.
11
 12

HERENCIA

En programación orientada a objetos, la herencia es, después de la agregación o composición, el

mecanismo más utilizado para alcanzar algunos de los objetivos más preciados en el desarrollo
de software como lo son la reutilización y la extensibilidad. A través de ella, los diseñadores
pueden crear nuevas clases partiendo de una clase o de una jerarquía de clases preexistente (ya
comprobadas y verificadas) evitando con ello el rediseño, la modificación y verificación de la parte
ya implementada. La herencia facilita la creación de objetos a partir de otros ya existentes e
implica que una subclase obtiene todo el comportamiento (métodos) y finalmente los atributos
(variables) de su superclase.

Ejercicio 13 crear el UML con la super clase Persona, la sub clase Aprendiz. Teniendo en cuenta
que la super clase persona tiene los siguientes atributos código, nombre, apellido. La clase
Aprendiz tiene los siguientes atributos ficha, programa y un método llamado matriculado. Se
asume que se deben crear los constructores, los métodos get y set .

Ejercicio 14 crear el script con la super clase Persona, la sub clase Aprendiz. Teniendo en cuenta
que la super clase persona tiene los siguientes atributos código, nombre, apellido. La clase
Aprendiz tiene los siguientes atributos ficha, programa y un método llamado matriculado. Se
asume que se deben crear los constructores, los métodos get y set . Se debe crear un objeto
llamado Aprendiz_juan y enviarle los argumentos.
13
 14

15. crear el UML de una superclase y dos subclases de su proyecto formativo teniendo en cuenta
los atributos, los constructores y los métodos.

16. crear script de una superclase y dos subclases de su proyecto formativo teniendo en cuenta
los atributos, los constructores y los métodos en js.
 15

class tipo_producto{

constructor(id_tipo_producto, nombre){
this.id_tipo_producto = id_tipo_producto;
this.nombre = nombre;

get id_tipo_producto(){
return this.id_tipo_producto;
}

set id_tipo_producto(nuevo_id_tipo_producto){
this.id_tipo_producto = nuevo_id_tipo_producto;
}

get nombre(){
return this.id_tipo_producto;
}

set nombre(nuevo_nombre){
this.nombre = nuevo_nombre;
}
}

class categoria extends tipo_producto{

constructor(id_categoria, descripcion){

super(id_tipo_producto, nombre);

this.id_categoria = id_categoria;
this.descripcion = descripcion;
}

get id_categoria(){
return this.id_categoria;
}

set id_categoria(nuevo_id_categoria){
this.id_categoria = nuevo_id_categoria;
}

get descripcion(){
return this.descripcion;
 16

set descripcion(nuevo_descripcion){
this.descripcion = nuevo_descripcion;
}
}

class productos extends categoria{

constructor(id_producto, nombre, presentacion, peso, valor_unidad,

imagen){

super(id_tipo_producto, nombre, id_categoria, descripcion);

this.id_producto = id_producto;
this.nombre = nombre;
this.presentacion = presentacion;
this.peso = peso;
this.valor_unidad = valor_unidad;
this.imagen = imagen;
}

get id_producto(){
return this.id_producto;
}

set id_producto(nuevo_id_producto){
this.id_producto = nuevo_id_producto;
}

get nombre(){
return this.nombre;
}

set nombre(nuevo_nombre){
this.nombre = nuevo_nombre;
}

get presentacion(){
return this.presentacion;
}

set presentacion(nuevo_presentacion){
this.presentacion = nuevo_presentacion;
 17

get peso(){
return this.peso;
}

set peso(nuevo_peso){
this.peso = nuevo_peso;
}

get valor_unidad(){
return this.valor_unidad;
}

set valor_unidad(nuevo_valor_unidad){
this.valor_unidad = nuevo_valor_unidad;
}

get imagen(){
return this.imagen;
}

set imagen(nuevo_imagen){
this.imagen = nuevo_imagen;
}

Diseñar en UML a partir de una superclase llamada operadores ARITMETICOS con los atributos
X, Z, se debe crear el constructor que reciba los parámetros.

Crear la subclase SUMA, RESTA, MULTIPCACION, DIVICION y módulo. Se asume que toda la
subclase tiene método de retorno de las operaciones aritméticas.

class OperadoresA {
constructox,yr(x,y){

}
 18

get x (){
return this._x;
}
set x(nuevo_x){
this._x = nuevo_x;
}
get y (){
return this._y;
}
set y(nuevo_y){
this._y = nuevo_y;
}
}

class Suma extends OperadoresA {

constructor(x,y){
super(x,y);

resultado(){
return this._x + this._y;
}

let suma = new Suma(4, 5);

console.log(suma.resultado());

class Resta extends OperadoresA {

constructor(x,y){
super(x,y);

resultado(){
return this._x - this._y;
}

}
 19

let resta = new Resta(10, 5);

console.log(resta.resultado());

class Multiplicacion extends OperadoresA {

constructor(x,y){
super(x,y);

resultado(){
return this._x * this._y;
}

let multiplicacion = new Multiplicacion(2, 2);

console.log(multiplicacion.resultado());

class Division extends OperadoresA {

constructor(x,y){
super(x,y);

resultado(){
return this._x / this._y;
}

let division = new Division(20, 2);

console.log(division.resultado());

class Modulo extends OperadoresA {

constructor(x,y){
super(x,y);

}
 20

resultado(){
return this._x % this._y;
}

let modulo = new Modulo(20, 3);

console.log(modulo.resultado());
21
 22

ENCAPSULAMIENTO

En programación modular, y más específicamente en programación orientada a objetos, se

denomina encapsulamiento al ocultamiento del estado, es decir, de los datos miembro de un
objeto de manera que solo se pueda cambiar mediante las operaciones definidas para ese
objeto.

Cada objeto está aislado del exterior, es un módulo natural, y la aplicación entera se reduce a
un agregado o rompecabezas de objetos. El aislamiento protege a los datos asociados de un
objeto contra su modificación por quien no tenga derecho a acceder a ellos, eliminando efectos
secundarios e interacciones.

De esta forma el usuario de la clase puede obviar la implementación de los métodos y

propiedades para concentrarse solo en cómo usarlos. Por otro lado se evita que el usuario
pueda cambiar su estado de maneras imprevistas e incontroladas

Ventajas

● Reutilización

● Sistema más fiable y de alta calidad

● Mantenimiento más fácil

● Mejores estructuras de información

● Desarrollo más flexible

● Incremento de la adaptabilidad

Desventajas

● Cambio de la forma de pensar en la programación tradicional a la orientada a objetos

● La ejecución de programas orientados a objetos es un poco lenta.

 23

Ejercicio 21 UML y Javascript: Teniendo en cuenta el UML de la imagen de la Clase

Aprendiz, realizar el script con sus respectivos atributos público y privados. El método privado
Encapsulado_resgistro y publico Desencapsulado_registro. Validar el código del aprendiz para
que me muestre el registro de información.
 24

function Aprendiz(codigo,nombre,apellido){

this._codigo=codigo
var _nombre= nombre
var _apellido=apellido

var encapsulado_registro=function (a) {

var c=a;

console.log(c+_nombre+_apellido)
}

this.Desenpasulado_registro =function (clave){

var _c=clave

if(_c==1){

encapsulado_registro(_c)

let Objeto_aprendiz=new Aprendiz(1,'Oscar','Martinez')

console.log(Objeto_aprendiz._codigo)
 25

Ejercicio 23 Con base al ejercicio 15 que fue diseñado por el aprendiz con base a su proyecto
productivo. Aplicar el encapsulamiento a los atributos necesarios y métodos. Según lo explicado
en la sesión de clase.

function Producto(IdProducto, NombreProd, MarcaProd, Presentacion, TipoProd,

FechaVen, ValorNeto) {

this._IdProducto = IdProducto;
var _NombreProd = NombreProd;
var _MarcaProd = MarcaProd;
var _Presentacion = Presentacion;
var _TipoProd = TipoProd;
var _FechaVen = FechaVen;
var _ValorNeto = ValorNeto;

var encapsulado_registro =function(a){

var c=a;

console.log(c+" "+NombreProd+" "+MarcaProd+" "+Presentacion+"

"+TipoProd+" "+FechaVen+" "+ValorNeto)

this.Desencapsulamiento_Registro=function (clave) {

var _c=clave

if (_c==1) {

encapsulado_registro(_c)

let c=prompt("Ingrese una clave");

let NombreProd=prompt("Ingrese nombre del producto");
 26

let MarcaProd=prompt("Ingrese marca del producto");

let Presentacion=prompt("Ingrese presentacion del producto");
let TipoProd=prompt("Ingrese tipo del producto");
let FechaVen=prompt("Ingrese fecha de vencimiento del producto");
let ValorNeto=prompt("Ingrese valor neto del producto");

//console.log(Objeto_Producto._IdProducto)

let clave=Objeto_Producto._IdProducto
Objeto_Producto.Desencapsulamiento_Registro(clave)

POLIMORFISMO

En programación orientada a objetos, el polimorfismo se refiere a la propiedad por la que es

posible enviar mensajes sintácticamente iguales a objetos de tipos distintos. El único requisito
que deben cumplir los objetos que se utilizan de manera polimórfica es saber responder al
mensaje que se les envía.

Se refiere a los métodos que tiene la clase abstracta TRANASPORTE por la que es posible enviar
mensajes sintácticamente iguales a SUB CLASES CABALLO, COCHE Y AVION de tipos distintos.
El único requisito que deben cumplir las sub clases que se utilizan de manera polimórfica es
saber responder al mensaje que se les envía.
 27

Ejercicio 24 Teniendo en cuenta la explicación de polimorfismo crear la sintaxis en el lenguaje

javascript. Se sabe que tenemos la clase abstracta TRANSPORTE y las sub clases SUB CLASES
CABALLO, COCHE Y AVION. Crear los objetos Caballo_cafe, Carro_rojo , Avion_blanco y llamar
los métodos indicados en la clase abstracta TRANSPORTE.

class transporte{
avanzar() {}
frenar(){}
}

class caballo extends transporte{

avanzar(){
return "avanzar con el caballo"
}

frenar(){
return"frenar con el caballo"
}
}

class carro extends transporte{

avanzar(){
return "avanzar con el carro"
 28

frenar(){
return"frenar con el carro"
}
}

class avion extends transporte{

avanzar(){
return "avanzar con el avion"
}

frenar(){
return"frenar con el avion"
}
}

let objeto_caballo=new caballo();

let objeto_carro=new carro();
let objeto_avion=new avion();

console.log("CABALLO BONITO")
console.log(objeto_caballo.avanzar());
console.log(objeto_caballo.frenar());

console.log("CARRO VERDE")
console.log(objeto_caballo.avanzar());
console.log(objeto_caballo.frenar());

console.log("AVION A MIAMI")
console.log(objeto_caballo.avanzar());
console.log(objeto_caballo.frenar());

PROTOTIPOS Los prototipos son un mecanismo mediante el cual los objetos en JavaScript heredan características
entre sí Herencia y prototipos En Javascript se denomina herencia a la capacidad de un objeto para recibir (heredar)
propiedades y métodos de otro objeto. Gracias a ello podemos crear nuevos objetos (instancias) basándonos en otros
objetos ya existentes.En Javascript la herencia se logra a través de prototipos.Cada objeto tiene un prototipo. Cuando
se crea un objeto este obtiene su pro

Cada objeto tiene un prototipo. Cuando se crea un objeto este obtiene su propio prototipo automáticamente.Javascript
nos permite crear objetos basados en prototipos de otros objetos. Con lo que obtienen (heredan) las propiedades y
métodos del prototipo.
 29

Ejercicio 28 Comparación de la clase Rectángulo con los atributos altura, ancho y el método
CalArea . Utilizado la palabra reservada Class. En la comparación con el otro ejercicio se utiliza
la palabra reservada function. Según el UML que se muestra a continuación:

class Rectangulo {
constructor( altura, ancho) {
this._altura = altura
this._ancho = ancho }

calcArea() {
return this._altura * this._ancho
}
}

const objeto_rectangulo = new Rectangulo(3, 2)

document.write( objeto_rectangulo.calcArea())

class Rectangulo {
constructor( altura, ancho) {
this._altura = altura
this._ancho = ancho }

calcArea() {
return this._altura * this._ancho
}
}

const objeto_rectangulo = new Rectangulo(3, 2)

document.write( objeto_rectangulo.calcArea())
 30

function Rectangulo(alto, ancho) {

this._alto = alto
this._ancho = ancho

Rectangulo.prototype.calcArea = function calcArea() {

return this._alto * this._ancho
}

const objeto_rectangulo = new Rectangulo(7, 2)

document.write( objeto_rectangulo.calcArea())

Ejercicio 29 Teniendo en cuenta la explicación anterior adicionar a nuestro UML el método

CalPerimetro y adicionar a nuestro script el código correspondiente a la clase y a la función.

class Rectangulo {
constructor( altura, ancho) {
this._altura = altura
this._ancho = ancho }
 31

calcArea() {
return this._altura * this._ancho
}

CalPerimetro() {
return (this._altura * 2) + (this._ancho * 2)
}

const objeto_rectangulo = new Rectangulo(3, 2)

document.write( "Area del rectangulo " +objeto_rectangulo.calcArea())
document.write( " Perimetro del rectangulo" +
objeto_rectangulo.CalPerimetro())

function Rectangulo(alto, ancho) {

this._alto = alto
this._ancho = ancho

}
Rectangulo.prototype.calcArea = function calcArea() {
return this._alto * this._ancho
}

Rectangulo.prototype.CalPerimetro = function CalPerimetro() {

return (this._alto * 2) + (this._ancho * 2)

}

const objeto_rectangulo = new Rectangulo(5,3)

document.write( "Area del rectangulo " +objeto_rectangulo.calcArea())
document.write( " Perimetro del rectangulo" +
objeto_rectangulo.CalPerimetro())
 32

CONCLUSION

El documento proporciona información sobre la programación orientada a objetos (POO)

como un paradigma de programación que utiliza objetos para manipular datos y realizar
operaciones. Se menciona que un objeto tiene propiedades (datos) y métodos (funciones)
que le permiten realizar diferentes tareas. El documento también destaca la importancia de
las clases y los objetos en la POO. Una clase es un modelo o plantilla que define las
propiedades y métodos de un objeto, mientras que un objeto es una instancia específica de
una clase con valores concretos para sus propiedades. Se presentan ejercicios de diseño de
clases y objetos en UML y JavaScript, así como el uso de la notación literal de objetos.
 33

REFERENCIAS

https://www.freecodecamp.org/espanol/news/programacion-orientada-a-objectos-
en-javascript-explicado-con-ejemplos/

https://www.campusmvp.es/recursos/post/los-conceptos-fundamentales-sobre-
programacion-orientada-objetos-explicados-de-manera-simple.aspx

https://es.wikipedia.org/wiki/Polimorfismo_(inform%C3%A1tica