A generic java question

Hi, I am trying generic java downloaded from
http://developer.java.sun.com/developer/earlyAccess/adding_generics/
it works fine with "Test.java", an example included in the package, but it gives "cannot resolve symbol" error message when the source code contains something like "packagename.classname" in the type. For example:
List<network.Node> nodeList = new ArrayList<network.Node>();
it'll complain: cannot resolve symbol Node.
The reason to put a package name before the class name is because there are classes in different packages with the same name.
Any help with this problem would be appreciated.

This is proably a dumb question, but are you using the fully qualified package name. If not, you must.
Chuck

Similar Messages

What do people think about the different Generic Java approaches?

I have seen a lot of different approaches for Generic Java, and when people find problems with each approach the normal response has been: the other approach is worse with such and such a problem, do you have a better way?
The different approaches I have seen are: (in no particular order)
Please correct me if I am wrong and add other approaches if they are worthy of mention.
1) PolyJ - by MIT
This is a completely different approach than the others, that introduces a new where clause for bounding the types, and involves changing java byte codes in order to meet it's goals.
Main comments were not a java way of doing things and far too greater risk making such big changes.
2) Pizza - by Odersky & Wadler
This aims at extending java in more ways than just adding Generics. The generic part of this was replaced by GJ, but with Pizza's ability to use primitives as generic types removed, and much bigger changes allowing GJ to interface with java.
Main comments were that Pizza doesn't work well with java, and many things in Pizza were done in parallel with java, hence were no longer applicable.
3) GJ - by Bracha, Odersky, Stoutamire & Wadler
This creates classes with erased types and bridging methods, and inserts casts when required when going back to normal java code.
Main comments are that type dependent operations such as new, instanceof, casting etc can't be done with parametric types, also it is not a very intuitive approach and it is difficult to work out what code should do.
4) Runtime Generic Information - by Natali & Viroli
Each instance holds information about its Runtime Type.
Main comments from people were that this consumes way too much memory as each instance holds extra information about its type, and the performance would be bad due to checking Type information at runtime that would have been known at compile.
5) NextGen - by Cartwright & Steele
For each parameterized class an abstract base class with types erased is made and then for each new type a lightweight wrapper class and interface are created re-using code from the base class to keep the code small.
Main comments from people were that this approach isn't as backwards compatible as GJ due to replacing the legacy classes with abstract base classes which can't be instantiated.
6) .NET common runtime - by Kennedy & Syme
This was written for adding Generics to C#, however the spec is also targeted at other languages such as VB.
Main comments from people were that this approach isn't java, hence it is not subject to the restrictions of changing the JVM like java is.
7) Fully Generated Generic Classes - by Agesen, Freund & Mitchell
For each new type a new class is generated by a custom class loader, with all the code duplicated for each different type.
Main comments from people were that the generated code size gets too big, and that it is lacking a base class for integration with legacy code.
8) JSR-14 - by Sun
This is meant to come up with a solution Generic Solution to be used in java. Currently it is heavily based on GJ and suffering from all the same problems as GJ, along with the fact that it is constantly undergoing change and so no one knows what to expect.
See this forum for comments about it.
As if we didn't have enough approaches already, here is yet another one that hopefully has all of the benefits, and none of the problems of the other approaches. It uses information learnt while experimenting with the other approaches. Now when people ask me if I think I have a better approach, I will have somewhere to point them to.
(I will be happy to answer questions concerning this approach).
9) Approach #x - by Phillips
At compile time 1 type is made per generic type with the same name.
e.g.class HashSet<TypeA> extends AbstractSet<TypeA> implements Cloneable, Serializable will be translated to a type: class HashSet extends AbstractSet implements Cloneable, SerializableAn instance of the class using Object as TypeA can now be created in 2 different ways.
e.g.Set a = new HashSet();
Set<Object> b = new HashSet<Object>();
//a.getClass().equals(b.getClass()) is trueThis means that legacy class files don't even need to be re-compiled in order to work with the new classes. This approach is completely backwards compatible.
Inside each type that was created from a generic type there is also some synthetic information.
Information about each of the bounding types is stored in a synthetic field.
Note that each bounding type may be bounded by a class and any number of interfaces, hence a ';' is used to separate bounding types. If there is no class Object is implied.
e.g.class MyClass<TypeA extends Button implements Comparable, Runnable; TypeB> will be translated to a type: class MyClass {
public static final Class[][] $GENERIC_DESCRIPTOR = {{Button.class, Comparable.class, Runnable.class}, {Object.class}};This information is used by a Custom Class Loader before generating a new class in order to ensure that the generic types are bounded correctly. It also gets used to establish if this class can be returned instead of a generated class (occurs when the generic types are the same as the bounding types, like for new HashSet<Object> above).
There is another synthetic field of type byte[] that stores bytes in order for the Custom Class Loader to generate the new Type.
There are also static methods corresponding to each method that contain the implementation for each method. These methods take parameters as required to gain access to fields, contructors, other methods, the calling object, the calling object class etc. Fields are passed to get and set values in the calling object. Constructors are passed to create new instances of the calling object. Other methods are passed when super methods are called from within the class. The calling object is almost always passed for non static methods, in order to do things with it. The class is passed when things like instanceof the generated type need to be done.
Also in this class are any non private methods that were there before, using the Base Bounded Types, in order that the class can be used exactly as it was before Generics.
Notes: the time consuming reflection stuff is only done once per class (not per instance) and stored in static fields. The other reflection stuff getting done is very quick in JDK1.4.1 (some earlier JDKs the same can not be said).
Also these static methods can call each other in many circumstances (for example when the method getting called is private, final or static).
As well as the ClassLoader and other classes required by it there is a Reflection class. This class is used to do things that are known to be safe (assuming the compiler generated the classes correctly) without throwing any exceptions.
Here is a cut down version of the Reflection class: public final class Reflection {
public static final Field getDeclaredField(Class aClass, String aName) {
    try {
      Field field = aClass.getDeclaredField(aName);
      field.setAccessible(true);
      return field;
    catch (Exception ex) {
      throw new Error(ex);
public static final Object get(Field aField, Object anObject) {
    try {
      return aField.get(anObject);
    catch (Exception ex) {
      throw new Error(ex);
public static final void set(Field aField, Object anObject, Object aValue) {
    try {
      aField.set(anObject, aValue);
    catch (Exception ex) {
      throw new Error(ex);
public static final int getInt(Field aField, Object anObject) {
    try {
      return aField.getInt(anObject);
    catch (Exception ex) {
      throw new Error(ex);
public static final void setInt(Field aField, Object anObject, int aValue) {
    try {
      aField.setInt(anObject, aValue);
    catch (Exception ex) {
      throw new Error(ex);
}Last but not least, at Runtime one very lightweight wrapper class per type is created as required by the custom class loader. Basically the class loader uses the Generic Bytes as the template replacing the erased types with the new types. This can be even faster than loading a normal class file from disk, and creating it.
Each of these classes has any non private methods that were there before, making calls to the generating class to perform their work. The reason they don't have any real code themselves is because that would lead to code bloat, however for very small methods they can keep their code inside their wrapper without effecting functionality.
My final example assumes the following class name mangling convention:
* A<component type> - Array
* b - byte
* c - char
* C<class name length><class name> - Class
* d - double
* f - float
* i - int
* l - long
* z - boolean
Final Example: (very cut down version of Vector)public class Vector<TypeA> extends AbstractList<TypeA> implements RandomAccess, Cloneable, Serializable {
protected Object[] elementData;
protected int elementCount;
protected int capacityIncrement;
public Vector<TypeA>(int anInitialCapacity, int aCapacityIncrement) {
    if (anInitialCapacity < 0) {
      throw new IllegalArgumentException("Illegal Capacity: " + anInitialCapacity);
    elementData = new Object[initialCapacity];
    capacityIncrement = capacityIncrement;
public synchronized void setElementAt(TypeA anObject, int anIndex) {
    if (anIndex >= elementCount) {
      throw new ArrayIndexOutOfBoundsException(anIndex + " >= " + elementCount);
    elementData[anIndex] = anObject;
}would get translated as:public class Vector extends AbstractList implements RandomAccess, Cloneable, Serializable {
public static final Class[][] $GENERIC_DESCRIPTOR = {{Object.class}};
public static final byte[] $GENERIC_BYTES = {/*Generic Bytes Go Here*/};
protected Object[] elementData;
protected int elementCount;
protected int capacityIncrement;
private static final Field $0 = Reflection.getDeclaredField(Vector.class, "elementData"),
                             $1 = Reflection.getDeclaredField(Vector.class, "elementCount"),
                             $2 = Reflection.getDeclaredField(Vector.class, "capacityIncrement");
static void $3(int _0, Field _1, Object _2, Field _3, int _4) {
    if (_0 < 0) {
      throw new IllegalArgumentException("Illegal Capacity: " + _0);
    Reflection.set(_1, _2, new Object[_0]);
    Reflection.setInt(_3, _2, _4);
static void $4(int _0, Field _1, Object _2, Field _3, Object _4) {
    if (_0 >= Reflection.getInt(_1, _2)) {
      throw new ArrayIndexOutOfBoundsException(_0 + " >= " + Reflection.getInt(_1, _2));
    ((Object[])Reflection.get(_3, _2))[_0] = _4;
public Vector(int anInitialCapacity, int aCapacityIncrement) {
    $3(anInitialCapacity, $0, this, $2, aCapacityIncrement);
public synchronized void setElementAt(Object anObject, int anIndex) {
    $4(anIndex, $1, this, $0, anObject);
} and new Vector<String> would get generated as:public class Vector$$C16java_lang_String extends AbstractList$$C16java_lang_String implements RandomAccess, Cloneable, Serializable {
protected Object[] elementData;
protected int elementCount;
protected int capacityIncrement;
private static final Field $0 = Reflection.getDeclaredField(Vector$$C16java_lang_String.class, "elementData"),
                             $1 = Reflection.getDeclaredField(Vector$$C16java_lang_String.class, "elementCount"),
                             $2 = Reflection.getDeclaredField(Vector$$C16java_lang_String.class, "capacityIncrement");
public Vector$$C16java_lang_String(int anInitialCapacity, int aCapacityIncrement) {
    Vector.$3(anInitialCapacity, $0, this, $2, aCapacityIncrement);
public synchronized void setElementAt(String anObject, int anIndex) {
    Vector.$4(anIndex, $1, this, $0, anObject);
}Comparisons with other approaches:
Compared with PolyJ this is a very java way of doing things, and further more it requires no changes to the JVM or the byte codes.
Compared with Pizza this works very well with java and has been designed using the latest java technologies.
Compared with GJ all type dependent operations can be done, and it is very intuitive, code does exactly the same thing it would have done if it was written by hand.
Compared with Runtime Generic Information no extra information is stored in each instance and hence no extra runtime checks need to get done.
Compared with NextGen this approach is completely backwards compatible. NextGen looks like it was trying to achieve the same goals, but aside from non backwards compatibility also suffered from the fact that Vector<String> didn't extend AbstractList<String> causing other minor problems. Also this approach doesn't create 2 types per new types like NextGen does (although this wasn't a big deal anyway). All that said NextGen was in my opinion a much better approach than GJ and most of the others.
Compared to .NET common runtime this is java and doesn't require changes to the JVM.
Compared to Fully Generated Generic Classes the classes generated by this approach are very lightweight wrappers, not full blown classes and also it does have a base class making integration with legacy code simple. It should be noted that the functionality of the Fully Generated Generic Classes is the same as this approach, that can't be said for the other approaches.
Compared with JSR-14, this approach doesn't suffer from GJ's problems, also it should be clear what to expect from this approach. Hopefully JSR-14 can be changed before it is too late.

(a) How you intend generic methods to be translated.
Given that Vector and Vector<Object> are unrelated types,
what would that type be represented as in the byte code of
the method? In my approach Vector and Vector<Object> are related types. In fact the byte code signature of the existing method is exactly the same as it was in the legacy code using Vector.
To re-emphasize what I had said when explaining my approach:
System.out.println(Vector.class == Vector<Object>.class); // displays true
System.out.println(Vector.class == Vector<String>.class); // displays false
Vector vector1 = new Vector<Object>(); // legal
Vector<Object> vector2 = new Vector(); // legal
// Vector vector3 = new Vector<String>(); // illegal
// Vector<String> vector4 = new Vector(); // illegal
Vector<String> vector5 = new Vector<String>(); // legal
You must also handle the case where the type
parameter is itself a parameterized type in which the type
parameter is not statically bound to a ground instantiation.This is also very straightforward: (let me know if I have misunderstood you)
(translation of Vector given in my initial description)
public class SampleClass<TypeA> {
public static void main(String[] args) {
    System.out.println(new Vector<Vector<TypeA>>(10, 10));
}would get translated as:public class SampleClass {
public static final Class[][] $GENERIC_DESCRIPTOR = {{Object.class}};
public static final byte[] $GENERIC_BYTES = {/*Generic Bytes Go Here*/};
private static final Constructor $0 = Reflection.getDeclaredConstructor(Vector$$C16java_util_Vector.class, new Class[] {int.class, int.class});
static void $1(Constructor _0, int _1, int _2) {
    try {
      System.out.println(Reflection.newInstance(_0, new Object[] {new Integer(_1), new Integer(_2)}));
    catch (Exception ex) {
      throw (RuntimeException)ex;
public static void main(String[] args) {
    $1($0, 10, 10);
}and SampleClass<String> would get generated as:public class SampleClass$$C16java_lang_String {
private static final Constructor $0 = Reflection.getConstructor(Vector$$C37java_util_Vector$$C16java_lang_String.class, new Class[] {int.class, int.class});
public static void main(String[] args) {
    SampleClass.$1($0, 10, 10);
Also describe the implementation strategy for when these
methods are public or protected (i.e. virtual).As I said in my initial description that for non final, non static, non private method invocations a Method may be passed into the implementing synthetic method as a parameter.
Note: the following main method will display 'in B'.
class A {
public void foo() {
    System.out.println("in A");
class B extends A {
public void foo() {
    System.out.println("in B");
public class QuickTest {
public static void main(String[] args) {
    try {
      A.class.getMethod("foo", null).invoke(new B(), null);
    catch (Exception ex) {}
}This is very important as foo() may be overwritten by a subclass as it is here. By passing a Method to the synthetic implementation this guarantees that covariance, invariance and contra variance all work exactly the same way as in java. This is a fundamental problem with many other approaches.
(b) The runtime overhead associated with your translationAs we don't have a working solution to compare this to, performance comments are hard to state, but I hope this helps anyway.
The Class Load time is affected in 4 ways. i) All the Generic Bytes exist in the Base Class, hence they don't need to be read from storage. ii) The custom class loader, time to parse the name and failed finds before it finally gets to define the class. iii) The generation of the generic bytes to parametric bytes (basically involves changing bytes from the Constant Pool worked out from a new Parametric type, Utf8, Class and the new Parametric Constant types may all be effected) iv) time to do the static Reflection stuff (this is the main source of the overhead). Basically this 1 time per class overhead is nothing to be concerned with, and Sun could always optimize this part further.
The normal Runtime overhead (once Classes have been loaded) is affected mainly by reflection: On older JDKs the reflection was a lot slower, and so might have made a noticeable impact. On newer JDKs (since 1.4 I think), the reflection performance has been significantly improved. All the time consuming reflection is done once per class (stored in static fields). The normal reflection is very quick (almost identical to what is getting done without reflection). As the wrappers simply include a single method call to another method, these can be in-lined and hence made irrelevant. Furthermore it is not too difficult to make a parameter that would include small methods in the wrapper classes, as this does not affect functionality in the slightest, however in my testing I have found this to be unnecessary.
(c) The space overhead (per instantiation)There are very small wrapper classes (one per new Type) that simply contain all non private methods, with single method calls to the implementing synthetic method. They also include any fields that were in the original class along with other synthetic fields used to store reflected information, so that the slow reflection only gets done once per new Type.
(d) The per-instance space overheadNone.
(e) Evidence that the proposed translation is sound and well-defined for all relevant cases (see below)Hope this is enough, if not let me know what extra proof you need.
(f) Evidence for backward compatibility
(For example, how does an old class file that passes a Vector
to some method handle the case when the method receives a Vector<T>
where T is a type parameter? In your translation these types are unrelated.)As explained above, in my approach these are only unrelated for T != Object, in the legacy case T == Object, hence legacy code passing in Vector is exactly the same as passing in Vector<Object>.
(g) Evidence for forward compatibility
(How, exactly, do class files that are compiled with a generics compiler run on an old VM)They run exactly the same way, the byte codes from this approach are all legal java, and all legal java is also legal in this approach. In order to take advantage of the Generics the Custom Class Loader would need to be used or else one would get ClassNotFoundExceptons, the same way they would if they tried using Collections on an old VM without the Collections there. The Custom Class Loader even works on older VMs (note it may run somewhat slower on older VMs).
(h) A viable implementation strategyType specific instantiations are at Class Load time, when the Custom Class Loader gets asked for a new Class, it then generates it.
The type specific instantiations are never shipped as they never get persisted. If you really wanted to save them all you need to do is save them with the same name (with the $$ and _'s etc), then the class loader would find them instead of generating them. There is little to be gained by doing this and the only reason I can think of for doing such a thing would be if there was some reason why the target VM couldn't use the Custom Class Loader (the Reflection class would still need to be sent as well, but that is nothing special). Basically they are always generated at Runtime unless a Class with the same name already exists in which case it would be used.
The $GENERIC_DESCRIPTOR and $GENERIC_BYTES from the base class along with the new Type name are all that is required to generate the classes at runtime. However many other approaches can achieve the same thing for the generation, and approaches such as NextGen's template approach may be better. As this generation is only done once per class I didn't put much research into this area. The way it currently works is that the $GENERIC_DESCRIPTOR are basically used to verify that a malicious class files is not trying to create a non Type Safe Type, ie new Sample<Object>() when the class definition said class Sample<TypeA extends Button>. The $GENERIC_BYTES basically correspond to the normal bytes of a wrapper class file, except that in the constant pool it has some constants of a new Parametric Constant type that get replaced at class load time. These parametric constants (along with possibly Utf8 and Class constants) are replaced by the Classes at the end of the new type name, a little more complex than that but you probably get the general idea.
These fine implementation details don't affect the approach so much anyway, as they basically come down to class load time performance. Much of the information in the $GENERIC_BYTES could have been worked out by reflection on the base type, however at least for now simply storing the bytes is a lot easier.
Note: I have made a small syntax change to the requested class:
public T(X datum) --> public T<X>(X datum)
class T<X> {
private X datum;
public T<X>(X datum) {
    this.datum = datum;
public T<T<X>> box() {
    return new T<T<X>>(this);
public String toString() {
    return datum.toString();
public static void main(String[] args) {
    T<String> t = new T<String>("boo!");
    System.out.println(t.box().box());
}would get translated as:
class T {
public static final Class[][] $GENERIC_DESCRIPTOR = {{Object.class}};
public static final byte[] $GENERIC_BYTES = {/*Generic Bytes Go Here*/};
private Object datum;
private static final Field $0 = Reflection.getDeclaredField(T.class, "datum");
private static final Constructor $1 = Reflection.getDeclaredConstructor(T$$C1T.class, new Class[] {T.class});
static void $2(Field _0, Object _1, Object _2) {
    Reflection.set(_0, _1, _2);
static Object $3(Constructor _0, Object _1) {
    try {
      return Reflection.newInstance(_0, new Object[] {_1});
    catch (Exception ex) {
      throw (RuntimeException)ex;
static String $4(Field _0, Object _1) {
    return Reflection.get(_0, _1).toString();
static void $5() {
    T$$C16java_lang_String t = new T$$C16java_lang_String("boo!");
    System.out.println(t.box().box());
public T(Object datum) {
    $2($0, this, datum);
public T$$C1T box() {
    return (T$$C1T)$3($1, this);
public String toString() {
    return $4($0, this);
public static void main(String[] args) {
    $5();
}as the generic bytes aren't very meaningful and by no means a requirement to this approach (NextGen's template method for generation may work just as well), here are the generated classes with some unused code commented out instead:
class T$$C28T$$C22T$$C16java_lang_String {
private T$$C22T$$C16java_lang_String datum;
private static final Field $0 = Reflection.getDeclaredField(T$$C28T$$C22T$$C16java_lang_String.class, "datum");
// private static final Constructor $1 = Reflection.getDeclaredConstructor(T$$C34T$$C28T$$C22T$$C16java_lang_String.class, new Class[] {T$$C28T$$C22T$$C16java_lang_String.class});
public T$$C28T$$C22T$$C16java_lang_String(T$$C22T$$C16java_lang_String datum) {
    T.$2($0, this, datum);
// public T$$C34T$$C28T$$C22T$$C16java_lang_String box() {
//    return (T$$C34T$$C28T$$C22T$$C16java_lang_String)T.$3($1, this);
public String toString() {
    return T.$4($0, this);
public static void main(String[] args) {
    T.$5();
class T$$C22T$$C16java_lang_String {
private T$$C16java_lang_String datum;
private static final Field $0 = Reflection.getDeclaredField(T$$C22T$$C16java_lang_String.class, "datum");
private static final Constructor $1 = Reflection.getDeclaredConstructor(T$$C28T$$C22T$$C16java_lang_String.class, new Class[] {T$$C22T$$C16java_lang_String.class});
public T$$C22T$$C16java_lang_String(T$$C16java_lang_String datum) {
    T.$2($0, this, datum);
public T$$C28T$$C22T$$C16java_lang_String box() {
    return (T$$C28T$$C22T$$C16java_lang_String)T.$3($1, this);
public String toString() {
    return T.$4($0, this);
public static void main(String[] args) {
    T.$5();
class T$$C1T {
private T datum;
private static final Field $0 = Reflection.getDeclaredField(T$$C1T.class, "datum");
// private static final Constructor $1 = Reflection.getDeclaredConstructor(T$$C6T$$C1T.class, new Class[] {T$$C1T.class});
public T$$C1T(T datum) {
    T.$2($0, this, datum);
// public T$$C6T$$C1T box() {
//    return (T$$C6T$$C1T)T.$3($1, this);
public String toString() {
    return T.$4($0, this);
public static void main(String[] args) {
    T.$5();
class T$$C16java_lang_String {
private String datum;
private static final Field $0 = Reflection.getDeclaredField(T$$C16java_lang_String.class, "datum");
private static final Constructor $1 = Reflection.getDeclaredConstructor(T$$C22T$$C16java_lang_String.class, new Class[] {T$$C16java_lang_String.class});
public T$$C16java_lang_String(String datum) {
    T.$2($0, this, datum);
public T$$C22T$$C16java_lang_String box() {
    return (T$$C22T$$C16java_lang_String)T.$3($1, this);
public String toString() {
    return T.$4($0, this);
public static void main(String[] args) {
    T.$5();
}the methods from the Reflection class used in these answers not given in my initial description are:
public static final Object newInstance(Constructor aConstructor, Object[] anArgsArray) throws Exception {
    try {
      return aConstructor.newInstance(anArgsArray);
    catch (InvocationTargetException ex) {
      Throwable cause = ex.getCause();
      if (ex instanceof Exception) {
        throw (Exception)ex;
      throw new Error(ex.getCause());
    catch (Exception ex) {
      throw new Error(ex);
public static final Constructor getDeclaredConstructor(Class aClass, Class[] aParameterTypesArray) {
    try {
      Constructor constructor = aClass.getDeclaredConstructor(aParameterTypesArray);
      constructor.setAccessible(true);
      return constructor;
    catch (Exception ex) {
      throw new Error(ex);
}

Issue about Invoking a BPEL Process with the Generic Java API

I Invoking a BPEL Process with the Generic Java API and apache axis or axis2
it turn up a error as follow:
org.apache.axis2.AxisFault: ORABPEL-08021
Cannot find partner wsdl.
parnterLink "BPELProcess1" is not found in process "BPELProcess1" (revision "v2008_11_17__38943").
Please check the deployment descriptor of the process to find the correct partnerLink name.
     at org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(Utils.java:512)
     at org.apache.axis2.description.OutInAxisOperationClient.handleResponse(OutInAxisOperation.java:370)
     at org.apache.axis2.description.OutInAxisOperationClient.send(OutInAxisOperation.java:416)
     at org.apache.axis2.description.OutInAxisOperationClient.executeImpl(OutInAxisOperation.java:228)
     at org.apache.axis2.client.OperationClient.execute(OperationClient.java:163)
     at org.apache.axis2.client.ServiceClient.sendReceive(ServiceClient.java:548)
     at org.apache.axis2.client.ServiceClient.sendReceive(ServiceClient.java:528)
     at wf.Test_axis2_callws.main(Test_axis2_callws.java:41)
i can't solve it !
what's problem ???
anyone use java code to invoke bpel process successfully..can show me some example?
thanks
chan

Hi,
Check below link may help you solve your problem.
http://www.activevos.com/cec/samples/content/sample-invoke/doc/index.html
Regards

Generic Java for Oracle Data Integrator 10g (10.1.3.5.0)

Hi,
How can I install the Oracle Data Integrator Client in my MacBook. So the generic version should be the right one.
But there are versions for windows, linux, solaris, HPUX and AIX.. but no generic java version.
The version 10.1.3.4.0 has an generic version.
How can I fix this issue, since I tried the linux version but doesn't install.
Thanks.

Hi,
Install the 10.1.3.4 and make an "manual install" after that. It's means copy the oracledi directory over the old oracledi directory.
There is detailed instruction on install manual...
Did you already tried this?
Cezar Santos
[www.odiexperts.com]

Generic Java class for working with Context Nodes

Hi,all
I would like to write generic Java class for working with Context Nodes:
populating node,
add element to node,
update node element,
remove node element
Any ideas how can I do it?

Hi,Armin
Thanks for your answer.
I have many nodes with the same structure,but different data.
I don't want to work with each one of them individually.
This is the main reason.
Regards,
Michael
Any ideas?

Java Question... please help

I am running Snow Leopard (mac os x version 10.6.8)
For the past couple of years I've played gin in yahoo games.
Yesterday when I entered the gin lobby ...the font was so tiny
I wasn't able to read it.   I checked Java on my computer and
it is enabled, however I just realized when I go into the gin
lobby... there is no java icon on the dock.   Since the font size
is fine in all other applications, I am presuming this is a Java
issue.
Help if you are able.. please and thanks

Huh? Is this a Java question? Where's the Java? I just see a little JavaScript. Do you know how to use servlets and JSPs?
Jesper

What kind of Java questions can I ask?

Here's a change:
I want to interview some good java people. I have lots of Java questions in mind which I could ask them, however fellow JavaGuru's
I would like some potential questions from you which I could ask someone who claims he/she is a good java programmer??
I am asking because I want to be as fair as possible to the applicant and not ask them questions which I think are tough etc...

Touchy subject.
The language is not as important, as understanding programming concepts.
So fine, when the programmer's horizont involves some abstraction levels.
If a programmer can write an UML class diagram for a linked list.
If a programmer knows a design pattern Singleton.
If a programmer can write his/her own single linked list class with sorted insertion.
Language concepts:
- Why:
import java.util.*;
Map map = new HashMap();
- Answer:
Hiding the choice of implementation (HashMap) by using the more general
interface Map.
Don't expect much on an interview though. The situation might not be
adequate to distinghuish between the good and the bad apples.
Talking code is a good starting point, code of your making unfortunately.
A good programmer will hesitate to show really useful code.
A bad programmer might have stolen his/her code.
The problem you might have, that you are in search of an expert, not
having the expertise in-house. In that case you might get a better
picture, talking about which IDE would be opportune, whether he/she
has experience with the source version system CVS, what would his/her
ideas be about coming projects.
That would establish a common line of communication.

"Batch" type script - maybe generic UNIX question!

Hey peeps,
We just set up an email filter on Solaris 9, which has 20MB of configuration files that need backing up on a regular basis. What I would like is a short executable script which does the following:
tar -cf the config files into a tar file, named conf-backup-DATE.tar with todays date.
open an ftp connection, with a specified username and password
"put" the tar file on the ftp server
disconnect from the ftp server
I think this is more of a generic UNIX question than a Solaris question, but I don't know any more about UNIX than I do about Solaris anyway!

Your script defines functions which will enable you to invoke the backup. But this script only defines functions. You need to invoke them for your backup to work. The sample invocation can look like this (CODE NOT TESTED!!!):
Setup
Initialize
Gethottblspace
BeginHotbackup
Best Regards
Krystian Zieja / mob

Interesting Java Questions. Need answers Pls

Hi All,
I have come accross few java question, could any one please provide best answers please?
1. Why the wait() method is there in the Object class? Not in the Threads?
2. Why JDBC has all interfaces & not classes?
3. Which type of collection do u prefer to make the incoming objects in sort order?
4. Why the hasCode() method should be implemented if we are overiding the equals(0 method?
Please provide me best answers ASAP.
Girish.K

do u prefer tohttp://www.catb.org/~esr/faqs/smart-questions.html#writewell
How To Ask Questions The Smart Way
Eric Steven Raymond
Rick Moen
Write in clear, grammatical, correctly-spelled language
We've found by experience that people who are careless and sloppy writers are usually also careless and sloppy at thinking and coding (often enough to bet on, anyway). Answering questions for careless and sloppy thinkers is not rewarding; we'd rather spend our time elsewhere.
So expressing your question clearly and well is important. If you can't be bothered to do that, we can't be bothered to pay attention. Spend the extra effort to polish your language. It doesn't have to be stiff or formal - in fact, hacker culture values informal, slangy and humorous language used with precision. But it has to be precise; there has to be some indication that you're thinking and paying attention.
Spell, punctuate, and capitalize correctly. Don't confuse "its" with "it's", "loose" with "lose", or "discrete" with "discreet". Don't TYPE IN ALL CAPS; this is read as shouting and considered rude. (All-smalls is only slightly less annoying, as it's difficult to read. Alan Cox can get away with it, but you can't.)
More generally, if you write like a semi-literate b o o b you will very likely be ignored. So don't use instant-messaging shortcuts. Spelling "you" as "u" makes you look like a semi-literate b o o b to save two entire keystrokes.

JAVA QUESTIONS HELP!!!!!

Hi there im a student and have an exam on java coming up next week, i have a few past paper questions that im stuck with if anyone can help that would be great.....
1.) Java implements generic types by erasure: what does this mean?
A. The compiler removes references to parameter types and inserts casts wherever return types refer to parameter types.
B. The programmer must comment out references to parameter types before code is compiled.
C. The compiler removes any casts that may be type-unsafe. 􀀀
D. The compiler removes any references to parameter types and inserts references to the closest super class that will make expressions type-safe.
E. Any type-unsafe casts to parameter types will be ignored by the interpreter at run-time.
2.) In Remote method Invocation, what is meant by �marshalling�?
A. Marshalling is the process of synchronizing all parameters to the method being invoked, in order to
prevent data corruption arising from the concurrent method call. 􀀀
B. Marshalling is the process of sending a copy of the remote object to the client JVM in order to
invoke its method locally. 􀀀
C. Marshalling is the process of sending the state of the client JVM on a byte stream to the remote
object in order that the JVM can be started as a separate thread on the remote host. 􀀀
D. Marshalling is the process of suspending the current thread in the client JVM until a result is obtained
from the remote method invocation. 􀀀
E. Marshalling is the process of sending the state of all parameter instances on a byte stream to the remote object.
3.)What is the immediate superclass of javax.swing.JFrame?
A. java.lang.Object 􀀀
B. javax.swing.Window 􀀀
C. javax.swing.JComponent 􀀀
D. java.AWT.Window 􀀀
E. java.AWT.Frame
4.) What is the immediate superclass of javax.swing.JComponent?
A. java.lang.Object 􀀀
B. java.AWT.Component 􀀀
C. java.AWT.Container 􀀀
D. java.AWT.Window 􀀀
E. javax.swing.Object
5.) Which of the following statements about the java.AWT and javax.swing packages is true?
A. All components in both packages are thread-safe􀀀
B. Most components in both packages are thread-safe􀀀
C. Most components in java.AWT are thread-safe, but most in javax.swing are not􀀀
D. Most components in javax.swing are thread-safe, but most in java.AWT are not􀀀
E. No components in either package are thread-safe􀀀
6.) Which of the following best describes how AWT events are handled in Java?
A. There is a special thread that handles all AWT events. 􀀀
B. Each AWT event causes a new thread to be created to handle that event. 􀀀
C. All AWT events are handled in the main thread. 􀀀
D. The programmer must explicitly create one thread to handle all AWT events. 􀀀
E. For each AWT event, the programmer must explicitly create a thread to handle that event. 􀀀
7.) Which of the following best describes how component-generated events can be handled in Java?
A. All component-generated events are handled automatically by the Java interpreter. 􀀀
B. The programmer creates instances of appropriate listener classes, and registers these instances with
the component; when the component generates an event, the relevant methods of all registered
listeners are executed. 􀀀
C. The programmer creates instances of appropriate listener classes, and registers these instances with
the component; when the component generates an event, one of the registered listeners is chosen by
the interpreter and the relevant method of that instance is executed. 􀀀
D. The programmer must declare a subclass of the component and add one method for each type of
event the component can generate; when the component generates an event, the appropriate method
is executed. 􀀀
E. Each component class has event-handling methods; the programmer declares a subclass of the
component and overrides those methods; when the component generates an event, the overridden
method is executed. 􀀀
Any help would b great thanks guys. Andy

1.) Java implements generic types by erasure: what
does this mean?
A. The compiler removes references to parameter types
and inserts casts wherever return types refer to
parameter types.
B. The programmer must comment out references to
parameter types before code is compiled.
C. The compiler removes any casts that may be
type-unsafe. 􀀀
D. The compiler removes any references to parameter
types and inserts references to the closest super
class that will make expressions type-safe.
E. Any type-unsafe casts to parameter types will be
ignored by the interpreter at run-time.None of the above (assuming this is not a Google translation of some non-English text).
2.) In Remote method Invocation, what is meant by
�marshalling�?
A. Marshalling is the process of synchronizing all
parameters to the method being invoked, in order to
prevent data corruption arising from the concurrent
method call. 􀀀
B. Marshalling is the process of sending a copy of
the remote object to the client JVM in order to
invoke its method locally. 􀀀
C. Marshalling is the process of sending the state of
the client JVM on a byte stream to the remote
object in order that the JVM can be started as a
separate thread on the remote host. 􀀀
D. Marshalling is the process of suspending the
current thread in the client JVM until a result is
obtained
from the remote method invocation. 􀀀
E. Marshalling is the process of sending the state of
all parameter instances on a byte stream to the
remote object.None of the above. Although there is one answer that at least describes how Marshalling is used.
3.)What is the immediate superclass of
javax.swing.JFrame?
A. java.lang.Object 􀀀
B. javax.swing.Window 􀀀
C. javax.swing.JComponent 􀀀
D. java.AWT.Window 􀀀
E. java.AWT.FrameAt least this one does have the correct answer. It's in the API docs, so I guess it'd be hard to be wrong.
4.) What is the immediate superclass ofDitto.
5.) Which of the following statements about the
java.AWT and javax.swing packages is true?
A. All components in both packages are
thread-safe􀀀
B. Most components in both packages are
thread-safe􀀀
C. Most components in java.AWT are thread-safe, but
most in javax.swing are not􀀀
D. Most components in javax.swing are thread-safe,
but most in java.AWT are not􀀀
E. No components in either package are
thread-safe􀀀Again, none of the above.
6.) Which of the following best describes how AWT
events are handled in Java?
A. There is a special thread that handles all AWT
events. 􀀀
B. Each AWT event causes a new thread to be created
to handle that event. 􀀀
C. All AWT events are handled in the main thread.
􀀀
D. The programmer must explicitly create one thread
to handle all AWT events. 􀀀
E. For each AWT event, the programmer must explicitly
create a thread to handle that event. 􀀀One answer is almost, sort of, correct. Wow.
I can understand why you're having problems answering these questiosn. Well, there's no excuse for the questions that come out fo the Javadocs, but for the others ... it explains a lot about the quality of recent graduates.

Generics parameter question

I'm trying to create a binary tree that implements Map, or extends AbstractMap.package binarytree;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
public abstract class MapTest<K, D> implements Map<K, D> {
     public Set<Entry<K, D>> entrySet() {
          // TODO Auto-generated method stub
          return null;
     public void putAll(Map<? extends K, ? extends D> m) {
          Set<Entry<? extends K, ? extends D>> s = m.entrySet();
          // Error on the above line.
                //Type mismatch: cannot convert from Set<Map.Entry<capture#1-of ? extends K,capture#2-of ? extends D>> to Set<Map.Entry<? extends K,? extends D>>
}I'm using Eclipse. It wants me to change the line to :
Set<?> s = m.entrySet();I don't understand. EntrySet() is supposed to return Set<Entry<K, D>>, where K, D are the type parameters of the Map. The type of my Map parameter, m, is Map<? extends K, ? extends D>. Shouldn't m.entrySet() return Set<Entry<? extends K, ? extends D>>?
Why is does Eclipse want me to define the return value as a Set<?>?

Let me try an answer. First of all, generics in Java are not covariant, meaning that even though Integer is a subtype of Number, List<Integer> is not a subtype of List<Number>.
While someone using putAll could pass a Map<Apple,Pears> one day, here and now the compiler assigns the artificial type names capture#1 and capture#2. While these are subtypes of K and D respectively, Entry<capture#1,capture#2> is not a subtype of Entry<K,D> according to the rule above. Consequently the assignment between the two is illegal. Wrapping Set around it makes it even worse.
One mistake made easily goes as follows: Set<A extends Wine> is a set that in the future someone will use to store all kinds of Wine derivatives. THIS IS WRONG! The set will be used to store all kinds of A derivatives.
Consequently, Entry<capture#1,capture#2> will, in the future be some very specific type. And this type is certainly not compatible with Entry<K,D>. This is why the closest possible variable definition proposed by Eclipse is Set<?>.
A lot of in depth information about this stuff is provided by [Angelika Langer|http://www.angelikalanger.com/GenericsFAQ/FAQSections/TechnicalDetails.html]. While trying to answer your question, I also put together this.
Harald.
Edited by: pifpafpuf on Dec 6, 2008 7:05 PM
Edited by: pifpafpuf on Dec 6, 2008 7:07 PM

Field.get(Object obj) now returning null with Generics (Java 5.0) ??

Hello,
I'm currently using Java 5.0 (especially for the Generics part) on a new Java/J2EE project, but having a strange issue with code working previously in a Java 1.4 project.
Below is an overriding of the toString() method provided by the Object class which allow me to view nicely in debug (dev. mode) the contents of my Transfer Objects (all the TO's must extend this ATO abstract class).
Previously this code displayed me something like:
[field1 => value1, field2 => value2] ... for a TO (sort of "Javabean") having e.g. two String fields with values initialized to "value1" (resp. "value2").
But unfortunately, this does (or seems) not to work anymore, having such display :
[field1 => null, field2 => null]I tried to debug, and the problem is that the call fieldValue = field.get(this); returns null while it should returns the actual value of the field.
I thing it it strongly related to Generics, but could not at the moment found how/why it does not work.
May someone help...? Thanks.
public abstract class ATO {
    // Reflection for field value display
    public String toString() {
        StringBuffer sb = new StringBuffer("[");
        MessageFormat mf = new MessageFormat("{0} => {1}, ");
        Field[] fields = this.getClass().getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            Field field = (Field) fields;
String fieldName = field.getName();
Object fieldValue = null;
try {
fieldValue = field.get(this);
} catch (IllegalArgumentException e) {
} catch (IllegalAccessException e) {
mf.format(new Object[] { fieldName, fieldValue }, sb, null);
if (sb.length() > 1) {
sb.setLength(sb.length() - 2);
sb.append("]");
return sb.toString();

ejp wrote:
Field field = (Field) fields;
This cast is unnecessary.
Effectively, I haven't noticed it yet. Fixed.
} catch (IllegalArgumentException e) {
} catch (IllegalAccessException e) {
}Either the field value really is null or you are getting one of these exceptions which you are ignoring. Never write empty catch blocks.That's true, I missed something. Fixed with some code to log the eventual exceptions.
Thanks for you answer.

Simple basic java question

public static void main(String[] args)
..anyone know the statement as above could be start at begining , so what is the (String[ ] args) mean in java ?
in my ideas of this statement is
publc : indicates the statemean can be used as all class , this is open for public use
static mean the main method can used as class method
void indicate that the statement return nothing
main indicate any class should be run this first.
so my question what is the function of (String [ ] args) ? // one string array call args ?

String[] args is indeed an array of Strings called args. The reason it's there is to collect any arguments passed to your code when you start it.
eg. if you have a class called TestClass and you called it from the command line like this:
java TestClass exam tomorrow oh shite
.......then the args array would hold the four Strings:
exam
tomorrow
oh
shite

Forte for Java question

By using the JDBC form wizard, I generated a swing program. Along with the java code, there is a form file which looks like an xml file. My question is how to complie and run the java source code without a forte4j IDE?
Thanks

One thing is you need the jdbc in your classpath or specify at runtime. Search compiler in the forte help menu - to see options.
execution : <specify at runtime>
java -classpath:.;postgresql.org Program
-- above for postgresql driver residing in same directory as Program.class
compile : javac Progam.java or javac -classpath .;postgresql.org Progam.java
Ray

TextSamplerDemo.java question

I took the TextSamplerDemo from http://java.sun.com/docs/books/tutorial/uiswing/components/text.html and stripped it down to the one thing I have a question about. Given the code below, how do I implement the toolbar button to make selected text turn bold? I've been beating my head againt this one for a couple of days now and getting nowhere.
Any help would be deeply appeciated.
--gary
import javax.swing.*;
import javax.swing.text.*;
import java.awt.*; //for layout managers and more
import java.awt.event.*; //for action events
public class TextSamplerDemo extends JPanel
implements ActionListener {
private String newline = "\n";
protected static final String textFieldString = "JTextField";
public TextSamplerDemo() {
setLayout(new BoxLayout(this, BoxLayout.PAGE_AXIS));
JToolBar toolBar = buildToolbar();
add(toolBar);
//Create a text pane.
JTextPane textPane = createTextPane();
JScrollPane paneScrollPane = new JScrollPane(textPane);
paneScrollPane.setVerticalScrollBarPolicy(
JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
paneScrollPane.setPreferredSize(new Dimension(250, 155));
paneScrollPane.setMinimumSize(new Dimension(10, 10));
add(textPane);
public void actionPerformed(ActionEvent e) {
private JTextPane createTextPane() {
String[] initString =
{ "This is an editable JTextPane, ", //regular
"another ", //italic
"styled ", //bold
"text ", //small
"component, " + newline, //large
"which supports embedded components..." + newline,//regular
newline + "JTextPane is a subclass of JEditorPane that " + newline +
"uses a StyledEditorKit and StyledDocument, and provides " + newline +
"cover methods for interacting with those objects."
String[] initStyles =
{ "regular", "italic", "bold", "small", "large",
"regular", "regular"
JTextPane textPane = new JTextPane();
StyledDocument doc = textPane.getStyledDocument();
addStylesToDocument(doc);
try {
for (int i=0; i < initString.length; i++) {
doc.insertString(doc.getLength(), initString,
doc.getStyle(initStyles[i]));
} catch (BadLocationException ble) {
System.err.println("Couldn't insert initial text into text pane.");
return textPane;
protected void addStylesToDocument(StyledDocument doc) {
//Initialize some styles.
Style def = StyleContext.getDefaultStyleContext().
getStyle(StyleContext.DEFAULT_STYLE);
Style regular = doc.addStyle("regular", def);
StyleConstants.setFontFamily(def, "SansSerif");
Style s = doc.addStyle("italic", regular);
StyleConstants.setItalic(s, true);
s = doc.addStyle("bold", regular);
StyleConstants.setBold(s, true);
s = doc.addStyle("small", regular);
StyleConstants.setFontSize(s, 10);
s = doc.addStyle("large", regular);
StyleConstants.setFontSize(s, 16);
private JToolBar buildToolbar() {
JToolBar toolBar = new JToolBar();
toolBar.setRollover( true );
toolBar.setFloatable( false );
JButton boldButton = new JButton("Bold");
boldButton.setToolTipText( "Set selected text to bold" );
boldButton.addActionListener( new ActionListener() {
public void actionPerformed( ActionEvent e ) {
// code here to make selected text bold
toolBar.add( boldButton );
return toolBar;
* Create the GUI and show it. For thread safety,
* this method should be invoked from the
* event-dispatching thread.
private static void createAndShowGUI() {
//Make sure we have nice window decorations.
JFrame.setDefaultLookAndFeelDecorated(true);
//Create and set up the window.
JFrame frame = new JFrame("TextSamplerDemo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//Create and set up the content pane.
JComponent newContentPane = new TextSamplerDemo();
newContentPane.setOpaque(true); //content panes must be opaque
frame.setContentPane(newContentPane);
//Display the window.
frame.pack();
frame.setVisible(true);
public static void main(String[] args) {
//Schedule a job for the event-dispatching thread:
//creating and showing this application's GUI.
javax.swing.SwingUtilities.invokeLater(new Runnable() {
public void run() {
createAndShowGUI();

try this, but im'not sure.
StyleContext styleContext = StyleContext.getDefaultStyleContext();
Style def = styleContext.getStyle(StyleContext.DEFAULT_STYLE);
Style bold = styledDocument.addStyle("bold", def);
StyleConstants.setBold(bold, true);into the listener of your component insert this:
int start = getSelectionStart();
int len = getSelectionEnd() - start;
styledDocument.setCharacterAttributes(start, len, bold, true);by gino

A generic java question

Similar Messages

Maybe you are looking for