Un programa permite resolver muchos tipos de problemas, desde tareas relativamente sencillas a solucionar grandes problemas organizacionales y necesidades de las personas, sin embargo, debemos de empezar por lo básico creando programas que permitan resolver problemas que involucren instrucciones secuenciales.
Así, en el tema de hoy crearemos algoritmos en pseudocódigo y en Java que permitan resolver problemas que involucren instrucciones secuenciales.
Estos posts te servirán tanto si estás empezando de cero en el mundo de la programación, si eres estudiante de primer año y necesitas reforzar algunos temas, o si eres un curioso que le entró la duda y las ganas de aprender a programar. Sea el motivo que fuese por lo que estás aquí, te invito a seguir esta serie de publicaciones que estaré realizando, en donde aprenderás con los temas que te vaya enseñando lo básico de la programación para que puedas realizar tú mismo tus propios programas.
¡Bienvenido!
¿Qué e suna estructura de secuencia?
Una estructura de secuencia como su mismo nombre lo indica, es una secuencia ordenada y finita de pasos que deben de seguir ciertas instrucciones y al mismo tiempo dicha secuencia de instrucciones debe ser única como podemos apreciar en la siguiente imagen.
El ella se puede ver claramente 3 instrucciones que van de arriba hacia abajo y que se van a efectuar una a continuación de la otra siguiendo una secuencia única. Es decir, primero se ejecutará la acción "accion1", después la acción "accion2" y por último la acción "accion3".
 |
