原创内容，转载请注明原文网址：http://homeqin.cn/a/wenzhangboke/jishutiandi/Android/2019/1013/677.html
1、Fragment的发生与常州游戏开发培训介绍
Android运转在种种百般的建筑中，有小屏幕的手机，超大屏的平板乃至电视。针对屏幕尺寸的差距，许多情况下，都是先针对手机开辟一套App，然后拷贝一份，点窜布局以顺应平板神马超级大屏的。岂非无法做到一个App能够同时顺应手机和平板么，固然了，必需有啊。Fragment的发现即是为打听决这样的题目。你能够把Fragment当做Activity的一个界面的一个组成片面，乃至Activity的界面能够彻底有不同的Fragment组成，更帅气的是Fragment领有本人的性命周期和汲取、处理用户的事件，这样就无谓在Activity写一堆控件的事件处理的代码了。更为紧张的是，你能够动静的增加、替代和移除某个Fragment。
2、Fragment的性命周期
Fragment必需是依存与Activity而存在的，是以Activity的性命周期会干脆影响到Fragment的性命周期。官网这张图非常好的分析了两者性命周期的关系：
能够看到Fragment比Activity多了几个分外的性命周期回调技巧：
onAttach(Activity)
当Fragment与Activity发生相关时调用。
onCreateView(LayoutInflater, ViewGroup,Bundle)
建立该Fragment的视图
onActivityCreated(Bundle)
当Activity的onCreate技巧返回时调用
onDestoryView()
与onCreateView想对应，当该Fragment的视图被移除时调用
onDetach()
与onAttach相对应，当Fragment与Activity相关被作废时调用
留意：除了onCreateView，其余的全部技巧要是你重写了，必需调用父类对于该技巧的实现，
3、静态的使用Fragment
这是手机App外包使用Fragment非常简单的一种方法，把Fragment当做一般的控件，干脆写在Activity的布局文件中。步骤：
1、秉承Fragment，将响应的布局文件和Fragment绑定，代码编写控制逻辑
2、主布局文件内部增加曾经控制逻辑的fragment
复制代码
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent" >
<fragment
android:id="@+id/id_fragment_title"
android:name="com.example.androidexpriment.TitleFragment"
android:layout_width="fill_parent"
android:layout_height="45dp" />
<fragment
android:layout_below="@id/id_fragment_title"
android:id="@+id/id_fragment_content"
android:name="com.example.androidexpriment.ContentFragment"
android:layout_width="fill_parent"
android:layout_height="fill_parent" />
</RelativeLayout>
复制代码
是不是把Fragment当做一般的View同样申明在Activity的布局文件中，然后全部控件的事件处理等代码都由各自的Fragment去向理，瞬间以为Activity好干净有木有~~代码的可读性、复用性以及可保护性是不是瞬间提升了。
4、Fragment家属常用的API
Fragment常用的三个类：
android.app.Fragment 要紧用于定义Fragment
android.app.FragmentManager 要紧用于在Activity中操纵Fragment
android.app.FragmentTransaction 保证少许列Fragment操纵的原子性，谙习事务这个词，一定能清楚~
a、获得FragmentManage的方法：
getFragmentManager() // v4中，getSupportFragmentManager
b、要紧的操纵都是FragmentTransaction的技巧
FragmentTransaction transaction = fm.benginTransatcion();//开启一个事务
transaction.add()
往Activity中增加一个Fragment
transaction.remove()
从Activity中移除一个Fragment，要是被移除的Fragment没有增加到回退栈（回退栈背面会详细说），这个Fragment实例将会被烧毁。
transaction.replace()
使用另一个Fragment替代目前的，现实上即是remove()然后add()的合体~
transaction.hide()
潜藏目前的Fragment，仅仅是设为不可见，并不会烧毁
transaction.show()
表现之前潜藏的Fragment
detach()
会将view从UI中移除,和remove()不同,此时fragment的状况仍然由FragmentManager保护。
attach()
重修view视图，附加到UI上并表现。
transatcion.commit()//提交一个事务
留意：常用Fragment的哥们，大约会时常碰到这样Activity状况不一致：State loss这样的错误。要紧是由于：commit技巧一定要在Activity.onSaveInstance()之前调用。
上述，根基是操纵Fragment的全部的方法了，在一个事务开启到提交能够进行多个的增加、移除、替代等操纵。
值得留意的是：要是你稀饭使用Fragment，一定要清楚这些技巧，哪一个会烧毁视图，哪一个会烧毁实例，哪一个仅仅只是潜藏，这样才气更好的使用它们。
a、好比：我在FragmentA中的EditText填了少许数据，当切换到FragmentB时，要是有望会到A还能看到数据，则适用你的即是hide和show；也即是说，有望保存用户操纵的面板，你能够使用hide和show，固然了不要用力在那new实例，进行下非null校验。
b、再好比：我不有望保存用户操纵，你能够使用remove()，然后add()；大约使用replace()这个和remove,add是相像的结果。
c、remove和detach有一点细微的差别，在不思量回退栈的情况下，remove会烧毁全部Fragment实例，而detach则只是烧毁其视图布局，实例并不会被烧毁。辣么二者怎么弃取使用呢？要是你确目前Activity连续存在，辣么在不有望保存用户操纵的时分，你能够优先使用detach。
5、动静的使用Fragment
上头曾经演示了，非常简单的使用Fragment的方法~底下介绍若何动静的增加、更新、以及删除Fragment
activity_main.xml
复制代码
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="#ccc444">
<FrameLayout
android:id="@+id/id_content"
android:layout_width="fill_parent"
android:layout_height="fill_parent" >
</FrameLayout>
</RelativeLayout>
复制代码
MainActivity.java
复制代码
package com.example.androidexpriment;
import android.app.Activity;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.view.Window;
public class MainActivity extends Activity
{
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.activity_main);
FragmentManager fm = getFragmentManager();
FragmentTransaction tx = fm.beginTransaction();
tx.add(R.id.id_content, new FragmentOne(),"ONE");
tx.commit();
}
}
复制代码
很简单，干脆将FragmentOne增加到布局文件中的FrameLayout中，留意这里并无调用FragmentTransaction.addToBackStack(String)，而是将back按钮的控制逻辑放在fragment中实行
底下是FragmentOne
fragment_one.xml
复制代码
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="#ffffff"
android:orientation="vertical" >
<Button
android:id="@+id/id_fragment_one_btn"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="3dp"
android:layout_gravity="center"/>
<EditText
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:textColor="#333333"
android:textSize="20sp" />
</LinearLayout>
复制代码
FragmentOne.java
复制代码
package com.example.androidexpriment;
import android.app.Fragment;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;
public class FragmentOne extends Fragment implements OnClickListener
{
private Button mBtn;
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState)
{
View view = inflater.inflate(R.layout.fragment_one, container, false);
mBtn = (Button) view.findViewById(R.id.id_fragment_one_btn);
mBtn.setOnClickListener(this);
return view;
}
@Override
public void onClick(View v)
{
FragmentTwo fTwo = new FragmentTwo();
FragmentManager fm= getFragmentManager();
FragmentTransaction tx= fm.beginTransaction();
tx.replace(R.id.id_content, fTwo, "TWO");
tx.addToBackStack(null);
tx.commit();
}
}
复制代码
咱们在点击FragmentOne中的按钮时，使用了replace技巧，要是你看了前一篇博客，一定记得replace是remove和add的合体，而且要是不增加事务到回退栈，前一个Fragment实例会被烧毁。这里很明显，咱们调用tx.addToBackStack(null);将目前的事务增加到了回退栈，以是FragmentOne实例不会被烧毁，但是视图档次仍然会被烧毁，即会调用onDestoryView和onCreateView，证据即是：周密看上头的结果图，咱们在跳转前在文本框输入的内容，在用户Back得到第一个界面的时分不见了。
插曲：replace()技巧能够经历remove,add结合到达相像的结果。
tx.remove(fm.findFragmentById(R.layout.fragment_one));//error
// tx.remove(getTargetFragment());//error
tx.remove(fm.findFragmentByTag("ONE"));//right
tx.add(R.id.id_content,fTwo);
使用前两种技巧都会报空指针的错误。
java.lang.NullPointerException: Attempt to write to field 'int android.app.Fragment.mNextAnim' on a null object reference
一首先想经历查找源码的方法办理，在BackStackRecord.java中发现几种操纵技巧，mNextAnim的赋值要紧在
f.mNextAnim = op.enterAnim;
f.mNextAnim = op.exitAnim;
复制代码
1 public void run() {
2 if (FragmentManagerImpl.DEBUG) Log.v(TAG, "Run: " + this);
3
4 if (mAddToBackStack) {
5 if (mIndex < 0) {
6 throw new IllegalStateException("addToBackStack() called after commit()");
7 }
8 }
9
10 bumpBackStackNesting(1);
11
12 Op op = mHead;
13 while (op != null) {
14 switch (op.cmd) {
15 case OP_ADD: {
16 Fragment f = op.fragment;
17 f.mNextAnim = op.enterAnim;
18 mManager.addFragment(f, false);
19 } break;
20 case OP_REPLACE: {
21 Fragment f = op.fragment;
22 if (mManager.mAdded != null) {
23 for (int i=0; i<mManager.mAdded.size(); i++) {
24 Fragment old = mManager.mAdded.get(i);
25 if (FragmentManagerImpl.DEBUG) Log.v(TAG,
26 "OP_REPLACE: adding=" + f + " old=" + old);
27 if (f == null || old.mContainerId == f.mContainerId) {
28 if (old == f) {
29 op.fragment = f = null;
30 } else {
31 if (op.removed == null) {
32 op.removed = new ArrayList<Fragment>();
33 }
34 op.removed.add(old);
35 old.mNextAnim = op.exitAnim;
36 if (mAddToBackStack) {
37 old.mBackStackNesting += 1;
38 if (FragmentManagerImpl.DEBUG) Log.v(TAG, "Bump nesting of "
39 + old + " to " + old.mBackStackNesting);
40 }
41 mManager.removeFragment(old, mTransition, mTransitionStyle);
42 }
43 }
44 }
45 }
46 if (f != null) {
47 f.mNextAnim = op.enterAnim;
48 mManager.addFragment(f, false);
49 }
50 } break;
51 case OP_REMOVE: {
52 Fragment f = op.fragment;
53 f.mNextAnim = op.exitAnim;
54 mManager.removeFragment(f, mTransition, mTransitionStyle);
55 } break;
56 case OP_HIDE: {
57 Fragment f = op.fragment;
58 f.mNextAnim = op.exitAnim;
59 mManager.hideFragment(f, mTransition, mTransitionStyle);
60 } break;
61 case OP_SHOW: {
62 Fragment f = op.fragment;
63 f.mNextAnim = op.enterAnim;
64 mManager.showFragment(f, mTransition, mTransitionStyle);
65 } break;
66 case OP_DETACH: {
67 Fragment f = op.fragment;
68 f.mNextAnim = op.exitAnim;
69 mManager.detachFragment(f, mTransition, mTransitionStyle);
70 } break;
71 case OP_ATTACH: {
72 Fragment f = op.fragment;
73 f.mNextAnim = op.enterAnim;
74 mManager.attachFragment(f, mTransition, mTransitionStyle);
75 } break;
76 default: {
77 throw new IllegalArgumentException("Unknown cmd: " + op.cmd);
78 }
79 }
80
81 op = op.next;
82 }
83
84 mManager.moveToState(mManager.mCurState, mTransition,
85 mTransitionStyle, true);
86
87 if (mAddToBackStack) {
88 mManager.addBackStackState(this);
89 }
90 }
复制代码
遵照报错信息查找——>FragmentManager.execPendingActions 1454
留意源码中的FragmentManager是个空洞类，真正发挥用途的是FragmentManagerImpl
final class FragmentManagerImpl extends FragmentManager
在Fragment中，FragmentManager fm= getFragmentManager();
在源码中
FragmentManagerImpl mFragmentManager;
final public FragmentManager getFragmentManager() {
return mFragmentManager;
}
同样FragmentTransaction也是个空洞类
final class BackStackRecord extends FragmentTransaction implements
FragmentManager.BackStackEntry, Runnable ｛
｝
FragmentTransaction tx= fm.beginTransaction();实在源码中是这样的
@Override
public FragmentTransaction beginTransaction() {
return new BackStackRecord(this);
}
为何
f.mNextAnim = NULL
源码扯的很深，报错实在非常好明白，你惟有曾经add过的Fragment，你才能够remove。而在主Activity tx.add(R.id.id_content, new FragmentOne(),"ONE");，经历布局文件找fragment必定是不可取的，由于一个布局能够例化出多个fragmetn，以是为了能找到建立的Fragment，保举加上Tag。
接下来FragmentTwo
布局文件：
复制代码
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >
<Button
android:id="@+id/id_fragment_two_btn"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center"
/>
<EditText
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:gravity="center"
android:textSize="20sp"
android:textStyle="bold" />
</LinearLayout>
复制代码
复制代码
package com.example.androidexpriment;
import android.app.Fragment;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;
public class FragmentTwo extends Fragment implements OnClickListener
{
private Button mBtn ;
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState)
{
View view = inflater.inflate(R.layout.fragment_two, container, false);
mBtn = (Button) view.findViewById(R.id.id_fragment_two_btn);
mBtn.setOnClickListener(this);
return view ;
}
@Override
public void onClick(View v)
{
FragmentThree fThree = new FragmentThree();
FragmentManager fm = getFragmentManager();
FragmentTransaction tx = fm.beginTransaction();
tx.hide(this);
tx.add(R.id.id_content , fThree, "THREE");
// tx.replace(R.id.id_content, fThree, "THREE");
tx.addToBackStack(null);
tx.commit();
}
}
复制代码
这里点击时，咱们没有使用replace，而是先潜藏了目前的Fragment，然后增加了FragmentThree的实例，非常后将事务增加到回退栈。这样做的目标是为了给大家提供一种方案：要是不有望视图重绘该怎么做，请再次周密看结果图，咱们在FragmentTwo的EditText填写的内容，用户Back回归时，数据还在~~~
非常后FragmentThree即是简单的Toast了：
复制代码
package com.example.androidexpriment;
import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.Toast;
public class FragmentThree extends Fragment implements OnClickListener
{
private Button mBtn;
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState)
{
View view = inflater.inflate(R.layout.fragment_three, container, false);
mBtn = (Button) view.findViewById(R.id.id_fragment_three_btn);
mBtn.setOnClickListener(this);
return view;
}
@Override
public void onClick(View v)
{
Toast.makeText(getActivity(), " i am a btn in Fragment three",
Toast.LENGTH_SHORT).show();
}
}
复制代码
好了，经由上头的介绍，应该曾经晓得Fragment回退栈是怎么一回事了，以及hide，replace等各自的运用的场景。
这里极端留意一点：上头的整体代码不具备任何参考代价，纯粹为了表现回退栈，在背面疏解了Fragment与Activity通讯以后，会重构上头的代码！
2、Fragment与Activity通讯
由于全部的Fragment都是倚赖于Activity的，以是通讯起来并不复杂，大约归纳为：
a、要是你Activity中包含本人经管的Fragment的援用，能够经历援用干脆走访全部的Fragment的public技巧
b、要是Activity中未留存任何Fragment的援用，辣么没关系，每个Fragment都有一个唯独的TAG大约ID,能够经历getFragmentManager.findFragmentByTag()获得任何Fragment实例，然后进行操纵。
c、在Fragment中能够经历getActivity得到目前绑定的Activity的实例，然后进行操纵。
注：要是在Fragment中需求Context，能够经历调用getActivity(),要是该Context需求在Activity被烧毁后还存在，则使用getActivity().getApplicationContext()。
3、Fragment与Activity通讯的非常好现实
由于要思量Fragment的重叠使用，以是必需低落Fragment与Activity的耦合，而且Fragment更不应该干脆操纵别的Fragment，毕竟Fragment操纵应该由它的经管者Activity来决意。
底下App开发培训我经历两种方法的代码，划分重构，FragmentOne和FragmentTwo的点击事件，以及Activity对点击事件的响应：
首先看FragmentOne
复制代码
package com.example.androidexpriment;
import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;
public class FragmentOne extends Fragment implements OnClickListener
{
private Button mBtn;
/**
* 配置按钮点击的回调
* @author zhy
*
*/
public interface FOneBtnClickListener
{
void onFOneBtnClick();
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState)
{
View view = inflater.inflate(R.layout.fragment_one, container, false);
mBtn = (Button) view.findViewById(R.id.id_fragment_one_btn);
mBtn.setOnClickListener(this);
return view;
}
/**
* 交给宿主Activity处理，要是它有望处理
*/
@Override
public void onClick(View v)
{
if (getActivity() instanceof FOneBtnClickListener)
{
((FOneBtnClickListener) getActivity()).onFOneBtnClick();
}
}
}
复制代码
能够看到现在的FragmentOne反面任何Activity耦合，任何Activity都能够使用；而且咱们申明了一个接口，往返调其点击事件，想要经管其点击事件的Activity实现此接口就即可。能够看到咱们在onClick中首先校验了目前绑定的Activity是否实现了该接口，要是实现了则调用。
再看FragmentTwo
复制代码
package com.example.androidexpriment;
import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;
public class FragmentTwo extends Fragment implements OnClickListener
{
private Button mBtn ;
private FTwoBtnClickListener fTwoBtnClickListener ;
public interface FTwoBtnClickListener
{
void onFTwoBtnClick();
}
//配置回调接口
public void setfTwoBtnClickListener(FTwoBtnClickListener fTwoBtnClickListener)
{
this.fTwoBtnClickListener = fTwoBtnClickListener;
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState)
{
View view = inflater.inflate(R.layout.fragment_two, container, false);
mBtn = (Button) view.findViewById(R.id.id_fragment_two_btn);
mBtn.setOnClickListener(this);
return view ;
}
@Override
public void onClick(View v)
{
if(fTwoBtnClickListener != null)
{
fTwoBtnClickListener.onFTwoBtnClick();
}
}
}
复制代码
与FragmentOne极端相似，但是咱们提供了setListener这样的技巧，意味着Activity不但需求实现该接口，还必需表现调用mFTwo.setfTwoBtnClickListener(this)。
非常后看Activity :
复制代码
package com.example.androidexpriment;
import com.example.androidexpriment.FragmentOne.FOneBtnClickListener;
import com.example.androidexpriment.FragmentTwo.FTwoBtnClickListener;
import android.app.Activity;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.view.Window;
public class MainActivity extends Activity implements FOneBtnClickListener,
FTwoBtnClickListener
{
private FragmentOne mFOne;
private FragmentTwo mFTwo;
private FragmentThree mFThree;
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.activity_main);
mFOne = new FragmentOne();
FragmentManager fm = getFragmentManager();
FragmentTransaction tx = fm.beginTransaction();
tx.add(R.id.id_content, mFOne, "ONE");
tx.commit();
}
/**
* FragmentOne 按钮点击时的回调
*/
@Override
public void onFOneBtnClick()
{
if (mFTwo == null)
{
mFTwo = new FragmentTwo();
mFTwo.setfTwoBtnClickListener(this);
}
FragmentManager fm = getFragmentManager();
FragmentTransaction tx = fm.beginTransaction();
tx.replace(R.id.id_content, mFTwo, "TWO");
tx.addToBackStack(null);
tx.commit();
}
/**
* FragmentTwo 按钮点击时的回调
*/
@Override
public void onFTwoBtnClick()
{
if (mFThree == null)
{
mFThree = new FragmentThree();
}
FragmentManager fm = getFragmentManager();
FragmentTransaction tx = fm.beginTransaction();
tx.hide(mFTwo);
tx.add(R.id.id_content, mFThree, "THREE");
// tx.replace(R.id.id_content, fThree, "THREE");
tx.addToBackStack(null);
tx.commit();
}
}
复制代码
代码重构收场，与首先的结果一模同样。
周密品味下两类写法的差别，第一种是在Fragment把实现逻辑都写死啦,鲜明这种代码就没什么复用代价，而第二种只是在Fragment了定义了一种空洞的操纵，即能够响应点击事件，至于点击事件是什么，在主activity内部决意。
上头两种通讯方法都是值得保举的，任意选定一种本人稀饭的。Activity担负的是Fragment间相似总线同样的脚色，该当由它决意Fragment若何操纵。另外固然Fragment不行响应Intent翻开，但是Activity能够，Activity能够汲取Intent，然后凭据参数校验表现哪一个Fragment。
复制代码
package com.example.androidexpriment;
import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;
/*public class FragmentOne extends Fragment implements OnClickListener{
private Button mbtn;
public interface FOneBtnClickListener{
void onFOneBtnClick();
}
//得到该Fragment对应的Activity
@Override
public void onClick(View v) {
if(getActivity() instanceof FOneBtnClickListener) {
((FOneBtnClickListener)getActivity()).onFOneBtnClick();
}
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View view = inflater.inflate(R.layout.fragment_one,null);
mbtn= (Button) (view).findViewById(R.id.id_fragment_one_btn);
mbtn.setOnClickListener(this);
return view;
}
}*/
public class FragmentOne extends Fragment implements OnClickListener{
private Button mbtn;
private FOneBtnClickListener foneBtnClickListener;
public interface FOneBtnClickListener{
void onFOneBtnClick();
}
public void setFoneBtnClickListenr(FOneBtnClickListener f){
foneBtnClickListener = f;
}
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
foneBtnClickListener.onFOneBtnClick();
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View view = inflater.inflate(R.layout.fragment_one, null);
mbtn = (Button) view.findViewById(R.id.id_fragment_one_btn);
mbtn.setOnClickListener(this);
return view;
}
}
复制代码
4、若何处理运转时配置发生变更
运转时配置发生变更，非常多见的即是屏幕发生扭转，要是你不晓得若何处理屏幕变更能够参考：Android 屏幕扭转 处理 AsyncTask 和 ProgressDialog 的非常好方案
这里提一下：许多人以为强迫配置屏幕的方向就能够了，但是有一点，当你的运用被至于后台（比方用户点击了home），长光阴没有返回的时分，你的运用也会被重新启动。好比上例：要是你把上头的例子你至于FragmentThree界面，然后处于后台状况，长光阴后你会发现当你再次经历home翻开时，上头FragmentThree与FragmentOne叠加在一起，这即是由于你的Activity重新启动，在原来的FragmentThree上又绘制了一个FragmentOne。
好了，底下看一段代码：
Activity:
复制代码
package com.example.androidexpriment;
import android.app.Activity;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.util.Log;
import android.view.Window;
public class MainActivity extends Activity
{
private FragmentOne mFOne;
private static final String TAG = "FragmentOne";
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
Log.e(TAG, savedInstanceState+"");
requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.activity_main);
/* if(savedInstanceState == null) {
mFOne = new FragmentOne();
FragmentManager fm = getFragmentManager();
FragmentTransaction tx = fm.beginTransaction();
tx.add(R.id.id_content, mFOne, "ONE");
tx.commit();
}*/
mFOne = new FragmentOne();
FragmentManager fm = getFragmentManager();
FragmentTransaction tx = fm.beginTransaction();
tx.add(R.id.id_content, mFOne, "ONE");
tx.commit();
}
}
复制代码
Fragment
复制代码
package com.example.androidexpriment;
import android.app.Fragment;
import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;
public class FragmentOne extends Fragment
{
private static final String TAG = "FragmentOne";
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState)
{
Log.e(TAG, "onCreateView");
View view = inflater.inflate(R.layout.fragment_one, container, false);
return view;
}
@Override
public void onCreate(Bundle savedInstanceState)
{
// TODO Auto-generated method stub
super.onCreate(savedInstanceState);
Log.e(TAG, "onCreate");
}
@Override
public void onDestroyView()
{
// TODO Auto-generated method stub
super.onDestroyView();
Log.e(TAG, "onDestroyView");
}
@Override
public void onDestroy()
{
// TODO Auto-generated method stub
super.onDestroy();
Log.e(TAG, "onDestroy");
}
}
复制代码
很简单的代码，当你运转以后，接续的扭转屏幕，你会发现每扭转一次屏幕，后台log会打印出两套性命周期的回调。相配与有两个Fragment
这是为何呢，由于当屏幕发生扭转，Activity发生重新启动，默认的Activity中的Fragment也会随着Activity重新建立；这样造成当扭转的时分，本人存在的Fragment会重新启动，然后当实行Activity的onCreate时，又会再次实例化一个新的Fragment，这即是发现的缘故。两个
辣么若何办理呢：
实在经历搜检onCreate的参数Bundle savedInstanceState就能够校验，目前是否发生Activity的重新建立，代码上头曾经有啦。
上篇：上一篇：Android--关照之Notification
下篇：下一篇：明白Scroller
