Programación en Java. Operadores

Las funciones matemáticas forman parte de una clase llamada «Math», por lo que tienen nombres compuestos que empiezan por «Math» como Math.sqrt para la función de raíz cuadrada. Por ejemplo para calcular la raíz cuadrada de x y asignar la respuesta a y debería escribir:

 y=Math.sqrt(x);

Aquí hay una lista de las funciones matemáticas mas importantes definidas en la clase Math:

  •  Math.abs(x) calcula el valor absoluto de x.
  • Las funciones trigonométricas usuales, Math.sin(x), Math.cos(x), y Math.tan(x).
  • Las funciones trigonométricas inversas arcoseno, arcocoseno y arcotangente que se escriben como Math.asin(x), Math.acos(x), y Math.atan(x).
  • La función exponencial Math.exp(x) para calcular el numero e elevado a x, y la función de logaritmo natural Math.log(x) para calcular el logaritmo de x en la base e
  • Math.pow(x,y) para calcular el valor de x elevado a y.
  • Math.round(x) que redondea x al valor entero mas cercano. (Por ejemplo Math.round(3.76) es 4)
  • Math.random(). Que devuelva un valor aleatorio double en el rango 0.0<=Math.random()<1.0.
    (El ordenador realmente calcula números pseudoaleatorios, pero se pueden considerar aleatorios para muchas aplicaciones)

Para estas funciones, el tipo del argumento — el valor en el interior del paréntesis — puede ser cualquier tipo numérico. Para muchas de esas funciones, el valor calculado por la funciones es de tipo double y no el mismo que el tipo del argumento. Sin embargo, para Math.abs(x) el valor devuelto debe ser entero, si x es entero.(esto significa que Math.sqrt(9) da el valor double 3.0, pero Math.abs(9) da el valor int 9.). Observe que Math.random() no tiene ningún argumento. Sin embargo, necesita poner los paréntesis aun cuando no haya nada entre ellos. Los paréntesis, le permiten al ordenador diferenciar entre metodos y variables.

 ——————————————————————————–

Los literales, las variables y las llamadas a funciones, son expresiones simples. Las expresiones mas complejas deben ser generadas utilizando operadores para combinar la expresiones simples,.

Entre los operadores se incluyen + para sumar dos números, < para comparar dos valores y así sucesivamente.

Cuando en una expresión aparecen varios operadores, hay una cuestión de prioridad para determinar que operadores se agrupan para la evaluación. Por ejemplo, en la expresión

A+B*C,

«B*C» se calcula primero y el resultado se le añade a A.

Decimos que la multiplicación (*) tienen mayor prioridad que la suma (+).

Si la prioridad por defecto, no es lo que quiere, puede emplear los paréntesis para explicitar el orden en que lo quiere agrupar.

Por ejemplo, puede usar «(A+B)*C» si quiere sumar A a B y multiplicar el resultado por C.

El resto del articulo, define los detalles de los operadores en Java. El numero de operadores en Java, es bastante grande y aquí no voy a presentarlos todos. Los mas importantes, aparecerán aquí, otros pocos, se verán en capítulos posteriores cuando se conviertan en importantes.

 ——————————————————————————–

 Operadores aritméticos

Los operadores aritméticos, incluyen sumar, restar, multiplicar, y dividir., y se indican con +, -, *, /.

Estas operaciones, se pueden realizar con valores de tipo numérico: byte, short, int, long, float, o double.

Cuando el ordenador realiza una de estas operaciones, los dos valores que combina ha de ser del mismo tipo.

Si su programa le dice al ordenador que combine dos valores de diferente tipo, el ordenador convertirá uno de los valores al tipo del otro. Por ejemplo, para calcular

37.4+10,

el ordenador convertirá el entero 10 en numero real 10.0 y entonces calculara 37.4+10.0. (La representación interna del ordenador para 10 y 10.0, es muy diferente aunque las personas piensen que representa el mismo numero) .

Normalmente, no se debe preocupar sobre la conversión de tipos, porque el ordenador lo realiza automáticamente.

Cuando dos valores numéricos se combinan (después de realizar la conversión de tipo si es necesaria), la respuesta será del mismo tipo.

Si multiplica dos ints, obtendrá un int; si multiplica dos doubles, obtendrá un double. Esto es lo que espera, pero tiene que ser mas cuidadoso cuando emplee el operador división /. Cuando divide dos enteros, la respuesta siempre es otro entero. si en cociente tiene parte decimal, se descarta.

Por ejemplo, el valor de 7/2 es 3, y no 3.5.

Si N es una variable entera (int), N/100 es entero y 1/N es siempre igual a cero!. Esto es normalmente una fuente de errores en programación. Puede forzar al ordenador a que trabaje con números reales en la respuesta, haciendo que uno de los operandos sea real.

