Poo Laboratorio1 Practica

Fundamentos de la programación
UNIVERSIDAD DE LAS FUERZAS ARMADAS-ESPE

SEDE SANTO DOMINGO
DEPARTAMENTO DE CIENCIAS DE LA COMPUTACIÓN - DCCO-SS
CARRERA DE INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN
PERIODO : abril 2023 – agosto 2023
ASIGNATURA : Programación Orientada a objetos
TEMA : Laboratorio 1
NOMBRES : Laglaguano Villavicencio Andy Joel
NIVEL-PARALELO : Segundo nivel “A”
DOCENTE : Ing. Cevallos Farias Javier José
FECHA DE ENTREGA : 16/05/2023
SANTO DOMINGO - ECUADOR
2023
P á g i n a 1 | 38 Grupo7
Tabla de ilustraciones
Ilustración 1 24
Ilustración 2 25
Ilustración 3 25
Ilustración 4 26
Ilustración 5 26
Ilustración 6 27
Ilustración 7 27
Ilustración 8 28
Ilustración 9 28
Ilustración 10 29
Ilustración 11 29
Ilustración 12 30
Ilustración 13 30
Ilustración 14 31
Ilustración 15 31
Ilustración 16 32
Ilustración 17 32
Ilustración 18 33
Ilustración 19 33
Ilustración 20 34
Ilustración 21 34
Ilustración 22 35
Índice
1. Introducción ...........................................................................................................................................................3
2. Sistemas de Objetivos........................................................................................................................................3
Objetivo General ...................................................................................................................................................3
Objetivos Específicos ............................................................................................................................................3
3.Desarrollo…………………………………………………………………………………………4
4.Conclusiones .........................................................................................................................................................23
5. Recomendaciones……………………………………………………………………………………….……23
6. Bibliografías……………………………………………………………………………………………..…. 23
1. Introducción
Este informe de laboratorio describe el proceso de instalación y configuración del entorno Git
Bash en Windows, y su uso para ejecutar códigos en el entorno de programación Apache NetBeans.
Además, se introduce el concepto de encapsulamiento en programación orientada a objetos, así como
los conceptos de clases, objetos, atributos y métodos en Java y su aplicación en NetBeans.
El informe está dividido en secciones. Primeramente, se explican los pasos necesarios para
instalar y configurar Git Bash, para Windows que permite interactuar con el sistema de control de
versiones Git. En la segunda sección, se presenta el entorno de programación Apache NetBeans, un IDE
para Java, y se explica su uso para escribir y ejecutar código en Java. Finalmente, se enfoca en los
conceptos de encapsulamiento en, clases, objetos, atributos y métodos en Java.
las clases se utilizan para definir la estructura y el comportamiento de los objetos, los objetos
son instancias concretas de una clase y representan entidades del mundo real, los atributos son variables
que almacenan datos específicos de cada objeto y los métodos son bloques de código que definen el
comportamiento y las acciones que pueden realizar los objetos. Juntos, estos conceptos forman la base
de la programación orientada a objetos en Java y permiten crear aplicaciones más modularizadas,
reutilizables y organizadas.
(Robert C. Martin)
2. Sistemas de Objetivos
Objetivo General
Demostrar cómo descargar y configurar Git Bash y Apache NetBeans en Windows y ejecutar en Java,
incluyendo el funcionamiento del encapsulamiento en programación orientada a objetos para poder
crear códigos y mejorar la comprensión de los conceptos de programación.
Objetivos Específicos
• Introducir el entorno de programación Apache NetBeans y su uso para escribir y ejecutar

código en Java, incluyendo la creación de proyectos y la compilación de código.
• Explicar detalladamente el proceso de instalación de Git Bash en Windows, incluyendo la

descarga del archivo de instalación y su ejecución.
• Proporcionar ejemplos prácticos de la aplicación de encapsulamiento, clases, objetos, atributos
y métodos en Java y demostrar su impacto en la calidad del código y la eficiencia del desarrollo
de software.
3. Desarrollo
1. Programación orientada a objetos: La programación orientada a objetos es un

paradigma de programación que se basa en la idea de modelar el mundo real mediante la creación de
objetos. Estos objetos encapsulan datos (atributos) y comportamientos (métodos), lo que permite una
estructura organizada y modular del código. Como dijo Uncle Bob (Robert C. Martin): "La
programación orientada a objetos no es pensar en objetos, es pensar en cómo hacer programas que
hagan cosas." Uncle Bob (Robert C. Martin)
2. Variables y tipos de datos en Java: Las variables son elementos fundamentales en la

