【声明】

迎接转发,但请保留小说原来出处→_→

生命1号:http://www.cnblogs.com/smyhvae/

小说来源:http://www.cnblogs.com/smyhvae/p/3924567.html

 

【正文】

注:四大组件指的是运用组件:Activity、Service、布罗兹castReceiver、ContentProvider;在此之前的控件指的是UI组件。

博文目录:

  • 一、Activity简介
  • 二、Activity的景观和生命周期
  • 三、Activity的为主用法
  • 4、向下多少个Activity传递数据
  • 5、重回数据给上一个Activity
  • 6、Activity运转时显示屏方向与展现格局
  • 七、Activity的实地封存
  • 八、Activity通过SharedPreferences保存数据

一、Activity简介:

Activity组件是四大组件之壹,在选取中一个Activity能够用来代表3个界面,
中文意思也得以清楚为“活动”
,即二个运动始于,代表Activity组件运营;活动收尾,代表三个Activity的生命周期甘休。

八个android应用必须经过Activity来运作和运转,和J二ME
的MIDlet ①样,在android中,Activity的生命周期统一交由系统一管理理。与MIDlet
区别的是安装在android 中的全数的Activity 都以一致的。

知晓以下八个基本概念,将促进大家越来越好的摸底Activity:

• Application(APP)

• Activity

• Activity栈

• Task

各类Application均占据独立的内部存款和储蓄器空间。需求注意的是:Application之间固然互相独立,但应用程式_1中的Activity与APP_第22中学的Activity之间能够开始展览通信(调用、访问等)。

2、Activity的情景和生命周期

1、Activity的状态:

(一)Resumed:Activity对象出于运维情况。3个新Activity
运营入栈后,它在荧屏最前端,处于栈的最顶端,此时它地处可知并得以与用户交互的激活状态。

(2)Paused:另3个Activity位于前端,不过本Activity还可知。

       
Paused状态常用于:当Activity被另八个透明只怕Dialog样式的Activity覆盖时的气象。此时它依旧与窗口管理器保持三番五次,系统持续维护其里面景色,所以它如故可知,但它已经失去了关子故不可与用户交互。注:三个Activity出于paused状态时,系统并不会放出财富。释放财富你的操作要靠开发者来成功。

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

(四)killed:Activity被系统杀死回收大概未有被运行时。

XML, 绘制表格如下:

生命周期函数

调用时机

举例

onCreate

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

买车

onStart

当Activity变得可见时调用

打火,启动

onResume

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

踩油门,驱动汽车前进

onPause

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

松开油门

onStop

当前Activity变得不可见时调用

熄火

onDestroy

当前Activity被销毁之前调用

车辆报废

onRestart

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

 

 

 

 

 

 

 

 

 

 

 

 

 

 

