Java

By
Ing. Rodolfo Gallardo-Rosales, M.C.

[email protected]
Universidad de Colima
Cómo iniciar
• Puede utilizarse cualquier editor, por ejemplo, el editor del entorno

DOS del windows. (Si es UNIX, el ed o el vi)
• Los programas necesarios (en orden) son los siguientes:

• Editor
• Compilador
• Vinculador
• Visor de applets o navegador
• La compilación se hará mediante la orden “javac”; por ejemplo:
• C:\> javac Saludo.java
Mi primer programa
• Escribe en tu editor las siguientes líneas de tu primer programa, que

guardarás con el nombre de Saludo.java:
import java.awt.*;
import java.applet.Applet;
public class Saludo extends Applet {

public void paint (Graphics g) {
g.drawString ("Hola, Mundo!", 50, 50);
}
}
• Ahora, compílalo mediante la orden:

Javac Saludo.java
• Y se generará el archivo compilado:
Saludo.class
Para crear una página web
• No puede correrse un applet (programa) de Java sólo, así que

necesitamos una página de HTML para correrlo
• Un nombre adecuado, sería Saludo.html y su contenido HTML

apropiado, sería
<html>
<title> Página Web con applet </title>
<applet code="Saludo.class" width=300 height=200> </applet>
</html>
Ejecución del programa
• El visor de applets es un auxiliar muy valioso para probar los applets

de java, y se aplica de la siguiente manera:
• C:\Documents and settings\root\> Appletviewer saludo.html

Desglose del programa
• Vamos ahora a explicar el programa en Java
1. import java.awt.*;
2. import java.applet.Applet;
3. public class Saludo extends Applet {
4. public void paint (Graphics g) {
5. g.drawString ("Hola", 50, 50);
6. }
7. }
• Evidentemente los números no forman parte del programa
• La pieza más importante, y la que es necesario comprender ahora

mismo, es la línea 5. Esta indica que el visor debe mostrar la línea
“Hola”, los números 50,50 indica 50 pixels desde la izquierda y 50
pixels desde ariba
Introducción a los gráficos
• El siguiente programa, muestra una línea diagonal en la pantalla.

• Su listado es:
import java.awt.*;
public class PrimeraLinea extends Applet {
public void paint(Graphics g) {
g.drawLine(0,0,100,100);
}
}
• El código en HTML para PrimeraLinea.html será

<applet code="PrimeraLinea.class“ width=300 height=200> </applet>
Explicación del programa
• Sólo entenderemos una sección del programa (conocida como

método)
1. public void paint(Graphics g) {

2. g.drawLine(0,0,100,100);
3. }
• G es el área donde se va a realizar el grafico,

• El método drawLine tiene:
• Horizontal de inicio de línea
• Vertical de inicio de línea
• Horizontal de fin de línea
• Vertical de fin de línea
Otros métodos gráficos
• El método drawRect tiene parámetros:

• Horizontal esquina superior izquierda
• Vertical esquina superior izquierda
• Ancho del rectángulo
• Alto del rectángulo
• El método drawOval tiene parámetros

• Horizontal esquina superior izquierda del rectángulo
• Vertical esquina superior izquierda del rectángulo
• Anchura del rectángulo
• Altura del rectángulo
Otros métodos gráficos
• El método drawArc tiene parámetros

• Horizontal esquina superior izquierda del rectángulo
• Vertical esquina superior izquierda del rectángulo
• Anchura del rectángulo
• Altura del rectángulo
• Ángulo de inicio
• Ángulo total del arco
Rellenar figuras con colores
• Hay 13 colores estándar

black blue cyan darkGray
gray green lightGray magenta
orange pink red white
yellow
• Y el uso adecuado sería

setBackground(Color.lightGray);
g.setColor(Color.red);
• Y un método para rellenar figuras

fillRect
fillArc
fillOval
Ejemplo para rellenar figuras
import java.awt.*;
public class PrimerasFiguras extends Applet {
g.drawRect(30,30,80,40);
g.drawOval(120,30,50,50);
g.setColor(Color.black);
g.fillRect(30,100,80,40);
g.fillOval(120,100,50,50);
g.drawLine(30,160,130,170);
g.drawArc(30,180,50,50,60,40);
g.fillArc(120,180,50,50,60,40);
}
}
******************** y el HTML ************************
<applet code="PrimerasFiguras.class"
width=300 height=200> </applet>
Declaración de variables
• Veamos el código siguiente:

//calcular área de rectángulo -versión 1
import java.awt.*;
public class Calculo extends Applet {

int longitud; //declaraciones
int anchura;
int area;
longitud = 20; //asignaciones

anchura = 10;
area = longitud * anchura; //* indica multiplicar
g.drawString("El área es " + area, 100, 100); //mostrar respuesta en pantalla
}
}
Escribir tus propios métodos
import java.awt.*;
public class ProbarTriangulo extends Applet {

int inferiorX = 80;
int inferiorY = 200;
int base = 100;
int altura = 110;
g.drawLine(inferiorX, inferiorY, inferiorX+base, inferiorY);

g.drawLine(inferiorX+base, inferiorY, inferiorX+base/2,
inferiorY-altura);
g.drawLine(inferiorX+base/2, inferiorY-altura,
inferiorX, inferiorY);
}
}
Un primer método
import java.awt.*;
public class MetodoTrianguloDemo extends Applet {

dibujarTriangulo(g,80,200,100,110);
dibujarTriangulo(g,125,220,60,70);
}
private void dibujarTriangulo(Graphics g, int inferiorX,

int inferiorY, int base, int altura) {
g.drawLine(inferiorX, inferiorY, inferiorX+base,
inferiorY);
g.drawLine(inferiorX+base, inferiorY, inferiorX+base/2,
inferiorY-altura);
g.drawLine(inferiorX+base/2, inferiorY-altura, inferiorX,
inferiorY);
}
}
Uso de los métodos como base
import java.awt.*;
public class CasaDemo extends Applet {
dibujarCasa(g,50,50,70,30);
dibujarCasa(g,100,50,60,20);
}
private void dibujarTriangulo(Graphics g, int inferiorX,

int inferiorY, int base, int altura) {
g.drawLine(inferiorX, inferiorY, inferiorX+base,
inferiorY);
g.drawLine(inferiorX+base, inferiorY, inferiorX+
base/2, inferiorY-altura);
g.drawLine(inferiorX+base/2, inferiorY-altura, inferiorX,
inferiorY);
}
private void dibujarCasa(Graphics g, int inferiorX, int inferiorY,

int anchura, int altura) {
g.drawRect(inferiorX, inferiorY-altura, anchura, altura);
dibujarTriangulo(g, inferiorX, inferiorY-altura, anchura, altura/2);
}
}
Programa controlado por eventos
• Programa para leer un número de una barra de desplazamiento y

mostrar su valor en dígitos en la pantalla.
• Se requiere escribir el código de Java y guardarlo en un archivo

llamado PrimerEvento.java.
• Ahora, hacer el PrimerEvento.html para correrlo.

