Jag sitter här och funderar över hur man bäst strukturerar klasserna för en situation...

Det finns ett antal digitala produkter och till varje produkt hör ett antal filer. För detta är det förstås lämpligt att ha en klass Product samt en klass File. I klassen Product finns en metod getFiles() som returnerar en array av File-objekt.

Den knepiga biten är att en produkt med tillhörande filer kan anpassas till en användare (User). Till en anpassad produkt hör då anpassade filer. Då vill jag ha en klass UserProduct samt en klass UserFile. I UserProduct skall finnas en metod getFiles() som returnerar en array av UserFile-objekt.

Den mesta informationen som ett UserProduct-objekt eller ett UserFile-objekt returnerar via getters (egenskaper) är samma som originalen, alltså Product- resp File-objekt, returnerar. Men det finns viss information som skiljer sig.

Eftersom Product och UserProduct, liksom File och UserFile, skall ha så gott som samma gränssnitt, har jag funderat över att göra UserProduct till subklass till Product, och UserFile till subklass till File. Men jag stötte på patrull när jag skulle implementera det.

Har även funderat på att göra både Product och UserProduct till subklasser till en AbstractProduct (och motsvarande för filer), men det känns inte riktigt rätt.

Förslag?

Är det en massa logik inblandat i de här klasserna? Om inte så skulle jag nog fundera på om inte interface vore en väg att gå

Inte särskilt mycket logik, mest getters.

Kan du utveckla hur interface skulle användas?

Hur skall enklast jag få UserProduct att fungera nästan likadant som Product, och UserFile nästan likadant som File?

Enklast, utan att jag vet exakt vad det handlar om, hade nog varit att låta de modifierade sakerna ärva av de vanliga. Om det nu inte går så skulle jag tippa på att man definerar de metoder/egenskaper som en generell produkt/fil har, sedan stoppar man in dem i två interface. De interfacen låter man sedan både den generella och den modifierade produkten/filen ärva.

När man sedan ska använda en produkt så låter man koden endast använda interfacet, på så sätt bryr sig inte koden om ifall det är en generell produkt eller en modifierad produkt som används egentligen.

Jag har alltså produkter som var och en består av ett antal filer.
I kod kan jag fråga en produkt efter dess filer.

En produkt kan sedan anpassas till en köpare genom att produktens filer anpassas (t.ex. att de vattenmärks). När det har skett finns både originalprodukten, originalfilerna, den anpassade produkten och originalprodukten.

Jag vill då ha en klass för anpassade produkter och en för anpassade filer.
I kod skall jag kunna fråga en anpassad produkt efter dess filer och få de anpassade filerna, inte originalfilerna.

De flesta egenskaperna hos en anpassad produkt eller fil är samma som hos originalprodukten/-filen, men vissa egenskaper skiljer. T.ex. ger MD5 olika på original- och anpassade filer.


Blev det klarare?

Måste du ha olika klasser överhuvudtaget? Det är väl snarare koden som skapar/fyller objekten som borde ta hänsyn..?

De anpassade objekten kan ha attribut som de icke anpassade saknar. Bland annat därför tycker jag inte att det är riktigt rätt att köra med samma klass.

Hm.. Men är verkligen arv inget alternativ?

Om jag hade fått till en bra lösning med arv hade det troligen valt den lösningen.

Kan du göra UserProduct till en wrapper för Product? Din UserProduct har en privat Product variabel som gemensamma metoder vidarebefordras till.

class UserProduct {
    private Product product;
    private Date created;
    
    public UserProduct(Product product) { 
        this.product = product;
        created = new Date();
    }

    // Skickas vidare till produkten
    public String getName() {
        return product.getName();
    }

    public File[] getFiles() {
        return product.getFiles();
    }

    // Specialiserade metoder för UserProduct
    public Date getCreated() {
        return new Date(created.getTime());
    }

    public UserFile[] getUserFiles() {
        // returnera filerna
    }
}

Jag har löst det med just wrappers. UserFile är en wrapper för File, och UserProduct är en wrapper för Product. Sedan låter jag UserProduct::getFiles() anropa Product::getFiles() för att hämta originalfilerna (File), vilka sedan wrappas till UserFile som returneras.

Lyckligtvis behövde jag inte skriva en massa metoder typ
<code>
// Skickas vidare till produkten
public String getName() {
return product.getName();
}
</code>
Det gick i stället att lösa genom att lägga in en "magisk" metod som fångar alla anrop till metoder som inte är definierade. Anropen skickas vidare till det wrappade objektet.

(Råkade dubbelposta)

PHP?

Stämmer att det är PHP.