A modern programming language that makes developers happier.

kotlinlang

it appears to me that kotlin is more sensitive at the class level, at order of operations? it seems to process class files/fields vertically. I don't recall java having as many cases as this does. But for instance, a class level property being referenced by the init {} block, the property must be _above_. is this behavior actually different, or just something i haven't run into enough before? What is it called?

similar as Java,
```class Foo {
  static {
    System.out.println(foo);
  }
  static int foo = 0;```
is disallowed

and for non-static, Java also rejects
```class Foo {
  int bar = foo + 1;
  int foo = 0;```

Java doesn't allow you to add arbitrary `init` blocks, so perhaps that makes it less obvious

but init {} is not static, correct? that is just the primary ctor

i guess the equivalent for many cases would just be having it in Foo() {}

&gt; Java doesn't allow you to add arbitrary `init` blocks, so perhaps that makes it less obvious
That's wrong.
Java has the same, it just has no keyword.
It just looks like a top-level (within the class body) block statement.
But it is the same meaning as an init block in Kotlin.
It is copied into all constructors.
It is for example the only way to do something in the constructor of an anonymous class.

The example from above adapted would be
```class Foo {
  {
    System.out.println(foo);
  }
  int foo = 0;
}```
and would also not compile with error "Illegal forward reference".
Here is the specification of which forward references are illegal in Java: <https://docs.oracle.com/javase/specs/jls/se18/html/jls-8.html#jls-8.3.3>

&gt; but init {} is not static, correct?
Correct, it is like in Java an initialization block

&gt; that is just the primary ctor
Neither in Java, nor in Kotlin, it is part of all constructors.
You can in such a way define things that should be done in all constructors even if not all constructors delegate to the same one in the end or similar.

&gt; i guess the equivalent for many cases would just be having it in Foo() {}
Only if it is the sole constructor.

oh I forgot about those initializer blocks, I only remembered `static`. they get compiled into the `&lt;init&gt;` methods, same in both

hmmm interesting. didn't know a lot of this