Andriod基础入门

Andriod体系结构：

  • 应用程序层
  • 应用程序框架层
  • 核心类库

Dalvik 是 Google 公司自己设计用于 Android 平台的虚拟机，其是基于寄存器的结构，运行的是其专有的 .dex 文件；Java 虚拟机是基于栈的结构，其运行的是 .class 字节码文件。程序在翻译成.class文件后，会将所有的.class文件转换成一个.dex文件。

Andriod程序结构

  • manifests文件夹：Android系统配置文件夹，包含一个AndroidManifest.xml文件。在程序中定义的四大组件都要在这个文件中注册，另外在该文件中还可以给程序添加权限。
  • java文件夹：存放Java代码的文件夹，新建项目时默认生成了三个文件夹，com.first.project文件夹用来存放Java文件，这里包含一个名为MainActivity的Java文件，是新建项目时默认生成的。第二个和第三个文件为测试代码文件夹，不是十分常用。
  • res文件夹：存放Android项目的资源文件，包含四个文件夹：drawable（图片资源文件夹）、layout（布局资源文件夹）、mipmap（图片资源文件夹，存放项目图标）、values（存放数值资源文件）。布局文件为XML文件。
  • Gradle Scripts：用于存放项目创建的相关文件，无须修改。

Andriod程序打包

程序开发完成后，需要将程序打包成APK文件，后缀名为“.apk”。

Android UI开发

布局类型

线性布局

线性布局（LinearLayout），主要以水平和垂直方式来显示界面中的控件。

1
2
3
4
5
<!-- 线性布局垂直显示 -->
android:orientation="vertical"

<!-- 线性布局水平显示 -->
android:orientation="horizontal"

相对布局

程序创建时，默认采用的就是相对布局。

帧布局

表格布局

绝对布局

常用控件

TextView

1
2
3
4
5
6
7
8
TextView tv=(TextView)findViewById(R.id.xxxx);

//设置文本
tv.setText(string);
tv.setText(Integer.toString(num));

//得到文本
tv.getText().toString()

EditText

输入框，继承自TextView，用法类似

Button

其作用是响应用户的一系列点击事件。其常用的点击方式有3种。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class MainActivity extends AppCompatActivity { 
    private Button btn1,btn2;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //通过findViewById初始化控件
        btn1 = (Button) findViewById(R.id.myBtn1);
        btn2 = (Button) findViewById(R.id.myBtn2);
        //第一种，匿名内部类的方法实现按钮1的点击事件
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                btn1.setText("click btn1!");
            }
        });
    }
    //第二种，通过实现onClick()方法，实现按钮2的点击事件
    public void click(View v){
        btn2.setText("click btn2");
    }
}

上面两种方式均适合按钮较少的情况，只不过匿名内部类的形式更加常用。不过当按钮点击事件较多时，可以使用第三种点击事件，即在当前 Activity 中实现 OnClickLisenter 接口，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class MainActivity extends AppCompatActivity implements View.OnClickListener{
    private Button btn1,btn2;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btn1 = (Button) findViewById(R.id.myBtn1);
        btn2 = (Button) findViewById(R.id.myBtn2);
        //这里必须要注册
        btn1.setOnClickListener(this);
        btn2.setOnClickListener(this);
    }
    @Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.btn1:
                btn1.setText("click btn1!");
                break;
            case R.id.btn1:
                btn2.setText("click btn2!");
                break;        
        }        
    }
}

RadioButton

RadioButton 为单选按钮，需要与 RadioGroup 配合使用。在 RadioGroup 中可以利用 android:orientationn 控制 RadioButton 排列方向。

ImageView

功能是在屏幕中显示图像。

常见对话框

普通对话框

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        AlertDialog dialog;
        dialog = new AlertDialog.Builder(this).setTitle("我的提示框")
            .setIcon(R.drawable.p1) //设置图标
            .setMessage("确定要关闭本应用程序吗？") //设置提示消息
            .setPositiveButton("确定", null) //添加确定按钮
            .setNegativeeButton("取消", null) //添加取消按钮
            .create(); //创建对话框
        
        dialog.show() //显示对话框
    }
}

单选对话框

多选对话框

进度条对话框

消息对话框

自定义对话框

Activity

