Différence entre Python auto et Java

Sur self en Python (voici la source: Python auto explication):

La raison pour laquelle vous devez utiliser auto. est parce que Python ne pas utiliser la syntaxe @ référer à l'instance attributs. Python a décidé de faire, des méthodes d'une manière qui rend l'instance à laquelle la méthode est de passer automatiquement, mais pas reçu automatiquement: le premier paramètre de méthodes est l'exemple, la méthode est appelée. Cela fait des méthodes tout à fait la même que les fonctions, et laisse le nom de l'utiliser jusqu'à vous (même si auto est la convention, et les gens vont généralement froncer les sourcils à vous lorsque vous utilisez autre chose.) auto n'est pas spécial pour le code, c'est juste un autre objet.

Python aurait pu faire quelque chose d'autre à distinguer normale noms d'attributs -- syntaxe particulière comme le Rubis a, ou d'exiger des déclarations comme C++ et Java, ou peut-être quelque chose de plus différent, mais il n'a pas. Python est tout pour rendre les choses explicite, de le rendre vivant ce qu'il en est, et bien qu'il ne le fait pas entièrement partout, il le fait faire par exemple des attributs. C'est pourquoi l'attribution à une instance de l'attribut doit savoir ce qu'instance d'attribuer à l', et c'est pourquoi il a besoin de auto..

Sur this en Java étant expliqué par Oracle (voici la source: Java cette explication):

Au sein d'une instance de méthode ou d'un constructeur, ce est une référence à l'objet — l'objet dont la méthode ou le constructeur est appelé. Vous pouvez vous référer à un membre de l'objet courant à l'intérieur d'une méthode d'instance ou un constructeur en utilisant ce.
La raison la plus courante pour l'utilisation de la ce mot-clé est parce qu'un champ est masqué par une méthode ou d'un constructeur paramètre.

Être prudent super peut garder sa propre version de ce.j'en Java, mais auto.je me réfère toujours à l'enfant en Python.

Main.java:

class Parent {

    int i;
    Parent() {
        this.i = 5;
    }

    void doStuff() {
        System.out.println(this.i);
    }
}

class Child extends Parent {
    int i;
    Child() {
        this.i = 7;
    }
}

class Main {

    public static void main(String[] args) {
        Child m = new Child();
        System.out.println(m.i); //print 7
        m.doStuff(); //print 5
    }
}

Main.py:

class Parent(object):
    i = 5;
    def __init__(self):
        self.i = 5

    def doStuff(self):
        print(self.i)

class Child(Parent, object):

    def __init__(self):
        super(Child, self).__init__()
        self.i = 7

class Main():

    def main(self):
        m = Child()
        print(m.i) #print 7
        m.doStuff() #print 7

m = Main()
m.main()

De sortie:

$ java Main 
7
5
$ python Main.py 
7
7

[Mise à jour]

La raison en est que Java est int i déclaration Child classe rend le i devenir de la classe de portée variable, bien qu'aucune de ces variables ombrage en Python sous-classement. Si vous supprimez int i dans Child classe de Java, il permet d'imprimer le 7 et le 7 aussi.