Was ist der Unterschied zwischen einer statischen und einer nicht statischen Methode?

Siehe die folgenden Codefragmente:

Code 1

public class A {
    static int add(int i, int j) {
        return(i + j);
    }
}

public class B extends A {
    public static void main(String args[]) {
        short s = 9;
        System.out.println(add(s, 6));
    }
}

Code 2

public class A {
    int add(int i, int j) {
        return(i + j);
    }
}

public class B extends A {
    public static void main(String args[]) {
    A a = new A();
        short s = 9;
        System.out.println(a.add(s, 6));
    }
}

Was ist der Unterschied zwischen diesen Codefragmenten? Beide werden 15als Antwort ausgegeben .

Eine statische Methode gehört zur Klasse selbst und eine nicht statische Methode (auch als Instanz bezeichnet) gehört zu jedem Objekt, das aus dieser Klasse generiert wird. Wenn Ihre Methode etwas tut, das nicht von den individuellen Merkmalen ihrer Klasse abhängt, machen Sie sie statisch (dadurch wird der Footprint des Programms kleiner). Andernfalls sollte es nicht statisch sein.

Beispiel:

class Foo {
    int i;

    public Foo(int i) { 
       this.i = i;
    }

    public static String method1() {
       return "An example string that doesn't depend on i (an instance variable)";
    }

    public int method2() {
       return this.i + 1; // Depends on i
    }
}

Sie können statische Methoden wie folgt aufrufen : Foo.method1(). Wenn Sie dies mit Methode2 versuchen, schlägt dies fehl. Aber das wird funktionieren:Foo bar = new Foo(1); bar.method2();

Statische Methoden sind nützlich, wenn Sie nur eine Instanz (Situation, Umstand) haben, in der Sie die Methode verwenden möchten, und Sie nicht mehrere Kopien (Objekte) benötigen. Wenn Sie beispielsweise eine Methode schreiben, die sich auf einer und nur einer Website anmeldet, die Wetterdaten herunterlädt und dann die Werte zurückgibt, können Sie sie als statisch schreiben, da Sie alle erforderlichen Daten innerhalb der Methode und fest codieren können Sie werden nicht mehrere Instanzen oder Kopien haben. Sie können dann mithilfe einer der folgenden Methoden statisch auf die Methode zugreifen:

MyClass.myMethod();
this.myMethod();
myMethod();

Nicht statische Methoden werden verwendet, wenn Sie mit Ihrer Methode mehrere Kopien erstellen möchten. Wenn Sie beispielsweise die Wetterdaten aus Boston, Miami und Los Angeles herunterladen möchten und dies innerhalb Ihrer Methode tun können, ohne den Code für jeden einzelnen Standort individuell anpassen zu müssen, greifen Sie nicht statisch auf die Methode zu ::

MyClass boston = new MyClassConstructor(); 
boston.myMethod("bostonURL");

MyClass miami = new MyClassConstructor(); 
miami.myMethod("miamiURL");

MyClass losAngeles = new MyClassConstructor();
losAngeles.myMethod("losAngelesURL");

Im obigen Beispiel erstellt Java drei separate Objekte und Speicherorte mit derselben Methode, auf die Sie mit der Referenz "boston", "miami" oder "losAngeles" einzeln zugreifen können. Sie können statisch nicht auf die oben genannten Elemente zugreifen, da MyClass.myMethod (); ist ein generischer Verweis auf die Methode, nicht auf die einzelnen Objekte, die der nicht statische Verweis erstellt hat.

Wenn Sie in eine Situation geraten, in der die Art und Weise, wie Sie auf jeden Ort zugreifen oder wie die Daten zurückgegeben werden, so unterschiedlich ist, dass Sie keine "Einheitsgröße" -Methode schreiben können, ohne durch viele Rahmen zu springen, können Sie dies besser Erreichen Sie Ihr Ziel, indem Sie drei separate statische Methoden schreiben, eine für jeden Standort.

Allgemein

statisch : Es muss kein Objekt erstellt werden, mit dem wir direkt aufrufen können

ClassName.methodname()

Nicht statisch : Wir müssen ein Objekt wie erstellen

ClassName obj=new ClassName()
obj.methodname();

Eine statische Methode gehört zur Klasse und eine nicht statische Methode gehört zu einem Objekt einer Klasse. Das heißt, eine nicht statische Methode kann nur für ein Objekt einer Klasse aufgerufen werden, zu der es gehört. Eine statische Methode kann jedoch sowohl für die Klasse als auch für ein Objekt der Klasse aufgerufen werden. Eine statische Methode kann nur auf statische Elemente zugreifen. Eine nicht statische Methode kann sowohl auf statische als auch auf nicht statische Elemente zugreifen, da zum Zeitpunkt des Aufrufs der statischen Methode die Klasse möglicherweise nicht instanziiert wird (wenn sie für die Klasse selbst aufgerufen wird). Im anderen Fall kann eine nicht statische Methode nur aufgerufen werden, wenn die Klasse bereits instanziiert wurde. Eine statische Methode wird von allen Instanzen der Klasse gemeinsam genutzt. Dies sind einige der grundlegenden Unterschiede. Ich möchte auch auf einen oft ignorierten Unterschied in diesem Zusammenhang hinweisen. Immer wenn eine Methode in C ++ / Java / C # aufgerufen wird, wird ein implizites Argument (die 'this'-Referenz) zusammen mit / ohne die anderen Parameter übergeben. Bei einem statischen Methodenaufruf wird die Referenz 'this' nicht übergeben, da statische Methoden zu einer Klasse gehören und daher nicht die Referenz 'this' haben.

