Pourquoi l’héritage d’interface est-il nécessaire ?

Pourquoi les interfaces sont-elles nécessaires ? Pourquoi l’héritage d’interface est-il nécessaire ? Pourquoi le polymorphisme est-il nécessaire ? Pour ceux qui ont lu et compris comment procéder à l'héritage d'interface, mais qui n'ont pas compris pourquoi. La dernière fois, en prenant l'exemple de la famille Ivanov ordinaire, nous avons examiné pourquoi les interfaces sont nécessaires. Nous continuons à numériser la famille en difficulté. Chaque personne a des habitudes qu'elle n'a héritées de personne ou qu'elle n'a transmises à personne - ses habitudes personnelles. Notre tâche est de fournir à chaque membre de la famille des habitudes uniques. Passons au plan Java : nous devons implémenter des méthodes uniques dans des classes qui appartiendront uniquement à ces classes. Eh bien, allez-y ! Voici Petya :

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

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

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

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

C'est papa :

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

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

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

C'est maman :

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

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

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

Parfait! Tout fonctionne comme il se doit ! Dans le premier article, il était dit que le programme était le reflet du monde réel. La propriété la plus intéressante de la réalité est qu’elle change tout le temps. La famille Ivanov ne faisait pas exception : ils avaient une adorable fille nommée Masha. Et elle a hérité de maman l’habitude de battre des cils et de papa de renifler. Nous devons apporter des modifications à notre programme. Allez, ce n’est pas si difficile, l’essentiel est de penser logiquement. Après tout, tout le monde sait pourquoi les interfaces sont nécessaires. Créons maintenant une interface Masha's Habits , décrivons-y les méthodes clapElashes() et squish() , implémentons-la sur Masha et nous avons terminé. Et si des méthodes portant le même nom sont déjà implémentées dans d’autres interfaces, vous pouvez le faire une seule fois. En effet, qui sait quels sont les projets de la famille Ivanov, si Seryozha naît , qui héritera des habitudes de papa, maman, arrière-grand-père et de quelqu'un d'autre de la quatrième génération, créant à chaque fois une interface, comme : interface Les habitudes de Seryozha , et là déclarer des méthodes qui peuvent déjà être déclarées des centaines de fois dans d’autres interfaces ? Dans quelques ou trois générations, nous risquons d'obtenir des interfaces avec un tas de méthodes identiques déjà décrites dans d'autres interfaces, et si nous devons changer le nom d'une habitude (et c'est tout à fait possible - après tout, le monde change) , alors comment comprendre ces spaghettis, je ne peux pas imaginer. Il ne reste plus qu'à s'asseoir et rêver d'un miracle. Maintenant, si chaque habitude avait sa propre interface. Imaginons :

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

Et puis, comme dans Lego, nous pourrions, en utilisant l'héritage multiple des habitudes individuelles, taper l'interface dont nous avons besoin pour les habitudes d'un membre individuel de la famille. Quelque chose comme ça:

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

Et puis implémentez simplement l'interface souhaitée dans la classe souhaitée, par exemple, Mom :

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

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

La même chose pourrait être faite avec Papa, Petya et Masha . Et puis, avec l'agrandissement de la famille Ivanov, il n'y aurait aucun problème avec les habitudes, nous les mélangerions simplement par héritage au niveau de l'interface, comme les ingrédients d'une salade, et ne produirions pas un tas de méthodes du même nom. Eh, des rêves, des rêves... L'homme dessiné a raison, c'est effectivement possible - maintenant la simulation de la famille Ivanov est sauvegardée ! Un lecteur attentif peut se poser la question : "Pourquoi créer des interfaces pour chaque membre de la famille ? Nous avons un ensemble d'actions - mettez-les en œuvre immédiatement pour la classe requise." Imaginons que dans de nombreux mondes parallèles, il y ait des doubles de Petya , et que tous les Petyas aient besoin d'implémenter l'interface Petya's Habits

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

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

Et s’il n’y avait pas d’interface commune ?

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

Cela se traduit par un code plus répétitif. L'héritage d'interface rend l'application plus flexible aux modifications, en particulier, les problèmes liés aux méthodes répétitives peuvent être résolus. Veuillez noter encore une fois que l'héritage multiple d'interfaces est autorisé.