O que é um método estático?: 
Um método estático é um método que pertence a uma classe, mas não pertence a uma instância dessa classe e esse método pode ser chamado sem a instância ou objeto dessa classe. 
O que é um método não estático?: 
Todo método em java é padronizado para um método não estático sem a palavra-chave static precedendo-o. Não-estáticos métodos podem aceder a qualquer estático método e estática variável, sem a criação de uma instância do objecto.
Abaixo estão as várias diferenças importantes entre eles: 
 

1. Acessando membros e métodos: 
   • No método estático , o método só pode acessar membros de dados estáticos e métodos estáticos de outra classe ou mesma classe, mas não pode acessar métodos e variáveis ​​não estáticos. Além disso, um método estático pode reescrever os valores de qualquer membro de dados estáticos. 
      
   • No método não estático , o método pode acessar membros de dados estáticos e métodos estáticos, bem como membros e métodos não estáticos de outra classe ou mesma classe, também pode alterar os valores de qualquer membro de dados estáticos. 
      
2. Processo de chamada: 
   • No método estático , a memória de um método estático é fixada na memória RAM, por isso não precisamos do objeto de uma classe na qual o método estático está definido para chamar o método estático. Para chamar o método, precisamos escrever o nome do método seguido pelo nome da classe. 
      

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

// calling
GFG.geek();

// Java program to call a static method
 
class GFG {
 
    // static method
    public static int sum(int a, int b)
    {
        return a + b;
    }
}
 
class Main {
    public static void main(String[] args)
    {
        int n = 3, m = 6;
 
        // call the static method
        int s = GFG.sum(n, m);
 
        System.out.print("sum is = " + s);
    }
}

• Saída: 
   

sum is = 9

•  
• No método não estático , a memória do método não estático não é fixada na memória ram, portanto, precisamos do objeto de classe para chamar um método não estático. Para chamar o método, precisamos escrever o nome do método seguido pelo nome do objeto da classe. 
   

class GFG{
 public void geek()
 { }
}

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

g.geek();

// calling

// Java program to call a non-static method
 
class GFG {
 
    // non-static method
    public int sum(int a, int b)
    {
        return a + b;
    }
}
 
class Main {
    public static void main(String[] args)
    {
        int n = 3, m = 6;
        GFG g = new GFG();
        int s = g.sum(n, m);
        // call the non-static method
 
        System.out.print("sum is = " + s);
    }
}

• Saída: 
   

sum is = 9

1. Processo de ligação: 
   • No método estático , o método usa tempo de compilação ou vinculação inicial. Por esta razão, podemos acessar o método estático sem criar uma instância.
   • No método não estático , o método usa tempo de execução ou vinculação dinâmica. Para que não possamos acessar um método não estático sem criar uma instância. 
      
2. Substituindo: 
   • No método estático , não podemos substituir um método estático, por causa da vinculação inicial. 
     Exemplo: 
      

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

• Saída: 
   

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

•  
• No método não estático , podemos substituir um método não estático. Porque para substituição, precisamos de polimorfismo em tempo de execução, o que acontece apenas na ligação em tempo de execução. 
  Exemplo: 
   

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

• Erro: 
   

Parent
Child

1. Alocação de memória: 
   • No método estático , a alocação de memória acontece apenas uma vez, porque a palavra-chave static fixou uma memória particular para aquele método na ram. Portanto, quando o método é chamado todas as vezes em um programa, cada vez que uma determinada memória é usada. Por esse motivo, menos memória é alocada.
      
   • No método não estático , aqui a alocação de memória acontece quando o método é invocado e a memória é alocada toda vez que o método é chamado. Muita memória é usada aqui.
      

Tabela de diferenças: