public class UnaClase

{
public int a;
public static int metodo()
{
UnaClase uc = new UnaClase();
// ... Aquí haríamos que uc.a tuviese el valor adecuado
return uc.a + 1;
}
}
Nota
Para hacer referencia a un elemento estático utilizaremos siempre el nombre de la clase a la que
pertenece, y no la referencia a una instancia concreta de dicha clase.
Por ejemplo, si hacemos lo siguiente:
Lenguaje Java Avanzado
14
Copyright © 2012-2013 Dept. Ciencia de la Computación e IA All rights reserved.
UnaClase uc = new UnaClase();
uc.metodo();
Aparecerá un warning, debido a que el método metodo no es propio de la instancia
concreta uc, sino da la clase UnaClase en general. Por lo tanto, deberemos llamarlo con:
UnaClase.metodo();
1.3.9. Imports estáticos
Los imports estáticos permiten importar los elementos estáticos de una clase, de forma
que para referenciarlos no tengamos que poner siempre como prefijo el nombre de la
clase. Por ejemplo, podemos utilizar las constantes de color de la clase java.awt.Color,
o bien los métodos matemáticos de la case Math.
Ejemplo
import static java.awt.Color;
import static java.lang.Math;
public class...
{
...
JLabel lbl = new JLabel();
lbl.setBackground(white); // Antes sería Color.white
...
double raiz = sqrt(1252.2); // Antes sería Math.sqrt(...)Dará error, porque el
campo a no es estático, y lo estamos utilizando dentro del método
estático. Para solucionarlo tenemos dos posibilidades: definir a como estático (si el diseño
del programa lo permite), o bien crear un objeto de tipo UnaClase en el método, y utilizar
su campo a (que ya no hará falta que sea estático, porque hemos creado un objeto y ya
podemos acceder a su campo a):el elemento a añadir no estaba en el conjunto y ha sido
añadido, o false si el elemento ya se
encontraba dentro del conjunto. Un conjunto podrá contener a lo sumo un elemento
null.
Los conjuntos se definen en la interfaz Set , a partir de la cuál se construyen diferentes
implementaciones: HashSet Los objetos se almacenan en una tabla de dispersión
(hash).
El coste de las operaciones básicas (inserción, borrado, búsqueda) se realizan en
tiempo
constante siempre que los elementos se hayan dispersado de forma adecuada. La
iteraciónConjuntos
Los conjuntos son grupos de elementos en los que no encontramos ningún elemento
repetido. Consideramos que un elemento está repetido si tenemos dos objetos o1 y
o2
iguales, comparandolos mediante el operador o1.equals(o2). De esta forma, si el
objeto a
insertar en el conjunto estuviese repetido, no nos dejará insertarlo. Recordemos que
el
método add devolvía un valor booleano, que servirá para este caso, devolviendonos
true si
el elemento a añadir no estaba en el conjunto y ha sido añadido, o false si el elemento
ya seExtrae el primer / último elemento de la lista respectivamente, devolviéndonos
dicho objeto
y eliminándolo de la lista. Hemos de destacar que estos métodos nos permitirán
trabajar
con la lista como si se tratase de una pila o de una cola. En el caso de la pila
realizaremos
la inserción y la extracción de elementos por el mismo extremo, mientras que para la
cola
insertaremos por un extremo y extraeremos por el otro.Añade el objeto indicado al
principio / final de la lista respectivamente.
Object getFirst() / Object getLast()
Obtiene el primer / último objeto de la lista respectivamente.
Object removeFirst()lista _O(n), siendo _n _el tamaño de la lista. Para aprovechar las
ventajas que tenemos en
el coste temporal al trabajar con los extremos de la lista, se proporcionan métodos
propios
para acceder a ellos en tiempo constante:
void addFirst(Object obj) / void addLast(Object obj)Label JLabel Etiqueta. Es una cadena de texto como
componente.
List JList
Un componente que contiene un conjunto dinámico de
elementos.
Menu JMenu
Es un elemento dentro de la barra de menú, el cual
contiene un conjunto de elementos de tipo menú.
MenuItem JMenuItem Un elemento dentro de un menú.Component
Es el padre de todos los componentes AWT, excepto de
los componentes de tipo menú
Container Es el padre de todos los contenedores
Dialog JDialog
Es un cuadro de diálogo oon una ventana con titulo y
bordes.
Frame JFrame
Es un marco o ventana y es la clase base de todas las
ventanas GUI con controles para ventana.Button JButton Es un botón usado para
recibir el clic del ratón
Canvas Un lienzo o panel usado para dibujar
Checkbox JCheckBox
Cuadro de verificación. Es un componente que le
permite seleccionar un elemento
Choice JComboBox Es una lista desplegable de elementos estáticos.En los lenguajes
de Programación Orientada a Objetos como Java tenemos dos
paquetes o conjuntos de clases principales agrupados en el paquete
llamado AWT
(Abstract Windows Tolkit) y en el paquete SWING, algunos de estos
componentes
del paquete AWT y del SWING están resumidos en la siguiente tabla 11-
1:los contenedores y
los componentes. Un componente, también denominado componente
simple o
atómico, es un objeto que tiene una representación gráfica, que se
puede mostrar en
la pantalla y con la que puede interactuar el usuario. Ejemplos de
componentes son
los botones, campos de texto, etiquetas, casillas de verificación, menús,
etc.,.Los componentes
Los componentes son clases de objetos que permiten utilizar elementos
gráficos para
crear interfaces gráficas y están divididos en dos grandes grupos:por lo
tanto si se van a
utilizar componentes SWING, debe programar exclusivamente en el nuevo
modelo, o dicho de otro
forma, se recomienda al programador construir programas GUI mezclando lo
menos posible
SWING con AWT.Los componentes Swing no soportan el modelo de Eventos de
Propagación, sino solamente el
modelo de eventos de Delegación incluido desde la versión JDK 1.1;Las etiquetas
de información o “tool tips”, se pueden crear con una sola
línea de código. Además, con SWING la apariencia de la aplicación se adapta
dinámicamente al
sistema operativo y plataforma en que esté corriendo.Hay muchas ventajas que
ofrece el SWING. Por ejemplo, la navegación con el teclado es
automática, cualquier aplicación SWING puede utilizarce sin ratón, sin tener que
escribir una línea
de código adicional.componentes, todos ellos lightweight, es decir, ya no se usan
componentes peer dependientes del
sistema operativo, ademas, SWING está totalmente escrito en Java. Todo esto
conlleva una
mayor funcionalidad en manos del programador, y en la posibilidad de mejorar en
gran médida la
apariencia cosmética de las interfaces gráficas de usuario.Cuando se empieza a
utilizar SWING, se observa que Sun ha dado un paso importante adelante
respecto al AWT. Ahora los componentes de la interface gráfica son Beans y
utilizan el nuevo
modelo de Delegación de Eventos de Java. Swing proporciona un conjunto
completo detecla de enter en un botón, mover un elemento con las teclas de
navegación, eventos especiales
como los programados por tiempo, etc. Sin los eventos las GUI serían interfaces
gráficas sin vida,
y por lo tanto no serían muy útiles que digamos.Eventos. Son las clases o
interfaces que permiten crear objetos que capturen y manejen los
eventos. Un evento es una acción sobre algún componente, por ejemplo, clic a un
botón, pulsar laLayouts. Son clases o interfaces que permiten crear objetos de
que administren el diseño, la
distribución y colocación de los objetos componentes dentro de los objetos
contenedores. Por
ejemplo el FlowLayout distribuye los componentes de izquierda a derecha y de
arriba a abajo, el
BorderLayout los distribuye en cinco áreas geográficas; norte, sur, este, oeste y
centro, etc.Contenedores. Son clases o interfaces que permiten crear objetos
gráficos para contener a los
componentes, tales como; paneles, cuadros de diálogo, marcos, ventanas,
etc.Componentes. Son clases o interfaces que permiten crear los objetos gráficos que
componen una GUI
tales como;botones, listas desplegables, cuadros de texto, casillas de verificación,
botones de opción,
campos de texto, etiquetas, menús, etc.Una estrategia para estudiar las AWT es
dividirlas en :
 Componentes
 Contenedores
 Layouts ( Administradores de diseño )
 EventosLas AWT y SWING proveen componentes básicos para una GUI
(Graphics User Interface -
Interface Gráfica de Usuario) y son utilizados en las aplicaciones y los applets de
Java. Una de
las ventajas de usar AWT es que la interface es independiente de la plataforma o
interface gráfica
de la máquina. Esto nos asegura que lo que se vea en una computadora
aparecerá igual en otra
computadora.Punteros this y super
El puntero this apunta al objeto en el que nos encontramos. Se utiliza normalmente
cuando hay variables locales con el mismo nombre que variables de instancia de
nuestro
objeto:Con esto automáticamente Pato tomaría todo lo que tuviese Animal (aparte, Pato
puede
añadir sus características propias). Si Animal fuese una clase abstracta, Pato debería
implementar los métodos abstractos que tuviese. Herencia e
interfaces
Herencia
Cuando queremos que una clase herede de otra, se utiliza al declararla la palabra
extends
tras el nombre de la clase, para decir de qué clase se hereda. Para hacer que Pato
herede
de Animal :Dentro pondremos el código que queramos ejecutar desde esa clase. Hay
que tener en
cuenta que main es estático, con lo que dentro sólo podremos utilizar campos y
métodos
estáticos, o bien campos y métodos de objetos que creemos dentro del main
.Ejecución de clases: método main
En las clases principales de una aplicación (las clases que queramos ejecutar) debe
haber
un método main con la siguiente estructura:
Introducción al lenguaje Java
29que ya se utilizan para la herramienta Javadoc. Las marcas @deprecated no afectan al
comportamiento de los métodos que las llevan, pero previenen al compilador para que
muestre una advertencia indicando que el método que se utiliza está desaconsejado.
También se tienen otras marcas @param , @return , @ see , etc, que utiliza Javadoc para
generar las páginas de documentación y las relaciones entre
ellas.Metainformación o anotaciones
Se tiene la posibilidad de añadir ciertas anotaciones en campos, métodos, clases y
otros
elementos, que permitan a las herramientas de desarrollo o de despliegue leerlas y
realizar
ciertas tareas. Por ejemplo, generar ficheros fuentes, ficheros XML, o un Stub de
métodos
para utilizar remotamente con RMI. Un ejemplo más claro lo tenemos en las
anotacionesArgumentos variables
Java permite pasar un número variable de argumentos a una función (como sucede
con
funciones como printf en C). Esto se consigue mediante la expresión "..." a partir del
momento en que queramos tener un número variable de argumentos.
EjemploImports estáticos
Los imports estáticos permiten importar los elementos estáticos de una clase, de
forma que
para referenciarlos no tengamos que poner siempre como prefijo el nombre de la
clase. Por
ejemplo, podemos utilizar las constantes de color de la clase java.awt.Color , o bien los
métodos matemáticos de la case Math . EjemploAparecerá un warning, debido a que el
método metodo no es propio de la instancia
concreta uc , sino da la clase UnaClase en general. Por lo tanto, deberemos llamarlo con:
UnaClase.metodo();Para hacer referencia a un elemento estático utilizaremos siempre el
nombre de la
clase a la que pertenece, y no la referencia a una instancia concreta de dicha clase.
Por ejemplo, si hacemos lo siguiente:Un ejemplo simple
Para ir teniendo una idea, vamos a poner un ejemplo de una clase Java:
public class Muestra extends Frame {
// atributos de la clase
Button si;
Button no;
// métodos de la clase:
public Muestra () {

Label comentario = new Label("Presione un botón", Label.CENTER);

si = new Button("Sí");
no = new Button("No");
add("North", comentario);
add("East", si);
add("West", no);de desarrollo y debugging! En Java, inclusive, ni siquiera existen las variables globales!
(Aunque parezca
difícil de aceptar, esto es una gran ventaja desde el punto de vista del desarrollo).
En cuanto a la herencia, simplemente significa que se pueden crear nuevas clases que hereden de otras
preexistentes; esto simplifica la programación, porque las clases hijas incorporan automáticamente los
métodos de las madres. Por ejemplo, nuestra clase "auto" podría heredar de otra más general, "vehículo", y
simplemente redefinir los métodos para el caso particular de los automóviles… lo que significa que, con una
buena biblioteca de clases, se puede reutilizar mucho código inclusive sin saber lo que tiene
adentro.Encapsulamiento significa que el objeto es auto-contenido, o sea que la misma definición del objeto
incluye
tanto los datos que éste usa (atributos) como los procedimientos (métodos) que actúan sobre los mismos.
Cuando se utiliza programación orientada a objetos, se definen clases (que definen objetos genéricos) y la
forma en que los objetos interactúan entre ellos, a través de mensajes. Al crear un objeto de una clase dada, se
dice que se crea una instancia de la clase, o un objeto propiamente dicho. Por ejemplo, una clase podría ser
"autos", y un auto dado es una instancia de la clase.
La ventaja de esto es que como no hay programas que actúen modificando al objeto, éste se mantiene en
cierto modo independiente del resto de la aplicación. Si es necesario modificar el objeto (por ejemplo, para
darle más capacidades), esto se puede hacer sin tocar el resto de la aplicación… lo que ahorra mucho tiempo
Bueno, ahora vamos a reunir las piezas que tenemos hasta ahora agregando estos métodos a nuestra clase
Ventana8 para ver cómo queda la ventana completa:super.handleEvent se encarga de otros eventos
dirigidos al panel, como la entrada de datos por teclado al
campo de texto por ejemplo.En caso de alguna acción sobre uno de los botones, el método setText (de la
clase TextField) pone en el
campo de texto elDia el valor del día actual o el siguiente.
Notar que sólo hemos considerado que haya algún evento y no un tipo de evento en particular; en realidad el
método va a actuar por ejemplo tanto al presionar el mouse sobre el botón como al soltarlo. Pero esto no nos
molesta.public boolean handleEvent (Event e) {
if (e.target == hoy)
elDia.setText(GetHoy());
if (e.target == diasiguiente)
elDia.setText(GetManana());
return super.handleEvent(e);
}El método getDescription es público y se usa para acceder a la fecha que se ha ingresado desde las demás
clases; simplemente devuelve el contenido del campo elDia, de clase TextField.
Aquí hemos desarrollado también el método handleEvent:Otra manera sería armar un array con los días de
cada mes, corregir los días de febrero para los años
bisiestos, y comparar contra este array en lugar de usar un switch. La idea siempre es la misma: devolver un
String con la fecha del día siguiente.
Notar algo interesante: como estas clases se cargan y ejecutan en la máquina cliente, la fecha que aparece es
la del cliente y no la del servidor (que puede ser diferente depende la hora y el lugar del mundo en que estén
ambas máquinas).El constructor crea un panel con cuatro campos en forma de grilla vertical, donde mostrará
el texto "Día
salida: ", el campo de entrada de texto elDia y los botones hoy y diasiguiente.
El método privado getHoy usa los métodos getDate, getMonth y getYear de la clase date para armar un
String con la fecha actual. El método privado getManana hace lo mismo para leer la fecha actual, y le suma
1 al día para tener el día siguiente. El switch siguiente verifica que si pasó de fin de mes tome el primer día y
el mes siguiente (o el primer día del año siguiente si es en diciembre). Notar que no se consideraron los años
bisiestos en febrero para no complicar el método, pero no es difícil de corregir.
Este es un poco más largo pero no más complejo. Vamos por parte:
DiaPartida() {
setLayout (new GridLayout (4,1));
elDia = new TextField();
elDia.setText(GetHoy());
hoy = new Button ("Hoy");
diasiguiente = new Button ("Mañana");
add (new Label ("Día salida: "));
add (elDia);
add (hoy);
add (diasiguiente);
}
case (4):
case (6):
case (9):
case (11): if (dia>30) {
dia = 1;
mes++;
}
break;
default: if (dia>28) { // ojo, hay que corregir para bisiestos!
dia = 1;
mes++;
}
}
return dia+"/"+mes+"/"+ano;
}
public String getDescription() {
return elDia.getText();
}
public boolean handleEvent (Event e) {
if (e.target == hoy)
elDia.setText(GetHoy());
if (e.target == diasiguiente)
elDia.setText(GetManana());
return super.
listaPueblos.addItem("Buenos Aires");
listaPueblos.addItem("La Plata");
listaPueblos.addItem("Azul");
listaPueblos.addItem("Rosario");
listaPueblos.addItem("Cordoba");
listaPueblos.addItem("Bahía Blanca");
add("South", listaPueblos);
}
public String getDescription() {
return listaPueblos.getSelectedItem();
}
}
No hay mucho para analizar aquí, creo. La variable listaPueblos es privada, pero puede consultarse cuál es la
ciudad seleccionada mediante getDescription (que es public). Este método llama al método
getSelectedItem de la lista, que devuelve el texto seleccionado.
En el constructor, armamos el texto del título como un StringBuffer. Los objetos StringBuffer son similares
a
los de clase String pero pueden ser modificados. En cambio los objetos String, una vez creados, no pueden
ser modificados directamente: sus métodos (concat, toLowerCase, etc.) simplemente crean un nuevo String
con el nuevo valor.
Esto lo hicimos para introducir esta nueva clase; por supuesto hubiera sido más fácil poner, como pueden
comprobar, con el mismo resultado:
String tit = "Seleccione ciudad de "+salidaOllegada+": ";
add("North", new Label(tit));
Por otra parte, creamos el objeto listaPueblos como new List(4, false), que indica que la lista va a tener 4
renglones y sólo se puede seleccionar un ítem por vez. Agregamos luego 6 ítems mediante addItem y la
agregamos al panel.
Ahora ya podemos agregar las listas a nuestra ventana y poner un par de variables para guardarlas:
class Ventana8 extends Frame { // hija de Frame
SelecPueblo cs; // ciudad de salida
SelecPueblo cl; // ciudad de llegada
button ok; // también el botón de compra de pasajes
boolean enApplet; // y otra para indicar si es un applet o no
Ventana8 (String titulo, boolean enApplet) { // un constructor
super(titulo); // llama al de Frame
this.enApplet = enApplet; // guardamos esto
cs = new SelecPueblo("SALIDA"); // CIUDAD DE SALIDA
add ("Center", cs);
cl = new SelecPueblo("LLEGADA"); // CIUDAD DE LLEGADA
add ("East", cl);
ok = new Button("Viaje: de ? a ? el ?/?/?");
add("South",ok);
pack(); // dimensionamos la ventana
show(); // y la mostramos!
}
...........................
Ya pueden ir probando cómo queda, aunque por ahora mucha funcionalidad no tenemos...
http://www.librosgratis.org
Página 38
Agregando fechas
Otro panel más nos servirá para seleccionar o entrar la fecha:
import java.util.*;
import java.awt.*;
class DiaPartida extends Panel {
private TextField elDia;
private Button hoy;
private Button diasiguiente;
DiaPartida() {
setLayout (new GridLayout (4,1));
elDia = new TextField();
elDia.setText(GetHoy());
hoy = new Button ("Hoy");
diasiguiente = new Button ("Mañana");
add (new Label ("Día salida: "));
add (elDia);
add (hoy);
add (diasiguiente);
}
private String GetHoy() {
Date d = new Date();
int dia = d.getDate();
int mes = d.getMonth();
int ano = d.getYear();
return dia+"/"+mes+"/"+ano;
}
private String GetManana() {
Date d = new Date();
int dia = d.getDate();
int mes = d.getMonth();
int ano = d.getYear();
dia = dia++;
switch (mes) {
case (1):
case (3):
case (5):
case (7):
case (8):
case (10): if (dia>31) {
dia = 1;
mes++;
}
break;
case (12): if (dia>31) {
dia = 1;
mes = 1;
ano++;