[JAVA] Comparaison de l'héritage de classe et de la description du constructeur

introduction

Tout a commencé lorsque j'ai essayé d'hériter des classes en Python. Du point de vue de moi-même, qui a eu affaire à Java jusqu'à présent J'ai pensé: "Qu'est-ce que c'est !!!!!!", donc dans certains langages de programmation J'ai comparé la méthode de description de l'héritage de classe avec la méthode de description et le comportement du constructeur.

Cette position

Écrivez, comparez, visualisez et exprimez vos impressions sur Java.

J'ai utilisé paiza.IO pour vérifier le fonctionnement. Pratique. https://paiza.io/ja

Spécifications de l'échantillon

--Classe parentale (Super classe) --Préparation d'un constructeur par défaut. Sortie de la chaîne de caractères "★ Parent constructeur" vers la console --Préparer une fonction / méthode --Sortir la chaîne de caractères passée en argument à la console --Child class (classe à hériter) --Hériter de la classe Parent --Préparation d'un constructeur par défaut. Sortie de la chaîne de caractères "☆ Constructeur enfant" vers la console --Préparer une fonction / méthode --Sortir la chaîne de caractères passée en argument à la console --Appelez la fonction / méthode Super classe avec la chaîne de caractères "★ La fonction / méthode du parent peut être appelée" comme argument.

Java Personnellement, c'est la langue que je connais le mieux. La version est Java 12.

Méthode de description de l'héritage de classe

Méthode de description du constructeur

échantillon

Parent.java


public class Parent {
    
    public Parent(){
        System.out.println("★ Constructeur parent");
    }
    
    protected void parentMethod(String message){        
        System.out.println(message);
    }
}

Child.java


public class Child extends Parent{

    public Child(){
        System.out.println("☆ Constructeur enfant");
    }

    public void childMethod(String message){       
        System.out.println(message);
        parentMethod("★ Vous pouvez appeler la méthode Parent");
    }
}

Main.java


public class Main {
    public static void main(String[] args) {

        Child child = new Child();
        child.childMethod("☆ Vous pouvez appeler la méthode Child");
    }
}

Résultat d'exécution (console)

★ Constructeur parent ☆ Constructeur enfant ☆ Vous pouvez appeler la méthode Child ★ Vous pouvez appeler la méthode Parent

Impressions

――Comment écrire l'héritage de classe et le constructeur qui vous conviennent le mieux personnellement

Python Ensuite, l'opportunité d'écrire cet article. La version est Python 3.6.8.

Méthode de description de l'héritage de classe

** classe ** * Classe héritière * ** (** * Super classe * **): **

Méthode de description du constructeur

** def \ _ \ _ init \ _ \ _ (soi ** *, si un argument * **): ** ** Processus de définition de la valeur initiale par exemple self **

