🐠
Operadores
CASTING
En Java, el término "casting" se refiere a la conversión de un objeto de un tipo
a otro. Esto se hace mediante la sintaxis de la palabra clave (tipo) .
Hay dos tipos principales de casting en Java:
1. Casting implícito: Ocurre cuando se convierte un tipo de dato de menor
precisión a un tipo de dato de mayor precisión. Java realiza esto
automáticamente sin necesidad de intervención del programador. Por
ejemplo:
int entero = 10;
double decimal = entero; // Conversión implícita de int
a double
2. Casting explícito: Ocurre cuando se convierte un tipo de dato de mayor
precisión a un tipo de dato de menor precisión. Este tipo de casting
requiere intervención explícita del programador y puede generar pérdida de
datos si el valor no cabe en el rango del tipo al que se está convirtiendo.
Por ejemplo:
Operadores 1
double decimal = 10.5;
int entero = (int) decimal; // Conversión explícita de d
ouble a int
Es importante tener cuidado al realizar casting explícito, ya que puede provocar
errores si no se manejan adecuadamente los límites de los tipos de datos.
public class Main {
public static void main(String[] args) {
double decimal = 10.5;
int entero = (int) decimal; // Casting explícito de
double a int
[Link]("Valor decimal: " + decimal);
[Link]("Valor entero después del castin
g: " + entero);
// Operaciones aritméticas con valores enteros
entero = entero + 5;
[Link]("Valor entero después de sumar
5: " + entero);
// Operaciones aritméticas con valores decimales
decimal = entero / 2.0; // División entre un entero
y un double
[Link]("Valor decimal después de dividi
r entre 2: " + decimal);
}
}
En este ejemplo, estamos realizando casting explícito de un double a un int .
Luego, realizamos algunas operaciones aritméticas tanto con valores enteros
como con valores decimales. En la división, hemos usado 2.0 en lugar de 2
para asegurarnos de que la división se realice como una operación de punto
flotante, ya que si usamos 2 , Java considerará que ambos operandos son
enteros y el resultado será un entero, lo que podría no ser lo esperado.
Operadores 2
Operadores lógicos en Java
En Java, los operadores lógicos se utilizan para realizar operaciones de
comparación lógica entre dos o más valores booleanos. Estos operadores se
utilizan principalmente en las expresiones condicionales y en las estructuras de
control de flujo como if , while , for , entre otras. Los operadores lógicos
principales en Java son:
1. AND lógico ( && ): Este operador devuelve true si y solo si ambas
expresiones booleanas que conecta son true . Si alguna de las expresiones
es false , el resultado será false .
2. OR lógico ( || ): Este operador devuelve true si al menos una de las
expresiones booleanas que conecta es true . Solo devuelve false si ambas
expresiones son false .
3. NOT lógico ( ! ): Este operador se utiliza para negar una expresión
booleana. Si la expresión es true , devuelve false ; si es false , devuelve
true .
Aquí tienes un ejemplo de cómo se utilizan estos operadores en Java:
public class Main {
public static void main(String[] args) {
boolean a = true;
boolean b = false;
// AND lógico
boolean resultadoAnd = a && b; // resultadoAnd será
false
// OR lógico
boolean resultadoOr = a || b; // resultadoOr será t
rue
// NOT lógico
boolean resultadoNotA = !a; // resultadoNotA será f
alse
boolean resultadoNotB = !b; // resultadoNotB será t
rue
Operadores 3
[Link]("Resultado del AND lógico: " + r
esultadoAnd);
[Link]("Resultado del OR lógico: " + re
sultadoOr);
[Link]("Resultado del NOT lógico para
a: " + resultadoNotA);
[Link]("Resultado del NOT lógico para
b: " + resultadoNotB);
}
}
Este programa imprimirá:
Resultado del AND lógico: false
Resultado del OR lógico: true
Resultado del NOT lógico para a: false
Resultado del NOT lógico para b: true
Es importante recordar que los operadores lógicos tienen cortocircuitos, lo que
significa que en ciertas situaciones, Java no evaluará todas las expresiones.
Por ejemplo, en una expresión a && b , si a es false , Java no evaluará b , ya
que sabe que el resultado final de la expresión será false independientemente
del valor de b . Esto puede ser útil para mejorar la eficiencia en ciertos casos.
Operador ternario
El operador ternario en Java es una forma concisa de escribir una expresión
condicional. Tiene la siguiente sintaxis:
javaCopy code
condición ? expresión1 : expresión2
La condición es una expresión booleana que se evalúa como true o false . Si la
condición es true , se evalúa y devuelve expresión1 ; de lo contrario, se evalúa y
Operadores 4
devuelve expresión2 .
Aquí tienes un ejemplo para ilustrar su uso:
javaCopy code
public class Main {
public static void main(String[] args) {
int edad = 20;
// Operador ternario para determinar si una persona
es mayor de edad
String mensaje = (edad >= 18) ? "Es mayor de edad"
: "Es menor de edad";
[Link](mensaje);
}
}
En este ejemplo, si edad es mayor o igual a 18, la condición (edad >= 18) será
true, por lo que la variable mensaje contendrá el valor "Es mayor de edad" . De lo
contrario, contendrá el valor "Es menor de edad" .
El operador ternario es útil para simplificar expresiones condicionales simples y
mantener el código limpio y legible. Sin embargo, se debe tener cuidado de no
abusar de su uso, ya que puede hacer que el código sea difícil de entender si
se utiliza en situaciones complejas.
Operadores 5
Operadores 6