programación, ya que nos permiten almacenar y manipular datos en un programa. En Java, existen
diferentes tipos de datos, como enteros (byte, short, int, long), caracteres (char), números decimales
(double, float), cadenas de texto (String) y variables booleanas. Cada tipo de dato tiene un rango y una
forma específica de representación. Es importante elegir el tipo de dato adecuado según las necesidades
del programa. (Roberto Hernández Sampieri)
3. Uso de condicionales en Java: Los condicionales son estructuras de control que nos
permiten tomar decisiones en un programa. En Java, se utilizan principalmente las sentencias if-else
para evaluar una condición y ejecutar diferentes bloques de código en función del resultado. Es posible
combinar múltiples condiciones utilizando operadores lógicos como && (AND) y || (OR). Los
condicionales son herramientas poderosas para controlar el flujo de ejecución de un programa y
adaptarlo a diferentes situaciones. (Rock Content)
4. Creación de objetos y asignación de atributos: En Java, los objetos son instancias de una
clase, que es una plantilla que define las propiedades y comportamientos de un objeto. Al crear un
objeto, se reserva espacio en memoria para almacenar sus atributos, que representan características
específicas del objeto. Estos atributos pueden ser variables de diferentes tipos de datos. La asignación
de atributos se realiza mediante la utilización del operador de asignación (=), donde se proporcionan los
valores correspondientes a cada atributo del objeto. Esta técnica nos permite almacenar información
relevante y modelar entidades del mundo real en nuestros programas. (Jairo García)
Código para configurar el Git Bash con el repositorio GitHub
• Primero descargamos el Git Bash, ya teniéndolo instalado procedemos a configurarlo con

nuestro usuario y correo de nuestra cuenta GitHub ya creada para poder subir nuestros archivos al
repositorio.
PC-MASTER@DESKTOP-FELSKOT MINGW64 ~ (master)

$ cd Documents
PC-MASTER@DESKTOP-FELSKOT MINGW64 ~/Documents (master)

$ mkdir AJLV_PROGRA
PC-MASTER@DESKTOP-FELSKOT MINGW64 ~/Documents (master)

$ cd AJLV_PROGRA
PC-MASTER@DESKTOP-FELSKOT MINGW64 ~/Documents/AJLV_PROGRA (master)

$ git init
Initialized empty Git repository in C:/Users/PC-MASTER/Documents/AJLV_PROGRA/.git/

$ touch .gitigoner

$ git add .gitigoner
$ touch Practica.txt

$ git add Practica.txt

$ git config --global user.name ajlaglaguano

$ git config --global user.mail ajlaglaguano@espe.edu.ec

$ git commit -m "Mi primera practica"
[master (root-commit) ba458a3] Mi primera practica
2 files changed, 0 insertions(+), 0 deletions(-)
create mode 100644. gitigoner
create mode 100644 Practica.txt

$ git branch -M main
PC-MASTER@DESKTOP-FELSKOT MINGW64 ~/Documents/AJLV_PROGRA (main)

$ git remote add origin https://github.com/AndyLaglaguanoV/AndyLaglaguanoV.git

$ git push -u origin main

$ git push -u origin main
Enumerating objects: 3, done.
Counting objects: 100% (3/3), done.
Delta compression using up to 8 threads
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 236 bytes 1 118.00 Ki6/s, done.
Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
To https:https://github.com/AndyLaglaguanoV/AndyLaglaguanoV.git
* [new branch] main -> main
branch 'main' set up to track 'origin/main'.
Código Variables Java
Luego de tener configurada nuestra cuenta del Git Bash con nuestro repositorio, ya podemos
comenzar a realizar nuestros primeros códigos en NetBeans en este caso comenzamos con variables
tipo enteros y caracteres. El código proporcionado muestra ejemplos de declaración y asignación de
variables en Java. Se presentan diferentes tipos de variables, como enteros (byte, short, int, long),
caracteres (char), números decimales (double, float), cadenas de texto (String) y variables booleanas.
Además, se imprime en la consola el valor de una de las variables. En resumen, el código ilustra cómo
se pueden utilizar y manipular diferentes tipos de variables en un programa de Java.
/*
* Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this
license
* Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Main.java to edit this template
*/
package variables.java;
/**
*
* @author PC-MASTER
*/
public class VariablesJava {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// Nuemeros enteros
byte a= 5 ;
short b= 200;
int c = 1000000;
long d = 10000000000L;
//Caracter
char e = 'a';
double f = 4.5;
float g = 4.5f;
String h= "Hola Mundo";
boolean i = 5 > 10;
System.out.println(h);
}
}
Operadores Java
Como segundo proyecto, se ha desarrollado el siguiente código que se basa en la declaración de

