Develop Reference

Where is .class defined in Java? (Is it a variable or what?)

There are 2 ways to get a class's Class object.
Statically:
Class cls = Object.class;
From an instance:
Object ob = new Object();
Class cls = ob.getClass();
Now my question is getClass() is a method present in the Object class,
but what is .class? Is it a variable? If so then where is it defined in Java?

That's implemented internally and called a class literal which is handled by the JVM.
The Java Language Specification specifically mentions the term "token" for it.
So .class is more than a variable, to be frank it is not a variable at all. At a broader level you can consider it as a keyword or token.
https://docs.oracle.com/javase/specs/jls/se9/html/jls-15.html#jls-15.8.2
A class literal is an expression consisting of the name of a class, interface, array, or primitive type, or the pseudo-type void, followed by a '.' and the token class.
A class literal evaluates to the Class object for the named type (or for void) as defined by the defining class loader (§12.2) of the class of the current instance.

That information resides in the class 'file', although classes need not have a physical .class file in the file system. The JVM takes care of making it available from the class definition, as the other answer states.
See also:
https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html

How exactly are class literals evaluated inside static methods?

From the JLS (§15.8.2):
A class literal evaluates to the Class object for the named type (or for void) as defined by the defining class loader (§12.2) of the class of the current instance.
This makes sense, but what if there is no 'current instance'? (i.e. the expression is in a class method, aka 'static method')
My intuition tells me to use the same rule, swapping out 'class of the current instance' for something like 'class of the class method'. However, I cannot find any such rule in the JLS, which in my experience tends to be very explicit. This makes me uncertain about my intuition.
The alternative is that my assumption that there is no 'current instance' when in a class method, is incorrect. If so - what are the rules for determining the 'current instance' when in a class method?

Class of the current instance indicates the instance of java.lang.Class whose type is T. Even if the class in consideration has static method, It is always an instance of java.lang.Class.
You can get related explanation in Java Documentation for java.lang.Class:
Instances of the class Class represent classes and interfaces in a running Java application. An enum is a kind of class and an annotation is a kind of interface. Every array also belongs to a class that is reflected as a Class object that is shared by all arrays with the same element type and number of dimensions. The primitive Java types (boolean, byte, char, short, int, long, float, and double), and the keyword void are also represented as Class objects.
Class has no public constructor. Instead Class objects are constructed automatically by the Java Virtual Machine as classes are loaded and by calls to the defineClass method in the class loader.
The following example uses a Class object to print the class name of an object:
void printClassName(Object obj) {
System.out.println("The class of " + obj +
" is " + obj.getClass().getName());
}
It is also possible to get the Class object for a named type (or for void) using a class literal. See Section 15.8.2 of The Java™ Language Specification. For example:
System.out.println("The name of class Foo is: "+Foo.class.getName());

I believe "instance" in this case refers to the instance of the class itself, i.e., the class definition, and not an object instance of that class. This is difficult to articulate, so let's consider an example:
class A {}
class B {
Class<A> a = A.class;
}
Here, the expression A.class executes within a class B. However, it is possible that class B might be loaded into the runtime more than once using different class loaders. So, when the documentation says, "as defined by the defining class loader (§12.2) of the class of the current instance", I believe it is referring to whichever class loader loaded the copy ("instance") of the B class that is currently executing.
In short, the Class<A> instance assigned to a will be loaded from the same class loader that loaded B.
In practice, this isn't the sort of thing you're likely to have to have to worry about. Most Java developers don't have to deal with multiple class loaders in their day-to-day work.

The class literal can never appear alone, it must always be qualified by either a class name or a primitive type name. class should be used when you need to access a class object statically. someObject.getClass() should be used when you need to access an objects class at runtime.
Thus:
public class Foo {
public static String getMyFooClassNameStatic_good() {
return Foo.class.getName(); // ok
}
public static String getBarClassName() {
// the Bar class will be looked up in the same class loader as
// the one that the the Foo CLASS instance was loaded from that
// is executing this method. So if there are multiple versions
// of Bar floating around, the one you will get is the one that
// was loaded from the same class loader as the loaded Foo. That's
// what the language about "current instance" in the spec is
// getting at.
return Bar.class.getName();
}
public static String getMyFooClassNameStatic_bad() {
return class.getName(); // syntax error -
// use one of:
// Foo.class.getName()
// (new Foo()).getClass().getName()
// Class.forName("Foo").getName()
}
public static String getIntClassName() {
return int.class.getName(); // ok
}
}

Query on instance of Class class

Every object in Java belongs to a certain class. That's why the Object class, which is inherited by all other classes, defines the getClass().
getClass() method returns the instance of Class class.
For example:
class Foo{}
class Sample{ class Foo instance = Foo(); Class obj = instance.getClass(); }
Another way of getting the instance of Class class is by saying Foo.class
My question:
I can see the definition of getClass() in Object class source code(File Object.java package java.lang). In which source file, can i see the member class which we are using as Foo.class?

No source file. class is a keyword (like this, instanceof, etc), not a member of any class, and is handled by the compiler, not in code.

