📄 java3.htm
字号:
archiva un objeto, o sea que no forman parte del estado permanente
del mismo.
<P>
<I>Volatile</I> se utiliza con variables modificadas asincrónicamente
por objetos en diferentes <I>threads</I> (literalmente "hilos",
tareas que se ejecutan en paralelo); básicamente esto implica
que distintas tareas pueden intentar modificar la variable simultáneamente,
y <I>volatile</I> asegura que se vuelva a leer la variable (por
si fue modificada) cada vez que se la va a usar (esto es, en lugar
de usar registros de almacenamiento como buffer).
<H3>Los tipos de Java</H3>
<P>
Los tipos de variables disponibles son básicamente 3:
<UL>
<LI>tipos básicos (no son objetos)
<LI>arreglos (arrays)
<LI>clases e interfases
</UL>
<P>
Con lo que vemos que cada vez que creamos una clase o interfase
estamos definiendo un nuevo tipo.
<P>
Los <B>tipos básicos</B> son:<BR>
<TABLE BORDER=1>
<TR><TD WIDTH=104><B>Tipo</B></TD><TD WIDTH=170><B>Tamaño/Formato</B>
</TD><TD WIDTH=208><B>Descripción</B></TD></TR>
<TR><TD WIDTH=104>byte</TD><TD WIDTH=170>8-bit complemento a 2
</TD><TD WIDTH=208>Entero de un byte</TD></TR>
<TR><TD WIDTH=104>short</TD><TD WIDTH=170>16-bit complemento a 2
</TD><TD WIDTH=208>Entero corto</TD></TR>
<TR><TD WIDTH=104>int</TD><TD WIDTH=170>32-bit complemento a 2
</TD><TD WIDTH=208>Entero</TD></TR>
<TR><TD WIDTH=104>long</TD><TD WIDTH=170>64-bit complemento a 2
</TD><TD WIDTH=208>Entero largo</TD></TR>
<TR><TD WIDTH=104>float</TD><TD WIDTH=170>32-bit IEEE 754</TD>
<TD WIDTH=208>Punto flotante, precisión simple</TD></TR>
<TR><TD WIDTH=104>double</TD><TD WIDTH=170>64-bit IEEE 754</TD>
<TD WIDTH=208>Punto flotante, precisión doble</TD></TR>
<TR><TD WIDTH=104>char</TD><TD WIDTH=170>16-bit caracter Unicode
</TD><TD WIDTH=208>Un caracter</TD></TR>
<TR><TD WIDTH=104>boolean</TD><TD WIDTH=170>true, false</TD><TD WIDTH=208>Valor booleano (verdadero o falso)
</TD></TR>
</TABLE>
<P>
<P>
Los <B>arrays</B> son arreglos de cualquier tipo (básico
o no). Por ejemplo, existe una clase <I>Integer</I>; un arreglo
de objetos de dicha clase se notaría:
<P>
Integer vector[ ];
<P>
Los arreglos siempre son dinámicos, por lo que <B>no es
válido</B> poner algo como:
<P>
Integer cadena[5];
<P>
Aunque sí es válido inicializar un arreglo, como
en:
<P>
int días[ ] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31,
30, 31 };
<P>
char letras[ ] = { 'E', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S',
'O', 'N', 'D' };
<P>
String nombres[ ] = new String[12];<BR>
<P>
Nota al margen: no confundir un String (<I>cadena</I> de caracteres)
con un <I>arreglo</I> de caracteres! Son cosas bien distintas!
<P>
Ya hablaremos más adelante de las clases String y StringBuffer.
<P>
En Java, para todas las variables de tipo básico se accede
al valor asignado a la misma directamente (no se conoce la dirección
de memoria que ocupa). Para las demás (arrays, clases o
interfases), se accede a través de un puntero a la variable.
El valor del puntero no es accesible ni se puede modificar (como
en C); Java no necesita esto y además eso atentaría
contra la robustez del lenguaje.
<P>
De hecho, en Java no existen los tipos <B>pointer</B>, <B>struct</B>
o <B>union</B>. Un objeto es más que una estructura, y
las uniones no se hacen necesarias con un método de programación
adecuado (y además se evita la posibilidad de acceder a
los datos incorrectamente).
<P>
Algo más respecto a los arreglos: ya que Java gestiona
el manejo de memoria para los mismos, y lanza excepciones si se
intenta violar el espacio asignado a una variable, se evitan problemas
típicos de C como acceder a lugares de memoria prohibidos
o fuera del lugar definido para la variable (como cuando se usa
un subíndice más grande que lo previsto para un
arreglo…).
<H3>Y los métodos…</H3>
<P>
Los métodos, como las clases, tienen una declaración
y un cuerpo.
<P>
La declaración es del tipo:<BR>
<P>
[<B>private</B>|<B>protected</B>|<B>public</B>] [<B>static</B>]
[<B>abstract</B>] [<B>final</B>] [<B>native</B>] [<B>synchronized</B>]
TipoDevuelto NombreMétodo <B>( </B>[tipo1 nombre1[, tipo2
nombre2 ]…] <B>)</B> [<B>throws</B> excepción1 [,excepción2]…
]<BR>
<P>
A no preocuparse: poco a poco aclararemos todo con ejemplos.
<P>
Básicamente, los métodos son como las funciones
de C: implementan, a través de funciones, operaciones y
estructuras de control, el cálculo de algún parámetro
que es el que devuelven al objeto que los llama. Sólo pueden
devolver <B>un</B> valor (del tipo <I>TipoDevuelto</I>), aunque
pueden no devolver ninguno (en ese caso <I>TipoDevuelto</I> es
<B>void</B>). Como ya veremos, el valor de retorno se especifica
con la instrucción <B>return</B>, dentro del método.
<P>
Los métodos pueden utilizar valores que les pasa el objeto
que los llama (<I>parámetros</I>), indicados con <I>tipo1
nombre1, tipo2 nombre2</I>… en el esquema de la declaración.
<P>
Estos parámetros pueden ser de cualquiera de los tipos
ya vistos. Si son tipos básicos, el método recibe
el <I>valor</I> del parámetro; si son arrays, clases o
interfases, recibe un puntero a los datos (<I>referencia</I>).
Veamos un pequeño ejemplo:<BR>
<PRE WIDTH=132>
<FONT SIZE=2>public int AumentarCuenta(int cantidad) {
cnt = cnt + cantidad;
return cnt;
}<BR>
</FONT>
</PRE>
<P>
Este método, si lo agregamos a la clase <B>Contador</B>,
le suma <I>cantidad</I> al acumulador <B>cnt</B>. En detalle:
<UL>
<LI>el método recibe un valor entero (<I>cantidad</I>)
<LI>lo suma a la variable de instancia <I>cnt</I>
<LI>devuelve la suma (<I>return cnt</I>)
</UL>
<P>
¿Cómo hago si quiero devolver más de un valor?
Por ejemplo, supongamos que queremos hacer un método dentro
de una clase que devuelva la posición del mouse.
<P>
Lo siguiente no sirve:
<PRE WIDTH=132>
<FONT SIZE=2> void GetMousePos(int x, int y) {
x = ….; // esto no sirve!
y = ….; // esto tampoco!
}</FONT>
</PRE>
<P>
porque el método no puede modificar los parámetros
<I>x</I> e <I>y</I> (que han sido pasados por valor, o sea que
el método recibe el valor numérico pero no sabe
adónde están las variables en memoria).
<P>
La solución es utilizar, en lugar de tipos básicos,
una clase:
<PRE WIDTH=132>
<FONT SIZE=2> class MousePos { public int x, y; }</FONT>
</PRE>
<P>
y luego utilizar esa clase en nuestro método:
<PRE WIDTH=132>
<FONT SIZE=2> void GetMousePos( MousePos m ) {
m.x = ……;
m.y = ……;
}<BR>
<BR>
</FONT>
</PRE>
<H3>El resto de la declaración</H3>
<P>
<B>Public</B>, <B>private</B> y <B>protected</B> actúan
exactamente igual para los métodos que para los atributos,
así que veamos el resto.
<P>
Los métodos estáticos (<B>static</B>), son, como
los atributos, métodos <I>de clase</I>; si el método
no es <B>static</B> es un método <I>de instancia</I>. El
significado es el mismo que para los atributos: un método
<I>static</I> es compartido por todas las instancias de la clase.
<P>
Ya hemos hablado de las clases abstractas; los métodos
abstractos (<B>abstract</B>) son aquellos de los que se da la
declaración pero no la implementación (o sea que
consiste sólo del encabezamiento). Cualquier clase que
contenga al menos un método abstracto (o cuya clase madre
contenga al menos un método abstracto que no esté
implementado en la hija) es una clase abstracta.
<P>
Es <B>final</B> un método que no puede ser redefinido por
ningún descendiente de la clase.
<P>
Las clases <B>native</B> son aquellas que se implementan en otro
lenguaje (por ejemplo C o C++) propio de la máquina. Sun
aconseja utilizarlas bajo riesgo propio, ya que en realidad son
ajenas al lenguaje. Pero la posibilidad de usar viejas bibliotecas
que uno armó y no tiene ganas de reescribir existe!.
<P>
Las clases <B>synchronized</B> permiten sincronizar varios <I>threads</I>
para el caso en que dos o más accedan concurrentemente
a los mismos datos. De nuevo, más detalles habrá
en el futuro, cuando hablemos de threads.
<P>
Finalmente, la cláusula <B>throws</B> sirve para indicar
que la clase genera determinadas excepciones. También hablaremos
de las excepciones más adelante.<BR>
<P>
En la próxima veremos el cuerpo de la declaración
y empezaremos a armar algunos ejemplos concretos para ir aclarando
todos estos conceptos…
<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 + -