Programa controlado por eventos
import java.awt.*;
import java.awt.event.*;
public class PrimerEvento extends Applet

implements AdjustmentListener {
private Scrollbar barraDeslizable ;
private int barraDeslizableValor = 0;
public void init() {

barraDeslizable = new Scrollbar(Scrollbar.HORIZONTAL,
0, 1, 0, 100);
add(barraDeslizable);
barraDeslizable.addAdjustmentListener(this);
}

g.drawString("El valor actual es " + barraDeslizableValor,
100, 100);
}
public void adjustmentValueChanged(AdjustmentEvent e) {

barraDeslizableValor = barraDeslizable.getValue ();
repaint();
}
}
Ejemplo de programa controlado por eventos
• El siguiente programa, simula una persiana electrónica, al arrastrar la

barra de desplazamiento vertical hacia abajo, la persiana se baja.
• Para representar esta configuración, debemos dibujar un rectángulo

que represente el marco de la ventana y un rectángulo relleno para la
persiana.
• Guardar el programa en un archivo llamado Persiana.java

Ejemplo de programa controlado por eventos
// Ejemplo de barra de desplazamiento - simulador de persiana

import java.awt.*;
public class Persiana extends Applet

private Scrollbar barraDeslizable ;
private int barraDeslizableValor;
public void init () {

barraDeslizable = new Scrollbar(Scrollbar.VERTICAL, 0, 1,
0, 100);
}

showStatus("El valor de la barra de desplazamiento es " +
barraDeslizableValor);
g.drawRect(40, 80, 60, 100);
g.fillRect(40, 80, 60, barraDeslizableValor);
}

barraDeslizableValor = barraDeslizable.getValue ();
repaint();
}
}
Agregando etiquetas
• Se ha estado utilizando “add” para colocar un nuevo componente en la

pantalla, usando lo que se llama “esquema de flujo” de AWT, donde los
componentes van centrados y de izquierda a derecha, y se pasan a la
siguiente fila en caso de necesitar más espacio
• El caso es que no podemos saber su posición en píxeles, así que no

podemos utilizar el método drawString para colocar texto cerca de ellos
• Como alternativa, se puede utilizar un componente etiqueta que

contiene texto y que se agrega al esquema en forma similar a las
barras de desplazamiento.
• Simplemente declaramos el componente y lo inicializamos con texto

Agregando etiquetas
import java.awt.*;
public class EtiquetaDemo extends Applet

private Scrollbar barra1, barra2;
private int barra1Valor = 0;
private int barra2Valor = 0;

Label titulo1, titulo2; // es suficiente un alcance local
titulo1 = new Label("arriba:");
add(titulo1);
barra1 = new Scrollbar(Scrollbar.HORIZONTAL, 0, 1, 0, 100);
add(barra1);
barra1.addAdjustmentListener(this);
titulo2 = new Label(" abajo:");
add(titulo2);
barra2 = new Scrollbar(Scrollbar.HORIZONTAL, 0, 1, 0, 100);
add(barra2);
barra2.addAdjustmentListener(this);
}
Agregando etiquetas (continúa)

g.drawString("El valor de ARRIBA es " + barra1Valor, 100, 100);
g.drawString("El valor de ABAJO es " + barra2Valor, 100, 150);
}

barra1Valor = barra1.getValue();
barra2Valor = barra2.getValue();
repaint();
}
}
Uso de escalas en la barra de desplazamiento
• Consideremos el problema de convertir un número de pulgadas (en la

gama de 0 a 10) a centímetros donde una pulgada equivale a 2.54 cm
• Podríamos establecer en la barra de desplazamiento una gama de 0 a

10, pero eso nos daría poca precisión
• En vez de eso, crearemos una barra de desplazamiento de 0 a 100 y

luego escalaremos esos números enteros para convertirlos en
números de punto flotante, con incrementos de 0.1 pulgadas
Uso de escalas en la barra de desplazamiento
// Ejemplo de barra de desplazamiento - pulgadas a centímetros

import java.awt.*;
public class PulgACm extends Applet

private Scrollbar barraDeslizable;
private float barraDeslizableValor;
barraDeslizable = new Scrollbar(Scrollbar.HORIZONTAL, 0, 1,
0, 100);
}

float cmEquivalente;
cmEquivalente = barraDeslizableValor*2.54f;
g.drawString("Pulgadas="+barraDeslizableValor+" Cm="+cmEquivalente,
100, 100);
}

barraDeslizableValor = (float) barraDeslizable.getValue()/10;
repaint();
}
}
Una salida en forma gráfica
• Puede ser que se necesite dibujar una parte de una imagen, y luego
esperar por un evento, lo cual resultaría difícil utilizando “paint” y
“repaint”, ya que “paint” borra toda la imagen antes de volver a dibujar
• Se puede mantener la imagen existente, y agregar la otra parte cuando

sea necesario
• Esto se logra mediante el método getGraphics, el cual obtiene los

detalles relacionados con el área de dibujo.
Una salida en forma gráfica
import java.awt.*;
public class BarraDesplazamientoValores extends Applet

private Scrollbar barraDeslizable;
private int xActual = 1;
private int yActual = 5;

barraDeslizable = new Scrollbar(Scrollbar.HORIZONTAL,
0, 1, 0, 100);
}
public void adjustmentValueChanged (AdjustmentEvent e) {

Graphics g = getGraphics();
xActual = barraDeslizable.getValue();
g.drawLine(0, yActual, xActual, yActual);
yActual = yActual+5;
}
}
La instrucción if
• Definiremos un programa como una serie de instrucciones para la

computadora; misma que obedece las instrucciones en secuencia, es
decir, una a una
• A enudo es conveniente que la computadora compare ciertos datos y

después lleve a cabo una de varias acciones, dependiendo del
resultado de la comparación
La instrucción if
import java.awt.*;
public class Votacion extends Applet implements AdjustmentListener {
private Scrollbar barra;

private int edad = 0;

barra = new Scrollbar(Scrollbar.HORIZONTAL, 0, 1, 0, 100);
add(barra);
barra.addAdjustmentListener(this);
}

if (edad > 17)
g.drawString ("Puede votar", 50, 50);
g.drawString("La edad es " + edad, 50, 70);
}
public void adjustmentValueChanged(AdjustmentEvent event) {
edad = barra.getValue();
repaint();
}
}
Operadores de comparación: tirar el dado
• Este ejemplo demuestra cómo llevar a cabo una serie más compleja
de evaluaciones
• Se tiran dos dados en un juego de apuestas y el programa tiene que

decidir cuál va a ser el resultado
• Se crearán dos barras de desplazamiento con un rango de 1 a 6 para

