Facultad de Ingeniería

Ingeniería de Redes y Comunicaciones

TAREA ACADÉMICA 3

Alumno: Quilla Lipa, Elvis Henry

Código: U21227145

Ciclo: 03

Curso: Taller de programación

Profesor: Lizardo Silva, Ubaldo

2023
 INDICE DE CONTENIDO

TEMA 1: JShell: conceptos, testing, ejemplo.......................................................................3

TEMA 2: Creación de un repositorio en github, registro de una cuenta, subir archivos
en la cuenta de github.............................................................................................................7
TEMA 3: Funcionamiento del JVM...................................................................................10
TEMA 4: Ejemplo de un Formulario con dos componentes visuales (no vistos en clases)
................................................................................................................................................15
CONCLUSIONES................................................................................................................17
BIBLIOGRAFÍAS................................................................................................................17

pág. 2
 TEMA 1: JSHELL: CONCEPTOS, TESTING, EJEMPLO

jshell es una herramienta de línea de comandos introducida en Java 9. Permite

ejecutar código de una manera sencilla sin necesidad de un IDE, aunque no es un
sustituto de estos. Se arranca, se escribe la sentencia en Java que se quiere
ejecutar, y automáticamente se muestra el resultado de la ejecución. Es decir, jshell
implementa el clásico patrón REPL (Read-Evaluate-Print Loop).
Es una herramienta bastante útil cuando se está escribiendo determinado tipo de
código. Lo habitual es tenerla abierta en una consola aparte e ir probando en ella
pequeños snippets de código a medida que se desarrolla. Esto permite tener un
feedback inmediato en vez de esperar a compilar y ejecutar toda la aplicación en el
IDE. Es útil sobre todo para probar variantes de un mismo código, experimentar
con una librería con la que no se tenga demasiada experiencia, evaluar una
secuencia larga de métodos concatenados, o ejecutar código copiado directamente
de un sitio web.
jshell se encuentra en el subdirectorio bin del directorio donde se encuentre
instalada la máquina virtual de Java. Se ejecuta arrancando directamente el
programa desde línea de comandos:

jshell admite el acostumbrado parámetro -help, que muestra todas las opciones
disponibles, y el clásico parámetro -v (verbose), que muestra información más
detallada durante la ejecución. Parámetros ambos que merece la pena utilizar, al
menos las primeras veces que se utilice la herramienta.
Una vez arrancado jshell se puede ejecutar código Java directamente en la propia
línea de comandos. Por ejemplo, se puede definir una variable y asignarle un valor:

Como se observa, a pesar de ser Java, no es necesario poner punto y coma al final
de la línea. La variable es automáticamente instanciada e inicializada. Se puede
comprobar su valor escribiendo una expresión que haga referencia a ella:

pág. 3
La expresión es evaluada y el valor resultante es automáticamente impreso. Lo
interesante es que la expresión puede ser todo lo compleja que se quiera:

Cuando jshell evalúa una expresión le asigna un identificador al resultado. En el

ejemplo anterior, el resultado se asigna a una variable de nombre $3. Esta variable
se puede referenciar y utilizar de manera independiente, o dentro de una expresión,
lo que a su vez creará una nueva variable:

Además de variables, también se pueden definir clases y métodos:

jshell evalúa las expresiones cuando se pulsa retorno de carro. Si la expresión es

válida, pero no está completa, entonces las siguientes líneas formarán también
parte de la expresión en curso, tantas como sean necesarias para completarla.
Las clases y métodos definidos se pueden referenciar dentro de expresiones:

Si se quiere cambiar una definición sólo hay que volver a declararla, la nueva
declaración sobrescribirá la anterior:

pág. 4
jshell es un editor de líneas que permite moverse por ellas con las teclas de cursor,
tiene teclas de acceso rápido para algunas acciones de edición comunes en la
mayoría de editores, algunas características básicas como un histórico de las
líneas introducidas, y una potente opción de autocompletar.
El autocompletar más básico se obtiene pulsando la tecla de tabulación a medida
que se escribe. Esto hace que se muestren todas las opciones disponibles que
casen con la expresión en curso, o directamente se complete la expresión si sólo
hay una opción disponible. Dependiendo del contexto, volviendo a pulsar tabulador,
se muestra información adicional, como por ejemplo la documentación si está
disponible:

pág. 5
Otras opciones de autocompletar se ejecutan pulsando shift junto con el tabulador.
En ese punto el editor se queda esperando que se pulse una tecla. La v sirve para
crear una variable con la expresión en curso, la m para crear un método, y la i para
importar una clase.
Por defecto están disponibles paquetes del módulo base de Java, pero se pueden
importar paquetes de librerías de terceros que se encuentren en el classpath:

