Liskov Substitutionsprinzip - verletze ich es hier?

Question

Ich versuche immer noch, LSP zu verstehen. Nach dem, was ich bisher verstanden habe, sollten Subklassen/Subtypen in der Lage sein, Baseclass/Main-Typ zu ersetzen, und das Programm sollte intakt funktionieren.

Ich habe folgendes ...

abstract class Warehouse<T> { 
     private StockLoader<T> loader; 
     private List<T> stock; 

     protected setStockLoader(StockLoader loader) { 
      this.loader = loader; 
     } 

     protected List<T> getStock() { 
      return stock; 
     } 

     public void load() { 
     stock = loader.load(); 
     } 

     abstract showStock(); 
    } 

class WheatWH extends Warehouse<Wheat> { 
    @Override 
    public void showStock() { 
     // Print stocck with getStock() returns Wheat; 
    } 
} 

class RiceWH extends Warehouse<Rice> { 
    @Override 
    public void showStock() { 
     // Print stocck with getStock() returns Rice; 
    } 
} 


    interface List<T> StockLoader<T>() { 
     public List<T> load();  
    } 

    class PlainStockLoader implements StockLoader<Wheat>{ 
     public List<Wheat> load() { 
      //Code 
     } 
    } 

    class Rice { 
     ..... 
    } 

    class Wheat { 
     .... 
    } 

Ist es LSP verletzen? Wenn nicht, was würde LSP im obigen Progress verletzen? Verstößt dies auch gegen andere Prinzipien? Kann dies auf andere Weise verbessert werden?

Answer 1

Was Sie haben, sieht perfekt aus. Das Ziel wäre eine Implementierung zu haben, so dass Sie so etwas wie tun könnte:

Warehouse<Wheat> wheat = new WheatWH(); 
Warehouse<Rice> rice = new RiceWH(); 

Und dann in der Lage sein, Methoden aufrufen aus der Warehouse Klasse auf wheat und rice unabhängig von der Unterklasse sie sind. Der Code, den du bisher gemacht hast, macht das perfekt, also würde ich sagen, dass du definitiv auf dem richtigen Weg bist.