[PYTHON] Ich habe mich mit Überschreibungen der Klassenvererbung befasst.

Einführung

Mein Junior fragte mich nach der Vererbung von Java-Klassen, aber ich konnte sie nicht sofort beantworten, also habe ich viel recherchiert.

Ursprung

Alter @ IT-Besprechungsraum: Informationen zur Vererbung von Variablen

Auszug, weil es schwer zu lesen ist

Wenn in der Oberklasse eine gleichnamige Variable vorhanden ist, die Methode der Oberklasse Bei der Ausführung bezieht sich die gleichnamige Variable auf die Oberklasse. Wie kann ich in meiner Klasse auf eine gleichnamige Variable verweisen?

Unten finden Sie eine Beispielquelle. Was ich dachte, würde zurückkehren "Ich bin ein Kind" gab zurück "Ich bin ein Elternteil".

• Der Zugriffsmodifikator und der Klassenname wurden so geändert, dass sie in einer Datei kompiliert werden können.

Main.java

//Ausführungsklasse
public class Main{
    public static void main(String args[]){
        Child c1 = new Child();
        c1.print(); 
    } 
} 

//Super Klasse
class Parent{
    private String JIBUN = "Elternteil"; 
    public void print(){
        System.out.println("ich" + JIBUN + "ist."); 
    }
} 

//Kinderklasse
class Child extends Parent{
    private String JIBUN = "Kinder";
}

Er sagte, dass er nicht verstehe, selbst wenn er die Erklärung lese.

Informationen zur Vererbung und Überlastung von Java

In dem Moment, als ich es sah, dachte ich, dass JIBUN privat ist, so dass es nicht aus anderen Klassen referenziert werden kann und Eltern und Kind unterschiedlich sind, oder? Es war das.

Aber was ist, wenn es geschützt (öffentlich) ist? Ich kam auf die Frage, also habe ich sie richtig untersucht.

Unten finden Sie die Quelle, die für den Test verwendet wurde. piza.io

Main.java

//Ausführungsklasse
public class Main{
    public static void main(String args[]){
        Child c1 = new Child();
        c1.print(); 
        c1.print2();
        Parent parent = new Child();
        c1.print(); 
        c1.print2();
    } 
} 

//Super Klasse
class Parent{
    private String JIBUN1 = "Elternteil 1"; 
    protected String JIBUN2 = "Elternteil 2"; 
    protected String JIBUN3 = "Elternteil 3"; 
    public void print(){ 
        System.out.println("print"); 
        System.out.println("ich" + JIBUN1 + "ist."); 
        System.out.println("ich" + JIBUN2 + "ist."); 
        System.out.println("ich" + JIBUN3 + "ist."); 
    }
//    final public void print2(){Wenn Sie es nicht überschreiben möchten, fügen Sie final hinzu und Sie erhalten einen Kompilierungsfehler.
    public void print2(){
        System.out.println("print2"); 
        System.out.println("Eltern" + JIBUN1 + "ist."); 
        System.out.println("Eltern" + JIBUN2 + "ist."); 
        System.out.println("Eltern" + JIBUN3 + "ist."); 
    } 
} 

//Kinderklasse
class Child extends Parent{
    // @Override //Kompilierungsfehler, da er nicht überschrieben werden kann
    private String JIBUN1 = "Kind 1";
    // @Override //Kompilierungsfehler, da er nicht überschrieben werden kann
    protected String JIBUN2 = "Kind 2";
    Child() {
        this.JIBUN3 = "Kind 3";
    }
    @Override //Die Überschreibungsanmerkung gibt eindeutig an, dass es sich um eine Überschreibung handelt
    public void print2(){
        System.out.println("print2"); 
        System.out.println("Kinder" + JIBUN1 + "ist."); 
        System.out.println("Kinder" + JIBUN2 + "ist."); 
        System.out.println("Kinder" + JIBUN3 + "ist."); 
    } 
}

