CODEWITHSUNDEEP
phpooparchitecturephp-7
ReynierPM
ReynierPM

Reputation: 18690

Multi-level inheritance in PHP classes

Lets say I have this code:

class A {
   ...
}

class B extends A {
   ...
}

class C extends B {
   ...
}

$c = new C();
$c->getMethodOrPropertyFromB()->getMethodOrPropertyFromA();

Other than a bad architecture or bad design will this have any impact on PHP / Webserver (Apache/Nginx) performance when the script executes?

If this is not recommended to have such multi-level in PHP classes, can you explain why?

Note: in addition to the answers I've got I will let this here which is helpful as well

Upvotes: 1

Views: 6863

Answers (2)

nerdlyist
nerdlyist

Reputation: 2857

My initial thought was that this may not be good for inheritance but after testing it seems okay. However, there are other means of accomplishing this you could be aware of.

Abstract classes or Interfaces may make sense.

Abstract classes are just like other classes but they cannot be instantiated. There are also abstract methods which must be implemented by concrete classes.

abstract class A {
    //You can also have abstract methods
    abstract public function doFoo();
    abstract public function doBar($when);

    //Also implemented method which when
    //called unless overridden will use this logic
    public function sayHi(){
        echo "hi";
    }
}

Now this class can choose to implement the abstract methods or not also adding any further logic needed by it.

abstract class B extends A {
    public function doFoo(){
        //Some code
    }
    abstract public function doFooBar();
    public function sayBye(){
        echo "bye";
    }
}

This is a concrete class and all abstract methods must be implemented here if not already ones that are implemented can be overridden yet again.

class C extends B {
    public function doFoo(){
        //Some different code
    }
    public function doBar($when){
        //Some code
    }
    public function doFooBar(){
        //Some code
    }

    //do not need sayHi() and  sayBye() but they will be available.
}

Interface in a simple and crude way is a bag of methods. You are simply telling the developer if you are going to use this implement these. These methods are not declared as abstract but cannot be implemented in the interface.

interface iA {
    public function doFoo();
    public function doBar();
}

An interface can be extended by other interface which is just adding more methods to the interface

interface iB extends iA {
    public function doFooBar();
}

interface iC {
    public function doAnything();
}

And implemented by classes

class A implements iA{
    public function doFoo(){
        //Some Code
    }
    public function doBar(){
        //Some Code
    }
}

class B implements iB{
    public function doFoo(){
        //Some Code
    }
    public function doBar(){
        //Some Code
    }
    public function doFooBar(){
        //Some Code
    }   
}

The added advantage of interfaces is that a class or abstract can implement more then one

abstract class C implements iA, iC {
    public function doFoo(){
        //Some Code
    }
}

class D extends C {
    //get doFoo() from C implementation and must implement the remaining...
    public function doBar(){
        //Some Code
    }
    public function doAnything(){
        //Some Code
    }
}

Upvotes: 1

codedge
codedge

Reputation: 5174

This seems perfectly fine. PHP only support single inheritance - so you can only inherit from one class. If you need more functionality in a class but cannot get the functality in a parent class you can also consider using traits. Traits try to solve the single inheritance problem - even if it's not a problem per se.

If you properly build your classes you get a nice chain of inheritance which does not have any bad influences onto Apache/Nginx.

Upvotes: 1

Related Questions