【声明】

迎接转载,但求保留文章原来出处→_→

命壹号:http://www.cnblogs.com/smyhvae/

文章来源:http://www.cnblogs.com/smyhvae/p/3924567.html

 

【正文】

横流:四怪组件指的凡用组件:Activity、Service、BroadcastReceiver、ContentProvider;之前的控件指的凡UI组件。

博文目录:

  • 一、Activity简介
  • 次、Activity的状态及生命周期
  • 老三、Activity的核心用法
  • 季、向下一个Activity传递数据
  • 五、返回数据给上一个Activity
  • 六、Activity运行时屏幕方向与显示方式
  • 七、Activity的实地封存
  • 八、Activity通过SharedPreferences保存数据

一、Activity简介:

Activity组件是四那个组件有,在以中一个Activity可以用来表示一个界面,
中文意吧得理解呢“活动”
,即一个活动开,代表Activity组件启动;活动收尾,代表一个Activity的生命周期结束。

一个android应用必须经Activity来运转和开行,和J2ME
的MIDlet 一样,在android中,Activity的生命周期统一交由系统管理。与MIDlet
不同之凡安在android 中的有所的Activity 都是千篇一律之。

明以下四只基本概念,将有助于我们再次好的打听Activity:

• Application(APP)

• Activity

• Activity栈

• Task

每个Application均占有独立的内存空间。需要注意的是:Application之间虽然相互独立,但APP_1中的Activity与APP_2遭遇之Activity之间可拓展通信(调用、访问等)。

老二、Activity的状态及生命周期

1、Activity的状态:

(1)Resumed:Activity对象由运行状态。一个新Activity
启动入栈后,它于屏幕最前端,处于栈的极上,此时它们地处可见并可跟用户交互的激活状态。

(2)Paused:另一个Activity位于前端,但是本Activity还可见。

       
Paused状态时用来:当Activity被外一个晶莹剔透或Dialog样式的Activity覆盖时的状态。此时她仍和窗口管理器保持连续,系统继续保障其内部状态,所以它们还是可见,但它已经失去了关子故不可与用户交互。注:一个Activity出于paused状态时,系统并无会见放出资源。释放资源而的操作而依开发者来形成。

(3)Stopped:另一个Activity位于前端,完全遮挡本Activity。

(4)killed:Activity被网杀死回收或者没有叫启动时。

 绘制表格如下:

生命周期函数

调用时机

举例

onCreate

在Activity对象被第一次创建时调用

买车

onStart

当Activity变得可见时调用

打火,启动

onResume

当Activity开始准备和用户交互时调用

踩油门,驱动汽车前进

onPause

当系统即将启动另外一个Activity之前调用

松开油门

onStop

当前Activity变得不可见时调用

熄火

onDestroy

当前Activity被销毁之前调用

车辆报废

onRestart

当一个Activity再次启动之前调用

 

 

 

 

 

 

 

 

 

 

 

 

 

 

横流:on开头的相似是事件之方。(引申知识:观察者的设计模式)

2、Activity的生命周期:

XML 1

详情请见我的另外一首博客:Activity的生命周期

 

生命周期的完好代码如下:

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;

public class MainActivity extends Activity {

    private static final String TAG = "smyhvae";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d(TAG, "onCreate");
    }

    @Override
    protected void onStart() {
        super.onStart();
        Log.d(TAG, "onStart");
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.d(TAG, "onResume");
    }


    @Override
    protected void onPause() {
        super.onPause();
        Log.d(TAG, "onPause");
    }


    @Override
    protected void onStop() {
        super.onStop();
        Log.d(TAG, "onStop");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "onDestroy");
    }

    @Override
    protected void onRestart() {
        super.onRestart();
        Log.d(TAG, "onRestart");
    }
}

 

 

老三、Activity的启航模式:(面试注意)

 

Activity有季种植启动模式:standard、singleTop、singleTask、singleInstance。可以当AndroidManifest.xml中activity标签的属性android:launchMode面临安装该activity的加载模式。

 

  • standard模式:默认的模式,以这种模式加载时,每当启动一个新的移动,必定会组织一个初的Activity实例放到返回栈(目标task)的栈顶,不管这Activity是否早已是于返回栈中;
  • singleTop模式:如果一个因为singleTop模式启动的activity的实例已经有为返回桟的桟顶,那么又起步之Activity时,不见面创造新的实例,而是用位于栈顶的不可开交实例,并且会调用该实例的onNewIntent()方法将Intent对象传递到之实例中;

 

