Posso sovrascrivere e sovraccaricare i metodi statici in Java?

Mi piacerebbe sapere:

  1. Perché i metodi statici non possono essere sovrascritti in Java?
  2. I metodi statici possono essere sovraccaricati in Java?

I metodi statici non possono essere sovrascritti nel senso esatto della parola, ma possono hide i metodi statici del genitore

In pratica vuol dire che il compilatore que deciderà quale metodo eseguire in fase di compilazione, e non in runtime, come con i metodi di istanza sovrascritte.

Per un esempio accurato dai un’occhiata qui .

E questa è la documentazione java che spiega la differenza tra l’ override dei metodi di istanza e il hide i metodi di class (statici).

Sovrascrittura: l’ override in Java significa semplicemente che il particolare metodo sarebbe chiamato in base al tipo di tempo di esecuzione dell’object e non al tipo di tempo di compilazione di esso (che è il caso dei metodi statici sovrascritti)

Nascondere: i metodi della class padre che sono statici non fanno parte di una class figlia (sebbene siano accessibili), quindi non si tratta di sovrascriverli. Anche se si aggiunge un altro metodo statico in una sottoclass, identico a quello nella sua class genitore, questo metodo statico di sottoclass è unico e distinto dal metodo statico nella sua class genitore.

I metodi statici non possono essere sovrascritti perché non c’è nulla da sovrascrivere, poiché sarebbero due metodi diversi. Per esempio

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(); } } 

E sì, i metodi statici possono essere sovraccaricati come qualsiasi altro metodo.

Possiamo sovraccaricare i metodi statici?

La risposta è . Possiamo avere due o più metodi statici con lo stesso nome, ma differenze nei parametri di input. Ad esempio, si consideri il seguente programma Java.

 public class Test { public static void foo() { System.out.println("Test.foo() called "); } public static void foo(int a) { System.out.println("Test.foo(int) called "); } public static void main(String args[]) { Test.foo(); //Test.foo() called printed Test.foo(10); //Test.foo(int) called printed } } 

Possiamo sovraccaricare metodi che differiscono solo dalla parola chiave statica?

Non possiamo sovraccaricare due metodi in Java se differiscono solo dalla parola chiave statica (numero di parametri e tipi di parametri è lo stesso). Vedere il seguente programma Java, ad esempio. Questo comportamento è lo stesso in C ++.

 public class Test { public static void foo() { System.out.println("Test.foo() called "); } public void foo() { // Compiler Error: cannot redefine foo() System.out.println("Test.foo(int) called "); } public static void main(String args[]) { Test.foo(); } } 

Possiamo sovrascrivere i metodi statici in java?

Possiamo dichiarare metodi statici con la stessa firma in sottoclass, ma non è considerato prioritario in quanto non ci sarà alcun polimorfismo di runtime. Quindi la risposta è No.

Se una class derivata definisce un metodo statico con la stessa firma di un metodo statico nella class base, il metodo nella class derivata nasconde il metodo nella class base. se il metodo statico viene ridefinito da una class derivata, allora non è prioritario.

 class Base { // Static method in base class which will be hidden in subclass public static void display() { System.out.println("Static or class method from Base"); } // Non-static method which will be overridden in derived class public void print() { System.out.println("Non-static or Instance method from Base"); } } class Derived extends Base { // This method hides display() in Base public static void display() { System.out.println("Static or class method from Derived"); } // This method overrides print() in Base public void print() { System.out.println("Non-static or Instance method from Derived"); } } public class Test { public static void main(String args[ ]) { Base obj1 = new Derived(); // As per overriding rules this should call to class Derive's static // overridden method. Since static method can not be overridden, it // calls Base's display() obj1.display(); //output -> Static or class method from Base // Here overriding works and Derive's print() is called obj1.print(); //output-> Non-static or Instance method from Derived } } 

I metodi statici non possono essere sovrascritti perché non vengono inviati sull’istanza dell’object in fase di runtime. Il compilatore decide quale metodo viene chiamato.

Questo è il motivo per cui ricevi un avvertimento sul compilatore quando scrivi

  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 

I metodi statici possono essere sovraccaricati (nel senso che è ansible avere lo stesso nome di metodo per diversi metodi, purché abbiano tipi di parametri diversi).

  Integer.parseInt("10"); Integer.parseInt("AA", 16); 

I metodi della class padre che sono statici non fanno parte di una class figlia (sebbene siano accessibili), quindi non si tratta di sovrascriverli. Anche se si aggiunge un altro metodo statico in una sottoclass, identico a quello nella sua class genitore, questo metodo statico di sottoclass è unico e distinto dal metodo statico nella sua class genitore.

I metodi statici non possono essere sovrascritti perché non fanno parte dello stato dell’object. Piuttosto, appartengono alla class (cioè sono metodi di class). Va bene sovraccaricare i metodi statici (e finali).

Se chiamo il metodo usando il nome SubClass MysubClass, allora il metodo della sottoclass mostra cosa vuol dire che il metodo statico può essere ignorato o no

 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 } } 

No, i metodi statici non possono essere ignorati in quanto fa parte di una class piuttosto che di un object. Ma si può sovraccaricare il metodo statico.

I metodi statici sono un metodo la cui copia singola è condivisa da tutti gli oggetti della class. Il metodo statico appartiene alla class piuttosto che agli oggetti. Poiché i metodi statici non dipendono dagli oggetti, il compilatore Java non deve attendere la creazione degli oggetti. Per chiamare il metodo statico si usa la syntax come ClassName.method ();

In caso di sovraccarico del metodo, i metodi dovrebbero essere nella stessa class per sovraccaricare. Anche se sono dichiarati come statici, è ansible sovraccaricarli come,

  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); } } 

