Perché i metodi statici non possono chiamare direttamente metodi non statici? [duplicare]

Perché un campo / metodo statico - per definizione - non è legato a nessun singolo oggetto / istanza della classe, mentre un campo / metodo non statico si riferisce sempre a un oggetto / istanza reale in qualche modo.

Dato che probabilmente è stato troppo vago / astratto per rispondere alla domanda, e questo tipo di confusione deriva solitamente da un fraintendimento di ciò che in realtà significa statico, facciamo questo concreto con uno pseudocodice simile a C ++:

class Foo {
public:
    static int a() { return 2; }
    int b()        { return d_x; }
    Foo(int x)     { d_x = x; }
private:
    int d_x;
}

Il metodo statico a non è legato a nessuna particolare istanza di Foo , il che significa che può essere richiamato da qualsiasi posizione, indipendentemente dal fatto che tu abbia o meno un oggetto Foo effettivo. In C ++ devi semplicemente scrivere Foo::a() , e restituirebbe sempre 2.

Il metodo non statico b è legato a una singola istanza di Foo . Poiché restituisce semplicemente l'int all'interno di un determinato oggetto Foo , non ha senso provare a chiamare b() senza un oggetto Foo specifico. Cosa ti aspetti che ritorni se non avesse un Foo ? Quindi Foo f; f.b(); ha senso ma Foo::b() no.

Se provassi a effettuare una chiamata a () b (), ogni volta che chiamavo a () senza un'istanza effettiva di Foo , chiamerei anche b () senza un'istanza effettiva di Foo , quindi anche a () non ha senso.

In sostanza, i due metodi sono implementati in questo modo:

namespace Foo {
    int a() {
        return 2;
    }
    int b(Foo* this) {
        return this->x;
    }
};

Quando osservi i metodi in questo modo, è abbastanza ovvio perché b () può chiamare a () ma non viceversa: a () semplicemente non ha una Foo* in giro per dare a b ( ).

Per inciso, puoi "aggirare" questa limitazione scrivendo un metodo statico che prende un oggetto Foo effettivo e quindi chiama metodi non statici su quell'oggetto Foo . Ma di solito è un odore di codice che indica che hai metodi statici che non dovrebbero essere un metodo statico o non statico che dovrebbe essere statico, o una classe che sta cercando di fare troppe cose contemporaneamente.

In qualche modo Tongue-in-cheek ... O almeno questa è la prospettiva funzionale sui metodi ...

Non esiste una cosa chiamata "metodo"

class Apple
{
 ...
public void Eat()
{
    this.weight --;
}
public static Apple ChangeColor(Apple apple)
{
    apple.color = Color.GetRandomColor();
}
} 

L'esempio sopra definisce una classe con due metodi uno statico e uno no. Il secondo è in realtà una funzione che riceve un singolo parametro del tipo Apple e cambia il suo colore. La prima è anche una funzione che implicitamente riceve un parametro chiamato this e ne diminuisce il peso.

Questa è fondamentalmente l'idea alla base di una 'funzione membro' / 'metodo membro'. Riceve un primo parametro implicito del tipo della classe.

così facendo: Apple.Eat() non ha senso, ci sono troppi pochi parametri (Apple è il nome della classe qui).

mentre fa questo:

Apple x = new Apple();
x.eat()

Anche il "primo parametro implicito" di "metodi membro" nei linguaggi OOP ha una caratteristica speciale. Se un metodo membro è virtuale (specifico per lingua), il metodo sarà richiamato dinamicamente in base al tipo di quel parametro.

Dispatch dinamico o invocazione dinamica, è qualcosa di simile a overload di metodi - che sta decidendo quale metodo chiamare in base a compilazione tipo di tempo, eccetto che accade in runtime .

Alcuni linguaggi di programmazione consentono di farlo su tutti i parametri di una funzione - questo è chiamato Invio multiplo

Sebbene la maggior parte dei linguaggi OOP consenta questo solo per il 'primo parametro implicito' di 'metodi membro' - questo è chiamato metodi virtuali, Polymorphism e single dispatch .

A proposito ... C'è un intero modello di design chiamato Visitor esclusivamente per consentire una sorta di dispacciamento multiplo a lingue che non hanno la funzione

Perché tutte le cose statiche non sono correlate a nessun oggetto, ma sono correlate a una classe. Quindi tutti gli oggetti della stessa classe accederanno allo stesso metodo statico.

D'altra parte, i metodi non statici sono collegati a un particolare oggetto di una classe.

È possibile chiamare metodi statici senza creare alcun oggetto di una classe, ma non è il caso con metodi non statici.