jshell además de declaraciones y expresiones admite comandos. Los comandos se

utilizan para mostrar información y controlar el entorno de ejecución. Para
diferenciarlos de las expresiones, todos los comandos se escriben empezando por
el carácter barra (/). Sirven para listar el historial (/history), las clases (/types),
métodos (/methods), variables (/vars) y paquetes disponibles (/imports), volver a
ejecutar un snippet (/!), utilizar un editor externo (/edit), y realizar muchas otras
tareas. Es recomendable echar un vistazo a la ayuda para ver todos los comandos
disponibles.

Un último comando que hay que conocer es /exit, que sirve para cerrar jshell.
En definitiva, una herramienta muy útil de la que siempre han presumido muchos
otros lenguajes, sobre todo los de scripts, y que ahora también está disponible de
forma nativa para Java.

pág. 6
 TEMA 2: CREACIÓN DE UN REPOSITORIO EN GITHUB, REGISTRO DE UNA
CUENTA, SUBIR ARCHIVOS EN LA CUENTA DE GITHUB

Creación de un repositorio
1. En la esquina superior derecha de cualquier página, utiliza el menú
desplegable + y selecciona New repository (Nuevo repositorio).

2. Escriba un nombre corto y fácil de recordar para el repositorio. Por ejemplo:

"hola-mundo".

3. Opcionalmente, puede agregar una descripción del repositorio. Por ejemplo,

"Mi primer repositorio en GitHub".
4. Elige la visibilidad del repositorio. Para obtener más información, vea «Acerca
de los repositorios».
5. Seleccione Initialize this repository with a README (Inicializar este repositorio
con un archivo Léame).
6. Haga clic en Create repository (Crear repositorio).
Felicidades. Ha creado correctamente su primer repositorio y lo has inicializado con
un archivo Léame.

pág. 7
Registro de una cuenta
1. Si quieres crear una cuenta personal nueva, asegúrate de haber cerrado sesión
en GitHub.
2. Vaya a la página de precios de GitHub.
3. Lea la información acerca de los diferentes productos y suscripciones que
GitHub ofrece y, después, haga clic en el botón actualizar de la suscripción que
quiere elegir.
4. Sigue las indicaciones para crear tu cuenta personal o de organización.

Pasos siguientes
"Verificar tu dirección de correo electrónico"
"Crear una cuenta empresarial" en la documentación de GitHub Enterprise Cloud
GitHub public roadmap en el repositorio github/roadmap

Como subir archivos en la cuenta de github

En la parte inferior del repositorio se visualizará el contenido del README (es
conveniente crearlo y darle unos estilos adecuados), además de instrucciones
sobre cómo funciona el programa, aplicación o herramienta y cómo ponerlo en
marcha.
Para subir un código previamente creado hay que hacer lo siguiente:
1. Abre la terminal en la carpeta donde se alojan los ficheros fuente y escribe el
siguiente código para iniciar git en dicha carpeta:
git init

2. Se habrá creado la carpeta. git con la información del proyecto. Añade los
ficheros para subir el mismo con este comando:
git add
Otra forma de añadir un único fichero es introduciendo el comando siguiente:
git add nombrdelfichero

3. Prepara los ficheros que quieres subir con una pequeña explicación acerca de
los cambios:
git commit -m “Creado el proyecto inicial”

pág. 8
4. Debes subir los cambios a GitHub. Para ello tienes que saber la ruta del
repositorio (acabada en. git) que está en Clone or Download, el botón verde de
la página del proyecto. Luego añade el repositorio desde la terminal con este
comando:
git remote add origin URLrepositorio.git

5. Sube los cambios con el siguiente comando:

git push origin master

Cómo subir un proyecto local a GitHub desde Visual Studio Code:

Microsoft tuvo la genial idea de integrar GitHub en su entorno de desarrollo para
que los desarrolladores pudieran subir sus proyectos sin problemas desde Visual
Studio Code. Para ello hay que hacer lo siguiente:
1. Conéctate a GitHub desde Visual Studio Code yendo a la sección Team
Explorer, luego haz clic en Administrador de conexiones y después en Sign in.
2. Introduce tu usuario y contraseña de GitHub.
3. Si no lo has hecho antes, crea un repositorio para tu espacio de trabajo como
viste previamente.
4. Añade tu proyecto haciendo doble clic en el repositorio.
5. Copia la solución del proyecto a la ruta del espacio de trabajo.
6. Haz clic en Cambios y verás una lista que muestra los archivos que se incluirán
en el repositorio.
7. Añade una descripción sobre los cambios y haz clic en Commit All.
8. Sincroniza los cambios con GitHub para subir los archivos a dicha plataforma
haciendo clic en Sync al aparecer el mensaje de confirmación de Commit.
9. Presiona el botón Push para que inicie el proceso y verás un mensaje que
confirma la publicación del proyecto en el repositorio.
10.Entra en la web de GitHub y accede a tu cuenta para verificar si el proyecto se
ha subido correctamente.

