Android 适配器模式应用及设计原理

 <android.support.v7.widget.recyclerview
   android:layout_width="match_parent"
   android:layout_height="wrap_content"
   android:id="@+id/mrecycler"/>
  

  recyclerview mrecycler= (recyclerview) findviewbyid(r.id.mrecycler);
   mrecycler.setlayoutmanager(new staggeredgridlayoutmanager(2,staggeredgridlayoutmanager.vertical));

public static abstract class adapter<vh extends viewholder> {

 private final adapterdataobservable mobservable = new adapterdataobservable();

 public abstract vh oncreateviewholder(viewgroup parent, int viewtype);

 public abstract void onbindviewholder(vh holder, int position);

 public void onbindviewholder(vh holder, int position, list<object> payloads) {
   onbindviewholder(holder, position);
 }

 /**
  * this method calls {@link #oncreateviewholder(viewgroup, int)} to create a new
  * {@link viewholder} and initializes some private fields to be used by recyclerview.
  *
  * @see #oncreateviewholder(viewgroup, int)
  */
 public final vh createviewholder(viewgroup parent, int viewtype) {
   tracecompat.beginsection(trace_create_view_tag);
   final vh holder = oncreateviewholder(parent, viewtype);
   holder.mitemviewtype = viewtype;
   tracecompat.endsection();
   return holder;
 }

 /**
  * this method internally calls {@link #onbindviewholder(viewholder, int)} to update the
  * {@link viewholder} contents with the item at the given position and also sets up some
  * private fields to be used by recyclerview.
  *
  * @see #onbindviewholder(viewholder, int)
  */
 public final void bindviewholder(vh holder, int position) {
   holder.mposition = position;
   if (hasstableids()) {
     holder.mitemid = getitemid(position);
   }
   holder.setflags(viewholder.flag_bound,
       viewholder.flag_bound | viewholder.flag_update | viewholder.flag_invalid
           | viewholder.flag_adapter_position_unknown);
   tracecompat.beginsection(trace_bind_view_tag);
   onbindviewholder(holder, position, holder.getunmodifiedpayloads());
   holder.clearpayload();
   tracecompat.endsection();
 }

 /**
  * return the view type of the item at <code>position</code> for the purposes
  * of view recycling.
  *
  * <p>the default implementation of this method returns 0, making the assumption of
  * a single view type for the adapter. unlike listview adapters, types need not
  * be contiguous. consider using id resources to uniquely identify item view types.
  *
  * @param position position to query
  * @return integer value identifying the type of the view needed to represent the item at
  *         <code>position</code>. type codes need not be contiguous.
  */
 public int getitemviewtype(int position) {
   return 0;
 }

 /**
  * returns the total number of items in the data set hold by the adapter.
  *
  * @return the total number of items in this adapter.
  */
 public abstract int getitemcount();

 /**
  * called when a view created by this adapter has been attached to a window.
  *
  * <p>this can be used as a reasonable signal that the view is about to be seen
  * by the user. if the adapter previously freed any resources in
  * {@link #onviewdetachedfromwindow(recyclerview.viewholder) onviewdetachedfromwindow}
  * those resources should be restored here.</p>
  *
  * @param holder holder of the view being attached
  */
 public void onviewattachedtowindow(vh holder) {
 }

 /**
  * called when a view created by this adapter has been detached from its window.
  *
  * <p>becoming detached from the window is not necessarily a permanent condition;
  * the consumer of an adapter's views may choose to cache views offscreen while they
  * are not visible, attaching an detaching them as appropriate.</p>
  *
  * @param holder holder of the view being detached
  */
 public void onviewdetachedfromwindow(vh holder) {
 }

 /**
  * register a new observer to listen for data changes.
  *
  * <p>the adapter may publish a variety of events describing specific changes.
  * not all adapters may support all change types and some may fall back to a generic
  * {@link android.support.v7.widget.recyclerview.adapterdataobserver#onchanged()
  * "something changed"} event if more specific data is not available.</p>
  *
  * <p>components registering observers with an adapter are responsible for
  * {@link #unregisteradapterdataobserver(recyclerview.adapterdataobserver)
  * unregistering} those observers when finished.</p>
  *
  * @param observer observer to register
  *
  * @see #unregisteradapterdataobserver(recyclerview.adapterdataobserver)
  */
 public void registeradapterdataobserver(adapterdataobserver observer) {
   mobservable.registerobserver(observer);
 }

