Android学习

安卓期末考题复习

知识点总结

View

布局管理

线性布局

实现垂直或者水平布局。

orientation属性控制控件排列方向，包含两个属性值：vertical(垂直)、horizontal(水平)；weight属性表示权重。

相对布局

根据控件之间的相对位置进行布局。

帧布局

控件只能放在页面的左上角，新添加的控件会覆盖已存在的控件。

表格布局

将整个页面划分为行列表格进行布局。

绝对布局

控件的位置根据x,y坐标进行设定。

控件

view和viewGroup

TextView

autoLink属性

Button

EditView

imageView

RadioGroup

RadioButton

checkBox

Spinner

Toast

Toast是Android系统提供的轻量级信息提醒机制，用于向用户提示即时消息，它显示在应用程序界面的最上层，显示一段时间后自动消失不会打断当前操作，也不获得焦点。

Toast.makeText(MainActivity.this,“WIFI已断开”,Toast.LENGTH_SHORT).show();

BroadCast

广播机制实现流程

BroadcastReceiver

广播的接收 注册在哪 怎么注册 静态注册 动态注册

1. 创建BroadcastReceiver类： 创建一个继承自 BroadcastReceiver 的类，并在其中重写 onReceive() 方法，以便在接收到广播时执行特定的操作。

   public class MyBroadcastReceiver extends BroadcastReceiver {
       @Override
       public void onReceive(Context context, Intent intent) {
           // 在这里处理接收到的广播
           String action = intent.getAction();
           if ("your.custom.action".equals(action)) {
               // 根据广播的action进行相应的处理
           }
       }
   }
   

2. 注册BroadcastReceiver： 有两种方式可以注册 BroadcastReceiver，一种是在代码中动态注册，另一种是在AndroidManifest.xml中静态注册。

   • 动态注册： 在Activity或其他组件的生命周期内动态注册Receiver。

     IntentFilter filter = new IntentFilter("your.custom.action");
     registerReceiver(new MyBroadcastReceiver(), filter);
     

     记得在组件销毁时注销Receiver：

     @Override
     protected void onDestroy() {
         super.onDestroy();
         unregisterReceiver(myBroadcastReceiver);
     }
     

   • 静态注册： 在 AndroidManifest.xml 中注册，这样Receiver会随着应用的启动而启动，不需要额外的注册代码。

     <receiver android:name=".MyBroadcastReceiver">
         <intent-filter>
             <action android:name="your.custom.action" />
             <category android:name="android.intent.category.DEFAULT" />
         intent-filter>java
     receiver>
     

3. 发送广播： 使用 Context 的 sendBroadcast() 方法发送广播。

   Intent intent = new Intent("your.custom.action");
   sendBroadcast(intent);
   

   如果需要发送有序广播，可以使用 sendOrderedBroadcast()。

Activity

生命周期

1.onCreate(): 在Activity第一次创建时调用。这里通常进行初始化，例如设置用户界面、绑定数据等。

2.onStart(): 在Activity变得对用户可见时调用。Activity此时还不可与用户交互。

3.onResume(): 在Activity开始与用户交互时调用。Activity位于前台并获取用户焦点。

4.onPause(): 在系统即将启动另一个Activity时调用。这时Activity仍然部分可见，但不可与用户交互。应该在这里保存任何需要在暂停期间保存的数据。

5.onStop(): 在Activity不再对用户可见时调用。Activity被其他Activity完全遮盖。

6.onRestart(): 在Activity从停止状态变为活动状态之前调用。这通常用于重新初始化已释放的资源。

7.onDestroy(): 在Activity被销毁之前调用。通常在这里做清理工作。

各类测试中Activity的回调函数调用顺序

正常启动程序：onCreate → onStart → onResume【创建、启动、恢复】
程序启动后点击返回：onPause → onStop → onDestory【暂停、停止、再见】
正常启动后按Home键：onPause → onStop
按Home键后再单击应用进入：onRestart → onStart → onResume
正常启动后切换为横屏（Ctrl+F11）：onPause → onStop → onDestroy → onCreate → onStart→ onResume
锁屏后解锁：onPause → onStop → onRestart → onStart → onResume
来电通话后挂机（来电是以通知的形式显示，接通后onPause部分遮挡？，挂机后onResume）：onPause → onResume

Activity的任务栈和启动模式

1.standard模式，每启动一个Activity就会在栈顶创建一个新的实例。

2.singleTask模式，检查栈中是否存在当前Activity的实例，如果存在，把它之上的实例出栈。

3.singleInstance模式，创建新的任务栈。

两个Activity之间传递数据❤

直接举例说明：FirstActivity将两个整数通过Intent传给SecondActivity，进行加法计算后，将结果通过广播返回给FirstActivity，用Toast的形式将结果展示出来。