Si has seguido estos pasos, tu proyecto se habrá subido correctamente a GitHub.

pág. 9
 TEMA 3: FUNCIONAMIENTO DEL JVM

La JVM (Java Virtual Machine) actúa como un motor en tiempo de ejecución para
ejecutar aplicaciones Java.
No confundir con los emuladores, por ejemplo, para programar en Android, aunque
tengan sus similitudes.
Como vimos anteriormente en las características de Java, se destaca por ser
independiente de la plataforma, y precisamente esto se debe a la JVM, pero ¿qué
es realmente la máquina virtual de Java?
JVM es la que realmente llama al método principal presente en un código Java.
JVM es una parte del JRE (Java Run Environment).
Las aplicaciones Java se llaman WORA (Write Once Run Everywhere). Esto
significa que un programador puede desarrollar código Java en un sistema y puede
esperar que se ejecute en cualquier otro sistema habilitado para Java sin ningún
ajuste. Todo esto es posible gracias a la JVM.
1. ¿Cómo funciona?
1.1. Subsistema Java Class Loader
Es principalmente responsable de tres actividades:
 Carga
 Enlace
 Inicialización
1.1.1. Carga
El cargador de clases lee el archivo .class, genera los datos binarios
correspondientes y los guarda en el área de métodos (“method area” –vea la
imagen anterior). Para cada archivo .class, JVM almacena la siguiente información
en el área de método.
Nombre completamente calificado de la clase cargada y su clase primaria
inmediata.
Si el archivo .class está relacionado con Class o Interface o Enum
Información sobre modificadores, variables, métodos, etc.
Después de cargar el archivo .class, JVM crea un objeto de tipo Class para
representar este archivo en la memoria heap. Tenga en cuenta que este objeto es
de tipo Class predefinido en el paquete java.lang. Este objeto Class puede ser
utilizado por el programador para obtener información de nivel de clase como
nombre de clase, nombre principal, métodos e información de variable, etc. Para
obtener esta referencia de objeto, podemos usar el método getClass() de la clase
Object.

pág. 10
Por ejemplo:

Salida:

pág. 11
1.1.2. Vinculación o Enlace
Realiza la verificación, la preparación y (opcionalmente) la resolución.
 Verificación: asegura la exactitud del archivo .class, es decir, comprueba si este
archivo está formateado correctamente y generado por un compilador válido o
no. Si la verificación falla, obtenemos la excepción de tiempo de ejecución
java.lang.VerifyError.
 Preparación: JVM asigna memoria para las variables de clase e inicializa la
memoria a los valores predeterminados.
 Resolución: es el proceso de reemplazar referencias simbólicas del tipo con
referencias directas. Se realiza buscando en el área del método (method area)
para localizar la entidad a la que se hace referencia.
1.1.3. Inicialización
En esta fase, todas las variables estáticas se asignan con sus valores definidos en
el código y en el bloque estático (si corresponde). Esto se ejecuta de arriba a abajo
en una clase y de padres a hijos en la jerarquía de clases.
En general, hay tres cargadores de clase (class loaders):
 Cargador de clases Bootstrap (Bootstrap class loader): cada implementación
de JVM debe tener un cargador de clases de arranque, capaz de cargar clases
confiables. Carga las clases API centrales de java presentes en el directorio
JAVA_HOME/jre/lib. Esta ruta se conoce popularmente como ruta de arranque.
Se implementa en lenguajes nativos como C, C++.
 Cargador de clases de extensiones (Extension class loader): es un elemento
secundario del Bootstrap class loader. Carga las clases presentes en los
directorios de extensiones JAVA_HOME/jre/lib/ext (Ruta de extensión) o
cualquier otro directorio especificado por la propiedad del sistema java.ext.dirs.
Está implementado en Java por la clase sun. misc.Launcher$ExtClassLoader.
 Cargador de clases de sistema/aplicación (system/Application class loader): es
secundario del cargador de clases de extensión. Es responsable de cargar las
clases desde la ruta de la clase de aplicación. Internamente utiliza la variable
de entorno asignada a java.class.path. También se implementa en Java
mediante la clase sun.misc.Launcher$AppClassLoader.
Por ejemplo:

pág. 12
Salida:

1.2. Memoria JVM

 Área de método (Method area): en el área de método, se almacena toda la
