HTMLpointHTMLpoint HTMLpoint.com


 Operadores



Los operadores del enguaje Java son los mismos que los de los demás lenguajes, además cada nuevo tipo tendrá su proprio método que incluyen nuevos operadores, como vimos en el ejemplo de la clse Complejos.
Analizamos los operadores de acceso a las clases y a los objetos, es decir, simplemente el punto. Si queremos entrar en el campo X del objeto x, simplemente tendremos que escribir x.X, aunque x tenga un método Y(ent valor), nosostros entramos o, mejor en este caso, lo solicitamos escribiendo x.Y(39); Tenemos los operadores aritméticos de siempre: +,-,*,/ y %.
Hay que tener en cuenta también las operaciones son tipadas, es decir, si sumo dos enteros el resultado es un valor entero y así para todas las operaciones, de forma que si tenemos una expresión siempre es posible establecer el tipo de resultado.
Java ejerce un fuerte control sobre los tipos. De hecho, no es posible asignar un carácter e un entero, lo que es posible en el lenguaje C, y además es imposible asignar un double a un float sin un casting explícito. El casting obliga a un valor de un tipo a tener un tipo distinto. Si escribo 5, me refiero a un entero, mientras que si hago un cast a float me refiero a la versión de 5 real y para hacerlo tendré que escribir(float) 5.
De esta forma puedo asignar los enteros a reales y de reales double a relaes float. Pensemos, por ejemplo en:

double v1=10.0;
float v2;
ent v3=5;


y pensemos en las siguientes asignaciones equivocadas:

v2=v1;
v1=v3;


Si hacemos unos cast, se convierten en exactas también para Java:

v2=(float) v1;
v1=(double) v3;

Hay que notar la división de los enteros que en otros lenguajes da un entero. Por lo tanto, si queremos el número real que resulta de la división de los dos números enteros x e y, antes hay que transformarlos en números reales:

float resultado= (float ) x / (float) y;

Para las cadenas hay un operador de encadenamiento:

cadena a="Pietro " ;
Cadena b= a + "Castellu";
Cadena b+="cci"


El resultado será Pietro Castellucci. El operador es el signo +. En un momento dado, utilizamos una asignación particular, es decir, += que es una abreviación. Si tengo que escribir a=a+1; puedo abreviar y escribir a+=1, que es lo mismo. Lo mismo vale para cada operador binario. El operador + cuelga de una cadena también caracteres y números, pensemos en las salidas de los ejemplos anteriores en los que escribíamos, por ejemplo:

System.out.println("Número complejo:"+Re+"+i"+Im+" tiene módulo "+mod);

esto os puede parecer raro, sobre todo si consideramos que dijimos que las expresiones Java están bien caracterizadas por los tipos, a diferencia del C. Esto ocurre, sin embargo, porque el sistema hace unas conversiones implícitas de tipos primitivos y objetos en cadenas. Por ejemplo, si establecemos cualquier objeto y lo hacemos con un método toString(), el sistema tendrá que trabajar con cadenas y con este objeto solicitará automáticamente el método toString().

Además Java ofrece otros cuatro operadores que son unas abreviaciones: dos son de incremento de variables y dos de incremento. Si X es una variable puedo escribir:

X++
++X
X--
--X


Esto quiere decir: primero evalua X y luego incrementa X, primero incrementa X y luego evalua X, primero evalua X y luego disminuye X y , por último, primero disminuye X y luego evalúa X. Esto quiere decir que la expresión X++ es un mando de asignación, pero también una expresión que devuelve un resultado que, en este caso, es X antes de que se incremente.

Por ejemplo:

X=10;
Y=X++;


dará como resultado X=11 e Y=10. Intendad editar y poner en marcha lo siguiente clase incdec

{

public static void main(Cadena [] a)
{

ent X,Y,Z,W,V;

X=10;

System.out.println("X="+X);

Y=X++;

System.out.println("Y=X++: tengo X="+X+",Y="+Y);

Z=++Y;

System.out.println("Z=++Y: tengo Z="+Z+",Y="+Y);

W=Z--;

System.out.println("W=Z--: tengo W="+W+",Z="+Z);

V=--W;

System.out.println("V=--W: tengo V="+V+",W="+W);

}
}


Otros operadores son los de comparación, es decir:

> mayor de, x>y nos da verdadero si x es mayor que y, en caso contrario, nos da falso

>= mayor o igual a, x>=y nos da verdadero si x es mayor o igual a y, en caso contrario nos da falso

< menor de, x<y nos da verdadero si x es menor de y, en caso contrario, nos da falso

<= menor o igual a, x<=y nos da verdadero si x es menor o igual a y, en caso contrario, nos da falso

== igual a, x==y nos da verdadero si x es igual a y, en caso contrario, nos da falso

!= diferente, x!=y nos da verdadero si x es diferente de y, en caso contrario, nos da falso

Tenemos también los operadores lógicos &&, || y !, que representan la conjunción y, la disjuntiva o y el no: Establecidos los valores booleanos x e y , x && y será verdadera si x e y lo son también; será falsa si no lo son (si las dos son falsas o si una es verdadera y la otra falsa).
x || y sará vedadera si x o y o los dos son verdaderas (será falsa sólo si los dos son falsos). !x será verdadera si x es falsa, mientras será falsa si x es verdadera.
Tenemos los operadores binarios orientados hacia los bit:

&, AND bit a bit
| , OR bit a bit
^, OR EXCLUSIVO, bit a bit
y los shift, >>, <<, >>>.


Estas operaciones binarias son muy útiles para construir las matrices.

El último operador es el condicional que nos permite definir expresiones con dos diferentes resultados según un valor booleano.
Pongamos el siguiente ejemplo:

ent ValorAbsoluto = ( a<0 ? -a : a );

ValorAbsoluto tendrá el valor -a si a es negativo o si a es positivo o nulo.
Llegados a este punto, podemos escribir todas las expresiones que queramos en lenguaje Java.


  Vuelva al inicio de la página