生命周期

  1. 启动状态

    Activity 的启动状态很短暂，一般情况下，当 Activity 启动后就会进入到运行状态。

  2. 运行状态

    Activity 在此状态时处于屏幕最前端，可以与用户进行交互。当 Activity 处于运行状态时，Android 会尽可能地保持它的运行，即使出现内存不足的情况，Android 也会先销毁栈底的 Activity，来确保当前 Activity 正常运行。

  3. 暂停状态

    在某些情况下，当 Activity 对于用户来说仍然可见，但他无法获取焦点，用户对它的操作没有响应，此时它就处于暂停状态。

  4. 停止状态

    当 Activity 完全不可见时，它就处于停止状态，但仍保留着当前状态和成员信息。

  5. 销毁状态

    当 Activity 处于销毁状态时，将被清理出内存。

img

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
//onCreate在Activity创建时调用，通常做一些初始化设置
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    LogUtils.d(TAG,"onCreate ---> 创建时调用");
}

//onStart方法在Activity即将可见时调用
@Override
protected void onStart() {
    super.onStart();
    LogUtils.d(TAG,"onStart ---> 即将可见不可交互时调用");
}

//onResume方法在Activity获取焦点开始与用户交互时调用
@Override
protected void onResume() {
    super.onResume();
    LogUtils.d(TAG,"onResume ---> 可见可交互时调用");
}
 
//onPause方法在Activity被其他Activity覆盖或锁屏时调用
@Override
protected void onPause() {
    super.onPause();
    LogUtils.d(TAG,"onPause ---> 即将暂停时调用");
}

//onStop方法在Activity对用户不可见时调用
@Override
protected void onStop() {
    super.onStop();
    LogUtils.d(TAG,"onStop ---> 即将停止不可见时调用");
}
 
//onDestroy方法在Activity销毁时调用
@Override
protected void onDestroy() {
    super.onDestroy();
    LogUtils.d(TAG,"onDestroy ---> 即将销毁时调用");
}

//onRestart方法在Activity从停止状态再次启动时调用
@Override
protected void onRestart() {
    super.onRestart();
    LogUtils.d(TAG,"onRestart ---> 重启时调用");
}

Activity之间的跳转

Intent

  1. 显式意图

    显式意图可以直接通过名称开启指定的目标组件。

    1
    2
    Intent intent = new Intent(MainActivity.this, SecondActivity.class); //创建 Intent 对象
    startActivity(intent); //开启SecondActivity

  2. 隐式意图

    隐式意图相比显式意图来说更为抽象，它并没有明确指定要开启哪个目标组件。而是通过指定action 和 category 等属性信息，系统根据这些信息进行分析，然后寻找目标 Activity。

    1
    2
    3
    4
    5
    6
    7
    <activity android:name=".SecondActivity">
    	<intent-filter>
        	<!--设置 action 属性，需要在代码中根据所设置的 name 打开指定的组件-->
        	<action android:name="com.example.smyh006intent01.MY_ACTION"/ 
        	<category android:name="android.intent.category.DEFAULT" />
        </intent-filter>
    </activity>
    1
    2
    3
    Intent intent = new Intent();
    //设置动作（实际action属性就是一个字符串标记而已）              intent.setAction("com.example.smyh006intent01.MY_ACTION"); //方法：
    startActivity(intent);

Activity之间的数据传递

数据传递

1
2
3
4
//将Activity01中的字符串传递到Activity02中
Intent intent = new Intent(this,Activity02.class);
intent.putExtra("extra_data", "Hello Activity02");
startActivity(intent);
1
2
3
//Activity02中取出传递过来的数据
Intent intent = getIntent();
String data = intent.getStringExtra("extra_data");

数据回传

1
2
3
4
//在Activity01中开启Activity02
Intent intent = new Intent(this,Activity02.class);
//startActivityForResult的第一个参数是Intent对象，第二个参数是请求码，用于判断数据的来源，输入一个唯一值即可
startActivityForResult(intent,1);
1
2
3
4
5
//Activity02中添加返回数据的代码
Intent intent = new Intent();
intent.putExtra("extra_data", "Hello Activity01");
//setResult方法向上一个Activity回传数据，第一个参数用于向Activity01返回处理结果，第2个参数是把带有数据的Intent传递回去
setResult(1,intent);

需要在Activity01中重写该方法来得到返回的数据

