When to implement and extend?

Implement: Interfaces are abstract classes without implementation details, so you can only declare things(Contracts). A class implements an interface to make sure that it follows the interface's rules and contracts. A class can implement multiple interfaces.

Extend: You extend classes when you want a more specific version of a class. And also you don't want to repeat writing other methods that exist in the parent class.

Example:

// Contract: a pet should play
public interface Pet {
    public void play(); 
}

// An animal eats and sleeps
class Animal {
    public void eat(){ //details };
    public void sleep(){ //details };
}


public class Camel extends Animal {
    // no need to implement eat() and sleep() but
    // either of them can be implemented if needed. i.e. 
    // if Camel eats or sleeps diffrently from other animals!
}

public class Dog extends Animal implements Pet {    
    public void play() {
       // MUST implemt play() details           
    }
}

Both Camel and Dog are animals, so they extend Animal class. But only the Dog is a specific kind of Animal that also can be a Pet.

As you see this thread is closed because it's opinion-base there is no exact correct answer. It's a design choice and depends on the situation and project needs. you have both options available, now you can decide what is the best choice. for example dog class does not have to always be like in the above example, if the project is all about the different kind of dogs (and not other animals) and even their sleeping and eating difference is important! it can be like this:

// the main contract
public interface Dog {
   public void eat();
   public void sleep();
} 

// Contract
public interface Pet {
    public void play(); 
} 

// Contract
public interface Hunter {
    public void hunt();
}

public class FamilyDogs implements Dog, Pet {
    // must implement all details
} 

public class GuardDogs implements Dog, Hunter {    
    // must implement all details
}

Inheritance is useful to reduce the amount of code you rewrite. If you have several classes with a few common methods or fields, instead of defining these methods and fields over and over you can factor them into a base class and have each of the child classes extend that base class.

Interfaces (and implements) are useful when you'd like to define a common protocol for how a group of objects should behave. For example, you might want to mandate that objects that are comparable can be compared for equality and hashed, etc.

Using inheritance is ultimately a design choice. Be on the lookout for cases where you define the same methods across several classes; those are excellent cases where you can factor those methods out into a base class. The same goes for classes that observe some of the same characteristics: you can guarantee consistency by putting those characteristics in an interface to be implemented by those related classes.

Inheritance is a big concept in OOP that goes way beyond just PHP. I recommend you read the wikipedia article on inheritance and perhaps Design Patterns by the Gang of Four.

I believe your understanding of inheritance is mainly correct. The next step would be to use it in production.