UNIVERSIDAD TECNOLÓGICA OTEIMA

FACULTAD DE CIENCIAS TECNOLÓGICAS

LICENCIATURA EN INFORMÁTICA CON ENFASIS EN REDES Y TELECOMUNICACIONES
PROGRAMACIÓN II
(PROYECTO FINAL)

Indicaciones:
Los estudiantes conformaran grupos de 3 personas, cada grupo debe presentar los programas
desarrollados y también se probaran los programas en tiempo de ejecución para comprobar que
funcionan perfectamente.

En la plataforma deben colocar un documento en Word que debe contener los siguientes puntos:
 Portada
 Enunciado de los Programas
 Código Fuente de los Programas
 Pantallas de Ejecución de los Programas
 Conclusiones y Recomendaciones

Todos los programas que se desarrollarán deben hacer uso de la clase JFrame de Java e
implementar el uso de cajas de textos y botones como componentes en el desarrollo de
aplicaciones con interfaces gráficas de usuarios (GUI).

Parte Investigativa: JFrame es una clase utilizada en Swing (biblioteca gráfica) para generar
ventanas sobre las cuales añadir distintos objetos con los que podrá interactuar
usuario. A diferencia de JPanel, JFrame posee algunas nociones típicas de una ventana como
minimizar, cerrar, maximizar y poder moverla.
Problema N° 1
Elaborar una aplicación en java que permite calcular las raíces de una ecuación cuadrática en su
forma a x 2 +bx +c=0 . Una ecuación cuadrada tiene dos raíces:

−b+ √ b 2−4 ac −b−√ b2−4 ac

r 1= r 2=
2a 2a

import [Link].*;
import [Link].*;
import [Link];
import [Link];

public class CalculadoraRaicesGUI extends JFrame implements ActionListener {

Aquí comienza la declaración de la clase CalculadoraRaicesGUI, que extiende JFrame y también

implementa la interfaz ActionListener. Esto significa que la clase puede manejar eventos de acción,
como hacer clic en un botón.

private JTextField coeficienteATextField;

private JTextField coeficienteBTextField;
private JTextField coeficienteCTextField;
private JButton calcularButton;

Se declaran cuatro campos privados: tres campos de texto para los coeficientes a, b y c,
respectivamente, y un botón para calcular las raíces.

public CalculadoraRaicesGUI() {
setTitle("Calculadora de Raíces");
 setSize(300, 200);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocationRelativeTo(null);
setLayout(new GridLayout(4, 2));

En el constructor de la clase, se establecen las propiedades de la ventana, como el título, el

tamaño, el cierre predeterminado al hacer clic en la 'X' de la ventana, la posición en la pantalla y el
diseño de la interfaz.

JLabel coeficienteBLabel = new JLabel("Coeficiente b:");

add(coeficienteBLabel);
coeficienteBTextField = new JTextField();
add(coeficienteBTextField);

JLabel coeficienteCLabel = new JLabel("Coeficiente c:");

add(coeficienteCLabel);
coeficienteCTextField = new JTextField();
add(coeficienteCTextField);

Se crean etiquetas y campos de texto para que el usuario ingrese los coeficientes a, b y c.

calcularButton = new JButton("Calcular");

[Link](this);
add(calcularButton);

setVisible(true);
}
Se crea un botón con el texto "Calcular" y se agrega un ActionListener (en este caso, el mismo
objeto CalculadoraRaicesGUI), lo que significa que este objeto manejará los eventos generados por
hacer clic en este botón. Finalmente, se establece la ventana como visible.

public void actionPerformed(ActionEvent e) {

if ([Link]() == calcularButton) {

Cuando se produce un evento de acción (por ejemplo, hacer clic en el botón), este método se
llama. Comprueba si el origen del evento es el botón de cálculo.

// Obtener los coeficientes de las cajas de texto

double a = [Link]([Link]());
double b = [Link]([Link]());
double c = [Link]([Link]());
Obtiene los coeficientes ingresados por el usuario desde los campos de texto y los convierte de
texto a números.

// Calcular el discriminante
double discriminante = b * b - 4 * a * c;

Calcula el discriminante utilizando la fórmula cuadrática.

// Calcular las raíces

double raiz1, raiz2;

if (discriminante >= 0) {
raiz1 = (-b + [Link](discriminante)) / (2 * a);
raiz2 = (-b - [Link](discriminante)) / (2 * a);
} else {
// Raíces complejas
double parteReal = -b / (2 * a);
double parteImaginaria = [Link](-discriminante) / (2 * a);
raiz1 = parteReal + parteImaginaria * 1.0;
raiz2 = parteReal - parteImaginaria * 1.0;
}
Calcula las raíces de la ecuación cuadrática, teniendo en cuenta si el discriminante es positivo
(raíces reales) o negativo (raíces complejas).

// Mostrar las raíces

[Link](this, "Las raíces son:\nRaíz 1 = " + raiz1 + "\nRaíz 2 = " +
raiz2);
}
}

Muestra un cuadro de diálogo emergente con las raíces calculadas.

public static void main(String[] args) {

new CalculadoraRaicesGUI ();
}
}
Problema N° 2
Elaborar una aplicación que lea las coordenadas x,y de dos puntos en el plano cartesiano.
Construir un método llamado distancia que reciba como parámetros los valores de los puntos
x1,y1,x2,y2 y calcule la distancia entre los dos puntos. Todos los valores deben ser tratados como
valores del tipo double.