Para calcular 1.0/N, por ejemplo, el ordenador convierte a N a numero real para igualar el tipo al de 1.0, con lo que obtiene como respuesta un numero real.

Java también dispone de un operador para calcular el resto cuando un entero se divide por otro. Este operador se indica por %, Si A y B son enteros, entonces A%B representa el resto de la división A/B, Por ejemplo, 7%2 es 1, 34577%100 es 77 y 50%8 es 2. En la sección anterior, empleamos N%2 para calcular el resto de N dividido por 2, El resto será 0 si N es par y será 1 si es impar.

Finalmente, puede necesitar el operador unitario menos, que hace negativo a un numero.Por ejemplo, -X tiene el mismo valor que (-1)*X. Por integridad, Java también tiene el operador unitario mas, como +X, aunque realmente no hace nada.

 ——————————————————————————–

 Incremento y Decremento

Encontrara que añadir 1 a una variable es una operación extremadamente común en programación, Restar uno de una variable, es también algo bastante común. En el ejemplo de la sección anterior, vio las instrucciones:

 years = years + 1;

counter = counter+1;

La operación para sumar 1 a una variable llamada x puede ser realizada escribiendo x++ ( o si o prefiere, ++x). Esto cambia el valor de x teniendo el mismo efecto que escribir «x=x+1». Las dos instrucciones anteriores, pueden escribirse como

 years++;

counter++;

De forma similar, puede escribir x– ( o –x) para restar 1 a x. Sumar 1 a una variables se llama incrementar la variable, y restar 1 se llama decrementar. El operador ++ y — son llamados operador incremento y decremento respectivamente.

Normalmente cuando usa ++ o — escribe instrucciones como «x++,» o «x–«. Estas instrucciones son comandos para cambiar el valor de x, Sin embargo, es correcto también el usar x++, ++x, x– o –x en expresiones, o como parte de expresiones mas grandes. Esto es, puede escribir algo semejante a :

 y = x++;

y = ++x;

console.putln(–x);

z=(++x) * (y–);

La instrucción «y = x++» asigna el valor de x a y, y después suma 1 al valor de x. El valor asignado a y es el valor de la expresión x++ que se define como el valor antiguo de x, antes de sumarle 1. Esto es, si el valor de x es 6, la instrucción «y = x++» cambia el valor de x a 7 y cambia el valor de y a 6. Por otra parte, el valor de ++x se define como el nuevo valor de x, después de sumar 1. Esto es si x vale 6, la instrucción «y = ++x» cambia el valor de ambos, x e y a 7, El operador decremento, trabaja de forma semejante.

Esto puede ser confuso. Mi consejo es: No se confundan. Usen ++ y — solo en operaciones sueltas, y no en expresiones.

 ——————————————————————————–

 Operadores relacionales

Java tiene variables boleanas y expresiones de valor boleano que pueden ser usadas para expresar condiciones que pueden ser verdaderas o falsas. Una manera de crear una expresión de valor boleano, es comparar dos valores usando un operador relacional. Los operadores relacionales pueden ser usados para probar si dos valores son iguales, si uno es mayor que otro, etcétera. Los operadores operacionales en Java son: ==, !=, <, >, <=, y >=. EL significado de los operadores es:

A==B Es A «igual a » B?

A!=B Es A «no igual a» B?

A<B Es A «menor que » B?

A>B Es A «mayor que » B?

A<=B Es A «menor o igual a» B?

A>=B Es A «mayor o igual a» B?

Estos operadores se pueden emplear para comparar valores numéricos de cualquier tipo. También pueden ser usados para comparar valores tipo char. Para caracteres, < y > se definen de acuerdo al valor numérico del carácter en Unicode. (Puede no ser siempre lo que quiere. El orden alfabético no es el mismo porque las mayúsculas van antes que todas las minúsculas.)

Cuando usamos una expresión boleana, debe recordar que en lo que concierne al ordenador, los valores boleanos no son nada especial. Puede emplear valores boleanos en instrucciones while y en instrucciones if, naturalmente, pero también tendrá que asignar las variables boleanas igual que asigna valores numéricos a las variables numéricas. Las variables boleanas, pueden usarse también en expresiones boleanas. Por ejemplo

 console.put(«Entre un numero positivo: «);

int N = getInt();

boolean badInput = (N <= 0);

while (badInput) {

console.put(«He dicho un número POSITIVO: «);

N = getInt();

badInput = (N <= 0);

}

Usar aquí una variable boleana, es un poco tonto, pero si la condición que quiere probar es muy complicada, puede querer hacer sencillas comprobaciones e ir almacenando el resultado en variables boleanas.

A propósito, los operadores == y != pueden ser usados para comparar valores boleanos. Es ocasionalmente útil. Por ejemplo, puede imaginarse que hace esto?:

