char c1 = '\u0041';
char c2 = 0x0041;
char c3 = 65;
char c4 = 0101; // octal

yield the same value for the c's when printed out ('A'). You just can't cast your char to anything of lesser or equal bitwidth.

So byte b = 1; //is OK
But byte b = 1000; // is NOT OK because the range of value a byte primitive can have is from -128 to +127 (i.e 2^7 to (2^7)-1
The same rule applies for all other primitives also.
regds
maha anna

byte  a = 127;         // narrowing OK
char  b = 65535;       // narrowing OK
short c = 32767;       // narrowing OK
int   d = 2147483647;  // OK
float e = 1.0;         // narrowing not OK
float e = (float) 1.0; // narrowing OK
float e = 1.0F;        // OK
double f = 1.0;        // OK

For integral types, you don't have to "cast down" the literal int into a smaller type such as byte, short, char so:

byte b = 2; // ok although 2 is an int
char c = 2; // ok although 2 is an int
short s = 2; // ok although 2 is an int
int i = 2; // ok
long l = 2; // this is okay although expected compiler to complain
long l2 = 2L; // this is the normal way

float f = 2.0; // BAD compiler barfs: "Explicit cast needed to convert double to float"
float f = 2.0f; // correct
double d = 2.0; // ok

If a cast is need to "narrow" for floating point variables why isn't it needed for integral types? (2nd "anomaly")

byte b1 = 2, b2 = 3, b3 = 3;
b3 = b1 + b2; // compiler barfs: "Incompatible type for =. Explicit cast needed to convert int to byte."
b3 = (byte)( b1 + b2 ); // this works

Where did the int come from? Arithmetic promotion--all operands to binary operators are promoted to int automatically if they are not int, float or double. So why use byte or short? (3rd "anomaly")

So...
1. The "yardstick" types are different bitwidths for integral types and floating point types (int & double) // not a big deal
2. Integral literal assignments do not follow casting/conversion rules but floating point literal assignments do.
3. Arithmetic promotion GUARANTEES that you have to cast back down to the smaller type if you use binary operands on anything smaller than an int even if they are all of the same type.

And this language was "designed" from scratch?

char c = 1; // is okay as we've all seen however...
System.out.println( "The char c is: " + c ); // does NOT print out "The char c is: 1"

Unicode \u0001 is the control character "soh". To get a '1' to print out you have to put 49 (\u0031) into c.

the out put is the "char c is "

how come..?

plz clarify

The 'toString()' method of Character class will return the String representation of the character it contains.
regds
maha anna