1
2
3
4
5
6
7
8
9
10
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    //第一个参数，请求码，第二个结果码，第三个是数据
    if(requestCode == 1){
        if(resultCode == 1){
            //获取Activity02里的返回的数据结果
            String shuju=data.getStringExtra("extra_data");
        }
    }
}

数据存储

文件存储

在Android中读取/写入文件的方法，与Java中实现I/O程序是一样的。

1
2
3
4
5
6
7
8
9
10
11
12
//打开应用程序中对应的输出流，将数据存储到指定的文件中，name表示文件名，mode表示文件的操作模式
FileOutputStream fos = openFileOutput(String name, int mode);

//打开应用程序对应的输入流，读取指定文件中的数据；
FileInputstream fis = openFileInput(String name);

/*
MODE_PRIVATE：该文件只能被当前程序读写
MODE_APPEND：该文件内容可以追加
MODE_WORLD_READABLE：该文件的内容可以被其他程序读
MODE_WORLD_WRITEABLE：该文件的内容可以被其他程序写
*/

存储数据：

1
2
3
4
5
6
7
8
9
10
String fileName = "data.txt"; //文件名称
String content = "helloworld"; //保存数据
FileOutputStream fos;
try{
    fos = openFileOutput(fileName, MODE_PRIVATE);
    fos.write(content.getBytes()); //将数据写入文件中
    fos.close(); //关闭输出流
}catch(Exception e){
    e.printStackTrace();
}

读取数据：

1
2
3
4
5
6
7
8
9
10
11
String content = "";
FileInputStream fis;
try{
    fis = openFileInput("data.txt"); //获得文件输入流对象
    byte[] buffer = new byte[fis.available()]; //创建缓冲区，并获得文件长度
    fis.read(buffer); //将文件内容读取到buffer缓冲区
    content = new String(buffer); //转换成字符串
    fis.close(); //关闭输入流
}catch(Exception e){
    e.printStackTrace();
}

ShardPreferences

轻量级存储类，将数据保存在XML文件中。

存储数据：

1
2
3
4
5
6
//获取sp对象，参数data表示文件名，MODE_PRIVATE表示文件操作模式
ShardPreferences sp = getShardPreferences("data",MODE_PRIVATE);
ShardPreferences.Editor editor = sp.edit(); //获取编辑器
editor.putString("name", "传智播客"); //存入String类型数据
editor.putInt("age", 8); //存入Int类型数据
editor.commit(); //提交修改

删除数据：

1
2
editor.remove("name"); //删除一条数据
editor.clear(); //删除所有数据

获取数据：

1
2
3
ShardPreferences sp = getShardPreferences("data",MODE_PRIVATE);
//若name不存在，返回“”值，即空值
String data = sp.getString("name","")

SQLite数据库

数据库的创建

Android 使用 SQLiteOpenHelper 的子类创建数据库，因此需要创建一个类继承自 SQLiteOpenHelper，并重写该类中的 OnCreate()方法和 onUpgrade()方法即可。

1
2
3
4
5
6
7
8
9
10
11
12
public class MyHelper extends SQLiteOpenHelper{
    public MyHelper(COntext context){
        super(cotext, "itcast.db", null, 2);
    }
    //数据库第一次被创建时调用该方法
    public void onCreate(SQLiteDatabase db){
        //初始化数据库的表结构，执行一条建表的SQL语句
        db.execSQL("CREATE TABLE information(_id INTEGER PRIMARY KEY AUTOINCREMENT,name VARCHAR(20), price INTEGER)")
    }
    //当数据库的版本号增加时调用
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion){}
}

数据库的使用

增加一条数据

1
2
3
4
5
6
7
8
public void insert(String name,String price){
    SQLiteDatabase db = helper.getWriteableDatabase(); //获取可读写SQLiteDatabase对象
    ContentValues values = new ContentValues(); //创建ContentValues对象
    values.put("name", name); //将数据添加到ContentValues对象
    values.put("price", price); 
    long id = db.insert("information",null,values); //插入一条数据到information对象，第一个参数是数据表名称，第二个参数表示如果发现将要插入的行为空行时，会将这个列名的值设为null，第三个参数为ContentValues对象
    db.close(); //关闭数据库
}

修改一条数据：