información del nivel de clase, como el nombre de clase, el nombre inmediato
de la clase principal, la información de métodos y variables, etc., incluidas las
variables estáticas. Solo hay un área de método por JVM, y es un recurso
compartido.
 Área Heap (Heap area): la información de todos los objetos se almacena en el
área heap. También hay un área heap por JVM. También es un recurso
compartido.
 Área de pila (Stack area): para cada subproceso, JVM crea una pila en tiempo
de ejecución que se almacena aquí. Cada bloque de esta pila se llama registro
de activación/marco de pila que almacena los métodos de llamadas. Todas las
variables locales de ese método se almacenan en su marco correspondiente.
Una vez que finaliza un hilo, JVM destruirá la pila en tiempo de ejecución. No
es un recurso compartido.
 Registros de PC (PC Registers): Almacena la dirección de la instrucción de
ejecución actual de un hilo. Obviamente, cada hilo tiene registros de PC
separados.
 Pilas de métodos nativos (Native method stacks): para cada hilo, se crea una
pila nativa separada. Almacena información del método nativo.

pág. 13
1.3. Motor de ejecución (Execution Engine)
El motor de ejecución ejecuta .class (bytecode). Lee el código de bytes línea por
línea, usa datos e información presente en varias áreas de memoria y ejecuta
instrucciones. Se puede clasificar en tres partes:
 Intérprete: interpreta el bytecode línea por línea y luego lo ejecuta. La
desventaja aquí es que cuando se llama un método varias veces, cada vez
se requiere interpretación.
 Compilador Just-In-Time (JIT): se usa para aumentar la eficiencia del
intérprete. Compila todo el bytecode y lo cambia a código nativo para que
cada vez que el intérprete vea llamadas a métodos repetidos, JIT
proporcione código nativo directo para esa parte, de modo que la
reinterpretación no es necesario, por lo tanto, se mejora la eficiencia.
 Recolector de basura: destruye objetos no referenciados.
1.4. Interfaz nativa de Java (JNI – Java Native Interface)
Es una interfaz que interactúa con las Bibliotecas de métodos nativos y proporciona
las bibliotecas nativas (C, C++) necesarias para la ejecución. Permite a la JVM
llamar a bibliotecas C/C ++ y ser llamado por bibliotecas C/C++ que pueden ser
específicas del hardware.
1.5. Bibliotecas de métodos nativos (Native Method Libraries)
Es una colección de bibliotecas nativas (C, C ++) que requiere el motor de
ejecución.

pág. 14
 TEMA 4: EJEMPLO DE UN FORMULARIO CON DOS COMPONENTES
VISUALES (NO VISTOS EN CLASES)

En el siguiente formulario utilizo dos componentes visuales no vistos en clase. El primero es el

Spinner y el segundo Radio Button, adicionalmente uso Button Group para limitar al usuario
escoger solo una opción.

Tenemos que arrastrar el Radio Button al formulario y colocarle un nombre (en este caso le puse de
nombre “sexo”). Después vamos a properties de cada Radio Button y seleccionamos al grupo que
creamos anteriormente.

pág. 15
Este es el código que se utilizó para que funcione el formulario.

Finalmente, nos da este resultado.

pág. 16
CONCLUSIONES

 jShell es una herramienta de línea de comandos en Java que permite

experimentar y probar código de manera interactiva, lo que facilita el aprendizaje
y la depuración.
 jShell proporciona una forma rápida y conveniente de probar fragmentos de
código sin necesidad de escribir un programa completo, lo que agiliza el proceso
de desarrollo y prototipado.
 GitHub es una plataforma de desarrollo colaborativo que permite a los
desarrolladores alojar, revisar y colaborar en proyectos de software, lo que
fomenta la colaboración y el trabajo en equipo.
 JVM (Máquina Virtual de Java) es una parte fundamental del entorno de
ejecución de Java que interpreta y ejecuta el código bytecode, lo que garantiza
la portabilidad y la independencia de la plataforma.
 La JVM realiza diversas optimizaciones durante la ejecución, como la
compilación Just-In-Time (JIT), lo que mejora el rendimiento y la eficiencia del
código Java.

BIBLIOGRAFÍAS
https://inmensia.com/blog/20180509/jshell-un-repl-en-java/
https://intelequia.com/blog/post/c%C3%B3mo-subir-un-proyecto-a-un-repositorio-de-github
https://docs.github.com/es/get-started/signing-up-for-github/signing-up-for-a-new-github-
account#signing-up-for-a-new-account
https://docs.github.com/es/get-started/quickstart/create-a-repo
https://javadesdecero.es/fundamentos/como-funciona-maquina-virtual/

pág. 17