Ausführungsergebnis

print
Ich bin Elternteil 1.
Ich bin Elternteil 2.
Ich bin 3 Kinder
print2
Das Kind ist Kind 1.
Das Kind ist Kind 2.
Das Kind ist Kind 3.
print
Ich bin Elternteil 1.
Ich bin Elternteil 2.
Ich bin 3 Kinder
print2
Das Kind ist Kind 1.
Das Kind ist Kind 2.
Das Kind ist Kind 3.

Die Ergebnisse sind unten zusammengefasst.

• Felder können nicht überschrieben werden. Versteckt sein.
• Der Compiler gibt jedoch keine Warnung aus. Ich war überrascht! !!
• Methoden können nur grundlegende Überschreibungen sein. (Kann nicht versteckt werden.)
• Wenn für die Methodenüberschreibungssteuerung final im übergeordneten Element hinzugefügt wird, ist das Überschreiben verboten, und wenn @Override im Vererbungsziel hinzugefügt wird, tritt ein Fehler mit Ausnahme des Überschreibens auf.
• Stellen Sie daher beim Erstellen einer Klasse sicher, dass Methoden, die nicht überschrieben werden sollen, final hinzugefügt werden. Es ist eine gute Idee, beim Erstellen einer Überschreibungsmethode immer @Override hinzuzufügen.

Über Vererbung und Überlastung von C

Eigentlich habe ich die Objektorientierung in C # gelernt, daher war das Schreiben einfacher.

piza.io

Dieses Mal gibt es Methodenüberschreibungen und Ausblenden, also gibt es print2 (Überschreiben) und print3 (Ausblenden).

• Überschreiben → Verwenden Sie die geerbte Methode, auch wenn sie als übergeordnete Klasse verwendet wird. (Da die vorhandene Bewegung neu geschrieben wird, kann die Bewegung später definiert werden.)
• Ausblenden → Übergeordnete Methode bei Verwendung als übergeordnete Klasse. Bei Verwendung als Vererbungsziel die Vererbungszielmethode.

Main.cs

using System;

public class Test {
    public static void Main(){
        Child c1 = new Child(); 
        c1.print(); 
        c1.print2(); 
        c1.print3(); 
        Parent parent = new Child(); 
        parent.print(); 
        parent.print2(); 
        parent.print3(); 
    }
}

//Super Klasse
public class Parent{
    // virtual //Kompilierungsfehler, da er nicht überschrieben werden kann
    private string JIBUN1 = "Elternteil 1"; 
    // virtual //Kompilierungsfehler, da er nicht überschrieben werden kann
    protected string JIBUN2 = "Elternteil 2"; 
    // virtual //Kompilierungsfehler, da er nicht überschrieben werden kann
    protected string JIBUN3 = "Elternteil 3";
    public void print(){ 
        Console.WriteLine("print"); 
        Console.WriteLine("ich" + JIBUN1 + "ist."); 
        Console.WriteLine("ich" + JIBUN2 + "ist."); 
        Console.WriteLine("ich" + JIBUN3 + "ist."); 
    } 
    virtual public void print2(){ 
        Console.WriteLine("print2"); 
        Console.WriteLine("Eltern" + JIBUN1 + "ist."); 
        Console.WriteLine("Eltern" + JIBUN2 + "ist."); 
        Console.WriteLine("Eltern" + JIBUN3 + "ist."); 
    }
    public void print3(){
        Console.WriteLine("print3"); 
        Console.WriteLine("Eltern" + JIBUN1 + "ist."); 
        Console.WriteLine("Eltern" + JIBUN2 + "ist."); 
        Console.WriteLine("Eltern" + JIBUN3 + "ist."); 
    } 
} 