Referenz : Statisch gegen nicht statische Methoden

Technisch gesehen besteht der Unterschied zwischen einer statischen und einer virtuellen Methode in der Art und Weise, wie sie verknüpft sind.

Eine herkömmliche "statische" Methode wie in den meisten Nicht-OO-Sprachen wird zur Kompilierungszeit "statisch" mit ihrer Implementierung verknüpft / verkabelt. Wenn Sie also in Programm A die Methode Y () aufrufen und Ihr Programm A mit der Bibliothek X verknüpfen, die Y () implementiert, ist die Adresse von XY () fest mit A codiert, und Sie können dies nicht ändern.

In OO-Sprachen wie JAVA werden "virtuelle" Methoden zur Laufzeit "spät" aufgelöst, und Sie müssen eine Instanz einer Klasse bereitstellen. Um also in Programm A die virtuelle Methode Y () aufzurufen, müssen Sie eine Instanz bereitstellen, z. B. BY (). Zur Laufzeit hängt die aufgerufene Implementierung jedes Mal, wenn A BY () aufruft, von der verwendeten Instanz ab, sodass BY (), CY () usw. zur Laufzeit möglicherweise unterschiedliche Implementierungen von Y () bereitstellen können.

Warum wirst du das jemals brauchen? Auf diese Weise können Sie Ihren Code von den Abhängigkeiten entkoppeln. Angenommen, Programm A führt "draw ()" aus. Mit einer statischen Sprache ist das alles, aber mit OO führen Sie B.draw () aus, und die tatsächliche Zeichnung hängt vom Typ des Objekts B ab, das sich zur Laufzeit ändern kann, um einen Kreis zu quadrieren usw. Auf diese Weise kann Ihr Code Zeichnen Sie mehrere Dinge, ohne dass Änderungen erforderlich sind, auch wenn nach dem Schreiben des Codes neue B-Typen bereitgestellt werden. Raffiniert -

Eine statische Methode gehört zur Klasse und eine nicht statische Methode gehört zu einem Objekt einer Klasse. Ich gebe ein Beispiel, wie es Unterschiede zwischen den Ausgaben erzeugt.

public class DifferenceBetweenStaticAndNonStatic {

  static int count = 0;
  private int count1 = 0;

  public DifferenceBetweenStaticAndNonStatic(){
    count1 = count1+1;
  }

  public int getCount1() {
    return count1;
  }

  public void setCount1(int count1) {
    this.count1 = count1;
  }

  public static int countStaticPosition() {
    count = count+1; 
    return count;
    /*
     * one can not use non static variables in static method.so if we will
     * return count1 it will give compilation error. return count1;
     */
  }
}

public class StaticNonStaticCheck {

  public static void main(String[] args){
    for(int i=0;i<4;i++) {
      DifferenceBetweenStaticAndNonStatic p =new DifferenceBetweenStaticAndNonStatic();
      System.out.println("static count position is " +DifferenceBetweenStaticAndNonStatic.count);
        System.out.println("static count position is " +p.getCount1());
        System.out.println("static count position is " +DifferenceBetweenStaticAndNonStatic.countStaticPosition());

        System.out.println("next case: ");
        System.out.println(" ");

    }
}

}}

Jetzt wird ::: ausgegeben

static count position is 0
static count position is 1
static count position is 1
next case: 

static count position is 1
static count position is 1
static count position is 2
next case: 

static count position is 2
static count position is 1
static count position is 3
next case:  

Wenn Ihre Methode mit den Eigenschaften des Objekts zusammenhängt, sollten Sie sie als nicht statische Methode definieren. Andernfalls können Sie Ihre Methode als statisch definieren und unabhängig vom Objekt verwenden.

Beispiel für eine statische Methode

class StaticDemo
{

 public static void copyArg(String str1, String str2)
    {
       str2 = str1;
       System.out.println("First String arg is: "+str1);
       System.out.println("Second String arg is: "+str2);
    }
    public static void main(String agrs[])
    {
      //StaticDemo.copyArg("XYZ", "ABC");
      copyArg("XYZ", "ABC");
    }
}

Ausgabe:

First String arg is: XYZ

Second String arg is: XYZ

Wie Sie im obigen Beispiel sehen können, habe ich zum Aufrufen der statischen Methode nicht einmal ein Objekt verwendet. Es kann direkt in einem Programm oder unter Verwendung des Klassennamens aufgerufen werden.

Beispiel für eine nicht statische Methode

class Test
{
    public void display()
    {
       System.out.println("I'm non-static method");
    }
    public static void main(String agrs[])
    {
       Test obj=new Test();
       obj.display();
    }
}

