To wrap up this part of the course, let's go back and

take a look at the list of methods the system.object provides.

As we've seen we can override most of these methods

with their own implementations.

We've seen how overwriting ToString can provide a better conversion

of objects to string.

The default implementation provided by system.object is

just to print the object's type name.

We've seen how we can redefine what it means for

two objects to be equal by overriding equals and get hash code.

There are a couple more methods in system.object, we haven't looked at yet.

Finalize is used by the memory management system,

also known as the garbage collector.

You see every time a new object is created,

it's stored some place in the computer's memory.

We may create lots and

lots of objects, eventually we don't need access to some of these objects any more.

We don't have any way to delete them from memory and free up that space for

other objects, so these objects can just sit in memory taking up space.

Periodically, .NET memory management system runs the garbage collector which

goes through the memory and

finds objects that aren't being used by the program anymore.

It removes them from the memory and frees up the space.

We're given the opportunity to run some final code

right before the object is removed, that's the purpose of the finalize method.

We can override the finalize method and write whatever code we want there.

Typically, finalize is used to close files and

clean up any other computer resources that the object may have been using.

Most of the time we don't need to think about the finalizer method.

Writing finalizer methods is something that is rare,

so we won't go into it right now.

The MemberwiseClone method is exactly what it sounds like.

It is used to create a copy of an object.

The method is protected so it's only accessible from within the subclass.

But it also can't be overridden by subclasses because it's not virtual,

this method is rarely used in practice.

So that's the system.object class.

In most cases, we don't interact with this class directly,

instead we use it indirectly through a subclass.

Because all classes inherit from system.object,

we can count on all objects having these methods.

This is just one more example of how polymorphism

with virtual methods is useful.

In the next part of this course, we'll learn about the final basic principle of

object oriented programming, abstraction.

We'll learn how C # supports this principle by

further extending the tree house defense game.