流动:如果因为singleTop模式启动之activity的一个实例已经有让返回桟中,但是未以桟顶,那么它们的行为跟standard模式相同,也会见创造多单实例;

 

  • singleTask模式:这种模式下,每次启动一个activity时,系统第一会见当回栈中检查是不是有拖欠走之实例,如果是,则直接用该实例(会调用实例的onNewIntent()方法),并把这个运动之上的富有移动均去掉;如果没发现即使见面创一个初的动实例;

 

  • singleInstance模式:总是在初的任务中开,并且这个新的天职中发出且只有马上一个实例,并叫多只应用共享该栈中之该Activity实例。一旦该模式的Activity的实例存在叫某某栈中,任何利用还激活该Activity时还见面引用该栈中的实例。其职能一定给多独应用程序共享一个使,不管谁激活该Activity都见面进来和一个下被。

流动:也就是说被拖欠实例启动之外activity会自动运行为任何一个任务中。当又启动该activity的实例时,会再度调用已是的任务以及实例。并且会调用这个实例的onNewIntent()方法,将Intent实例传递到该实例中。和singleTask相同,同一时刻以网遭到只见面是一个这么的Activity实例。(singleInstance即单实例)

 

流动:前面三栽模式受到,每个应用程序都产生谈得来之回来仓库,同一个移动在不同之回仓库中可栈时,必然是开创了新的实例。而下singleInstance模式可以缓解此题材,在这种模式下会发出一个独门的回到栈来管理是运动,不管是呀一个应用程序来拜会是倒,都公用同一个回仓库,也就算缓解了共享活动实例的题材。(此时得以兑现任务中的切换,而非是单独某个栈中的实例切换)

 

1、singleInstance模式详解:

singleInstance模式从字面上看于为难理解,下面通过代码举例来分析。代码如下:

(1)新建三个Activity:FirstActivity、SecondActivity、ThirdActivity。同时,将SecondActivity的起步模式设置为singleInstance。

(2)三单Activity的代码如下:

FirstActivity.java:

 1 import android.app.Activity;
 2 import android.content.Intent;
 3 import android.os.Bundle;
 4 import android.util.Log;
 5 import android.view.View;
 6 import android.widget.Button;
 7 
 8 
 9 public class FirstActivity extends Activity {
10 
11     private Button button1;
12 
13     @Override
14     protected void onCreate(Bundle savedInstanceState) {
15         super.onCreate(savedInstanceState);
16         Log.d("--->FirstActivity", "返回栈的id是" + getTaskId());  //打印当前返回栈的id
17         setContentView(R.layout.activity_main);
18         button1 = (Button) findViewById(R.id.button1);
19         button1.setOnClickListener(new View.OnClickListener() {
20             @Override
21             public void onClick(View v) {
22                 startActivity(new Intent(FirstActivity.this, SecondActivity.class));
23 
24             }
25         });
26     }
27 
28 }

头代码中,在onCreate()方法吃打印当前返回栈的id。点击按钮,跳反到SecondActivity。

 

SecondActivity.java:

 1 import android.app.Activity;
 2 import android.content.Intent;
 3 import android.os.Bundle;
 4 import android.util.Log;
 5 import android.view.View;
 6 import android.widget.Button;
 7 
 8 
 9 public class SecondActivity extends Activity {
10 
11     private Button button2;
12 
13     @Override
14     protected void onCreate(Bundle savedInstanceState) {
15         super.onCreate(savedInstanceState);
16         Log.d("--->SecondActivity", "返回栈的id是" + getTaskId());  //打印当前返回栈的id
17         setContentView(R.layout.activity_second);
18         button2 = (Button) findViewById(R.id.button2);
19         button2.setOnClickListener(new View.OnClickListener() {
20             @Override
21             public void onClick(View v) {
22                 startActivity(new Intent(SecondActivity.this, ThirdActivity.class));
23 
24             }
25         });
26     }
27 
28 }

 

上面代码中,在onCreate()方法吃打印当前返回栈的id。点击按钮,跳反到ThirdActivity。

