It is possible to obtain all fields with the method getDeclaredFields() of Class. Then you have to check the modifier of each fields to find the private ones:

List<Field> privateFields = new ArrayList<>();
Field[] allFields = SomeClass.class.getDeclaredFields();
for (Field field : allFields) {
    if (Modifier.isPrivate(field.getModifiers())) {
        privateFields.add(field);
    }
}

Note that getDeclaredFields() will not return inherited fields.

Eventually, you get the type of the fields with the method Field.getType().

obj = obj.getClass().getSuperclass().cast(obj);

This line does not do what you expect it to do. Casting an Object does not actually change it, it just tells the compiler to treat it as something else.

E.g. you can cast a List to a Collection, but it will still remain a List.

However, looping up through the super classes to access fields works fine without casting:

Class<?> current = yourClass;
while(current.getSuperclass()!=null){ // we don't want to process Object.class
    // do something with current's fields
    current = current.getSuperclass();
}

BTW, if you have access to the Spring Framework, there is a handy method for looping through the fields of a class and all super classes:
ReflectionUtils.doWithFields(baseClass, FieldCallback)
(also see this previous answer of mine: Access to private inherited fields via reflection in Java)

In order to access private fields, you need to get them from the class's declared fields and then make them accessible:

Field f = obj.getClass().getDeclaredField("stuffIWant"); //NoSuchFieldException
f.setAccessible(true);
Hashtable iWantThis = (Hashtable) f.get(obj); //IllegalAccessException

EDIT: as has been commented by aperkins, both accessing the field, setting it as accessible and retrieving the value can throw Exceptions, although the only checked exceptions you need to be mindful of are commented above.

The NoSuchFieldException would be thrown if you asked for a field by a name which did not correspond to a declared field.

obj.getClass().getDeclaredField("misspelled"); //will throw NoSuchFieldException

The IllegalAccessException would be thrown if the field was not accessible (for example, if it is private and has not been made accessible via missing out the f.setAccessible(true) line.

The RuntimeExceptions which may be thrown are either SecurityExceptions (if the JVM's SecurityManager will not allow you to change a field's accessibility), or IllegalArgumentExceptions, if you try and access the field on an object not of the field's class's type:

f.get("BOB"); //will throw IllegalArgumentException, as String is of the wrong type

You can use the getDeclaredFields method of Class class to get all the fields that are declared in the class irrespective of its modifier. Using the getDeclaredFields method will provide you with an array of Field, which you can then iterate through, and call the getType method to get the types of the fields. The following code demonstrates the same:

class TestClass
{
    private String x;
    private int y;
    private boolean z;
}
public class Test
{
    public static void main(String[] args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchFieldException 
    {
        Class clazz = TestClass.class;
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) 
        {
            System.out.println("fieldName: "+field.getName()+", fieldType: "+field.getType());
        }
    }
}

The above code outputs:

fieldName: x, fieldType: class java.lang.String
fieldName: y, fieldType: int
fieldName: z, fieldType: boolean

This is quite old question post but i'll provide an answer here for the sake of new searches.

Using the approach provided by @highlycaffeinated here: https://stackoverflow.com/a/6796254/776860

You can easily come up with a desired solution with a couple of changes.

Retrieving a list of private field names only

public List<String> getMap(Object o) throws IllegalArgumentException, IllegalAccessException {
    List<String> result = new ArrayList<String>();
    Field[] declaredFields = o.getClass().getDeclaredFields();
    for (Field field : declaredFields) {
        if(!field.isAccessible()) {
            result.add(field.getName());
        }
    }
    return result;
}

Retrieving a Map of all field names and their values

public Map<String, Object> getMap(Object o) throws IllegalArgumentException, IllegalAccessException {
    Map<String, Object> result = new HashMap<String, Object>();
    Field[] declaredFields = o.getClass().getDeclaredFields();
    for (Field field : declaredFields) {
        field.setAccessible(true);
        result.put(field.getName(), field.get(o));
        } 
    }
    return result;
}

Exactly like @highlycaffeinated provided just with the additional line field.setAccessible(true); which enables you to introspect private fields too.

Yes, it absolutely is - assuming you've got the appropriate security permissions. Use Field.setAccessible(true) first if you're accessing it from a different class.

import java.lang.reflect.*;

class Other
{
    private String str;
    public void setStr(String value)
    {
        str = value;
    }
}

class Test
{
    public static void main(String[] args)
        // Just for the ease of a throwaway test. Don't
        // do this normally!
        throws Exception
    {
        Other t = new Other();
        t.setStr("hi");
        Field field = Other.class.getDeclaredField("str");
        field.setAccessible(true);
        Object value = field.get(t);
        System.out.println(value);
    }
}

And no, you shouldn't normally do this... it's subverting the intentions of the original author of the class. For example, there may well be validation applied in any situation where the field can normally be set, or other fields may be changed at the same time. You're effectively violating the intended level of encapsulation.

You could use getDeclaredClasses to find nested classes, then find the private fields and finally the getters and setters:

Class<?> topClass = ...

for (Class<?> innerClass : topClass.getDeclaredClasses()) {
    for (Field field : innerClass.getDeclaredFields()) {
        if (Modifier.isPrivate(field.getModifiers())) {
            String name = Character.toUpperCase(field.getName().charAt(0)) 
                        + field.getName().substring(1);
            Method getter;
            try {
                getter = innerClass.getDeclaredMethod("get" + name);
            } catch (Exception ex) {
                getter = null;
            }
            Method setter;
            try {
                setter = innerClass.getDeclaredMethod("set" + name, field.getType());
            } catch (Exception ex) {
                setter = null;
            }

            // TODO real work...
            System.out.printf("%s: getter=%s, setter=%s%n", 
                              innerClass.getSimpleName(), getter, setter);
        }
    }
}

Edit: above code is valid for "nested classes" as mentioned in the questions title. After the sample code was added to the question it seems like the question is about getters and setters of the fields of the class:

Use getDeclaredFields to get all fields of the class and find the corresponding getter and setter as above; use getType to get the type (class) of each field and (recursively) start over with that class.

Class.getDeclaredFields() returns the fields in the order of declaration. To get only the private ones:

for (Field field : YourClass.cass.getDeclaredFields())
    if (Modifier.isPrivate(field.getModifiers()))
        System.out.println(field.getName());

Note that inherited fields are not included, quoting from the javadoc:

Returns an array of Field objects reflecting all the fields declared by the class or interface represented by this Class object. This includes public, protected, default (package) access, and private fields, but excludes inherited fields.

For that, you have to do the same for the super class and implemented interfaces (recursively).

Warning:

Quoting from the javadoc:

The elements in the returned array are not sorted and are not in any particular order.

The API does not require the returned Field array to be sorted in any way, but in practice (Oracle implementation), they are in the same order as you declared them.