步骤：

1. 在 FirstActivity 中启动 SecondActivity 并传递两个整数。
2. 在 SecondActivity 中接收这两个整数，执行加法计算。
3. 从 SecondActivity 发送一个包含计算结果的广播。
4. FirstActivity 接收这个广播并使用 Toast 显示结果。

代码：

// FirstActivity.java
package com.example.myapp;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;

public class FirstActivity extends AppCompatActivity {

private static final String ACTION_RESULT = "com.example.myapp.ACTION_RESULT";
private ResultReceiver resultReceiver;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_first);

    // 注册广播接收器
    resultReceiver = new ResultReceiver();
    IntentFilter filter = new IntentFilter(ACTION_RESULT);
    registerReceiver(resultReceiver, filter);

    // 启动 SecondActivity 并传递两个整数
    Intent intent = new Intent(this, SecondActivity.class);
    intent.putExtra("num1", 5);
    intent.putExtra("num2", 10);
    startActivity(intent);
}

@Override
protected void onDestroy() {
    super.onDestroy();
    // 注销广播接收器
    unregisterReceiver(resultReceiver);
}

// 广播接收器类
private class ResultReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent != null && ACTION_RESULT.equals(intent.getAction())) {
            int result = intent.getIntExtra("result", 0);
            Toast.makeText(FirstActivity.this, "Result: " + result, Toast.LENGTH_LONG).show();
        }
    }
}

}

// SecondActivity.java
package com.example.myapp;

import android.content.Intent;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;

public class SecondActivity extends AppCompatActivity {

private static final String ACTION_RESULT = "com.example.myapp.ACTION_RESULT";

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_second);

    // 获取传递过来的两个整数
    Intent intent = getIntent();
    int num1 = intent.getIntExtra("num1", 0);
    int num2 = intent.getIntExtra("num2", 0);

    // 进行加法运算
    int result = num1 + num2;

    // 通过广播发送结果
    Intent resultIntent = new Intent(ACTION_RESULT);
    resultIntent.putExtra("result", result);
    sendBroadcast(resultIntent);

    // 结束 SecondActivity
    finish();
}

}

<application
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:roundIcon="@mipmap/ic_launcher_round"
    android:supportsRtl="true"
    android:theme="@style/AppTheme">
    <activity android:name=".SecondActivity">activity>
    <activity android:name=".FirstActivity">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
        intent-filter>
    activity>
application>

Service

生命周期

• 创建：onCreate() -> 服务被创建。
• 启动：onStartCommand() -> 服务被启动，可以被调用多次。
• 绑定：onBind() -> 客户端绑定到服务。
• 解绑：onUnbind() -> 所有客户端都解绑了服务。
• 销毁：onDestroy() -> 服务被销毁。

如何启动

Service的启动有两种方式

startService()和bindService()

一、startService()方式

// MyService.java
package com.example.myapp;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;

public class MyService extends Service {

private static final String TAG = "MyService";

@Override
public void onCreate() {
    super.onCreate();
    Log.d(TAG, "Service Created");
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    Log.d(TAG, "Service Started");
    // 在这里处理任务
    return START_STICKY;
}

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

@Override
public IBinder onBind(Intent intent) {
    return null;
}

}

// 在Activity中启动服务
Intent intent = new Intent(this, MyService.class);
startService(intent);

// 在Activity中停止服务
Intent intent = new Intent(this, MyService.class);
stopService(intent);

二、bindService()方式

这种方式用于绑定一个服务，适用于需要与活动进行交互的情况。绑定服务后，活动和服务之间可以进行通信。

// MyService.java
package com.example.myapp;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.util.Log;

public class MyService extends Service {

private static final String TAG = "MyService";
private final IBinder binder = new LocalBinder();

public class LocalBinder extends Binder {
    MyService getService() {
        return MyService.this;
    }
}

@Override
public void onCreate() {
    super.onCreate();
    Log.d(TAG, "Service Created");
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    Log.d(TAG, "Service Started");
    return START_STICKY;
}

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

@Override
public IBinder onBind(Intent intent) {
    return binder;
}

public String getGreeting() {
    return "Hello from Service";
}

}

// 在Activity中绑定和解绑服务
package com.example.myapp;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {
private static final String TAG = “MainActivity”;
private MyService myService;
private boolean isBound = false;

private ServiceConnection serviceConnection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
        MyService.LocalBinder binder = (MyService.LocalBinder) service;
        myService = binder.getService();
        isBound = true;
        Log.d(TAG, myService.getGreeting());
    }

    @Override
    public void onServiceDisconnected(ComponentName name) {
        isBound = false;
    }
};

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    // 绑定服务
    Intent intent = new Intent(this, MyService.class);
    bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);
}