ThirdActivity.java:

 1 import android.app.Activity;
 2 import android.os.Bundle;
 3 import android.util.Log;
 4 import android.widget.Button;
 5 
 6 
 7 public class ThirdActivity extends Activity {
 8 
 9     private Button button3;
10 
11     @Override
12     protected void onCreate(Bundle savedInstanceState) {
13         super.onCreate(savedInstanceState);
14         Log.d("--->ThirdActivity", "返回栈的id是" + getTaskId());  //打印当前返回栈的id
15         setContentView(R.layout.activity_third);
16     }
17 
18 }

 

运作程序,在FirstActivity中点击按钮上SecondActivity中,然后于SecondActivity中点击按钮进入ThirdActivity。后台打印日志如下:

XML 2

头日志可以望:SecondActivity的Task
id不同让FirstActivity和ThirdActivity,这证明SecondActivity确实是存放在于一个独门的归来栈中的,而且此返回栈中只有SecondActivity这一个活动。

接下来,我们循下Back键进行返回,你见面发觉ThirdActivity竟然直接回到到了FirstActivity,再比如下Back键又会回到SecondActivity,再遵照下Back键才见面退出程序。解释如下:

FirstActivity和ThirdActivity存放在同一个返栈里,当在ThirdActivity中本下Back键,ThirdActivity出栈,那么FirstActivity就改成了栈顶活动展示在界面上;然后在FirstActivity界面再次以下Back键,立马是当下之返回栈已经拖欠了,于是便显得了外一个返回栈的栈顶活动,即SecondActivity。最后以下Back键,这时,所有的归来栈都已经空了,自然为即淡出了序。 

 

其三、Activity的着力用法:

1、隐藏标题栏:

requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.activity_main);  

横流:第一实行代码一定要是于次推行代码之前实施。

2、在倒中以Toast:

比如点击按钮时,弹出吐司:

1          button.setOnClickListener(new OnClickListener() {            
2              @Override
3              public void onClick(View v) {
4                  Toast.makeText(MainActivity.this, "You clicked the Button",Toast.LENGTH_SHORT).show();                
5              }                
6          });

3、启动一个Activity的不二法门:哪怕于默认启动的Activity中启动另一个Activity

主导代码如下:

Intent intent = new Intent();
intent.setClass(MainActivity.this, SecondActivity.class); 

切切实实过程要参考本人的外一样首博客: 当前Activity跳反至任何一个Activity的详细过程

 

4、隐式Intent的用法:

用隐式Intent,我们不光可启动自己程序外的移动,还可启动其他程序的活动,这使Android多单应用程序之间的意义共享成为了也许。比如应用程序中待出示一个网页,没有必要自己失去实现一个浏览器(事实上为不太可能),而是一味待条用系统的浏览器来开辟这个网页就推行了。

【实例】:打开指定网页。

监听器部分的主干代码如下:

1         button.setOnClickListener(new OnClickListener() {            
2             @Override
3             public void onClick(View v) {
4                 Intent intent = new Intent(Intent.ACTION_VIEW);
5                 intent.setData(Uri.parse("http://www.baidu.com"));
6                 startActivity(intent);
7             }
8         }); 

第4行代码:指定了Intent的action是
Intent.ACTION_VIEW,这是一个Android系统放的动作;

第5履行代码:通过Uri.parse()方法,将一个网址字符串解析成一个Uri对象,再调用intent的setData()方法将以此Uri对象传递进入。

翔:《android第一实行代码》P48页。

若是一旦打电话的说话,可以使用下的代码:

                Intent intent = new Intent(Intent.ACTION_DIAL);
                intent.setData(Uri.parse("tel:10086"));
                startActivity(intent);

  

季、向下一个Activity传递数据:

今非昔比的Activity
实例可能运行于一个进程面临,也恐怕运行于不同之长河被。因此,我们要平等栽专门的编制帮助我们以Activity
之间传递消息。Android 中经Intent 对象来代表一致长长的消息,一个Intent
对象不仅含有有这个消息之目的地,还可涵盖消息的情,这好于一封Email,其中不仅该包含收件地点,还好蕴涵具体的始末。对于一个Intent
对象,消息“目的地 ”是要的,而内容虽然是不过卜项。

当地方的实例中通过Activity.
startActivity(intent)启动另外一个Activity的时光,我们于Intent类的构造器中指定了“收件人地址”。

Activity传递数据有以下简单种植艺术:

1、【方式一】使用Intent自带的bundle对象

传递数据,代码如下:

这边,我们采取另外一样种植绑定监听时之法子,即在布局文件中,对Button按钮做如下设置:

 