boolean sameSign = ((x > 0) == (y > 0));

 ——————————————————————————–

 Operadores Boleanos.

En castellano, las condiciones complejas se pueden formar usando las palabras «y», «o», y «no». Por ejemplo, » Si hay un examen y no estudia…». «y»,»o», y «no» son operadores boleanos y en Java también existen.

En Java el operador boleano «y» se representa como &&. El operador && se emplea para combinar dos valores boleanos. El resultado es un valor boleano true si los dos valores que se combinan son true, y el resultado es false si cualquiera de ellos es false. Por ejemplo,

(X==0)&&(y==0)

es true si y solo si x es igual a cero e y es igual a cero.

El operador boleano «o» se representa por ||.(Esto se supone que es dos caracteres de línea vertical). «A||B» es cierto si A es true o B es true, o si ambos son true. «A||B» es false solo si ambos,A y B son false.

Los operadores && y || se dice que son versiones de «corto-circuito» de los operadores boleanos. Esto es porque el segundo operador de &&  o || no se tiene que evaluar siempre. Considere la comprobación:

if ( (A != 0) && (B/A > 1) )

Suponga que el valor de A es cero. En este caso, la división B/A es ilegal, dado que una división por cero no esta permitida. Sin embargo, el ordenador no llegara a realizar la división, dado que cuando el ordenador evalúa (A!=0) y encuentra el resultado false, ya sabe que (A!=0)&& y cualquier cosa, también será false.

De esa manera no es necesario tomarse la molestia de evaluar el segundo operador, (B/A>1). La evaluación se ha hecho en circuito-corto, y la división por cero se ha evitado.

Sin el circuito corto, habría tenido un error de división por cero.( Esto puede parecer un tecnicismo, y lo es. Pero a veces puede hacer la vida del programador un poco mas fácil .

Para ser aun un poco mas técnicos: Realmente hay una versión de && y || que no es de circuito corto, y se escribe como & y | .No los use a menos que tenga una particular razón para hacerlo.)

El operador boleano «no» en un operador unitario. En Java, se indica con ! y se escribe delante de un operando. Por ejemplo si test en una variable boleana, entonces

test = !test;

invertirá el valor de test, cambiandolo de true a false o de false a true. Lo puede usar

if ( !( (A == 0) && (B == 0) ) )

para examinar si «no ocurre que A sea igual a cero y B sea igual a cero»

——————————————————————————–

 Operadores condicionales

Cualquier buen lenguaje de programación, tiene pequeñas características ingeniosas, que no son realmente necesarias pero que le hacen sentirse a uno tranquilo cuando las usa. Java tiene el operador condicional. Es un operador ternario, esto es, tiene tres operandos –y dividido en dos partes, ? y :, que deben emplearse conjuntamente. Esta es su forma

expresion-boleana ? expresión-1 : expresión-2

El ordenador evalúa la expresión boleana. Si el valor es true, evalúa la expresión-1, si no, evalúa la expresión-2. Por ejemplo

N = (N % 2 == 0) ? (N/2) : (3*N+1);

Tiene el mismo efecto que la instrucción if:

if (N % 2 == 0)
N = N/2;
else
N = 3*N+1;

——————————————————————————–

 Operadores de asignación

Esta bastante familiarizado con las instrucciones de asignación, que usan el operador = para asignar el valor de una expresión a una variable. De hecho, = es realmente un operador y una asignación, puede ser una expresión, o formar parte de otra expresión mas compleja. El valor de una asignación como A=B es lo mismo que el valor asignado a A, Entonces, si quiere asignar el valor de B a A y comprobar al mismo tiempo si el valor es cero, puede decir:

if ( (A=B) == 0 )

Tambien le puedo comentar, que no es lo mejor que puede hacer….

En general el tipo de la expresión que se encuentra a la derecha de la instrucción de asignación, debe ser el mismo tipo de la variable que se encuentra a la izquierda. Sin embargo, en algunos casos, el ordenador puede convertir automáticamente el tipo del valor calculado por la expresión para igualarlo al tipo de la variable. Considere la lista de los tipos numéricos:byte, short, int, long, float, double. El valor de un tipo que esta antes en la lista, puede ser convertido automáticamente a otro que este después. Por ejemplo:

int A = 17;

double X = A; // OK; A se convierte a double

short B = A; // error; no hay conversión automática de int a short

La idea de la conversión es que solo se hace automáticamente cuando no es necesario cambiar la semántica del valor. Cualquier int puede ser convertido a double con el mismo valor numérico. Sin embargo, Hay valores int que están fuera del valor correcto de los short. Es sencillo, no hay forma de representar el valor 100000 en un short.