If an instance of an object is available, then the simplest way to get its Class is to invoke Object.getClass()
Foo foo=new Foo();
Class c = foo.getClass();
If the type is available but there is no instance then it is possible to obtain a Class by appending .class to the name of the type. This is also the easiest way to obtain the Class for a primitive type.
boolean b;
Class c = boolean.class;
and this would produce compile-time error
Class c = b.getClass();
because a boolean is a primitive type and cannot be dereferenced
And for something like this
Foo foo=null;
note that you cannot use foo.getClass() in this case since it is not instantiated.
And finally for something like this
Foo foo=new FooChild();
Class c= foo.getClass(); //returns FooChild, evaluates at runtime
Class c= Foo.class;// returns Foo , evaluates statistically at compile-time.
Edit:- For .class its a static field inside every primitive type, static Class<Integer> ,The Class instance representing the Integer. you can see it here for Integer , here for Boolean. boolean, byte, char, short, int, long, float, and double all of them have a Class static field because like i said its always going to stay same and primitive types cannot be cannot be dereferenced. To see the source, if you see source of Integer you can see the class field as public static final Class<Integer> TYPE = (Class<Integer>) VMClassLoader.getPrimitiveClass('I'); , see here line 82. You can search and see for others too.

Declare variable of a type (literal) stored in a collection

Is it possible to declare variable of a type (literal) stored in a collection?
Or that might be more of a feature/task for an interpreted, not a compiled language like Java?
For example:
import java.util.*;
class Base {}
class A1 extends Base{}
class A2 extends Base{}
public class Test{
public static void main(String[] args){
ArrayList<Class<? extends Base>> typeArrayList=new ArrayList<Class<? extends Base>>();
typeArrayList.add(A1.class);
typeArrayList.add(A2.class);
typeArrayList.add(A1.class);
typeArrayList.add(A1.class);
//etc. etc.
//now that all the types are nicely stored in a collection,
//could we somehow use them to declare variables of those types?
//e.g. declare something like:
//typeArrayList.get(1) someVariable;
}//main
}//Testlass

You can use:
Object o = typeVarArrayList.get(1).newInstance();
or
Type o = (Type) typeVarArrayList.get(1).newInstance();
But you need that the class have one constructor without parameters.
If you need a more specific constructor, please see here

You can use newInstance() if there is a default constructor available, if not then you will need to have people supply you with factory objects and then call a method in the factory to build your objects.
The Factory pattern is generally neater too for most implementations unless the objects being created really are just plain beans with nothing but default values as the factory allows you to properly set up the object.

//e.g. declare something like:
//typeArrayList.get(1) someVariable;
In short, no, type declarations must be explicit.
For example, the Java language defines these rules for local variable declarations:
LocalVariableDeclaration:
VariableModifiersopt Type VariableDeclarators
Type:
PrimitiveType
ReferenceType
ReferenceType:
ClassOrInterfaceType
TypeVariable
ArrayType
Drilling down to TypeVariable (because I'm not copying the entire language grammar) we get:
TypeVariable:
Identifier
An identifier is restricted to the things you'd expect in a class name.

A method for obtaining an object of type Class

In my textbook I can read:
If T is any Java type, then T.class is the matching class object. For example:
Class cl1 = Date.class; // if you import java.util.*;
Class cl2 = int.class;
Class cl3 = Double[].class;
Later on I'm reading:
The virtual machine manages a unique Class object for each type. Therefore, you can use the == operator to compare class objects. For example:
if (e.getClass() == Employee.class)
Could you help me find anything about this .class field in the documentation.
And another qutstion - I can't understand whether the e.getClass() == Employee.class is the same as e.class == Employee.class. I mean, if it is the same, why the author of the textbook used getClass here in the lefthand expression.

From JLS §15.8.2 - Class Literals:
A class literal is an expression consisting of the name of a class, interface, array, or primitive type, or the pseudo-type void, followed by a '.' and the token class.
The type of C.class, where C is the name of a class, interface, or array type (§4.3), is Class.
So, Date.class, int.class are nothing but class literals, which give appropriate Class objects for a class type.
I can't understand whether the e.getClass() == Employee.class is the same as e.class == Employee.class
No, they are not the same. In fact, e.class won't even compile. As per the definition of class literal above, since e is not a type but an object of Employee (I assume that), e.class is not a valid class literal. To get the Class object of a class, using it's instance, you need to use Object#getClass() method.
So, e.getClass() and Employee.class are two different ways to obtain the Class object for Employee class. Both to be used in different circumstances. When you know the class type, use 2nd version, and when you have an instance of your class, use the 1st version.
However, note that in case of inheritance, e.getClass() might not return the same Class object as Employee.class. The former would return the Class object of the actual subclass object, referred by the reference e, whereas the later would always give you Class<Employee>.
If you neither have the instance, nor the class type available, then you can also get the Class object for a class name in String form, using - Class#forName(String) method.

How you get a Class object depends on what you already know. If you have an object referenced by x, you can obtain the Class object for its class by x.getClass(). If you know, when you are writing your code, the name of a type T, you can use T.class to get the class object. There is a third approach, less convenient, that only requires run time access to the class name.
The getClass method is described as one of the Object methods, in the Object API documentation.
Class literals, the T.class form, are described in the Java Language Specification.
The third approach uses one of the static forName methods defined the API documentation for java.lang.Class.