When you call button!!.setOnClickListener { ... }

You are invoking a sort of shorthand.

What you're actually doing is passing argument to setOnClickListener.  The button class has a data field called onClickListener which is a kind of object.  So, what I'm really doing is creating a new object of the appropriate type (View.OnClickListener?) and assigning my button's pointer to that object.  But since there's only one method setOnClickListener and it only takes the one parameter, I don't have to specific about this when I call the method because there's no ambiguity.

When I add a piece of code, what it's doing is creating a new object that INHERITS from View.OnClickListener and overrides one of the methods with that piece of code between the braces.  It turns that that particular only has one method that is allowed to be overridden so that there is no ambiguity about which method should get that code.

So, what I'm really doing (and kind of how Java would do it) is I'm saying

button!!.setOnClickListener (
  new View.OnClickListener {override fun onClick (View v) {  ...  }}
}

I don't actually have to say what method is beihg overridden because there's only possibility for that.  And I have to say that I'm creating a new object because there's only one parameter for setOnClickListener anyway, so I have to be creating a new View.OnClickListener object.



The main activity can create and call other activities.  Activities work a lot like how methods work.  (However, activities aren't really methods.  Activities have their own methods.)

But when one activity calls another.  The first activity freezes.  The second activity starts doing stuff.  And when the second activity is done, the first activity picks up where it left off.  (Kind of like methods.)

Activities can call other activities which can call other activities and so forth, just like methods.  If an activity starts up an activity of the same class as itself, you run the risk of infinite recursion, just like with methods.

When you create an activity, you can pass information to that new activity, just like a method can pass information through parameters.  When an activity dies, it can return information back to the first activity, just like a method can return information to the original method when it dies.