Why can static methods only use static data?

Lets explain it with a hypothetical sample.

Imagine a simple class:

class User
{
User(string n) { name = n; };
string name;
}

Now we create 2 instances of this class:

User Bones = new User("Bones");
User Jim = new User("Jim");

now, think - what if we add a new static method to User, eg:

static string GetName();

and you call it:

string x = User::GetName()

what would x contain? "Jim", "Bones", or something else?

The problem is that a static method is a single method, defined on the class, not the objects. As a result, you don't know which object it might apply to. This is why its a special thing. Its best to think of static methods as individual things, like functions in C for example. That languages like Java have them contained inside classes is mainly a problem with Java not allowing anything to exist outside a class, so functions like this have to be forced inside a class in some manner (a bit like how main() is forced to be inside a class too when all sense says it should be a singular, standalone function).

Non-static data is associated to an instance of the class. Static methods (and data) are not associated to a particular instance of the class. There does not need to be an instance of a class to use static methods on it. Even if there were instance(s), there would be no way for Java to guarantee that you are operating on the instance you are expecting when you call a static method. Therefore, static methods cannot have access to non-static data.

It can use field data; consider the following java code:

class MyBean {
    private String myString;

    static void myStaticMethod() {
        myString = "tada";/*not allowed; if this was possible how would 
                           be different from a field without static?*/

        MyBean myBean = new MyBean();//allowed if associated with an instance
        myBean.myString = "tada";
    }
}

Think of it as static methods living in a non-object-oriented dimension.

In the "object oriented dimension" a class can spawn multiples egos (instances), each ego has conscience of itself via its state.

In the flat, non-OO-dimension a class is oblivious of their egos living in the OO-dimension. Their world is flat and procedural, almost as if OOP had not been invented yet, and as if the class was a small procedural program, and the static data were just global variables.

I think the easiest way to explain this is to look at some code and then consider what results we would expect the code to produce.

// Create three new cars.  Cars have a name attribute.  
Car car1 = new Car("Mazda3");
Car car2 = new Car("FordFocus");
Car car3 = new Car("HondaFit");

// Now we would like to print the names of some cars: 
// First off why don't we try this: 

Car.printCarName();

// Expected behaviour: 
// If we think about what we are trying to do here it doesn't
// really make sense.  What instance of car name should this 
// print?  Should it print Mazda3?  FordFoucs?
// What is the expected behaviour?  If we are going to have a
// static call on car call printCarName it should probably do
// something like print all car names or a random car name or
// throw an error.  


//Now lets try this instead: 

Car.printCarName(car1);

// Expected Behaviour: 
// Luckily the expected behaviour is very clear here.  This
// should print Mazda3.  This works as expected.  


// Finally lets try this: 

car1.printMyName();

// Expected Behaviour:
// Same as previous example, however this is the *right* way
// to do it.  

For completeness here is the car class:

public class Car{

    public String name;

    public Car(String name){
        this.name = name;
    }

    public static printCarName(){
        print "Not sure what to do here...  Don't know which car you are talking about.";
    }

    public static printCarName(Car c){
        print c.name;
    }

    public /*NOT static*/ printMyName(){
        print this.name;
    }

}

The other answers pretty much say it all, however, there is some "detail" I'd like to add.

Static methods (say those in Java) just don't have an implicit object associated to them (accessible through this) whose members you can access usually directly by name.

That doesn't mean they cannot access non-static data.

class MyClass {
  public static void foo(MyOtherClass object) {
    System.out.println(object.member);
  }
}

class MyOtherClass {
  public int member = 10;
}

I know this is just a detail, but I found your question strange when I read it. "Can use only static data" is too much restrictive.

By the way, I didn't test the code, I just wrote it here in order to exemplify what I was saying.

I think the issue here is one of understanding.

From a technical standpoint a static method called from within an object would be quite capable of seeing the instance fields. I strongly suspect this is what caused the question in the first place.

The issue is that methods can be called from outside the object. At that point there's no instance data to provide them--and thus no way for the compiler to resolve the code. Since allowing instance data caused a contradiction we must not allow instance data.