📄 java2.htm
字号:
<HTML>
<HEAD>
<TITLE>Java desde Cero</TITLE>
<META NAME="GENERATOR" CONTENT="Internet Assistant for Microsoft Word 2.0z">
</HEAD>
<BODY background=1.gif TEXT=000000 LINK=FF0000 VLINK=A62A2A>
<H1>Las clases en Java</H1>
<P>
Bueno, antes que nada conviene saber que en Java hay un montón
de clases ya definidas y utilizables.
<P>
Éstas vienen en las bibliotecas estándar:
<UL>
<LI>java.lang - clases esenciales, números, strings, objetos,
compilador, runtime, seguridad y threads (es el único paquete
que se incluye automáticamente en todo programa Java)
<LI>java.io - clases que manejan entradas y salidas
<LI>java.util - clases útiles, como estructuras genéricas,
manejo de fecha, hora y strings, número aleatorios, etc.
<LI>java.net - clases para soportar redes: URL, TCP, UDP, IP,
etc.
<LI>java.awt - clases para manejo de interface gráfica,
ventanas, etc.
<LI>java.awt.image - clases para manejo de imágenes
<LI>java.awt.peer - clases que conectan la interface gráfica
a implementaciones dependientes de la plataforma (motif, windows)
<LI>java.applet - clases para la creación de applets y
recursos para reproducción de audio.
</UL>
<P>
Para que se den una idea, los números enteros, por ejemplo,
son "instancias" de una clase no redefinible, <I>Integer</I>,
que desciende de la clase <I>Number</I> e implementa los siguientes
atributos y métodos:
<PRE>
<FONT SIZE=2>public final class java.lang.Integer extends java.lang.Number {
// Atributos
public final static int MAX_VALUE;
public final static int MIN_VALUE;
// Métodos Constructores
public Integer(int value);
public Integer(String s);
// Más Métodos
public double doubleValue();
public boolean equals(Object obj);
public float floatValue();
public static Integer getInteger(String nm);
public static Integer getInteger(String nm, int val);
public static Integer getInteger(String nm, Integer val);
public int hashCode();
public int intValue();
public long longValue();
public static int parseInt(String s);
public static int parseInt(String s, int radix);
public static String toBinaryString(int i);
public static String toHexString(int i);
public static String toOctalString(int i);
public String toString();
public static String toString(int i);
public static String toString(int i, int radix);
public static Integer valueOf(String s);
public static Integer valueOf(String s, int radix);
}</FONT>
</PRE>
<P>
Mucho, no?
<P>
Esto también nos da algunas ideas:
<UL>
<LI>la estructura de una clase
<LI>caramba, hay métodos repetidos!
</UL>
<P>
De la estructura enseguida hablaremos; en cuanto a los métodos
repetidos (como <I>parseInt</I> por ejemplo), al llamarse al método
el compilador decide cuál de las implementaciones del mismo
usar basándose en la cantidad y tipo de parámetros
que le pasamos. Por ejemplo, parseInt("134") y parseInt("134",16),
al compilarse, generarán llamados a dos métodos
distintos.
<H2>Estructura de una clase</H2>
<P>
Una clase consiste en:
<PRE>
<FONT SIZE=2>algunas_palabras <B>class</B> <B>nombre_de_la_clase</B> [algo_más] <B>{
</B> [lista_de_atributos]
[lista_de_métodos]
<B>}</B></FONT>
</PRE>
<P>
Lo que está entre [ y ] es opcional…
<P>
Ya veremos qué poner en "algunas_palabras" y
"algo_más", por ahora sigamos un poco más.
<P>
La lista de atributos (nuestras viejas variables locales) sigue
el mismo formato de C: se define primero el tipo y luego el nombre
del atributo, y finalmente el ";".
<P>
<FONT FACE="Arial">public final static <B>int MAX_VALUE</B></FONT>
<P>
<FONT FACE="Arial">;</FONT>
<P>
También tenemos "algunas_palabras" adelante,
pero en seguida las analizaremos.
<P>
En cuanto a los métodos, también siguen la sintaxis
del C; un ejemplo:
<PRE>
<FONT SIZE=2>public int <B>incContador() {</B> // declaración y apertura de {
cnt++; // instrucciones, separadas por ";"
return(cnt);
<B>}</B> // cierre de }</FONT>
</PRE>
<P>
Finalmente, se aceptan comentarios entre /* y */, como en C, o
bien usando // al principio del comentario (el comentario termina
al final de la línea).
<P>
Veamos un ejemplo:
<PRE WIDTH=132>
<FONT SIZE=2>// Implementación de un contador sencillo
// GRABAR EN UN ARCHIVO "Contador.java" (OJO CON LAS MAYUSCULAS!)
// COMPILAR CON: "javac Contador.java" (NO OLVIDAR EL .java!)
// ESTA CLASE NO ES UNA APLICACION, pero nos va a servir enseguida
public class Contador { // Se define la clase Contador
// Atributos
int cnt; // Un entero para guardar el valor actual
// Constructor // Un método constructor…
public Contador() { // …lleva el mismo nombre que la clase
cnt = 0; // Simplemente, inicializa (1)
}
// Métodos
public int incCuenta() { // Un método para incrementar el contador
cnt++; // incrementa cnt
return cnt; // y de paso devuelve el nuevo valor
}
public int getCuenta() { // Este sólo devuelve el valor actual
return cnt; // del contador
}
}</FONT>
</PRE>
<P>
Cuando, desde una aplicación u otro objeto, se crea una
<B>instancia</B> de la clase <B>Contador</B>, mediante la instrucción:
<P>
<FONT FACE="Arial">new Contador()</FONT>
<P>
el compilador busca un método con el mismo nombre de la
clase y que se corresponda con la llamada en cuanto al tipo y
número de parámetros. Dicho método se llama
Constructor, y una clase puede tener más de un constructor
(no así un objeto o instancia, ya que una vez que fue creado
no puede recrearse sobre sí mismo).
<P>
En tiempo de ejecución, al encontrar dicha instrucción,
el intérprete reserva espacio para el objeto/instancia,
crea su estructura y llama al constructor.
<P>
O sea que el efecto de <FONT FACE="Arial">new Contador()</FONT>
es, precisamente, reservar espacio para el contador e inicializarlo
en cero.
<P>
En cuanto a los otros métodos, se pueden llamar desde otros
objetos (lo que incluye a las aplicaciones) del mismo modo que
se llama una función desde C.
<P>
Por ejemplo, usemos nuestro contador en un programa bien sencillo
que nos muestre cómo evoluciona:
<PRE WIDTH=132>
<FONT SIZE=2>// Usemos nuestro contador en una mini-aplicación
// GRABAR EN UN ARCHIVO "Ejemplo1.java" (OJO CON LAS MAYUSCULAS!)
// COMPILAR CON: "javac Ejemplo.java" (NO OLVIDAR EL .java!)
// EJECUTAR CON: "java Ejemplo1" (SIN el .java)
import java.io.*; // Uso la biblioteca de entradas/salidas
public class Ejemplo1 { // IMPORTANTE: Nombre de la clase
// igual al nombre del archivo!
// entero para asignarle el valor del contador e imprimirlo
// aunque en realidad no me hace falta.
static int n;
// y una variable tipo Contador para instanciar el objeto…
static Contador laCuenta;
// ESTE METODO, MAIN, ES EL QUE HACE QUE ESTO SE COMPORTE
// COMO APLICACION. Es donde arranca el programa cuando ejecuto "java Ejemplo1"
// NOTA: main debe ser public & static.
public static void main ( String args[] ) {
System.out.println ("Cuenta… "); // Imprimo el título
laCuenta = new Contador(); // Creo una instancia del Contador
System.out.println (laCuenta.getCuenta()); // 0 - Imprimo el valor actual (cero!)
n = laCuenta.incCuenta(); // 1 - Asignación e incremento
System.out.println (n); // Ahora imprimo n
laCuenta.incCuenta(); // 2 - Lo incremento (no uso el valor…
System.out.println (laCuenta.getCuenta()); // …de retorno) y lo imprimo
System.out.println (laCuenta.incCuenta()); // 3 - Ahora todo en un paso!
}
}</FONT>
</PRE>
<P>
En el capítulo III vamos a analizar este programa en detalle.
Por ahora veamos la diferencia con un applet que haga lo mismo:
<BR>
<PRE WIDTH=132>
<FONT SIZE=2> // Applet de acción similar a la aplicación Ejemplo1
// GRABAR EN ARCHIVO: "Ejemplo2.java"
// COMPILAR CON: "javac Ejemplo2.java"
// PARA EJECUTAR: Crear una página HTML como se indica luego
import java.applet.*;
import java.awt.*;
public class Ejemplo2 extends Applet {
static int n;
static Contador laCuenta;
// Constructor…
public Ejemplo2 () {
laCuenta = new Contador();
}
// El método paint se ejecuta cada vez que hay que redibujar
// NOTAR EL EFECTO DE ESTO CUANDO SE CAMBIA DE TAMAÑO LA
// VENTANA DEL NAVEGADOR!
public void paint (Graphics g) {
g.drawString ("Cuenta...", 20, 20);
g.drawString (String.valueOf(laCuenta.getCuenta()), 20, 35 );
n = laCuenta.incCuenta();
g.drawString (String.valueOf(n), 20, 50 );
laCuenta.incCuenta();
g.drawString (String.valueOf(laCuenta.getCuenta()), 20, 65 );
g.drawString (String.valueOf(laCuenta.incCuenta()), 20, 80 );
}
}<BR>
</FONT>
</PRE>
<P>
Ahora es necesario crear una página HTML para poder visualizarlo.
Para esto, crear y luego cargar el archivo ejemplo2.htm con un
browser que soporte Java (o bien ejecutar en la ventana DOS: "appletviewer
ejemplo2.htm"):
<PRE WIDTH=132>
<FONT SIZE=2><HTML>
<HEAD>
<TITLE>Ejemplo 2 - Applet Contador</TITLE>
</HEAD>
<BODY>
<applet code="Ejemplo2.class" width=170 height=150>
</applet>
</BODY>
</HTML><BR>
</FONT>
</PRE>
<P>
Para terminar este capítulo, observemos las diferencias
entre la aplicación standalone y el applet:
<UL>
<LI>La aplicación usa un método main, desde donde
arranca
<LI>El applet, en cambio, se arranca desde un constructor (método
con el mismo nombre que la clase)
</UL>
<P>
Además:
<UL>
<LI>En la aplicación utilizamos System.out.println para
imprimir en la salida estándar
<LI>En el applet necesitamos "dibujar" el texto sobre
un fondo gráfico, por lo que usamos el método g.drawString
dentro del método paint (que es llamado cada vez que es
necesario redibujar el applet)
</UL>
<P>
Con poco trabajo se pueden combinar ambos casos en un solo objeto,
de modo que <B>la misma</B> clase sirva para utilizarla de las
dos maneras:<BR>
<PRE WIDTH=132>
<FONT SIZE=2>// Archivo: Ejemplo3.java
// Compilar con: javac Ejemplo3.java
import java.applet.*;
import java.awt.*;
import java.io.*;
public class Ejemplo3 extends Applet {
static int n;
static Contador laCuenta;
public Ejemplo3 () {
laCuenta = new Contador();
}
public static void main(String args[]) {
laCuenta = new Contador();
paint();
}
public static void paint () {
System.out.println ("Cuenta...");
System.out.println (laCuenta.getCuenta());
n = laCuenta.incCuenta();
System.out.println (n);
laCuenta.incCuenta();
System.out.println (laCuenta.getCuenta());
System.out.println (laCuenta.incCuenta());
}
public void paint (Graphics g) {
g.drawString ("Cuenta...", 20, 20);
g.drawString (String.valueOf(laCuenta.getCuenta()), 20, 35 );
n = laCuenta.incCuenta();
g.drawString (String.valueOf(n), 20, 50 );
laCuenta.incCuenta();
g.drawString (String.valueOf(laCuenta.getCuenta()), 20, 65 );
g.drawString (String.valueOf(laCuenta.incCuenta()), 20, 80 );
}
}</FONT>
</PRE>
<P>
Esta clase puede ejecutarse tanto con "java Ejemplo3"
en una ventana DOS, como cargarse desde una página HTML
con:
<PRE WIDTH=132>
<FONT SIZE=2><applet code="Ejemplo3.class" width=170 height=150>
</applet></FONT>
</PRE>
<P>
Notar que conviene probar el applet con el appletviewer ("appletviewer
ejemplo3.htm"), ya que éste indica en la ventana DOS
si hay algún error durante la ejecución. Los browsers
dejan pasar muchos errores, simplemente suprimiendo la salida
a pantalla del código erróneo.
<P>
Notar que en todo este desarrollo de las clases Ejemplo1, Ejemplo2
y Ejemplo3, en ningún momento volvimos a tocar la clase
Contador!
<P>
En el próximo capítulo analizaremos el código
línea por línea para ir comprendiendo los distintos
elementos que allí aparecen.
<P>
<HR>
Jorge Bourdette
<P>
<A HREF="mailto:jpb@amarillas.com">jpb@amarillas.com</A>
</BODY>
</HTML>
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -