public @interface Demo{
  String value(); //方法的形式表示属性,没有默认值的话需要手动赋值
  String value2() default "helloWorld";
}
// 等价于,本质上是一个集成了Annotation接口的接口
interface Demo extends java.lang.annotation.Annotation{}

@Target(ElementType.Method)
@Retention(RetentionPolicy.RUNTIME)
public @interface Test{}

//Annotation
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ViewInject {  
    int value() default 0;  
}

//Activity
public void autoInjectAllField() {  
        try {  
            Class<?> clazz = this.getClass();  
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {  
                // 查看这个字段是否有我们自定义的注解类标志的  
                if (field.isAnnotationPresent(ViewInject.class)) {  
                    ViewInject inject = field.getAnnotation(ViewInject.class);  
                    int id = inject.value();  
                    if (id > 0) {  
                        field.setAccessible(true);  
                        field.set(this, this.findViewById(id));//给我们要找的字段设置值  
                    }  
                }  
            }  
        } catch (IllegalAccessException e) {  
            e.printStackTrace();  
        } catch (IllegalArgumentException e) {  
            e.printStackTrace();  
        }  
}

public class Toast {
    static final String TAG = "Toast";
    static final boolean localLOGV = false;

    /** @hide */
    /*定义部分*/
    @IntDef({LENGTH_SHORT, LENGTH_LONG})
    @Retention(RetentionPolicy.SOURCE)
    public @interface Duration {}

    public static final int LENGTH_SHORT = 0;
    public static final int LENGTH_LONG = 1;

    ...

    /*作为类型使用时*/
     /**
     * Set how long to show the view for.
     * @see #LENGTH_SHORT
     * @see #LENGTH_LONG
     */
    public void setDuration(@Duration int duration) {
        mDuration = duration;
    }

    /*做为返回值时*/
    /**
     * Return the duration.
     * @see #setDuration
     */
    @Duration
    public int getDuration() {
        return mDuration;
    }
}

/**
 * This method converts dp unit to equivalent pixels, depending on device density. 
 * 
 * @param dp A value in dp (density independent pixels) unit. Which we need to convert into pixels
 * @param context Context to get resources and device specific display metrics
 * @return A float value to represent px equivalent to dp depending on device density
 */
public static float convertDpToPixel(float dp, Context context){
    Resources resources = context.getResources();
    DisplayMetrics metrics = resources.getDisplayMetrics();
    float px = dp * ((float)metrics.densityDpi / DisplayMetrics.DENSITY_DEFAULT);
    return px;
}

/**
 * This method converts device specific pixels to density independent pixels.
 * 
 * @param px A value in px (pixels) unit. Which we need to convert into db
 * @param context Context to get resources and device specific display metrics
 * @return A float value to represent dp equivalent to px value
 */
public static float convertPixelsToDp(float px, Context context){
    Resources resources = context.getResources();
    DisplayMetrics metrics = resources.getDisplayMetrics();
    float dp = px / ((float)metrics.densityDpi / DisplayMetrics.DENSITY_DEFAULT);
    return dp;
}

public void draw(Canvas canvas) {
  . . . 
  // 绘制背景，只有dirtyOpaque为false时才进行绘制，下同
  int saveCount;
  if (!dirtyOpaque) {
    drawBackground(canvas);
  }

  . . . 

  // 绘制自身内容
  if (!dirtyOpaque) onDraw(canvas);

  // 绘制子View
  dispatchDraw(canvas);

   . . .
  // 绘制滚动条等
  onDrawForeground(canvas);

}

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 					    			    setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
}

public static int getDefaultSize(int size, int measureSpec) {
    int result = size;
    int specMode = MeasureSpec.getMode(measureSpec);
    int specSize = MeasureSpec.getSize(measureSpec);

    switch (specMode) {
    case MeasureSpec.UNSPECIFIED:
    	//getSuggestedMinimumWidth()
        result = size;
        break;
    case MeasureSpec.AT_MOST:
    	//子View为wrap_content时为父view的size
    case MeasureSpec.EXACTLY:
        result = specSize;
        break;
    }
    return result;
}

ViewConfiguratin.get(this).getScaledTouchSlop();

//init()
VelocityTracker velocityTracker = VelocityTracker.obtain();
velocityTracker.addMovement(event);

//int参数是以毫秒为单位的时间
velocityTracker.computeCurrentVelocity(int);
velocityTracker.getXVelocity();

