Is there any static language in which a class is an object?

There are quite a few dynamically typed object oriented languages in which a class itself is an object. Smalltalk, and Python for example. Is there any statically typed language in which a class is an object?

EDIT:

By the term "object", I mean a first class entity. For example, classes in Python can be passed to other methods, can be re开发者_如何学运维turned from methods etc.

In a lot of statically typed languages, like JAVA, a class is an object with its own methods. For example, in Java, the object that represents the "String" class is accessible as "String.class" and then you can invoke methods on this class as "String.class.getFields()", "getMethods()", getConstructor()", "cast(obj)", etc. You can see in the API documentation all the methods of the "Class" class.

Nevertheless, given that the language is statically typed, you cannot dynamically modify a class.

In other words, you are not going to find a method called "class.addField()" in the Class class. The more you can do is "extend" the class (if it is not final) by inheritance.

In yet other words, the a "Class" object is read-only.

By the term "object", I mean a first class entity. For example, classes in Python can be passed to other methods, can be returned from methods etc.

As any other object, you can pass them to methods and return them from methods (they are just regular objects, but that expose only "read" methods). Example (I omit generics for clearness):

public Class myMethod(Class someClassObject) {
    System.out.println(someClassObject.getCanonicalName());
    Class anotherClass = String.class;
    return anotherClass ;
}

I don't fully agree with @edutesoy answer.

First-class means that an implicit constructs is reified as an explicit construct that can be passed around like any object. Classes in Java are not "first-class", they are mirrors where you can inspect some properties but are not the the object itself.

That you can not change the structure of the class at run-time is fine, e.g. add fields, change method body or signature, and that under this perspective it's partly "read-only" is ok.

But let's consider static fields. I guess everybody agrees that unless final static fields are mutable, just like instance fields. In Smalltalk, these are just fields defined on the class itself, rather than on instances of the class. Also, in Smalltalk, class-side methods are polymorphic just like any other method, and :

aClass field: aValue. 

might resolve differently depending on the class that is passed. This is not possible in Java ; a static field or method must be referenced via its type. This also means that it does not allow overriding static methods (read the link for more details) as would be the case if they were truely first class.

The fact that reflection is possible in Java doesn't make classes "first-class"--you can only pass a representation of the class around. And to come back to the original question: I don't know of any statically typed language with first-class classes (but my knowledge is limited, maybe one exists).

EDIT

Actually, now I remember it exists StrongTalk (http://www.strongtalk.org/) which is Smalltalk with static typing. The typing issues are discussed in this paper: Strongtalk: Typechecking Smalltalk in a Production Environment

From Oleg Kiselyov and Ralph Lammel's "Haskell's overlooked object system" (emphasis mine),

Not only OOHaskell provides the conventional OO idioms; we have also language-engineered several features that are either bleeding-edge or unattainable in mainstream OO languages: for example, first-class classes and class closures; statically type-checked collection classes with bounded polymorphism of implicit collection arguments; multiple inheritance with user-controlled sharing; safe co-variant argument subtyping.

Well, the benefits of that are reduced in an early-bound language. However, Java reflection objects for classes would basically be what you are asking for.

Why, incidentally, do you want this? Is it more than idle curiousity?

Take a look at the concept of homoiconicity which refers to the extant that a language can refer to its own structures. Also take a look at this post by Eric Lippert.