import [Link].*;
import [Link].*;

public class CalculadoraDistancia extends JFrame {

private JTextField x1Field, y1Field, x2Field, y2Field;
private JButton calcularButton;
private JLabel resultadoLabel;

public CalculadoraDistancia() {
super("Calculadora de Distancia");

// Configurar el diseño del JFrame

setLayout(null);

// Crear y posicionar los componentes

JLabel x1Label = new JLabel("x1:");
[Link](20, 20, 20, 20);
add(x1Label);
x1Field = new JTextField();
[Link](50, 20, 100, 20);
add(x1Field);

JLabel y1Label = new JLabel("y1:");

[Link](20, 50, 20, 20);
add(y1Label);
y1Field = new JTextField();
[Link](50, 50, 100, 20);
add(y1Field);

JLabel x2Label = new JLabel("x2:");

[Link](20, 80, 20, 20);
add(x2Label);
x2Field = new JTextField();
[Link](50, 80, 100, 20);
add(x2Field);

JLabel y2Label = new JLabel("y2:");

 [Link](20, 110, 20, 20);
add(y2Label);
y2Field = new JTextField();
[Link](50, 110, 100, 20);
add(y2Field);

calcularButton = new JButton("Calcular Distancia");

[Link](50, 140, 150, 30);
[Link](new ActionListener() {
public void actionPerformed(ActionEvent e) {
calcularDistancia();
}
});
add(calcularButton);

resultadoLabel = new JLabel("");

[Link](50, 180, 200, 20);
add(resultadoLabel);

// Configurar el JFrame
setSize(300, 250);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocationRelativeTo(null);
setVisible(true);
}

private void calcularDistancia() {

try {
double x1 = [Link]([Link]());
double y1 = [Link]([Link]());
double x2 = [Link]([Link]());
double y2 = [Link]([Link]());

double distancia = [Link]([Link](x2 - x1, 2) + [Link](y2 - y1, 2));

[Link]("La distancia entre los puntos es: " + distancia);
} catch (NumberFormatException ex) {
[Link](this, "Por favor ingrese valores numéricos válidos.",
"Error", JOptionPane.ERROR_MESSAGE);
}
}

public static void main(String[] args) {

[Link](new Runnable() {
public void run() {
new CalculadoraDistancia();
}
});
}
}

import [Link].*;
import [Link].*;

Aquí se importan las clases necesarias de las bibliotecas Swing y AWT de Java, que se utilizarán
para construir la interfaz gráfica y manejar eventos.

