Re: cannot find symbol?

From:

Daniel Pitts <newsgroup.nospam@virtualinfinity.net>

Newsgroups:

comp.lang.java.programmer

Date:

Fri, 03 May 2013 21:54:02 -0700

Message-ID:

<Mv0ht.26140$GU1.13015@newsfe18.iad>

On 5/3/13 9:01 PM, qwertmonkey@syberianoutpost.ru wrote:

  Basically I am passing a String array to a method (verify) defined in a
  generic way in an interface in order to create an object of a certain type

  I am checking that the object of the correct type is created but when I try
to call a method java tells me "cannot find symbol"

  I squinted at it for a while, but can't see what is wrong with it

  What is wrong with this code? How do you fix that problem? Does it relate
to the use of generic declarations and/or reflection?

  thanks,
  lbrtchx
  comp.lang.java.programmer: cannot find symbol?

// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~

import java.util.Date;

import java.io.IOException;

import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;

// __ mock/test object
class IADObj{
  private int d;
  private String aS;
  private Date Dt;
// __
  IADObj(){}
// __
  public void setCtxt(int d, String aS, long lTm){
   this.d = d;
   this.aS = aS;
   this.Dt = new Date(lTm);
  }
// __
  public String toString(){ return("// __ d: |" + d + "|, aS: |" + aS +
  "|, Dt: |" + Dt + "|"); }
}

// __
interface verifiableCLIContext06<T_Ctxt>{
  public boolean verifyCtxt(String[] aSArs, Class<? extends T_Ctxt> TpArgK);
  public T_Ctxt getCtxtDTO();
}

// __
class DTO_T_Ctxt06<T_Ctxt> implements verifiableCLIContext06<T_Ctxt> {
  private T_Ctxt tCtxt; // operating context

// __
  DTO_T_Ctxt06(){ System.err.println("// __ object created: |" +
getTimeStamp() + "|"); }

// __
  private String getTimeStamp(){ return((new Date()).toString()); }

// __
  public boolean verifyCtxt(String[] aSAr, Class<? extends T_Ctxt> TpArgK){
   int iArSz= Integer.MIN_VALUE;
   boolean Is = ((aSAr != null) && ((iArSz = aSAr.length) > 0));
   if(Is){
    for(int i = 0; (i < iArSz); ++i){
     System.err.println("// __ aSAr[" + i + "]: |" + aSAr[i] + "|");
    }
// __
    try{
     tCtxt = (T_Ctxt)TpArgK.newInstance();

     System.err.println("// __ tCtxt.getClass(): |" + tCtxt.getClass() + "|");

/*
     tCtxt.setCtxt((new Integer(aSAr[0])).intValue(), aSAr[1],
(new Long(aSAr[0])).longValue());

cannot find symbol
symbol : method setCtxt(int,java.lang.String,long)
location: class java.lang.Object
     tCtxt.setCtxt((new Integer(aSAr[0])).intValue(), aSAr[1],
(new Long(aSAr[0])).longValue());
          ^
*/

    }catch(InstantiationException InstX){ InstX.printStackTrace(System.err); }
     catch(IllegalAccessException IlglAxX){ IlglAxX.printStackTrace(); }
   }// (Is)
// __
   return(Is);
  }

// __
  public T_Ctxt getCtxtDTO(){ return(tCtxt); }
}

// __
public class DTO_T_Ctxt06Test{

  public static void main(String[] args) {
   IADObj IAD = new IADObj();
   String[] aSAr = new String[]{"37", "abc", (new Date()).toString()};

   DTO_T_Ctxt06<IADObj> DTO_T_Ctxt06 = new DTO_T_Ctxt06<IADObj>();

   DTO_T_Ctxt06.verifyCtxt(aSAr, IAD.getClass());
  }
}
// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~

Try reducing your problem to an SSCCE <http://sscce.org>. It is
difficult to follow those poorly named mock classes and interfaces.

On an unrelated note, what the hell convention is that? DTO? T_? Hell,
underscores in class names? This looks like it was copied from C++ code
which was copied from C code.

Actually, now that I say that, are you expecting generics to work like
templates in C++? They don't.

The DTO_T_Ctxt06 object (which has the same name as the class, bad and
confusing) only knows about the "?". It doesn't know about the specific
subclass you've chosen.

What you want is an interface.

public interface ContextAware {
   void setContext(int data, String string, long time);
}

public class Adjective implements ContextAware {
   private int data;
   private String string;
   private Date date;
   public void setContext(int data, String string, long time) {
      this.data = data;
      this.string = string;
      this.date = new Date(time);
   }
}

public class ContextVerifier {
   public verifyContext(String[] strings, ContextAware target) {
      target.setContext(
         Integer.parseInt(strings[0]),
         strings[1],
         Long.parseLong(strings[2]);
   }
}

public class Test {
   public static void main(String...args) {
      final String[] args = {
        "37",
        "abc",
        String.valueOf(System.currentTimeMillies())
      };

      final ContextVerifier cv = new ContextVerifier();
      cv.verifyContext(args, new Adjective();
   }
}

Well, would you look at that. You no longer have to deal with Class
tokens, instantiation, exceptions, or generics! A much cleaner program.
  Untested, but the main concept should be clear.

Hope this helps,
Daniel.