compile-time type checking

[Vatsa dude]

Can anyone please suggest how I can improve compile-time type checking in the following piece of code?

  
  */
        public class MyCache{

            private Map<Object, Object> map;

            public MyCache() {
                map = new HashMap<Object, Object>();
            }

            public void put(Object key, Object value) {
                map.put(key, value);
            }

            public Object get(Object key) {
                return map.get(key);
            }
        }
  

[Vatsa dude]

Only solution I can think of is changing <Object, Object> to <String, String> all over the code.. Is that it?

[Max Rahder]

It depends on what types of object you want to store in the map. If you might store anything in the Map, then there is no way to improve it -- what you've defined will store any object/object pair. But, for example, if you know the key is a String, then define the variable as private Map<String, Object> map = new HashMap<String, Object>(); -- the more specific your requirements, the more specific you can be. (By the way, your get() and put() methods don't seem to do anything more than what's provided in the map itself.)

[Vatsa dude]

I'm sorry, I might have misunderstood the problem. I had to duplicate a class as a Singleton similar to 'MyCache' below called 'SingletonCache'. Can compile-time type checking be improved in the code below? (Except for changing <Object, Object> to specific type like <String,String>

  
 public static class SingletonCache {
        	
        	private static  SingletonCache singleton = null;
        	
        	private static  Map<Object, Object> map;       	
        	        	
        	private SingletonCache() {
        		//Construct the object here
       	        if (map != null) {
        	                throw new IllegalStateException("Already instantiated");
        	        }
       	        map = new HashMap<Object, Object>();
        	    }
        	
        	public void put(Object key, Object value) {
               singleton = (SingletonCache) map.put(key, value);
            }
        	
        	/*
        	 * Making the method synchronized prevents two threads from calling the get method
        	 * at the same time. Using lazy initialization below.
        	 */
            public static synchronized Object get(Object key) {
            	
            	singleton = (SingletonCache)map.get(key);
            	
            	if(singleton == null)
            	{
            		singleton = new SingletonCache();
            	}
            	return singleton;
              }
        	  
      	}