PROGRAMAS JAVA

En esta sección se puedes descargar subprogramas básicos de Java, también llamados

Applets, que son programas diseñados para transportarse a través de Internet y
ejecutarse en navegadores Web (como el Internet Explorer, Opera, FireFox, etc.). Hay
muchos otros applets en la sección de demos del J2DSK(j2sdk1.4.1/demo/applets), en
los cuales te puedes basar.

Nuestro primer subprograma en Java

?
01// Nuestro primer subprograma en Java.
02// Paquetes de Java
03import java.awt.Graphics; // importar la clase Graphics
import javax.swing.<SPAN class="goog_qs-tidbit goog_qs-tidbit-
040">JApplet; // importar la clase JApplet
05public class SubprogramaBienvenido extends</SPAN> JApplet
06{
07 // dibujar texto en el fondo del subprograma
public void paint( Graphics g )
08 {
09 // llamar a la versión del método paint de la superclase
10 super.paint( g );
11 // dibujar un String en la coordenada x 25 y la coordenada y
25
12 g.drawString( "¡Bienvenido a la programación en Java!", 25,
1325 );
14 }// fin del método paint
15}// fin de la clase SubprogramaBienvenido

Mostrar varias cadenas en un subprograma

?
01
02// Mostrar varias cadenas en un subprograma.
03// paquetes de Java
import java.awt.Graphics; // importar la clase Graphics
04import javax.swing.JApplet; // importar la clase JApplet
05public class SubprogramaBienvenido2 extends JApplet
06{
07 // dibujar texto en el fondo del subprograma
public void paint( Graphics g )
08 {
09 // llamar a la versión del método paint de la superclase
10 super.paint( g );
11 // dibujar dos valores String en diferentes ubicaciones
g.drawString( "¡Bienvenido a", 25, 25 );
12 g.drawString( "la programación en Java!", 25, 40 );
13 }// fin del método paint
14
15} // fin de la clase SubprogramaBienvenido2
16
17

Mostrar texto y dibujar líneas

?
01// Mostrar texto y líneas.
02// Paquetes de Java
03import java.awt.Graphics; // importar la clase Graphics
04 import javax.swing.JApplet; // importar la clase JApplet
public class LineasBienvenido extends JApplet
05{
06 // dibujar líneas y una cadena en el fondo del subprograma
07 public void paint( Graphics g )
08 {
09 // llamar a la versión del método paint de la superclase
super.paint( g );
10 // dibujar una línea horizontal, desde (15, 10) hasta (250,
1110)
12 g.drawLine( 15, 10, 250, 10 );
13 // dibujar una línea horizontal desde (15, 30) hasta (250,
30)
14 g.drawLine( 15, 30, 250, 30 );
15 // dibujar String entre líneas, en la ubicación (25, 25)
16 g.drawString( "Bienvenido a la programacion en Java!", 25,
1725 );
18
19 } // fin del método paint
20
21} // fin de la clase LineasBienvenido

Suma dos números de punto flotante

01// Suma dos números de punto flotante.