1     <Button
2         android:id="@+id/button1"
3         android:layout_width="wrap_content"
4         android:layout_height="wrap_content"
5         android:layout_below="@+id/textView1"
6         android:layout_marginTop="22dp"
7         android:onClick="gotoSecondActivity"
8         android:text="启动第二个Activity" /> 

上面第7履行代码就是咱绑定的监听事件,点击按钮,将触发gotoSecondActivity()函数中之代码。紧接着召开下的操作。

以MainActivity中发送数据:

1     public void gotoSecondActivity(View view){
2         //创建一个意图
3         Intent intent = new Intent(MainActivity.this,SecondActivity.class);
4         
5         //第一种方式:使用Intent自带的bundle对象
6         intent.putExtra("name", "smyhvae");//方法:public Intent putExtra (String name, boolean value)         
7         startActivity(intent);
8     }

 

每当SecondActivity中接收数据:

 1     protected void onCreate(Bundle savedInstanceState) {
 2         // TODO Auto-generated method stub
 3         super.onCreate(savedInstanceState);
 4         setContentView(R.layout.second);
 5         
 6         Intent intent = getIntent();
 7         String name = intent.getStringExtra("name");          
 8 
 9         
10         TextView textView = (TextView)findViewById(R.id.textView1);
11         textView.setText("name="+name);       
1112     } 

 

或者传递一个目标:

新建一个Student.java的类似公事,作为传递的目标:

 1 import java.io.Serializable;
 2 //让这个类序列化
 3 public class Student implements Serializable{
 4     int grade ;
 5     String school;
 6     String address;
 7     
 8     //将这些变量 变成字符串,方便输出
 9     @Override
10     public String toString() {
11         return "Student [grade=" + grade + ", school=" + school + ", address="
12                 + address + "]";
13     }
14     
15 }

 

在MainActivity中发送数据:

 1     public void gotoSecondActivity(View view){
 2         //创建一个意图
 3         Intent intent = new Intent(MainActivity.this,SecondActivity.class);
 4         
 5         //传递自定义类型(对象)
 6         Student student = new Student();
 7         student.grade = 2;
 8         student.school = "UESTC";
 9         student.address = "chengdu";
10         intent.putExtra("student", student);//方法:public Intent putExtra (String name, Serializable value) 
11         
12         startActivity(intent);
13     }

 

于SecondActivity中接收数据:

 1     protected void onCreate(Bundle savedInstanceState) {
 2         // TODO Auto-generated method stub
 3         super.onCreate(savedInstanceState);
 4         setContentView(R.layout.second);               
 5 
 6 
 7       Intent intent = getIntent();
 8        Student student = (Student) intent.getSerializableExtra("student");
 9         
10         TextView textView = (TextView)findViewById(R.id.textView1);
11         textView.setText(student);         
12         
13         System.out.println("SecondActivity-onCreate");
14     } 

​【工程文件】

链接:http://pan.baidu.com/s/1jGvEc6q

密码:ic6c

 

2、【方式二】创建Bundle对象来传递

经按钮监听事件。核心代码如下:

在MainActivity中发送数据:

 1     //通过这个方法跳转到SecondActivity界面     
 2     public void gotoSecondActivity(View view){
 3         //创建一个意图
 4         Intent intent = new Intent(MainActivity.this,SecondActivity.class);
 5         
 6         //第二种传值方式:创建Bundle对象来传递
 7         Bundle bundle = new Bundle();  //创建bundle的内容
 8         bundle.putString("name", "smyhvae");//编写bundle的内容
 9         bundle.putInt("age", 22);
10         bundle.putLong("id", 20132224);
11         
12         intent.putExtra("person", bundle);//封装bundle。方法:public Intent putExtra (String name, Bundle value)     
13 
14         startActivity(intent);
15     }

 

于SecondActivity中接收数据:

 1     protected void onCreate(Bundle savedInstanceState) {
 2         // TODO Auto-generated method stub
 3         super.onCreate(savedInstanceState);
 4         setContentView(R.layout.second);
 5         
 6         //获取上一个Activity传递过来的参数
 7         Intent intent = getIntent();
 8         Bundle bundle = intent.getBundleExtra("person");
 9         String name = bundle.getString("name");
10         int age = bundle.getInt("age");
11         
12         //获取上一个Activity传递过来的参数,将接收到的数据输出到TextView当中
13         TextView textView = (TextView)findViewById(R.id.textView1);
14         textView.setText("name="+name+";"+"age="+age);         
15         
16         System.out.println("SecondActivity-onCreate");
17     }

 

