Instead of trying to call a setter, you could also just directly set the value to the property using reflection. For example:

public static boolean set(Object object, String fieldName, Object fieldValue) {
    Class<?> clazz = object.getClass();
    while (clazz != null) {
        try {
            Field field = clazz.getDeclaredField(fieldName);
            field.setAccessible(true);
            field.set(object, fieldValue);
            return true;
        } catch (NoSuchFieldException e) {
            clazz = clazz.getSuperclass();
        } catch (Exception e) {
            throw new IllegalStateException(e);
        }
    }
    return false;
}

Call:

Class<?> clazz = Class.forName(className);
Object instance = clazz.newInstance();
set(instance, "salary", 15);
set(instance, "firstname", "John");

FYI, here is the equivalent generic getter:

@SuppressWarnings("unchecked")
public static <V> V get(Object object, String fieldName) {
    Class<?> clazz = object.getClass();
    while (clazz != null) {
        try {
            Field field = clazz.getDeclaredField(fieldName);
            field.setAccessible(true);
            return (V) field.get(object);
        } catch (NoSuchFieldException e) {
            clazz = clazz.getSuperclass();
        } catch (Exception e) {
            throw new IllegalStateException(e);
        }
    }
    return null;
}

Call:

Class<?> clazz = Class.forName(className);
Object instance = clazz.newInstance();
int salary = get(instance, "salary");
String firstname = get(instance, "firstname");

If your classes respect the JavaBeans convention (standard getters and setters encapsulate fields), you can use the Introspector, and several frameworks that rely on it.

My favorite example would be Spring's BeanWrapper technology, which allows you to write code like this:

BeanWrapper bw = new BeanWrapperImpl(street);
bw.setPropertyValue("buildings[0].appartments[1].owner", "luke");

Hopefully this is what you are trying to do:

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class Test {
    
    private Map ttp = new HashMap(); 
    
    public  void test() {
        Field declaredField =  null;
        try {
            
            declaredField = Test.class.getDeclaredField("ttp");
            boolean accessible = declaredField.isAccessible();

            declaredField.setAccessible(true);
            
            ConcurrentHashMap<Object, Object> concHashMap = new ConcurrentHashMap<Object, Object>();
            concHashMap.put("key1", "value1");
            declaredField.set(this, concHashMap);
            Object value = ttp.get("key1");

            System.out.println(value);

            declaredField.setAccessible(accessible);
            
        } catch (NoSuchFieldException 
                | SecurityException
                | IllegalArgumentException 
                | IllegalAccessException e) {
            e.printStackTrace();
        }
        
    }

    public static void main(String... args) {
        Test test = new Test();
        test.test(); 
    }
}

It prints :

value1

To access a private field you need to set Field::setAccessible to true. You can pull the field off the super class. This code works:

CopyClass<?> clazz = Child.class;
Object cc = clazz.newInstance();

Field f1 = cc.getClass().getSuperclass().getDeclaredField("a_field");
f1.setAccessible(true);
f1.set(cc, "reflecting on life");
String str1 = (String) f1.get(cc);
System.out.println("field: " + str1);

Use Class#newInstance().

Class<TypeA> cls = TypeA.class;
TypeA typeA = cls.newInstance();

Or, in your specific case when you have to determine the type of the method parameter:

Class<?> cls = setterMethod.getParameterTypes()[0];
Object value = cls.newInstance();
setterMethod.invoke(bean, value);

You can learn more about reflection in Sun tutorial on the subject. That said, classnames ought to start with uppercase. I've corrected it in the above example.

By the way, instead of reinventing the Javabean reflection wheel, you may find one of the tools mentioned here useful as well.

I think I may be overthinking this problem (i.e., I shouldn't be using reflection to set variables in this way)

Yep. Reflection is fairly slow and should only be used as a last resort. If this is simply to avoid having so much redundant code, consider using automatic code generation. For pure data objects, I would strongly recommend using protocol buffers; it will generate the getters / setters (you only need to declare the fields). Plus it allows for easy communication of the data between C++, Java, and Python.

If you have a class that has a lot of fields but isn't a pure data object... well

1. You should consider whether all the fields should be mutable. (Do you really need setters?)
2. Whether the fields should even be visible. (Do you need any accessors at all?)

It is often a good idea to make fields "final", initialize them in the constructor(s), and provide no access or provide limited access through an implemented interface.

Reflection seems a very fragile and non-intuitive way to implement this. Instead I think you should be telling the objects what to do, and they will collaborate between themselves to determine this. e.g.

restaurant.switchToSpringMenu();

and the Restaurant object could swap between menu instances that it has.

Exact requirement is that I will be getting some task to be done and corresponding value.. Now every task can be at different level in the hierarchy of the class... So I am not how else should I implement this

Perhaps this could be achieved via a visitor pattern. e.g. you do something like:

restaurant.reorganise(forSummer);

where forSummer is some implementation of a task. The Restaurant object collaborates with this task object, then calls on the underlying Employee/Menu classes, which will do the same.

If you really want a more generic means of navigating these hierarchies, you could look at JXPath, which allows you to use XPath-like expressions to find objects e.g.

 (Ingredient)JXPathContext.newContext(restaurants).
         getValue("restaurant[address/zipCode='90210']/menu/ingredients[1]");