variables y el uso de operadores aritméticos. En este caso, se utilizan variables de tipo entero para
realizar operaciones de suma, resta, multiplicación y división.
Este código utiliza variables de tipo entero num1 y num2 para almacenar los valores utilizados
en las operaciones. Luego, se realizan las operaciones de suma, resta, multiplicación y división, y se
almacenan en las variables correspondientes. Finalmente, los resultados se imprimen en la consola.
/*
license
*/
package operadores_java;
/**
*
* @author PC-MASTER
*/
public class Operadores_Java {
/**
*/
// Declaracion de variables
int a = 4;
int b = 3;
// Declaracion de operadores
int suma = a+b;
int resta = a-b;
int multi = a*b;
int div = a/b;
System.out.println(suma);
System.out.println(resta);
System.out.println(multi);
System.out.println(div);
}
}
Código de NetBeans de Operadores racionales
En el siguiente proyecto se realizó el siguiente código que sirve para mostrar ejemplos de uso
de operadores relacionales en Java. Específicamente, se utiliza el operador < para comprobar si el valor
de la variable "valor1" es menor que el valor de "valor2" y se utiliza el operador > para comprobar si el
valor de "valor1" es mayor que el valor de "valor2". Los resultados de estas comparaciones se imprimen
en la consola. Esto permite demostrar cómo funcionan los operadores relacionales en Java y cómo se
pueden utilizar para realizar comparaciones entre valores numéricos.

license
*/
package operadores_relacionales;
/**
*
* @author PC-MASTER
*/
public class Operadores_Relacionales {

int valor1 = 20;
int valor2 = 30;
System.out.println(valor1< valor2);
System.out.println(valor1 >valor2);
}
Código de operadores lógicos
El siguiente código proporcionado utiliza operadores lógicos en Java para realizar

comparaciones entre valores enteros. Se utiliza el operador == para verificar si el valor de "valorM" es
igual al valor de "valorL", y el operador != para comprobar si son diferentes. Luego, se utilizan los
operadores lógicos && (AND) y || (OR) para combinar las comparaciones y obtener resultados lógicos.
/*
license
*/
package operadores_logicos;
/**
*
* @author PC-MASTER
*/
public class Operadores_Logicos {
/**
*/
int valorM = 10;

int valorL = 24;
System.out.println((valorM== valorL)&& (valorM != valorL));//true

System.out.println((valorM== valorL)|| (valorM != valorL)); //true
System.out.println(valorM != valorL);//false
Código de NetBeans Practica Ramdom
En este proyecto el código proporcionado utiliza la clase Math de Java para generar números
aleatorios. Se utiliza el método Math.random() para obtener un número aleatorio en el rango de 0.0
(incluido) a 1.0 (excluido). Además, se muestra cómo multiplicar el resultado por 100 para obtener un
número aleatorio de dos dígitos y cómo convertirlo en un entero utilizando (int) para obtener un
número entero en el rango de 0 a 99. En resumen, el código muestra cómo generar y manipular números
aleatorios en Java.
/*
license
*/
package practica_ramdom;
/**
*
* @author PC-MASTER
*/
public class Practica_Ramdom {
/**
*/
System.out.println( Math.random());
// PARA HACERLO DE DOS DIGITOS
System.out.println( Math.random()*100);
// Los convertimos a entero
System.out.println((int)(Math.random()*100 ));
}
Código Practica_06_condicionales
Finalmente, en este último código creado en la primera parte de nuestro laboratorio El código
proporcionado utiliza condicionales (if-else) en Java para imprimir un saludo dependiendo de la hora
del día. Si la variable "hora" está entre 0 y 12 (inclusive), se imprime "BUENOS DIAS". Si la hora está
entre 12 y 18 (inclusive), se imprime "BUENAS TARDES". De lo contrario, se imprime "BUENAS
NOCHES". Este código muestra cómo utilizar estructuras de control condicionales para tomar
decisiones basadas en una condición específica.
/*
license
*/
package practica_06_condicionales;
/**
*
* @author PC-MASTER
*/
public class Practica_06_condicionales {
/**
*/
// sentencia if (condicional)
int hora = -5;
if (hora >= 0 && hora <= 12){
System.out.println("BUENOS DIAS ");
}else{ if( hora >12 && hora <= 18){
System.out.println("BUENAS TARDES");
}else{
System.out.println("BUENAS NOCHES");
}
}
}
}
Segunda parte del proyecto códigos de tipo clases
El código proporcionado crea instancias de diferentes objetos, como "Niño", "Zapato" y

