class Point { int x, y; }
class ColoredPoint extends Point { int color; }
Class Test {
	public static void main(String[] args) {
		ColoredPoint[] cpa = new ColoredPoint[10];
		Point[] pa = cpa;
		pa[0] = new Point();
	}
}

But for arrays, all elements must be of the same/assignable to the class type of the array. It is the rule. So here all elements of array cpa must be ColoredPoint/one of its subclasses if there is any.Simillarly an array of Point can have only 'Point' objects/any of its subclasses as its elements. When you assign an element of an object array, here also the regular conversion/casting rules apply.

Having said that, when we try to assign one of the element of 'pa' array (which is actually a ref to an array of ColouredPoint , NOT Point) to an object of class type 'Point', an ArrayStoreException will occur. Because the physical original array which was created first , is of type 'Colored Point' NOT Point. For regular object casting/conversion can we assign a var of type 'ColoredPoint' to an object of type Point ? ( ColoredPoint cp = new Point() ) No. This is the reason why this RuntimeException is thrown.

If it would have been like the foll. code then it is ok. Because a subclass object can be auto-converted to a var of type of its superclass without any problem.

     Point[] pa = new Point[10];
     pa[0] = new ColoredPoint();

Also note that for primitive arrays the rules are slightly different. An int[] can be converted to only another int[] array. No auto-conversion. (i.e) an int[] can't be assigned to a long[] array. I think you know these things well. .
regds
maha anna

Anna i totally got it now.

I read this follwing statement in JLS. It's regarding arrays. It says "There is no permitted conversion from any array type to any class type other than Object or String".

I thought from array type to class Object is the only permitted conversion.

String s;
Object o;
int arr[] = new int[10];
s = arr; // is this legal??
o = arr; // this is o.k.

5.1.4 Widening Reference Conversions
------------------------------------
The following conversions are called the widening reference conversions:
- From any array type to type Object.

5.1.5 Narrowing Reference Conversions
-------------------------------------
The following conversions are called the narrowing reference conversions:
- From type Object to any array type.

5.1.7 Forbidden Conversions
------------------------------
- There is no permitted conversion from class type S to any array type if S
is not Object.
- There is no permitted conversion from any array type to any class type other than Object or String.

An array can be assigned only to a variable of a compatible array type, or to a variable of type Object.

quote:

---

5.1.6 String Conversions

There is a string conversion to type String from every other type, including the null type.

---

This is in addition to the widening and narrowing reference conversions listed in 4.1.4 and 4.1.5, and it explains the exception given in 4.1.7. Note that string conversion is not included under assignment conversion, so it's never done implicitly as the result of an = operator. It's only done here:

quote:

---

5.4 String Conversion

String conversion applies only to the operands of the binary + operator when one of the arguments is a String. In this single special case, the other argument to the + is converted to a String, and a new String which is the concatenation of the two strings is the result of the +. String conversion is specified in detail within the description of the string concatenation + operator (§15.17.1).

---