//destroy()
velocityTracker.clear();
velocityTracker.recycle();

GestureDetector gestureDetector = new GestureDetector(new GestureDetector.OnGestureListener() {
    @Override
    public boolean onDown(MotionEvent e) {
        return false;
    }

    @Override
    public void onShowPress(MotionEvent e) {

    }

    @Override
    public boolean onSingleTapUp(MotionEvent e) {
        return false;
    }

    @Override
    public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
        return false;
    }

    @Override
    public void onLongPress(MotionEvent e) {

    }

    @Override
    public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
        return false;
    }
});

//add this to onTouchEvent
@Override
public boolean onTouchEvent(MotionEvent event) {
    boolean consume = mGestureDetector.onTouchEvent(event);
    return consume;
}

public class RoundImageView extends ImageView {

    private Region mClickRegion;

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        mWidth = w;
        mHeight = h;
        mRadius = Math.min(w, h) / 2;

        Path clickPath = new Path();
        clickPath.addCircle(mRadius, mRadius, mRadius, Path.Direction.CW);
      	//设定clickRegion，将其与View绑定
        mClickRegion.setPath(clickPath, new Region(0, 0, w, h));
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        int x = (int) event.getX();
        int y = (int) event.getY();
      	//判断交互事件是否在Region中
        return mClickRegion.contains(x, y) && super.onTouchEvent(event);
    }
}

//init()
Scroller mScroller = new Scroller(context);

//invoke
mScroller.startScroll(getScrollX(),getScrollY(),-50,-50);
invalidate();

//系统在draw()方法中调用此方法
//但因为其不会自动调用，所以需要invalidate()>draw()>computeScroll()
@Override
public void computeScroll(){
  if(mScroller.computeScrollOffset()){
    //true means has not finished
    ((View)getParent()).scrollTo(mScroller.getCurrX(),mScroller.getCurrY());
  	invalidate();
  }
}

mViewDraggerHelper = ViewDragHelper.create(this,callback);

@Override
public boolean onInterceptTouchEvent(MotionEvent ev){
  	return mViewDraggerHelper.shouldInterceptTouchEvent(ev);
}

@Override
public boolean onTouchEvent(MotionEvent event){
  	mViewDragHelper.processTouchEvent(event);
  	return true;
}

@Override
public void computeScroll(){
  	if(mViewDragHelper.continueSettling(true)){
      	ViewCompat.postInvalidateOnAnimation(this);
  	}
}

private ViewDragHelper.Callback callback = new ViewDragHelper.Callback(){

  	@Override
  	public boolean tryCaptureView(View child , int pointerId){
  		//指定哪一个子View可以被移动
      	return child == XXXView;
  	}
  	
  	//返回值为0，表示在该方向上不发生滑动
  	@Override
  	public int clampViewPositionVertical(View child,int top,int dy){
      	return top;
  	}
  	
  	@Override
  	public int clampViewPositinoHorizontal(View child,int left,int dx){
      	return left;
  	}
  	
  	//结束拖动后调用
  	@Override
  	public void onViewReleased(View releasedChild,float xvel,float yvel){
      	super.onViewReleased(releasedChild,xvel,yvel);
      	if(mMainView.getLeft()<500){
          	mViewDragHelper.smoothSlideViewTo(mMainView,0,0);
          	ViewCompat.postInvalidateOnAnimation(this);
      	}
  	}
}

static final int PFLAG_FOCUSED = 0x00000002;
int mPrivateFlags;
public boolean hasFocus() {
        return (mPrivateFlags & PFLAG_FOCUSED) != 0;
}

public static final int MASK = 0x00000006;
public static final int FLAG_A = 0x00000000;
public static final int FLAG_B = 0x00000002;
public static final int FLAG_C = 0x00000004;

static class ListenerInfo {
       protected OnCreateContextMenuListener mOnCreateContextMenuListener;

       ************

       private OnSystemUiVisibilityChangeListener mOnSystemUiVisibilityChangeListener;

       OnApplyWindowInsetsListener mOnApplyWindowInsetsListener;
   }

   ListenerInfo mListenerInfo;

