Perché è necessaria l'ereditarietà dell'interfaccia?

Perché sono necessarie le interfacce? Perché è necessaria l'ereditarietà dell'interfaccia? Perché è necessario il polimorfismo? Per coloro che hanno letto e capito come eseguire l'ereditarietà dell'interfaccia, ma non hanno capito il motivo. L'ultima volta, usando l'esempio della normale famiglia Ivanov, abbiamo esaminato il motivo per cui sono necessarie le interfacce. Continuiamo a digitalizzare la famiglia in difficoltà. Ogni persona ha alcune abitudini che non ha ereditato da nessuno o che non ha trasmesso a nessuno: le sue abitudini personali. Il nostro compito è fornire ad ogni membro della famiglia abitudini uniche. Passiamo al piano Java: dobbiamo implementare metodi univoci in classi che apparterranno solo a queste classi. Bene, vai avanti! Questo è Petya:

class Петя implements ПривычкиПапы, ПривычкиМамы {

//это личные Петины привычки
public void ковырятьВНосу () {
System.out.println("Ковырь-ковырь");
    }

//это унаследованные привычки
@Override
public void прихлюпывать() {
     System.out.println("Хлюп");
   }

@Override
public void поджимать () {
System.out.println("Поджать губки");
    }
}

Questo è papà:

class Папа implements ПривычкиПапы {

//это личные Папины привычки
public void чесатьБороду () {
System.out.println("Чешу бороду");
    }

//это переданные привычки
   @Override
    public void прихлюпывать() {
     System.out.println("Хлюп");
   }
}

Questa è la mamma:

class Мама implements ПривычкиМамы{

//это личные Мамины привычки
public void хлопатьРесницами () {
System.out.println("Хлоп-хлоп");
    }

//это переданные привычки
@Override
public void поджимать() {
System.out.println("Поджать губки");
    }
}

Perfetto! Tutto funziona come dovrebbe! Nel primo articolo si diceva che il programma è un riflesso del mondo reale. La proprietà più interessante della realtà è che cambia continuamente. La famiglia Ivanov non faceva eccezione; avevano una dolce figlia di nome Masha. E ha ereditato dalla mamma l'abitudine di sbattere le ciglia e di tirare su col naso da papà. Dobbiamo apportare modifiche al nostro programma. Dai, non è così difficile, l'importante è pensare in modo logico. Dopotutto, tutti sanno perché sono necessarie le interfacce. Ora creiamo un'interfaccia Masha's Habits , descriviamo lì il metodo clapElashes() e squish() , implementiamolo su Masha e abbiamo finito. E se i metodi con lo stesso nome fossero già implementati in altre interfacce, puoi farlo una volta. In effetti, chissà quali piani ha la famiglia Ivanov, se nasce Seryozha , che erediterà le abitudini di papà, mamma, bisnonno e qualcun altro della quarta generazione, creando ogni volta un'interfaccia, come: interfaccia le abitudini di Seryozha , e lì dichiarare metodi che possono già essere dichiarati centinaia di volte in altre interfacce? In un paio o tre generazioni rischiamo di ottenere interfacce con una serie di metodi identici che sono già descritti in altre interfacce e, se necessario, cambiare il nome di qualche abitudine (e questo è del tutto possibile - dopo tutto, il mondo sta cambiando) , quindi come capire questi spaghetti, non riesco a immaginarlo. Non resta che sedersi e sognare un miracolo. Ora, se ogni abitudine avesse la propria interfaccia. Immaginiamo:

public interface ПривычкаПрихлюпывать {
    public void прихлюпывать();
}
public interface ПривычкаПоджимать {
    public void поджимать();
}
public interface ПривычкаКовырятьВНосу {
    public void ковырятьВНосу();
}
public interface ПривычкаХлопатьРесницами {
    public void хлопатьРесницами();
}
public interface ПривычкаЧесатьБороду {
    public void чесатьБороду();
}

E poi, come in Lego, potremmo, utilizzando l'eredità multipla delle abitudini individuali, digitare l'interfaccia di cui abbiamo bisogno per le abitudini di un singolo membro della famiglia. Qualcosa come questo:

public interface ПривычкиМамы extends ПривычкаПоджимать, ПривычкаХлопатьРесницами {
    }
public interface ПривычкиПапы extends ПривычкаЧесатьБороду, ПривычкаХлюпать {
    }
public interface ПривычкиПети extends ПривычкаПоджимать, ПривычкаХлюпать,ПривычкаКовырятьВНосу {
    }
public interface ПривычкиМаши extends ПривычкаХлюпать, ПривычкаХлопатьРесницами {
    }

E poi implementa semplicemente l'interfaccia desiderata per la classe desiderata, ad esempio Mamma:

class Мама implements ПривычкиМамы{
@Override
public void хлопатьРесницами () {
System.out.println("Хлоп-хлоп");
    }

@Override
public void поджимать() {
System.out.println("Поджать губки");
    }
}

Lo stesso potrebbe essere fatto con papà, Petya e Masha . E poi, con l'espansione della famiglia Ivanov, non ci sarebbero problemi con le abitudini, le mescoleremmo semplicemente attraverso l'ereditarietà a livello di interfaccia, come gli ingredienti in un'insalata, e non produrremmo un mucchio di metodi con lo stesso nome. Eh, sogni, sogni... L'uomo disegnato ha ragione, questo è effettivamente possibile - ora la simulazione della famiglia Ivanov è salvata! Un lettore attento potrebbe porre la domanda: "Perché creare interfacce per ogni membro della famiglia? Abbiamo una serie di azioni: implementale immediatamente per la classe richiesta." Immaginiamo che in molti mondi paralleli ci siano i doppi di Petya , e che tutti i Petya debbano implementare l'interfaccia Petya's Habits

interface ПривычкиПети extends ПривычкаПоджимать, ПривычкаХлюпать,ПривычкаКовырятьВНосу 

class ПетяВселеннаяХ implements ПривычкиПети
class ПетяВселеннаяY implements ПривычкиПети
// и т.д.

E se non ci fosse un'interfaccia comune?

class ПетяВселеннаяХ implements ПривычкаПоджимать, ПривычкаХлюпать,ПривычкаКовырятьВНосу
class ПетяВселеннаяY implements ПривычкаПоджимать, ПривычкаХлюпать,ПривычкаКовырятьВНосу
// и т.д.

Ciò si traduce in un codice più ripetitivo. L'ereditarietà dell'interfaccia rende l'applicazione più flessibile ai cambiamenti, in particolare è possibile risolvere i problemi con la ripetizione dei metodi. Tieni presente ancora una volta che è consentita l'ereditarietà multipla delle interfacce.