En algunos casos puede hacer conversiones, que no se hubieran hecho de forma automática. Para ello, deberá utilizar algo llamado tipo forma (type cast). Lo puede indicar poniendo el tipo entre paréntesis delante de la variable que quiere convertir. Por ejemplo,

int A = 17;

short B = (short)A; // OK; se utiliza un cast
// para cambiar el valor
// de int a short

Esto lo puede utilizar para cambiar cualquier tipo numérico en otro distinto. Pero sea consciente que el valor del numero puede cambiar al hacer estas conversiones.Por ejemplo en int 1000000, al pasarlo a short, queda como 34464. Este numero se obtiene de tomar los 4 bytes del int 100000 y despreciar 2 para obtener el short. (Como un short solo tiene 2 bytes, no queda mas remedio que perder esa información)

También puede utilizar el cast entre variables char y numéricas. El valor numérico de un char, es el valor del código en Unicode. Por ejemplo (char)97 es ‘a’ y (int)’+’ es 43

Java tiene algunas variaciones de los operadores que sirven para evitar teclear. Por ejemplo «A+=B» es lo mismo que «A=A+B». De igual forma funcionan los operadores -=,*=,/= y %=

 Reglas de prioridad

Si en una expresión emplea varios operadores, y no utiliza paréntesis para indicar el orden de evaluación, tendrá que tener en cuenta las prioridades entre las evaluaciones.(Es mucho mas sencillo y mas claro, el emplear con toda libertad los paréntesis)

A continuación, presentamos la lista de los operadores explicados en esta sección, ordenador de mayor a menor prioridad.(se ejecutan primero los de mayor prioridad).

  •  Operadores unitarios: ++, –, !,unitarios – +,tipo forma
  • Multiplicación y división: *, /, %
  • Suma y resta : +, –
  • Operadores relacionales: <, >, <=, >=
  • Igual y desigual: ==, !=
  • Boleano y: &&
  • Boleano o: ||
  • Operador condicional: ?:
  • Operadores de asignación: = += -= *= /= %=

Los operadores que aparecen en la misma línea, tienen la misma prioridad. Cuando aparecen juntos en la misma línea, los operadores unitarios y los de asignación se evalúan de derecha a izquierda, mientras que el resto, se evalúa de izquierda a derecha. Por ejemplo. A*B/C es lo mismo que (A*B)/C, y A=B=C es lo mismo que A=(B=C) (Se le ocurre para que podría emplearse la expresión A=B=C?)

Resumen

Los operadores permiten a las expresiones combinarse en expresiones más complejas. Java proporciona una colección grande de operadores que se pueden utilizar para manipular datos, incluyendo operadores aritméticos, asignación ,lógicos y de moldeado.Las reglas de asociación y de prioridad se utilizan para determinar como evaluar expresiones utilizando operadores.

Descripción Operador Ejemplo
Paréntesis () (a+3)*2
Incremento ++ a++ //incrementa después de su uso.++a //incrementa antes de su uso.
Decremento a– //decrementa después de su uso.–a //decrementa antes de su uso.
Complemento de bits ~ ~a
Desplazamientos <<   >> a<<2b>>3
Suma + a+3
Resta a-3
Multiplicación * 3*2
División / 10/2
Módulo o resto % 7%2
Conversión o cast (tipo) expresión (float) a(float) 3,5 * 2
Relacionales <> > < >= <= a>=3
Igualdad == a==3 (a es igual a 3)
Desigualdad != a!=3 (a no es igual a 3)
And && a==3 & b!=3
Or || a==3 | b!=3
Not ! a=!a
And (bit) & x=a&b
Or (bit) | x=a|b
ternario ?: descuento = (precio > 25000) ? 0.05f : 0.02f;
Asignación =+=*=etc. b+=3 (equivalente a b=b+3)

 

Las definiciones de las operaciones OR, AND y NOT se recogen en las siguientes tablas de la verdad.

A
B
A OR B
A
B
A AND B
A
NOT A
F
F
F
F
F
F
F
V
F
V
V
F
V
F
V
F
V
F
V
V
F
F
V
V
V
V
V
V
F: Falso
V: Verdadero

Acerca de Miguel Garcia

Programador, Desarrollador web, Formador en distintas areas de informatica y director de equipos multidisciplinares.
Esta entrada fue publicada en Formacion, Java y etiquetada , . Guarda el enlace permanente.

4 respuestas a Programación en Java. Operadores

  1. Gonzalo M dijo:

    a– //decrementa después de su uso.–a //decrementa después de su uso.

    hay un error en el cuadro debería decir –a decrementa antes de su uso.

  2. Pingback: Java - Un resumen organizado....o no.Recursos para formacion

  3. Pingback: Ejercicios Java (4) – OperadoresRecursos para formacion

Deja un comentario

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.