//Kinderklasse
public class Child : Parent{ 
    // override //Kompilierungsfehler, da er nicht überschrieben werden kann
    private string JIBUN1 = "Kind 1";
    // override //Kompilierungsfehler, da er nicht überschrieben werden kann
    protected string JIBUN2 = "Kind 2";
    public Child() {
        this.JIBUN3 = "Kind 3";
    }
    override public void print2(){
        Console.WriteLine("print2"); 
        Console.WriteLine("Kinder" + JIBUN1 + "ist."); 
        Console.WriteLine("Kinder" + JIBUN2 + "ist."); 
        Console.WriteLine("Kinder" + JIBUN3 + "ist."); 
    }
//    override public void print3(){Kompilierungsfehler, da print3 nicht virtuell ist
    public void print3(){ //Nur eine Überschreibungsdefinition
        Console.WriteLine("print3"); 
        Console.WriteLine("Kinder" + JIBUN1 + "ist."); 
        Console.WriteLine("Kinder" + JIBUN2 + "ist."); 
        Console.WriteLine("Kinder" + JIBUN3 + "ist."); 
    } 
}

Ausgabeergebnis

print
Ich bin Elternteil 1.
Ich bin Elternteil 2.
Ich bin 3 Kinder
print2
Das Kind ist Kind 1.
Das Kind ist Kind 2.
Das Kind ist Kind 3.
print3
Das Kind ist Kind 1.
Das Kind ist Kind 2.
Das Kind ist Kind 3.
print
Ich bin Elternteil 1.
Ich bin Elternteil 2.
Ich bin 3 Kinder
print2
Das Kind ist Kind 1.
Das Kind ist Kind 2.
Das Kind ist Kind 3.
print3
Der Elternteil ist Elternteil 1.
Der Elternteil ist Elternteil 2.
Elternteil ist Kind 3.

Kompilierungsfehler (Warnung)

Compilation succeeded - 2 warning(s)
Main.cs(49,22): warning CS0108: `Child.JIBUN2' hides inherited member `Parent.JIBUN2'. Use the new keyword if hiding was intended
Main.cs(21,22): (Location of the symbol related to previous warning)
Main.cs(60,17): warning CS0108: `Child.print3()' hides inherited member `Parent.print3()'. Use the new keyword if hiding was intended
Main.cs(36,17): (Location of the symbol related to previous warning)

Die Ergebnisse sind unten zusammengefasst.

• Felder können nicht überschrieben werden. Versteckt sein.
• Da private Felder klassenspezifisch sind, gibt es keine versteckten Warnungen. Da geschützt und höher ausgeblendet sind, wird eine Warnung angezeigt.
• Methoden können standardmäßig nicht überschrieben werden. (Versteckt.)
• Wenn Sie die Methode überschreiben möchten, fügen Sie virtuell hinzu. Überschreibung auch am Überschreibungsziel hinzufügen. Wenn eines fehlt, tritt ein Fehler oder eine Warnung auf und kann nicht überschrieben werden.
• Ich werde wütend, wenn ich versuche, etwas Seltsames zu tun, das sich grundlegend von meinen Gefühlen unterscheidet (ich fühle)

Nun, dieses Gefühl ist ein persönlicher Eindruck, weil es in C # kultiviert wurde.

Informationen zu C ++ - Vererbung und Überlastung

Ich habe C ++ nicht ernsthaft codiert, daher werde ich versuchen, es zu googeln.

Hier gibt es auch print2 und print3.

paiza.io

Main.cpp

#include <iostream>
using namespace std;

