Determine type of a primitive

[Barkat Mardhani]

Is there any way to determine the type of a primitive?

[Vishy Karl]

I think No there is method for objects but I don't think there is for primitive.
Others do correct if you feel I am wrong,
Bye
Vishal.

[Ed Tse]

can you post the scenario? when do u need that?

[Danijel Kucak]

Originally posted by Vishal Kalra:
I think No there is method for objects but I don't think there is for primitive.
Others do correct if you feel I am wrong,
Bye
Vishal.

i think there is no method for objects, it's operator instanceof
Bye,
Danijel

[Barkat Mardhani]

class Test {
public static void main(String[] args) {
int i = 0 ;
System.out.println(/** print type of i **/)
}

[Steve Lovelace]

How's this?

public class Test {
 public static void main(String[] args) {
 int i = 0 ;
 System.out.println(Typist.typeFor(i));
 }
 public static class Typist {
 public static Class typeFor(byte p) {return byte.class;}
 public static Class typeFor(short p) {return short.class;}
 public static Class typeFor(char p) {return char.class;}
 public static Class typeFor(int p) {return int.class;}
 public static Class typeFor(long p) {return long.class;}
 public static Class typeFor(float p) {return float.class;}
 public static Class typeFor(double p) {return double.class;}
 public static Class typeFor(boolean p) {return boolean.class;}
 public static Class typeFor(Object p) {return p.getClass();}
 }
}

[ September 19, 2003: Message edited by: Steve Lovelace ]

[Barkat Mardhani]

Thanks Steve. That is great. But I was expecting some like this in API. By the way what is by byte.class. Never seen that before.
Thanks
Barkat

[Alton Hernandez]

I doubt very much there is one.
Primitive types are not objects. You cannot do introspection on them.

[Barkat Mardhani]

What about if Steve's code is part of AP1 so that every client does not have write it?

[Steve Lovelace]

Appears the VM builds for itself a Class object for each of the primitive types. The syntax for accessing these is <type>.class, so, byte.class, int.class, etc. Alton's right that introspection (reflection?) won't get you anywhere:

 import java.util.*;
import java.lang.reflect.*;
public class Test {
public static void main(String[] args) {
Class b = boolean.class;
Field[] f = b.getDeclaredFields();
Method[] m = b.getDeclaredMethods();
Constructor[] c = b.getDeclaredConstructors();
System.out.print(Arrays.asList(f));
System.out.print(Arrays.asList(m));
System.out.print(Arrays.asList(c));
System.out.println(b.isPrimitive());
}
}
[][][]true 

Somebody know offhand what introspection is, is it different from reflection?

[Jose Botella]

Reflection is the ability of a program to use an object whose class file was not present at the time of its compilation. The program cannot name the real type of such object, it cannot name its methods or fields because the compiler would complain. Instead the program uses java.lang.reflect
I think introspection is either a synonym, or a process that uses reflection discovering JavaBeans members for a Gui Builder.
JavaBean specification
[ September 21, 2003: Message edited by: Jose Botella ]

[Alton Hernandez]

Objects that are introspective(or reflective) has the ability to describe itself. Programming languages that support introspection allows objects to be examined, like, what class it came from, what are its fields and methods, etc.

[Steve Lovelace]

Just a note about Typist. It really isn't anything more than a kinda cute demo of overloading and the existence of Class objects for primitives. Fact is, you can always see the declaration of a primitive variable - it's somewhere in your code, and whatever its declared to be, that's what it is. So Typist has no real purpose in life.