Alien-Factory

1. Hello Fantom!

The classic "Hello World!" program

** Doc comments are a form of *Markdown*
** See [Fandoc]`fandoc::index`
class HelloWorld {

    Void main() {
        echo("Hello World!") 
    }   
}

Find Out More! ...

Differences from Java

Semi-colons; after every line are optional;
Document comments are in Fandoc, not HTML. (Fantom's version of Markdown)
Methods are public scope by default
main() does not need to be static or take args
Void is an object! (But not a very useful one!)
Call echo() instead of System.out.println()

2. Literals

select all

class DataTypes {
  Void main() {
    easy   := true          // --> Bool
    count  := 3             // --> Int
    pi     := 3.14f         // --> Float
    name   := "Space Alien" // --> Str
    range  := (1..3)        // --> Range

    google := `http://www.google.com` // Uri
    moment := 2sec                    // Duration
    method := DataTypes#main          // Slot

    // example of Str interpolation
    iSpy   := "I see ${count} Aliens"
  }
}

Differences from Java

Types are inferred, no need to specify the class!
Use := to declare and assign a variable
Useful types Uri, Duration and Range are built in!
Reflection has never been easier!
No primatives, everything is an Object, example: 3.toStr()
Use ${...} for Str and Uri interpolation

3. Maps and Lists

select all

class MapsAndLists {
  Void main() {
    list := ["one", "two"]     // declare List
    item := list[1]            // get item
    list.add("beer")           // add item

    map := ["foo":1, "bar":2]  // declare Map
    val := map["bar"]          // get value
    map["beer"] = 3            // set value

    emptyList := [,]
    emptyMap  := [:]
  }
}

Differences from Java

Only 1 List type and 1 Map type!
Cool syntax for declaration
Built in Generics
Maps may be ordered or case-insensitive

4. Fields

select all

class Fields {
  Int simple
  Int complex {
    get { return &complex + 1 }
    set { &complex = it * 2   }
  }

  Void main() {
    simple = 2
    echo(simple)   // --> 2

    complex = 2
    echo(complex)  // --> 5
  }
}

Differences from Java

No more boiler plate getters and setters!
Built-in accessors for get & set if you need them!
Fields have public scope by default
Easy reflection: Fields#complex.get()

5. Methods

select all

class Methods {
  Str simple() {
    "Simon"
  }

  Int maths(Int x, Int y := 2) {
    return x + y
  }

  Void main() {
    a := simple       // --> "Simon"
    b := maths(4)     // --> 6
    c := maths(4, 5)  // --> 9
  }
}

Differences from Java

Brackets() optional when calling methods with no arguments. E.g. simple() vs. simple
return keyword optional for single statement methods
Method parameters can have default values
Methods have public scope by default
Fantom does not support method overloading:
- 90% of cases solved with default parameter values
- 10% of cases solved by renaming the method
Easy reflection: Methods#simple.call()

6. Classes

select all

class MyClass {
  new makeFromStr(Str str) {
    echo("Made with ${str}")
  }
}

class Class2 {
  Void main() {
    obj1 := MyClass.makeFromStr("Love")

    // ctor name is optional 
    obj2 := MyClass("Love")
  }
}

Differences from Java

Ctors are methods that return new
Name ctors anything you like. (By convention they start with 'make')
Instantiate classes by calling ctors like static methods. (Don't use new keyword)
Instantiating with ctor name is optional.

7. Mixins

select all

class MyMixin : MyOtherMixin {
  // num must be implemented in subclasses
  abstract Int num

  // add1() *must* be overridden
  abstract Void add1(Int i)

  // add2() *cannot* be overridden
  Void add2(Int i) { echo(num + i) }

  // add3() *may* be overridden
  virtual Void add3(Int i) { echo(num + i) }

  // use the override keyword to override
  override Str toStr() { num.toStr }
}

Differences from Java

Interfaces are called mixins
Use : in place of extends and implements.
Mixin methods can have implementations!
Mixins can define fields, but can not hold their values.
All abstract methods have to be overridden.
Only virtual methods may be overridden.
Fields may override simple methods.

8. Packaging

select all

// import entire pods
using xml
// import single classes
using util::Random
// import and rename single classes
using util::Random as Wibble

class Packaging {
  // XParser is in the 'xml' pod
  html := XParser("<html/>".in).parse

  num1 := Random().next

  num2 := Wibble().next
}

Differences from Java

Fantom libraries are called pods, not jars.
Use using instead of import.
There is no package hierarchy / directory structure, just pods!
Import entire pods or single classes.
Rename imported classes to avoid name clashes.
Build pods with Fantom scripts named build.fan (No need for Ant, Maven, Gradle, Buildr, ...)
pods may also contain source code, documentaion, images, resources...

9. Unit Testing

select all

   
class MyUnitTest : Test {

  // called before every test method
  override Void setup() { ... }
  // called before after test method
  override Void teardown() { ... }

  // test method
  Void testStuff() {
    // verify methods are in Test 
    super.verifyEq(21 * 2, 42)
    // 'super' is optional
    verifyNotNull(43)
  }
}

Differences from Java

Fantom has Unit testing Built-in!
Just extend the Test class.
setup and teardown methods.
Run from the cmd line with:
C:\>fant MyUnitTest.fan

10. Null or Not-Null!?

select all

class Nullables {
  Void main() {
    Str  neverNull := "hello"
    Str? maybeNull := "moto"

    neverNull = null  // compilation error
    maybeNull = null  // okay

    // null-safe operator 
    maybeNull?.reverse()

    // elvis operator
    notNull := maybeNull ?: "wotever"
  }
}

Differences from Java

No more NullPointerExceptions!
Every type has a nullable and not-nullable version
Only nullable types can be null - you're in control!
Null safe shortcut operators
Elvis operators

Fantom Syntax for Java Programmers

This slideshow shows some of the syntactical differences between Fantom and Java. Each slide displays a concise Fantom code example and explains how it differs from Java.

Click a title below to show the slide above, then mouse hover over it to prevent cycling.

Try out any example online, with the Fantom Coding Ground!

Edits

29 July 2016 - Restyled and reworded as part of the article migration to alienfactory.co.uk.

2 August 2014 - Original article.

Written by Steve Eynon ( ) on 2nd August 2014
Last edited on 29th July 2016
Tags: Beginner, Java, Fun, Popular

Syntax Showdown - Fantom vs Java

1. Hello Fantom!

Differences from Java

2. Literals

Differences from Java

3. Maps and Lists

Differences from Java

4. Fields

Differences from Java

5. Methods

Differences from Java

6. Classes

Differences from Java

7. Mixins

Differences from Java

8. Packaging

Differences from Java

9. Unit Testing

Differences from Java

10. Null or Not-Null!?

Differences from Java

Fantom Syntax for Java Programmers

Edits

Discuss