【工程文件】

链接:http://pan.baidu.com/s/1ntLqzfN

密码:xzn7

 

五、返回数据让上一个Activity:

手续如下:

  • 起先带回来结果的MainActivity:

       
startActivityForResult(Intent
intent, int requestCode)

       
第二单参数为呼吁求码,用于在后头的回调中判断数的源于

Intent intent = new Intent(MainActivity.this, SecondActivity.class);
startActivityForResult(intent,1);

 

  • 于SecondActivity中经过putExtra放入数据,然后调用以下方式:(非常关键)

        setResult(int resultCode,
Intent
data)

         resultCode一般只使用RESULT_OK
或RESULT_CANCELED这简单单价值,第二只参数则将带有数据的Intent传递回去

Intent intent = new Intent();
intent.putExtra("data_return", "smyhvae");
setResult(RESULT_OK, intent);
finish();

 

  • SecondActicity被销毁之前,会调用上MainActivity的
    onActivityResult()方法,所以一旦重复写是方式:

public void onActivityResult(int
requestCode, int resultCode,Intent data)

 1     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
 2         switch (requestCode) {
 3         case 1:
 4             if (resultCode == RESULT_OK) {
 5                 String returnedData = data.getStringExtra("data_return");
 6                 Log.d("FirstActivity", returnedData);
 7             }
 8             break;
 9         default:
10         }
11     } 

举例略。

 

六、Activity运行时屏幕方向和显示方式

1、锁定屏幕方向:横屏/ 竖屏

Android 内置了样子感应器的支撑。Android
会根据所处的趋势自动在竖屏和横屏间切换。但是有时我们的应用程序仅能当横屏/
竖屏时运行,比如一些游戏,此时我们要锁定该Activity
运行时的屏幕方向,<activity>节点的android:screenOrientation属性可以完成该项任务,示例代码如下:

【方法一致】在清单文件被安排:

<activity android:name=".EX01"
    android:label="@string/app_name"
    android:screenOrientation="portrait"> 
    // 值为portrait时强制为竖屏, 值为landscape时强制为横屏
</activity>

 

【方法二】通过代码实现(一般位于onCreate方法XML被之前头),如下:

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATTION_LANDSCAPE); 
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATTION_PORTRAIT); 

此处取一个多少知识,Android模拟器中,快捷键”Ctrl+F11/F12″可以兑现转屏

 

2、全屏显示:

好于那onCreate()方法被补充加如下代码实现:

        //设置全屏模式
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
        //去除标题栏
        requestWindowFeature(Window.FEATURE_NO_TITLE);

 

3、以对话框式显示Activity:

在清单文件中布置:

        <activity 
            android:name="com.example.smyh004activity02.SecondActivity"
            android:label="SecondActivity"
            android:theme="@android:style/Theme.DeviceDefault.Dialog">            
        </activity> 

专门关爱:Activity的启航模式。见《Android第一实施代码》P68页

 

七、Activity的现场封存:

次第于运转时,一些设备的布置或者会见变动,如:横竖屏的切换、键盘的可用性等。这种业务若有,Activity会重新创设。

重创设的过程如下:

  • 于销毁之前,会调用onSaveInstanceState()去保存应用被的组成部分数码,保存在系当中;
  • 接下来调用onDestroy()销毁之前的Activity;
  • 终极调用
    onCreate()或onRestoreInstanceState()方法去重新创设一个Activity。

现场封存的步骤如下:

(1)在MainActivity中,调用onSaveInstanceState(),即添加如下代码就好以临时数据保存:

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        String tempData = "Something you want to save";
        outState.putString("data_key", tempData);
        Log.i(LOG, "onSaveInstanceState..");
    }

 

(2)数据保存之后,修改MainActivity的onCreate()方法:

 1     @Override
 2     protected void onCreate(Bundle savedInstanceState) {
 3         super.onCreate(savedInstanceState);
 4         setContentView(R.layout.activity_main);
 5         Log.i(LOG, "onCreate...");
 6         //步骤2:还原当前activity的状态
 7         if (savedInstanceState != null) {
 8             String tempData = savedInstanceState.getString("data_key");
 9             Log.i(LOG, tempData);
10         }
11     }

 