1
2
3
4
5
6
7
8
public int update(String name,String price){
    SQLiteDatabase db = helper.getWriteableDatabase(); 
    ContentValues values = new ContentValues(); 
    values.put("price", price); 
    long id = db.update("information", values, "name=?", new String[]{name}); //修改数据库中的数据，第一个参数是数据表名称，第二个参数为ContentValues对象，第三个参数为可选的where语句，第四个参数表示whereClause语句中表达式的占位参数列表，这些字符串会替换掉where条件中的“？”
    db.close(); 
    return number;
}

BroadcastReceiver

广播接收者的创建

静态注册：

1
2
3
4
5
6
7
8
9
10
public class MyReceiver extends BroadcastReceiver{
    public MyReceiver(){
    }
    @Override
    public void onReceive(Context context, Intent intent){
        throw new UnsupportedOperationException("Note yet implemented");
    }
}
//创建MyReceiver继承自BroadcastReceiver，默认包含一个构造方法和一个onReceive()方法。其中onReceive()方法用于实现广播接收者的相关操作，由于该方法尚未实现，因此会抛出异常，在实现方法时删除异常即可
//静态注册是创建一个广播接收者，并在清单文件中完成注册

动态注册：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 @Override
protected void onCreate(Bundle saveInstanceState){
    super.onCreate(savedInstanceState);
    //实例化广播接收者
    MyReceiver receiver = new MyReceiver();
    //实例化过滤器并设置要过滤的广播
    String action = "android.provider.Telephony.SMS_RECEIVED";
    IntentFilter intentFilter = new IntentFilter(action);
    //注册广播
    registerReceiver(receiver,intentfilter);
}
@Override
protected void onDestroy(){
    super.onDestory();
    //当Activity销毁时注册BroadcastReceiver
    unregisterReceiver(receiver);
}
//动态注册是创建一个广播接收者，并在Activity中通过代码进行注册。动态注册的广播接收者的生命周期依赖于注册广播的组件

