Android学习(一)

日志

  • Log. v()。 用于 打印 那些 最为 琐碎 的、 意义 最小 的 日志 信息。 对应 级别 verbose, 是 Android 日志 里面 级别 最低 的 一种。
  • Log. d()。 用于 打印 一些 调试 信息, 这些 信息 对 你 调试 程序 和 分析 问题 应该 是有 帮助 的。 对应 级别 debug, 比 verbose 高 一级。
  • Log. i()。 用于 打印 一些 比较 重要的 数据, 这些 数据 应该 是你 非常 想 看到 的、 可以 帮你 分析 用户 行为 数据。 对应 级别 info, 比 debug 高 一级。
  • Log. w()。 用于 打印 一些 警告 信息, 提示 程序 在这 个 地方 可能 会有 潜在 的 风险, 最好 去 修复 一下 这些 出现 警告 的 地方。对应 级别 warn, 比 info 高 一级。
  • Log. e()。 用于 打印 程序 中的 错误 信息, 比如 程序 进入 到了 catch 语句 当中。 当 有错误 信息 打印 出来 的 时候, 一般 都 代表 你的 程序 出现 严重 问题 了, 必须 尽快 修复。 对应 级别 error, 比 warn 高 一级。

活动(Activity)

活动( Activity) 是最 容易 吸引 用户 的 地方, 它是 一种 可以 包含 用户 界面 的 组件, 主要 用于 和 用户 进行 交互。

  1. 在 java/ com. example. activitytest中新建一个activity
  2. 在 src/layout中创建一个布局文件, 在activity中加载布局()回到 FirstActivity, 在 onCreate() 方法 中 加入 如下 代码: setContentView( R. layout. first_ layout);
  3. 在 AndroidManifest 文件 中 注册

配置 主 活动 的 方法 其 实在 第 1 章 中 已经 介绍 过了, 就是 在< activity> 标签 的 内部 加入< intent- filter> 标签, 并在 这个 标签 里 添加< action android: name=” android. intent. action. MAIN”/> 和< category android: name=” android. intent. category. LAUNCHER” />这 两句 声明 即可。

Toast(短暂出现的提示框)

首先 需要 定义 一个 弹出 Toast 的 触发 点, 正好 界面 上有 个 按钮, 那 我们 就让 点击 这个 按钮 的 时候 弹出 一个 Toast 吧。 在 onCreate()中添加

1
2
3
4
5
6
7
8
9
10
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Button button=(Button) findViewById(R.id.button);
button.setOnClickListener(new View.OnClickListener(){
public void onClick(View v){
Toast.makeText(MainActivity.this,"You clicked Button", Toast.LENGTH_SHORT).show();
}
});
}

得到 按钮 的 实例 之后, 我们 通过 调用 setOnClickListener() 方法 为 按钮 注册 一个 监听器, 点击 按钮 时 就会 执行 监听器 中的 onClick() 方法。

静态方法makeText() 创建 出 一个 Toast 对象, 然后 调用 show() 将 Toast 显示 出来 就可以 了。 这里 需要 注意 的 是, makeText() 方法 需要 传入 3 个 参数。 第一个 参数 是 Context, 也就是 Toast 要求 的 上下文, 由于 活动 本身 就是 一个 Context 对象, 因此 这里 直接 传入 FirstActivity. this 即可。 第二个 参数 是 Toast 显示 的 文本 内容, 第三 个 参数 是 Toast 显示 的 时 长, 有两 个 内置 常量 可以 选择 Toast. LENGTH_ SHORT 和 Toast. LENGTH_ LONG。

  1. 在res/menu中新建Menu resource file

  2. 在新建出来的menuxml文件中添加items

  3. 在activity中重写onCreateOptionsMenu()方法

    1
    2
    3
    public boolean onCreateOptionsMenu(Menu menu) {
    getMenuInflater().inflate(R.menu.main,menu); return true;
    }

    inflate() 方法 接收 两个 参数, 第一个 参数 用于 指定 我们 通过 哪一个 资源 文件 来 创建 菜单, 这里 当然 传入 R. menu. main。 第二个 参数 用于 指定 我们 的 菜单项 将 添加 到 哪一个 Menu 对象 当中, 这里 直接 使用 onCreateOptionsMenu() 方法 中 传入 的 menu 参数。 然后 给 这个 方法 返回 true, 表示 允许 创建 的 菜单 显示 出来, 如果 返回 了 false, 创建 的 菜单 将 无法 显示。

  4. 定义菜单响应事件。在acticity中重写onOprionsItemsSelected()方法:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    public boolean onOptionsItemSelected(MenuItem item) {
    switch (item.getItemId())
    {
    case R.id.add_item:
    Toast.makeText(this,"You clicked Add", Toast.LENGTH_SHORT).show();
    break;
    case R.id.remove_item:
    Toast.makeText(this,"You clicked Remove", Toast.LENGTH_SHORT).show();
    break;
    default:
    Toast.makeText(this,"Default",Toast.LENGTH_SHORT).show();
    }
    return true;
    }

销毁事件

只要 按 一下 Back 键 就可以 销毁 当前 的 活动 了。 不过 如果 你 不想 通过 按键 的 方式, 而是 希望 在 程序 中 通过 代码 来 销毁 活动, 当然 也可以, Activity 类 提供 了 一个 finish() 方法, 我们 在 活动中 调用 一下 这个 方法 就可以 销毁 当前 活动 了。