一体化代码如下:

 1 package com.example.smyh004activity03;
 2 import android.os.Bundle;
 3 import android.app.Activity;
 4 import android.content.res.Configuration;
 5 import android.util.Log;
 6 import android.view.Menu;
 7 public class MainActivity extends Activity {
 8     private static final String LOG = "Activity";
 9     @Override
10     protected void onCreate(Bundle savedInstanceState) {
11         super.onCreate(savedInstanceState);
12         setContentView(R.layout.activity_main);
13         Log.i(LOG, "onCreate...");
14         //步骤2:还原当前activity的状态
15         if (savedInstanceState != null) {
16             String tempData = savedInstanceState.getString("data_key");
17             Log.i(LOG, tempData);
18         }
19     }
20     // 步骤1:活动被销毁之前(如在横竖屏切换时),会触发该方法来保存activity数据
21     @Override
22     protected void onSaveInstanceState(Bundle outState) {
23         super.onSaveInstanceState(outState);
24         String tempData = "open";
25         outState.putString("data_key", tempData);
26         Log.i(LOG, "onSaveInstanceState..");
27     }
28 
29 }

 当手动旋转屏幕后,后台输出结果如下:

XML 3

及图的日志被,如果将生命周期写完整一点,打印的日志如下:

XML 4

 

于盘屏幕时,如果无思量再也创设Activity,我们好透过清单文件AndroidManifest.xml中android:configChanges来指定的少数性能不发生变化,然后通知顺序去调整用onConfiguratonChanged()方法主动去改变有装置(当盘屏幕的下)。

清单文件中,指定的常见属性有:

  • “keyboard”
    键盘发生了变更—-例如用户用了表面的键盘 
  • “keyboardHidden”
    键盘的可用性发生了转移
  • “orientation” 屏幕方向改变
  •   “screenSize” 屏幕尺寸改变

安装代码举例如下:

        <activity
            android:name="com.example.smyh004activity03.MainActivity"
            android:label="@string/app_name"
            android:configChanges="orientation|screenSize" >
        </activity> 

注:符号“|”表示“并且”的意,这行代码在事实上采用被十分广泛。

随后以上头的java代码的基本功之上,添加如下代码:

1     @Override
2     public void onConfigurationChanged(Configuration newConfig) {
3         super.onConfigurationChanged(newConfig);
4         Log.i(LOG, "onConfigurationChanged..");
5     }

 

末尾,当手动旋转屏幕后,后台输出结果如下:

XML 5  

好看来,onSaveInstanceState()方法并不曾吃调用,也就是说,旋转屏幕时,当前Activity并没给灭绝。

 

八、Activity通过Shared
Preferences保存数据:

寻常情况下会发出如此的问题,我们于编写短信的以发生电话从进去,那么接电话定是要开动另一个Activiy,那么当前编辑短信的Activity所编写的信息我们怀念临时保留下去,等对接了电话后回到该Activity时,可以持续编辑短信。该功能要什么错过贯彻呢?

事实上,SharedPreferences使用xml格式为Android应用提供相同种永恒的数存贮方式。对于一个Android应用,它存贮在文件系统的/data/
data/your_app_package_name/shared_prefs/目录下,可以让处于同一个运用中之所有Activity
访问。Android
提提供了相关的API来处理这些多少要无需程序员直接操作这些文件或者考虑数据并的题材。

现便因此代码来兑现这效果:

率先用SharedPreferences这个工具类: 

 1     private EditText etMsg ;
 2     private Button sendButton;
 3     private SharedPreferences sp;
 4     
 5     @Override
 6     protected void onCreate(Bundle savedInstanceState) {
 7         super.onCreate(savedInstanceState);
 8         setContentView(R.layout.activity_main);
 9         
10         etMsg = (EditText)findViewById(R.id.editText1);
11         sendButton = (Button)findViewById(R.id.button1);
12         
13         // 获取共享属性操作的工具(文件名,操作模式)
14         sp = This.getSharedPreferences("data", 0);
15     } 

头第14执行代码中,调用的方式是:public
SharedPreferences getSharedPreferences
(String name, int mode)

中,第一单参数代表XML文件,如果来是文件,就会操作是文件,如果没是文件,就见面创是文件;第二单参数代表一如既往栽操作模式,0代表私有。

然后,我们要在onPause()方法里保存数据,之所以当onPause()方法里保存,是坐当有可能会见受外存销毁的生命周期函数中,而onPause()方法最先执行。代码如下: 