Ma in caso di sovrascrittura del metodo, il metodo nella super class e il metodo nella sottoclass fungono da metodo diverso. la super class avrà una sua copia e la sottoclass avrà una sua copia, quindi non verrà sottoposta a override del metodo.

 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 } } 

Questo esempio per la sovrascrittura del metodo statico

Nota: se chiamiamo un metodo statico con riferimento a un object, verrà chiamato il metodo statico di tipo (class) di riferimento, non il metodo statico di class dell’object.

Il metodo statico appartiene solo alla class.

Da Perché Java non consente l’override dei metodi statici?

L’override dipende dall’avere un’istanza di una class. Il punto di polimorfismo è che è ansible sottoclass una class e gli oggetti che implementano quelle sottoclassi avranno comportamenti diversi per gli stessi metodi definiti nella superclass (e sovrascritti nelle sottoclassi). Un metodo statico non è associato a nessuna istanza di una class, quindi il concetto non è applicabile.

Ci sono state due considerazioni che hanno guidato il design di Java che ha avuto un impatto su questo. Uno riguardava la performance: c’erano state molte critiche a Smalltalk sul fatto che fosse troppo lento (la raccolta dei rifiuti e le chiamate polimorfiche facevano parte di questo) e i creatori di Java erano determinati a evitarlo. Un altro era la decisione che il pubblico di destinazione per Java era sviluppatori C ++. Fare in modo che i metodi statici funzionino nel modo in cui hanno il beneficio della familiarità per i programmatori C ++ e anche molto veloci, perché non è necessario attendere il runtime per capire quale metodo chiamare.

static metodi static sono metodi a livello di class .

Il concetto di occultamento è usato per metodi static .

Vedi: http://www.coderanch.com/how-to/java/OverridingVsHiding

Lo scopo principale dell’utilizzo del metodo statico è quello di accedere al metodo di una class senza creare un’istanza per esso. Non ha senso se si esegue l’override di quel metodo poiché saranno accessibili da classname.method ()

No, non è ansible sovrascrivere un metodo statico. La statica si risolve contro la class, non l’istanza.

 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"; } } 

Ogni class ha un metodo statico getCName (). Quando si chiama il nome della class si comporta come ci si aspetterebbe e ognuno restituisce il valore previsto.

 @Test public void testGetCNameOnClass() { assertThat(Parent.getCName(), is("I am the parent")); assertThat(Child.getCName(), is("I am the child")); } 

Nessuna sorpresa in questo test unitario. Ma questo non è prioritario. Questo dichiara qualcosa che ha un nome collisione.

Se proviamo a raggiungere lo statico da un’istanza della class (non una buona pratica), allora mostra davvero:

 private Parent cp = new Child(); `enter code here` assertThat(cp.getCName(), is("I am the parent")); 

