Ereditarietà Java vs inizializzazione

Question

Sto leggendo J. Bloch Java efficace e ora sono in sezione eredità vs composizione. Per quanto ho capito ha detto che l'eredità non è sempre buona.

Una causa correlata di fragilità nelle sottoclassi è che la loro superclasse può acquisire nuovi metodi nelle versioni successive. Supponiamo che un programma dipenda dalla sua sicurezza sul fatto che tutti gli elementi inseriti nella serie soddisfano alcuni predicati. Questo può essere garantito da sottoclasse della raccolta e sovrascrivendo ogni metodo capace di aggiungendo un elemento di assicurare che il predicato è soddisfatto prima aggiungendo l'elemento. Funziona bene fino a un nuovo metodo in grado di inserendo un elemento viene aggiunto alla superclasse in una successiva versione .

Ma perché non funziona? La superclasse è solo l'interfaccia Collection e se aggiungiamo un nuovo metodo abbiamo solo un errore in fase di compilazione. Questo non è dannoso in assoluto ...

Answer 1

Supponiamo di avere una superclasse Collection in qualche biblioteca v1.0:

public class MyCollection { 
    public void add(String s) { 
     // add to inner array 
    } 
} 

È sottoclasse che per accettare solo le stringhe che hanno lunghezza 5:

public class LimitedLengthCollection extends MyCollection { 
    @Override 
    public void add(String s) { 
     if (s.length() == 5) { 
      super.add(s); 
     } 
    } 
} 

Il contratto, l'invariante di questa classe è che non conterrà mai una stringa che non ha lunghezza 5.

Ora viene rilasciata la versione 2.0 della libreria e si inizia a utilizzarla. La classe base è modificata in:

public class MyCollection { 
    public void add(String s) { 
     // add to inner array 
    } 

    public void addMany(String[] s) { 
     // iterate on each element and add it to inner array 
    } 
} 

e la sottoclasse non viene modificata.Ora gli utenti della sottoclasse possono fare

LimitedLengthCollection c = new LimitedLengthCollection(); 
c.addMany(new String[] {"a", "b", "c"}); 

e quindi il contratto della sottoclasse viene interrotto. Si supponeva che accettasse solo stringhe di lunghezza 5 e non più, perché è stato aggiunto un ulteriore metodo nella superclasse.

Answer 2

Perché (in generale) interromperà il codice client che ha implementato la classe Collection.

In questo particolare esempio, la sicurezza verrà interrotta perché gli utenti malintenzionati sarebbero in grado di inserire elementi utilizzando il metodo non ancora sovrascritto che è stato aggiunto dopo aver spedito il codice.

Basare il codice su classi ereditate che non controlli può morderti in futuro.

Answer 3

se aggiungiamo un nuovo mehtod abbiamo solo un errore di compilazione

Questo è vero solo quando si aggiunge un abstract metodo alla superclasse/interfaccia. Se viene aggiunto un metodo non astratto, è perfettamente valido non sovrascrivere quel nuovo metodo.

Answer 4

Il problema non è che l'ereditarietà non potrebbe funzionare.

Il problema è che con l'ereditarietà lo sviluppatore non può imporre un comportamento (come l'esempio della collezione che soddisfa alcuni predicati).

Quando creiamo una nuova classe raramente è davvero un tipo specializzato di un'altra. Più spesso è qualcosa di nuovo che usa altre classi.

Così raramente abbiamo bisogno di ereditarietà e più spesso abbiamo bisogno di creare una classe che utilizzi altre classi per fare qualcosa.

Il È UN vs HA UN

Bisogna chiedersi:

Classe B è un nuovo tipo sub di classe A che fare le stesse cose di A in modo diverso?

o

Classe B ha una classe all'interno di fare qualcosa di diverso da quello che A è intented fare?

E sappiate che più spesso la risposta giusta è quest'ultima.