Operadores
## Objetivos de Aprendizaje
- Dominar operadores aritmeticos
- Comprender operadores de comparacion
- Aprender operadores logicos
- Explorar notacion de operadores en Scala
## Operadores Aritmeticos
### Operaciones Basicas
```scala
val a = 10
val b = 3
a + b // 13 (suma)
a - b // 7 (resta)
a * b // 30 (multiplicacion)
a / b // 3 (division entera)
a % b // 1 (modulo/resto)
```
### Comportamiento de la Division
```scala
val intResult = 10 / 3 // 3 (division entera)
val doubleResult = 10.0 / 3.0 // 3.333...
// Conversion de tipo
val result = 10.toDouble / 3 // 3.333...
```
### Operaciones de Tipos Numericos
```scala
// Operaciones Int
val intMax = Int.MaxValue // 2147483647
val intMin = Int.MinValue // -2147483648
// Ejemplo de desbordamiento
val overflow = Int.MaxValue + 1 // -2147483648
// BigInt para numeros grandes
val bigNum = BigInt("12345678901234567890")
val bigResult = bigNum * bigNum
```
## Operadores de Comparacion
### Igualdad
```scala
val x = 10
val y = 20
val z = 10
x == y // false (igualdad estructural)
x != y // true
// Para objetos, == llama a equals()
val s1 = new String("hello")
val s2 = new String("hello")
s1 == s2 // true (igualdad de contenido)
s1 eq s2 // false (igualdad de referencia)
```
### Operadores Relacionales
```scala
x < y // true
x > y // false
x <= z // true
x >= z // true
// Encadenamiento (Scala 3)
1 < 2 < 3 // true
1 < 2 > 3 // false
```
## Operadores Logicos
```scala
val a = true
val b = false
!a // false (NOT)
a && b // false (AND)
a || b // true (OR)
```
### Evaluacion de Cortocircuito
```scala
def sideEffect(): Boolean = {
println("Called!")
true
}
false && sideEffect() // false, sideEffect() no se llama
true || sideEffect() // true, sideEffect() no se llama
```
## Operadores Bit a Bit
```scala
val x = 5 // 0101 en binario
val y = 3 // 0011 en binario
x & y // 1 (0101 & 0011 = 0001)
x | y // 7 (0101 | 0011 = 0111)
x ^ y // 6 (0105 ^ 0011 = 0110)
~x // -6 (NOT bit a bit)
x << 1 // 10 (desplazamiento a la izquierda)
x >> 1 // 2 (desplazamiento a la derecha, preserva signo)
x >>> 1 // 2 (desplazamiento a la derecha, llena con ceros)
```
## Notacion de Operadores
### Notacion Infija
En Scala, los metodos pueden usarse como operadores:
```scala
// Estos son equivalentes
a.+(b) // Llamada a metodo
a + b // Notacion de operador (infija)
// Funciona con cualquier metodo
a.+(b) // a + b
a.-(b) // a - b
a.*(b) // a * b
a./(b) // a / b
a.%(b) // a % b
```
### Operadores Unarios
```scala
val x = 5
+x // 5 (unario +)
-x // -5 (unario -)
!true // false
// Detras de escena
x.unary_+ // +x
x.unary_- // -x
```
### Reglas de Precedencia
```scala
// De mayor a menor precedencia
// *, /, %
// +, -
// <, >, <=, >=
// ==, !=
// &
// ^
// |
// &&
// ||
// = (asignacion)
// :, ::, +:, :+, etc.
// Todas las letras
// Todos los operadores de asignacion
```
## Operaciones con Cadenas
```scala
val str = "Hello"
// Concatenacion
"Hello" + " " + "World" // "Hello World"
str.concat(" Scala") // "Hello Scala"
// Metodos de cadena como operadores
str.take(5) // "Hello"
str.drop(5) // " Scala"
str.contains("lo") // true
str.startsWith("He") // true
str.endsWith("lo") // true
str.indexOf("lo") // 3
str.replace("H", "J") // "Jello"
str.toLowerCase // "hello"
str.toUpperCase // "HELLO"
str.trim // "Hello"
```
## Operadores de Asignacion
```scala
var x = 10
x += 5 // x = 15
x -= 3 // x = 12
x *= 2 // x = 24
x /= 4 // x = 6
x %= 4 // x = 2
// No se puede encadenar: x = y = 10 es invalido en Scala
```
## Ejemplos de Operadores
### Expresiones Matematicas
```scala
def quadraticFormula(a: Double, b: Double, c: Double): (Double, Double) = {
val discriminant = b * b - 4 * a * c
if (discriminant < 0) {
throw new Exception("No real roots")
}
val sqrtDisc = Math.sqrt(discriminant)
val root1 = (-b + sqrtDisc) / (2 * a)
val root2 = (-b - sqrtDisc) / (2 * a)
(root1, root2)
}
```
### Condiciones Logicas
```scala
def isLeapYear(year: Int): Boolean = {
(year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)
}
def gradeScore(score: Int): Char = {
if (score >= 90) 'A'
else if (score >= 80) 'B'
else if (score >= 70) 'C'
else if (score >= 60) 'D'
else 'F'
}
```
## Resumen
- Aritmeticos: `+`, `-`, `*`, `/`, `%`
- Comparacion: `==`, `!=`, `<`, `>`, `<=`, `>=`
- Logicos: `&&`, `||`, `!`
- Bit a bit: `&`, `|`, `^`, `~`, `<<`, `>>`, `>>>`
- Scala trata los operadores como metodos (notacion de operadores)
- Cualquier metodo puede usarse en notacion infija
- La precedencia sigue convenciones matematicas
- La interpolacion de cadenas y los metodos proporcionan operaciones de cadena ricas
Comments
Comments powered by Giscus
To enable comments, add your Giscus embed code here.
Learn more about Giscus →