Hello. In this course

we'll take the time to really
understand the class methods.

You should have done the exercise
with the counter,

you have done a class method,
it worked very well.

Now we'll take a good look,
so you understand for once and all.

You'll learn in this course
that there's no difference in Pharo

between class and instance methods
on a search algorithm level.

There's only one search algorithm

alluded to and used,
that's defined in the virtual machine,

and you'll see that, while we could
have said that the class methods,

at first glance, are like static
Java methods, they're not.

In fact, they are dynamically linked.

There's a search at execution,

while in Java, typically,
static methods aren't dynamically sought.

Let's see how it works.

In fact, what you've seen

is that there's only one lookup,
which starts in the receiver's class.

If the method is defined in the class,

it's returned, otherwise
it continues in the superclass.

What this means, graphically,

is that I've my example
of the Counter class.

When I send the increment message,
what will happen?

Step 1, I look in the Counter class,
and I'll go back up...

If I've "increment" it's defined here,

if it's a method defined
higher up in the hierarchy

it will be sought higher up.

In fact, this mechanism is used
in Pharo, there's only one,

it's used for both instances and classes.

When you did the exercise with
the class counter and sent the message

"with value" to the class counter

to create an instance, what happened?

The class counter is instance
of a class called "Counter class"

and we looked, we used
the same method as before.

We looked in the receiver class,
the receiver was "Counter",

so we looked in the class
"Counter class" and found the method

"with value" which we applied
to the receiver

and it gave us a new instance.

So we used exactly the same process
as for the messages we sent

to an instance of the Counter class.

So what is a "class" in Pharo?
A class is an instance.

It's an object like any object.
In Pharo there are only objects.

A class is an instance
of another class, called a metaclass.

It's just to distinguish them.
A metaclass is just a class

whose instances are classes,

to differentiate between
terminal instances and classes.

The next thing is that
the Counter class, in this line,

the Counter class is the only instance
of the class Counter class.

This Counter class is created
automatically, without you knowing it.

When you defined the Counter class,
the system automatically created

the class Counter class,
and it created the Counter class.

You thought you were creating 1 class,
but in fact you were creating 2.

What you have to know in Pharo
is that all the classes

in a class called XXX
are called XXX class.

So if I have Counter,
the Counter class will be

Counter class, systematically.

So, in fact, what you do in reality,

we're just showing you how it works.
We needn't have explained it,

but it means that when
the browser shows you

the Counter class, it shows you

the code that will be executed
on the instances of this class.

That means, "increment"

is the code that will be executed
on this instance here.

When you click on the "class" button
to define a class method,

it shows you the code that will be
executed on this object here.

And in fact, if we look,
when I send the message "increment"

to the counter instance,
I'll look in the Counter class.

Look, that's the method executed.

When I send the message
"with value" to the Counter class,

where will I look? In its class.
I follow this link,

and it's this method here.

So what should you know?

A class is an object in Pharo.

A class can receive messages.

I told you when we did the syntax,

I told you date, today...

What's that? It's a message
that we sent to a class.

There are no elements
syntaxed differently.

It's the same as sending a message
syntactically to an instance.

What's more, this course shows you,
there's only one method lookup.

The class methods
are looked up dynamically

like the instance methods.
Where are they looked up?

In the class of the receiver.

When it's an instance,
it's looked up in the class,

when it's an instance class
like the Counter class

it's looked up in the metaclass,
in the class called Counter class.

So a class is an instance
of another class, called a metaclass,

and only one look up works.

So we'll return to this notion
in the final session,

in the lecture
Understanding Metaclasses

and we're going to revisit,
we're going to lift the lid on Pharo

and show you how it works,
and it's completely uniform.