Diferencia entre el método estático y no estático en Java

Un método estático es un método que pertenece a una clase, pero no pertenece a una instancia de esa clase y este método puede llamarse sin la instancia u objeto de esa clase. Cada método en Java tiene por defecto un método no estático sin una palabra clave estática que lo preceda. Los métodos no estáticos pueden acceder a cualquier método estático y variable estática , sin crear una instancia del objeto. Aclaremos las diferencias. A continuación se muestran las diversas diferencias importantes entre estos indicadores de la siguiente manera:

1. Acceso a miembros y métodos
2. proceso de llamada
3. Proceso de encuadernación
4. Proceso de anulación
5. Asignación de memoria

#1: Acceso a miembros y métodos

Un método estático solo puede acceder a miembros de datos estáticos y métodos estáticos de otra clase o de la misma clase, pero no puede acceder a métodos y variables no estáticos. Además, un método estático puede reescribir los valores de cualquier miembro de datos estáticos.

Un método no estático puede acceder a miembros de datos estáticos y métodos estáticos, así como a miembros y métodos no estáticos de otra clase o de la misma clase, también puede cambiar los valores de cualquier miembro de datos estáticos

Ejemplo

// Java program to Illustrate Calling of a Static Method
 
// Class 1
// Helper class
class Helper {
 
    // Static method
    public static int sum(int a, int b)
    {
        // Simply returning the sum
        return a + b;
    }
}
 
// Class 2
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Custom values for integer
        // to be summed up
        int n = 3, m = 6;
 
        // Calling the static method of above class
        // and storing sum in integer variable
        int s = Helper.sum(n, m);
 
        // Print and display the sum
        System.out.print("sum is = " + s);
    }
}

sum is = 9

Ejemplo 

// Java program to Illustrate Calling of a Non-Static Method
 
// Class 1
// Helper class
class Helper {
 
    // Non-static method
    public int sum(int a, int b)
    {
        // Returning sum of numbers
        return a + b;
    }
}
 
// Class 2
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Input integers to be summed up
        int n = 3, m = 6;
 
        // Creating object of above class
        Helper g = new Helper();
 
        // Calling above method to compute sum
        int s = g.sum(n, m);
 
        // Calling the non-static method
        System.out.print("sum is = " + s);
    }
}

sum is = 9

#2: proceso de llamada 

La memoria de un método estático está fija en la ram, por esta razón, no necesitamos el objeto de una clase en la que se define el método estático para llamar al método estático. Para llamar al método necesitamos escribir el nombre de la clase seguido del nombre del método

Sintaxis: Llamada de métodos estáticos

class GFG{
 public static void geek()
 { }
}

// calling
GFG.geek();

La memoria del método no estático no está fijada en la RAM, por lo que necesitamos un objeto de clase para llamar a un método no estático. Para llamar al método necesitamos escribir el nombre del método seguido del nombre del objeto de la clase

Sintaxis: Llamada de métodos no estáticos

class GFG{
 public void geek()
 { }
}

// creating object
GFG g = new GFG();

g.geek();

// calling

#3: Proceso de encuadernación 

En el método estático , el método utiliza el tiempo de compilación o el enlace anticipado. Por esta razón, podemos acceder al método estático sin crear una instancia. En un método no estático , el método utiliza tiempo de ejecución o vinculación dinámica. Para que no podamos acceder a un método no estático sin crear una instancia. 

#4: Anular 

En el método estático , no podemos anular un método estático debido al enlace anticipado. 

Ejemplo:

// Override of static method
class Parent {
 
    // static method
    static void show()
    {
        System.out.println("Parent");
    }
}
 
// Parent inherit in Child class
class Child extends Parent {
 
    // override show() of Parent
    void show()
    {
        System.out.println("Child");
    }
}
 
class GFG {
    public static void main(String[] args)
    {
        Parent p = new Parent();
        // calling Parent's show()
        p.show();
        // cannot override Parent's show()
    }
}

Producción: 

java:15: error: show() in Child cannot override show() in Parent
    void show()
         ^
  overridden method is static

En el método no estático , podemos anular un método no estático. Porque para anular necesitamos el polimorfismo en tiempo de ejecución, que ocurre solo en el enlace en tiempo de ejecución. 

Ejemplo:

// Override of non-static method
 
class Parent {
    void show()
    {
        System.out.println("Parent");
    }
}
 
// Parent inherit in Child class
class Child extends Parent {
 
    // override show() of Parent
    void show()
    {
        System.out.println("Child");
    }
}
 
class GFG {
    public static void main(String[] args)
    {
        Parent p = new Parent();
        // calling Parent's show()
        p.show();
 
        Parent c = new Child();
        // calling Child's show()
        c.show();
    }
}

Salida: Error

Parent
Child

#5: Asignación de memoria 

En el método estático , la asignación de memoria ocurre solo una vez, porque la palabra clave estática fijó una memoria particular para ese método en RAM. Entonces, cuando se llama al método cada vez en un programa, cada vez que se usa esa memoria en particular. Por ese motivo, se asigna menos memoria.

En el método no estático , aquí la asignación de memoria ocurre cuando se invoca el método y la memoria se asigna cada vez que se llama al método. Aquí se usa mucha memoria. Ahora, por último, la tabla de trazado para comprender por completo