double vs Double as Floating Point Numbers in Eclipse

My question is two-part.

1. Why does the following work fine in Eclipse? Isn't "Double" a class?

    Double h = 2.5;
    double j = 2;

2. Why does "Double" above give me an error when I don't assign a decimal value to it, but "double" is fine whether or not I assign a decimal value to it?

As was already mentioned, the term is autoboxing. The object wrappers for the primitive types will automatically convert.

As to your second part,

Double a = 2;

Doesn't work since 2 is not a double and the auto boxing only works between the same types. In this case 2 is an int.

But if you cast it.

Double a = (double)2;

works just fine.

double a = 2;

works because an int can be automatically converted to a double. But going the
other way doesn't work.

int a = 2.2; // not permitted.

Check out the Section on conversions. In the Java Language Specification. Warning that it can sometimes be difficult to read.

Amended Answer.

In java you can cast up or down or have narrowing or widening casts (going from a 32 bit to 16 bit) value is narrowing. But I tend to think about it is losing vs not losing something. In most cases if you have the potential to lose part of value in assignment, you need to cast, otherwise you don't (See exceptions at end). Here are some examples.

long a = 2; // 2 is an integer but going to a long doesn't `lose` precision.
int b = 2L; // here, 2 is a long and the assignment is not permitted.  Even 
            // though a long 2 will fit inside an int, the cast is still 
            // required.
int b = (int)2L;  // Fine, but clearly a contrived case

Same for floating point.

float a = 2.2f; // fine
double b = a;   // no problem, not precision lost
float c = b;    // can't do it, as it requires a cast.

double c = 2.2f; // a float to a double, again a not problem.
float d = 2.2;  // 2.2 is a double by default so requires a cast or the float designator.
float d = (float)2.2;

Exceptions

No cast is required when converting from int to float or long to double. However, precision can still be lost since the floats only have 24 bits of precision and doubles only have 53 bits of precision.

To see this for ints you can run the following:

		for (int i = Integer.MAX_VALUE; i > Integer.MAX_VALUE-100; i--) {
		    float s = i;
		    int t = (int)s; // normal cast required
		    if (i != t) {
		    	System.out.println (i + " " + t);
		    }
		}

Double is a wrapper class, creating a new Double casts a primitive variable of the SAME type into a Object. For Double h = 2, you are wrapping a int into a Double. Since wrapping only works between same types, if you want your Double variable be 2, then you should use

Double h = 2.0;