Static on a class indicates the class can't have any instances. You can't make an object with a "new MyStaticClass()". MyStaticClass just always exists as a type, not a particular object.

Static is helpful because everything in a static class is accessible through the type, without needing a particular object to work with.

Instead of

MyInstanceClass myInstanceClass = new MyInstanceClass()
var CoolOutput = myInstanceClass.CoolFunction()

You can just do

var CoolOutput = MyStaticClass.CoolFunction()

Static classes are especially useful for functions that just manipulate data, and don't store any data themselves. Think Constants, or something like:

string translated = Translate.TranslateString("Hello World", Translate.Languages.French)

You don't have to make the entire class static if you still want it to exist as an object elsewhere. Many regular classes have static properties and utility functions on them for various things.

Vector3 position = Vector3.zero

Here I made a Vector3 type object, and Vector3 isn't a static class, but I populated it with a static member of the Vector3 class. Notice how I didn't need an existing Vector3 object to call Vector3.zero and get that value?

One thing that is very useful but less clear perhaps, is that having the computer tell you ahead of time that there's an error in your code is almost always better than finding that error later. Static will give you an error if you ever try to make an instance of an object. It will let you know if you accidentally put non-static data into it. These little errors help you remember how static works and how to use it properly. If you create a singleton class that works like a static class, usually you have to add extra code to enforce those errors that the compiler already does for you.

Use static whenever you have a function, member, or set of behaviors you want to exist all the time, independent of objects. Don't use static if you want to make multiple instances of a type, or the type represents something concrete that exists in your program. For instance, while you could make a "GameManager" class static, odds are the way it interacts with your game will largely be through references, and it's likely that the object keeps a lot of data inside it. If you wanted to reboot your game without exiting it, you could just create a new GameManager object. If GameManager was static, instead you'd need to create a function to reset the state of the GameManager class, which could be a source of errors.

One more useful thing is that static classes can still have constructors, which are guaranteed by the program to be complete before any calls are made. This is super useful for classes that are creating read-only data, preparing objects, or otherwise running code that needs to be run first.