introducir los valores de cada uno de los dados
• Se establece la regla que sólo una puntuación que sume seis será la
que gane
Operadores de comparación: tirar el dado
import java.awt.*;
public class Dados1 extends Applet implements AdjustmentListener {

private Scrollbar dado1, dado2;
private int valor1 = 1, valor2 = 1;

dado1 = new Scrollbar(Scrollbar.HORIZONTAL, 1, 1, 1, 6);
add(dado1);
dado1.addAdjustmentListener(this);
dado2 = new Scrollbar(Scrollbar.HORIZONTAL, 1, 1, 1, 6);
add(dado2);
dado2.addAdjustmentListener(this);
}
Operadores de comparación: tirar el dado (continúa)

int total;
total = valor1 + valor2;
g.drawString("el total es "+total, 50, 50);
if (total == 6)
g.drawString("¡ha ganado!", 50, 60);
}

valor1 = dado1.getValue();
valor2 = dado2.getValue();
repaint();
}
}
Caso de estudio con if: Tom y Jerry
• En este programa, se crean dos barras de desplazamiento, una

llamada Tom y la otra llamada Jerry
• El programa compara los valores e informa cuál de las dos barras tiene
el valor más grande
• El método fillRect se usa para dibujar un rectángulo sólido

Caso de estudio con if: Tom y Jerry
import java.awt.*;
public class TomYJerry extends Applet implements AdjustmentListener {
private Scrollbar tom, jerry;

private int tomValor = 0, jerryValor = 0;

Label toms = new Label("Tom:");
add(toms);
tom = new Scrollbar(Scrollbar.HORIZONTAL, 0, 1, 0, 100);
add(tom);
tom.addAdjustmentListener(this);
Label jerrys = new Label("Jerry:");

add(jerrys);
jerry = new Scrollbar(Scrollbar.HORIZONTAL, 0, 1, 0, 100);
add(jerry);
jerry.addAdjustmentListener(this);
}
Caso de estudio con if: Tom y Jerry (continua)

g.drawString("Tom", 5, 70);
g.fillRect(40, 60, tomValor, 10);
g.drawString("Jerry", 5, 85);
g.fillRect(40, 75, jerryValor, 10);
if (tomValor > jerryValor)
g.drawString("Tom es mayor", 50, 50);
else
g.drawString("Jerry es mayor", 50, 50);
}

tomValor = tom.getValue();
jerryValor = jerry.getValue();
repaint();
}
}
Caso de estudio con if: pantalla de amplificador
• Algunos amplificadores estereofónicos tienen una pantalla que muestra

el volumen creado
• La pantalla presenta altibajos de acuerdo con el volumen en un punto

dado en el tiempo
• Algunas veces la pantalla tiene un indicador que muestra el valor

máximo producido actualmente
• Este programa muestra el valor numérico del valor máximo en el que

se encuentra la barra de desplazamiento
Caso de estudio con if: pantalla de amplificador
import java.awt.*;
public class Max extends Applet implements AdjustmentListener {

private Scrollbar controlVolumen;
private int max = 0;
private int volumen = 0;

controlVolumen = new Scrollbar(Scrollbar.HORIZONTAL,
0, 1, 0, 100);
add(controlVolumen);
controlVolumen.addAdjustmentListener(this);
}

if (volumen > max)
max = volumen;
g.drawString("El valor máximo es " + max, 50, 50);
}

volumen = controlVolumen.getValue();
repaint();
}
}
Caso de estudio con if: conteo de botones
• Empezaremos utilizando sólo un botón con una etiqueta que dice

“Oprima aquí”
• Al oprimir el botón haciendo click con el ratón, haremos que el

programa muestre el número de veces que se ha hecho click sobre el
botón
• Esto comprobará que el botón y nuestro código en Java están

funcionando correctamente
Caso de estudio con if: conteo de botones
import java.applet.*;
import java.awt.*;
public class BotonesContar extends Applet implements

ActionListener {
private Button evaluador;
private int cuenta = 0;

evaluador = new Button("Oprima aquí");
add(evaluador);
evaluador.addActionListener(this);
}
public void actionPerformed(ActionEvent event) {

cuenta++;
repaint();
}

g.drawString("El número de botones oprimidos
es " + cuenta, 10, 50);
}
}
Variables booleanas: boton ouch
• Todos los tipos de variable que se han visto hasta aquí están
diseñadas para guardar valores numéricos
• Ahora veremos un nuevo tipo de variable, conocido como boolean

(también llamadas flags o banderas), que sólo puede guardar los
valores true o false
• Estas se usan en programación para mantener el registro del estado

de cierta acción
• Utilizaremos una variable booleana para indicar si el botón ha sido o no

oprimido
Variables booleanas: boton ouch
import java.awt.*;
public class BotonOuch extends Applet implements ActionListener {
private Button evaluador;

private boolean oprimidoYa = false;

evaluador = new Button("Oprima aquí");
add(evaluador);
evaluador.addActionListener(this);
}

if (oprimidoYa)
g.drawString("OUCH", 100, 50);
}

oprimidoYa = true;
repaint();
}
}
Números aleatorios: dados
• Ahora en vez de introducir los valores de los dados mediante la barra

de desplazamiento, cambiaremos el programa de manera que la
computadora decida al azar los valores de los dados
• Crearemos un botón etiquetado como “Tirar”; al oprimir este botón el

programa obtendrá dos números aleatorios y los utilizará como valores
para los dados
Números aleatorios: dados
import java.awt.*;
public class Dados2 extends Applet implements ActionListener {
private Button tirarDados;

private boolean tirados = false;

tirarDados = new Button("Tirar");
add(tirarDados);
tirarDados.addActionListener(this);
}

tirados = true;
repaint();
}
Números aleatorios:dados (continúa)

int dado1, dado2;
if (tirados) {
dado1 = (int)(Math.random() * 6) + 1;
dado2 = (int)(Math.random() * 6) + 1;
g.drawString("Los dados son " + dado1 + " y " + dado2, 20, 40);
if (dado1 == dado2)
g.drawString("ha ganado", 20, 60);
else
g.drawString("lo siento", 20, 60);
}
}
}
Caso de estudio con botones: chico y grande
• En este programa crearemos dos botones
• El programa dibuja un círculo
• Al oprimir un botón el círculo se hace más grande; el otro botón lo hace

más pequeño
• Cuando el usuario hace click con el ratón, el visor de applets detecta el

evento; después invoca al método llamado actionPerformed que
hemos escrito para manejar el evento
Caso de estudio con botones: chico y grande
import java.awt.*;
public class ChicoYGrande extends Applet implements ActionListener {

private int diametro = 20;
private Button chico, grande;

chico = new Button("Chico");
add(chico);
chico.addActionListener(this);
grande = new Button("Grande");
add(grande);
grande.addActionListener(this);
}
Caso de estudio con botones: chico y grande (continúa)

g.drawOval(25, 25, diametro, diametro);
}

if (event.getSource() == chico)
diametro = diametro - 10;
if (event.getSource() == grande)
diametro = diametro + 10;
repaint();
}
}
Caso de estudio con botones: la caja de seguridad
• Este programa representa el candado de combinación en una cja de

seguridad
• El programa muestra tres botones, uno para cada uno de los dígitos 1,
2y3
• El usuario tiene que oprimir tres botones, tratando de adivinar