/**
* Returns the width of the vertical scrollbar.
*
* @return The width in pixels of the vertical scrollbar or 0 if there
*         is no vertical scrollbar.
*/
public int getVerticalScrollbarWidth() {
    ScrollabilityCache cache = mScrollCache;
    if (cache != null) {
        ScrollBarDrawable scrollBar = cache.scrollBar;
        if (scrollBar != null) {
            int size = scrollBar.getSize(true);
            if (size <= 0) {
                size = cache.scrollBarSize;
            }
            return size;
        }
        return 0;
    }
    return 0
}

new Thread(new Runnable(){
	@Override
	public void run(){
		Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
		// do sth
	}
}).start();

Lock mLock = new ReentrantLock();
mlock.lock();
try{
    //...
}finally{
  	mlock.unlock();
}

// 条件对象
Condition condition = mLock.newCondition();
// 阻塞当前进程，并放弃锁(收到signalAll后再次获得锁)
condition.await();
condition.signalAll();

public static final void prepare(){
	if(sThreadLocal.get()!=null){
		throw new RuntimeException("Only one Looper may be created per thread");
	}
  	//关于ThreadLocal的介绍，放在文章末尾，此处可以理解为一个referfence，可以set和get
	sThreadLocal.set(new Looper());
}

HandlerThread handlerThread = new HandlerThread("thread_name");
handlerThread.start();
//MyHandler extends android.os.Handler
mHandler = new MyHandler(handlerThread.getLooper());

public static Executor THREAD_POOL_EXECUTOR
		= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
		TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

//execute
THREAD_POOL_EXECUTOR.execute(Runnable XX);

public interface Sequence{
	int getNumber();
}

public class SequenceByThreadLocal implements Squence{
	private static ThreadLocal<Integer> numberContainer = new ThreadLocal<Integer>(){
		@Override
		protected Integer initialValue(){
			return 0;
		}
	};

	public int getNumber(){
		numberContainer.set(numberContainer.get()+1);
		return numberContainer.get();
	}
}

public class MyThreadLocal<T>{
	private Map<Thread,T> container = Collections.synchronizedMap(new HashMap<Thread,T>());

	public void set(T vaule){
		container.put(Thread.currentThread(),value);
	}

	public T get(){
		Thread thread = Thread.currentThread();
		T value = container.get(thread);
		if(value == null &&　!container.containsKey(key){
			valuee = initValue();
			container.put(thread,value);
		}
		return value;
	}

	public void remove(){
		container.put(Thread.currentThread());
	}

	protected T initialValue(){
		return null;
	}
}

@Override
public void getItemOffsets(Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
        super.getItemOffsets(outRect, view, parent, state);
        int position = ((RecyclerView.LayoutParams))
          view.getLayoutParams()).getViewAdapterPosition();
        outRect.set(0, mList.containsKey(position) ? mTitleHeight : 0, 0, 0);
    }

@Override
    public void onDraw(Canvas c, RecyclerView parent, RecyclerView.State state) {
        super.onDraw(c, parent, state);
        final int left = parent.getPaddingLeft();
        final int right = parent.getWidth() - parent.getPaddingRight();
        final int childCount = parent.getChildCount();
        for (int i = 0; i < childCount; i++) {
            final View child = parent.getChildAt(i);
            final RecyclerView.LayoutParams params = 
            	(RecyclerView.LayoutParams) child.getLayoutParams();
            int position = params.getViewAdapterPosition();
            if (!mList.containsKey(position)) {
                continue;
            }
            drawTitleArea(c, left, right, child, params, position);
        }
    }

@Override
public void onDrawOver(Canvas c, RecyclerView parent, RecyclerView.State state) {
    	super.onDrawOver(c, parent, state);
        final int position = ((LinearLayoutManager) parent.getLayoutManager()).findFirstVisibleItemPosition();
        if (position == RecyclerView.NO_POSITION) {
            return;
        }
        View child = parent.findViewHolderForAdapterPosition(position).itemView;
        String initial = getTag(position);
        if (initial == null) {
            return;
        }

  		//flag指示当标题栏是否发生碰撞（如开头gif图中指示的）
        boolean flag = false;
        if (getTag(position + 1) != null && !initial.equals(getTag(position + 1))) {
            if (child.getHeight() + child.getTop() < mTitleHeight) {
              	//与restore()对应，表示下面translate平移坐标系只对绘制当前标题栏生效
                c.save();
                flag = true;
              	//translate使发生碰撞时，两个标题栏紧贴，制造出挤开的效果（dy<0,表示绘制偏下）
                c.translate(0, child.getHeight() + child.getTop() - mTitleHeight);
            }
        }

        c.drawRect(parent.getPaddingLeft(), parent.getPaddingTop(),
                parent.getRight() - parent.getPaddingRight(), parent.getPaddingTop() + mTitleHeight, mBackgroundPaint);
        c.drawText(initial, child.getPaddingLeft() + mTextStartMargin,
                parent.getPaddingTop() + mTitleHeight - (mTitleHeight - mTextHeight) / 2 - mTextBaselineOffset, mTextPaint);

        if (flag) {
            c.restore();
        }
    }

