Question

Consider the following class hierarchy:

Abstract class Printer{
    public print(){
        //code to handle printing
    }
}

class LaserPrinter extends Printer{
    private $file;
    public setFile($file){
        $this->file = $file; 
    }
}

class InkJetPrinter extends Printer{
    private $document;
    public setDocument($document){
        $this->document= $document; 
    }
}

class ClientClass{
    private $filesToPrint=array();
    public __construct(InkJetPrinter $inkJetPrinter, LaserPrinter $laserPrinter){   //I was hoping to apply Dependency Inversion here by defining both inputs as type Printer instead
         //constructor stuff    
    }

    public function startPrinting(){
         //some logic to extract the $files and $documents from $this->filesToPrint
         //...
         $this->inkJetPrinter->setDocument($document);//<---Things got messy here
         $this->laserPrinter->setFile($file);//<---and here too
         //...
    }
}

Now the class LaserPrinter can’t be replaced by its parent Printer because Printer doesn’t have setFile method.
Does that mean that his hierarchy breaks the Liskov substitution principle? Are subclasses not allowed to have their own public methods?

Answer 1

First of all, I assume that you have inheritance in that code, although I can’t see anything that hints that LaserPrinter or InkJetPrinter inherit from Printer.

No, it doesn’t break the Liskov principle, because the subclass needs to behave properly when it’s used as a Printer.

The bit that might be triggering your question is that the classes also should use Depedency Inversion, so the fully constructed LaserPrinter should be passed to anything that uses a Printer. In the example you have there, can the file change once LaserPrinter is created?

If the file doesn’t need to change, then you probably want to pass it in the constructor of LaserPrinter. If the file can change, then you want to: create the file name inside LaserPrinter or create a new class which creates the file names and then inject the class in LaserPrinter.

You might want to read about the Open/Closed and Dependency Inversion principles, as I think they are very closely related to your question.

---

edit

After looking at the code again, there’s something that I find odd. Printer.print() should receive a parameter describing what to print. Having the LaserPrinter or InkJetPrinter reference what they need to print from an instance variable looks wrong.

For example you don’t say: Printer, here you have a document… now print it.

It’s more like Printer, now that you’re fully configured and running, print this document

It looks like you already have an object that represents what you want to print (that encapsulates a document and file). You can pass that object and have something like print(jobDetail).