Scala for Backend Engineering & Functional Programming · Aula

val, var e tipos

Vinculações e inferência.

val, var e tipos é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

Vinculações em Scala

Em Scala, você dá nomes aos valores usando vinculações. As duas palavras-chave são val e var.

Um val é imutável (não pode ser reatribuído), enquanto um var é mutável (pode ser reatribuído).

Declarando um val

Um val vincula um nome a um valor uma única vez. Tentar reatribuí-lo causa um erro de compilação.

Prefira val por padrão. A imutabilidade torna o código mais fácil de compreender.

object Main {
  def main(args: Array[String]): Unit = {
    val name = "Ada"
    println(name)
  }
}

Declarando um var

Um var pode ser reatribuído com =. Use-o somente quando você realmente precisar de estado mutável.

Observe que o novo valor ainda deve ser compatível com o tipo original.

object Main {
  def main(args: Array[String]): Unit = {
    var count = 0
    count = count + 1
    count = count + 1
    println(count)
  }
}

Inferência de tipos

Em geral, o Scala deduz o tipo para você. Escrever val x = 42 faz com que x seja automaticamente um Int.

Isso é chamado de inferência de tipos: você obtém tipagem estática sem precisar escrever sempre o tipo.

object Main {
  def main(args: Array[String]): Unit = {
    val x = 42
    val pi = 3.14
    val flag = true
    println(x)
    println(pi)
    println(flag)
  }
}

Anotações de tipo explícitas

Você também pode declarar o tipo explicitamente depois de dois-pontos: val x: Int = 42.

Isso é útil para documentação ou para escolher um tipo mais abrangente que o tipo inferido.

object Main {
  def main(args: Array[String]): Unit = {
    val age: Int = 30
    val price: Double = 9.99
    val label: String = "Sale"
    println(label + ": " + price)
  }
}

Tipos numéricos comuns

Scala tem vários tipos numéricos:

Int para números inteiros
Long para números inteiros grandes
Double para números decimais
Float para números decimais menores

Um literal inteiro é, por padrão, um Int; um literal decimal é, por padrão, um Double.

object Main {
  def main(args: Array[String]): Unit = {
    val whole: Int = 7
    val big: Long = 9000000000L
    val dec: Double = 2.5
    println(whole + dec)
  }
}

Boolean e Char

Boolean armazena true ou false. Char armazena um único caractere escrito entre aspas simples.

Esses são tipos completos que você pode armazenar em vals e vars.

object Main {
  def main(args: Array[String]): Unit = {
    val isReady: Boolean = true
    val grade: Char = 'A'
    println(isReady)
    println(grade)
  }
}

Tipo String

String armazena texto entre aspas duplas. Strings são imutáveis em Scala.

Você pode concatená-las com + e chamar muitos métodos úteis nelas.

object Main {
  def main(args: Array[String]): Unit = {
    val first = "Grace"
    val last = "Hopper"
    val full = first + " " + last
    println(full.toUpperCase)
  }
}

Por que val em vez de var?

Valores imutáveis evitam toda uma classe de erros: nada mais pode alterá-los sem que você perceba.

São mais fáceis de compreender
São mais seguros em código concorrente
Estimulam um estilo funcional

Use var somente quando a mutação for realmente necessária.

Segurança de tipos na prática

Como Scala tem tipagem estática, o compilador detecta incompatibilidades de tipos antes que o programa seja executado.

Atribuir texto a um Int falharia no momento da compilação. Veja um código válido e com tipos corretos.

object Main {
  def main(args: Array[String]): Unit = {
    val quantity: Int = 3
    val unitPrice: Double = 4.50
    val total: Double = quantity * unitPrice
    println(total)
  }
}

Juntando tudo

Combine vinculações imutáveis e mutáveis com inferência e anotações em um pequeno programa.

Observe como o compilador acompanha cada tipo para você.

object Main {
  def main(args: Array[String]): Unit = {
    val base = 100
    var running = base
    val step: Int = 25
    running = running + step
    println(running)
  }
}

Verificação rápida

Verifique sua compreensão sobre vinculações e tipos.

Recapitulação

Você aprendeu como Scala dá nomes aos valores:

val é uma vinculação imutável; var é mutável
Inferência de tipos escolhe o tipo com base no valor
Você pode adicionar anotações explícitas, como val x: Int
Os tipos básicos incluem Int, Long, Double, Boolean, Char e String
Prefira val para obter um código mais seguro e claro

Perguntas Frequentes

A aula “val, var e tipos” é grátis?

Sim — o texto completo de “val, var e tipos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

O que vou aprender em “val, var e tipos”?

Vinculações e inferência. Você pratica Scala for Backend Engineering & Functional Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Scala for Backend Engineering & Functional Programming?

Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “val, var e tipos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Scala for Backend Engineering & Functional Programming?

Sim. Cada aula de Scala for Backend Engineering & Functional Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Scala for Backend Engineering & Functional Programming