"Televisor", y asigna valores a sus atributos. Luego, se imprimen en la consola algunos de los atributos
de estos objetos. En resumen, el código ilustra cómo se pueden crear y manipular objetos en Java,
asignando valores a sus atributos y accediendo a ellos para obtener información.
Menú principal
/*
license
*/
package ppo6_laboratorio1_practica_clase;
/**
*
* @author PC-MASTER
*/
public class PPO6_LABORATORIO1_PRACTICA_CLASE {
/**
*/
// TODO code application logic here
// VALOREES NIÑO 1
Niño niño1 = new Niño();
niño1.Nombre= "Joel";
niño1.Edad= "8";
niño1.Etnia= "Mestizo";
niño1.Color= "Blanco";
niño1.Genero= "Masculino";
// VALORES NIÑO 2
Niño niño2 = new Niño();
niño2.Nombre= "Diego";
niño2.Edad= "5";
niño2.Etnia= "Mestizo";
niño2.Color= "Moreno";
niño2.Genero= "Masculino";
// VALORES ZAPATO 1
Zapato zapato1 = new Zapato();
zapato1.Color= "Negro";
zapato1.Talla= "42";
zapato1.Marca= "Venus";
zapato1.Modelo="Casual";
zapato1.Precio= "35";
// VALORES ZAPATO 2
Zapato zapato2 = new Zapato();
zapato2.Color= "Blanco";
zapato2.Talla= "40";
zapato2.Marca= "Adidas";
zapato2.Modelo="Deportivo";
zapato2.Precio= "55";
// VALORES TELEVISOR 1
Televisor televisor1 = new Televisor();
televisor1.Color= "Negro";
televisor1.Pulgadas= "55";
televisor1.Marca= "LG";
televisor1.Pantalla= "Oled";
televisor1.Precio= "1200";
// VALORES TELEVISOR 1
Televisor televisor2 = new Televisor();
televisor2.Color= "Blanco";
televisor2.Pulgadas= "75";
televisor2.Marca= "TCL";
televisor2.Pantalla= "LCD";
televisor2.Precio= "850";
System.out.println(televisor1.Color);
System.out.println(televisor1.Pulgadas);
CODIGO CLASE_ Niño
/*
license
* Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
*/
/**
*
* @author PC-MASTER
*/
public class Niño {
String Nombre;
String Edad;
String Etnia;
String Color;
String Genero;
CODIGO CLASE_ Televisor
/*
license
*/
/**
*
* @author PC-MASTER
*/
public class Televisor {
String Color;
String Pulgadas;
String Marca;
String Pantalla;
String Precio;
CODIGO CLASE_ Zapato
/*
license
*/
/**
*
* @author PC-MASTER
*/
public class Zapato {
String Color;
String Talla;
String Marca;
String Modelo;
String Precio;
Tercera parte del proyecto códigos de tipo clase
Código proyecto clase Operadores
Menú principal
El código proporcionado se refiere a una clase llamada "POO_PRACTICA_CLASE_2" que

contiene el método principal "main". Aquí se crea una instancia de la clase "Operaciones" llamada
"operacion1" y se llama a sus métodos para realizar una serie de operaciones.
En el método "main", se invoca el método "capturarnumeros()" de la instancia "operacion1"
para capturar los números necesarios para las operaciones. Luego se llama al método "sumar()" para
realizar la suma de los números capturados. Finalmente, se llama al método "resultados()" para
imprimir los resultados de las operaciones.
Este código muestra un ejemplo básico de cómo utilizar una clase llamada "Operaciones" para
realizar operaciones matemáticas. Se asume que la clase "Operaciones" está implementada en otro
archivo del proyecto.
/*
license
*/
package com.mycompany.poo_practica_clase_2;
/**
*
* @author ESPE
*/
public class POO_PRACTICA_CLASE_2 {
Operaciones operacion1 = new Operaciones ();
operacion1.capturarnumeros();
operacion1.sumar();
operacion1.resultados();
}
}
Clase Operadores
El código proporcionado pertenece a la clase "Operaciones", que incluye métodos para capturar
números ingresados por el usuario, realizar una suma y mostrar el resultado. Utiliza la clase
JOptionPane para mostrar mensajes y recibir la entrada del usuario. Los números capturados se
almacenan en variables, se realiza la suma y se imprime el resultado.
/*
license
*/
package com.mycompany.poo_practica_clase_2;
import javax.swing.JOptionPane;
/**
*
* @author ESPE
*/
public class Operaciones {
int nu1;
int nu2;
int suma;
int resta; int multiplicacion; int division;
public void capturarnumeros() {
nu1=Integer.parseInt(JOptionPane.showInputDialog("Digite su primer numero numero"));

nu2=Integer.parseInt(JOptionPane.showInputDialog("Digite un numero"));
}
public void sumar() {
suma=nu1+nu2;
}
//generamor de metodos
//pedimos numeros
//nuestro metodos es publico
public void resultados() {
System.out.println("El resultado de la suma es:"+suma);
}
}
Proyecto 2 Método retorno de valores
Menú principal
El código proporcionado corresponde al programa "Metodo_retorno_de_valores", el cual utiliza

la clase "Operaciones". En este programa, se solicita al usuario ingresar dos números y se realiza la
suma de los mismos utilizando el método "sumar" de la clase "Operaciones". El resultado de la suma se
almacena en una variable y se muestra en pantalla utilizando el método "resultados". Además, se
imprime nuevamente el resultado de la suma utilizando el método "sumar". El programa utiliza la clase
JOptionPane para mostrar mensajes y recibir la entrada del usuario
/*
license
*/
package metodo_retorno_de_valores;
/**
*
* @author ESPE
*/
public class Metodo_retorno_de_valores {
/**
*/
Operaciones op1 = new Operaciones();
int nu1=Integer.parseInt(JOptionPane.showInputDialog("Deme numero"));

int nu2=Integer.parseInt(JOptionPane.showInputDialog("Digite numero"));
int ope=op1.sumar(nu1,nu2);
op1.resultados(ope);
System.out.println("El resultado de la suma es:"+op1.sumar(nu1, nu2));
Clase Operadores
La clase "Operaciones" contiene un método llamado "sumar" que recibe dos parámetros
enteros, "nu1" y "nu2". Dentro de este método, se realiza la suma de los dos números y se almacena en
una variable local llamada "suma". Posteriormente, se retorna el valor de la suma. Además, la clase
tiene un método llamado "resultados" que recibe como parámetro el resultado de la suma, pero no
realiza ninguna operación en su cuerpo.
/*
license
*/
package metodo_retorno_de_valores;
/**
*
* @author ESPE
*/
public int sumar(int nu1, int nu2){
int suma = nu1 + nu2 ;
//retorno suma
return suma;
}
// CREAMOS METODO PARA MOSTRAR RESULTADO
public void resultados (int suma){
Proyecto 3 Método con argumentos
El código muestra una clase llamada "Metodo_con_argumentos" que contiene el método

principal "main". Dentro de este método, se crea una instancia de la clase "Operaciones" llamada "op1".
Luego, se solicita al usuario ingresar dos números enteros utilizando la clase JOptionPane y se
almacenan en las variables "nu1" y "nu2". A continuación, se llama al método "sumar" de la instancia
"op1" y se le pasan como argumentos los números ingresados. Sin embargo, no se realiza ninguna
operación con el resultado de la suma. Por último, se llama al método "resultados" de la instancia "op1",
pero su implementación no se muestra en el código proporcionado.
/*
license
*/
package metodo_con_argumentos;
/**
*
* @author ESPE
*/
public class Metodo_con_argumentos {
/**
*/
Operaciones op1 = new Operaciones ();
int nu1=Integer.parseInt(JOptionPane.showInputDialog("Digite su primer numero

numero"));
int nu2=Integer.parseInt(JOptionPane.showInputDialog("Digite un numero"));
//llama a s variables
op1.sumar(nu1, nu2);
//presentamo los resultados
op1.resultados();
CLASE OPERACIONES
El código muestra una clase llamada "Operaciones" que tiene los campos de instancia "suma",
"resta", "multiplicacion" y "division". Luego, se definen dos métodos: "sumar" y "resultados". El
método "sumar" toma dos parámetros enteros "nu1" y "nu2" y calcula la suma asignándola al campo
"suma". Sin embargo, hay un error de sintaxis en el código debido a la presencia de un punto y coma
después del nombre del campo "suma" en la declaración. El método "resultados" está incompleto y no
se muestra su implementación en el código proporcionado.
/*
license
*/
package metodo_con_argumentos;
/**
*
* @author ESPE
*/
int suma;, int resta ; int multiplicacion ; int division;
//generamos meotos
// nuestro metodo es publioc
// CREAMOS METODOS
public void sumar(int nu1, int nu2){

suma=nu1+nu2;
public void reultados
4. Conclusiones
• La instalación y configuración de Git Bash es un proceso sencillo y necesario para
interactuar con el sistema de control de versiones Git en Windows.
• Apache NetBeans es un entorno de programación completo y fácil de usar para el
desarrollo en Java.
• El encapsulamiento, las "clases" y los "objetos" son conceptos fundamentales de la
programación orientada a objetos en Java y son esenciales para la creación de
programas de calidad.
5. Recomendaciones
• Para aquellos que deseen trabajar en proyectos de programación, Git Bash es una
herramienta valiosa que permite la colaboración y el control de versiones.
• Es importante seguir buenas prácticas de programación, como la implementación de

encapsulamiento y la creación de "clases" y "objetos" claramente definidos para
asegurar un código de calidad y fácil de mantener.
• Los estudiantes de programación pueden beneficiarse de la práctica constante en la

escritura y ejecución de código en Java, lo que les permitirá mejorar sus habilidades de
programación y comprender mejor los conceptos de programación orientada a objetos.
6. Bibliografía/ Referencias
NetBeans IDE. (s/f). Oracle.com. Recuperado el 10 de mayo de 2023, de
https://www.oracle.com/es/tools/technologies/netbeans-ide.html
Netbeans. (s/f). Juntadeandalucia.es. Recuperado el 10 de mayo de 2023, de
https://www.juntadeandalucia.es/servicios/madeja/contenido/recurso/888
Canelo, M. M. (2020b, noviembre 2). ¿Qué es la Programación Orientada a
Objetos? Profile Software Services. https://profile.es/blog/que-es-la-
programacion-orientada-a-objetos/
(S/f). Amazon.com. Recuperado el 10 de mayo de 2023, de https://aws.amazon.com/es/what-
is/ide/#:~:text=Un%20entorno%20de%20desarrollo%20integrado,una%20aplicaci%C3%B
3n%20f%C3%A1cil%20de%20usar.
"Clean Code: A Handbook of Agile Software Craftsmanship" - Robert C. Martin
ANEXOS
Instalación del Git Bash
Ilustración 1. En nuestro navegador buscamos Git Bash.
Ilustración 2. Seleccionamos la primera opción que es la página oficial.
Ilustración 3. Selecciona la versión de Git bash que deseas descargar. Por lo general, se
recomienda la última versión disponible, aunque también debes considerar la compatibilidad
con otros programas que utilices.
Ilustración 4. Luego de haber finalizado la descarga lo buscamos en nuestra biblioteca de

descargas o donde lo guardamos.
Ilustración 5. Procedemos a instalar siguiendo los pasos necesarios.
Ilustración 6. Seguimos configurado y siguiendo los pasos necesarios.
Ilustración 7. Luego de haber aceptado y configurado correctamente empezara la instalación.
Ilustración 8. Terminada la instalación seleccionamos finish.
Ilustración 9. Luego abrimos el Git Bash para empezar su configuración.
Ilustración 10. Configuramos con nuestros datos
Ilustración 11. Finalizamos
Ilustración 12. Código Variables Java
Ilustración 13. Código Operadores Java
Ilustración 14. Operadores Relacionales
Ilustración 15. Código Practica random
Ilustración 16. Operadores Lógicos
Ilustración 17. Condicionales “if , elseif”
Segunda parte de laboratorio práctica de clases, objetos, atributos Y métodos en Java
Menú principal
Ilustración 17. Practica en clases
Ilustración 18. Practica en clases
Ilustración 19. Menú principal
Ilustración 20. Clase niño
Ilustración 21. Clase Zapato
Ilustración 22. Clase Televisor

Poo Laboratorio1 Practica

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Poo Laboratorio1 Practica

Cargado por

Copyright:

Formatos disponibles

Fundamentos de la programación

UNIVERSIDAD DE LAS FUERZAS ARMADAS-ESPE

CARRERA DE INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

PERIODO : abril 2023 – agosto 2023

ASIGNATURA : Programación Orientada a objetos

NOMBRES : Laglaguano Villavicencio Andy Joel

NIVEL-PARALELO : Segundo nivel “A”

DOCENTE : Ing. Cevallos Farias Javier José

FECHA DE ENTREGA : 16/05/2023

SANTO DOMINGO - ECUADOR

incluyendo el funcionamiento del encapsulamiento en programación orientada a objetos para poder

crear códigos y mejorar la comprensión de los conceptos de programación.

• Introducir el entorno de programación Apache NetBeans y su uso para escribir y ejecutar

• Explicar detalladamente el proceso de instalación de Git Bash en Windows, incluyendo la

1. Programación orientada a objetos: La programación orientada a objetos es un

2. Variables y tipos de datos en Java: Las variables son elementos fundamentales en la

Código para configurar el Git Bash con el repositorio GitHub

• Primero descargamos el Git Bash, ya teniéndolo instalado procedemos a configurarlo con

PC-MASTER@DESKTOP-FELSKOT MINGW64 ~ (master)

PC-MASTER@DESKTOP-FELSKOT MINGW64 ~/Documents (master)

PC-MASTER@DESKTOP-FELSKOT MINGW64 ~/Documents (master)

PC-MASTER@DESKTOP-FELSKOT MINGW64 ~/Documents/AJLV_PROGRA (master)

PC-MASTER@DESKTOP-FELSKOT MINGW64 ~/Documents/AJLV_PROGRA (master)

PC-MASTER@DESKTOP-FELSKOT MINGW64 ~/Documents/AJLV_PROGRA (master)

PC-MASTER@DESKTOP-FELSKOT MINGW64 ~/Documents/AJLV_PROGRA (master)

PC-MASTER@DESKTOP-FELSKOT MINGW64 ~/Documents/AJLV_PROGRA (master)

PC-MASTER@DESKTOP-FELSKOT MINGW64 ~/Documents/AJLV_PROGRA (master)

PC-MASTER@DESKTOP-FELSKOT MINGW64 ~/Documents/AJLV_PROGRA (master)

PC-MASTER@DESKTOP-FELSKOT MINGW64 ~/Documents/AJLV_PROGRA (master)

PC-MASTER@DESKTOP-FELSKOT MINGW64 ~/Documents/AJLV_PROGRA (master)

PC-MASTER@DESKTOP-FELSKOT MINGW64 ~/Documents/AJLV_PROGRA (main)

PC-MASTER@DESKTOP-FELSKOT MINGW64 ~/Documents/AJLV_PROGRA (main)

PC-MASTER@DESKTOP-FELSKOT MINGW64 ~/Documents/AJLV_PROGRA (main)

Código Variables Java

String h= "Hola Mundo";

boolean i = 5 > 10;

Como segundo proyecto, se ha desarrollado el siguiente código que se basa en la declaración de

Código de NetBeans de Operadores racionales

* Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this

public static void main(String[] args) {

El siguiente código proporcionado utiliza operadores lógicos en Java para realizar

int valorM = 10;

System.out.println((valorM== valorL)&& (valorM != valorL));//true

Código de NetBeans Practica Ramdom

Segunda parte del proyecto códigos de tipo clases

El código proporcionado crea instancias de diferentes objetos, como "Niño", "Zapato" y

CODIGO CLASE_ Niño

CODIGO CLASE_ Televisor

CODIGO CLASE_ Zapato

Tercera parte del proyecto códigos de tipo clase

Código proyecto clase Operadores

El código proporcionado se refiere a una clase llamada "POO_PRACTICA_CLASE_2" que

public static void main(String[] args) {

Operaciones operacion1 = new Operaciones ();

public void capturarnumeros() {

nu1=Integer.parseInt(JOptionPane.showInputDialog("Digite su primer numero numero"));

public void resultados() {

System.out.println("El resultado de la suma es:"+suma);

Proyecto 2 Método retorno de valores

El código proporcionado corresponde al programa "Metodo_retorno_de_valores", el cual utiliza

Operaciones op1 = new Operaciones();

int nu1=Integer.parseInt(JOptionPane.showInputDialog("Deme numero"));