Java proporciona muchos tipos de operadores que se pueden utilizar según la necesidad. Se clasifican en función de la funcionalidad que proporcionan. Algunos de los tipos son:
- Operadores aritméticos
- Operadores unarios
- Operador de asignación
- Operadores relacionales
- Operadores logicos
- Operador Ternario
- Operadores bit a bit
- Operadores de Turno
- instancia de operador
Echemos un vistazo a ellos en detalle.
1. Operadores aritméticos: se utilizan para realizar operaciones aritméticas simples en tipos de datos primitivos.
- * : Multiplicación
- / : División
- % : Módulo
- + : Adición
- – : Resta
2. Operadores unarios: los operadores unarios necesitan solo un operando. Se utilizan para incrementar, decrementar o negar un valor.
- – : Unario menos , usado para negar los valores.
- + : Unario más indica el valor positivo (sin embargo, los números son positivos sin esto). Realiza una conversión automática a int cuando el tipo de su operando es byte, char o short. Esto se llama promoción numérica unaria.
- ++: Operador de incremento , utilizado para incrementar el valor en 1. Hay dos variedades de operadores de incremento.
- Post-Incremento: El valor se usa primero para calcular el resultado y luego se incrementa.
- Pre-Incremento: El valor se incrementa primero y luego se calcula el resultado.
- — : Operador de decremento , utilizado para decrementar el valor en 1. Hay dos variedades de operadores de decremento.
- Post-decremento: el valor se usa primero para calcular el resultado y luego se decrementa.
- Decremento previo: el valor se decrementa primero y luego se calcula el resultado.
- ! : Operador lógico no , utilizado para invertir un valor booleano.
3. Operador de asignación: ‘=’ El operador de asignación se utiliza para asignar un valor a cualquier variable. Tiene una asociatividad de derecha a izquierda, es decir, el valor dado en el lado derecho del operador se asigna a la variable de la izquierda y, por lo tanto, el valor del lado derecho debe declararse antes de usarlo o debe ser una constante.
El formato general del operador de asignación es:
variable = value;
En muchos casos, el operador de asignación se puede combinar con otros operadores para crear una versión más corta de la declaración llamada Declaración compuesta . Por ejemplo, en lugar de a = a+5, podemos escribir a += 5.
- += , para sumar el operando izquierdo con el operando derecho y luego asignarlo a la variable de la izquierda.
- -= , para restar el operando derecho del operando izquierdo y luego asignarlo a la variable de la izquierda.
- *= , para multiplicar el operando izquierdo con el operando derecho y luego asignarlo a la variable de la izquierda.
- /= , para dividir el operando izquierdo por el operando derecho y luego asignarlo a la variable de la izquierda.
- %= , para asignar el módulo del operando izquierdo por el operando derecho y luego asignarlo a la variable de la izquierda.
4. Operadores relacionales: estos operadores se utilizan para verificar relaciones como igualdad, mayor que y menor que. Devuelven resultados booleanos después de la comparación y se utilizan ampliamente en instrucciones de bucle, así como en declaraciones condicionales if-else. El formato general es,
variable relation_operator value
- Algunos de los operadores relacionales son:
- ==, Igual a devuelve verdadero si el lado izquierdo es igual al lado derecho.
- !=, No igual a devuelve verdadero si el lado izquierdo no es igual al lado derecho.
- <, menor que: devuelve verdadero si el lado izquierdo es menor que el lado derecho.
- <=, menor o igual que devuelve verdadero si el lado izquierdo es menor o igual que el lado derecho.
- >, mayor que: devuelve verdadero si el lado izquierdo es mayor que el lado derecho.
- >=, mayor o igual que devuelve verdadero si el lado izquierdo es mayor o igual que el lado derecho.
5. Operadores lógicos: estos operadores se utilizan para realizar operaciones de «Y lógico» y «O lógico», es decir, una función similar a la puerta AND y la puerta OR en la electrónica digital. Una cosa a tener en cuenta es que la segunda condición no se evalúa si la primera es falsa, es decir, tiene un efecto de cortocircuito. Se usa ampliamente para probar varias condiciones para tomar una decisión. Java también tiene «NO lógico», que devuelve verdadero cuando la condición es falsa y viceversa
Los operadores condicionales son:
- &&, Y lógico: devuelve verdadero cuando ambas condiciones son verdaderas.
- ||, OR lógico: devuelve verdadero si al menos una condición es verdadera.
- !, NOT lógico: devuelve verdadero cuando una condición es falsa y viceversa
6. Operador ternario: El operador ternario es una versión abreviada de la instrucción if-else. Tiene tres operandos y de ahí el nombre ternario.
El formato general es:
condition ? if true : if false
La declaración anterior significa que si la condición se evalúa como verdadera, entonces ejecute las declaraciones después del ‘?’ de lo contrario, ejecute las declaraciones después de ‘:’.
Java
// Java program to illustrate
// max of three numbers using
// ternary operator.
public class operators {
public static void main(String[] args)
{
int a = 20, b = 10, c = 30, result;
// result holds max of three
// numbers
result
= ((a > b) ? (a > c) ? a : c : (b > c) ? b : c);
System.out.println("Max of three numbers = "
+ result);
}
}
Max of three numbers = 30
7. Operadores bit a bit: estos operadores se utilizan para realizar la manipulación de bits individuales de un número. Se pueden utilizar con cualquiera de los tipos enteros. Se utilizan al realizar operaciones de actualización y consulta de los árboles indexados binarios.
- &, Operador AND bit a bit: devuelve AND bit a bit de los valores de entrada.
- |, Operador OR bit a bit: devuelve bit a bit OR de los valores de entrada.
- ^, operador XOR bit a bit: devuelve el XOR bit a bit de los valores de entrada.
- ~, Operador de complemento bit a bit: Este es un operador unario que devuelve la representación en complemento a uno del valor de entrada, es decir, con todos los bits invertidos.
8. Operadores de desplazamiento: estos operadores se utilizan para desplazar los bits de un número hacia la izquierda o hacia la derecha, multiplicando o dividiendo el número por dos, respectivamente. Se pueden utilizar cuando tenemos que multiplicar o dividir un número por dos. formato general-
number shift_op number_of_places_to_shift;
- <<, Operador de desplazamiento a la izquierda: desplaza los bits del número a la izquierda y llena 0 en los vacíos que quedan como resultado. Efecto similar a multiplicar el número con alguna potencia de dos.
- >>, operador de desplazamiento a la derecha con signo: desplaza los bits del número a la derecha y rellena 0 en los vacíos que quedan como resultado. El bit más a la izquierda depende del signo del número inicial. Efecto similar a dividir el número con alguna potencia de dos.
- >>>, operador de desplazamiento a la derecha sin signo: desplaza los bits del número a la derecha y, como resultado, llena 0 en los vacíos que quedan. El bit más a la izquierda se establece en 0.
9. operador instanceof: la instancia del operador se utiliza para la verificación de tipo. Se puede usar para probar si un objeto es una instancia de una clase, una subclase o una interfaz. formato general-
object instance of class/subclass/interface
Java
// Java program to illustrate
// instance of operator
class operators {
public static void main(String[] args)
{
Person obj1 = new Person();
Person obj2 = new Boy();
// As obj is of type person, it is not an
// instance of Boy or interface
System.out.println("obj1 instanceof Person: "
+ (obj1 instanceof Person));
System.out.println("obj1 instanceof Boy: "
+ (obj1 instanceof Boy));
System.out.println("obj1 instanceof MyInterface: "
+ (obj1 instanceof MyInterface));
// Since obj2 is of type boy,
// whose parent class is person
// and it implements the interface Myinterface
// it is instance of all of these classes
System.out.println("obj2 instanceof Person: "
+ (obj2 instanceof Person));
System.out.println("obj2 instanceof Boy: "
+ (obj2 instanceof Boy));
System.out.println("obj2 instanceof MyInterface: "
+ (obj2 instanceof MyInterface));
}
}
class Person {
}
class Boy extends Person implements MyInterface {
}
interface MyInterface {
}
obj1 instanceof Person: true obj1 instanceof Boy: false obj1 instanceof MyInterface: false obj2 instanceof Person: true obj2 instanceof Boy: true obj2 instanceof MyInterface: true
Precedencia y asociatividad de operadores
Las reglas de precedencia y asociativas se utilizan cuando se trata de ecuaciones híbridas que involucran más de un tipo de operador. En tales casos, estas reglas determinan qué parte de la ecuación considerar primero, ya que puede haber muchas valoraciones diferentes para la misma ecuación. La siguiente tabla muestra la precedencia de los operadores en orden decreciente como magnitud, con la parte superior representando la precedencia más alta y la inferior mostrando la precedencia más baja.
Preguntas interesantes sobre los operadores
1. Precedencia y asociatividad: a menudo hay confusión cuando se trata de ecuaciones híbridas que son ecuaciones que tienen múltiples operadores. El problema es qué parte resolver primero. Hay una regla de oro a seguir en estas situaciones. Si los operadores tienen precedencia diferente, resuelva primero la precedencia más alta. Si tienen la misma precedencia, resuelve según la asociatividad, es decir, de derecha a izquierda o de izquierda a derecha. La explicación del programa a continuación está bien escrita en comentarios dentro del propio programa.
Java
public class operators {
public static void main(String[] args)
{
int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;
// precedence rules for arithmetic operators.
// (* = / = %) > (+ = -)
// prints a+(b/d)
System.out.println("a+b/d = " + (a + b / d));
// if same precedence then associative
// rules are followed.
// e/f -> b*d -> a+(b*d) -> a+(b*d)-(e/f)
System.out.println("a+b*d-e/f = "
+ (a + b * d - e / f));
}
}
a+b/d = 20 a+b*d-e/f = 219
2. Sea un compilador: el compilador en nuestros sistemas utiliza una herramienta lex para hacer coincidir la mayor coincidencia al generar tokens. Esto crea un pequeño problema si se pasa por alto. Por ejemplo, considere la declaración a=b+++c ; muchos de los lectores pueden parecer que crean un error de compilación. Pero esta declaración es absolutamente correcta ya que los tokens creados por lex son a, =, b, ++, +, c. Por lo tanto, esta declaración tiene un efecto similar de primero asignar b+c a a y luego incrementar b. Del mismo modo, a=b++++c; generaría un error ya que los tokens generados son a, =, b, ++, ++, +, c. lo que en realidad es un error ya que no hay operando después del segundo operando unario.
Java
public class operators {
public static void main(String[] args)
{
int a = 20, b = 10, c = 0;
// a=b+++c is compiled as
// b++ +c
// a=b+c then b=b+1
a = b++ + c;
System.out.println("Value of a(b+c), "
+ " b(b+1), c = " + a + ", " + b
+ ", " + c);
// a=b+++++c is compiled as
// b++ ++ +c
// which gives error.
// a=b+++++c;
// System.out.println(b+++++c);
}
}
Value of a(b+c), b(b+1), c = 10, 11, 0
3. Usando + sobre(): cuando use el operador + dentro de system.out.println() , asegúrese de hacer la suma usando paréntesis. Si escribimos algo antes de hacer la suma, entonces se lleva a cabo la suma de strings, es decir, la asociatividad de la suma es de izquierda a derecha y, por lo tanto, los enteros se agregan a una string produciendo primero una string, y los objetos de string se concatenan cuando se usa +. Por lo tanto, puede crear resultados no deseados.
Java
public class operators {
public static void main(String[] args)
{
int x = 5, y = 8;
// concatenates x and y as
// first x is added to "concatenation (x+y) = "
// producing "concatenation (x+y) = 5"
// and then 8 is further concatenated.
System.out.println("Concatenation (x+y)= " + x + y);
// addition of x and y
System.out.println("Addition (x+y) = " + (x + y));
}
}
Concatenation (x+y)= 58 Addition (x+y) = 13
Este artículo es una contribución de Rishabh Mahrsee . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA