Question: How can I reload a ListView from inside an AlertDialog? This AlertDialog is spawned by a ContectMenu.

```
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    registerForContextMenu(getListView());
    ......
    MatrixCursor cursor;
    cursor = NameManager.getnameList();
    ........
    final SimpleCursorAdapter adapter = new SimpleCursorAdapter(this,
            R.layout.row, cursor, from, to);
    setListAdapter(adapter);
}
.......
.......
case R.id.delete:
            new AlertDialog.Builder(this)
            .setTitle("Delete " + cursor.getString(1))
            .setMessage("Are you sure?")
            .setPositiveButton("Ok",
                    new DialogInterface.OnClickListener() {
                @Override
                public void onClick(
                        DialogInterface dialogInterface, int i) {
                    try {
                        .......
                        // TODO reload listview

                    } catch (IOException e) {
                        e.printStackTrace();
                        return;
                    }
                }
            }).setNeutralButton("Cancel", null)
            .create().show();
            return true;

```

Answer: 
Here's another alternative, assuming you have control of all the classes involved: abstract out the fields in the superclass and declare them in the subclasses, sort of like this...

```
abstract class SuperClass {
  abstract int[] getFooArray(); // not public!
  abstract int getBar();
}

```

and then just define the field in each of those subclasses, overriding the methods to return them.

Yes, it will involve some code duplication, but it could very well be cleaner in the end than an unreadably long constructor, and the code you're duplicating isn't very much -- a field, a one-line method to return that field.
When I have a need for an immutable object (all members are final) that takes many different parameters in the constructor I usually use a Builder pattern.

In this case you can make the builders subclass each other and in this way you will still maintain the ability to extend.

For an example you can see the Guava API for ImmutableCollection [Builder](http://guava-libraries.googlecode.com/svn/trunk/javadoc/com/google/common/collect/ImmutableCollection.Builder.html).
Or if you don't require immutability, here is an example of [CacheBuilder](http://guava-libraries.googlecode.com/svn/trunk/javadoc/com/google/common/cache/CacheBuilder.html) also taken from the same library:

```
Cache<Key, Graph> graphs = CacheBuilder.newBuilder()
   .concurrencyLevel(4)
   .weakKeys()
   .maximumSize(10000)
   .expireAfterWrite(10, TimeUnit.MINUTES)
   .build(
       new CacheLoader<Key, Graph>() {
         public Graph load(Key key) throws AnyException {
           return createExpensiveGraph(key);
         }
       });

```

As you can see the use of a builder replaces the need to pass in 6 parameters in the constructor and makes for more readable/usable code.

If you still don't want to use builders I would go with option (3) as that will prevent some of the hassle of maintaining a very long constructor