Android领域抽象类实例化

Question

我正在尝试设置一个 AutoCompleteTextview（在我的 MainActivity 中），从 Realm 数据库中获取数据。所以我使用如下适配器：

public abstract class FilterableRealmBaseAdapter<T extends RealmObject> extends ArrayAdapter<T> implements Filterable {

private final RealmResults<T> mRealmObjectList;
private List<T> mResults;

public FilterableRealmBaseAdapter(Context context, @LayoutRes int layout, RealmResults<T> realmObjectList) {
    super(context, layout);
    mRealmObjectList = realmObjectList;
}

@Override
public int getCount() {
    return mResults == null ? 0 : mResults.size();
}

@Override
public T getItem(int position) {
    return mResults == null ? null : mResults.get(position);
}

@Override
public Filter getFilter() {

    return new Filter() {
        private boolean mHasResults = false;

        @Override
        protected FilterResults performFiltering(CharSequence constraint) {
            // do nothing here because it's executed in another thread and Realm really
            // doesn't like treating data from another thread.
            final FilterResults results = new FilterResults();
            results.count = mHasResults ? 1 : 0; // AutoCompleteTextView already hides dropdown here if count is 0, so correct it.
            return results;
        }

        @Override
        protected void publishResults(CharSequence constraint, FilterResults results) {
            // back on the main thread, we can do the query and notify
            if (constraint != null) {
                mResults = performRealmFiltering(constraint, mRealmObjectList);
                mHasResults = mResults.size() > 0;
                notifyDataSetChanged();
            }
        }
    };
}

protected abstract List<T> performRealmFiltering(@NonNull CharSequence constraint, RealmResults<T> results);
}

如何使用它在我的 MainActivity 中设置适配器？我猜它是通过扩展它并覆盖抽象方法来完成的。但是我的 MainActivity 已经扩展了 AppCompatActivity 并且适配器类已经扩展了 ArrayAdapter，所以我很困惑。感谢所有支持。

Answer 1

我有点重写了上面的代码，我认为它应该可以工作。

public abstract class FilterableRealmBaseAdapter<T extends RealmModel> extends ArrayAdapter<T> implements Filterable {

    private RealmResults<T> results;

    private final RealmChangeListener realmChangeListener;

    public FilterableRealmBaseAdapter(Context context, @LayoutRes int layout, @Nullable RealmResults<T> initialResults) {
        super(context, layout);
        this.realmChangeListener = new RealmChangeListener() {
            @Override
            public void onChange(Object element) {
                notifyDataSetChanged();
            }
        };
        this.results = initialResults;
        if(results != null && results.isValid()) {
            results.addChangeListener(realmChangeListener);
        }
    }

    @Override
    public int getCount() {
        return results == null || !results.isValid() ? 0 : results.size();
    }

    @Override
    public T getItem(int position) {
        return results == null || !results.isValid() ? null : results.get(position);
    }

    @Override
    public Filter getFilter() {
        return new Filter() {
            @Override
            protected FilterResults performFiltering(CharSequence constraint) {
                return new FilterResults();
            }

            @Override
            protected void publishResults(CharSequence constraint, FilterResults results) {
                if (constraint != null) {
                    if(this.results != null && this.results.isValid()) {
                        results.removeChangeListeners();
                    }
                    this.results = executeRealmQuery(constraint);
                    results.addChangeListener(realmChangeListener);
                    notifyDataSetChanged();
                }
            }
        };
    }

    protected abstract RealmResults<T> executeRealmQuery(@NonNull CharSequence constraint);
}

public class SomethingRealmAdapter extends FilterableRealmBaseAdapter<Something> {
    private final Realm realm;

    public SomethingRealmAdapter(Context context, @LayoutRes int layout, @Nullable RealmResults<Something> results, Realm realm) {
        super(context, layout, results);
        this.realm = realm;
    }

    protected RealmResults<T> executeRealmQuery(@NonNull CharSequence constraint) {
        return realm.where(Something.class)
                    .contains(SomethingFields.NAME, constraint.toString(), Case.INSENSITIVE)
                    .findAllSorted(SomethingFields.NAME, Sort.ASCENDING);
    }
}