Paint.FontMetrics fm = mPaint.getFontMetrics();
float singleHeight = fm.bottom - fm.top + fm.leading;

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    setMeasuredDimension(measureWidth(widthMeasureSpec), measureHeight(heightMeasureSpec));
}

private int measureWidth(int widthMeasureSpec) {
    int result;
    int specMode = MeasureSpec.getMode(widthMeasureSpec);
    int specSize = MeasureSpec.getSize(widthMeasureSpec);
    if (specMode == MeasureSpec.EXACTLY) {
        result = specSize;
    } else {
        result = getSuggestedMinWidth();
        if (specMode == MeasureSpec.AT_MOST) {
            result = Math.min(result, specSize);
        }
    }
    return result;
}

//获取建议的最小宽度，尽量保证不会出现显示不下的情况（极端情况下仍会显示不下）
private int getSuggestedMinWidth() {
    String maxLengthTag = "";
    for (String tag : mNavigators) {
        if (maxLengthTag.length() < tag.length()) {
            maxLengthTag = tag;
        }
    }
    return (int) (mPaint.measureText(maxLengthTag) + 0.5);
}

private int measureHeight(int heightMeasureSpec) {
    int result;
    int specMode = MeasureSpec.getMode(heightMeasureSpec);
    int specSize = MeasureSpec.getSize(heightMeasureSpec);
    if (specMode == MeasureSpec.EXACTLY) {
        result = specSize;
    } else {
        Paint.FontMetrics fm = mPaint.getFontMetrics();
        float singleHeight = fm.bottom - fm.top + fm.leading;
      	//这个mLetterSpacingExtra是疏密程度，是自定义属性，默认1.4
        mBaseLineHeight = fm.bottom * mLetterSpacingExtra;
        result = (int) (mNavigators.size() * singleHeight * mLetterSpacingExtra);
        if (specMode == MeasureSpec.AT_MOST) {
            result = Math.min(result, specSize);
        }
    }
    return result;
}

protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        int height = getHeight();
        int width = getWidth();
  		//高度为0，可能是因为传入参数为空，则不予显示
        if (height == 0) {
            return;
        }
        int singleHeight = height / mNavigators.size();

  		//遍历绘制Text
        for (int i = 0; i < mNavigators.size(); i++) {
            float xPos = width / 2 - mPaint.measureText(mNavigators.get(i)) / 2;
            float yPos = singleHeight * (i + 1);
            if (i == mFocusIndex) {
                canvas.drawText(mNavigators.get(i), xPos, yPos - mBaseLineHeight, mFocusPaint);
            } else {
                canvas.drawText(mNavigators.get(i), xPos, yPos - mBaseLineHeight, mPaint);
            }
        }
    }

@Override
    public boolean dispatchTouchEvent(MotionEvent event) {
        final float y = event.getY();
        final int formerFocusIndex = mFocusIndex;
        final OnTouchingLetterChangeListener listener = mOnTouchingLetterChangeListener;
        final int c = calculateOnClickItemNum(y);

        switch (event.getAction()) {
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_CANCEL:
                mFocusIndex = -1;
                invalidate();
                listener.onTouchingEnd(mNavigators.get(c));
                break;
            case MotionEvent.ACTION_DOWN:
                listener.onTouchingStart(mNavigators.get(c));
            default:
                if (formerFocusIndex != c) {
                    if (c >= 0 && c < mNavigators.size()) {
                        listener.onTouchingLetterChanged(mNavigators.get(c));
                        mFocusIndex = c;
                        invalidate();
                    }
                }
                break;
        }
        return true;
    }

    /**
     * @param yPos
     * @return the corresponding position in list
     */
    private int calculateOnClickItemNum(float yPos) {
        int result;
      	//计算当前触摸点属于哪个TAG,超出边界按照边界值返回（尤其在MOVE的时候很容易滑出边界）
        result = (int) (yPos / getHeight() * mNavigators.size());
        if (result >= mNavigators.size()) {
            result = mNavigators.size() - 1;
        } else if (result < 0) {
            result = 0;
        }
        return result;
    }

   //GB2312中简体中文的起止，判断范围
