method - Diferencia entre Python auto y Java este
metodo static java (4)
Había hecho un poco de Python mucho tiempo atrás. Sin embargo me estoy moviendo a Java ahora. Quería saber si había alguna diferencia entre el método "self" de Python y Java "this".
Sé que "yo" no es una palabra clave, mientras que "esto" es. Y eso es más o menos lo que pude averiguar. ¿Me estoy perdiendo algo más?
Desde mi perspectiva, la diferencia más obvia es que en la clase java, en el constructor, debe especificar el campo
this.radius = radius
Mientras esté en el código de Python, no tiene que hacerlo, está implícito.
En primer lugar, déjame corregirte, el self no es un método. Moviéndose más lejos:
Técnicamente, tanto el self como this se utilizan para la misma cosa. Se utilizan para acceder a la variable asociada con la instancia actual. La única diferencia es que debe incluirse de self explícita como primer parámetro para un método de instancia en Python, mientras que este no es el caso de Java. Además, el nombre self puede ser cualquier cosa. No es una palabra clave, como ya sabes. Incluso puedes cambiarlo por this , y funcionará bien. Pero a la gente le gusta usar el self , ya que ahora se ha convertido en una convención.
Aquí hay un método de instancia simple que accede a una variable de instancia tanto en Python como en Java:
Pitón:
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);
Ver también:
Tenga cuidado, super puede mantener su propia versión de this.i en Java , pero self.i siempre hace referencia al niño 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()
Salida:
$ java Main
7
5
$ python Main.py
7
7
[Actualizar]
La razón se debe a que la declaración int i Java en Child clase secundaria hace que i convierta en una variable de alcance de clase, mientras que no existe una variable de este tipo en la subclasificación de Python. Si elimina int i en Child clase secundaria de Java, se imprimirá 7 y 7 también.
Acerca del self en Python (aquí está la fuente: auto explicación de Python ):
La razón por la que necesitas usar el yo . es porque Python no usa la sintaxis de @ para referirse a los atributos de instancia. Python decidió hacer métodos de una manera que haga que la instancia a la que pertenece el método se pase automáticamente, pero no se reciba automáticamente: el primer parámetro de los métodos es la instancia a la que se llama el método. Eso hace que los métodos sean completamente iguales a las funciones, y deja que el nombre real se use para ti (aunque self es la convención, y la gente generalmente te frunce el ceño cuando usas otra cosa). Self no es especial para el código, es simplemente otro objeto
Python podría haber hecho algo más para distinguir los nombres normales de los atributos (sintaxis especial como Ruby), o requerir declaraciones como C ++ y Java, o quizás algo más diferente, pero no fue así. Python es todo para hacer las cosas explícitas, lo que lo hace obvio, y aunque no lo hace del todo en todas partes, lo hace por ejemplo, los atributos. Es por eso que asignar un atributo de instancia necesita saber a qué instancia asignar y por eso se necesita uno mismo .
Sobre this en Java lo explica Oracle (aquí está la fuente: Java esta explicación ):
Dentro de un método de instancia o un constructor, esta es una referencia al objeto actual, el objeto cuyo método o constructor se está llamando. Puede referirse a cualquier miembro del objeto actual desde un método de instancia o un constructor usando esto . La razón más común para usar esta palabra clave es porque un campo está sombreado por un método o un parámetro constructor.