Intent(连接各个活动)

Intent 是 Android 程序 中 各组 件 之间 进行 交互 的 一种 重要 方式, 它不 仅可 以指 明 当前 组件 想要 执行 的 动作, 还可 以在 不同 组件 之间 传递 数据。 Intent 一般 可被 用于 启动 活动、启动 服务 以及 发送 广播 等 场景。

显示Intent

Intent 有多 个 构造 函数 的 重载, 其中 一个 是 Intent( Context packageContext, Class<?> cls)。 这个 构造 函数 接收 两个 参数, 第一个 参数 Context 要求 提供 一个 启动 活动 的 上下文, 第二个 参数 Class 则是 指定 想要 启动 的 目标 活动, 通过 这个 构造 函数 就可以 构建 出 Intent 的“ 意图”。 然后 我们 应该 怎么 使用 这个 Intent 呢? Activity 类 中 提供 了 一个 startActivity() 方法, 这个 方法 是 专门 用于 启动 活动 的, 它 接收 一个 Intent 参数, 这里 我们将 构建 好的 Intent 传入 startActivity() 方法 就可以 启动 目标 活动 了。

修改MainActivity中按钮点击事件

1
2
3
4
5
6
button.setOnClickListener(new View.OnClickListener(){
public void onClick(View v){
Intent intent=new Intent(MainActivity.this,Test1Activity.class);
startActivity(intent);
}
});

MainActivity.this作为上下文,Test1Activity.class作为目标活动。通过startActivity来执行Intent。

隐式Intent

它 并不 明确 指出 我们 想要 启动 哪一个 活动, 而是 指定 了 一系列 更为 抽象 的 action 和 category 等 信息, 然后 交由 系统 去 分析 这个 Intent, 并 帮我 们 找出 合适 的 活动 去 启动。

  1. 在AndroidManifest.xml中指定活动能够响应的action和category

    1
    2
    3
    4
    5
    6
    <activity android:name=".Test1Activity">
    <intent-filter>
    <action android:name="com.example.activitytest.ACTION_START"/>
    <category android:name="android.intent.category.DEFAULT"/>
    </intent-filter>
    </activity>

    在< action> 标签 中 我们 指明 了 当前 活动 可以 响应 com. example. activitytest. ACTION_ START 这个 action, 而< category> 标签 则 包含 了 一些 附加 信息, 更 精确 地 指明 了 当前 的 活动 能够 响应 的 Intent 中 还可 能带 有的 category。 只有< action> 和< category> 中的 内容 同时 能够 匹配 上 Intent 中指 定的 action 和 category 时, 这个 活动 才能 响应 该 Intent。

  2. 修改按钮的点击事件

    1
    2
    3
    4
    5
    6
    button.setOnClickListener(new View.OnClickListener(){
    public void onClick(View v){
    Intent intent=new Intent("com.example.activitytest.ACTION_START");
    startActivity(intent);
    }
    });

    每个 Intent 中 只能 指定 一个 action, 但却 能 指定 多个 category


更多隐式Intent用法

使用 隐式 Intent, 我们 不仅 可以 启动 自己 程序 内 的 活动, 还可以 启动 其他 程序 的 活动, 这 使得 Android 多个 应用 程序 之间 的 功能 共享 成为 了 可能。 比如说 你的 应用 程序 中 需要 展示 一个 网页, 这时 你 没有 必要 自己 去 实现 一个 浏览器( 事实上 也不 太 可能), 而是 只需 要 调用 系统 的 浏览器 来 打开 这个 网页 就 行了。

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

了 Intent 的 action 是 Intent. ACTION_ VIEW, 这是 一个 Android 系统 内置 的 动作, 其 常 量值 为 android. intent. action. VIEW。 然后 通过 Uri. parse() 方法, 将 一个 网址 字符串 解析 成 一个 Uri 对象, 再 调用 Intent 的 setData() 方法 将 这个 Uri 对象 传递 进去。

setData()方法,它 接收 一个 Uri 对象, 主要 用于 指定 当前 Intent 正在 操作 的 数据, 而这 些 数据 通常 都是 以 字符串 的 形式 传入到 Uri. parse() 方法 中 解析 产生 的。

与此 对应, 我们 还可 以在< intent- filter> 标签 中 再 配置 一个< data> 标签, 用于 更 精确 地 指定 当前 活动 能够 响应 什么 类型 的 数据。< data> 标签 中 主要 可以 配置 以下 内容。

  • android: scheme。 用于 指定 数据 的 协议 部分, 如上 例 中的 http 部分。
  • android: host。 用于 指定 数据 的 主机 名 部分, 如上 例 中的 www. baidu. com 部分。
  • android: port。 用于 指定 数据 的 端口 部分, 一般 紧随 在 主机 名 之后。
  • android: path。 用于 指定 主 机名 和 端口 之后 的 部分, 如一 段 网址 中 跟在 域名 之后 的 内容。
  • android: mimeType。 用于 指定 可以处理 的 数据 类型, 允许 使用 通配符 的 方式 进行 指定。

除了 http 协议 外, 我们 还可以 指定 很多 其他 协议, 比如 geo 表示 显示 地理 位置、 tel 表示 拨 打电话。