@Override
protected void onDestroy() {
    super.onDestroy();
    if (isBound) {
        // 解绑服务
        unbindService(serviceConnection);
        isBound = false;
    }
}

}

在 AndroidManifest.xml 中声明服务

Fragment

生命周期

1.onAttach(): 当Fragment与Activity关联时调用。可以通过参数传递的方式获取Activity的引用。

2.onCreate(): 在Fragment创建时调用。用于初始化不依赖视图的部分。

3.onCreateView(): 在Fragment创建视图层次结构时调用。需要在这里返回Fragment的视图。

4.onActivityCreated(): 当Activity的onCreate()方法返回时调用。表示Activity与Fragment的视图已经创建完毕。

5.onStart(): 在Fragment可见时调用。

6.onResume(): 在Fragment可与用户交互时调用。

7.onPause(): 在Fragment不再与用户交互时调用。

8.onStop(): 在Fragment不可见时调用。

9.onDestroyView(): 在Fragment的视图被销毁时调用。通常在这里清理与视图相关的资源。

10.onDestroy(): 在Fragment被销毁时调用。用于清理不依赖视图的资源。

11.onDetach(): 当Fragment与Activity取消关联时调用。

Intent

Intent传递数据

1. 原始数据类型：如整数（int）、浮点数（float）、字符串（String）等。
2. URI：可以通过 Intent 传递文件、网络资源等的URI。
3. Serializable对象：实现了 Serializable 接口的对象可以通过 Intent 传递，但需要注意的是，这些对象需要是可序列化的，即它们的状态可以被转换为字节流。
4. Parcelable对象：实现了 Parcelable 接口的对象也可以通过 Intent 传递。与 Serializable 相比，Parcelable 提供了更灵活的序列化方式，并且通常比 Serializable 更高效。

考试题型分析

选择题

简答题

代码题

activity通信 结果回传 一个传给另一个

数据传递

颜色定义的使用，监听按钮的方法的复写

布局管理器哪些属性是共有的

在Android开发中，布局管理器（Layout Managers）是用于在屏幕上组织和显示视图组件的系统。不同的布局管理器如LinearLayout、RelativeLayout、FrameLayout等，虽然各自有其特定的属性和行为，但它们也有一些共有的属性，这些属性可以在大多数布局管理器中找到：

1. id - 每个布局管理器都可以有一个唯一的资源ID，用于在代码中引用。
2. layout_width - 指定布局的宽度，可以是match_parent（父布局的宽度）、wrap_content（根据子视图内容自动调整）或者具体的尺寸。
3. layout_height - 指定布局的高度，与宽度类似，可以是match_parent、wrap_content或者具体尺寸。
4. background - 设置布局的背景颜色或背景资源。
5. padding - 设置布局内边距，可以是统一的数值或者分别对左、上、右、下进行设置。
6. margin - 设置布局外边距，可以是统一的数值或者分别对左、上、右、下进行设置。
7. clipChildren - 决定子视图是否被裁剪到布局的边界内。
8. clipToPadding - 决定是否裁剪子视图到内边距的边界。
9. fitsSystemWindows - 决定布局是否应该扩展到系统窗口（如状态栏或导航栏）。
10. importantForAccessibility - 定义布局对于辅助功能的重要性。
11. layout_margin, layout_marginStart, layout_marginEnd, layout_marginTop, layout_marginBottom - 这些属性用于在不同方向上设置布局的外边距。
12. layout_gravity - 指定布局在其父布局中的对齐方式。
13. animateLayoutChanges - 在某些布局管理器中，如ConstraintLayout，这个属性可以设置是否在布局变化时执行动画。
14. transitionGroup - 指定布局是否作为一个过渡组，允许子视图在过渡期间保持其状态。
15. saveEnabled - 决定布局是否应该保存其状态。

题目收集

1.Android平台由(操作系统)，(中间件)，(用户界面)和(应用软件)组成。

2.Android 四大组件是（ Activity ），（ Service ），（ BroadcaseReceiver ）和（ ContentProvider ）。

3.阐述 android:padding 和 android:layout_margin 的异同？

• android:padding 仅影响组件自身内部的空间，不会影响到其他组件。
• android:layout_margin 影响组件与其他组件之间的空间，是组件与周围环境的间隔。

4.Android中的数据存储方式

文件存储、SharedPreferences 方式、内容提供器（ Content provider ）方式、SQLite 数据库方式和网路存储方式

5.简述Toast消息提示框的特点

一种快速的即时消息；消息内容简短；悬浮于应用程序的最上方；不获得焦点；用于提示任务是否完成的消息提示机制