//Super Klasse
class Parent{
    private:
        // virtual //Kompilierungsfehler, da er nicht überschrieben werden kann
        string JIBUN1 = "Elternteil 1";
    protected:
        // virtual //Kompilierungsfehler, da er nicht überschrieben werden kann
        string JIBUN2 = "Elternteil 2"; 
        // virtual //Kompilierungsfehler, da er nicht überschrieben werden kann
        string JIBUN3 = "Elternteil 3";
    public:
        void print() {
            cout << "print" << endl;
            cout << "ich" + JIBUN1 + "ist." << endl;
            cout << "ich" + JIBUN2 + "ist." << endl;
            cout << "ich" + JIBUN3 + "ist." << endl;
        };
        virtual void print2() {
            cout << "print2" << endl;
            cout << "Eltern" + JIBUN1 + "ist." << endl;
            cout << "Eltern" + JIBUN2 + "ist." << endl;
            cout << "Eltern" + JIBUN3 + "ist." << endl;
        }
        void print3() {
            cout << "print3" << endl;
            cout << "Eltern" + JIBUN1 + "ist." << endl;
            cout << "Eltern" + JIBUN2 + "ist." << endl;
            cout << "Eltern" + JIBUN3 + "ist." << endl;
        }
};

//Kinderklasse
class Child : public Parent{ 
    private:
        string JIBUN1 // override //Kompilierungsfehler, da er nicht überschrieben werden kann
        = "Kind 1";
    protected:
        string JIBUN2 // override //Kompilierungsfehler, da er nicht überschrieben werden kann
        = "Kind 2";
        
    public:
        Child() {
            this->JIBUN3 = "Kind 3";
        };
        void print2() override {
            cout << "print2" << endl;
            cout << "Kinder" + JIBUN1 + "ist." << endl;
            cout << "Kinder" + JIBUN2 + "ist." << endl;
            cout << "Kinder" + JIBUN3 + "ist." << endl;
        }
        // void print3() override {Kompilierungsfehler, da print3 nicht virtuell ist
        void print3() { //Nur eine Überschreibungsdefinition
            cout << "print3" << endl;
            cout << "Kinder" + JIBUN1 + "ist." << endl;
            cout << "Kinder" + JIBUN2 + "ist." << endl;
            cout << "Kinder" + JIBUN3 + "ist." << endl;
        }
};

int main(void){
    Child *c1 = new Child();
    c1->print();
    c1->print2();
    c1->print3();
    Parent *parent = new Child();
    parent->print();
    parent->print2();
    parent->print3();
}

Ausführungsergebnis

print
Ich bin Elternteil 1.
Ich bin Elternteil 2.
Ich bin 3 Kinder
print2
Das Kind ist Kind 1.
Das Kind ist Kind 2.
Das Kind ist Kind 3.
print3
Das Kind ist Kind 1.
Das Kind ist Kind 2.
Das Kind ist Kind 3.
print
Ich bin Elternteil 1.
Ich bin Elternteil 2.
Ich bin 3 Kinder
print2
Das Kind ist Kind 1.
Das Kind ist Kind 2.
Das Kind ist Kind 3.
print3
Der Elternteil ist Elternteil 1.
Der Elternteil ist Elternteil 2.
Elternteil ist Kind 3.

Es gab keine besonderen Kompilierungsfehler (Warnungen).

Die Ergebnisse sind unten zusammengefasst.

• Felder können nicht überschrieben werden. Versteckt sein.
• Methoden können standardmäßig nicht überschrieben werden. (Versteckt.)
• Wenn Sie die Methode überschreiben möchten, fügen Sie virtuell hinzu. Das Überschreibungsziel kann eine Überschreibung haben oder nicht.
• Es ist eine Schande, dass Sie die virtuelle Methode überschreiben können, ohne eine Überschreibung zu schreiben!

Über Vererbung und Überlastung von Python3

Zu dieser Zeit habe ich auch die LL-Sprache untersucht. Die Klasse ist Python, das wie eine Nachrüstung aussieht.

Da die Annahmen unterschiedlich sind, hat die Quelle eine ganz andere Bedeutung. Es tut uns leid. (JIBUN1 und JIBUN2 sind Klassenfelder)

Auch hier gibt es print2 und print3, aber sie sind gleich, da sie nicht separat geschrieben werden können.

paiza.io

main.py

# coding: utf-8
# Your code here!

def main():
    c1 = Child()
    c1.print()
    c1.print2()
    c1.print3()

    parent = Parent()
    parent.print()
    parent.print2()
    parent.print3()

