Puis-je remplacer et surcharger des méthodes statiques en Java?
J'aimerais savoir:
- Pourquoi les méthodes statiques ne peuvent-elles pas être remplacées en Java?
- Les méthodes statiques peuvent-elles être surchargées en Java?
Les méthodes statiques ne peuvent pas être remplacées dans le sens exact du mot, mais elles peuvent masquer les méthodes statiques parent
En pratique, cela signifie que le compilateur décidera quelle méthode exécuter au moment de la compilation, et non au moment de l'exécution, comme c'est le cas avec les méthodes d'instance surchargées.
Pour un exemple soigné, jetez un coup d'oeil ici .
Et this est la documentation Java qui explique la différence entre les méthodes d’instance overriding et les méthodes hiding class (static).
Overriding: Overriding in Java signifie simplement que la méthode particulière serait appelée en fonction du type d'exécution de l'objet et de pas sur le type de compilation (ce qui est le cas avec overriden méthodes statiques)
Hiding: Les méthodes de la classe parent qui sont statiques ne font pas partie d'une classe enfant (bien qu'elles soient accessibles), il n'est donc pas question de le dépassant. Même si vous ajoutez une autre méthode statique dans une sous-classe, identique à celle de sa classe parente, cette méthode statique de la sous-classe est unique et distinct de la méthode statique dans sa classe parente.
Les méthodes statiques ne peuvent pas être remplacées car il n'y a rien à remplacer, car il s'agirait de deux méthodes différentes. Par exemple
static class Class1 {
public static int Method1(){
return 0;
}
}
static class Class2 extends Class1 {
public static int Method1(){
return 1;
}
}
public static class Main {
public static void main(String[] args){
//Must explicitly chose Method1 from Class1 or Class2
Class1.Method1();
Class2.Method1();
}
}
Et oui, les méthodes statiques peuvent être surchargées comme n'importe quelle autre méthode.
Les méthodes statiques ne peuvent pas être remplacées car elles ne sont pas distribuées sur l'instance d'objet au moment de l'exécution. Le compilateur décide quelle méthode doit être appelée.
C’est pourquoi vous recevez un avertissement du compilateur lorsque vous écrivez
MyClass myObject = new MyClass();
myObject.myStaticMethod();
// should be written as
MyClass.myStaticMethod()
// because it is not dispatched on myObject
myObject = new MySubClass();
myObject.myStaticMethod();
// still calls the static method in MyClass, NOT in MySubClass
Les méthodes statiques peuvent être surchargées (ce qui signifie que vous pouvez avoir le même nom de méthode pour plusieurs méthodes à condition que leurs types de paramètres soient différents).
Integer.parseInt("10");
Integer.parseInt("AA", 16);
Les méthodes de classe parent qui sont statiques ne font pas partie d'une classe enfant (bien qu'elles soient accessibles), il n'est donc pas question de la remplacer. Même si vous ajoutez une autre méthode statique dans une sous-classe, identique à celle de sa classe parent, cette méthode statique de sous-classe est unique et distincte de la méthode statique de sa classe parent.
Les méthodes statiques ne peuvent pas être remplacées car elles ne font pas partie de l'état de l'objet. Au contraire, ils appartiennent à la classe (c'est-à-dire qu'ils sont des méthodes de classe). Il est correct de surcharger les méthodes statiques (et finales).
Si j’appelle la méthode en utilisant le nom de sous-classe MysubClass, la méthode de sous-classe affiche ce que cela signifie: la méthode statique peut être remplacée ou non.
class MyClass {
static void myStaticMethod() {
System.out.println("Im in sta1");
}
}
class MySubClass extends MyClass {
static void myStaticMethod() {
System.out.println("Im in sta123");
}
}
public class My {
public static void main(String arg[]) {
MyClass myObject = new MyClass();
myObject.myStaticMethod();
// should be written as
MyClass.myStaticMethod();
// calling from subclass name
MySubClass.myStaticMethod();
myObject = new MySubClass();
myObject.myStaticMethod();
// still calls the static method in MyClass, NOT in MySubClass
}
}
Non, les méthodes statiques ne peuvent pas être remplacées car elles font partie d'une classe plutôt que d'un objet . Mais on peut surcharger une méthode statique.
Les méthodes static sont des méthodes class.
Le concept de masquage est utilisé pour les méthodes static.
Voir: http://www.coderanch.com/how-to/Java/OverridingVsHiding
Méthodes statiques est une méthode dont la copie unique est partagée par tous les objets de la classe. La méthode statique appartient à la classe plutôt qu'aux objets. Etant donné que les méthodes statiques ne dépendent pas des objets, Java Compiler n'a pas besoin d'attendre la création de l'objet. Pour appeler une méthode statique, nous utilisons une syntaxe comme ClassName.method ();
En cas de surcharge de méthode, les méthodes doivent appartenir à la même classe pour surcharger. Même si elles sont déclarées statiques, il est possible de les surcharger de la manière suivante:
Class Sample
{
static int calculate(int a,int b,int c)
{
int res = a+b+c;
return res;
}
static int calculate(int a,int b)
{
int res = a*b;
return res;
}
}
class Test
{
public static void main(String []args)
{
int res = Sample.calculate(10,20,30);
}
}
Mais en cas de substitution de méthode, la méthode de la super classe et la méthode de la sous-classe agissent comme une méthode différente. la super classe aura sa propre copie et la sous-classe aura sa propre copie afin d'éviter toute substitution de méthode.
Depuis Pourquoi Java n'autorise-t-il pas le remplacement de méthodes statiques?
La substitution dépend de la présence d'une instance d'une classe. L'intérêt du polymorphisme est que vous pouvez sous-classer une classe et que les objets implémentant ces sous-classes auront des comportements différents pour les mêmes méthodes définies dans la superclasse (et remplacées par celles-ci). Une méthode statique n'est associée à aucune instance d'une classe et le concept n'est donc pas applicable.
La conception de Java a été influencée par deux facteurs. L'une concernait les performances: il y avait eu beaucoup de critiques à propos de Smalltalk pour sa lenteur (la récupération de place et les appels polymorphes en faisaient partie) et les créateurs de Java étaient déterminés à éviter cela. Un autre exemple était la décision selon laquelle le public cible de Java était les développeurs C++. Les méthodes statiques fonctionnent de la manière habituelle pour les programmeurs C++ et sont très rapides car il n’est pas nécessaire d’attendre le moment de l’exécution pour déterminer quelle méthode appeler.
class SuperType {
public static void classMethod(){
System.out.println("Super type class method");
}
public void instancemethod(){
System.out.println("Super Type instance method");
}
}
public class SubType extends SuperType{
public static void classMethod(){
System.out.println("Sub type class method");
}
public void instancemethod(){
System.out.println("Sub Type instance method");
}
public static void main(String args[]){
SubType s=new SubType();
SuperType su=s;
SuperType.classMethod();// Prints.....Super type class method
su.classMethod(); //Prints.....Super type class method
SubType.classMethod(); //Prints.....Sub type class method
}
}
Cet exemple de substitution de méthode statique
Remarque: si nous appelons une méthode statique avec référence à un objet, la méthode statique de type référence (classe) sera appelée, et non une méthode statique de classe objet.
La méthode statique appartient à la classe uniquement.
Le but même de l’utilisation de la méthode statique est d’accéder à la méthode d’une classe sans créer d’instance pour elle. Cela n’a aucun sens de remplacer cette méthode car elle sera accessible par classname.method ().
Vous pouvez surcharger une méthode statique mais vous ne pouvez pas remplacer une méthode statique. En réalité, vous pouvez réécrire une méthode statique dans des sous-classes, mais cela n’appelle pas un remplacement, car celui-ci doit être lié au polymorphisme et à la liaison dynamique. La méthode statique appartient à la classe et n'a donc rien à voir avec ces concepts. La réécriture de la méthode statique s'apparente davantage à un shadowing.
Je conçois un code de méthode statique surchargeant.Je pense que c’est facilement surchargé.Veuillez me dire à quel point il est impossible de remplacer les membres statiques.Voici mon code-
class Class1 {
public static int Method1(){
System.out.println("true");
return 0;
}
}
class Class2 extends Class1 {
public static int Method1(){
System.out.println("false");
return 1;
}
}
public class Mai {
public static void main(String[] args){
Class2 c=new Class2();
//Must explicitly chose Method1 from Class1 or Class2
//Class1.Method1();
c.Method1();
}
}
La surcharge est également appelée liaison statique. Ainsi, dès que Word statique est utilisé, cela signifie une méthode statique ne peut pas afficher le polymorphisme au moment de l'exécution .
Nous ne pouvons pas remplacer une méthode statiquemais la présence d'implémentations différentes de la même méthode statique dans une super classe et sa sous-classe est valide. C'est juste que la classe dérivée cachera les implémentations de la classe de base.
Pour les méthodes statiques, l’appel de la méthode dépend du type de référence et non de l’objet référé, c’est-à-dire que la méthode statique appartient uniquement à une classe et non à ses occurrences.
Tandis qu'en cas de surcharge de méthodeles méthodes statiques peuvent être surchargéesiff, elles ont un nombre ou des types de paramètres différents. Si deux méthodes ont le même nom et la même liste de paramètres, elles ne peuvent pas être définies différemment en utilisant le mot clé 'static'.
C’est en fait assez simple à comprendre - Tout ce qui est marqué comme statique n’appartient qu’à la classe. Par exemple, la méthode statique ne peut pas être héritée de la sous-classe car elle appartient à la classe dans laquelle elles ont été déclarées. Voir le mot clé statique.
La meilleure réponse que j'ai trouvée à cette question est:
http://www.geeksforgeeks.org/can-we-overload-or-override-static-methods-in-Java/
Comme toute méthode statique fait partie de la classe et non de l'instance, il n'est pas possible de remplacer la méthode statique.
Non, vous ne pouvez pas remplacer une méthode statique. Le statique résout contre la classe, pas l'instance.
public class Parent {
public static String getCName() {
return "I am the parent";
}
}
public class Child extends Parent {
public static String getCName() {
return "I am the child";
}
}
Chaque classe a une méthode statique getCName (). Lorsque vous appelez le nom de la classe, celui-ci se comporte comme prévu et chacun renvoie la valeur attendue.
@Test
public void testGetCNameOnClass() {
assertThat(Parent.getCName(), is("I am the parent"));
assertThat(Child.getCName(), is("I am the child"));
}
Pas de surprises dans ce test unitaire. Mais ce n'est pas contraignant. Cela déclare quelque chose qui a une collision de nom.
Si nous essayons d’atteindre la statique à partir d’une instance de la classe (ce n’est pas une bonne pratique), alors cela montre vraiment:
private Parent cp = new Child();
`enter code here`
assertThat(cp.getCName(), is("I am the parent"));
Même si cp est un enfant, la statique est résolue par le type déclaré, Parent, au lieu du type réel de l'objet. Pour les non-statiques, cela est résolu correctement car une méthode non statique peut remplacer une méthode de son parent.