correctamente la combinación
import java.awt.*;
public class CajaSeguridad extends Applet
implements ActionListener {
private int adivinar = 0;

private int combinacion = 321;
private Button uno, dos, tres, denuevo;

uno = new Button("1");
add (uno);
uno.addActionListener(this);
dos = new Button("2");
add (dos);
dos.addActionListener(this);
tres = new Button ("3");
add (tres);
tres.addActionListener(this);
denuevo = new Button("Intente de nuevo");
add(denuevo);
denuevo.addActionListener(this);
}
(continúa)

if (adivinar == combinacion)
g.drawString ("Abierta", 50,50);
else
g.drawString ("Cerrada", 50,50);
}

if (event.getSource() == uno)
adivinar = adivinar*10 + 1;
if (event.getSource() == dos)
if (event.getSource() == tres)
if (event.getSource() == denuevo)
adivinar=0;
repaint();
}
}
Campo de texto: verificar la edad
• Los campos de texto son otra componente de la interfaz gráfica de

usuario que permiten introducir información
• Habíamos utilizado barras de desplazamiento para introducir números,

lo que es conveniente e intuitivo, pero un campo de texto permite
introducir números de manera más precisa que en una barra de
desplazamiento, y también utilizarse para introducir información textual
• En este programa, actúa como verificador de votos, como una nueva

versión , en el cual la edad del votante se inscribe en un campo de
texto
Campo de texto: verificar la edad
import java.awt.*;
public class VerificarEdad extends Applet

private TextField edadCampo;

private int edad;

edadCampo=new TextField(10);
add(edadCampo);
edadCampo.addActionListener(this);
}
Campo de texto: verificar la edad (continua)

edad=Integer.parseInt(edadCampo.getText());
repaint();
}

g.drawString("La edad es " + edad, 50, 50);
if (edad >= 18)
g.drawString("Puede votar", 50, 100);
else
g.drawString("No puede votar", 50,100);
}
}
Uso del while: líneas paralelas
• En el siguiente programa se ilustra el uso de la instrucción while con un

ejemplo, en el que se imprimirán en la pantalla, algunas líneas
paralelas horizontales
• Utilizaremos el método de biblioteca drawLine para imprimir una sola

línea
• Además usaremos una instrucción while para indicar que queremos

dibujar varias líneas
Uso del while: líneas paralelas
import java.awt.*;
public class Lineas extends Applet {

int n = 0;
int x = 20;
int y = 20;
while (n < 5) {
g.drawLine(x, y, x + 100, y);
y = y + 10;
n++;
}
}
}
Uso del while: escalones
• Este programa dibuja un número de escalones que van hacia abajo,

determinado en base al valor de una barra de desplazamiento
• Observemos que a pesar de que el número de escalones sea cero, el

programa funciona correctamente
• Esta, es una característica de los ciclos while y asegura que puedan

utilizarse con mucha frecuencia
Uso del while: escalones
import java.awt.*;
public class Escalones extends Applet

private Scrollbar escalones;

private int contador, numeroDeEscalones;

escalones = new Scrollbar(Scrollbar.HORIZONTAL, 0, 1, 0, 100);
add(escalones);
escalones.addAdjustmentListener( this);
}

int contador = 0;
int x = 20;
int y = 20;
while (contador < numeroDeEscalones) {
g.drawLine (x, y, x + 20, y);
g.drawLine (x + 20, y, x + 20, y + 20);
Uso del while: escalones (continua)
x = x + 20;
y = y + 20;
contador++;
}
}

numeroDeEscalones = escalones.getValue();
repaint();
}
}
El ciclo for: asteriscos
• En un ciclo for se reúnen muchos de los ingredientes del ciclo while en

la instrucción en sí
• Aquí está un programa para mostrar una fila de asteriscos en la

pantalla
• El número de asteriscos se introduce mediante una barra de

desplazamiento
El ciclo for: asteriscos
import java.awt.*;
public class Asteriscos extends Applet implements AdjustmentListener {

private Scrollbar barra;
private int numeroRequerido = 8;

barra = new Scrollbar(Scrollbar.HORIZONTAL, 0, 1, 0, 100);
add(barra);
barra.addAdjustmentListener(this);
}
numeroRequerido = barra.getValue();
repaint();
}

int contador;
int x = 10;
for (contador = 0; contador < numeroRequerido; contador++) {
g.drawString ("*", x, 30);
x = x + 10;
}
}
}
El ciclo do – while: granos de arroz
• En algunas veces, no sabemos cuántas veces es necesario repetir un

ciclo
• El siguiente es un programa que trata de corresponder con el antiguo

cuento del hombre que quería como recompensa por haber inventado
el ajedrez, un grano de arroz en el primer escaque, dos en el segundo,
cuatro en el tercero, ocho en el cuarto, y así sucesivamente,
duplicando la cantidad del escaque anterior
• En el programa, tratamos de averiguar cuántos escaques se necesitan

para obtener 100 granos de arroz
El ciclo do – while: granos de arroz
import java.awt.*;
public class Arroz extends Applet {

int contadorDeCuadros = 0;
int arrozEnEsteCuadro = 1;
int totalArroz = 0;
int y = 20;
do {
contadorDeCuadros++;
g.drawString("En el cuadro "+contadorDeCuadros +
" hay " + arrozEnEsteCuadro, 10, y);
totalArroz = totalArroz + arrozEnEsteCuadro;
arrozEnEsteCuadro = arrozEnEsteCuadro * 2;
y = y +20;
} while (totalArroz < 100);
g.drawString("El número de cuadros necesarios es " +

contadorDeCuadros, 10, y + 20);
}
}
Combinación de estructuras de control: la pelota
rebotadora
• En este programa se rebota una pelota en la pantalla, a esto se le

conoce como animación
• Se especifica su posición mediante sus coordenadas x e y,

inicialmente empieza en la esquina superior izquierda de la ventana
• Se mueve en incrementos de 7 píxeles en dirección x y de 2 píxeles en

dirección y
• El método de biblioteca fillOval se utiliza para dibujar la pelota, con un

diámetro de 10 píxeles
• Cuando la pelota pega en una de las cuatro paredes, su dirección se

invierte
rebotadora
import java.awt.*;
public class Pelota extends Applet {
private int x = 7, xCambio = 7;

private int y = 2, yCambio = 2;
private int rectIzqX = 0, rectDerX = 100;

private int rectSupY = 0, rectInfY = 100;
for (int n = 1; n < 1000; n++) {

g.drawRect(rectIzqX, rectSupY, rectDerX - rectIzqX+15, rectInfY -
rectSupY+10);
for (int jj=0;jj<1000000;jj++) { }

•
rebotadora (continua)
Color colorDeFondo = getBackground();

g.setColor(colorDeFondo);
g.fillOval(x, y, diametro, diametro);
if (x <= rectIzqX)
xCambio = -xCambio;
if (x >= rectDerX)
xCambio = -xCambio;
if (y <= rectSupY)
yCambio = -yCambio;
if (y >= rectInfY)
yCambio = -yCambio;
x = x + xCambio;
y = y + yCambio;
g.setColor(Color.red);
g.fillOval(x, y, diametro, diametro);
}
}
}
Uso de objetos: el programa globo
• Un objeto es la combinación de ciertos datos (variables) y de algunas