private static int BEGIN = 45217;
   private static int END = 63486;

   /**
    * 各声母第一个汉字
    * {i、u、v} 不做声母
    */
   private static char[] CHAR_TABLE = {'啊', '芭', '擦', '搭', '蛾', '发', '噶', '哈', '击', '喀', '垃','妈', '拿', '哦', '啪', '期', '然', '撒', '塌', '挖', '昔', '压', '匝'};

   private static char[] INITIAL_TABLE = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K','L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'W', 'X', 'Y', 'Z'};

//此table是各声母对应的起始GB值，与initialtable对应
   private static int[] BORDER = new int[chartable.length + 1];

   static {
       for (int i = 0; i < CHAR_TABLE.length; i++) {
           BORDER[i] = gbValue(CHAR_TABLE[i]);
       }
       BORDER[CHAR_TABLE.length] = END;
   }
   
//计算char对应的gb值
   private static int gbValue(char ch) {
       String str = "" + ch;
       try {
           byte[] bytes = str.getBytes("GB2312");
           if (bytes.length < 2) {
               return 0;
           }
           return (bytes[0] << 8 & 0xff00) + (bytes[1] & 0xff);
       } catch (Exception e) {
           return 0;
       }
   }

@NonNull
   public static ArrayList<ShareContactsBean> getPhoneContacts(Context mContext) {
       ArrayList<ShareContactsBean> result = new ArrayList<>(0);
       ContentResolver resolver = mContext.getContentResolver();
       Cursor phoneCursor = resolver.query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
               new String[]{ContactsContract.CommonDataKinds.Phone.NUMBER, ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME}, null, null, null);
       if (phoneCursor != null) {
           while (phoneCursor.moveToNext()) {
               String phoneNumber = 
                 phoneCursor.getString(0)
                 	.replace(" ", "")
                 	.replace("-", "");
               String contactName = phoneCursor.getString(1);
               result.add(new ShareContactsBean(contactName, phoneNumber));
           }
           phoneCursor.close();
       }
	//对结果进行排序，这个排序方法写在bean中
       Collections.sort(result, new Comparator<ShareContactsBean>() {
           @Override
           public int compare(ShareContactsBean l, ShareContactsBean r) {
               return l.compareTo(r);
           }
       });
       return result;
   }

Fragment fragment = new Fragment();
FragmentTransaction transaction = getFragmentManager().beginTransaction();
transaction.replace(R.id.fragment_container,fragment)
  .addToBackStack()
  .commit();

/**
*ActivityA中嵌一个FragmentA，
*如果此时启动ActivityB，且ActivityA因为内存不足或其他原因被回收的时候，
*从B回到A，会回调这样的生命周期：
*/

ActivityB.onPause();

ActivityA.onCreate();
FragmentA.onAttach();
ActivityA.onAttachFragment();
FragmentA.onCreate();
FragmentA.onViewCreated();
ActivityA.onStart();
FragmentA.onStart();
ActivityA.onRestoreInstanceState();
ActivityA.onResume();
FragmentA.onResume();

ActivityB.onStop();
ActivityB.onDestroy();

/**
*ActivityA中嵌一个FragmentA，
*按下home，且ActivityA因为内存不足或其他原因被回收的时候，
*从屏幕回到A，会回调这样的声明周期：
*/

ActivityA.onCreate();
FragmentA.onAttach();
FragmentA.onCreate();
ActivityA.onStart();
FragmentA.onStart();
ActivityA.onResume();
FragmentA.onResume();

@Override
protected void onCreate(Bundle savedInstanceState){
  	//todo
  	
  	if(savedInstanceState != null){
  		//可以使用getFragments()获取栈内所有Fragment
      	getFragemntManager().beginTransaction().show(XX).hide(XX).commit();
  	}
  	
}

