[JAVA] Héritage et interface.

Pour moi-même. Ce qui suit est écrit en java.

Je ne pense pas que ce soit vraiment bon, mais je n'ai pas encore utilisé ces syntaxes, donc il y a probablement un malentendu. Écrivez du code pendant votre temps libre, déplacez-le, hein ...? Je vais le faire, alors attendez.

Héritage

Héritage. Cela signifie étend. La classe héritée est appelée super classe et classe parent. La classe héritée est appelée une classe enfant.

Puisque la classe enfant a toute la super classe, vous pouvez utiliser les variables et les méthodes de la super classe. Ceux avec le modificateur d'accès privé de la super classe ne peuvent pas être utilisés. Tout modificateur protégé peut être utilisé.

Ce qui suit est une classe de créatures mystérieuses qui ne peuvent que courir et dormir. La classe enfant appelle simplement la fonction de la classe parent pour le moment.

Une créature qui consomme 10 endurance lorsqu'elle court et récupère 10 endurance lorsqu'elle dort.

sperClass.java

class superClass(){
    stamina = 100;

    protected void run(){
        stamina -= 10;
    }

    protected void sleep(){
        stamina += 10;
    }
}

childClass.java

class childClass extends superClass{
    public voic main(){
        System.out.println(stamina);
            //100 (La valeur de la variable d'endurance de la classe parent est affichée)

        run();
        sleep();
            //Vous pouvez utiliser les méthodes de la classe parent
    }
}

Override Je veux réécrire une méthode telle que la super classe dans une classe enfant. Le remplacement est ce que vous faites dans de tels moments. La méthode peut être écrasée.

Transformons la mystérieuse créature qui court et dort en une créature insecte de classe triche Une créature qui consomme 5 endurance en courant et récupère 50 endurance en dormant.

sperClass.java

class superClass(){
    int stamina = 100;

    protected void run(){
        stamina -= 10;
    }

    protected void sleep(){
        stamina += 10;
    }
}

childOverride.java

class childOverride extends superClass{
    @Override
    private void run(){
        stamina -= 5;
    }

    @Override
    private void sleep(){
        stamina += 50;
    }

    public void main(){
        //Quelque chose de traitement approprié
    }
}

Oui. J'ai une créature.

En redéfinissant la méthode avec le même nom dans la classe enfant, elle remplace le contenu défini dans la classe enfant.

@ Override sert à clarifier au compilateur que la méthode suivante essaie de remplacer, et il semble qu'il n'y ait pas de problème de fonctionnement même si elle n'est pas écrite. Cependant, si vous ajoutez @ Override, une erreur sera émise si la méthode avec le même nom n'existe pas dans la super classe lors de la compilation, vous pouvez donc la trouver avant d'exécuter le bogue.

Seules les méthodes peuvent être remplacées, pas les variables.

super mot-clé

Je veux exécuter le constructeur de la super classe. Je veux utiliser la fonction de super classe avant le remplacement. Je veux réaffecter une variable de super classe.

Le mot-clé super est utilisé dans de tels cas.

Lorsqu'une instance d'une classe enfant est créée, une instance de la super classe est également créée sans autorisation, mais c'est utile lorsque vous souhaitez passer un argument au constructeur de cette super classe.

super(param, args);

Si vous l'appelez ainsi, vous pouvez passer l'argument au constructeur. Vous pouvez appeler le constructeur de la super-classe à tout moment, mais cela n'est pas recommandé sauf à partir du constructeur de la classe enfant, vous ne devriez donc pas le faire.

interface

Il semble bon de penser que l'interface est comme un dessin de conception. Il s'agit d'indiquer clairement "Veuillez préparer une telle fonction".

public interface actions{
    void run();
    void sleep();
    void eat();
    void jump();

Donc, je vais écrire une classe à implémenter en fonction de cela.

class Hito implements antions{
    @Override
    public void run(){
        //Sprint avec deux jambes
    }

    @Override
    public void sleep(){
        //Poser un futon et dormir
    }

    @Override
    public void eat(){
        //Manger avec une cuillère et une fourchette
    }

    ...

}

C'est une personne. Vous pouvez courir à pleine vitesse avec deux jambes.

class Dog implements antions{
    @Override
    public void run(){
        //Sprint avec quatre jambes
    }

    @Override
    public void sleep(){
        //Roulez et dormez dans votre endroit préféré
    }

    @Override
    public void eat(){
        //Allez directement à l'assiette avec votre bouche
    }

    ...

}

C'est un chien. Vous devriez courir sur quatre pattes, rouler votre sommeil et manger uniquement avec votre bouche. Si c'est un chien général.

Avec ce genre de sentiment, l'interface consiste à écrire la conception et la mise en œuvre séparément. ʻImplements` signifie "implémentation". Est-ce comme un modèle lors de la création d'une classe? Ressentir.

Classe abstraite (résumé)

Une classe qui nécessite toujours l'héritage, comme l'interface mentionnée ci-dessus, est appelée une classe abstraite. Si vous attachez le modificateur ʻabstruct à une classe, vous ne pourrez pas l'instancier directement, et si vous l'attachez à une méthode, vous ne pourrez pas appeler cette méthode telle quelle. Les classes contenant des méthodes avec le modificateur ʻabstruct doivent toujours avoir le modificateur ʻabstruct`.

Vous ne devez pas créer une instance d'une classe avec des méthodes inachevées.

public abstruct class action{
    int O2;
    void Kokyu(){
        O2 += 10;
    }

    abstruct void run();
    abstruct void sleep();
    abstruct void eat();
}

class Hito extends action{
    @Override
    void run(){
        //Courir
    }

    @Override
    void sleep(){
        //Poser un futon et dormir
    }

    ...

    public void main(){
        Kokyu();
            //Breathe (méthode de super classe)

        run()
            //Courir

        sleep();
            //dormir
    }
}

hein ...?

Oui oui. Je connais... Vous voudrez dire interface réelle </ b>. Je comprends je comprends.