自定义广播

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class MainActivity extends AppCompatActivity{
    @overvide
    protected void onCreate(Bundle savedInstanceState){
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    public void send(View view){
        //创建Intent对象
        Intent intent = new Intent();
        //定义广播的事件类型（类型名称是自定义的，该名称必须与清单文件中注册自定义广播接收者的类型名称一致）
        intent.setAction("Help_Stitch");
        //发送广播
        sendBroadcast(intent);
    }
}
1
2
3
4
5
6
7
8
9
10
//创建一个广播接收者MyBroadcastReceiver，用于接收自定义广播事件
public class MyBroadcastReceiver extends BroadcastReceiver{
    public MyReceiver(){
    }
    @Override
    public void onReceive(Context context, Intent intent){
        Log.i("MyBroadcastReceiver","自定义的广播接收者，接收到了求救的广播事件");
        Log.i("MyBroadcastReceiver",intent.getAction());
    }
}
1
2
3
4
5
6
7
<!--在清单文件中设置自定义广播接收者的事件类型-->
<receiver android:name=".MyBroadcastReceiver">
	<intent-filter>
		<!--类型要一致-->
		<Action android:name="Help_Stitch"/>
	<intent-filter>
</receiver>

广播的类型

有序广播

无序广播

Service（服务）

Service（服务）是一个长期运行在后台的用户组件，没有用户界面。即使切换到另一个应用程序，服务也可以在后台运行，因此服务更适合执行一段时间而又不需要显示界面的后台操作，如下载数据，播放音乐等。

服务的生命周期

img

  • onCreate() ：第一次创建服务时执行的方法；
  • onDestory()：服务被销毁时执行的方法；
  • onStartCommand()：客户端通过调用startService()方法启动服务时执行该方法；
  • onBind()：客户端调用bindService()方法启动服务时执行该方法；
  • onUnbind()：客户端调用unBindService()断开服务绑定时执行的方法。

当通过startService()方法启动服务时，执行的生命周期方法为onCreate()、onStartCommand()，然后服务处于运行状态，直到自身调用stopSelf()方法或者其他组件调用stopService()方法时服务停止，最终被系统销毁。当使用bindService()方法启动服务时，执行的生命周期方法为onCreate() 、onBind()，然后服务处于运行状态，直到调用unBindService()方法时，服务被解绑调用onUnbind()方法，最终被销毁。

服务的启动方式

startService方式启动：

通过startService方式启动，服务会长期在后台运行，并且服务的状态与开启者的状态没有关系，即使启动服务的组件以及被销毁，服务也会依旧运行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//创建一个Service类，重写Service生命周期的方法
public class MyService extends Service{
    @Nullable
    @Override
    public IBinder onBind(Intent intent){
        return null;
    }
    public void onCreate(){
        super.onCreate();
        Log.i("StartService", "onStartCommand()");
        return super.onStartCommandIintent, flags, startId);
    }
    public void onDestory(){
        super.onDestory();
        Log.i("startService","onDestory()");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class MainActivity extends AppCompatActivity{
    @override
    protected void onCreate(Bundle savedInstanceState){
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button start = (Button) findViewById(R.id.btn_start);
        Button stop = (Button) findViewById(R.id.btn_stop);
    }
    //开启服务的方法
    public void start(View view){
        Intent intent = new Intent(this, MyService.class);
        startService(intent);
    }
    //关闭服务的方法
    public void stop(View view){
        Intent intent = new Intent(this, MyService.class);
        stopService(intent);
    }
}

bindService方式启动：

当一个组件通过bindService方式启动服务时，服务会与组件绑定。一个被绑定的服务听提供一个客户端与服务器接口，允许组件与服务交互，发送请求，得到结果。多个组件可以绑定一个服务，当调用onUnbind()方法时，这个服务就会被销毁。

bindService()方法的完整方法名为bindService(Intent service,ServiceConnection conn,int flags)，该方法的3个参数完整如下：

  • Intent对象用于指定要启动的Service。
  • ServiceConnection对象用于指定监听调用者与Service之间的连接状态。当调用者与Service连接成功时，将回调该对象的onServiceConnected(ComponentName name,IBinder service)方法。断开连接时，将回调该对象的onServiceDisconnected(Component Name name)方法。
  • flags指定绑定时是否自动创建Service（如果Service还未创建）。该参数可指定为0，即不自动创建，也可指定为“BIND_AUTO_CREATE”，即自动创建。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class MyService extends Service{
    //创建服务的代理，调用服务中的方法
    class MyBinder extends Binder{
        public void callMethodInService(){
            methodInservice();
        }
    }
    @Override
    public void onCreate(){
        Log.i("MyService","创建服务，调用onCreate()");
        super.onCreate();
    }
    @Override
    public IBinder onBlind(Intent intent){
        Log.i("MyService","绑定服务，调用onbind()");
        return new MyBlinder();
    }
    public void methodInService(){
        Log.i("MyService","自定义方法methodInService()");
    }
    @Override
    public boolean onUnbind(Intent intent){
        Log,i("MyService","解绑服务，调用onUnbind()");
        return super.onUnbind(intent);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public class MainActivity extends AppCompatActivity{
    private MyService.MyBinder myBinder;
    private MyConn myconn;
    protected void onCreate(Bundle savedInstanceState){
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    //绑定服务
    public void btnBind(View view){
        if(myconn == null){
            myconn = new MyConn();
        }
        Intent intent = new Intent(this, MyService.class);
        //参数1是Intent，参数2是连接对象，参数3是flags表示如果服务不存在就创建
        bindService(intent, myconn, BIND_AUTO_CREATE);
    }
    //解绑服务
    public void btnUnbind(View view){
        if(myconn != null){
            unbindService(myconn);
            myconn = null;
        }
    }
    //调用服务中的方法
    public void btnCall(View view){
		myBinder.callMethonInService();
    }
    //创建MyConn类，用于实现连接服务
    private class MyConn implements ServiceConnection{
        //当成功绑定到服务时调用的方法，返回MyService里面的IBinder对象
        public void onServiceConnected(ComponentName name, IBinder service){
            myBinder = (MyService.Mybinder) service;
            Log.i("MainActivity","服务成功绑定，内存地址为："+myBinder.toString());
        }
        //当服务失去连接时调用的方法
        public void onServiceDisconnected(componentName name){
        }
    }
}

课堂测验题目与问答

（不完整，有些没拍到，答案也可能有误）

  1. Android系统的内核是

    • Java
    • Linux
    • C++
    • Kotlin

  2. 安装Android开发环境，下面哪一步不是必须的

    • 下载并安装Android Studio
    • 下载Android SDK
    • 创建模拟器—Android Virtual Device（AVD）

  3. 布局资源的文件格式是

    • R
    • XML
    • HTML
    • JSON

  4. Android 项目中的Java源代码将被编译成__文件

    • Class
    • dex

  5. Intent intent=new Intent(MainActivity.thie, SecondActivity.class);此处设置的意图是一个

    • 显示意图
    • 隐式意图

  6. 如果在Activity_A中用数据回传方式启动Activity_B，则需要在Activity_A中调用以下方法中的：

    • startActivity()
    • startActivityForResult()
    • setResult()

  7. 如果在Activity_A中用数据回传方式启动Activity_B，则需要在Activity_A中重写以下方法中的：

    • onCreate()
    • setResult()
    • onActivityResult()

  8. 以下代码行用于完成ShardPreferences数据的写操作，哪一步有错？

    • ShardPreferences sp = getShardPreferences(“user”,MODE_PRIVATE);
    • ShardPreferences.Editor editor = sp.edit();
    • editor.putExtra(“name”,”张三”); （应该为 editor.putString）
    • editor.commit();

  9. 用文件方式写一个字符串数据str，以下代码行有误的是：

    • FileputStream file = openInputStream(“user.txt”,MODE_PRIVATE); （是 openFileInput）
    • file.write(str.getBytes());
    • file.close();

  10. 在读文件输入流对象file中的数据时，以下代码行可以准备一个合适长度的字节数组作为缓冲区

    • byte[] buff = new byte[file.length];
    • byte[] buff = file.avilable();
    • byte[] buff = new byte[file.available()];

  11. 一个SQLiteOpenHelper子类的作用包括：【多选题】

    • 生成或打开数据库文件
    • 向数据库中插入数据表
    • 管理数据库版本升级事项
    • 向数据表中插入数据行

  12. ContenValues对象可能使用被用在以下方法中的__：【多选题】

    • insert()
    • delete()
    • update()
    • query()

  13. 给定一张数据表”students“，现在要删除字段“number”为“20193312089”的数据行，下列方法正确的是：

    • delete(“students”,”number”,”20193312089”)
    • delete(“students”,”number=?”,”20193312089”)
    • delete(“students”,”number=?”,”new String(“20193312089”)
    • delete(“students”,”number=?”,new String[]{“20193312089”})

  14. 给定一张数据表”students“，现在查询所有数据行，其代码行如下：cursor = query(“students”,null,null,null,nyll,null,null); 以下说法正确的是：【多选题】

    • cursor是一个整数，代表数据行的总数
    • cursor.getCount() 返回数据行的总数
    • cursor.MoveToNext返回的是布尔值
    • cursor.getString() 可以访问当前数据行的全部字符串型字段的值

  15. 自定义适配器BaseAdapter子类时，需要实现的方法中，形成单行数据项视图的是

    • getCount()
    • getItem()
    • getItemId()
    • getView()

  16. 创建一个继承自BroadcastReceiver的广播接收者子类，需要重写它的__方法。

    • onCreate()
    • onReceive()
    • onStart()

  17. 注册一个广播接收者时，代码行__用于设置要接收的广播名称。

    • MyReceiver receiver = new MyReceiver();
    • IntentFilter filter = new IntentFilter();
    • filter.addAction(“android.intent.action.BOOT_COMPLETED”);
    • registerReceiver(receiver,filter);

  18. 创建一个Service子类时，需要重写它的__方法。

    • onCreate()
    • onStartCommand()
    • onBind()
    • onDestroy()

  19. 在MainAvtivity()中，用startService()方法启动MyService，当退出MainActivity时

    • MyService将在后台继续运行
    • MyService将随之销毁

  20. 在MainActivity中用bindService方法启动MyService，下列代码行不正确的是：

    • Intent service = new Intent(MainActivity.this,MyService.class)
    • ServiceConnection sc = new ServiceConnection(){…}
    • bindService(service, sc, null) （null 改为 BIND_AUTO_CREATE）

  21. 一个SQLite数据库的创建onCreate（）方法何时被调用？

    答：数据库第一层次创建时调用

  22. Service 运行在前台还是后台？

    运行在后台

  23. 要使用系统服务，通常需要哪些基本步骤？

    略

英文班期中考试题目

（只拍到部分题，答案可能有误）

填空题

  1. manifest 是一个 xml 文件，它描述了您在 android 操作系统上的应用程序，它被命名为 AndroidManifest.xml，并存在于您的 manifests 项目目录中。
  2. Android中的用户界面（UI）是通过布局文件实现的，同时 Service(服务)在后台运行耗时的任务。
  3. apple 是一个 xml 文件，用于告知其小部件如何在屏幕上显示，并在创建活动时使用 apple 的方法将其转换为活动视图。
  4. Android 项目中的所有 Java 类都位于java文件夹中，而图像文件，音频文件和 XML 文件等所有资源都保留在res文件夹中。
  5. 要将样式 “ mytextstyle” 应用于 Textview，其样式属性应设置为 style = “@style/mytextstyle”。
  6. 通过设置 textview 的 drawableLeft 属性，使图像出现在其左侧
  7. 在 Android 项目中创建新 Activity 时，<Activity> 会显示在 manifests 中
  8. 给定 Activity 中的成员变量，findViewById()方法可以帮助它获取对按钮小部件的引用，同时setOnClickListenter()方法在此按钮上设置侦听器以响应用户的单击动作。
  9. 要使用 startActivity() 方法启动Activity，需要一个intent对象。
  10. 当 Activity 对用户可见时，引发的回调是onStart()。当活动失去焦点时，将引发onPause()回调。
  11. ShardPreferences 对象以key/value(键值对)形式存储数据，而 Flie 输入/输出流以输入输出流(流)形式存储或写入数据。
  12. SQLiteOpenHelper 类可以创建或打开SQLite数据库，而该类提供诸如insert(),delete(),update() 和 query() 之类的数据库操作方法。
  13. ListView 是一个小部件，用于以统一的样式显示未知数字的数据项。应将一个item对象设置为 ListView 以获取数据项的计数和视图。此外，还设计了一个额外的adapter组件，用于以相同方式显示每个数据项 。
  14. 除了 intent 外，还应创建一个IBinder对象来绑定服务，而服务类中的onBind()回调将 Binder 对象返回给客户端。
  15. 要注册广播接收器，应创建一个Intent对象来设置接收收听的广播的事件类型名称。

分析题

课程应用程序：

LoginActivity；用户输入诸如 user_name，user_role（两个角色：student / teacher）和 password 之类的帐户信息。当用户单击“ Reset” 按钮时，将清除所有输入的信息。 单击”Login” 按钮可进行帐户检查。如果帐户合法，则会显示下一个 Activity。
CurriculaActivity：将显示该用户的课程信息，包括课程号（COURSE NUMBER），课程名称（COURSE NAME），团队（TEAM），学分（CREDIT）。课程可能是学生还是教师，取决于用户的角色。

任务列表

任务一：分别设计和绘制 LoginActivity 和 CurriculaActivity 的两个布局的草稿。

略

任务二：描述您可以设置为“Login”按钮的监听器

第一种，匿名内部类的方法实现

第二种，通过实现onClick()方法实现

第三种点击事件，即在当前 Activity 中实现 OnClickLisenter 接口（建议这种）

任务三：您将使用哪种数据存储技术来存储用户帐户和课程信息？说明如何使用以及为什么使用。

主要有文件存储，SharedPreferences，SQLite数据库三种存储。

建议使用SQLite数据库，因为存储数据较多，也方便维护。

如何使用：

数据库的创建：创建一个类继承自SQLiteOpenHelper，重写OnCreate()和onUpgrade()方法

任务四：假设一个学生用户已成功登录该应用程序，分析了如何查询和显示其课程。

首先已经获取了学生的 user_name，与数据库进行匹配，执行查询代码，最后输出信息显示到textView上。

查询代码类似如下：

1
2
3
4
5
6
7
db=myHelper.getReadableDatabase();
Cursor cursor=db.query("information", null, "_user_name=?", new String[]{user_name},null,null,null,);
if(cursor.getString(1)=='***'){ #人名,不过最好是学号
	textView.setText("课程号:"+cursor.getString(2)+";课程名称:"+cursor.getString(3)+";团队:"+cursor.getString(4)+";学分:"+cursor.getString(5));
}
cursor.close();
db.close();

考后回顾

老师人好，大多数同学都八九十分的样子。

期末考不要挂科就行。