1     //在onPause()方法中保存数据
2     @Override
3     protected void onPause() {
4         super.onPause();
5         String msg = etMsg.getText().toString();
6         Editor editor = sp.edit();
7         editor.putString("msg", msg); //执行方法:public abstract SharedPreferences.Editor putString (String key, String value) 
8         editor.commit();        
9     } 

以数据保存在msg变量中,然后用到Editor这个编辑器,给其put进去。当然,这些只是在内存中操作,如果要是反映至文件中,还要实行
commit()方法。

随之,我们只要以onResume()方法吃还恢复数据:(为什么要于斯主意被尚原数,不用自基本上说) 

1     @Override
2     protected void onResume() {
3         super.onResume();
4         etMsg.setText(sp.getString("msg", ""));        
5     }

当次中首先赖开行的下,并从未保留数据,所以回来一个默认的空值。将此返回的多少放到etMsg控件中便尽了。

今昔咱们运行程序,是可实行的。

像,现在编制内容,然后去别的程序,再回来的时节(就算我们把程序退出了),编辑的情节还依然留存。这个上,我们开拓文件浏览器,发现数目是保留于data-data-android工程的文件夹-shared-prefs目录的data.xml文件中的,而且是永久保存;所以,当当onResume()方法还原数据以后,我们还要加同组成部分代码,来删掉这个文件里的情节(无法去文件本身),不然就是见面永远保存本地成为废物了。代码如下: 

1     protected void onResume() {
2         super.onResume();
3         etMsg.setText(sp.getString("msg", ""));    
4         Editor editor = sp.edit();
5         editor.clear();
6         editor.commit();
7     } 

 

总后,最终之完整版本代码如下:

activity_main.xml文件代码: 

<LinearLayout 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:orientation="vertical"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context=".MainActivity" >
    <EditText
        android:id="@+id/editText1"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:gravity="top"
        android:layout_weight="1"
        android:ems="10" />
    <Button
        android:id="@+id/button1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Button" />
</LinearLayout> 

MainActivity.java的代码如下: 

 1 package com.example.smyh001;
 2 import android.app.Activity;
 3 import android.content.SharedPreferences;
 4 import android.content.SharedPreferences.Editor;
 5 import android.os.Bundle;
 6 import android.view.Menu;
 7 import android.widget.Button;
 8 import android.widget.EditText;
 9 public class MainActivity extends Activity {
10     private EditText etMsg ;
11     private Button sendButton;
12     private SharedPreferences sp;
13     
14     @Override
15     protected void onCreate(Bundle savedInstanceState) {
16         super.onCreate(savedInstanceState);
17         setContentView(R.layout.activity_main);
18         
19         etMsg = (EditText)findViewById(R.id.editText1);
20         sendButton = (Button)findViewById(R.id.button1);
21         
22         // 获取共享属性操作的工具
23         sp = getSharedPreferences("data", 0);
24     }
25     //在onPause()方法中保存数据
26     @Override
27     protected void onPause() {
28         super.onPause();
29         String msg = etMsg.getText().toString();
30         Editor editor = sp.edit();
31         editor.putString("msg", msg);//执行方法:public abstract SharedPreferences.Editor putString (String key, String value) 
32         editor.commit();        
33     }
34     
35     //在onResume()方法中还原数据
36     @Override
37     protected void onResume() {
38         super.onResume();
39         etMsg.setText(sp.getString("msg", ""));    
40         Editor editor = sp.edit();
41         editor.clear();
42         editor.commit();
43     }    
44 } 

 运行程序后,我们当编辑框输入有文:

XML 6

退程序,然后导出data.xml文件,打开后显示如下:

XML 7

证实输入的文书为保存于了data.xml文件中。当我们重回到程序,之前输入的亲笔会吃保存在界面上,而data.xml文件中之文书则会给清空。

 

 代码优化:

头代码中只要我们在第40行代码的后面加下面这一行代码:

        etMsg.setSelection((sp.getString("msg", "")).length());

当回到本程序时,setSelection方法可拿输入光标移动到文本的终极位置以便继续输入。里面的参数sp.getString(“msg”,
“”)是前所输入的字符串。

 

到这里为止,Android的基础知识就讲完了,以后会不断完善补充的。

 

自家之公众号

 

想学习代码之外的软技能?不妨关注自身的微信公众号:命团队(id:vitateam)。

 

扫一扫,你将发现任何一个新的世界,而当时将是千篇一律庙会漂亮之飞:

 

XML 8

 

相关文章

网站地图xml地图