public class CalculadoraDistancia extends JFrame {

Se define una clase llamada CalculadoraDistancia que extiende JFrame, lo que significa que esta
clase representa una ventana de aplicación.

private JTextField x1Field, y1Field, x2Field, y2Field;

private JButton calcularButton;
private JLabel resultadoLabel;

Se declaran los componentes de la GUI que se usarán en la ventana: cuatro campos de texto
(JTextField) para ingresar las coordenadas de los puntos, un botón (JButton) para calcular la
distancia y una etiqueta (JLabel) para mostrar el resultado.

public CalculadoraDistancia() {
super("Calculadora de Distancia");

Se crea el constructor de la clase. El constructor llama al constructor de la clase base (JFrame) con
el título "Calculadora de Distancia".

setLayout(null);

Se establece el diseño del JFrame en nulo, lo que significa que los componentes se posicionarán
manualmente.

JLabel x1Label = new JLabel("x1:");

[Link](20, 20, 20, 20);

Se crea una etiqueta para mostrar "x1:", se establecen sus dimensiones y se agrega al JFrame.
x1Field = new JTextField();
[Link](50, 20, 100, 20);

Se crea un campo de texto para ingresar la coordenada x del primer punto, se establecen sus
dimensiones

calcularButton = new JButton("Calcular Distancia");

[Link](50, 140, 150, 30);
[Link](new ActionListener() {
public void actionPerformed(ActionEvent e) {
calcularDistancia();
}
});

Se crea un botón para calcular la distancia entre los puntos. Se establecen sus dimensiones y se
agrega un ActionListener para manejar el evento de clic en el botón. Cuando se hace clic en el
botón, se llama al método calcularDistancia().

resultadoLabel = new JLabel("");

[Link](50, 180, 200, 20);

Se crea una etiqueta para mostrar el resultado de la distancia calculada. Se establecen sus
dimensiones y se agrega al JFrame.

setSize(300, 250);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocationRelativeTo(null);
setVisible(true);

Se configuran el tamaño de la ventana, la acción de cierre, la ubicación relativa y la visibilidad de la

ventana. La ventana se establece en visible para que se muestre al usuario.

private void calcularDistancia() {

try {
double x1 = [Link]([Link]());
double y1 = [Link]([Link]());
double x2 = [Link]([Link]());
double y2 = [Link]([Link]());

double distancia = [Link]([Link](x2 - x1, 2) + [Link](y2 - y1, 2));

[Link]("La distancia entre los puntos es: " + distancia);
} catch (NumberFormatException ex) {
 [Link](this, "Por favor ingrese valores numéricos válidos.", "Error",
JOptionPane.ERROR_MESSAGE);
}
}

Este método calcula la distancia entre los puntos ingresados por el usuario. Primero, convierte los
valores de los campos de texto en números (double). Luego, utiliza la fórmula de la distancia entre
dos puntos en un plano cartesiano. Si hay un error al convertir los valores de los campos de texto
en números, muestra un mensaje de error al usuario.

public static void main(String[] args) {

[Link](new Runnable() {
public void run() {
new CalculadoraDistancia();
}
});
}

El método main inicia la aplicación. Utiliza [Link]() para garantizar que la

creación de la interfaz gráfica se realice en el hilo de despacho de eventos de Swing, lo que es
necesario para garantizar la seguridad de la GUI en aplicaciones de Swing. Dentro de este método,
se crea una instancia de la clase CalculadoraDistancia, lo que iniciará la ventana de la calculadora.

PROBLEMA # 3

Elaborar un programa en lenguaje java en el cual el usuario debe introducir un número cualquiera
al azar. Mediante un método Cubo el programa debe calcular el cubo del número ingresado.

import [Link].*;
import [Link].*;
import [Link].*;

Estas líneas importan las clases necesarias para construir una interfaz gráfica de usuario (GUI) en
Java.

public class CalculadoraCubo extends JFrame {

Esta línea define una nueva clase llamada CalculadoraCubo que extiende de JFrame, lo que
significa que nuestra clase representará una ventana de aplicación.
private JTextField entradaNumero;
private JTextField resultadoCubo;
private JButton botonCalcular;

Estas líneas declaran tres variables miembro de la clase: entradaNumero, resultadoCubo y

botonCalcular, que representan un campo de texto para ingresar el número, otro campo de texto
para mostrar el resultado del cálculo y un botón para realizar el cálculo, respectivamente.

public CalculadoraCubo() {

Este es el constructor de la clase CalculadoraCubo. Aquí se inicializan y configuran los

componentes de la interfaz gráfica.

setTitle("Calculadora de Cubo");
setSize(300, 150);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocationRelativeTo(null);

Estas líneas configuran el título de la ventana, su tamaño, el comportamiento al cerrar (en este
caso, la aplicación se cerrará completamente cuando se cierre la ventana) y la posición de la
ventana en el centro de la pantalla.

JLabel etiquetaNumero = new JLabel("Ingrese un número:");

entradaNumero = new JTextField(10);
resultadoCubo = new JTextField(10);
[Link](false);
botonCalcular = new JButton("Calcular Cubo");

Estas líneas crean los componentes de la interfaz: una etiqueta de texto para indicar al usuario que
ingrese un número, un campo de texto para que el usuario ingrese el número, otro campo de
texto para mostrar el resultado del cálculo y un botón para iniciar el cálculo.
JPanel panel = new JPanel();
[Link](new GridLayout(3, 2));
[Link](etiquetaNumero);
[Link](entradaNumero);
[Link](new JLabel("Cubo del número:"));
[Link](resultadoCubo);
[Link](new JLabel());
[Link](botonCalcular);

Aquí se crea un panel para contener los componentes de la interfaz. Se establece un diseño de
cuadrícula de 3 filas y 2 columnas. Luego, se agregan los componentes a este panel en el orden
deseado.

[Link](new ActionListener() {
public void actionPerformed(ActionEvent e) {
calcularCubo();
}
});

Se agrega un ActionListener al botón de calcular. Cuando se hace clic en este botón, se llamará al
método calcularCubo().

add(panel);

Finalmente, se agrega el panel a la ventana.

setVisible(true);
Se hace visible la ventana.

private void calcularCubo() {

Este método se llama cuando se hace clic en el botón de calcular. Realiza el cálculo del cubo del
número ingresado por el usuario.

try {
double numero = [Link]([Link]());
double cubo = numero * numero * numero;
[Link]([Link](cubo));
} catch (NumberFormatException ex) {
[Link](this, "Ingrese un número válido.", "Error",
JOptionPane.ERROR_MESSAGE);
}

Dentro del método calcularCubo(), se intenta convertir el texto ingresado por el usuario en un
número decimal (double). Si tiene éxito, calcula el cubo de ese número y muestra el resultado en
el campo de texto resultadoCubo. Si ocurre un error durante la conversión (por ejemplo, si el
usuario ingresa letras en lugar de números), se muestra un mensaje de error utilizando un cuadro
de diálogo de JOptionPane.

public static void main(String[] args) {

[Link](new Runnable() {
public void run() {
new CalculadoraCubo();
}
});
}

Este es el método main, que se encarga de iniciar la aplicación. Crea una nueva instancia de la
clase CalculadoraCubo y la muestra en el hilo de despacho de eventos de Swing utilizando
[Link](), que garantiza que la interfaz gráfica se construya en el hilo de eventos
de Swing.
PROBLEMA # 4
Elaborar un programa en Java que lea el día y mes en que nació y mediante un método llamado
signo que indique su signo del zodiaco.

import [Link].*;
import [Link].*;
import [Link].*;

Estas líneas importan las clases necesarias de las bibliotecas Swing y AWT, que son utilizadas para
crear interfaces gráficas de usuario (GUI) en Java, así como las clases para manejar eventos.

public class SignoZodiaco extends JFrame implements ActionListener {

Define una clase llamada SignoZodiaco que extiende de JFrame (un marco de ventana) e
implementa la interfaz ActionListener, lo que significa que la clase manejará eventos de acción.

private JTextField txtDia, txtMes;

private JButton btnDeterminarSigno;
private JLabel lblResultado;

Estas líneas declaran variables miembro para un campo de texto (txtDia, txtMes), un botón
(btnDeterminarSigno) y una etiqueta (lblResultado).

public SignoZodiaco() {
// Código del constructor
}
Este es el constructor de la clase SignoZodiaco. Configura la apariencia de la ventana y crea los
componentes de la GUI, como campos de texto, botones y etiquetas.

public String determinarSigno(int dia, int mes) {

// Código para determinar el signo zodiacal
}

Este método determinarSigno toma dos argumentos (el día y el mes de nacimiento) y devuelve el
signo zodiacal correspondiente.

public void actionPerformed(ActionEvent e) {

// Código para manejar eventos de acción
}
Este método maneja los eventos de acción, en este caso, cuando se hace clic en el botón
btnDeterminarSigno.
public static void main(String[] args) {
new SignoZodiaco();
}
Este es el método main, que crea una instancia de la clase SignoZodiaco, lo que inicia la aplicación.
En resumen, este código crea una aplicación de escritorio simple que permite al usuario ingresar
su fecha de nacimiento y luego determina su signo zodiacal, mostrando el resultado en una
ventana de interfaz gráfica.

PROBLEMA # 5
Elaborar un programa en Java que permita crear un convertidor de al menos 5 medidas de
longitud.
Ejemplo:

import [Link].*;
import [Link].*;

public class LongitudConverter extends JFrame implements ActionListener {

Aquí se importan las clases JFrame y ActionListener del paquete [Link] y [Link]
respectivamente. Se define una clase llamada LongitudConverter que extiende JFrame e
implementa ActionListener, lo que significa que puede manejar eventos de acción.

private JTextField inputField;

private JButton convertButton;
 private JComboBox<String> fromComboBox;
private JComboBox<String> toComboBox;
private JLabel resultLabel;

private String[] medidas = {"Metros", "Centímetros", "Pulgadas", "Pies", "Yardas"};

Aquí se definen varios componentes de interfaz de usuario, incluyendo un campo de texto
(inputField), un botón de conversión (convertButton), dos listas desplegables (fromComboBox y
toComboBox) y una etiqueta de resultado (resultLabel). También se define un array de Strings
llamado medidas que contiene las opciones de unidades de longitud.

public LongitudConverter() {
setTitle("Convertidor de Longitud");
setSize(300, 200);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLocationRelativeTo(null);
setLayout(null);

El constructor de la clase LongitudConverter configura la apariencia de la ventana, estableciendo

el título, tamaño, operación al cerrar, ubicación y disposición nula (lo que significa que los
componentes se colocarán manualmente con coordenadas absolutas).

JLabel inputLabel = new JLabel("Valor:");

[Link](20, 20, 50, 20);
add(inputLabel);

inputField = new JTextField();

[Link](80, 20, 150, 20);
add(inputField);

Se crea una etiqueta para el campo de entrada y se establecen sus dimensiones y posición en la
ventana. Luego se crea el campo de entrada (inputField) y se establecen sus dimensiones y
posición.

fromComboBox = new JComboBox<>(medidas);

[Link](20, 50, 100, 20);
add(fromComboBox);

JLabel toLabel = new JLabel("a");

[Link](130, 50, 20, 20);
add(toLabel);
 toComboBox = new JComboBox<>(medidas);
[Link](150, 50, 100, 20);
add(toComboBox);

Se crea una lista desplegable (fromComboBox) para seleccionar la unidad de longitud de origen y
se establecen sus dimensiones y posición. Luego se crea una etiqueta (toLabel) para mostrar "a" y
se establecen sus dimensiones y posición. Después se crea otra lista desplegable (toComboBox)
para seleccionar la unidad de longitud de destino y se establecen sus dimensiones y posición.

convertButton = new JButton("Convertir");

[Link](100, 80, 100, 30);
[Link](this);
add(convertButton);

Se crea un botón (convertButton) con el texto "Convertir" y se establecen sus dimensiones y

posición. Se agrega un ActionListener al botón para manejar eventos de clic en el botón.

resultLabel = new JLabel("");

[Link](20, 120, 250, 20);
add(resultLabel);

Se crea una etiqueta (resultLabel) para mostrar el resultado de la conversión y se establecen sus
dimensiones y posición.

public void actionPerformed(ActionEvent e) {

if ([Link]() == convertButton) {
double valor = [Link]([Link]());
double resultado = convertir([Link]((String) [Link]()),
[Link]((String) [Link]()), valor);
[Link]("Resultado: " + resultado);
}
}

El método actionPerformed se llama cuando se realiza una acción, en este caso, cuando se hace
clic en el botón de conversión. Se verifica si el evento proviene del botón de conversión. Luego,
obtiene el valor ingresado en el campo de entrada como un double, convierte las unidades de
longitud de origen y destino seleccionadas en el fromComboBox y toComboBox respectivamente,
y llama al método convertir. Finalmente, muestra el resultado en la etiqueta de resultado.
 private double convertir(Longitud from, Longitud to, double valor) {
switch (from) {
case Metros:
return [Link](valor);
case Centimetros:
return [Link](valor);
case Pulgadas:
return [Link](valor);
case Pies:
return [Link](valor);
case Yardas:
return [Link](valor);
default:
return 0;
}
}

El método convertir realiza la conversión de longitud según las unidades de longitud de origen y
destino y el valor proporcionado. Utiliza un switch para determinar la unidad de longitud de origen
y llama al método de conversión correspondiente en la unidad de longitud de destino (to).

public static void main(String[] args) {

LongitudConverter converter = new LongitudConverter();
[Link](true);
}

El método main crea una instancia de LongitudConverter, establece su visibilidad en true, lo que
hace que la ventana sea visible y el programa comience a ejecutarse.