acciones (métodos), e idealmente un objeto se diseña de mnera que
los datos y las acciones estén íntimamente relacionados, en lugar de
estar reunidos al azar
• Como ejemplo, realizaremos este programa para mostrar y manipular

un globo
• El programa, simplemente muestra un globo representado por un

círculo en la pantalla hay dos botones para cambiar su tamaño
Uso de objetos: el programa globo
import java.awt.*;
public class JugarGlobo extends Applet

private Button agrandar, reducir;
private Globo miGlobo;

agrandar = new Button ("Agrandar");
add (agrandar);
agrandar.addActionListener(this);
reducir = new Button ("Reducir");

add (reducir);
reducir.addActionListener(this);
miGlobo = new Globo (20, 50, 50);

}
Uso de objetos: el programa globo (continua)

if (event.getSource() == agrandar)
miGlobo.cambiarTama ño(10);
if (event.getSource() == reducir)
miGlobo.cambiarTama ño(-10);
repaint();
}

miGlobo.mostrar(g);
}
}
class Globo{
private int diametro;
private int xCoord, yCoord;
public Globo (int diametroInicial, int xInicial, int yInicial) {

diametro = diametroInicial;
xCoord = xInicial;
yCoord = yInicial;
}
Uso de objetos: el programa globo (continua)
public void cambiarTamaño (int cambio) {

diametro = diametro + cambio;
}
public void mostrar (Graphics g) {

g.drawOval (xCoord, yCoord, diametro, diametro);
}
}
Arquitectura de applets: el globo
• Hemos visto que un programa orientado a objetos está compuesto

precisamente de objetos; cada objeto consta tanto de métodos que
proporcionan servicios a otros objetos, como de algunos datos
privados
• El programa consta de dos clases: la interfaz del usuario y la clase

Globo, que modela la aplicación
• La interfaz del usuario del globo consta de dos partes:

• Los botones que permiten el control del globo
• El proceso de mostrar el globo en la ventana
• El programa para la aplicación del globo (y de hecho para cualquier

aplicación con una GUI) consta de tres secciones
• El controlador (botones para cambiar de posición o tamaño)

• El modelo (el globo)
• La vista (mostrar el círculo)
• Estos tres elementos colaboran entre sí para hacer que todo programa
funciones
import java.awt.*;
public class JugarGlobo extends Applet implements ActionListener {
private Button agrandar, reducir, izquierda, derecha;

private Globo miGlobo;

agrandar = new Button("Agrandar");
add(agrandar);
agrandar.addActionListener(this);
reducir = new Button("Reducir");
add(reducir);
reducir.addActionListener(this);
izquierda = new Button("Izquierda");
add(izquierda);
izquierda.addActionListener(this);
derecha = new Button("Derecha");
add(derecha);
derecha.addActionListener(this);
miGlobo= new Globo();

}
Arquitectura de applets: el globo (continua)
public void actionPerformed(ActionEvent event) { //controlador

if (event.getSource() == agrandar)
miGlobo.agrandar();
if (event.getSource() == reducir)
miGlobo.reducir();
if (event.getSource() == izquierda)
miGlobo.izquierda();
if (event.getSource() == derecha)
miGlobo.derecha();
repaint();
}
public void paint (Graphics g) { // la vista

miGlobo.mostrar(g);
}
}
Arquitectura de applets: el globo (continua)
class Globo{ // el modelo

private int xCoord = 20, yCoord = 50;
public void mostrar(Graphics g) {

g.drawOval(xCoord, yCoord, diametro, diametro);
}
public void izquierda() {

xCoord = xCoord - 10;
}
public void derecha() {

xCoord = xCoord + 10;
}
public void agrandar() {

diametro = diametro + 5;
}
public void reducir() {

diametro = diametro - 5;
}
}
Caso de estudio de cálculos: dinero
• Veamos ahora el desarrollo de un programa para realizar cálculos con

dinero
• Por lo general, el dinero se maneja en dos partes: pesos y centavos,

dólares y centavos, libras y peniques, francos y céntimos
• El programa calcula el interés compuesto
• Una cantidad se invierte a una tasa de interés anual específica y su

valor se va acumulando
• El usuario introduce la cantidad inicial (un entero) y una tasa de interés

(un número de punto flotante) en campos de texto, luego hace click en
un botón para ver la cantidad acumulada cada año
Caso de estudio de cálculos: dinero
import java.awt.*;
public class Acumular extends Applet

private Button año;

private TextField campoIntereses, campoCantidad, resultado;
private Inversion miDinero;

Label etiquetaCantidad = new Label("Introduzca cantidad:");
add(etiquetaCantidad);
campoCantidad = new TextField(8);

add(campoCantidad);
campoCantidad.addActionListener(this);
Label etiquetaTasa = new Label("Introduzca tasa de interés");

add(etiquetaTasa);
campoIntereses = new TextField(4);

add(campoIntereses);
campoIntereses.addActionListener(this);
Caso de estudio de cálculos: dinero(continúa)
año = new Button ("Otro año");

add (año);
año.addActionListener(this);
Label etiquetaResultado = new Label ("Su dinero al finalizar el año es");

add(etiquetaResultado);
resultado = new TextField(20);

add(resultado);
miDinero = new Inversion();

}

if (event.getSource() == campoCantidad) {
float cantidad = Integer.parseInt(campoCantidad.getText());
miDinero.establecerCantidadInicial(cantidad);
}
if (event.getSource() == campoIntereses) {
float tasa = Float.parseFloat(campoIntereses.getText());
miDinero.establecerTasa(tasa);
}
if (event.getSource() == año) {
miDinero.otroAño();
float cantidadNueva =
miDinero.obtenerCantidadNueva();
int dolares = (int) cantidadNueva;
int centavos = Math.round(100.0f * (cantidadNueva -
dolares));
resultado.setText(dolares + " dólares " + centavos + "
centavos");
}
}
}
class Inversion {
private float tasaInteres;

private float cantidadAnterior, cantidadNueva;
public void establecerCantidadInicial(float cantidad) {

cantidadAnterior = cantidad;
}
public void establecerTasa(float tasa) {

tasaInteres = tasa;
}
public void otroAño() {

cantidadNueva = cantidadAnterior + (cantidadAnterior * tasaInteres / 100.0f);
cantidadAnterior = cantidadNueva;
}
public float obtenerCantidadNueva() {

return cantidadNueva;
}
}
Gráficos: función y = ax3 + bx2 + cx + d
• Supongamos que se desea representar la función y = ax3 + bx2 + cx +

d, en donde los valores para a, b, c y d se introducen mediante barras
de desplazamiento
• Asumiremos que el área disponible en la pantalla es de 400 píxeles en