Anche se cp è un figlio, la statica viene risolta tramite il tipo dichiarato, padre, anziché il tipo effettivo dell’object. Per non-statici, questo viene risolto correttamente perché un metodo non statico può sovrascrivere un metodo del suo genitore.

È ansible sovraccaricare un metodo statico ma non è ansible sovrascrivere un metodo statico. In realtà è ansible riscrivere un metodo statico in sottoclassi, ma questo non è chiamato override perché l’override deve essere correlato al polimorfismo e al bind dinamico. Il metodo statico appartiene alla class quindi non ha nulla a che fare con questi concetti. La riscrittura del metodo statico è più simile a uno shadowing.

Progetto un codice di metodo statico che sovrascrive. Penso che sia semplice da ignorare. Per favore chiariscimi come non sia in grado di scavalcare i membri statici. Ecco il mio codice-

 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(); } } 

In realtà è piuttosto semplice da capire: tutto ciò che è contrassegnato come statico appartiene solo alla class, ad esempio il metodo statico non può essere ereditato nella sottoclass perché appartiene alla class in cui sono stati dichiarati. Fai riferimento alla parola chiave statica.

La migliore risposta che ho trovato di questa domanda è:

http://www.geeksforgeeks.org/can-we-overload-or-override-static-methods-in-java/

Possiamo sovraccaricare i metodi statici?

La risposta è “Sì” . Possiamo avere due o più metodi statici con lo stesso nome, ma differenze nei parametri di input. Ad esempio, si consideri il seguente programma Java.

  // filename Test.java public class Test { public static void foo() { System.out.println("Test.foo() called "); } public static void foo(int a) { System.out.println("Test.foo(int) called "); } public static void main(String args[]) { Test.foo(); Test.foo(10); } } 

Produzione:

 Test.foo() called Test.foo(int) called 

Possiamo sovrascrivere i metodi statici in java?

Possiamo dichiarare metodi statici con la stessa firma in sottoclass, ma non è considerato prioritario in quanto non ci sarà alcun polimorfismo di runtime. Quindi la risposta è “No”.

Se una class derivata definisce un metodo statico con la stessa firma di un metodo statico nella class base, il metodo nella class derivata nasconde il metodo nella class base.

  /* Java program to show that if static method is redefined by a derived class, then it is not overriding. */ // Superclass class Base { // Static method in base class which will be hidden in subclass public static void display() { System.out.println("Static or class method from Base"); } // Non-static method which will be overridden in derived class public void print() { System.out.println("Non-static or Instance method from Base"); } } // Subclass class Derived extends Base { // This method hides display() in Base public static void display() { System.out.println("Static or class method from Derived"); } // This method overrides print() in Base public void print() { System.out.println("Non-static or Instance method from Derived"); } } // Driver class public class Test { public static void main(String args[ ]) { Base obj1 = new Derived(); // As per overriding rules this should call to class Derive's static // overridden method. Since static method can not be overridden, it // calls Base's display() obj1.display(); // Here overriding works and Derive's print() is called obj1.print(); } } 

Produzione :

 Static or class method from Base Non-static or Instance method from Derived 

Poiché qualsiasi metodo statico fa parte della class non dell’istanza, non è ansible sovrascrivere il metodo statico

Il sovraccarico è anche chiamato associazione statica, quindi non appena viene utilizzata la parola statica, significa che un metodo statico non può mostrare il polimorfismo di runtime .

Non possiamo sovrascrivere un metodo statico ma la presenza di diverse implementazioni dello stesso metodo statico in una super class e la sua sottoclass è valida. È solo che la class derivata nasconderà le implementazioni della class base.

Per i metodi statici, la chiamata al metodo dipende dal tipo di riferimento e non dall’object cui si fa riferimento, vale a dire che il metodo statico appartiene solo a una class e non alle sue istanze, quindi la chiamata al metodo viene decisa al momento della compilazione stesso.

Mentre in caso di sovraccarico del metodo, i metodi statici possono essere sovraccaricati se hanno numero di diff o tipi di parametri. Se due metodi hanno lo stesso nome e lo stesso elenco di parametri, non possono essere definiti diversi solo usando la parola chiave ‘statica’.