MyListActivity, MyCursorAdapter, MyViewHolder - classi nidificate o no?

1

Sto utilizzando diverse attività basate su ListActivity . Tutti mostrano informazioni da diverse query SQLite e tutte usano l'ottimizzazione ViewHolder . L'adattatore del cursore deve essere specializzato e anche il titolare della vista è speciale per lo scopo. Pertanto, sono definiti come private class es all'interno della definizione MyListActivity .

Non avendo troppa esperienza con Java, la mia domanda è se l'approccio scelto sia corretto. Probabilmente le classi non annidate (cioè il file piatto, separato * .java) non è migliore per ragioni a me sconosciute.

Quali sono i pro e i contro degli approcci annidati / piatti?

Per essere più specifici, ecco lo scheletro del codice:

public class MyListActivity extends ListActivity
        implements LoaderManager.LoaderCallbacks<Cursor> {

    private MyCursorAdapter myAdapter;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        ...
        initLoaderAndSetListAdapter();
    }

    private static class MyViewHolder {
        public TextView code;
        public CharArrayBuffer codeBuffer = new CharArrayBuffer(20);
        ...
    }

    private class MyCursorAdapter extends CursorAdapter {

        private final LayoutInflater mInflater;
        private final int mLayout;

        public MyCursorAdapter(Context context, Cursor c, int flags) {
            super(context, c, flags);
            mLayout = R.layout.the_specific_view_for_the_list_item;
            mInflater = (LayoutInflater)
                    context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        }

        @Override
        public View newView(Context context, Cursor cursor, ViewGroup parent) {
            View v = mInflater.inflate(mLayout, parent, false);
            MyViewHolder holder = new MyViewHolder();
            holder.code = (TextView) v.findViewById(R.id.code);
            v.setTag(holder);
            return v;
        }

        @Override
        public void bindView(View view, Context context, Cursor cursor) {
            MyViewHolder holder = (MyViewHolder) view.getTag();
            cursor.copyStringToBuffer(1, holder.codeBuffer);  // COLUMN_CODE
            ...
            holder.code.setText(holder.codeBuffer.data, 0, holder.codeBuffer.sizeCopied);
            ...
        }
    }

    private void initLoaderAndSetListAdapter() {
        getLoaderManager().initLoader(0, null, this);
        myAdapter = new MyCursorAdapter(this, null, 0);
        setListAdapter(myAdapter);
    }

    @Override
    public Loader<Cursor> onCreateLoader(int id, Bundle args) {
        Uri uri = ... set the uri based on situation... ;
        String[] projection = { ... };
        CursorLoader cursorLoader = new CursorLoader(this,
                uri, projection,
                null, null,
                orderingInfo);
        return cursorLoader;
    }

    @Override
    public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
        myAdapter.swapCursor(data);
    }

    @Override
    public void onLoaderReset(Loader<Cursor> loader) {
        myAdapter.swapCursor(null);
    }
}

La domanda è specifica della situazione descritta che incontro ripetutamente. Per favore, non considerarlo come classi generali nidificate o non .

    
posta pepr 15.08.2013 - 16:02
fonte

1 risposta

1

Oracle dice :

Why Use Nested Classes?

There are several compelling reasons for using nested classes, among them:

  1. It is a way of logically grouping classes that are only used in one place.
  2. It increases encapsulation.
  3. Nested classes can lead to more readable and maintainable code.

Logical grouping of classes — If a class is useful to only one other class, then it is logical to embed it in that class and keep the two together. Nesting such "helper classes" makes their package more streamlined.

Increased encapsulation — Consider two top-level classes, A and B, where B needs access to members of A that would otherwise be declared private. By hiding class B within class A, A's members can be declared private and B can access them. In addition, B itself can be hidden from the outside world.

Ora applica questi criteri all'utilizzo proposto delle classi nidificate. I vantaggi giustificano l'ulteriore complessità dell'annidamento delle classi?

Le classi annidate possono essere utilizzate solo all'interno della loro classe esterna, quindi devono dimostrare il loro valore all'interno della classe, dal momento che non sono utilizzabili altrove. La domanda generale è questa: può MyViewHolder essere utile in qualsiasi altro punto del programma, o sarà sempre utile solo in MyListActivity ?

    
risposta data 15.08.2013 - 18:04
fonte

Leggi altre domande sui tag