la dirección x y de 400 píxeles en la dirección y
• Se diseña el programa para mostrar los valores x e y en el rango de

- 5.0 a +5.0, por lo tanto, 1 unidad de x (o de y) equivale a 40 píxeles
• Para cada píxel de x, el programa:

• Calcula el valor de x a partir del valor de píxel de x
• Calcula el valor de y, el valor de la función de x
• Calcula el valor de píxel de y a partir del valor de y
Gráficos: función y = ax3 + bx2 + cx + d
import java.awt.*;
public class DibujarGafico extends Applet

private Grafico miGrafico;

private Scrollbar aBarraDesp, bBarraDesp, cBarraDesp, dBarraDesp;

miGrafico = new Grafico();
Label aEtiqueta = new Label("a:");

add(aEtiqueta);
aBarraDesp = new Scrollbar(Scrollbar.HORIZONTAL,
50, 10, 0, 100);
add(aBarraDesp);
aBarraDesp.addAdjustmentListener( this);
Label bEtiqueta = new Label("b:");
add(bEtiqueta);
Gráficos: función y = ax3 + bx2 + cx + d (continúa)
bBarraDesp = new Scrollbar(Scrollbar.HORIZONTAL,

50, 10, 0, 100);
add(bBarraDesp);
bBarraDesp.addAdjustmentListener( this);
Label cEtiqueta = new Label("c:");
add(cEtiqueta);
cBarraDesp = new Scrollbar(Scrollbar.HORIZONTAL,
50, 10, 0, 100);
add(cBarraDesp);
cBarraDesp.addAdjustmentListener( this);
Label dEtiqueta = new Label("d:");
add(dEtiqueta);
dBarraDesp = new Scrollbar(Scrollbar.HORIZONTAL,
50, 10, 0, 100);
add(dBarraDesp);
dBarraDesp.addAdjustmentListener( this);
}

int aValor = aBarraDesp.getValue();
int bValor = bBarraDesp.getValue();
int cValor = cBarraDesp.getValue();
int dValor = dBarraDesp.getValue();
miGrafico.establecerParametros(aValor, bValor, cValor, dValor);
repaint();
}

miGrafico.dibujar(g);
}
}
class Grafico {
private final int xPixelInicial = 10, xPixelFinal = 410, xOrigen = 215;

private final int yPixelInicial = 10, yPixelFinal = 410, yOrigen = 215;
private final float xInicial = -5.0f, xFinal = 5.0f;
private final float yInicial = -5.0f, yFinal = 5.0f;
private final float escala = (xPixelFinal - xPixelInicial) / (xFinal - xInicial);
private float a, b, c, d;
private float laFuncion(float x, float a,

float b, float c, float d) {
return a*x*x*x + b*x*x + c*x+d;
}
private float escalarX(int xPixel) {

float valor = (xPixel - xOrigen) / escala;
return valor;
}
private int escalarY(float y) {

int pixelCoord;
pixelCoord = Math.round(-y * escala) + yOrigen;
return pixelCoord;
}
public void establecerParametros(

int aValor, int bValor, int cValor, int dValor) {
a = escala(aValor);
b = escala(bValor);
c = escala(cValor);
d = escala(dValor);
}
private float escala(int coeficiente) {

return ((coeficiente - 50) / 10.0f);
}
public void dibujar(Graphics g) {

float x, y, siguienteX, siguienteY;
int xPixel, yPixel, siguienteXPixel, siguienteYPixel;
g.drawString("a= "+a+" b= "+b+" c= "+c+" d= "+d, 30, 60);
for(xPixel = xPixelInicial; xPixel < xPixelFinal; xPixel++) {

x = escalarX(xPixel);
y = laFuncion(x, a, b, c, d);
yPixel = escalarY(y);
siguienteXPixel = xPixel + 1;
siguienteX = escalarX(siguienteXPixel);
siguienteY = laFuncion(siguienteX, a, b, c, d);
siguienteYPixel = escalarY(siguienteY);
g.drawLine(xPixel, yPixel, siguienteXPixel, siguienteYPixel);

}
}
}
Arreglos: caída pluvial
• Es un programa para introducir algunos números, colocarlos en un

arreglo, mostrarlos en pantalla y sumarlos
• Los datos consisten en la precipitación pluvial para los siete días de la

semana (de domingo a sábado)
• El usuario del programa introduce un valor en el campo de texto, y

luego puede hacer click con el ratón en uno de los componentes del
arreglo para insertar el valor en el mismo
• El arreglo se muestra en la pantalla como una serie de rectángulos

mediante el uso de drawRect, uno debajo de otro
• El evento del click del ratón se pasa al método mouseClicked, el cual

obtiene la coordenada
Arreglos: caída pluvial
import java.awt.*;
public class CaidaPluvial extends Applet
implements ActionListener, MouseListener {
private Tabla lluviaDatos;

private TextField valor;

lluviaDatos = new Tabla();
Label l = new Label("Introduzca número y haga clic en el componente");

add(l);
valor = new TextField(10);
add(valor);
valor.addActionListener(this);
addMouseListener(this);
}

lluviaDatos.display(g);
}
Arreglos: caída pluvial (continúa)

int nuevoValor = Integer.parseInt(valor.getText());
lluviaDatos.establecerValor(nuevoValor);
repaint();
}
public void mouseClicked (MouseEvent event){

int yCoord = event.getY();
lluviaDatos.seleccionarComponente(yCoord);
repaint();
}
public void mouseReleased (MouseEvent e){

}
public void mousePressed (MouseEvent e){

}
public void mouseEntered (MouseEvent e){

}
public void mouseExited (MouseEvent e){

}
}
class Tabla {
private final int tablaTamaño = 7;

private int[] lluvia = new int[tablaTamaño];
private int indice;
private int nuevoValor;
private int suma = 0;
private final int xInicial = 20;

private final int yInicial = 60;
private final int cuadroAltura = 20;
private final int cuadroAncho = 60;
public void display(Graphics g) {

int y = yInicial;
for(int s = 0; s < lluvia.length; s++) {
g.drawRect(xInicial, y, cuadroAncho, cuadroAltura);
g.drawString(Integer.toString(lluvia[s]),
xInicial, y + cuadroAltura * 3 / 4);
y = y + cuadroAltura;
}
sumarValores();
g.drawString("La caída pluvial total es " + suma, 100, 100);
}
public void seleccionarComponente(int y) {

indice = (y - yInicial)/cuadroAltura;
lluvia[indice] = nuevoValor;
}
public void establecerValor(int valor) {

nuevoValor = valor;
}
private void sumarValores() {

suma = 0;
for (int s=0; s < lluvia.length; s++)
suma = suma + lluvia[s];
}
}
Arreglos: Lista de hits
• En este programa existen varios componentes que vale la pena

mencionar
• La lista de arreglos artistas, guarda cualquier número de objetos

Artista, declarados como una clase separada al final del programa
• Estos objetos son bastante simples, sólo contienen una cadena simple,
la información sobre la posición y el código necesario para mostrar un
objeto
• Al hacer click en el botón anexar, se crea un nuevo objeto que contiene