/**
*	在onSaveInstanceState()
* 	android.support.v4.app.Fragment#onStop
*/
private void checkStateLoss(){
  	if (mStateSaved) {
        throw new IllegalStateException(
                    "Can not perform this action after onSaveInstanceState");
    }
    if (mNoTransactionsBecause != null) {
        throw new IllegalStateException(
                    "Can not perform this action inside of " + mNoTransactionsBecause);
    
}

intent.setDataAndType(Uri.parse("file://abc"),"text/plain");
//获取隐式intent匹配情况
//PackageManager
public abstract List<ResolveInfo> queryIntentActivities(Intent intent,int flags);
//Intent
public abstract ResolveInfo resolveActivity(Intent intent,int flags);
//这里flag使用MATCH_DEFAULT_ONLY标记位，仅仅匹配带有DEFAULT的activity

public ArrayList<String> queryInstalledMarketPkgs(Context context) {
    ArrayList<String> pkgs = new ArrayList<String>();
    if (context == null)
        return pkgs;
    Intent intent = new Intent();
    intent.setAction("android.intent.action.MAIN");
    intent.addCategory("android.intent.category.APP_MARKET");
    PackageManager pm = context.getPackageManager();
    List<ResolveInfo> infos = pm.queryIntentActivities(intent, 0);
    if (infos == null || infos.size() == 0)
        return pkgs;
    int size = infos.size();
    for (int i = 0; i < size; i++) {
        String pkgName = "";
        try {
            ActivityInfo activityInfo = infos.get(i).activityInfo;
            pkgName = activityInfo.packageName;
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (!TextUtils.isEmpty(pkgName))
            pkgs.add(pkgName);

    }
    return pkgs;
}

// 评分
private void tryToGradeApp(){
  	List<String> packages;
    if(mContext==null) return;
    packages= Utils.queryInstalledMarketPkgs(mContext);

    if(null == packages || 0 == packages.size()){
        Toast.makeText(mContext,"Do not find any installed market in your phone.",Toast.LENGTH_SHORT).show();
        return;
    }

    String appName = mContext.getPackageName();
    Uri uri = Uri.parse("market://details?id=" + appName);
    Intent intent = new Intent(Intent.ACTION_VIEW, uri);

    mContext.startActivity(intent);
}

// 自定义View的状态存储一般模式

@Override
public Parcelable onSaveInstanceState() {
    return new MySavedState(super.onSaveInstanceState(), mFlag);
}

@Override
public void onRestoreInstanceState(Parcelable state) {
    if (!(state instanceof MySavedState)) {
        super.onRestoreInstanceState(state);
        return;
    }
    MySavedState myState = (MySavedState) state;
    super.onRestoreInstanceState(myState.savedState);
    mFlag = myState.flag;
}

private static class MySavedState implements Parcelable {
		// 父类的SavedState
        Parcelable savedState;
        // 本类自己的属性
        boolean flag;

        MySavedState(Parcelable savedState, boolean flag) {
            this.savedState = savedState;
            this.flag = flag;
        }
 }

public class ActivityWithFragment{
  	@Override
  	@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.XXX);

        Fragment fragment = getSupportFragmentManager().findFragmentById(R.id.contentFrame);
        if (fragment == null) {
            // Create the fragment
            fragment = TasksFragment.newInstance();
            ActivityUtils.addFragmentToActivity(
                    getSupportFragmentManager(), fragment, R.id.contentFrame);
        }


        // Load previously saved state, if available.
        if (savedInstanceState != null) {
            TasksFilterType currentFiltering =
                    (TasksFilterType) savedInstanceState.getSerializable(CURRENT_FILTERING_KEY);
            mTasksPresenter.setFiltering(currentFiltering);
        }
    }
}

//ActivityA
startActivity(intent,ActivityOptions.makeSceneTransitionAnimation(this).toBundle());

//ActivityB先声明后设置
A在代码中声明
getWindow().requestFeature(Window.FEATURE_CONTENT_TRANSITIONS);
B在xml中声明
<item name="android:windowContentTransitions">true</item>

具体设置:
getWindow().setEnterTransition(new Explode());
getWindow().setExitTransition(new Slide());

在ActivityA和ActivityB中同时定义
android:transitionName="XXX"

如果只需要一个共享元素，可以在ActivityA中：
startActivity(intent,ActivityOptions.makeSceneTransitionAnimation(this,view,"share").toBundle());

如果需要多个共享元素
startActivity(intent,
    ActivityOptions.makeSceneTransitionAnimation(
        this,
        Pair.Create(view,"share"),Pair.create(fab,"fab")
    ).toBundle()
);