web-dev-qa-db-fra.com

Différence entre Python self et Java ce

J'avais fait un peu de Python longtemps en arrière. Cependant, je passe maintenant à Java. Je voulais savoir s’il existait des différences entre la méthode Python "self" et la méthode Java "this".

Je sais que "soi" n'est pas un mot clé alors que "ceci" l'est. Et c'est à peu près ce que je pourrais comprendre. Est-ce que je manque quelque chose d'autre?

javapythonthisself
49
Bayko

À propos de self in Python (voici la source: auto-explication Python) ):

La raison pour laquelle vous devez utiliser self. C'est parce que Python n'utilise pas la syntaxe @ pour faire référence aux attributs d'instance. Python a décidé de faire des méthodes d'une manière qui rende l'instance à laquelle la méthode appartient. être passé automatiquement, mais pas reçu automatiquement: le premier paramètre des méthodes est l'instance sur laquelle la méthode est appelée, ce qui rend les méthodes entièrement identiques aux fonctions et laisse le nom réel à utiliser (bien que self est la convention, et les gens vont généralement vous froncer les sourcils lorsque vous utilisez autre chose.) self n'est pas spécial pour le code, c'est juste un autre objet.

Python aurait pu faire autre chose pour distinguer les noms normaux des attributs - une syntaxe spéciale comme Ruby a, ou nécessitant des déclarations comme C++ et Java do, ou peut-être quelque chose Python a tout pour rendre les choses explicites, rendre évidente ce qui est quoi, et bien qu'il ne le fasse pas entièrement partout, il le fait pour les attributs d'instance. C'est pourquoi l'assignation à un attribut d'instance a besoin de savoir à quelle instance assigner, et c’est pourquoi il a besoin de self ..

À propos de this in Java étant expliqué par Oracle (voici la source: Java cette explication =)) :

Dans une méthode d'instance ou un constructeur, this est une référence à l'objet actuel - l'objet dont la méthode ou le constructeur est appelé. Vous pouvez faire référence à n’importe quel membre de l’objet actuel à partir d’une méthode d’instance ou d’un constructeur en utilisant this. La raison la plus courante d'utiliser le mot clé this est qu'un champ est masqué par un paramètre de méthode ou de constructeur.

31
Anastasios Vlasopoulos

Tout d’abord, laissez-moi vous corriger - self n’est pas une méthode. Aller plus loin:

Techniquement, self et this sont utilisés pour la même chose. Ils sont utilisés pour accéder à la variable associée à l'instance actuelle. La seule différence est que vous devez inclure explicitement self comme premier paramètre d'une méthode d'instance en Python, alors que ce n'est pas le cas avec Java. De plus, le nom self peut être n'importe quoi. Ce n'est pas un mot-clé, comme vous le savez déjà. vous pouvez même le changer en this, et cela fonctionnera bien. Mais les gens aiment utiliser self, car cela est devenu un peu une convention.

Voici une méthode d'instance simple accédant à une variable d'instance à la fois Python et Java:

Python:

class Circle(object):
    def __init__(self, radius):
        # declare and initialize an instance variable
        self.radius = radius

# Create object. Notice how you are passing only a single argument.  
# The object reference is implicitly bound to `self` parameter of `__init__` method
circle1 = Circle(5);

Java:

class Circle {
    private int radius;

    public Circle(int radius) {
        this.radius = radius;
    }
}

Circle circle1 = new Circle(5);

Voir aussi:

67
Rohit Jain

Soyez prudent super peut garder sa propre version de this.i en Java, mais self.i fait toujours référence à 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()

Sortie:

$ Java Main 
7
5
$ python Main.py 
7
7

[Mise à jour]

La raison en est que int i déclaration dans Child classe rend la i variable de la portée de la classe, alors qu’aucune variable de ce type n’observe de sous-classe Python. Si vous supprimez int i dans Child classe de Java, il imprimera également 7 et 7.

12
林果皞

De mon point de vue, la différence la plus évidente est que dans la classe Java, dans le constructeur, vous devez spécifier le champ

this.radius = radius

Dans le code python, vous n’avez pas à le faire, c’est implicite.

1
Jason Cheng