注:on早先的一般是事件的方法。(引申知识:观望者的设计情势

二、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格局:私下认可的方式,以那种情势加载时,每当运转2个新的活动,必定会构造三个新的Activity实例放到再次来到栈(指标task)的栈顶,不管那么些Activity是否已经存在于重临栈中;
  • singleTop形式:倘若3个以singleTop形式运转的activity的实例已经存在于重返桟的桟顶,那么再开发银行这几个Activity时,不会创立新的实例,而是录取位于栈顶的非常实例,并且会调用该实例的onNewIntent()方法将Intent对象传递到那个实例中;

 

注:借使以singleTop情势运营的activity的三个实例已经存在于再次回到桟中,不过不在桟顶,那么它的一举一动和standard形式相同,也会创设四个实例;

 

  • singleTask格局:那种情势下,每一趟运营一个activity时,系统第二会在重返栈中检查是还是不是存在该活动的实例,要是存在,则直接使用该实例(会调用实例的onNewIntent()方法),并把这几个运动之上的有所活动统统去掉;倘使未有发现就会创建三个新的移动实例;

 

  • singleInstance格局:总是在新的天职业中学拉开,并且那么些新的职责中有且唯有那3个实例,并让多少个利用共享该栈中的该Activity实例。一旦该方式的Activity的实例存在于某些栈中,任何利用再激活该Activity时都会引用该栈中的实例。其效果也正是两个应用程序共享多少个采纳,不管哪个人激活该Activity都会跻身同一个用到中。

注:也正是说被该实例运转的其它activity会自动运营于另贰个职分中。当又一次启航该activity的实例时,会再度调用已存在的职务和实例。并且会调用那几个实例的onNewIntent()方法,将Intent实例传递到该实例中。和singleTask相同,同最近刻在系统中只会设有1个那样的Activity实例。(singleInstance即单实例)

 

注:前边二种格局中,各种应用程序都有谈得来的回来栈,同八个平移在差别的回来栈中入栈时,必然是创制了新的实例。而使用singleInstance形式能够消除这一个标题,在那种方式下会有二个独自的回来栈来管理这么些活动,不管是哪三个应用程序来访问那个运动,都公用同1个赶回栈,也就一蹴即至了共享活动实例的标题。(此时得以兑现职分之间的切换,而不是独自有个别栈中的实例切换)

 

一、singleInstance格局详解:

singleInstance方式从字面上看对比难领悟,下边通过代码举例来分析。代码如下:

(一)新建四个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确实是存放在在2个独自的回到栈中的,而且那些再次来到栈中唯有SecondActivity那3个平移。

下一场,大家按下Back键进行重临,你会意识ThirdActivity竟然直接再次回到到了FirstActivity,再按下Back键又会回来到SecondActivity,再按下Back键才会退出程序。解释如下:

FirstActivity和ThirdActivity存放在同三个回来栈里,当在ThirdActivity中按下Back键,ThirdActivity出栈,那么FirstActivity就改为了栈顶活动映以往界面上;然后在FirstActivity界面再一次按下Back键,那是现阶段的再次回到栈已经空了,于是就呈现了另3个再次回到栈的栈顶活动,即SecondActivity。最后按下Back键,那时,全部的回到栈都已经空了,自然也就退出了程序。 

 

叁、Activity的主旨用法:

一、隐藏标题栏:

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

注:第1行代码一定要在第壹行代码以前实施。

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          });

三、运维三个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系统内置的动作;

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

详见:《android第叁行代码》P48页。

设若要打电话的话,能够动用上面包车型客车代码:

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

  

4、向下三个Activity传递数据:

今非昔比的Activity
实例恐怕运营在1个历程中,也可能运转在分裂的历程中。由此,大家需求一种专门的建制帮忙大家在Activity
之间传递新闻。Android 中经过Intent 对象来代表一条音信,三个Intent
对象不仅含有有其一音讯的指标地,还足以包罗音讯的剧情,那好比1封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" /> 

上面第十行代码就是我们绑定的监听事件,点击按钮,将触发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那四个值,第1个参数则把带有数据的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
会根据所处的取向自动在竖屏和横屏间切换。可是有时大家的应用程序仅能在横屏/
竖屏时运营,比如1些游戏,此时我们要求锁定该Activity
运行时的荧屏方向,<activity>节点的android:screenOrientation属性能够成功该项任务,示例代码如下:

【方法一】在清单文件中布置:

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

 

【方法2】通过代码完成(1般位于onCreate方法中的后面),如下:

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

此间提三个小知识,Android模拟器中,飞速键”Ctrl+F11/F1二”可以兑现转屏

 

二、全屏突显:

能够在其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第一行代码》P6八页

 

7、Activity的实地封存:

先后在运作时,一些装置的配置可能会改变,如:横竖屏的切换、键盘的可用性等。那种业务假诺发生,Activity会重新创造。

重新创造的经过如下:

  • 在销毁从前,会调用onSaveInstanceState()去保存应用中的一些数量,保存在系统个中;
  • 接下来调用onDestroy()销毁从前的Activity;
  • 最后调用
    onCreate()或onRestoreInstanceState()方法去重新创设一个Activity。

实地封存的步骤如下:

(一)在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体化代码如下:

 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()方法主动去改变1些安装(当旋转荧屏的时候)。

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

  • “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并不曾被灭绝。

 

8、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变量中,然后得到艾德itor这一个编辑器,给它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局地代码,来删掉那一个文件里的情节(不或然删除文件本身),不然就会永远保存本地成为废物了。代码如下: 

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文件中的文本则会被清空。

 

 代码优化:

上边代码中1经大家在第四0行代码的末尾加上边那一行代码:

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

当重返到原程序时,setSelection方法可将输入光标移动到文本的末梢地点以便继续输入。里面的参数sp.getString(“msg”,
“”)是事先所输入的字符串。

 

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

 

小编的群众号

 

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

 

扫一扫,你将发现另贰个崭新的世界,而那将是一场美丽的不测:

 

XML 8

 

相关文章

网站地图xml地图