ArcGIS Engine Developer Guide

JAVA APPLICATION PROGRAMMING INTERFACE
IFeature feature = featureClass.getFeature(i);
IGeometry geom = feature.getShape();
if (geom.getGeometryType() == esriGeometryType.esriGeometryPolygon){
/* Note: "Polygon p = (Polygon) geom;" will give ClassCastException */
Polygon poly = new Polygon(geom);
doSomeProcessingOnPolygon(poly);
}
The polygon object poly thus constructed will implement all interfaces implemented
by the Polygon class. Consequently, you can call methods belonging to any
of the implemented interfaces on the poly object.
You could write all your code using the object constructors alone, but there are
times when it might be better to cast an object implementing a particular interface,
not to a class type, but to another interface implemented by that object.
Continuing the previous example, suppose you want to use the
doSomeProcessingOnPolygon(Polygon p) method not only on Polygon objects but on
other objects implementing IArea, such as Envelope and Ring. You could write a
generic doSomeProcessingOnArea(IArea area) method that works on all objects
implementing IArea. As Polygon, Envelope, and Ring objects all implement the IArea
interface, you could pass in those objects to this generic method, thereby preventing
the need to write additional methods for each object type, such as
doSomeProcessingOnEnvelope(Envelope env) and doSomeProcessingOnRing(Ring ring). To
accomplish this, you would need to cast from the IGeometry type to the IArea
type. In Java, this is typically done using interface cross-casting.
/* Incorrect usage: will give ClassCastException */
IArea area = (IArea) geom ;
However, for the same reason noted in the class cast above, such a cast would fail
with a ClassCastException. To be able to cast to the ArcObjects interface, you will
need to use the interface proxy classes discussed earlier in this section. In the
ArcGIS API for Java, you achieve the equivalent of an interface cross-casting by
using the InterfaceProxy of the interface being casted to.
IArea area = new IAreaProxy(geom);
The following code shows the use of an InterfaceProxy class to cross-cast the geom
object to IArea:
IFeature feature = featureClass.getFeature(i);
IGeometry geom = feature.getShape();
/* Note: "IArea area = (IArea) geom;" will give ClassCastException */
IArea area = new IAreaProxy(geom);
doSomeProcessingOnArea(area);
Using the IAreaProxy class as shown in the code above allows you to access the
object through its IArea interface so that it can then be passed to a method that
takes an argument of type IArea. Thus, in this particular example, one method
can deal with three different object types. However, only methods belonging to
the IArea interface will be valid for the area object. To call other methods of the
object, you will need to either class-cast to the appropriate object type using its
object constructor or get a reference to the other interfaces using the
InterfaceProxy classes.
190 • ArcGIS Engine Developer Guide