el texto deseado y se agrega al final de la lista de arreglos mediante el
uso del método add; remove se utiliza para eliminar una entrada de la
lista de arreglos
Arreglos: Lista de hits
import java.awt.*;
import java.util.*;
public class ListaHits extends Applet implements ActionListener, MouseListener {
private ArrayList artistas = new ArrayList();

private String texto;
private boolean elementoSeleccionado = false;
private int indiceSeleccionado = -1;
private Button anexar, eliminar, insertar, derecha;
private TextField campoTexto;
private Artista artista;
private int tamañoIncremento = 40;
private int yInicial = 60;
Arreglos: Lista de hits (continúa)

anexar = new Button("anexar al final");
add(anexar);
anexar.addActionListener(this);
eliminar = new Button("eliminar");
add(eliminar);
eliminar.addActionListener(this);
insertar = new Button("insertar");
add(insertar);
insertar.addActionListener(this);
campoTexto = new TextField("", 10);
add(campoTexto);
addMouseListener(this);
artista = new Artista("Elvis");

boolean resultado = artistas.add(artista);
}

texto = campoTexto.getText();
if (event.getSource() == anexar)
anexar();
if (event.getSource() == eliminar)
eliminar();
if (event.getSource() == insertar)
insertar();
elementoSeleccionado = false;
repaint();
}
public void mouseClicked(MouseEvent event) {

int yCoord = event.getY();
indiceSeleccionado = (yCoord - yInicial) / tamañoIncremento;
elementoSeleccionado = true;
repaint();
}
public void mouseReleased(MouseEvent mouse) {
}
public void mousePressed(MouseEvent mouse) {

}
public void mouseEntered(MouseEvent mouse) {

}
public void mouseExited(MouseEvent mouse) {

}
private void anexar() {

artista = new Artista(texto);
artistas.add(artista);
}
private void eliminar() {

if (elementoSeleccionado)
artistas.remove(indiceSeleccionado);
}
private void insertar() {

artista = new Artista(texto);
if (elementoSeleccionado)
artistas.add(indiceSeleccionado, artista);
}

for (int i = 0; i < artistas.size(); i++) {
artista = (Artista) artistas.get(i);
int x = 20;
int y = tamañoIncremento * i + yInicial;
if (i == indiceSeleccionado &&
elementoSeleccionado)
artista.mostrar(g, x, y, true);
else
artista.mostrar(g, x, y, false);
}
}
}
class Artista {
private int altura = 25, anchura = 75;

private String nombre;
public Artista(String nombre) {

this.nombre = nombre;
}
public void mostrar(Graphics g, int x, int y, boolean seleccionado) {

if (seleccionado) {
g.setColor(Color.lightGray);
g.fillRect(x, y, anchura, altura);
}
else
g.drawRect(x, y, anchura, altura);
g.drawString(nombre, x + 5, y + 20);
}
}
Arreglos de dos dimensiones: un ejemplo
• El programa mantiene un arreglo bidimensional de enteros; estos

representan las ventas de varios artículos en varias tiendas
• Primero se introduce un número en el campo de texto; el usuario hace

click con el ratón en una celda del arreglo para especificar el
componente del mismo que desea modificar
• El programa calcula y muestra el total general de todas las ventas
• El arreglo se visualiza como una cuadrícula formada por rectángulos

dibujados mediante drawRect. La posición de un evento de click del
ratón se obtiene mediante el método mouseClicked como coordenadas
de x e y
Arreglos de dos dimensiones: un ejemplo
import java.awt.*;
public class Ventas extends Applet

implements ActionListener, MouseListener {
private Tabla ventas;

private TextField valor;

ventas = new Tabla(3, 7);
Label l = new Label("Introduzca número y haga click en componente");
add(l);
valor = new TextField(8);
add(valor);
valor.addActionListener(this);
this.addMouseListener(this);
}

ventas.mostrar(g);
}
Arreglos de dos dimensiones: un ejemplo (continúa)

int nuevoValor=Integer.parseInt(valor.getText());
ventas.establecerValor(nuevoValor);
repaint();
}
public void mouseClicked (MouseEvent event){

int x = event.getX();
int y = event.getY();
ventas.seleccionarComponente(x, y);
repaint();
}
public void mouseReleased (MouseEvent e){

}
public void mousePressed (MouseEvent e){

}
public void mouseEntered (MouseEvent e){
}
public void mouseExited (MouseEvent e){

}
}
class Tabla {
private int[][] datos;

private int renglonIndice;
private int colIndice;
private int nuevoValor;
private int suma;
private final int xInicial = 20;

private final int yInicial = 60;
private final int cuadroAltura = 20;
private final int cuadroAnchura = 40;
public Tabla(int renglones, int columnas) {

datos = new int[ renglones][columnas];
for(int renglon = 0; renglon < renglones; renglon++)

for(int col = 0; col < columnas; col++)
datos[ renglon][col] = 0;
}
public void mostrar(Graphics g) {

for(int renglon = 0; renglon < datos.length; renglon++) {
for(int col = 0; col < datos[0].length; col++) {
int x = xInicial + col * cuadroAnchura;
int y = yInicial + renglon * cuadroAltura;
g.drawRect(x, y, cuadroAnchura, cuadroAltura );
g.drawString(Integer.toString(datos[ renglon]
[col]), x, y + cuadroAltura*3/4);
}
}
calcularSuma();
g.drawString("El total es " + suma, 100, 150);
}
public void seleccionarComponente( int x, int y) {
renglonIndice = (y - yInicial)/cuadroAltura;
colIndice = (x - xInicial)/cuadroAnchura;
datos[ renglonIndice][colIndice] = nuevoValor;
}
public void establecerValor(int valor) {

nuevoValor = valor;
}
private void calcularSuma() {
suma = 0;
for (int renglon=0; renglon < datos.length; renglon++)
for (int col = 0; col < datos[0].length; col++)
suma =suma + datos[ renglon][col];
}
}
Manipulación de cadenas: comparación
• Este applet tiene dos cuadros de texto textField como entrada, un

botón “avanzar” y un cuadro de texto textField como salida
• Al hacer click sobre el botón, se llevará a cabo la operación entre las

cadenas
• Hemos evitado que el usuario pueda escribir sobre el cuadro de texto

de salida, con la instrucción campoResultado.setEditable(false);
Manipulación de cadenas: comparación
import java.awt.*;
import java.util.*;
public class StringDemo extends Applet

private TextField cadena1Campo, cadena2Campo;

private TextField resultadoCampo;
Label cadena1Etiqueta, cadena2Etiqueta, resultadoEtiqueta;
Button avanzarBoton;

cadena1Etiqueta = new Label("Introduzca cadena1: ");
cadena2Etiqueta = new Label("Introduzca cadena2: ");
resultadoEtiqueta = new Label("el resultado es: ");
avanzarBoton = new Button("hacerlo");
cadena1Campo = new TextField(20);

