Différence entre Python self et Java this
j'avais fait un peu de Python il y a longtemps. Je me déplace cependant vers Java maintenant. Je voulais savoir s'il y avait des différences entre la méthode Python "self" et Java "this".
je sais que le "soi" n'est pas un mot clé "this" est. Et c'est à peu près ce que je pouvais comprendre. Est-ce que je manque autre chose?
4 réponses
à Propos de self en Python (voici la source: Python auto explication ):
La raison pour laquelle vous devez utiliser auto . 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 rend l'instance à laquelle appartient la méthode soit passée automatiquement, mais pas reçue automatiquement: le premier paramètre des méthodes est le exemple, la méthode est appelée. Cela rend les méthodes entièrement les mêmes que les fonctions, et laisse le nom réel à utiliser à vous (bien que self est la convention, et les gens seront généralement froncer les sourcils à vous lorsque vous utilisez quelque chose d'autre.) auto 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 exiger des déclarations comme C++ et Java do, ou peut-être quelque chose de plus différent -- mais ce n'est pas le cas. Python fait tout pour rendre les choses explicites, ce qui rend évident ce qui est quoi, et bien qu'il ne le fasse pas entièrement partout, il le fait par exemple des attributs. C'est pourquoi assigner à un attribut d'instance doit savoir à quelle instance attribuer, et c'est pourquoi il a besoin de self ..
à propos de this en Java étant expliqué par Oracle (voici la source: Java cette explication ):
dans une méthode d'instance ou un constructeur, ce est une référence à l'objet courant - l'objet dont la méthode ou le constructeur est appelé. Vous pouvez vous référer à n'importe quel membre de l'objet courant depuis une méthode d'instance ou un constructeur en utilisant ce . La raison la plus fréquente pour utiliser le ce mot-clé est parce qu'un champ est masqué par une méthode ou d'un constructeur paramètre.
tout d'Abord, permettez-moi de vous corriger - self n'est pas une méthode. Aller plus loin:
Techniquement les deux self et this sont utilisés pour la même chose. Ils sont utilisés pour accéder à la variable associée à l'instance en cours. La seule différence est que vous devez inclure self explicitement comme premier paramètre à 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 changer pour this , et il fonctionne parfaitement. Mais les gens aiment utiliser self , car il est devenu un peu d'une convention.
Voici une méthode d'instance simple pour accéder à une variable d'instance en Python et en 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:
Être prudent super peut garder sa propre version de ce.j'en Java , mais l'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()
sortie:
$ java Main
7
5
$ python Main.py
7
7
[mise à Jour]
la raison en est que la déclaration int i de Java dans la classe Child fait en sorte que la classe i devient une variable de portée de classe, alors qu'Aucune variable de ce type n'est associée au sous-titrage Python. Si vous supprimez int i dans la classe Child de Java, il affichera aussi 7 et 7.
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
Alors que dans le code python, vous n'avez pas à le faire, c'est implicite.