El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Conceptes Bàsics de Scala: Sintaxi i Estructura

Següent ►
►

En aquest tema, explorarem els conceptes bàsics de la sintaxi i l'estructura de Scala. Aquest és un pas fonamental per a qualsevol programador que vulgui aprendre Scala, ja que proporciona les bases necessàries per comprendre i escriure codi en aquest llenguatge.

Índex

  1. Introducció a la Sintaxi de Scala
  2. Estructura Bàsica d'un Programa Scala
  3. Comentaris en Scala
  4. Declaració de Variables
  5. Tipus de Dades
  6. Operadors Bàsics
  7. Exercicis Pràctics

  1. Introducció a la Sintaxi de Scala

Scala és un llenguatge de programació que combina característiques de la programació orientada a objectes i la programació funcional. La seva sintaxi és concisa i expressiva, permetent escriure codi clar i mantenible.

Característiques Clau:

  • Tipatge Estàtic: Scala és un llenguatge amb tipatge estàtic, el que significa que els tipus de dades es determinen en temps de compilació.
  • Inferència de Tipus: Scala pot inferir els tipus de dades, reduint la necessitat d'especificar-los explícitament.
  • Interoperabilitat amb Java: Scala és totalment interoperable amb Java, permetent utilitzar biblioteques i codi Java dins de Scala.

  1. Estructura Bàsica d'un Programa Scala

Un programa Scala típic consisteix en una o més classes i objectes. A continuació es mostra un exemple bàsic d'un programa Scala:

object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("Hola, món!")
  }
}

Explicació del Codi:

  • object HelloWorld: Defineix un objecte anomenat HelloWorld. Els objectes en Scala són instàncies úniques (singletons).
  • def main(args: Array[String]): Unit: Defineix el mètode main, que és el punt d'entrada del programa. Rep un array de cadenes com a argument.
  • println("Hola, món!"): Imprimeix "Hola, món!" a la consola.

  1. Comentaris en Scala

Els comentaris són importants per documentar el codi i fer-lo més llegible. Scala suporta dos tipus de comentaris:

  • Comentaris de Línia: Utilitzen // i s'estenen fins al final de la línia.
  • Comentaris de Bloc: Utilitzen /* ... */ i poden abastar múltiples línies.

Exemple:

// Aquest és un comentari de línia
/*
  Aquest és un comentari de bloc
  que abasta múltiples línies
*/

object Comentaris {
  def main(args: Array[String]): Unit = {
    println("Comentaris en Scala")
  }
}

  1. Declaració de Variables

En Scala, les variables es poden declarar utilitzant les paraules clau val i var:

  • val: Defineix una variable immutable (const).
  • var: Defineix una variable mutable.

Exemple:

val x: Int = 10  // Variable immutable
var y: Int = 20  // Variable mutable

y = 30  // Això és vàlid
// x = 15  // Això produirà un error, ja que x és immutable

  1. Tipus de Dades

Scala suporta diversos tipus de dades bàsics, incloent:

  • Numèrics: Int, Long, Float, Double
  • Caràcters: Char
  • Booleans: Boolean
  • Cadenes: String

Exemple:

val a: Int = 5
val b: Double = 5.5
val c: Char = 'A'
val d: Boolean = true
val e: String = "Hola, Scala"

  1. Operadors Bàsics

Scala suporta una varietat d'operadors per realitzar operacions aritmètiques, de comparació i lògiques.

Operadors Aritmètics:

  • + (suma)
  • - (resta)
  • * (multiplicació)
  • / (divisió)
  • % (mòdul)

Exemple:

val sum = 10 + 5  // 15
val diff = 10 - 5  // 5
val prod = 10 * 5  // 50
val quot = 10 / 5  // 2
val mod = 10 % 3  // 1

Operadors de Comparació:

  • == (igual a)
  • != (diferent de)
  • > (més gran que)
  • < (menys que)
  • >= (més gran o igual a)
  • <= (menys o igual a)

Exemple:

val isEqual = (10 == 10)  // true
val isNotEqual = (10 != 5)  // true
val isGreater = (10 > 5)  // true
val isLesser = (10 < 5)  // false
val isGreaterOrEqual = (10 >= 10)  // true
val isLesserOrEqual = (10 <= 5)  // false

Operadors Lògics:

  • && (AND lògic)
  • || (OR lògic)
  • ! (NOT lògic)

Exemple:

val andResult = (true && false)  // false
val orResult = (true || false)  // true
val notResult = !true  // false

  1. Exercicis Pràctics

Exercici 1:

Escriu un programa Scala que declari dues variables, a i b, amb valors enters. Calcula la suma, resta, producte, quocient i mòdul de a i b i imprimeix els resultats.

Solució:

object OperacionsBasiques {
  def main(args: Array[String]): Unit = {
    val a: Int = 15
    val b: Int = 4

    val suma = a + b
    val resta = a - b
    val producte = a * b
    val quocient = a / b
    val modul = a % b

    println(s"Suma: $suma")
    println(s"Resta: $resta")
    println(s"Producte: $producte")
    println(s"Quocient: $quocient")
    println(s"Mòdul: $modul")
  }
}

Exercici 2:

Escriu un programa Scala que declari una variable booleana isScalaFun i imprimeixi "Scala és divertida!" si isScalaFun és true, i "Scala no és divertida!" si isScalaFun és false.

Solució:

object ScalaFun {
  def main(args: Array[String]): Unit = {
    val isScalaFun: Boolean = true

    if (isScalaFun) {
      println("Scala és divertida!")
    } else {
      println("Scala no és divertida!")
    }
  }
}

Conclusió

En aquesta secció, hem cobert els conceptes bàsics de la sintaxi i l'estructura de Scala, incloent la declaració de variables, tipus de dades i operadors bàsics. Aquests fonaments són essencials per avançar en l'aprenentatge de Scala i construir programes més complexos. En el proper tema, explorarem les variables i els tipus de dades en més detall.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats