Java Introspection and Using Collections without Generics

In my prior article on Generics we looked at how to use Generics to associate at type with data stored in a Collection.

You might wonder why would anyone want to store information in a Collection without its type being preserved. Well, it's possible that you'd want to store many Objects of different types in one collection. In that case, the only parent those types might have in common is java.lang.Object. So using a Generic won't do you any good.

But, once you pull that data back out of the Collection, how do you find out what it was?

Fortunately, the object itself has that information stored with it.

There are two easy ways to find out what it is. instanceof can test if it is a specific type of Object:

if (anObject instanceof String) { aString = (String)anObject); }

You can also have an Object tell you its type:

Class myClass = anObject.getClass();

or

String myClassName = anObject.getClass().getName();

A look at the documentation for Object and Class gives all sorts of useful methods for dealing with classes of data objects in Java.

Here's some sample code:

import java.util.*;

public class NoGenerics2{
// This is an example of using introspection
// to determine types of Objects stored in a
// Collection without a Generic declaration.

  public static void main(String[] arg){
    ArrayList myList = new ArrayList(); // No Generic  declaration.
    String myString="Boss Moss";
    String yourString="Snorkledorf";

    // put the strings into the List
    myList.add(myString);
    myList.add(yourString);

    for (Object anObject: myList){
      System.out.println(anObject.getClass().getName());
      if (anObject instanceof String){
        String aString = (String)anObject; 
      }
      else{
        System.out.println("Not a String, Sheriff!");
      }
    }
  }
}

Generics in Java

Generics are an oddly-named thing in Java that associate objects stored in a Collection with a particular type. Let's take a look at a piece of code that uses a Collection to store some Strings. It uses an ArrayList. Here's the code:

import java.util.*;
public class NoGenerics{
// This is an example of what happens 
// when you don't declare a class
// for a Collection using Generics. 
// It won't compile!

  public static void main(String[] arg){
    // No Generic  declaration.
    ArrayList myList = new ArrayList();
    String myString="Boss Moss";
    String yourString="Snorkledorf";

    // put the strings into the ArrayList
    myList.add(myString);
    myList.add(yourString);

    for (String aString: myList){
    // We can't do String methods on the items from myList.
      if (aString.startsWith("Boss")){
        System.out.println(aString + ":");
        System.out.println("Make sure you spell it right!");
      }
      else{
        System.out.println(aString + ":");
        System.out.println("I am so pretty!");
      }
    }
  }
}

What happens here to upset javac is that once the String is placed in the ArrayList, its type is lost, and it is known only as an Object. To be treated as a String again, it would have to be cast as a String. If any errors are made in casting the data, the program will fail at runtime, not when it is being compiled--when the programmer has it in their hands to fix it.

Feel free to take the above code and try to compile it to see the error you'll get. It is instructive.

The Fix for Lost Types

In Java version 1.5 "Generics" were added to fix this. Now Collections like the ArrayList can associate a type with the data put in them, and the compiler can do type checking. Here's the above code, with the Generic declaration added:

import java.util.*;

public class Generics{
// This is an example of what happens 
// when you declare a data class
// for a Collection using Generics.

  public static void main(String[] arg){
    // Generic  declaration.
    ArrayList myList = new ArrayList();
    String myString="Boss Moss";
    String yourString="Snorkledorf";

    // put the strings into the ArrayList
    myList.add(myString);
    myList.add(yourString);

    for (String aString: myList){
    // Now when we can do String methods on the List items.
      if (aString.startsWith("Boss")){
        System.out.println(aString + ":");
        System.out.println("Make sure you spell it right!");
      }
      else{
        System.out.println(aString + ":");
        System.out.println("I am so pretty!");
      }
    }
  }
}

Generics = Typed Collections
So if you are going to use a collection on Objects all of a specific type (rather than mixing and matching), put on a Generic declaration.

Your Own Java Classes

To use Java effectively, you want to create and use your own classes. This is one of the great powers of object-oriented languages--the ability to construct programs out of independent building-blocks that cut large problems down into small, easily solvable ones. There's a lot more that can be said, and much of it is elsewhere. So I'll get right into a very simple, very basic example here.

We're going to create a very simple object class that will print a "Hello" message to the screen when called. This class will have two different methods that will do the same thing, though we'll vary the messages they print a bit so that we can see which one is doing the work.

Here's our class: (download HelloClass.Java)

public class HelloClass{

/**
 * sayHello() prints "Hello!" to the Java console output.
 */
 public void sayHello(){
  System.out.println("Hello!\n");
 }

/**
 * doHello() prints "Hello, hello!" to the Java console output.
 * It's static, so you don't need to instatiate a HelloClass 
 * object to use it.
 */
 public static void doHello(){
  System.out.println("Hello, hello!\n");
 }

} // End of HelloClass

The two methods we have to print messages are sayHello() and doHello(). To use sayHello(), we need to have a HelloClass object created, then call that object's sayHello() method.

doHello(), however, is a static method. This means is belongs to the class, not to any object of the class. So we can use it without any HelloClass objects being created first.

Here's a class that uses these methods as described: (download UseHello.java)

public class UseHello{
 public static void main(String[] arg){

  // We can use doHello() without a HelloClass object:
  HelloClass.doHello(); // call the HelloClass's doHello() method.

  // But we need to create a HelloClass object to use sayHello():
  HelloClass hello=new HelloClass();
  hello.sayHello(); // call hello's sayHello() method.

 }
} // End of UseHello.

If we try to call sayHello() without first creating a HelloClass object, like this:
HelloClass.sayHello();

then we'll get the dreaded "calling a non-static method from a static context" error message. That's letting you know that you need to instantiate (or create) a HelloClass object first, then tell that object to call its method.

Static methods are useful for things like general arithmetic and calculation or other methods that might be used in a way where state information is unimportant. But beware, it's easy to create static methods when what's really wanted is an object that does what you want.

Files available for download through: http://saundby.com/beginwithjava/.