Creating and using abstract classes can feel a little abstract when you're first

learning about them.

The following code may be a bit confusing at first, but

work through the example with me.

And then if you still have questions when we're done, try watching this video again.

Or reach out for help from the Treehouse community.

Let's start in the collection class.

To make any class an abstract class, you simply add the word abstract in front.

Now, in index.php, let's try to instantiate and object from this class.

New Collection.

By adding the keyword abstract,

you prevent the object from instantiating this class.

That's good for our collection, because our collection class uses the entity

property which is not set in the collection class.

Let's remove this line.

Now, let's go into post.

This class extends the collection class, and

overrides the constructor to set the entity.

There's no easy way to require that the property is set.

Instead, we can require that a method is defined using abstract method.

Instead of relying on a child class to override the constructor,

we can have the constructor call the set entity method.

Right after we set the repo, we'll call $this->setEntity();.

Like with an interface, we can define abstract

methods to guarantee that these methods be defined in the child.

Let's preview in the browser.

Non-abstract method setEntity must contain a body.

Because all interface methods are abstract,

we don't have to use an abstract keyword when defining our method.

Within an abstract class,

all abstract methods must start with a keyword abstract.

Although interfaces are only allowed to specify public methods.

Abstract classes are allowed to specify both public and

protected methods, but not private methods.

If we try to define an abstract method as private, we'll get another error.

Both private and protected methods are restricted to internal access only.

However, private methods cannot be overridden by a child class.

Because abstract methods must be defined in a child, this is a forced override.

We cannot use private access because it cannot be overridden.

Instead, we can use protected.

Protected methods can be overridden by a child class,

but they are restricted to internal access only.

This is exactly what we want for our internal setEntity method.

Were ready to update our post class.

Extending an abstract class works exactly the same way as extending any other class.

So we don't need to change anything there.

However, since we have added another abstract method, we

do need to make sure that our post class implements this new setEntity method.

Instead of extending the constructor, we make this the setEntity method.

Let's preview our site again.

Great, we've cleaned up our errors and everything is working again.

Now, let's take a closer look at combining interfaces and abstract classes.