Facultad de Ingeniería

Ingeniería de Sistemas e Informática

TAREA ACADÉMICA 3

Alumno: Henry Rogger Belleza Alvarado

Código: U21215588
Ciclo: 5to
Curso: Taller de programación
Profesor: Raul Armando Jimenez Drago

2023
ÍNDICE
TEMA 1: JShell: conceptos, testing...............................................................................................3
TEMA 2: JSHELL EN CONSOLA Y EN IDE........................................................................................5
TEMA 3: FUNCIONAMIENTO DEL JVM..........................................................................................7
TEMA 4: EJEMPLO DE UN FORMULARIO CON DOS COMPONENTES VISUALES (NO VISTOS EN
CLASES)........................................................................................................................................9
CONCLUSIONES:.....................................................................................................................12
BIBLIOGRAFÍAS.......................................................................................................................13
TEMA 1: JShell: conceptos, testing

JShell es una herramienta de línea de comandos introducida en Java 9 que proporciona un

entorno interactivo para escribir, ejecutar y probar fragmentos de código Java. Es una especie
de "intérprete de Java" que permite experimentar con código en tiempo real sin necesidad de
escribir un programa completo.

Conceptos clave de JShell:

Fragmentos de código: Puedes ingresar fragmentos de código en JShell línea por línea, en lugar
de escribir un programa completo. Esto permite probar y experimentar con código de forma
interactiva.

Evaluación inmediata: JShell evalúa y ejecuta cada línea de código a medida que se ingresa.
Esto te permite ver los resultados de inmediato y explorar cómo funcionan diferentes
expresiones y declaraciones.

Variables y expresiones: Puedes declarar variables y utilizar expresiones en JShell. Las variables
se almacenan y están disponibles para su uso en fragmentos posteriores. Esto facilita el
seguimiento y la reutilización de valores durante una sesión de JShell.

Autocompletado: JShell admite autocompletado, lo que te ayuda a escribir código más rápido
y evita errores tipográficos. Puedes presionar la tecla Tab para ver las opciones de
autocompletado disponibles.

Historial de comandos: JShell mantiene un historial de comandos ingresados, lo que te permite

acceder a comandos anteriores y reutilizarlos en cualquier momento.
Testing:

En cuanto a las pruebas en Java con NetBeans, NetBeans es un entorno de desarrollo

integrado (IDE) para Java que proporciona herramientas y funciones para escribir, compilar y
depurar programas Java. NetBeans tiene un sólido soporte para pruebas unitarias y pruebas de
integración.

Puedes usar el marco de pruebas JUnit en NetBeans para escribir y ejecutar pruebas unitarias.
JUnit es una biblioteca popular para escribir pruebas en Java y se integra bien con NetBeans.
Puedes crear casos de prueba, establecer condiciones de prueba y verificar los resultados
esperados utilizando aserciones de JUnit.

NetBeans también proporciona características de depuración que te permiten analizar el flujo

de ejecución de tu código y encontrar y corregir errores en tus pruebas. Puedes establecer
puntos de interrupción, examinar variables y ejecutar el código paso a paso para comprender y
solucionar problemas.

Además de JUnit, NetBeans también admite otros marcos de pruebas y herramientas de

pruebas, como TestNG y Mockito, que te permiten realizar pruebas más avanzadas, como
pruebas de integración y pruebas de simulación.

En resumen, NetBeans es un entorno de desarrollo que proporciona un sólido soporte para

escribir y ejecutar pruebas en Java. Puedes utilizar el marco de pruebas JUnit y otras
herramientas de pruebas para realizar pruebas unitarias y de integración en tus aplicaciones
Java.
TEMA 2: JSHELL EN CONSOLA Y EN IDE
JSHELL en Consola:

Acceso a JShell: Para acceder a JShell en la consola de comandos, debes asegurarte de tener
Java 9 o una versión posterior instalada en tu sistema. Luego, ejecutas el comando "jshell" en
la consola y se iniciará el entorno interactivo de JShell.

Interacción en tiempo real: En la consola de comandos, puedes ingresar fragmentos de código