** def \ _ \ _ new \ _ \ _ (cls ** *, si un argument * **): ** ** renvoie super (). \ _ \ _ New \ _ \ _ (cls ** *, s'il y a un argument * **) **

** * Les exemples suivants, les résultats d'exécution (console) et les impressions concernent la fonction \ _ \ _ init \ _ \ _. ** **

échantillon

parent.py


class Parent(object):

    def __init__(self):
        print('★ Constructeur parent')

    def parent_function(self, message):
        print(message)

child.py


from parent import Parent

class Child(Parent):

    def __init__(self):
        print('☆ Constructeur enfant')

    def child_function(self, message):
        print(message)
        Parent.parent_function(self, '★ Vous pouvez appeler la fonction Parent')

main.py


from child import Child

def main():
    ch = Child()
    ch.child_function('☆ Vous pouvez appeler la fonction enfant')
    

if __name__ == '__main__':
    main()

Résultat d'exécution (console)

☆ Constructeur enfant ☆ Vous pouvez appeler la fonction enfant ★ Vous pouvez appeler la fonction Parent

Impressions

Well "Eh bien, utilisez-vous des parenthèses dans l'héritage de classe? N'est-ce pas faux avec l'argument?"

child.py


from parent import Parent

class Child(Parent):

    def __init__(self):
        Parent.__init__(self) #Ajouté ici! !! !! !! !! !!
        print('☆ Constructeur enfant')

    def child_function(self, message):
        print(message)
        Parent.parent_function(self, '★ Vous pouvez appeler la fonction Parent')

-Une seule fonction \ _ \ _ init \ _ \ _ peut être préparée dans une classe

\ _ \ _ Nouvelle fonction \ _ \ _ * (2019/8/16) Ajouté

Au départ, seule la fonction \ _ \ _ init () \ _ \ _ était décrite, Depuis que j'ai reçu des commentaires, j'ai également étudié la fonction \ _ \ _ new \ _ \ _.

-La fonction ** \ _ \ _ new \ _ \ _ fonctionne ** lorsque l'instance est créée, elle fonctionne donc avant la fonction ** \ _ \ _ init \ _ \ _ **.

Vous trouverez ci-dessous la documentation de Python 3.7.4.

Lors de l'implémentation de la fonction \ _ \ _ new \ _ \ _, vous avez besoin de return super () .__ new __ (cls [, ...]). https://docs.python.org/ja/3/reference/datamodel.html#object.new

Dans une implémentation typique, lors de la création d'une nouvelle instance d'une classe, spécifiez les arguments appropriés pour super (). \ _ \ _ New \ _ \ _ (cls [, ...]) et \ _ pour la super classe. Appelez la méthode \ _new \ _ \ _ () pour apporter les modifications nécessaires à l'instance nouvellement créée avant de la renvoyer.

Il a été écrit correctement (´ ・ ω ・ `) https://docs.python.org/ja/3/reference/datamodel.html#object.init

Appelé après la création d'une instance (par \ _ \ _ new \ _ \ _ ()) et avant d'être renvoyée à l'appelant. L'argument est ce que vous passez à l'expression du constructeur de la classe. Si la classe de base et sa classe dérivée ont une méthode \ _ \ _ init \ _ \ _ (), la méthode \ _ \ _ init \ _ \ _ () de la classe dérivée est la méthode \ _ \ _ init \ _ \ _ de la classe de base ( ) Vous devez appeler explicitement la méthode pour vous assurer que la partie classe de base de l'instance est correctement initialisée. Par exemple, super (). \ _ \ _ Init \ _ \ _ ([args ...]).

Il semble que la fonction \ _ \ _ new \ _ \ _ était meilleure si elle était alignée avec le constructeur Java. ..

Lorsque j'ai remplacé l'exemple implémenté par la fonction \ _ \ _ init \ _ \ _ par la fonction \ _ \ _ new \ _ \ _ telle quelle, Le résultat de l'exécution (console) est le suivant. ☆ Constructeur enfant ★ Constructeur parent ☆ Vous pouvez appeler la fonction enfant ★ Vous pouvez appeler la fonction Parent

Ruby Par la logique mystérieuse que Python et Ruby. La version est Ruby 2.6.3.

Méthode de description de l'héritage de classe

** class ** * Classe héritière * ** <** * Super classe * end

Méthode de description du constructeur

** def initialize (** * si un argument * **) ** end

échantillon

parent.rb


class Parent

    def initialize()
        puts "★ Constructeur parent"
    end
    
    def parent_function(message)
        puts message
    end   
end

child.rb


require("./parent.rb")

class Child < Parent

    def initialize()
        puts "☆ Constructeur enfant"
    end
    
    def child_function(message)
        puts message
        parent_function("★ Vous pouvez appeler la fonction Parent")
    end
end

main.rb


require("./child.rb")

child = Child.new
child.child_function("☆ Vous pouvez appeler la fonction enfant")

Résultat d'exécution (console)

☆ Constructeur enfant ☆ Vous pouvez appeler la fonction enfant ★ Vous pouvez appeler la fonction Parent

Impressions

«Cela ressemble à une description qui transmet le sentiment d'héritage de la classe. C'est comme Python que le constructeur est une fonction avec un nom fixe --Semblable à Python, la fonction initialize de la classe Parent est écrasée par la fonction initialize de la classe Child. --Lorsque la fonction d'initialisation de la classe Child est supprimée et exécutée, "★ Parent constructeur" est affiché. --Avec super, exécutez également la fonction d'initialisation de Parent

child.rb


require("./parent.rb")

class Child < Parent

    def initialize()
        super()  #Ajouté ici! !! !! !! !! !!
        puts "☆ Constructeur enfant"
    end
    
    def child_function(message)
        puts message
        parent_function("★ Vous pouvez appeler la fonction Parent")
    end
end

--Une seule fonction d'initialisation peut être préparée par classe

PowerShell Dans la formation des nouveaux employés de l'entreprise, il y avait un thème pour créer un script PowerShell, donc je l'ai inclus. Il n'y avait pas d'héritage de classe dans PowerShell (Kiri), donc je pensais en faire une punch line ... **. ** ** Ce n'était pas sur paiza.IO, j'ai donc vérifié le fonctionnement sur mon PC.

Méthode de description de l'héritage de classe

** class ** * Classe héritière * : ** * Super classe * ** { }

Méthode de description du constructeur

échantillon

parent.psm1


class Parent {

    Parent() {
        write-host("★ Constructeur parent")
    }

    parent_function([String] $message) {

        write-host($message)
    }
}

child.ps1


using module ".\parent.psm1"

class Child : Parent {

    Child(){
         write-host("☆ Constructeur enfant")       
    }

    child_function([String] $message) {

        write-host($message)
        ([Parent]$this).parent_function("★ Vous pouvez appeler la fonction Parent")
    }
}

main.ps1


. .\child.ps1

$child = [Child]::new()
$child.child_function("☆ Vous pouvez appeler la fonction enfant")

Résultat d'exécution (console)

★ Constructeur parent ☆ Constructeur enfant ☆ Vous pouvez appeler la fonction enfant ★ Vous pouvez appeler la fonction Parent

Impressions

à la fin

À part Java, Python, Ruby et PowerShell, il y avait des choix «J'ai écrit mais je n'ai jamais utilisé de classes». J'ai pensé essayer quelques autres langages de programmation que je n'avais pas touchés auparavant. Je suis désolé, je suis épuisé par PowerShell.

paiza.IO a de nombreux langages de programmation utilisables, donc Si je me sens mieux, j'aimerais l'ajouter si j'essaye d'autres choses. ** Quoi qu'il en soit, paiza.IO est vraiment pratique. ** **

Comparez comment écrire C'était amusant de comprendre les caractéristiques de chaque langage de programmation et le manque de compréhension de ma compréhension! Merci de rester avec nous jusqu'à la fin.

Recommended Posts

Comparaison de l'héritage de classe et de la description du constructeur
Héritage de classe et super fonction
Comparaison d'Apex et de Lamvery
[Hikari-Python] Chapitre 09-03 Classe (Héritage)
Calcul de la classe auto-fabriquée et de la classe existante
Héritage de classe
Exemple d'utilisation de variables de classe et de méthodes de classe
Comparaison de gem, bundler et pip, venv
Comparaison de la régularisation L1 et Leaky Relu
Comparaison de vitesse de murmurhash3, md5 et sha1
Comparaison d'exemples d'implémentation de k-means de scikit-learn et pyclustering
Constructeur et destructeur
Comparaison d'écriture R et Python (méthode de division mutuelle euclidienne)
Description générale des notificateurs CPUFreq core et CPUFreq
[Python] Type de classe et utilisation du module datetime
Résumé du traitement pickle et unpickle des classes définies par l'utilisateur
Comparaison de Python et Ruby (Environment / Grammar / Literal Edition)
Une comparaison rapide des bibliothèques de test Python et node.js
Bibliothèque DNN (Deep Learning): Comparaison de chainer et TensorFlow (1)
Comparaison de Windows Server et Linux gratuit et Linux commercial
Tableau de comparaison des processus fréquemment utilisés de Python et Clojure
Exemple d'obtention du nom du module et du nom de la classe en Python
Vue d'ensemble des vues génériques basées sur les classes et des relations de classe héritées
Comparaison de CoffeeScript avec la grammaire JavaScript, Python et Ruby
À propos de la classe et de l'instance
Héritage multiple de classes
[Python] Héritage de classe (super)
Comparaison des implémentations LDA
Comparaison des classificateurs en ligne
[Python] Héritage de classe, remplacement
Comparaison des programmes d'adaptation
Classes et méthodes statiques
Comparaison de l'utilisation des fonctions d'ordre supérieur dans Python 2 et 3
Comparaison de la loi hongroise et des solveurs polyvalents pour les problèmes d'allocation