(mutable!)

public class User {
    private String name;
    private List<Order> orders;

    public User() {
        orders = new ArrayList<Order>();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Order> getOrders() {
        return orders;
    }

    public void setOrders(List<Order> orders) {
        this.orders = orders;
    }
}

public class Order {
    private int id;
    private List<Product> products;

    public Order() {
        products = new ArrayList<Product>();
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public List<Product> getProducts() {
        return products;
    }

    public void setProducts(List<Product> products) {
        this.products = products;
    }
}

public class Product {
    private int id;
    private String category;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getCategory() {
        return category;
    }

    public void setCategory(String category) {
        this.category = category;
    }
}

(immutable!)

case class User (name: String, orders: List[Order] = Nil)
 
case class Order (id: Int, products: List[Product] = Nil)

case class Product (id: Int, category: String)

Initialisierung:

val user = User(name = "Tim",  orders= List(
	Order(id = 1, products = List(
		Product(id = 1, category="Tools")))))

Ändern (nur über Kopie!)

user.copy(name = "Timo")

Gut für's Unternehmen: weckt Interesse für ein breiteres Spektrum an Entwicklern

 Nicht-Scala Entwickler werden gezwungen die Komfort-Zone zu verlassen - riesiger Lerneffekt, neue Perspektive

 Spaß

 Immutability (Collections, Objekte)

 Sehr ausgereifter funktionaler Ansatz (map-reduce, mehr als zwei Parameter bei Funktions-Referenzen etc.)

 Fehler durch mutability & Seiteneffekte werden vermieden, höhere Verständlichkeit

 Man kann durch unterbinden von null-Zuweisungen NullpointerExceptions effektiv verhindern

 (implizites) statisches Typsystem (compile-time checks)

 wenig Boilerplate, sprechende Syntax (concise)

 Java-Code und Libs können natürlich uneingeschränkt verwendet werden (Vermischung möglich)

 Non-Blocking I/O geschenkt (mit play)

 Concurrency durch Aktoren (weniger Fehleranfällig als Standard-Threading in Java)

 Scala console (repl) zum "ausprobieren" von code

 Properties based Testing mit ScalaTest

 Coole Sprachfeatures:

• Case Klassen
• Pattern Matching
• einfaches Schreiben von DSLs
• (sealed) Traits
• for-comprehension
• map & co auf Listen (nicht Streams!)
• Etiher
• Map-Syntax
• Named parameters
• Default Parameters
• tuples
• Currying
  

IDE Integration teilweise nicht optimal (allerdings: neuste SBT-Version und neueste IDEA Version funktionieren super zusammen)

 Entwicklung erstmal etwas langsamer, da noch knowhow aufgebaut werden muss

 etwas komplizierter als Java

 ScalaTest & Specs2: compilefehler sind öfter mal schwer verständlich, Fehlermeldungen sind nicht so schön wie bei Spock