El cuerpo de los métodos

Otra vez recordaremos nuestra vieja clase Contador:

// Implementación de un contador sencillo
public class Contador {
………………..
public int incCuenta() {
cnt++;
return cnt;
}
…………………
}

Dentro de los métodos pueden incluirse:

Declaración de variables locales

Asignaciones a variables

Operaciones matemáticas

Llamados a otros métodos:

	dentro de la clase
	de instancia, de otras clases
	de clase, de cualquier clase

Estructuras de control

Excepciones (try, catch, que veremos más adelante)

Declaración de variables locales

Las variables locales se declaran igual que los atributos de la clase:

Tipo NombreVariable [= Valor];

Ej: int suma;

float precio;

Contador laCuenta;

Sólo que aquí no se declaran private, public, etc., sino que las variables definidas dentro del método sólo son accesibles por él.

Las variables pueden inicializarse al crearse:

Ej: int suma = 0;

float precio = 12.3;

Contador laCuenta = new Contador ( );

Asignaciones a variables

Se asigna un valor a una variable mediante el signo =:

Variable = Constante | Expresión ;

Ej: suma = suma + 1;

precio = 1.05 * precio;

laCuenta.cnt = 0;

El último caso es válido si cnt es una variable pública de la clase Contador. Personalmente no creo conveniente acceder directamente a variables de otro objeto, ya que futuras modificaciones del objeto llamado o del que llama puede propender la difusión de errores… Es mejor usar métodos como getCuenta o un hipotético inicializarContador para ello. De hecho, algunos sugieren que todas las variables de una clase se declaren como private.

En el primer caso, o sea en general:

Variable = Variable Operador Expresión;

se puede escribir en forma más sencilla:

Variable Operador= Expresión;

Por ejemplo, suma = suma + 9 - cantidad;

puede escribirse: suma += 9-cantidad;

y precio = precio * 0.97;

como: precio *= 0.97;

Operaciones matemáticas

Hay varios tipos de operadores:

Unarios: + - ++ -- ~ ! (tipo) …..etc.

Se colocan antes (o en algunos casos después) de la constante o expresión.

Por ejemplo: -cnt; // cambia de signo; por ejemplo si cnt es 12 el resultado es -12; cnt no cambia.

++cnt; // equivale a cnt += 1;

cnt++; // equivale a cnt +=1; veremos la diferencia al hablar de estructuras de control

--cnt; // equivale a cnt -= 1;

cnt--; // equivale a cnt -= 1;

Binarios: + - * / % …..etc.

Van entre dos constantes o expresiones o combinación de ambas.

Por ejemplo: cnt + 2; // debuelve la suma de ambos.

promedio + ( valor / 2); // como se ve, se pueden usar paréntesis.

horas / hombres; // división.

acumulado % 3; // resto de la división entera entre ambos.

Nota: + sirve también para concatenar cadenas de caracteres; hablaremos de String y StringBuffer pronto. Cuando se mezclan Strings y valores numéricos, éstos se convierten automáticamente a cadenas:

"La frase tiene " + cant + " letras"

se convierte en: "La frase tiene 17 letras" // suponiendo que cant = 17

Precedencia de operadores en Java

La siguiente es la precedencia de los operadores en expresiones compuestas. De todos modos, como en todos los lenguajes, se recomienda usar paréntesis en caso de duda.

Posfijos [] . (params) expr++ expr--

Operadores unarios ++expr --expr +expr -expr ~ !

Creación y "cast" new (type)

Multiplicativos * / %

Aditivos + -

Desplazamiento << >> >>>

Relacionales < > <= >= instanceof

Igualdad == !=

AND bit a bit &

OR exclusivo bit a bit ^

OR inclusivo bit a bit |

AND lógico &&

OR lógico ||

Condicional ? :

Asignación = += -= *= /= %= ^= &= |= <<= >>= >>>=

Algunos ejemplos:

[] define arreglos: int lista[];

(params) es la lista de parámetros cuando se llama a un método: convertir(valor, base);

new permite crear una instancia de un objeto: new Contador();

(type) cambia el tipo de una expresión a otro: (float)(total % 10);

>> desplaza bit a bit un valor binario: base >> 3;

<= devuelve "true" si un valor es menor o igual que otro: total <= maximo;

instanceof devuelve "true" si el objeto es una instancia de la clase: papa instanceof Comida;

|| devuelve "true" si cualquiera de las expresiones es verdad: (a<5) || (a>20)

Llamadas a métodos

Se llama a un método de la misma clase simplemente con el nombre del método y los parámetros entre paréntesis, como se ve, entre otros, en el ejemplo en negrita:

	// Archivo:	Complejo.java
	// Compilar con:	javac Complejo.java
	public final class Complejo extends Number {
	// atributos:
		private float x;
		private float y;
	// constructor:
public Complejo(float  rx, float iy) {
	x = rx;
	y = iy;
}
	// métodos:
		public float Norma() {
			return (float)Math.sqrt(x*x+y*y);
		}
		// obligatorios (son abstractos en Number):
public double doubleValue() {
	return (double)Norma( );
}
public float floatValue() {
	return Norma();
}
public int intValue() {
	return (int)Norma();
}
public long longValue() {
	return (long)Norma();
}
public String toString() {
	return "("+x+")+i("+y+")";
}
	}

Pueden probar la clase (mínima) con el siguiente ejemplo de aplicación; la línea en negrita es un ejemplo de un llamado a un método de un objeto de otra clase. Notar que es este caso, es necesario llamar al método sobre un objeto (instancia) existente, por lo que se indica:

	
Nombre_del_Objeto<punto>Nombre_del_Método(parámetros)

// Archivo:  Ejemplo4.java
// Compilar con: javac Ejemplo4.java
// Ejecutar con: java Ejemplo4
import java.io.*;

public class Ejemplo4 {
public static void main(String args[]) {
Complejo numComp = new Complejo(4,-3);
System.out.println(numComp.toString());
System.out.println(numComp.Norma());
}
}

En la clase Complejo tenemos también un ejemplo de un llamado a un método de clase, o sea static:

return (float)Math.sqrt(x*x+y*y);

Como el método es de clase, no hace falta llamarlo para un objeto en particular. En ese caso, en lugar del nombre de un objeto existente se puede utilizar directamente el nombre de la clase:

Nombre_de_la_Clase<punto>Nombre_del_Método(parámetros)

En el próximo capítulo veremos las estructuras de control y empezaremos a armar ejemplos para repasar todo esto.

<> Página de tutoriales <> Página Anterior <> Siguiente Capitulo <>