de Java línea por línea y JShell los ejecutará de inmediato. Verás los resultados y podrás
experimentar con diferentes expresiones y declaraciones de manera interactiva.

Historial de comandos: JShell mantiene un historial de los comandos ingresados en la sesión

actual. Puedes acceder a los comandos anteriores utilizando las teclas de flecha hacia arriba y
hacia abajo para navegar por el historial y reutilizar comandos.

Funcionalidad de edición: En la consola, puedes editar líneas de código previamente

ingresadas utilizando las teclas de flecha izquierda y derecha. Esto te permite corregir errores
o modificar el código existente antes de ejecutarlo nuevamente.

JSHELL en NetBeans:

Integración en NetBeans: NetBeans ofrece una integración nativa de JShell en su entorno de

desarrollo. Puedes abrir una ventana de JShell en NetBeans desde el menú "Window"
(Ventana) y seleccionando "JShell".

Interfaz gráfica: Al utilizar JShell en NetBeans, tendrás una interfaz gráfica más avanzada que
te permite ver tanto el código ingresado como los resultados de manera más organizada.
También puedes interactuar con JShell a través de la ventana de salida y la ventana de entrada
de comandos.
Autocompletado y sugerencias: NetBeans proporciona características adicionales, como
autocompletado y sugerencias de código, mientras escribes en la ventana de JShell. Esto
facilita la escritura de código y te ayuda a recordar los nombres de los métodos y las variables.

Integración con el proyecto: JShell en NetBeans está integrado con tu proyecto Java actual.
Puedes acceder a las clases y bibliotecas definidas en tu proyecto desde JShell, lo que te
permite realizar pruebas y experimentar con el código de tu aplicación.

En resumen, JShell se puede utilizar tanto en la consola de comandos como en un entorno de

desarrollo como NetBeans. En la consola, puedes ingresar y ejecutar código Java en tiempo
real, mientras que en NetBeans, JShell está integrado con el IDE y ofrece características
adicionales, como autocompletado y una interfaz gráfica más avanzada. Ambas opciones te
permiten experimentar y probar código de manera interactiva.
TEMA 3: FUNCIONAMIENTO DEL JVM
El JVM (Java Virtual Machine) es un componente crucial en el funcionamiento de las
aplicaciones Java. Es una máquina virtual que ejecuta el código Java compilado, también
conocido como bytecode, y proporciona un entorno de ejecución seguro y portátil para las
aplicaciones.

El funcionamiento básico del JVM se puede describir en los siguientes pasos:

Compilación: El código fuente de Java se compila utilizando el compilador de Java (javac) para
generar bytecode. El bytecode es un código intermedio que no se ejecuta directamente en la
máquina física, sino en el JVM.

Carga de clases: El JVM carga el bytecode en tiempo de ejecución y lo organiza en estructuras

de datos internas, como el ClassLoader y el Class Data Area. El ClassLoader se encarga de
cargar las clases necesarias para la ejecución, mientras que el Class Data Area almacena la
información de las clases cargadas.

Verificación: Antes de ejecutar el bytecode, el JVM realiza una verificación de seguridad para
garantizar que el código cumple con ciertas restricciones y no puede acceder a recursos no
autorizados. Esta verificación incluye comprobar la integridad del bytecode, la validación de
tipos y la detección de errores potenciales.

Interpretación y compilación en tiempo real (JIT): El JVM interpreta el bytecode línea por línea
y lo traduce a instrucciones de la máquina física en tiempo real. El intérprete ejecuta el
bytecode de manera rápida pero menos eficiente. Sin embargo, el JVM también utiliza una
técnica llamada compilación en tiempo real (JIT compilation) para mejorar el rendimiento. El
JIT identifica fragmentos de código que se ejecutan con frecuencia y los compila en código
nativo optimizado para la máquina subyacente, lo que acelera su ejecución.
Administración de memoria: El JVM se encarga de la gestión automática de la memoria en
tiempo de ejecución. Utiliza el recolector de basura (garbage collector) para liberar
automáticamente la memoria de los objetos no utilizados, lo que evita problemas de
fragmentación y fugas de memoria.

