# Basics

## Trying Scala in the Browser

You can run Scala in your browser with ScalaFiddle.

1. Go to https://scalafiddle.io.
2. Paste `println("Hello, world!")` in the left pane.
3. Hit “Run” button. Output appears in the right pane.

This is an easy, zero-setup way to experiment with pieces of Scala code.

## Expressions

Expressions are computable statements.

You can output results of expressions using `println`.

``````println(1) // 1
println(1 + 1) // 2
println("Hello!") // Hello!
println("Hello," + " world!") // Hello, world!
``````

### Values

You can name results of expressions with the `val` keyword.

``````val x = 1 + 1
println(x) // 2
``````

Named results, such as `x` here, are called values. Referencing a value does not re-compute it.

Values cannot be re-assigned.

``````val x = 1 + 1
x = 3 // This does not compile.
``````

Types of values can be inferred, but you can also explicitly state the type, like this:

``````val x: Int = 1 + 1
``````

### Variables

Variables are like values, except you can re-assign them. You can define a variable with the `var` keyword.

``````var x = 1 + 1
x = 3 // This compiles because "x" is declared with the "var" keyword.
println(x * x) // 9
``````

As with values, you can explicitly state the type if you want:

``````var x: Int = 1 + 1
``````

### Blocks

You can combine expressions by surrounding them with `{}`. We call this a block.

The result of the last expression in the block is the result of the overall block, too.

``````println({
val x = 1 + 1
x + 1
}) // 3
``````

## Functions

Functions are expressions that take parameters.

You can define a function that returns a given integer plus one:

``````(x: Int) => x + 1
``````

On the left of `=>` is a list of parameters. On the right is an expression involving the parameters.

You can also name functions.

``````val addOne = (x: Int) => x + 1
``````

Functions may take multiple parameters.

``````val add = (x: Int, y: Int) => x + y
``````

Or it can take no parameters.

``````val getTheAnswer = () => 42
``````

We will cover functions in depth later.

## Methods

Methods look and behave very similar to functions, but there are a few key differences between them.

Methods are defined with the `def` keyword. `def` is followed by a name, parameter lists, a return type, and a body.

``````def add(x: Int, y: Int): Int = x + y
``````

Methods cannot be named with the `val` or `var` keywords.

``````def add(x: Int, y: Int): Int = x + y
``````

Methods can take multiple parameter lists.

``````def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
``````

Or no parameter lists at all.

``````def name: String = System.getProperty("name")
println("Hello, " + name + "!")
``````

There are some other differences, but for now, you can think of them as something similar to functions.

## Classes

You can define classes with the `class` keyword followed by its name and constructor parameters.

``````class Greeter(prefix: String, suffix: String) {
def greet(name: String): Unit =
println(prefix + name + suffix)
}
``````

You can make an instance of a class with the `new` keyword.

``````val greeter = new Greeter("Hello, ", "!")
greeter.greet("Scala developer") // Hello, Scala developer!
``````

We will cover classes in depth later.

## Case Classes

Scala has a special type of class called a “case” class. By default, case classes are immutable and compared by value. You can define case classes with the `case class` keywords.

``````case class Point(x: Int, y: Int)
``````

You can instantiate case classes without `new` keyword.

``````val point = Point(1, 2)
val anotherPoint = Point(1, 2)
val yetAnotherPoint = Point(2, 2)
``````

And they are compared by value.

``````if (point == anotherPoint) {
println(point + " and " + anotherPoint + " are the same.")
} else {
println(point + " and " + anotherPoint + " are different.")
}
// Point(1,2) and Point(1,2) are the same.

if (point == yetAnotherPoint) {
println(point + " and " + yetAnotherPoint + " are the same.")
} else {
println(point + " and " + yetAnotherPoint + " are different.")
}
// Point(1,2) and Point(2,2) are different.
``````

There is a lot more to case classes that we’d like to introduce, and we are convinced you will fall in love with them! We will cover them in depth later.

## Objects

Objects are single instances of their own definitions. You can think of them as singletons of their own classes.

You can define objects with the `object` keyword.

``````object IdFactory {
private var counter = 0
def create(): Int = {
counter += 1
counter
}
}
``````

You can access an object by referring to its name.

``````val newId: Int = IdFactory.create()
println(newId) // 1
``````

We will cover objects in depth later.

## Traits

Traits are types containing certain fields and methods. Multiple traits can be combined.

You can define traits with `trait` keyword.

``````trait Greeter {
def greet(name: String): Unit
}
``````

Traits can also have default implementations.

``````trait Greeter {
def greet(name: String): Unit =
println("Hello, " + name + "!")
}
``````

You can extend traits with the `extends` keyword and override an implementation with the `override` keyword.

``````class DefaultGreeter extends Greeter

class CustomizableGreeter(prefix: String, postfix: String) extends Greeter {
override def greet(name: String): Unit = {
println(prefix + name + postfix)
}
}

val greeter = new DefaultGreeter()
greeter.greet("Scala developer") // Hello, Scala developer!

val customGreeter = new CustomizableGreeter("How are you, ", "?")
customGreeter.greet("Scala developer") // How are you, Scala developer?
``````

Here, `DefaultGreeter` extends only a single trait, but it could extend multiple traits.

We will cover traits in depth later.

## Main Method

The main method is an entry point of a program. The Java Virtual Machine requires a main method to be named `main` and take one argument, an array of strings.

Using an object, you can define a main method as follows:

``````object Main {
def main(args: Array[String]): Unit =
println("Hello, Scala developer!")
}
``````