| Diagrama de flujo de la estructura de secuencia |
A continuación, veremos algunos ejemplos para aplicar este concepto.
Vamos a resolver algunos problemas tanto en algoritmo empleando pseudocódigo y luego lo pasaremos a Java en donde crearemos una pequeña interfaz gráfica de usuario utilizando applets. Lo podríamos hacer sin applets y mostrar el resultado por consola, sin embargo, he decido utilizar applets para que podamos tener una interacción más amigable con el programa, ya que este es un curso de introducción a la algoritmia y a la programación en Java para los que recién están comenzando. Si tienes un poco más de experiencia, puedes imprimir el resultado por la consola de tu IDE favorita.
¿Qué herramientas necesito para programar en Java?
Básicamente necesitamos el JDK que es un programa que contiene las librerías de programación y el compilar de Java; y una IDE que es el entorno de desarrollo integrado para editar, compilar y ejecutar nuestros programas escritos en java. Este tema lo puedes ver a detalle dando clic al siguiente enlace.
Herramientas para desarrollar un programa en Java
Problemas
Problema 1
El cálculo del pago mensual de un empleado de una empresa se efectúa de la siguiente manera: el sueldo básico se calcula en base al número total de horas trabajadas basado en una tarifa horaria; al sueldo básico, se le aplica una bonificación del 20% obteniéndose el sueldo bruto; al sueldo bruto, se le aplica un descuento del 10% obteniéndose el sueldo neto. Escriba un programa que calcule e imprima el sueldo básico, el sueldo bruto y el sueldo neto de un trabajador.
Algoritmo
Inicio // Declaración de variables real horasTrab, tarifaHor real sueldoBas, montoBoni, sueldoBru, montoDesc, sueldoNet // Entrada de datos Leer horasTrab, tarifaHor // Proceso de cálculo sueldoBas = horasTrab*tarifaHor montoBoni = 0.20*sueldoBas sueldoBru = sueldoBas+montoBoni montoDesc = 0.10*sueldoBru sueldoNet = sueldoBru-montoDesc // Salida de resultados Imprimir sueldoBas, montoBoni, sueldoBru, montoDesc, sueldoNet Fin
Programa
Código Fuente
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
public class Programa1 extends JApplet implements ActionListener{
// Declaración de variables
JButton btnProcesar;
JTextArea txtS;
JLabel lblHoras;
JLabel lblTarifa;
JTextField txtHoras;
JTextField txtTarifa;
JScrollPane scpScroll;
// Crea la interfaz gráfica de usuario GUI
public void init() {
getContentPane().setLayout(null);
lblHoras = new JLabel("Horas");
lblHoras.setBounds(15, 15, 42, 23);
getContentPane().add(lblHoras);
lblTarifa = new JLabel("Tarifa");
lblTarifa.setBounds(15, 39, 42, 23);
getContentPane().add(lblTarifa);
txtHoras = new JTextField();
txtHoras.setBounds(61, 15, 107, 23);
getContentPane().add(txtHoras);
txtTarifa = new JTextField();
txtTarifa.setBounds(61, 39, 107, 23);
getContentPane().add(txtTarifa);
btnProcesar = new JButton("Procesar");
btnProcesar.setBounds(305, 15, 101, 23);
btnProcesar.addActionListener(this);
getContentPane().add(btnProcesar);
txtS = new JTextArea();
txtS.setFont(new Font("monospaced", 0, 12));
scpScroll = new JScrollPane(txtS);
scpScroll.setBounds(15, 75, 394, 130);
getContentPane().add(scpScroll);
}
// Procesa eventos de tipo ActionEvent
public void actionPerformed( ActionEvent e ){
// Declaración de variables
double horasTrab, tarifaHor;
double sueldoBas, montoBoni, sueldoBru, montoDesc, sueldoNet;
// Entrada de datos
horasTrab = Double.parseDouble(txtHoras.getText());
tarifaHor = Double.parseDouble(txtTarifa.getText());
// Cálculo de montos
sueldoBas = horasTrab*tarifaHor;
montoBoni = 0.20*sueldoBas;
sueldoBru = sueldoBas+montoBoni;
montoDesc = 0.10*sueldoBru;
sueldoNet = sueldoBru-montoDesc;
// Salida de resultados
txtS.setText("Sueldo básico : S/. " + sueldoBas + "\n");
txtS.append ("Bonificación : S/. " + montoBoni + "\n");
txtS.append ("Sueldo bruto : S/. " + sueldoBru + "\n");
txtS.append ("Descuentos : S/. " + montoDesc + "\n");
txtS.append ("Sueldo neto : S/. " + sueldoNet);
}
}
Problema 2
Diseñe un programa que permita convertir una cantidad dada en metros a sus equivalentes en centímetros, pulgadas, pies y yardas. Considere la siguiente información:
1 metro = 100 centímetros
1 pie = 12 pulgadas
1 yarda = 3 pies
1 pulgada = 2.54 centímetros
Algoritmo
Inicio // Declaración de variables real xmetros, xpies, xpulgadas, xyardas, xcentimetros // Entrada de datos Leer xmetros // Proceso de conversión xcentimetros = xmetros*100 xpulgadas = xcentimetros/2.54 xpies = xpulgadas/12 xyardas = xpies/3 // Salida de resultados Imprimir xcentimetros, xpulgadas, xpies, xyardas Fin
Programa
Código Fuente
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
public class Problema02 extends JApplet implements ActionListener {
/**
*
*/
private static final long serialVersionUID = 5564728598678681863L;
// Declaración de variables
JLabel lblMetros;
JTextField txtMetros;
JButton btnProcesar;
JTextArea txtArea;
JScrollPane scpScroll;
// --------------------------------------------------------------------------
// Crea la interfaz gráfica de usuario
public void init() {
// Le decimos que nosotros configuramos las dimensiones de los componentes
getContentPane().setLayout(null);
// Inicialización de componentes para la creación de la GUI
lblMetros = new JLabel("Metros: ");
lblMetros.setBounds(15, 15, 100, 25);
getContentPane().add(lblMetros);
txtMetros = new JTextField();
txtMetros.setBounds(100, 15, 100, 25);
getContentPane().add(txtMetros);
btnProcesar = new JButton("Procesar");
btnProcesar.setBounds(320, 15, 100, 25);
btnProcesar.addActionListener(this);// Asociamos un escuchador al boton para que cada vez que se llame al control
// con un click se ejecute una acción y se invoque al método actionPerformed
getContentPane().add(btnProcesar);
txtArea = new JTextArea();
txtArea.setFont(new Font("Dialog", Font.PLAIN, 14));
scpScroll = new JScrollPane(txtArea);
scpScroll.setBounds(15, 50, 405, 150);
getContentPane().add(scpScroll);
}
// --------------------------------------------------------------------------
// Procesa eventos de tipo ActionEvent
public void actionPerformed(ActionEvent e) {
// Al dar click al control que tiene asociado una acción de evento
// se ejecutará lo especificado acontinuación
// Declaración de Variables
double metros, centimetros, pulgadas, pies, yardas;
// Entrada de Datos
metros = Double.parseDouble(txtMetros.getText());
// Cálculo de la operación
centimetros = metros * 100;
pulgadas = centimetros / 2.54;
pies = pulgadas / 12;
yardas = pies / 3;
// Imprimir Resultados
txtArea.setText("Resultado" + "\n");
txtArea.append("En centimentros: " + centimetros + " cm" + "\n");
txtArea.append("En pulgadas: " + pulgadas + " in" + "\n");
txtArea.append("En pies: " + pies + " ft" + "\n");
txtArea.append("En yardas: " + yardas + " yd" + "\n");
}
}
Problema 3
Escriba un programa que calcule el área total y el volumen de un cilindro. Considere las siguientes fórmulas: A = 2πr(r+h) y V = πr2h; siendo A el área, V el volumen, r el radio y h la altura.
Algoritmo
Inicio // Declaración de variables real r, h, area, volumen // Entrada de datos Leer r, h // Proceso de cálculo area = 2*3.1416*r*(r+h) volumen = 2*3.1416*r*r*h // Salida de resultados Imprimir area, volumen Fin
Programa
Código Fuente
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
public class Problema03 extends JApplet implements ActionListener {
/**
*
*/
private static final long serialVersionUID = 766293635189425596L;
// Declaración de variables
JLabel lblRadio, lblAltura;
JTextField txtRadio, txtAltura;
JButton btnProcesar;
JTextArea txtArea;
JScrollPane scpScroll;
// --------------------------------------------------------------------------
// Crea la interfaz gráfica de usuario
public void init() {
// Nosotros creamos la interfaz grafica de usuario
getContentPane().setLayout(null);
// Inicialización de componentes
lblRadio = new JLabel("Radio: ");
lblRadio.setBounds(15, 15, 100, 25);// setBounds(pos x, pos y, ancho, alto)
getContentPane().add(lblRadio); // Añadimos el componente al panel de contenido
lblAltura = new JLabel("Altura");
lblAltura.setBounds(15, 45, 100, 25);
getContentPane().add(lblAltura);
txtRadio = new JTextField();
txtRadio.setBounds(100, 15, 100, 25);
getContentPane().add(txtRadio);
txtAltura = new JTextField();
txtAltura.setBounds(100, 45, 100, 25);
getContentPane().add(txtAltura);
btnProcesar = new JButton("Procesar");
btnProcesar.setBounds(320, 15, 100, 25);
btnProcesar.addActionListener(this); // Al seleccionar el control ejecutaremos una acción (ActionEvent) y
// se invocara al método actionPerformed (ActionEvent e)
getContentPane().add(btnProcesar);
txtArea = new JTextArea();
txtArea.setFont(new Font("Monospaced", Font.BOLD | Font.ITALIC, 14));
scpScroll = new JScrollPane(txtArea);
scpScroll.setBounds(15, 80, 405, 135);
getContentPane().add(scpScroll);
}
// --------------------------------------------------------------------------
// Procesa eventos de tipo ActionEvent
public void actionPerformed(ActionEvent e) {
// Al invocar este método se ejecutará lo que tengamos defino aquí
// Paso (1) - Declaración de variables
double radio, altura, area, volumen;
// Paso (2) - Entrada de datos
radio = Double.parseDouble(txtRadio.getText());
altura = Double.parseDouble(txtAltura.getText());
// Paso (3) - Cálcular área y volumen del cilindro
area = 2 * Math.PI * radio * (radio + altura);
volumen = 2 * Math.PI * radio * radio * altura;
// Paso (4) - Salida de Resultados
// Limpiamos el area de texto cada vez que seleccionemos el control Procesar
txtArea.setText("");
// Anexamos los resultados al area de texto
txtArea.append("Resultado" + "\n");
txtArea.append("Area del Cilindro: " + area + "\n");
txtArea.append("Volumen del Cilindro: " + volumen);
}
}
Problema 4
Débora, Raquel y Séfora aportan cantidades de dinero para formar un capital. Diseñe un programa que determine el capital formado y el porcentaje de dicho capital que aporta cada uno.
Algoritmo
Inicio // Declaración de variables real dineDeb, dineRaq, dineSef, capital, porcDeb, porcRaq, porcSef // Entrada de datos Leer dineDeb, dineRaq, dineSef // Halla el capital formado capital = dineDeb + dineRaq + dineSef // Determine los porcentajes de cada capital respecto del total porcDeb = dineDeb*100/capital porcRaq = dineRaq*100/capital porcSef = dineSef*100/capital // Salida de resultados Imprimir capital, porcDeb, porRaq, porcSef Fin
Programa
Código Fuente
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
public class Problema04 extends JApplet implements ActionListener {
/**
*
*/
private static final long serialVersionUID = 7787644423584641837L;
// Declaración de variables
JLabel lblDineroRaquel, lblDineroDebora, lblDineroSefora;
JTextField txtDineroRaquel, txtDineroDebora, txtDineroSefora;
JButton btnProcesar;
JTextArea txtArea;
JScrollPane scpScroll;
//--------------------------------------------------------------------------
// Crea la interfaz gráfica de usuario
public void init() {
// Indicamos que queremos un posicionamiento absoluto
// Esto significa que nosostros trabajaremos todo el código
// para la creación de nuestra GUI
getContentPane().setLayout(null);
// Inicialización de componentes
lblDineroRaquel = new JLabel("Dinero de Raquel: ");
lblDineroRaquel.setBounds(15,15,110,25);
getContentPane().add(lblDineroRaquel);
lblDineroDebora = new JLabel("Dinero de Débora");
lblDineroDebora.setBounds(15,45,100,25);
getContentPane().add(lblDineroDebora);
lblDineroSefora = new JLabel("Dinero de Séfora");
lblDineroSefora.setBounds(15,75,100,25);
getContentPane().add(lblDineroSefora);
txtDineroRaquel = new JTextField();
txtDineroRaquel.setBounds(130,15,100,25);
getContentPane().add(txtDineroRaquel);
txtDineroDebora = new JTextField();
txtDineroDebora.setBounds(130,45,100,25);
getContentPane().add(txtDineroDebora);
txtDineroSefora = new JTextField();
txtDineroSefora.setBounds(130,75,100,25);
getContentPane().add(txtDineroSefora);
btnProcesar = new JButton("Procesar");
btnProcesar.setBounds(320,15,100,25);
// Importante: No olvidar asociar el control el evento de acción
// para invocar al método actionPerformed
btnProcesar.addActionListener(this);
getContentPane().add(btnProcesar);
txtArea = new JTextArea();
txtArea.setFont(new Font("DialogInput", Font.BOLD + Font.ITALIC, 10));
scpScroll = new JScrollPane(txtArea);
scpScroll.setBounds(15,105,405,110);
getContentPane().add(scpScroll);
}
//--------------------------------------------------------------------------
// Procesa eventos de tipo ActionEvent
public void actionPerformed( ActionEvent e ){
// Al invocar a este método se ejecutará toda la acción realizada a continuación
// Paso (1) - Declaración de Variabled
double dRaquel, dDebora, dSefora;
double total, pRaquel, pDebora, pSefora;
// Paso (2) - Entrada de datos
dRaquel = Double.parseDouble(txtDineroRaquel.getText());
dDebora = Double.parseDouble(txtDineroDebora.getText());
dSefora = Double.parseDouble(txtDineroSefora.getText());
// Paso (3) - Proceso de cálculo
total = dRaquel + dDebora + dSefora;
pRaquel = (dRaquel * 100) / total;
pDebora = (dDebora * 100) / total;
pSefora = (dSefora * 100) / total;
// Paso (4) - Salida de Resultados
txtArea.setText("Resultado" + "\n");
txtArea.append("Capital: " + total + "\n");
txtArea.append("Porcentaje de Raquel: " + pRaquel + "\n");
txtArea.append("Porcentaje de Débora: " + pDebora + "\n");
txtArea.append("Porcentaje de Séfora:" + pSefora);
}
}
Problema 5
Diseñe un algoritmo que lea un número entero de cinco cifras y determine la cifra central del número. Así, si el número ingresado fuera 45781, la cifra central a mostrar es 7.
Algoritmo
Inicio // Declaración de variables entero numero, centro // Entrada de datos Leer numero // Determina la cifra central centro = (numero%1000)/100 // Salida de resultados Imprimir centro Fin
Programa
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
public class Problema05 extends JApplet implements ActionListener {
/**
*
*/
private static final long serialVersionUID = -6780664428476123189L;
// Declaración de variables
JLabel lblNumero;
JTextField txtNumero;
JButton btnProcesar;
JTextArea txtArea;
JScrollPane scpScroll;
//--------------------------------------------------------------------------
// Crea la interfaz gráfica de usuario
public void init() {
// Definiremos un posicionamineto absoluto
// En otras palabras trabajeremos todo el código y difiniremos
// la psoicón y el tamaño de nuestro elemento gráficos
getContentPane().setLayout(null);
// Incialización de componentes
lblNumero = new JLabel("Número: ");
lblNumero.setBounds(15,15,100,25);
getContentPane().add(lblNumero);
txtNumero = new JTextField();
txtNumero.setBounds(100,15,100,25);
getContentPane().add(txtNumero);
btnProcesar = new JButton("Procesar");
btnProcesar.setBounds(320,15,100,25);
// Para que este control pueda ejecutar una acción tenemos que
// asociarle un listener o detector de eventos, puesto que implementamos
// la interfaz ActionListener
btnProcesar.addActionListener(this);
getContentPane().add(btnProcesar);
txtArea = new JTextArea();
txtArea.setFont(new Font("Serif", Font.PLAIN, 12));
scpScroll = new JScrollPane(txtArea);
scpScroll.setBounds(15,60,405,150);
getContentPane().add(scpScroll);
}
//--------------------------------------------------------------------------
// Procesa eventos de tipo ActionEvent
public void actionPerformed( ActionEvent e ){
// Una vez hecho click en el control Procesar ejecutamos una acción
// y se invoca al método actionPerformed que contiene la acción realizada
// Paso (1) - Declaración de Variabled
int numero, ccentral;
// Paso (2) - Entrada de datos
numero = Integer.parseInt(txtNumero.getText());
// Paso (3) Cálculo de la cifra central del númerp
ccentral = numero % 1000 / 100;
// Paos (4) - Salida de Resultados
txtArea.setText("Resultado" + "\n");
txtArea.append("La cifra del medio es: " + ccentral);
}
}
Problema 6
Diseñe un algoritmo para repartir una cantidad de dinero a tres personas en forma proporcional a sus edades. El monto que le corresponde a cada persona se calcula con la siguiente fórmula: monto de la persona = edad de la persona x monto a repatir / suma total de dades
Algoritmo
Inicio // Declaración de variables real montoP1, montoP2, montoP3, montoRepartir entero edadP1, edadP2, edadP3, sumaEdades // Entrada de datos Leer montoRepartir, edadP1, edadP2, edadP3 // Calcula la suma total de edades sumaEdades = edadP1 + edadP2 + edadP3 // Calcula la cantidad de dinero de cada persona montoP1 = (edadP1 * montoRepartir) / sumaEdades montoP2 = (edadP2 * montoRepartir) / sumaEdades montoP3 = (edadP3 * montoRepartir) / sumaEdades // Salida de resultados Imprimir montoP1, montoP2, montoP3 Fin
Programa
Código Fuente
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
public class Problema06 extends JApplet implements ActionListener {
/**
*
*/
private static final long serialVersionUID = -144922557423776548L;
// Declaración de variables
JLabel lblMonto, lblEdad1, lblEdad2, lblEdad3;
JTextField txtMonto, txtEdad1, txtEdad2, txtEdad3;
JButton btnProcesar;
JTextArea txtArea;
JScrollPane scpScroll;
//--------------------------------------------------------------------------
// Crea la interfaz gráfica de usuario
public void init() {
// Definiremos un posicionamineto absoluto, donde trabajaremos
// todo el código, es decir definiremos la posición y el tamaño
// de los elementos gráficos.
getContentPane().setLayout(null);
// Incialización de componentes sgráficos
lblMonto = new JLabel("Monto: ");
lblMonto.setBounds(15,15,100,25);
getContentPane();add(lblMonto);
lblEdad1 = new JLabel("Edad 1: ");
lblEdad1.setBounds(15,45,100,25);
getContentPane().add(lblEdad1);
lblEdad2 = new JLabel("Edad 2: ");
lblEdad2.setBounds(15,75,100,25);
getContentPane().add(lblEdad2);
lblEdad3 = new JLabel("Edad 3: ");
lblEdad3.setBounds(15,105,100,25);
getContentPane().add(lblEdad3);
txtMonto = new JTextField();
txtMonto.setBounds(100,15,100,25);
getContentPane().add(txtMonto);
txtEdad1 = new JTextField();
txtEdad1.setBounds(100,45,100,25);
getContentPane().add(txtEdad1);
txtEdad2 = new JTextField();
txtEdad2.setBounds(100,75,100,25);
getContentPane().add(txtEdad2);
txtEdad3 = new JTextField();
txtEdad3.setBounds(100,105,100,25);
getContentPane().add(txtEdad3);
btnProcesar = new JButton("Procesar");
btnProcesar.setBounds(320,15,100,25);
// Para que este control pueda ejjecutar una acción
// tenemos que asociarle un escuchador o detector de eventos
// puesto que implementamos la interfaz ActionListener
btnProcesar.addActionListener(this);
getContentPane().add(btnProcesar);
txtArea = new JTextArea();
txtArea.setFont(new Font("Sanserif", Font.ITALIC, 10));
scpScroll = new JScrollPane(txtArea);
scpScroll.setBounds(15,140,405,150);
getContentPane().add(scpScroll);
}
//--------------------------------------------------------------------------
// Procesa eventos de tipo ActionEvent
public void actionPerformed( ActionEvent e ){
// Si hice click en el control Procesar
/**/
// Paso (1) - Declaración de Variables
double monto, mp1, mp2, mp3;
int e1, e2, e3, sumaEdad;
// Paso (2) - Entrada de datos
monto = Double.parseDouble(txtMonto.getText());
e1 = Integer.parseInt(txtEdad1.getText());
e2 = Integer.parseInt(txtEdad2.getText());
e3 = Integer.parseInt(txtEdad3.getText());
// Paso (3) - Cáclcular monto por persona
sumaEdad = e1 + e2 + e3;
mp1 = e1 * monto / sumaEdad;
mp2 = e2 * monto / sumaEdad;
mp3 = e3 * monto / sumaEdad;
// Paso (4) - Salida de resultados
txtArea.setText("Resultado" + "\n");
txtArea.append("Suma de edades: " + sumaEdad + "\n");
txtArea.append("Monto persona 1: " + mp1 + "\n");
txtArea.append("Monto persona 2: " + mp2 + "\n");
txtArea.append("Monto persona 3: " + mp3 + "\n");
txtArea.append("Moto Total: " + (mp1 + mp2 + mp3));
}
}
Problema 7
Una tienda ha puesto en oferta la venta de un producto ofreciendo un 11% de descuento sobre el importe de la compra. Diseñe un algoritmo que determine el importe de la compra, el importe del descuento y el importe a pagar por la compra de cierta cantidad de unidades del producto.
Algoritmo
Inicio // Declaración de variables real precio, importecom, importedes, importepag entero unidades // Entrada de datos Leer precio, unidades // Cálculo de importes importecom = unidades*precio importedes = 0.11*importecom importepag = importecom – importedes // Salida de resultados Imprimir importecom, importedes, importepag Fin
Programa
Código Fuente
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
public class Problema07 extends JApplet implements ActionListener {
/**
*
*/
private static final long serialVersionUID = 4922589495625150441L;
// Declaración de variables
JLabel lblPrecio, lblCantidad;
JTextField txtPrecio, txtCantidad;
JButton btnProcesar;
JTextArea txtArea;
JScrollPane scpScroll;
//--------------------------------------------------------------------------
// Crea la interfaz gráfica de usuario
public void init() {
// Aquí definiremos un posicionamiento absoluto, es decir que
// nosotros mismos definiremos la posición y el tamaño de los
// elementos graficos declarados anteriormente.
getContentPane().setLayout(null);
// A continuación inicializaremos nuestros componentes
lblPrecio = new JLabel("Precio: ");
lblPrecio.setBounds(15,15,100,25); // setBounds(posición x,y | tamaño ancho y alto)
getContentPane().add(lblPrecio); // Añadimo el elemento al panel de contenido.
lblCantidad = new JLabel("Cantidad");
lblCantidad.setBounds(15,45,100,25);
getContentPane().add(lblCantidad);
txtPrecio = new JTextField();
txtPrecio.setBounds(100,15,100,25);
getContentPane().add(txtPrecio);
txtCantidad = new JTextField();
txtCantidad.setBounds(100,45,100,25);
getContentPane().add(txtCantidad);
btnProcesar = new JButton("Procesar");
btnProcesar.setBounds(320,15,100,25);
// Para que este control puedad ejecutar una acción
// tenemos que asociarle un escuchador o detector de eventos
// puesto que implementamos la inetrfaz ActionListener
btnProcesar.addActionListener(this); // Al dar click se invoca al método actionPerformed
getContentPane().add(btnProcesar);
txtArea = new JTextArea();
txtArea.setFont(new Font("monospaced",0,14));
scpScroll = new JScrollPane(txtArea);
scpScroll.setBounds(15,80,405,130);
getContentPane().add(scpScroll);
}
//--------------------------------------------------------------------------
// Procesa eventos de tipo ActionEvent
public void actionPerformed( ActionEvent e ){
// Si hiciste click al control Procesar
// Ejecutamos la acción siguiente
// Un algoritmo que puede ser ejecutado por un computador se le denomina
// algoritmos computacionales. Todo algoritmo computacional puede
// dividirse en 4 etapas.
// Paso (1) - Declaración de variabled
// Aquí decladaremos las variables a utilizar en el programa
int cantidad;
double precio,icompra,idescuento,ipagar;
// Paso (2) - Entrada de datos
// Aquí debemos de obtener los valores de la caja de texto ingresados y
// almacenarlo en las variables de entrada
cantidad = Integer.parseInt(txtCantidad.getText());
precio = Double.parseDouble(txtPrecio.getText());
// Paso (3) - Proceso de cálculo
// Realizar los cálculos del programa
icompra = cantidad * precio;
idescuento = 0.11 * icompra;
ipagar = icompra - idescuento;
// Paso (4) - Salida de resultados
// Aquí imprimiremos los resultados en la pantalla
// Pero antes limpiamos la pantalla, esto para no repetir el resultado
// cada vez que presionemos el control Procesar
txtArea.setText("");
// Ahora si anezamos los resultados
txtArea.append("Resultado" + "\n");
txtArea.append("Importe de compra: " + icompra + "\n");
txtArea.append("Importe de descuento: " + idescuento + "\n");
txtArea.append("Importe a pagar: " + ipagar) ;
// Recordar que "\n" es un salto de linea
}
}
Resumen
Las instrucciones secuenciales se efectúan una a continuación de la otra y siguiendo un orden único que va de arriba hacia abajo, por lo tanto, si una variable requiere del resultado de otras variables, estás deben ser declaradas, ingresadas y calculadas con anterioridad.
Descargar Ejercicios resueltos
Descargar archivo
Puedes completar lo aprendido asistiendo el material en video.
Clic aquí
¡Acabas de ver el tema Estructuras de Secuencia del curso de Introducción a la Algoritmia y a la programación en Java! ¡Fácil verdad!
Ir al índice
Asimismo, si deseas saber más acerca de estos temas, recuerda que puedes comprar la guía completa con todos los temas, ejercicios, evaluaciones resueltas, proyectos y más; para ello, tienes que ingresar al siguiente enlace. Y si eres seguidor de la comunidad Aprendec puedes acceder a un descuento del -%32.
Asimismo, si deseas saber más acerca de estos temas, recuerda que puedes comprar la guía completa con todos los temas, ejercicios, evaluaciones resueltas, proyectos y más; para ello, tienes que ingresar al siguiente enlace. Y si eres seguidor de la comunidad Aprendec puedes acceder a un descuento del -%32.
 |
| ¡Quiero esto! |
No hay comentarios, ¡cuéntame algo!
Me gustaría saber tu opinión. ¡Saludos!