Ejecución y control de flujo: El JVM ejecuta el bytecode de manera controlada y gestiona el

flujo de ejecución de las instrucciones. Esto incluye el manejo de excepciones, el control de
hilos (threads) y la sincronización para garantizar la concurrencia segura.

El JVM es altamente portátil, lo que significa que las aplicaciones Java se pueden ejecutar en
cualquier plataforma que tenga una implementación compatible del JVM. Esto se debe a que
el JVM proporciona una capa de abstracción sobre el sistema operativo subyacente,
permitiendo que el código Java sea independiente de la plataforma.

En resumen, el JVM es responsable de cargar, verificar, interpretar y ejecutar el bytecode Java,

así como de gestionar la memoria y controlar el flujo de ejecución. Proporciona un entorno de
ejecución seguro y portátil para las aplicaciones Java, lo que contribuye a la popularidad y
versatilidad del lenguaje Java. NetBeans, por su parte, es un entorno de desarrollo integrado
(IDE) que proporciona herramientas y características para desarrollar y depurar aplicaciones
Java utilizando el JVM.
TEMA 4: EJEMPLO DE UN FORMULARIO CON DOS
COMPONENTES VISUALES (NO VISTOS EN CLASES)

package formulario_1;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JTextField;

/**

* @author hbelleza

*/

public class Formulario_1 extends JFrame {

private JButton button;

private JTextField textField;

public Formulario_1() {

initComponents();

private void initComponents() {

button = new JButton();

textField = new JTextField();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

setTitle("formulario");
 button.setText("Mostrar");

button.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

buttonActionPerformed(evt);

});

javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());

getContentPane().setLayout(layout);

layout.setHorizontalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(layout.createSequentialGroup()

.addGap(100, 100, 100)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING,
false)

.addComponent(textField)

.addComponent(button, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))

.addContainerGap(100, Short.MAX_VALUE))

);

layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(layout.createSequentialGroup()

.addGap(50, 50, 50)

.addComponent(textField, javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)

.addGap(30, 30, 30)

.addComponent(button)

.addContainerGap(50, Short.MAX_VALUE))

);
 pack();

private void buttonActionPerformed(java.awt.event.ActionEvent evt) {

String texto = textField.getText();

System.out.println("Texto ingresado: " + texto);

public static void main(String[] args) {

java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {

new Formulario_1().setVisible(true);

});

}
CONCLUSIONES:
- JShell es una herramienta poderosa y flexible que mejora la productividad y la agilidad en el
desarrollo de aplicaciones Java. Su integración con NetBeans ofrece un entorno de desarrollo
completo y funcionalidades adicionales, lo que hace que la experiencia de programar en Java
sea más eficiente y efectiva.

- La integración de JShell en NetBeans mejora significativamente la productividad y la eficiencia

en el desarrollo de aplicaciones Java. Proporciona un entorno interactivo para probar y
experimentar con código Java de forma rápida y eficiente, lo que agiliza el proceso de
desarrollo y mejora la comprensión de los conceptos de programación. NetBeans, como un IDE
completo, se beneficia aún más con esta integración al proporcionar características avanzadas
de autocompletado y sugerencias, así como una estrecha integración con el proyecto actual.

- El JVM es esencial para el funcionamiento de las aplicaciones Java, proporcionando

portabilidad, compilación y ejecución en tiempo real, administración de memoria automática,
seguridad y aislamiento. La integración del JVM con NetBeans permite un desarrollo más
eficiente y efectivo de aplicaciones Java, brindando herramientas de compilación, depuración y
ejecución en un entorno integrado y amigable.
BIBLIOGRAFÍAS
https://javadesdecero.es/fundamentos/como-funciona-maquina-virtual/

https://www.arquitecturajava.com/java-9-jshell-y-su-uso/

https://sites.google.com/a/espe.edu.ec/programacion-ii/home/interfaces-visuales-
componentes-swing?tmpl=%2Fsystem%2Fapp%2Ftemplates%2Fprint%2F