#Super Klasse
class Parent(object):
    JIBUN1 = "Elternteil 1"
    JIBUN2 = "Elternteil 2"
    def __init__(self):
        self.JIBUN3 = "Elternteil 3"
        
    def print(self):
        print("print")
        print("ich" + self.JIBUN1 + "ist.")
        print("ich" + self.JIBUN2 + "ist.")
        print("ich" + self.JIBUN3 + "ist.")

    def print2(self):
        print("print2")
        print("Eltern" + self.JIBUN1 + "ist.")
        print("Eltern" + self.JIBUN2 + "ist.")
        print("Eltern" + self.JIBUN3 + "ist.")

    def print3(self):
        print("print3")
        print("Eltern" + self.JIBUN1 + "ist.")
        print("Eltern" + self.JIBUN2 + "ist.")
        print("Eltern" + self.JIBUN3 + "ist.")
 

#Kinderklasse
class Child(Parent):
    JIBUN1 = "Kind 1"
    def __init__(self):
        super(Parent, self).__init__()
        self.JIBUN3 = "Kind 3"

    def print2(self):
        print("print2")
        print("Kinder" + self.JIBUN1 + "ist.")
        print("Kinder" + self.JIBUN2 + "ist.")
        print("Kinder" + self.JIBUN3 + "ist.")

    def print3(self):
        print("print3")
        print("Kinder" + self.JIBUN1 + "ist.")
        print("Kinder" + self.JIBUN2 + "ist.")
        print("Kinder" + self.JIBUN3 + "ist.")

if __name__ == '__main__':
    main()

Ausführungsergebnis

print
Ich bin ein Kind 1.
Ich bin Elternteil 2.
Ich bin 3 Kinder
print2
Das Kind ist Kind 1.
Das Kind ist Elternteil 2.
Das Kind ist Kind 3.
print3
Das Kind ist Kind 1.
Das Kind ist Elternteil 2.
Das Kind ist Kind 3.
print
Ich bin Elternteil 1.
Ich bin Elternteil 2.
Ich bin Elternteil 3
print2
Der Elternteil ist Elternteil 1.
Der Elternteil ist Elternteil 2.
Der Elternteil ist Elternteil 3.
print3
Der Elternteil ist Elternteil 1.
Der Elternteil ist Elternteil 2.
Der Elternteil ist Elternteil 3.

Die Ergebnisse sind unten zusammengefasst.

• Erstens weist die Felddefinition im Konstruktor einen Wert zu. Wenn beim Zuweisen eines Werts kein Feld vorhanden ist, wird dieser erstellt. Es gibt keinen Zugriffsmodifikator.
• Da es sich in erster Linie um die Eingabe von Enten handelt, können Sie die Methoden und Felder beliebig überschreiben oder einfach auf die erste gefundene verweisen. (Wenn Sie es nicht finden können, suchen Sie die Vererbungsquelle.)
• Sie können mit self auf die Klassenvariable zugreifen, aber wenn Sie sie neu schreiben, wird sie in eine Instanzvariable umgewandelt. Der Zugriff über den Klassennamen ist jedoch schwierig.

Nun, ich denke es ist leicht zu verstehen.

Über Vererbung und Überladung von Rubin

Selbst in der LL-Sprache scheint Ruby die Klasse von Anfang an entworfen zu haben, also als Referenz. Rubin Ich habe es nur ein wenig gekratzt.

Dies ist auch eine Quelle mit einer ganz anderen Bedeutung.

paiza.io

Main.rb

# coding: utf-8
# Your code here!

def main()
    c1 = Child.new
    c1.print
    c1.print2
    Child.print3

    parent = Parent.new
    parent.print
    parent.print2
    Parent.print3
end