cadena2Campo = new TextField(20);
resultadoCampo = new TextField(40);
resultadoCampo.setEditable(false);
add(cadena1Etiqueta);
add(cadena1Campo);
Manipulación de cadenas: comparación (continúa)
add(cadena2Etiqueta);
add(cadena2Campo);
add(avanzarBoton);
avanzarBoton.addActionListener(this);
add(resultadoEtiqueta);
add(resultadoCampo);
}

String resultado ="";
if (event.getSource() == avanzarBoton) {
String cadena1 = cadena1Campo.getText();
String cadena2 = cadena2Campo.getText();
// ejemplo de cadenas - introducir cadena1 y cadena2
//.... inserte aquí su código
if(cadena1.equals(cadena2))
resultado="Son iguales.";
else
resultado="No son iguales.";
// fin de ejemplo
resultadoCampo.setText(resultado);
}
}
}
Manipulación de cadenas: Caso Frasier
• En 1970, Joseph Weizenbaum escribió un programa llamado ELIZA,

para simular un estilo específico de psiquiatra
• Era un programa sencillo, en el sentido de que se esforzaba muy poco

en comprender el sentido de los datos que introducían los usuarios
(pacientes)
• Este programa, ha sido llamado, en una versión más sencilla, Frasier,

en honor a un personaje de la televisión estadounidense
Manipulación de cadenas: Caso Frasier
import java.awt.*;
import java.util.*;
public class PregunteAFrasier extends Applet

private TextField preguntaCampo;

private TextField respuestaCampo;
Label preguntaEtiqueta, psiquiatraEtiqueta;
private Psiquiatra frasier;

preguntaEtiqueta = new Label("Escriba aquí.... ");
psiquiatraEtiqueta = new Label("Frasier dice: ");
add(preguntaEtiqueta);
preguntaCampo = new TextField(40);
add(preguntaCampo);
preguntaCampo.addActionListener(this);
add(psiquiatraEtiqueta);
respuestaCampo = new TextField(40);
respuestaCampo.setEditable(false);
add(respuestaCampo);
respuestaCampo.setText("Continúe, por favor....");
frasier = new Psiquiatra();
}
Manipulación de cadenas: Caso Frasier (continúa)

if (event.getSource() == preguntaCampo) {
String suValor = preguntaCampo.getText();
frasier.hacerPregunta(suValor);
respuestaCampo.setText(frasier.obtenerRespuesta() );
}
}
}
class Psiquiatra {
private String pregunta;
private String respuesta;
private Random valorAleatorio = new Random();
public void hacerPregunta(String p) {

pregunta = " " + p + " ";
}
public String obtenerRespuesta() {

int variacion = valorAleatorio.nextInt() % 3;
switch (variacion) {
case 0: respuesta = transformarPregunta(); break;
case 1: respuesta = "¿Por qué siente eso?"; break;
case 2: respuesta = "¡por favor sea sincero!"; break;
}
return respuesta;
}
private String transformarPregunta() {

if(pregunta.indexOf(" Yo ") >= 0) {
String tempResp = replace (pregunta," Yo ", " tú ");
tempResp = replace(tempResp, " estoy ", " estás ");
return replace(tempResp, " mi "," tu ")+"-¿por qué?";
}
else
if (pregunta.indexOf(" no ") >= 0)
return "¿no? ¡eso es negativo! Por favor explique....";
else
return "\"" + pregunta + "\"-No entiendo..";
}
private String replace(String original, String desde, String hacia) {

String parteIzq, parteDer;
int iniciarBusqueda = 0;
int lugar = original.indexOf(desde);
if(desde.length()!=0) {
while (lugar >= iniciarBusqueda) {

parteIzq = original.substring(0, lugar);
parteDer = original.substring(lugar + desde.length(), original.length());
original = parteIzq + hacia + parteDer;
iniciarBusqueda = parteIzq.length() + hacia.length();
lugar = original.indexOf(desde);
}
}
return original;
}
}

Java

Cargado por

Información del documentohacer clic para expandir la información del documento

Copyright:

Formatos disponibles

Java

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Java

Cargado por

Copyright:

Formatos disponibles

By

Ing. Rodolfo Gallardo-Rosales, M.C.

• Puede utilizarse cualquier editor, por ejemplo, el editor del entorno

• Los programas necesarios (en orden) son los siguientes:

• Escribe en tu editor las siguientes líneas de tu primer programa, que

public class Saludo extends Applet {

• Ahora, compílalo mediante la orden:

• No puede correrse un applet (programa) de Java sólo, así que

• Un nombre adecuado, sería Saludo.html y su contenido HTML

• El visor de applets es un auxiliar muy valioso para probar los applets

• C:\Documents and settings\root\> Appletviewer saludo.html

• Vamos ahora a explicar el programa en Java

• Evidentemente los números no forman parte del programa

• La pieza más importante, y la que es necesario comprender ahora

• El siguiente programa, muestra una línea diagonal en la pantalla.

• El código en HTML para PrimeraLinea.html será

<title> Página Web con applet </title>

• Sólo entenderemos una sección del programa (conocida como

1. public void paint(Graphics g) {

• G es el área donde se va a realizar el grafico,

• El método drawRect tiene parámetros:

• El método drawOval tiene parámetros

• El método drawArc tiene parámetros

• Hay 13 colores estándar

• Y el uso adecuado sería

• Y un método para rellenar figuras

• Veamos el código siguiente:

public class Calculo extends Applet {

longitud = 20; //asignaciones

public class ProbarTriangulo extends Applet {

g.drawLine(inferiorX, inferiorY, inferiorX+base, inferiorY);

public class MetodoTrianguloDemo extends Applet {

private void dibujarTriangulo(Graphics g, int inferiorX,

private void dibujarTriangulo(Graphics g, int inferiorX,

private void dibujarCasa(Graphics g, int inferiorX, int inferiorY,

• Programa para leer un número de una barra de desplazamiento y

• Se requiere escribir el código de Java y guardarlo en un archivo

• Ahora, hacer el PrimerEvento.html para correrlo.

public class PrimerEvento extends Applet

public void init() {

public void paint(Graphics g) {

public void adjustmentValueChanged(AdjustmentEvent e) {

• El siguiente programa, simula una persiana electrónica, al arrastrar la

• Para representar esta configuración, debemos dibujar un rectángulo

• Guardar el programa en un archivo llamado Persiana.java

// Ejemplo de barra de desplazamiento - simulador de persiana

public class Persiana extends Applet

public void init () {

public void paint (Graphics g) {

public void adjustmentValueChanged(AdjustmentEvent e) {

• Se ha estado utilizando “add” para colocar un nuevo componente en la

• El caso es que no podemos saber su posición en píxeles, así que no

• Como alternativa, se puede utilizar un componente etiqueta que

• Simplemente declaramos el componente y lo inicializamos con texto

public class EtiquetaDemo extends Applet

public void init() {

public void paint(Graphics g) {

public void adjustmentValueChanged(AdjustmentEvent e) {

• Consideremos el problema de convertir un número de pulgadas (en la