Ausgabe:

I'm non-static method

Eine nicht statische Methode wird immer unter Verwendung des Klassenobjekts aufgerufen, wie im obigen Beispiel gezeigt.

Wichtige Punkte:

So rufen Sie statische Methoden auf: direkt oder unter Verwendung des Klassennamens:

StaticDemo.copyArg(s1, s2);

oder

copyArg(s1, s2);

So rufen Sie eine nicht statische Methode auf: using object of the class:

Test obj = new Test();

Der grundlegende Unterschied besteht darin, dass nicht statische Mitglieder ohne das Schlüsselwort 'static' deklariert werden.

Alle statischen Elemente (sowohl Variablen als auch Methoden) werden mit Hilfe des Klassennamens referenziert. Daher werden die statischen Mitglieder der Klasse auch als Klassenreferenzmitglieder oder Klassenmitglieder bezeichnet.

Um auf die nicht statischen Elemente einer Klasse zugreifen zu können, sollten wir eine Referenzvariable erstellen. Referenzvariable ein Objekt speichern ..

Einfach ausgedrückt, aus Sicht des Benutzers verwendet eine statische Methode entweder überhaupt keine Variablen oder alle verwendeten Variablen sind lokal für die Methode oder sie sind statische Felder. Das Definieren einer Methode als statisch bietet einen leichten Leistungsvorteil.

Ein weiteres Szenario für die statische Methode.

Ja, die statische Methode gehört zur Klasse und nicht zum Objekt. Und wenn Sie nicht möchten, dass jemand das Objekt der Klasse initialisiert, oder wenn Sie nicht mehr als ein Objekt möchten, müssen Sie den privaten Konstruktor und damit die statische Methode verwenden.

Hier haben wir einen privaten Konstruktor und erstellen mit einer statischen Methode ein Objekt.

Ex::

public class Demo {

        private static Demo obj = null;         
        private Demo() {
        }

        public static Demo createObj() {

            if(obj == null) {
               obj = new Demo();
            }
            return obj;
        }
}

Demo obj1 = Demo.createObj ();

Hier ist jeweils nur eine Instanz aktiv.

- First we must know that the diff bet static and non static methods 
is differ from static and non static variables : 

- this code explain static method - non static method and what is the diff 

    public class MyClass {
        static {
            System.out.println("this is static routine ... ");

        }
          public static void foo(){
            System.out.println("this is static method ");
        }

        public void blabla(){

         System.out.println("this is non static method ");
        }

        public static void main(String[] args) {

           /* ***************************************************************************  
            * 1- in static method you can implement the method inside its class like :  *       
            * you don't have to make an object of this class to implement this method   *      
            * MyClass.foo();          // this is correct                                *     
            * MyClass.blabla();       // this is not correct because any non static     *
            * method you must make an object from the class to access it like this :    *            
            * MyClass m = new MyClass();                                                *     
            * m.blabla();                                                               *    
            * ***************************************************************************/

            // access static method without make an object 
            MyClass.foo();

            MyClass m = new MyClass();
            // access non static method via make object 
            m.blabla();
            /* 
              access static method make a warning but the code run ok 
               because you don't have to make an object from MyClass 
               you can easily call it MyClass.foo(); 
            */
            m.foo();
        }    
    }
    /* output of the code */
    /*
    this is static routine ... 
    this is static method 
    this is non static method 
    this is static method
    */

 - this code explain static method - non static Variables and what is the diff 


     public class Myclass2 {

                // you can declare static variable here : 
                // or you can write  int callCount = 0; 
                // make the same thing 
                //static int callCount = 0; = int callCount = 0;
                static int callCount = 0;    

                public void method() {
                    /********************************************************************* 
                    Can i declare a static variable inside static member function in Java?
                    - no you can't 
                    static int callCount = 0;  // error                                                   
                    ***********************************************************************/
                /* static variable */
                callCount++;
                System.out.println("Calls in method (1) : " + callCount);
                }

                public void method2() {
                int callCount2 = 0 ; 
                /* non static variable */   
                callCount2++;
                System.out.println("Calls in method (2) : " + callCount2);
                }


            public static void main(String[] args) {
             Myclass2 m = new Myclass2();
             /* method (1) calls */
             m.method(); 
             m.method();
             m.method();
             /* method (2) calls */
             m.method2();
             m.method2();
             m.method2();
            }

        }
        // output 

        // Calls in method (1) : 1
        // Calls in method (1) : 2
        // Calls in method (1) : 3
        // Calls in method (2) : 1
        // Calls in method (2) : 1
        // Calls in method (2) : 1 

Manchmal möchten Sie Variablen haben, die allen Objekten gemeinsam sind. Dies wird mit dem statischen Modifikator erreicht.

dh Klasse Mensch - Anzahl der Köpfe (1) ist statisch, für alle Menschen gleich, jedoch ist die menschliche Haarfarbe für jeden Menschen variabel.

Beachten Sie, dass statische Variablen auch verwendet werden können, um Informationen über alle Instanzen hinweg auszutauschen