#Super Klasse
class Parent
    @JIBUN1 = "Elternteil 1"
    @@JIBUN2 = "Elternteil 2"
    def initialize
        @JIBUN3 = "Elternteil 3"
    end
        
    def print
        p "print"
        p "ich" + (@JIBUN1 || 'nicht definiert') + "ist."
        p "ich" + (@@JIBUN2 || 'nicht definiert') + "ist."
        p "ich" + @JIBUN3 + "ist."
    end

    def print2
        p "print2"
        p "Eltern" + (@JIBUN1 || 'nicht definiert') + "ist."
        p "Eltern" + (@@JIBUN2 || 'nicht definiert') + "ist."
        p "Eltern" + @JIBUN3 + "ist."
    end

    def self.print3
        p "print3"
        p "Eltern" + @JIBUN1 + "ist."
        p "Eltern" + @@JIBUN2 + "ist."
        p "Eltern" + (@JIBUN3 || 'nicht definiert') + "ist."
    end
end
 

#Kinderklasse
class Child < Parent
    @JIBUN1 = "Kind 1"
    @@JIBUN2 = "Kind 2"
    def initialize
        super
        @JIBUN3 = "Kind 3"
    end

    def print2
        p "print2"
        p "Kinder" + (@JIBUN1 || 'nicht definiert') + "ist."
        p "Kinder" + (@@JIBUN2 || 'nicht definiert') + "ist."
        p "Kinder" + @JIBUN3 + "ist."
    end

    def self.print3
        p "print3"
        p "Kinder" + (@JIBUN1 || 'nicht definiert') + "ist."
        p "Kinder" + (@@JIBUN2 || 'nicht definiert') + "ist."
        p "Kinder" + (@JIBUN3 || 'nicht definiert') + "ist."
    end
end

main

Ausführungsergebnis

"print"
"Ich bin undefiniert."
"Ich bin 2 Kinder"
"Ich bin 3 Kinder"
"print2"
"Kinder sind undefiniert."
"Das Kind ist Kind 2."
"Das Kind ist Kind 3."
"print3"
"Das Kind ist Kind 1."
"Das Kind ist Kind 2."
"Kinder sind undefiniert."
"print"
"Ich bin undefiniert."
"Ich bin 2 Kinder"
"Ich bin Elternteil 3"
"print2"
"Der Elternteil ist undefiniert."
"Der Elternteil ist Kind 2."
"Der Elternteil ist Elternteil 3."
"print3"
"Der Elternteil ist Elternteil 1."
"Der Elternteil ist Kind 2."
"Der Elternteil ist undefiniert."

Die Ergebnisse sind unten zusammengefasst.

• Es scheint, dass es mit einer Klasse entworfen wurde, aber die Felddefinition weist einen Wert im Konstruktor zu. Wenn beim Zuweisen eines Werts kein Feld vorhanden ist, wird dieser erstellt. ~~ Es gibt keinen Zugriffsmodifikator. ~~ Es tut mir leid. Es gab unzureichende Forschung. Es gibt geschützte und private, aber nur Methoden.
• Dies war auch Ententippen.
• @@ Klassenvariablen können vom Vererbungsziel aus neu geschrieben werden! gefährlich! Sie können jedoch mit einer normalen Instanzmethode darauf verweisen. Die Instanzvariable @ class liegt näher an einem normalen Bild. Aber ich kann mit der Instanzmethode nicht darauf verweisen! !!

Es scheint, dass es mit Klassen entworfen wurde, aber es ist ein Rätsel, warum Klassenvariablen und Klasseninstanzvariablen so wurden.

Zusammenfassung

• In statisch typisierten Sprachen wie Java, C #, C ++ können Klassen nur Methoden überschreiben. Das Feld ist ausgeblendet.
• In dynamisch typisierten Sprachen wie Python und Ruby wird durch Enten-Typisierung ein Mechanismus zum Überschreiben realisiert. Daher können Felder und Methoden frei umgeschrieben werden.
• Wenn Sie eine Frage zu einer Sprache haben, mit der Sie nicht vertraut sind, sollten Sie diese vor der Beantwortung untersuchen.