 /**
  * unregister an observer currently listening for data changes.
  *
  * <p>the unregistered observer will no longer receive events about changes
  * to the adapter.</p>
  *
  * @param observer observer to unregister
  *
  * @see #registeradapterdataobserver(recyclerview.adapterdataobserver)
  */
 public void unregisteradapterdataobserver(adapterdataobserver observer) {
   mobservable.unregisterobserver(observer);
 }

 /**
  * called by recyclerview when it starts observing this adapter.
  * <p>
  * keep in mind that same adapter may be observed by multiple recyclerviews.
  *
  * @param recyclerview the recyclerview instance which started observing this adapter.
  * @see #ondetachedfromrecyclerview(recyclerview)
  */
 public void onattachedtorecyclerview(recyclerview recyclerview) {
 }

 /**
  * called by recyclerview when it stops observing this adapter.
  *
  * @param recyclerview the recyclerview instance which stopped observing this adapter.
  * @see #onattachedtorecyclerview(recyclerview)
  */
 public void ondetachedfromrecyclerview(recyclerview recyclerview) {
 }

 /**
  * notify any registered observers that the data set has changed.
  */
 public final void notifydatasetchanged() {
   mobservable.notifychanged();
 }

 /**
  * notify any registered observers that the item at <code>position</code> has changed.
  * equivalent to calling <code>notifyitemchanged(position, null);</code>.
  *
  * <p>this is an item change event, not a structural change event. it indicates that any
  * reflection of the data at <code>position</code> is out of date and should be updated.
  * the item at <code>position</code> retains the same identity.</p>
  *
  * @param position position of the item that has changed
  *
  * @see #notifyitemrangechanged(int, int)
  */
 public final void notifyitemchanged(int position) {
   mobservable.notifyitemrangechanged(position, 1);
 }

 /**
  * notify any registered observers that the item reflected at <code>fromposition</code>
  * has been moved to <code>toposition</code>.
  *
  * <p>this is a structural change event. representations of other existing items in the
  * data set are still considered up to date and will not be rebound, though their
  * positions may be altered.</p>
  *
  * @param fromposition previous position of the item.
  * @param toposition new position of the item.
  */
 public final void notifyitemmoved(int fromposition, int toposition) {
   mobservable.notifyitemmoved(fromposition, toposition);
 }
}

//根据需求，创建自定义样式的itemviw
 @override
 public viewholder oncreateviewholder(viewgroup viewgroup, int viewtype) {
   view view = layoutinflater.from(viewgroup.getcontext()).inflate(r.layout.item,viewgroup,false);
   viewholder vh = new viewholder(view);
   return vh;
 }

 //将数据与界面进行绑定的操作
 @override
 public void onbindviewholder(viewholder viewholder, int position) {
   viewholder.mtextview.settext(datas[position]);
 }

//获取数据的数量
 @override
 public int getitemcount() {
   return datas.length;
 }

 public interface onitemclicklistener {
    void itemclicklistener(view view,int postion);
    void itemlongclicklistener(view view,int postion);

  }

  if(mlistener!=null){//如果设置了监听那么它就不为空，然后回调相应的方法
      holder.itemview.setonclicklistener(new view.onclicklistener() {
        @override
        public void onclick(view v) {
          int pos = holder.getlayoutposition();//得到当前点击item的位置pos
          mlistener.itemclicklistener(holder.itemview,pos);//把事件交给我们实现的接口那里处理
        }
      });
      holder.itemview.setonlongclicklistener(new view.onlongclicklistener() {
        @override
        public boolean onlongclick(view v) {
          int pos = holder.getlayoutposition();//得到当前点击item的位置pos
          mlistener.itemlongclicklistener(holder.itemview,pos);//把事件交给我们实现的接口那里处理
          return true;
        }
      });
    }

  adapter=new myrecycleradapter(this, list);
   mrecycler.setadapter(adapter);
   adapter.setonclicklistener(new myrecycleradapter.onitemclicklistener() {
     @override
     public void itemclicklistener(view view, int postion) {
       toast.maketext(mainactivity.this,"点击了："+postion, toast.length_short).show();
     }

     @override
     public void itemlongclicklistener(view view, int postion) {
       list.remove(postion);
       adapter.notifyitemremoved(postion);
     }
   });