// paquetes de Java
02import java.awt.Graphics; // importar la clase Graphics
03import javax.swing.*; // importar el paquete javax.swing
04public class SubprogramaSuma extends JApplet
05{
double suma; // la suma de los valores introducidos por el
06usuario
07
08 // inicializar el subprograma, obteniendo los valores del
09usuario
10 public void init()
11 {
12usuario String primerNumero; // primera cadena introducida por el
13 String segundoNumero; // segunda cadena introducida por el
14usuario
15 double numero1; // primer número a sumar
16 double numero2; // segundo número a sumar
// obtener el primer número del usuario
17 primerNumero = JOptionPane.showInputDialog("Escriba el
18primer valor de punto flotante" );
19 // obtener el segundo número del usuario
20 segundoNumero = JOptionPane.showInputDialog("Escriba el
segundo valor de punto flotante" );
21 // convertir los números de tipo Stromg a tipo double
22 numero1 = Double.parseDouble( primerNumero );
23 numero2 = Double.parseDouble( segundoNumero );
24 // sumar los números
suma = numero1 + numero2;
25 }// fin del método init
26 // dibujar los resultados en un rectángulo en el fondo del
27subprograma
28 public void paint( Graphics g )
29 {
// llamar a la versión del método paint de la superclase
30 super.paint( g );
31 // dibujar un rectángulo, empezando desde (15, 10), que
32tenga 270
33 // píxeles de ancho y 20 píxeles de alto
g.drawRect( 15, 10, 270, 20 );
34 // dibujar los resultados como String en (25, 25)
35 g.drawString( "La suma es " + suma, 25, 25 );
36 }// fin del método paint
37} // fin de la clase SubprogramaSuma

Los ejemplos de esta sección se enfocan en el proceso de desarrollo de programas. Se

exponen los tipos primitivos de instrucciones de control para la tomas de decisiones (if,
else, if… else, while, do…while, for, switch, etc.). Los ejemplos también muestran el
manejo de la repetición controlada por contador y por centinela, y se introducen los
operadores de incremento, decremento y asignación de Java y las instrucciones break y
switch.

Repetición controlada por contador con la instrucción while

?
01// Repetición controlada por contador.
02import java.awt.Graphics;
03import javax.swing.JApplet;
04public class ContadorWhile extends JApplet
05{
// dibujar líneas en el fondo del subprograma
06 public void paint( Graphics g )
07 {
08 super.paint( g ); // llamar al método paint heredado de
09JApplet
10 int contador = 1; // inicialización
while ( contador <= 10 ) // condición de repetición
11 {
12 g.drawLine( 10, 10, 250, contador * 10 );
13 ++contador; // incremento
14 } // fin de instrucción while
} // fin del método paint
15} // fin de la clase ContadorWhile
16
17

Descargar código fuente

Repetición controlada por contador con la instrucción for

?
01// Repetición controlada por contador con la instrucción for
02import java.awt.Graphics;
03import javax.swing.<SPAN class="goog_qs-tidbit goog_qs-tidbit-
0">JApplet;
04public class ContadorFor extends JApplet
05{
06 // dibujar líneas en el</SPAN> fondo del subprograma
07 public void paint( Graphics g )
{
08 super.paint( g ); // llamar al método paint heredado de
09JApplet
10
11 // el encabezado de la instrucción for incluye la
12inicialización,
// la condición de repetición y el incremento
13
for ( int contador = 1; contador <= 10; contador++ )
14 g.drawLine( 10, 10, 250, contador * 10 );
15 } // fin del método paint
16} // fin de la clase ContadorFor

Descargar código fuente

Suma de enteros con la instrucción for

?
01// Suma de enteros con la instrucción for.
02import javax.swing.JOptionPane;
03public class Suma
04{
public static void main( String args[] )
05 {
06 int total = 0; // inicializar el total
07
08 // sumar los enteros pares del 2 al 100
09 for ( int numero = 2; numero <= 100; numero += 2 )
10 total += numero;
11
// mostrar el resultado
12 JOptionPane.showMessageDialog( null, "La suma es " +
13total,"Suma de los enteros pares del 2 al
14100",JOptionPane.INFORMATION_MESSAGE );
15
16 System.exit( 0 ); // terminar la aplicación
17 } // fin de main
} // fin de la clase Suma
18
Descargar código fuente

Cálculo del interés compuesto con la instrucción for

01// Cálculo del interés compuesto.

import java.text.NumberFormat; // clase para el formato numérico
02import java.util.Locale; // clase para información específica de
03cada país
04import javax.swing.JOptionPane;
05import javax.swing.JTextArea;
06public class Interes
{
07 public static void main( String args[] )
08 {
09 double cantidad; // cantidad depositada al final de
10 cada año
double principal = 1000.0; // cantidad inicial sin intereses
11 double tasa = 0.05; // tasa de interés
12
13 // crear NumberFormat para la moneda en dólares
14 NumberFormat formatoMoneda=NumberFormat.getCurrencyInstance(
15Locale.US );
16
17 // crear JTextArea para mostrar la salida
JTextArea areaTextoSalida = new JTextArea();
18
19 // establecer la primera línea de texto en areaTextoSalida
20 areaTextoSalida.setText( "Año\tCantidad en depósito\n" );
21
22 // calcular la cantidad en depósito para cada uno de los
23 diez años
for ( int anio = 1; anio <= 10; anio++ )
24
{
25 // calcular la nueva cantidad para el año especificado
26 cantidad = principal * Math.pow( 1.0 + tasa, anio );
27 // anexar una línea de texto a areaTextoSalida
28 areaTextoSalida.append( anio + "\t"
+formatoMoneda.format( cantidad ) + "\n" );
29 }// fin de instrucción for
30
31 // mostrar resultados
32 JOptionPane.showMessageDialog( null,
33areaTextoSalida,"Interés compuesto", JOptionPane.INFORMATION_MESSAGE
34);
35
System.exit( 0 ); // terminar la aplicación
36 } // fin de main
37} // fin de la clase Interes

Descargar código fuente

Uso de la instrucción do…while

?
01
02// Uso de la instrucción do...while.
import java.awt.Graphics;
03import javax.swing.JApplet;
04public class PruebaDoWhile extends JApplet
05{
06 // dibujar líneas en el subprograma
public void paint( Graphics g )
07 {
08 super.paint( g ); // llamar al método paint heredado de
09JApplet
10 int contador = 1; // inicializar contador
11
12 do
{
13 g.drawOval( 110 - contador * 10, 110 - contador *
1410,contador * 20, contador * 20 );
15 ++contador;
16 }
while ( contador <= 10 ); // fin de instrucción do...while
17 } // fin del método paint
18} // fin de la clase PruebaDoWhile
19

Descargar código fuente

Dibujar líneas, rectángulos u óvalos con base en la entrada del usuario

(switch)

01// Dibujar líneas, rectángulos u óvalos con base en la entrada del

usuario.
02import java.awt.Graphics;
03import javax.swing.*;
04
05public class PruebaSwitch extends JApplet
06{
int opcion; // la opcion del usuario en cuanto a cuál figura
07dibujar
08
09 // inicializar el subprograma, obteniendo la opción del usuario
10 public void init()
11 {
12 String entrada; // la entrada del usuario
// obtener la opción del usuario
13 entrada = JOptionPane.showInputDialog("Escriba 1 para
14dibujar líneas\n" +
15 "Escriba 2 para dibujar rectángulos\n" +
16 "Escriba 3 para dibujar óvalos\n" );
opcion = Integer.parseInt( entrada ); // convertir entrada
17
en int
18 } // fin del método init
19 // dibujar figuras en el fondo del subprograma
20 public void paint( Graphics g )
21 {
22JApplet super.paint( g ); // llamar al método paint heredado de
23 for ( int i = 0; i < 10; i++ ) // iterar 10 veces (0-9)
24 {
25 switch ( opcion ) // determinar la figura a dibujar
{
26 case 1: // dibujar una línea
27 g.drawLine( 10, 10, 250, 10 + i * 10 );
28 break; // fin de procesamiento de case
29
30 case 2: // dibujar un rectángulo
g.drawRect( 10 + i * 10, 10 + i * 10,50 + i * 10,
3150 + i * 10 );
32 break; // fin de procesamiento de case
33
34 case 3: // dibujar un óvalo
35 g.drawOval( 10 + i * 10, 10 + i * 10,50 + i * 10,
3650 + i * 10 );
break; // fin de procesamiento de case
37
38 default: // dibujar cadena indicando que se escribió
39un valor incorrecto
40 g.drawString( "Se escribió un valor
41 incorrecto",10, 20 + i * 15 );
42 } // fin de instrucción switch
} // fin de instrucción for
43 } // fin del método paint
44} // fin de la clase PruebaSwitch