- Herencia
La herencia es una
de las características fundamentales de la POO, ya que es
la que permite un gran aumento en la reutilización de
código.
La posibilidad de crear nuevas clases basadas en otras
pre-existentes permite, entre otras cosas, crear bibliotecas
genéricas, en base a las cuales realizar pequeños
ajustes para adaptarlas a las necesidades puntuales de cada
aplicación.
Para crear una clase basada
en una pre-existente se utiliza la siguiente sintaxis:
class SubClase extends SuperClase
{
}
Una subclase hereda todos los métodos y
propiedades que le provee su superclase y puede utilizarlos como
propios.
Una superclase puede ser a su vez subclase de otra y
así se estructura una
jerarquía de clases, donde hacia abajo aumenta la
especialización y hacia arriba la generalidad.
Ejemplo:
En este caso, todos los animales tienen,
por ejemplo, un método
comer, todos los mamíferos un método mamar y
todas las aves un
método volar. Aquí el mecanismo de herencia
permite desarrollar una sola vez los métodos de son
comunes a todas las subclases y sólo programar en
éstas aquellas características que las diferencian
de sus pares.
Se considera que una instancia de una subclase es
también instancia de toda superclase de la misma, en el
ejemplo, todo perro es un mamífero y
también un animal, lo cual implica que todo perro
tiene todas las propiedades y métodos propias de los
mamíferos, así como también aquellas de los
animales.
De este modo, una clase puede utilizar métodos
que no tiene definidos de la misma forma en que utilizaría
los propios:
class SuperClase
{
protected int unMetodo()
{
return 1;
}
}
class SubClase extends SuperClase
{
public void otroMetodo()
{
System.out.println( unMetodo() );
}
}
A su vez, una subclase podría optar por
reemplazar algún método heredado de una superclase,
para especificar un comportamiento
diferente. Por ejemplo, todos los animales comen, pero para un
perro no significa lo mismo comer que para un gato.
En Java, todas las
clases automáticamente heredan de una clase llamada
Object, la cual provee ciertos métodos, entre ellos
toString(), un método que muestra la
representación en una cadena de caracteres del objeto en
cuestión y que generalmente es una buena idea
sobrescribir.
Si una subclase oculta (sobrescribe) un método de
su superclase, aún puede querer en algún caso
utilizar el original. Para lograr este objetivo se
usa la palabra clave super.
Ejemplo:
Programa que crea un objeto llamando persona, el cual
lee e imprime el nombre y edad de una persona.
1 class Persona{
2 public
String Nombre;
3
public int edad;
4
5 public Persona(String nom,
int x)
6 {
7 Nombre=nom;
8 edad=x;
9 }
10
11 }
1 //clase
que se deriva de Persona
2 class
Persona2 extends
Persona{
3
public double sueldo;
4 public Persona2(String nom,
int x, double sal)
5 {
6 super(nom, x);
7 sueldo=sal;
8 }
1 //clase
que implementa la Clase Persona2
2 class
UsaPersona2{
3
public static void
main(String args []) {
4 Persona2 Jefe=new Persona2("Manuel", 20,
563.99);
5
System.out.println("Nombre:
"+Jefe.Nombre+"nEdad:
"+Jefe.edad+"nSueldo:
"+Jefe.sueldo);
6 }
7 }
La sentencia super lo que hace es llamar al constructor
de la superclase (clase de la que heredamos). En la función
principal es donde se crea el objeto que llama al miembro
constructor, al cual hay que pasar 3 valores (uno
para la clase punto2 y dos para la clase punto).
Preguntas
- ¿Qué es una
interfaz?____________________________________________________________________________________________ - ¿Para que sirven los
Paquetes?________________________________________________________________________________________________________________________ - Mencione dos razones por las cuales son importantes
las
interfaces:_______________________________________________________________________________________________________________________ - ¿cuál es la diferencia entre una
interfaz y la
herencia?________________________________________________________________________________________________________________________ - ¿Para que sirve la
herencia?________________________________________________________________________________________________________________________
Descubre el error
class punto{
private int x , y;
private punto(int a, int b){x=a;y=b;}
}
class punto2 extend punto{
int z;
punto2(int a, int b, int c)
{
super(a,c);
z=c;
}
}
class principal{
publis static void main(String args[]){
int a=10, b=20,c=30;
punto2 p=new punto(a,b,c);
system.out.println("objeto creado");
system.out.println(p.x+" "+p.y+" "+p.z);
}
}
/******************
Interfeces*****************/
class MiOtraClase implemens MiInterface
{
void miMetodo()
{
system.out.println("Chau mundo!");
}
}
Ejercicios
- Diseñe un programa, que
reciba como parámetros dos cadenas e indique con un
mensaje si son iguales. - Diseñe una clase (usando las interfaces) que,
indique si un nombre es válido o No. Para que un nombre
sea válido debe iniciar con mayúscula. Ejemplo:
Manuelà es un nombre
propio válido. Manuelà NO es un nombre propio
válido. - Desarrollar una clase ModificadorCadenas, la
cual tenga un método que reciba una cadena de caracteres
y dos letras y reemplace todas las apariciones de la primera
letra por la segunda. Crear una aplicación Java que
reciba como parámetro una cadena de caracteres y dos
caracteres y emita un mensaje conteniendo el reemplazo de todos
las apariciones del primer caracter por el segundo. - Crear una clase llamada Clase1 la cual pertenezca al
paquete paquete1 y tenga un método llamado mostrarHola,
el cual muestre por pantalla el mensaje "Hola". Desarrollar
otra clase llamada Clase2 la cual pertenezca al paquete
paquete2 y tenga un método main, el cual cree una
instancia de Clase1 y ejecute su método
mostrarHola. - Basándose en la aplicación anterior,
crear otra clase llamada Clase1a la cual contenga un
método mostrarChau, el cual muestre por pantalla el
mensaje "Chau" pero que no sea pública.
¿Qué pasa al intentar instanciarla desde la
Clase2?.Agregar un método a la clase Clase1 para que
permita utilizar la clase Clase1a. - Se desea controlar la cantidad de clientes que
una empresa
posee y la mora de los mismos. Para lo cual se le solicita que
cree una aplicación en Java, la cual contenga un arreglo
de n referencias a n objetos. Los objetos contienen información como: nombre del cliente, monto
de la deuda, Interés
(I=Monto*tasa*tiempo).
Para ello se le pide que utilice la Herencia de
Java. - Cree una clase, llamada Circulo, la cual, implementa
una interfaz llamada Figura(), y prueba en otra clase llamada
UsaCirculo, y permita visualizar el perímetro, el Area y
el volumen del
mismo. Además que la clase circulo, esté
sobrecargado con dos constructores. Y además en la clase
circulo, debe existir un método de establecer radio y
establcer perímetro. NOTA: todos los atributos son de
acceso privado.
Capítulo IX: Hilos
Los procesadores y
los Sistemas
Operativos modernos permiten la multitarea, es
decir, la realización simultánea de dos o
más actividades (al menos aparentemente). En la realidad,
un ordenador con una sola CPU no puede
realizar dos actividades a la vez. Sin embargo los Sistemas
Operativos actuales son capaces de ejecutar varios programas
"simultáneamente" aunque sólo se disponga de una
CPU: reparten el tiempo entre dos (o más) actividades, o
bien utilizan los tiempos muertos de una actividad (por
ejemplo,
operaciones de lectura de
datos desde el
teclado) para
trabajar en la otra. En ordenadores con dos o más
procesadores la multitarea es real, ya que cada procesador puede
ejecutar un hilo o thread diferente.
La Figura tomada del Tutorial de Sun,
muestra los esquemas correspondientes a un programa con uno o dos
hilos.
Los métodos de la clase Thread:
currentThread: Representa al hilo que esta
ejecutándose en ese momento.
yield: Asegura que los hilos de menor prioridad no
sufran inanición.
sleep: Pone a dormir al hilo en curso durante n
milisegundos.
start: Crea un hilo de sistema y
ejecuta. Luego llama al método run.
run: Es el cuerpo del hilo. Es llamado por el
método start.
stop: Provoca la destrucción del
hilo.
suspend: Detiene el hilo, pero no lo destruye. Puede
ejecutarse de nuevo.
resume: Para revivir un hilo suspendido.
setName: Asigna un nombre al hilo en curso.
getName: Devuelve el nombre del hilo en
ejecución.
setPriority() Establece la prioridad del hilo. De 1 a
10.
getPriority: Devuelve la prioridad del hilo en
curso.
Ejemplo 9.1
1 public class
ContadorAdelante extends Thread {
2 public
ContadorAdelante(String nombre) // constructor
3 {
4 if (nombre
!= null)
5 setName(nombre);
6 start(); //el hilo ejecuta su propio método
run
7 }
8
9 public
ContadorAdelante() { this(null); } //
constructor
10
public void run()
11 {
12 for
(int i=1;
i<=1000; i++)
13
System.out.print(getName() + "
"+i+"r");
14 System.out.println();
15 }
16 }
1 public class
TestHilo
2
{
3 public static
void main(String
[]args)
4
{
5
ContadorAdelante cuentaAdelante = new
6
ContadorAdelante("Contador+");
7 }
8 }
El operador new crea un hilo cuentaAdelante (el hilo
está en el estado
nuevo). El método start cambia el estado del
hilo a preparado. De ahora en adelante y hasta que finalice la
ejecución del hilo cuentaAdelante, será el
planificador de hilos el que determine cuando éste pasa al
estado de ejecución y cuando lo abandona para permitir que
se ejecuten simultáneamente otros hilos.
El método start no hace que se ejecute
inmediatamente el método run del hilo, sino que lo
sitúa en el estado preparado para que compita por la UCP
junto con el resto de los hilos que haya en este estado. Solo el
planificador puede asignar tiempo de UCP a un hilo y lo
hará con cuentaAdelante en cualquier instante
después de que haya recibido el mensaje start. Por lo
tanto, un hilo durante su tiempo de vida, gasta parte de
él en ejecutarse y el resto en alguno de los otros
estados.
Lo que no se debe hacer es llamar directamente al
método run; esto ejecutaría el código de
este método sin que intervenga el planificador. Quiere
esto decir que es el método start el que registra el hilo
en el planificador de hilos.
Ejemplo 9.2
Dos hilos se crean utilizando el método
setPriority con dos niveles de prioridad distintos. Se inician
ambos y se les permite la ejecución durante 10 segundos.
Cada hilo gira en torno a un bucle
que cuenta cuantas veces se ejecuto el mismo.
class pulso implements Runnable{
int pulsa=0;
private Thread hilo;
private boolean corre=true;
public pulso(int p){
hilo=new Thread(this);
hilo.setPriority(p);
}
public void run(){
while(corre){
pulsa++;
}
}
public void stop(){
corre=false;
}
public void start(){
hilo.start();
}
}
class hilos{
public static void main(String args[]){
Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
pulso h1=new pulso(Thread.NORM_PRIORITY+2);
pulso h2=new pulso(Thread.NORM_PRIORITY-2);
h1.start();
h2.start();
try{Thread.sleep(10000);}
catch(Exception e){}
h1.stop();
h2.stop();
System.out.println(h1.pulsa+" contra
"+h2.pulsa);
}
}
Preguntas
- ¿Qué es y para que sirve un
Hilo?________________________________________________________________________________________________________ - Mencione dos características de los
Hilo:__________________________________________________________________________________________________________________ - ¿Cuál es la diferencia entre un Hilo y
un proceso?_________________________________________________________________________________________________________________________________________________________________________ - Mencione cuales son los métodos más
importantes de un
Hilo:__________________________________________________________________________________________________________________
Descubra el Error
En el siguiente programa se genera un número
aleatorio, que será el retardo de cada hilo. Por tanto
según el número generado saldrá primero uno
y luego el otro en orden aleatorio.
import java.util.*;
class hilos extends Thrad{
int tiempo;
String nombre;
public hilo(String nomb,int tempo){
tiempo=tempo;
nombre=nomb;
}
public void run(){
try{slep(tiempo);}
catch(Exception e){
System.out.println("Error");
}
System.out.println("Hilo: "+nombre+" Temp:
"+tiempo);
}
Publid static void main(String args[]){
hilos h1=new
hilos("Uno",(int)(Math.random()*2000));
hilos h2=new
hilos("Dos",(int)(Math.random()*2000));
h1.stat();
h2.stat();
}
}
Capítulo X: Elementos Gráficos en Java
Estamos a punto de iniciar uno de los aspectos
más llamativos de Java, como lo es la parte
gráfica, el tratamiento de imágenes…
En muchas páginas
web, nos llaman la atención las animaciones, sonidos, y
aspectos gráficos de las mismas. Y muchos de esos efectos
han sido creados en Java, o al menos la base de los
mismos.
10.1 Imágenes en Applets
Para poder hacer
uso de las imágenes debemos tener en cuenta dos cosas. La
primera es que haremos uso de la clase Image, que pertenece al
paquete java.awt.
Creación del Objeto:
Para crearlo, se procede de la misma manera en la que
creamos cualquier variable de los tipos primitivos de
Java.
Image img1;
Localizar la Imagen
Es la ruta del documento web desde el cual
se cargará la imagen que
deseamos mostrar, y esto se hace mediante la
instrucción:
getDocumentBase()
Para cargar la imagen
Este método debe ir dentro del método init
de un Applet, además que, debe tener como argumento la
dirección de la imagen (getDocumentBase())
y el nombre de la misma.
Img1= getImage(getDocumentBase(),"t2.gif");
Para Mostrar La Imagen
Lo hacemos dentro del método paint de un
applet. Y es de la siguiente forma:
g.drawImage(img1,20,20,this);
Ejemplo 10.1
Programa que carga una imagen llamada t2.gif, la cual
está guardada dentro de la misma carpeta en la que se
encuentra el archivo de
java.
1 import java.awt.*;
2 import
java.applet.*;
3
4 public class imagen extends Applet{
5
6 Image img1;
7
8 public
void init(){
9
img1=getImage(getDocumentBase(),"t2.gif");
10 }
11
12 public
void paint(Graphics
g){
13
g.drawImage(img1,20,20,this);
14 }
15 }
Ejemplo 10.2
Muestra una serie de imágenes en movimiento.
Ideal para crear animaciones.
1 import java.awt.*;
2 import
java.applet.*;
3
4 public class move extends Applet implements Runnable {
5 Image
tabla[]=new
Image[3];
6
Image img_pintar;
7 Thread pasos;
8
9 public
void
init(){
10
setBackground(Color.white);
11
tabla[0]=getImage(getDocumentBase(),"t3.gif");
12
tabla[1]=getImage(getDocumentBase(),"t4.gif");
13
tabla[2]=getImage(getDocumentBase(),"t5.gif");
14 }
15
16 public void
start() {
17
pasos = new
Thread(this);
18 pasos.start();
19 }
20
21 public void run() {
22 for(;;){
23
24 //se puede hacer
un bucle
25
//para evitar estas
líneas
26
//de
código.
27
28 img_pintar = tabla[0];
29 repaint();
30 pausa(500);
31
32 img_pintar = tabla[1];
33 repaint();
34 pausa(500);
35
36 img_pintar = tabla[2];
37 repaint();
38 pausa(500);
39 }
40 }
41
42 public
void paint(Graphics
g){
43
g.drawImage(img_pintar,10,10,this);
44 }
45
46 void
pausa(int tempo)
{
47
try
{Thread.sleep(tempo);}
48 catch (InterruptedException e)
{}
49
}
50
}
Ejemplo 10.3
Muestra la impresión de una imagen en diferentes
tamaños.
1 import java.awt.*;
2 import
javax.swing.*;
3
public class DiferentesTamanos
xtendí
Japplet{
4
Image imagen;//declaracion del
objeto
5
public void init()
6 {
7 imagen=getImage(getCodeBase(),
"warning.gif");
8 }
9 public void
paint (Graphics g)
10 {
11 int
ancho=imagen.getWidth(this);
12 int
alto=imagen.getHeight(this);
13 int pos=10;
14
15 //impresion del 25%
16 g.drawImage(imagen, pos, 10,
ancho/4, alto/4, this);
17 //impresion del 50%
18 pos+=ancho/4
+15;
19
g.drawImage(imagen, pos, 10, ancho/2, alto/2, this);
20
21 //impresion del 100 %
22
pos+=ancho/4+15;
23
g.drawImage(imagen, pos, 10, this);
24 //impresión del 150%
25
pos+=ancho/4+15;
26
g.drawImage(imagen, 10, ancho+30,(int)(ancho*1.5), alto/4,
this);
27 }//del
paint
28
}//de la clase
10.2 Elementos de Una Interfaz Gráfica en
Java
Particularmente creo que, esta parte, es una de las
cosas más interesantes que Java nos puede presentar, el
uso de elementos gráficos que son atractivos al ojo humano
y que, provocan sorpresa al usuario.
Debemos decir que, una Interfaz Gráfica de
Usuario (O mejor conocida como GUI, por sus siglas en inglés:
Graphical User Interface). Y lo que constituye es como un
elemento intermediario, entre el programa (y la ejecución
de las instrucciones) con el usuario. Ya que, el usuario, puede
observar una ventanita en la cual se le pida que ingrese sus
datos personales, y al dar hacerlo y dar clic sobre un
botón, estos pueden ser impresos (por ejemplo), la forma
en la que el programa manda a imprimir esos datos, es invisible
para el usuario, sin embargo, el puede realizar esas acciones,
gracias a los elementos contenidos en la ventanita, que
constituye la interfaz.
La GUI se constituye a partir de componentes de GUI, los
cuales a su vez se deben encontrar en un contenedor. Un
Componente es un elemento visual con el cual el usuario
puede interactuar a través del ratón o el teclado;
mientras que un contenedor, es un área visual, en la cual
se encuentran los componentes.
Ejemplo de Componentes:
à Rótulo: es
un área en la cual se puede colocar texto NO
editable.
à Botón: Es
un área que dispara un evento al dar clic sobre
él.
à Lista: Es un
área en la cual se exhiben una serie de
elementos.
à Campo de Texto:
Es un área en la cual el usuario puede ingresar
información mediante el teclado.
Las clases que vamos a usar para crear los componentes,
forman parte del paquete java.awt.
PORCIÓN DE LA JERARQUIA DE JAVA.AWT
(tomado de "Java como Programar". Deitel y
Deitel)
Toda clase que hereda de la clase Component es un
componente.
Cualquier clase que hereda de la clase Container es un
contenedor. Un contenedor es un área en la que podemos
colocar componentes.
Rótulos
Como Ya se dijo, en los rótulos podemos colocar
texto no editable.
Un rótulo se crea a partir de la clase Label.
Dicha clase tiene dos constructores:
Public Label();
El cual construye un rótulo vacío que no
exhibe ningún texto.
Public Label (String S);
El cual construye un rótulo con el texto
S.
Métodos:
public String getText()
Devuelve el texto del rótulo.
public void setText( String s)
Fija el texto del rótulo
Ejemplo 10.4
Muestra el uso de los Labels
1 import java.awt.*;
2 import
javax.swing.*;
3
public class UsaLabel extends JApplet {
4 Label rotulo1, rotulo2,
rotulo3;
5
6 public void
init()
7
{
8 //inicializamos los rótulos
9
rotulo1=new
Label();//rotulo
vacío
10
rotulo2=new
Label("Este es un
Rótulo");
11 /*ahora
debemos agregar estos componentes al
12 contenedor, lo que se
hace mediante la
13
instrucción
add*/
14
add(rotulo1);
15
add(rotulo2);
16
17
}//del
init
18
}//del Applet
Botones
Los Botones disparan un evento (acción), cuando son accionados (al dar un
clic sobre él).
Los botones se construyen mediante la Clase
Button:
Public Button(); //Crea un Botón sin
rótulo
Public Button(String S); //Crea un Botón con el
rótulo S
Para asociar los controles como botones, listas,
casillas, etc… a un método debemos implementar el
método action. En dicho método deberemos escribir
las acciones que van a realizar cada uno de los controles que
tengamos en el applet, teniendo en cuenta lo
siguiente.
El método action recibe dos parámetros, el
primero es un objeto de la clase Event que recoge el evento
producido en el applet. El segundo es un objeto de la clase
Object que recoge cual a sido el control que a
producido la acción.
Con estos dos objetos lo primero que debemos escribir en
el método action son sentencias if para determinar el tipo
de control que a producido la acción (línea
1). Si hay más controles del mismo tipo,
deberemos distinguir uno de otro con más sentencias if
dentro de cada if que gestiona el tipo de control
(línea 2). Por último, cada uno de
estos if deben llevar una sentencia return true para indicar que
todo ha ido bien (lineal). Al final del
método se debe incluir la sentencia return false para no
hacer nada en caso de que la acción realizada no tenga
interés para nuestra aplicación (línea
4).
public boolean action(Event nombre_ev, Object
nombre_obj)
{
(1)if (nombre_ev.target instanceof
Button)
{
(2) cuerpo con if para cada uno de ese
tipo;
(3) return true;
}
(4)return false;
}
Ejemplo 10.5
Muestra como usar los botones.
1 //creacion de botones para pulsar
2 import java.awt.*;
3 import
java.applet.Applet;
4 public
class MisBotones
extends Applet
5 {
6 private
Button boton1, boton2, boton3;
7 public
void init()
8 {
9 boton1 = new Button("Pulse aqui");
10 boton2 = new Button("Yo no hago nada");
11 boton3 =
new Button("Sin rotulo");
12 //agregar
botones
13
add(boton1);
14
add(boton2);
15
add(boton3);
16
}
17 //manejar los eventos de
boton
18 public boolean
action (Event e, Object o)
19 {
20 //verificar si un boton
disparo el evento
21
if (e.target
instanceof Button)
{
22 //comprobar si se pulso boton1 o boton2
23 //no se
hara nada si se pulso boton2
24 // En o se guarda el
nombre del boton que se pulsó
25 if
(e.target == boton1)
26 showStatus ("Usted pulso: "+ o.toString());
27 else
if (e.target ==
boton3)
28
showStatus ("Usted pulso:
"+ e.arg);
29 return
true; //el evento se manejo aqui
30 }
31 return
true;
32 }
33 }
Campos de Texto
TextField implementa un área de entrada de texto
de una sola línea. Todo aquello que escribimos en una caja
de texto es de tipo String por tanto si queremos realizar
operaciones
matemáticas deberemos transformarlo a un
valor
numérico.
CREACIÓN:
TextField nombre_objeto=new TextField(ancho);
add(nombre_objeto);
POSICIONAMIENTO:
nombre_objeto.reshape(x,y,ancho,alto);
GUARDAR TEXTO: valido para
etiquetas.
variable=nombre_objeto.getText();
MOSTRAR TEXTO: valido para
etiquetas.
nombre_objeto.setText(variable);
Ejemplo 10.6
1 import
java.awt.*;
2
import
javax.swing.*;
3
public class Contrsena extends JApplet {
4 Label rotulo;
5 Button boton1;
6 TextField text1;
7 public
void init()
8 {
9 rotulo=new Label("Ingrese su
contraseña");
10 text1=new TextField(10);
11 boton1=new Button("Aceptar");
12
13 add(rotulo);
14 add(text1);
15 add(boton1);
16 }
17 public
boolean action ( Event e,
Object o)
18
{
19 if(e.target instanceof Button)
20 if(e.target==boton1)
21
{
22 String
password=text1.getText();
23 if(password.equals("Carolina"))
24
JOptionPane.showMessageDialog(null, "Contraseña
Correcta");
25 else
26
JOptionPane.showMessageDialog(null, "Contraseña
Incorrecta");
27 }
28 return
true;
29 }
30 }
31
32
LISTAS
Mediante la clase List crearemos el objeto. Este tipo de
lista puede admite más de una selección,
el orden de sus elementos es según han sido
añadidos. Los miembros son los mismos que en el control
anterior solo cambia el modo de construirlos. En este control
aparecen unas barras de desplazamiento verticales
automáticamente.
CREAR:
List nombre_objeto=new List(0,true); múltiple
selección.
List nombre_objeto=new List(0,false); selección
simple.
EJEMPLO:
import java.awt.*;
import java.applet.*;
public class lista extends Applet{
Label eti1=new Label("",Label.LEFT);
Label eti2=new Label("",Label.LEFT);
Button mira=new Button("Mostrar");
List lista=new List(0,true);
public void init(){
setLayout(null);
add(eti1);
add(eti2);
add(mira);
add(lista);
eti1.reshape(120,10,40,50);
eti2.reshape(160,10,40,50);
mira.reshape(10,90,75,40);
lista.reshape(10,10,100,75);
lista.addItem("Uno");
lista.addItem("Dos");
lista.addItem("Tres");
lista.addItem("Cuatro");
lista.addItem("Cinco");
lista.addItem("Seis");
}
public boolean action(Event evento,Object
obj)
{
if (evento.target instanceof Button)
{
int num=lista.getSelectedIndex();
String cad1=lista.getSelectedItem();
String cad2=String.valueOf(num);
eti1.setText(cad2);
eti2.setText(cad1);
return true;
// int num1=lista.countItems();
// String cad2=String.valueOf(num1);
// eti1.setText(cad2);
}
return false;
}
}
Preguntas
- ¿Que es la GUI y para que
sirve?__________________________________________________________________________________________________________________________ - En que se diferencian las cajas de texto con las
Etiquetas?_______________________________________________________________________________________________________________________ - ¿Que ocurre cuando se da clic sobre un
botón?__________________________________________________________________________________________________________________________ - Dos Botones, ¿pueden tener el mismo nombre?,
¿y el mismo rótulo? ¿Por
qué?____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________ - Menciones los pasos para presentar una imagen en un
Applet:__________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Descubre el error
TextField caja_texto= TextField(10);
label etiqueta=new Label(" ",)
String nombre;
public void init(){
setLayout(null);
Button boton=new Button(Cambiar);
add(caja_texto);
add(Etiqueta);
add(boton);
caja_texto.reshape(10,10,20);
etiqueta.reshape(70,10,20);
boton.reshape(10,50,30)
Ejercicios
- Diseñe un Applet que al presionar un
botón muestre una imagen y al presionar otro
botón, muestre otra imagen a la per de la
anterior. - Diseñe Un Applet que, al ingresar su nombre,
lo dibuje, pero al revés, esto, al accionar un
botón. - Se desea saber la equivalencia de grados Celsius a
Fahrenheit y viceversa, para lo cual se le pide que cree un
Applet que dados los grados muestre su respectivo
equivalente. - Diseñe un contenedor que, posea una Caja de
texto en la cual usted pueda ingresar una cadena, la cual al
accionar un botón, pueda copiar ese texto en una
etiqueta.BIBLIOGRAFÍA
1. "Java como programar". Deitel y Deitel. 5º
edición, Person Education
20042. "Programación en Java", Mora
Rodríguez, Frank.Año: 2006http://www.lawebdelprogramador.com
3. "Aprenda Java como si estuviera en
Primero".García de Jalón, Javier.
Rodríguez, José Ignacio.y otros. Escuela
Superior de Ingenieros Industriales. Universidad de Navarra. Marzo, 19994. "Teach Yourself Java 2 In 21 Days". Doherty,
Donald. Manning, Michelle.Sams Publishing. Año 1998
5. "Introducción a Java". Chojrin, Mauro.
Año 2006 - Cree una galería de imágenes (por lo
menos 5), en una carpeta gurde las respectivas imágenes.
Luego en una lista, coloque los nombres de dichas
imágenes, para que el usuario al dar clic sobre el
nombre de una de ellas pueda verla en el fondo de un
Applet. - Guiones de Clases. Inga. MSc. Patricia Haydeè
Estrada de López. Programación III Ciclo II/2006.
Falcultad de Ingeniería y Arquitectura.
Universidad de El Salvador
DEDICATORIA
A mi madre, mis hermanos y a todos aquellos que siempre
me animan y se interesan por lo que hago.
Por
Manuel Ortez
San Salvador, El Salvador. Diciembre de 2006
 Página anterior | Volver al principio del trabajo | Página siguiente  |