本 书 是 院 校 与 企 业 联 合 编 写, 理 论 结 合 实 际, 案 例 均 来 自 企 业 真 实 案 例, 且 由 企 业 一 线 技 术 人 员 编 写, 理 论 知 识 点 由 教 学 经 验 丰 富 的 院 校 骨 干 教 师 书 写, 力 图 引 导 学 生 在 知 识 结 构

Transcription

1 Java 物 联 网 程 序 设 计 基 础 主 编 周 雯 薛 文 龙 副 主 编 于 继 武 倪 晨 玮 王 艳 霞 洪 波 参 编 戴 在 林 张 方 毅 高 鹏 林 道 华 邹 梓 秀 机 械 工 业 出 版 社

2 本 书 是 院 校 与 企 业 联 合 编 写, 理 论 结 合 实 际, 案 例 均 来 自 企 业 真 实 案 例, 且 由 企 业 一 线 技 术 人 员 编 写, 理 论 知 识 点 由 教 学 经 验 丰 富 的 院 校 骨 干 教 师 书 写, 力 图 引 导 学 生 在 知 识 结 构 上 更 好 地 实 现 与 企 业 真 实 需 求 的 对 接, 从 而 有 效 提 高 其 就 业 竞 争 优 势, 顺 利 进 入 专 业 研 发 领 域 本 书 能 紧 跟 社 会 发 展 需 要, 体 现 新 技 术 新 设 备 新 工 艺, 以 就 业 为 导 向, 遵 循 技 能 人 才 成 长 和 职 业 发 展 规 律, 充 分 体 现 职 业 特 征, 满 足 学 生 职 业 生 涯 发 展 需 要, 可 操 作 性 强, 适 合 中 职 高 职 及 应 用 型 本 科 院 校 相 关 专 业 学 生 学 习 图 书 在 版 编 目 (CIP) 数 据 / 主 编. 北 京 : 机 械 工 业 出 版 社, 中 等 职 业 学 校 以 工 作 过 程 为 导 向 课 程 改 革 实 验 项 目. 计 算 机 网 络 技 术 专 业 核 心 课 程 系 列 教 材 ISBN Ⅰ.1 服 Ⅱ.1 韩 2 王 Ⅲ.1 网 络 服 务 器 配 置 中 等 专 业 学 校 教 材 Ⅳ.1TP368.5 中 国 版 本 图 书 馆 CIP 数 据 核 字 (2015) 第 号 机 械 工 业 出 版 社 ( 北 京 市 百 万 庄 大 街 22 号 邮 政 编 码 ) 策 划 编 辑 : 责 任 编 辑 : 版 式 设 计 : 责 任 校 对 : 封 面 设 计 : 责 任 印 制 : 印 刷 厂 印 刷 年 月 第 版 第 次 印 刷 184mm 260mm 印 张 千 字 册 标 准 书 号 :ISBN 定 价 :. 元 凡 购 本 书, 如 有 缺 页 倒 页 脱 页, 由 本 社 发 行 部 调 换 电 话 服 务 服 务 咨 询 热 线 : 读 者 购 书 热 线 : 封 面 无 防 伪 标 均 为 盗 版 网 络 服 务 机 工 官 网 : 机 工 官 博 :weibo.com/cmp1952 教 育 服 务 网 : 金 书 网 :

3 前 言 PREFACE 物 联 网 应 用 技 术 专 业 是 新 兴 专 业, 在 教 材 建 设 方 面 存 在 严 重 滞 后 等 问 题 开 设 物 联 网 专 业 的 院 校 逐 年 增 加, 从 事 该 行 业 技 术 人 员 的 人 数 递 增, 读 者 需 求 量 很 大 目 前 的 物 联 网 专 业 教 材, 不 是 电 子 类 的, 就 是 计 算 机 类 的, 要 不 就 是 计 算 机 网 络 类 的, 物 联 网 对 口 的 系 列 教 材 不 多 而 且 缺 少 企 业 的 参 与, 工 学 结 合 特 色 不 明 显 多 数 教 材 的 编 写 主 要 是 由 在 校 老 师 完 成 的, 而 在 校 教 师 在 完 成 教 材 编 写 的 时 候 具 有 局 限 性, 往 往 偏 重 理 论, 与 企 业 实 际 项 目 结 合 较 少 本 书 从 Java 语 言 的 基 本 特 点 人 手, 介 绍 Java 语 言 的 基 本 概 念 和 编 程 方 法, 并 深 入 介 绍 Java 语 言 的 高 级 特 性 书 中 内 容 涉 及 Java 语 言 中 的 基 本 语 法 数 据 类 型 类 异 常 及 线 程 等, 基 本 覆 盖 了 Java 语 言 的 大 部 分 实 用 技 术, 是 进 一 步 使 用 Java 语 言 进 行 技 术 开 发 的 基 础 本 书 是 院 校 与 企 业 联 合 编 写, 理 论 结 合 实 际, 案 例 均 选 自 企 业 实 际 项 目, 实 用 性 强 编 写 形 式 体 现 了 案 例 引 入 知 识 铺 垫 案 例 拓 展, 知 识 与 技 能 点 层 层 递 进 的 编 写 特 点, 从 而 实 现 企 业 岗 位 技 能 需 求 与 学 校 课 程 教 学 设 计 的 有 效 对 接 与 融 合, 并 且 在 课 程 教 学 应 用 的 过 程 中, 企 业 人 员 也 可 以 按 需 参 与 课 程 的 教 学, 最 终, 实 现 课 程 在 持 续 应 用 过 程 中 的 持 续 性 动 态 发 展 全 书 共 分 为 六 大 案 例, 建 议 学 时 数 为 72 学 时 (40 理 论 课 时 +32 实 验 课 时 ): 案 例 一 欢 迎 进 入 Java 世 界 开 发 环 境 搭 建 本 章 从 Java 入 门, 以 Android 开 发 环 境 搭 建 入 手, 重 点 介 绍 了 新 大 陆 物 联 网 实 训 平 台, 以 及 如 何 利 用 平 台 进 行 开 发 ( 建 议 学 时 :2 课 时 课 堂 教 学 +4 课 时 实 验 教 学 ) 案 例 二 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 本 章 介 绍 Java 数 据 类 型 的 分 类 取 值 范 围 以 及 变 量 的 生 命 周 期 等 内 容 ( 建 议 学 时 :6 课 时 课 堂 教 学 +4 课 时 实 验 教 学 ) 案 例 三 数 据 采 集 模 块 开 发 流 程 控 制 结 构 本 章 介 绍 了 Java 语 言 中 各 种 流 程 控 制 语 句 的 用 法 ( 建 议 学 时 :8 课 时 课 堂 教 学 +6 课 时 实 验 教 学 ) 案 例 四 四 模 块 输 入 数 据 采 集 数 组 与 集 合 本 章 主 要 介 绍 一 维 数 组 二 维 数 组 与 ArrayList List 等 集 合, 辅 助 以 实 验 系 统 的 设 计 案 例, 让 学 生 掌 握 数 组 和 常 用 集 合 的 使 用 方 法 ( 建 议 学 时 :8 课 时 课 堂 教 学 +8 课 时 实 验 教 学 ) III

4 Java 物 联 网 程 序 设 计 基 础 Java WULIANWANG CHENGXU SHEJI JICHU 案 例 五 数 据 采 集 JAVA 面 向 对 象 本 章 针 对 Java 程 序 设 计 语 言 进 行 深 入 理 解, 以 新 大 陆 物 联 网 实 训 设 备 为 平 台, 讲 解 面 向 对 象 的 知 识 要 点 ( 建 议 学 时 :8 课 时 课 堂 教 学 +6 课 时 实 验 教 学 ) 案 例 六 温 度 湿 度 实 时 更 新 系 统 程 序 开 发 本 章 对 线 程 的 运 行 机 制 同 步 做 了 详 细 的 探 讨 ( 建 议 学 时 :8 课 时 课 堂 教 学 +4 课 时 实 验 教 学 ) 本 书 由 周 雯, 薛 文 龙 担 任 主 编, 于 继 武, 倪 晨 玮, 王 艳 霞 担 任 副 主 编, 洪 波 担 任 参 编 全 书 案 例 源 代 码 均 由 北 京 新 大 陆 时 代 教 育 科 技 有 限 公 司 提 供 由 于 编 者 水 平 有 限, 疏 漏 在 所 难 免 敬 请 各 位 读 者 不 吝 赐 教, 以 求 共 同 进 步, 感 激 不 尽 编 者 2016 年 1 月 IV

5 目 录 CONTENTS 案 例 1 欢 迎 进 入 Java 世 界 开 发 环 境 搭 建 1.1 Java 入 门 // Android 开 发 环 境 搭 建 // 案 例 展 现 // 基 于 Java 的 物 联 网 实 训 系 统 // 案 例 拓 展 // 27 本 章 小 结 // 33 习 题 // 34 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 2.1 案 例 展 现 // Java 的 数 据 类 型 // 变 量 与 常 量 // 运 算 符 与 表 达 式 // 方 法 // Java 编 码 规 范 // 案 例 拓 展 // 74 本 章 小 结 // 77 习 题 // 79 案 例 3 三 数 据 采 集 模 块 开 发 流 程 控 制 结 构 3.1 案 例 展 现 // 条 件 控 制 语 句 // 循 环 控 制 语 句 // 案 例 实 现 // 案 例 扩 展 // 103 本 章 小 结 // 107 习 题 // 108 V

6 Java 物 联 网 程 序 设 计 基 础 Java WULIANWANG CHENGXU SHEJI JICHU 案 例 4 四 模 块 输 入 数 据 采 集 数 组 与 集 合 4.1 案 例 展 现 // 知 识 铺 垫 : 数 组 概 述 // 知 识 铺 垫 : 一 维 数 组 的 创 建 和 使 用 // 知 识 铺 垫 : 二 维 数 组 的 创 建 和 使 用 // 集 合 // 126 本 章 小 结 // 147 习 题 // 148 案 例 5 数 据 采 集 -JAVA 面 向 对 象 5.1 案 例 展 现 // 面 向 对 象 技 术 // 类 的 定 义 和 使 用 // 面 向 对 象 特 性 // 异 常 // 案 例 拓 展 // 194 本 章 小 结 // 205 习 题 // 205 案 例 6 温 度 湿 度 实 时 更 新 系 统 程 序 开 发 6.1 案 例 展 现 // 线 程 概 述 // 线 程 类 (Thread) // 定 时 器 Timer // Handler 消 息 传 递 机 制 // 案 例 实 现 // 238 本 章 小 结 // 242 习 题 // 242 VI

7 UNIT 2 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 2.1 案 例 展 现 实 现 单 击 界 面 上 采 集 按 钮, 界 面 分 别 显 示 光 照 温 度 湿 度 的 实 际 物 理 量 值 ; 并 判 断 温 度 是 否 大 于 文 本 输 入 的 给 定 温 度 值, 是 则 1# 风 扇 开 ; 否 则 1# 风 扇 关 每 单 击 一 次 采 集 按 钮, 单 击 次 数 加 1; 界 面 底 部 文 字 提 示 信 息 为 你 是 第 n 次 采 集 数 据, 其 中 n 为 你 第 几 次 单 击 了 该 按 钮 效 果 如 图 2-1 所 示 图 2-1 Case2_1 运 行 效 果

8 面 向 设 备 的 Java 程 序 设 计 MIANXIANG SHEBEIDE Java CHENGXU SHEJI 一 案 例 分 析 本 例 中 界 面 布 局 中 的 控 件 既 有 水 平 方 向 排 列, 也 有 垂 直 方 向 排 列, 因 此 要 采 用 线 性 布 局 的 嵌 套 方 式 来 实 现 主 要 包 含 了 文 本 框 编 辑 框 和 按 钮 三 种 控 件, 显 示 光 照 温 度 湿 度 的 实 际 物 理 量 值 采 用 TextView 控 件, 温 度 值 临 界 值 采 用 EditText 控 件, 采 集 按 钮 用 Button 控 件 需 要 监 听 按 钮 的 单 击 事 件, 并 记 录 单 击 的 次 数, 并 将 采 集 到 的 当 前 温 度 与 文 本 输 入 的 给 定 温 度 值 比 较, 然 后 控 制 相 应 的 风 扇 开 关 主 要 设 计 思 路 如 下 : 1. 创 建 一 个 空 白 安 卓 程 序 2. 把 动 态 库 复 制 到 项 目 中 3. 编 写 UI 布 局 xml 文 件, 自 行 设 计 UI 界 面 (1)LinearLayout 布 局 使 用 ; (2) 布 局 嵌 套 ; (3) 控 件 渲 染 优 先 级 :android:layout_weight= 1, 当 控 件 有 宽 高 时, 是 渲 染 优 先 级,0 最 高 ( 如 若 控 件 a 宽 度 为 填 充 父 窗 体, 控 件 b 为 包 裹 内 容, 并 且 ab 在 同 一 排, 那 么 b 将 不 可 见 如 果 b 控 件 渲 染 级 别 高 于 a, 那 么 先 绘 制 控 件 b,a 控 件 宽 度 填 充 剩 余 空 间 ) (4) 控 件 权 重 :android:layout_weight= 1, 当 控 件 有 宽 或 高 为 0 时, 是 控 件 为 0 的 宽 或 高 的 权 重, 按 权 重 分 配 宽 度 ( 如 果 某 控 件 宽 度 为 0, 那 么 它 的 宽 度 =( 控 件 权 重 / 所 在 排 所 有 控 件 权 重 和 )* 父 容 器 宽 度 ) 4. 编 写 后 台 代 码, 实 现 程 序 功 能 (1) 按 钮 单 击 事 件 进 行 监 控 和 处 理 ; (2) 使 用 DecimalFormat 类 格 式 化 浮 点 型 数 据 ; (3)Stirng 类 型 转 换 到 Double 类 型 ; (4) 使 用 动 态 库 对 象 获 取 光 照 温 度 湿 度 ; (5) 使 用 动 态 库 开 关 风 扇 二 操 作 步 骤 1. 新 建 安 卓 项 目, 把 素 材 文 件 \ 案 例 2\Case2_1\libs 文 件 夹 下 提 供 的 实 训 设 备 操 作 类 库 文 件 复 制 到 libs, 如 图 2-2 所 示 36

9 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 图 2-2 复 制 类 库 文 件 2. 打 开 res/values/strings.xml, 添 加 代 码 <?xml version= 1.0 encoding= utf-8?> <resources> <string name= app_name >Case2_1</string> <string name= hello_world >Hello world!</string> <string name= action_settings >Settings</string> <string name= stropen > 开 </string> <string name= strclose > 关 </string> <string name= strfanopen > 风 扇 开 </string> <string name= strfanclose > 风 扇 关 </string> </resources> 3. 编 写 好 activity_main.xml 界 面 代 码 4. 打 开 MainActivity.java, 进 行 编 辑 后 台 代 码 public class MainActivity extends Activity { // 声 明 四 个 TextView, 一 个 EditText, 一 个 Button private TextView mtvtemp,mtvhumi,mtvlight,mtvstate; private EditText metsettemp; private Button mbtngether; // 单 击 次 数 private int count=0; // 声 明 刚 导 入 libs 的 NewlandLibrary 中 的 NewlandLibraryHelper 类 private NewlandLibraryHelper protected void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.activity_main); /* * 使 用 findviewbyid 方 法 37

10 面 向 设 备 的 Java 程 序 设 计 MIANXIANG SHEBEIDE Java CHENGXU SHEJI * 根 据 id 找 到 布 局 文 件 activity_main.xml 中 的 一 个 EditText 和 四 个 TextView 和 一 个 Button * 并 强 制 转 化 为 EditText 和 TextView */ mbtngether = (Button)findViewById(R.id.btnGether); mtvtemp = (TextView)findViewById(R.id.tvTemp); mtvhumi = (TextView)findViewById(R.id.tvHumi); mtvlight = (TextView)findViewById(R.id.tvLight); mtvstate = (TextView)findViewById(R.id.tvState); metsettemp = (EditText)findViewById(R.id.etSetTemp); // 实 例 化 NewlandLibraryHelper 类, 将 本 文 的 上 下 文 传 入 即 this // 并 且 调 用 createprovider 方 法 创 建 提 供 者 mlibrary = new NewlandLibraryHelper(this); mlibrary.createprovider(); // 设 置 采 集 按 钮 的 单 击 监 听 事 件 mbtngether.setonclicklistener(new OnClickListener() NewApi public void onclick(view v) { // 设 置 3 个 文 本 框 的 值 count++;// 计 数 器 加 一 表 示 采 集 了 一 次 mtvstate.settext( 你 是 第 "+count+" 次 采 集 数 据 ");// 设 置 文 本 框 采 集 几 次 mtvhumi.settext( 湿 度 值 :"+format(mlibrary.getmhumidata())+"%"); mtvtemp.settext( 温 度 值 :"+format(mlibrary.getmtempdata())+" C"); mtvlight.settext( 光 照 值 :"+format(mlibrary.getmlightdata())+"lux"); // 获 取 临 界 值 判 断 是 否 实 际 温 度 有 没 有 大 于 临 界 值, 如 果 大 于 则 开 风 扇 否 则 关 闭 风 扇 String settemp = metsettemp.gettext().tostring(); if(settemp.isempty())return; if(double.valueof(settemp)<mlibrary.getmtempdata()){ mlibrary.openleftf(); else{ mlibrary.closeleftf(); protected void ondestroy() { // TODO Auto-generated method stub super.ondestroy(); mlibrary.closeuert(); 38

11 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 /** * 保 留 小 数 点 后 两 位 data 需 要 保 留 的 双 精 度 数 据 */ public String format(double data){ DecimalFormat df = new DecimalFormat( 0.00 ); return df.format(data); 用 程 序 5. 部 署 应 用 程 序, 将 ADAM4150 数 字 量 采 集 器 串 口 线 连 接 到 开 发 箱 COM2 口, 启 动 应 三 案 例 总 结 1 DecimalFormat 类 DecimalFormat 是 NumberFormat 的 一 个 具 体 子 类, 用 于 格 式 化 十 进 制 数 字 DecimalFormat 包 含 一 个 模 式 和 一 组 符 号 DecimalFormat 的 符 号 含 义 如 表 2-1 所 示 表 2-1 DecimalFormat 的 符 号 含 义 符 号 含 义 0 一 个 数 字 # 一 个 数 字, 不 包 括 0. 小 数 的 分 隔 符 的 占 位 符, 分 组 分 隔 符 的 占 位 符 ; 分 隔 格 式 - 缺 省 负 数 前 缀 % 乘 以 100 和 作 为 百 分 比 显 示 例 2.1 DecimalFormat df1 = new DecimalFormat( 0.0 ); DecimalFormat df2 = new DecimalFormat( #.# ); DecimalFormat df3 = new DecimalFormat( ); DecimalFormat df4 = new DecimalFormat( ###.### ); System.out.println(df1.format(12.34)); System.out.println(df2.format(12.34)); System.out.println(df3.format(12.34)); System.out.println(df4.format(12.34)); 39

12 面 向 设 备 的 Java 程 序 设 计 MIANXIANG SHEBEIDE Java CHENGXU SHEJI 例 2.1 的 编 译 运 行 结 果 如 下 : 注 意 : 需 导 入 包 import java.text.decimalformat 例 2.2 DecimalFormat df1 = new DecimalFormat( ####.000 ); System.out.println(df1.format( )); 例 2.2 的 编 译 运 行 结 果 如 下 : 分 析 : 在 这 个 例 子 中 设 置 了 数 字 的 格 式, 使 用 像 ####.000 的 符 号 这 个 模 式 意 味 着 在 小 数 点 前 有 四 个 数 字, 如 果 不 够 就 空 着, 小 数 点 后 有 三 位 数 字, 不 足 用 0 补 齐 2.2 Java 的 数 据 类 型 1 数 据 类 型 的 划 分 Java 变 量 包 括 如 下 两 大 类 数 据 类 型 : 基 本 数 据 类 型 和 对 象 数 据 类 型 基 本 数 据 类 型 包 括 : 1. 整 数 :byte short int long 2. 浮 点 数 :float double 3. 字 符 类 型 :char 4. 布 尔 类 型 :boolean 对 象 数 据 类 型 : Java 类 的 实 例 对 象 类 型 2 基 本 数 据 类 型 Java 语 言 提 供 了 八 种 基 本 类 型 六 种 数 字 类 型 ( 四 个 整 数 型, 两 个 浮 点 型 ), 一 种 字 符 类 型, 还 有 一 种 布 尔 型 基 本 数 据 类 型 见 表 byte( 字 节 型 ): 计 算 机 中 1 字 节 一 般 来 说 占 8 位 40

13 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 2.char( 字 符 型 ): 占 2 字 节, 也 就 是 16 位 3.short( 短 整 型 ): 占 2 字 节, 也 就 是 16 位 4.int( 整 型 ): 占 4 字 节, 也 就 是 32 位 5.long( 长 整 型 ): 占 8 字 节, 也 就 是 64 位 6.float( 单 精 度 实 型 ): 小 数 点 后 保 留 7 位 有 效 数 字, 占 32 位 7.double( 双 精 度 实 型 ): 小 数 点 后 保 留 15 位 有 效 数 字, 占 64 位 8.boolean( 字 节 型 ): 占 1 字 节,8 位 我 们 知 道 所 有 的 数 据 都 是 以 0 和 1 的 组 合 来 存 储 的, 例 如 整 型 数 字 1, 在 计 算 机 中 的 实 际 存 储 形 势 为 : 上 面 的 每 一 个 0 或 者 每 一 个 1 都 被 称 为 1 个 位 表 2-2 基 本 数 据 类 型 类 型 字 节 数 位 数 取 值 范 围 举 例 byte ~2 7-1 的 整 数 -128,54,127 short ~ 的 整 数 1348,6543 int ~ 的 整 数 0,-1000, long ~ 的 整 数 ,-12 float ~2 31 的 整 数 ,87F double ~2 63 的 整 数 ,0.435D char ~2 15 的 整 数 400,A,z,x,-23 boolean 1 8 true,false true (1)byte byte 数 据 类 型 是 8 位 有 符 号 的, 以 二 进 制 补 码 表 示 的 整 数 ; 最 小 值 是 -128(- ); 最 大 值 是 127( -1); 默 认 值 是 0 byte 类 型 用 在 大 型 数 组 中 节 约 空 间, 主 要 代 替 整 数, 因 为 byte 变 量 占 用 的 空 间 只 有 int 类 型 的 四 分 之 一 例 如 :byte a = 100,byte b = -50 (2)char char 类 型 是 一 个 单 一 的 16 位 Unicode 字 符 最 小 值 是 \u0000 ( 即 为 0); 最 大 值 是 \uffff ( 即 为 65,535);char 数 据 类 型 可 以 储 存 任 何 字 符 例 如 :char letter = A Java 中 还 有 一 种 特 殊 的 字 符 型 数 值, 那 就 是 转 义 字 符 有 一 些 特 殊 符 号 是 不 能 通 过 一 般 41

14 面 向 设 备 的 Java 程 序 设 计 MIANXIANG SHEBEIDE Java CHENGXU SHEJI 字 符 来 进 行 显 示 的, 例 如 换 行 符 和 制 表 符 在 表 2-3 中 列 出 了 Java 中 比 较 常 用 的 转 义 字 符 表 2-3 常 用 转 义 字 符 转 义 字 符 描 述 \ddd 1 到 3 位 八 进 制 数 据 所 表 示 的 字 符 (ddd) \uxxxx 1 到 4 位 十 六 进 制 数 所 表 示 的 字 符 (xxxx) \ 单 引 号 字 符 \ 双 引 号 字 符 \\ 反 斜 杠 字 符 \r 回 车 ) \n 换 行 \f 走 纸 换 页 \t 横 向 跳 格 \b 退 格 (3)short short 数 据 类 型 是 16 位 有 符 号 的 以 二 进 制 补 码 表 示 的 整 数 最 小 值 是 (-2^15); 最 大 值 是 32767(2^15-1); short 数 据 类 型 也 可 以 像 byte 那 样 节 省 空 间 一 个 short 变 量 是 int 型 变 量 所 占 空 间 的 二 分 之 一 ; 默 认 值 是 0 例 如 :short s = 1000,short r = (4)int 整 型 是 Java 数 据 类 型 中 的 最 基 本 类 型, 使 用 int 表 示 所 谓 整 型 就 好 比 日 常 生 活 中 的 十 进 制 数, 是 没 有 小 数 点 的 在 Java 里 整 型 是 有 符 号 的, 且 有 正 负 之 分 如 java 中 整 数 常 量 有 3 种 表 示 方 式 :10 进 制 8 进 制 ( 以 0 开 头 ) 和 16 进 制 ( 以 0x 或 0X 表 示 ) 下 面 就 对 这 三 种 进 制 来 进 行 介 绍 1)10 进 制 :10 进 制 数 在 日 常 生 活 中 最 常 见, 大 家 天 天 都 在 用 Java 里 定 义 一 个 10 进 制 数 如 下 正 的 10 进 制 数 :int i = 11; 负 的 10 进 制 数 :int j = -12; 2)8 进 制 :8 进 制 数 的 进 制 规 则 是 满 8 进 1, 包 含 0-7 的 8 个 数 字, 在 整 数 前 面 添 加 一 个 0 就 表 示 为 8 进 制 数 3)16 进 制 数 :16 进 制 数 的 进 制 规 则 是 满 16 进 1, 包 含 0-9,a-f 的 16 个 数 字, 在 整 数 前 面 添 加 一 个 0x 表 示 16 进 制 数 42

15 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 如 果 你 对 八 进 制 和 十 六 进 制 的 转 换 不 太 清 楚 的 话, 首 先 要 知 道 十 进 制 八 进 制 和 十 六 进 制 的 成 员 十 进 制 的 基 本 成 员 : 八 进 制 的 基 本 成 员 : 十 六 进 制 的 基 本 成 员 : A B C D E F( 其 中 A B C D E F 分 别 代 表 ) 例 如, 八 进 制 数 345 转 换 成 十 进 制 数 为 :5*80+4*81+3*82 例 如, 十 六 进 制 数 45 转 换 成 十 进 制 数 为 :5*160+4*81 (5)long 对 于 大 型 计 算, 常 会 遇 到 很 大 的 整 数, 超 出 int 类 型 所 表 示 的 范 围, 这 时 要 使 用 long 类 型 一 个 java 整 数 常 量 默 认 是 int 类 型, 有 两 种 情 形 必 须 清 楚 : 1) 如 果 直 接 将 较 小 的 整 数 常 量 ( 在 byte 或 short 的 数 值 范 围 ) 赋 给 byte 或 short 变 量, 系 统 会 自 动 把 这 个 整 数 常 量 当 做 byte 和 short 类 型 来 处 理 2) 如 果 使 用 一 个 较 大 的 整 数 ( 超 过 int 类 型 的 表 数 范 围 ) 时,java 不 会 自 动 把 这 个 整 数 常 量 当 做 long 类 型 处 理, 如 果 希 望 当 成 long 处 理, 则 应 该 在 常 量 后 面 增 加 L (6) 浮 点 数 浮 点 型 同 样 也 是 Java 数 据 类 型 中 的 基 本 类 型, 整 型 表 示 整 数, 浮 点 型 则 表 示 小 数 所 谓 浮 点 类 型 就 好 比 日 常 生 活 中 的 10 进 制 数 加 上 小 数 点 在 Java 里 浮 点 类 型 是 有 符 号 且 有 正 负 之 分 的 1)float: 单 精 度 浮 点 数 声 明 为 float 类 型 的 浮 点 数 时, 要 在 结 尾 加 F 或 f, 浮 点 类 型 默 认 的 类 型 是 double 正 的 浮 点 数 :float i1=11.11f; 负 的 浮 点 数 :float j2=-17.15f; 2)double: 双 精 度 浮 点 数 声 明 为 double 类 型 的 浮 点 数 时, 要 在 结 尾 加 D 或 d 声 明 为 double 类 型 时 结 尾 的 D 和 d 可 加 可 不 加 这 里 建 议 是 在 double 数 据 类 型 的 数 后 面 加 上 D 或 者 d, 以 便 更 能 够 和 单 精 度 浮 点 数 区 分 (7)boolean 布 尔 型 是 一 种 起 到 判 断 作 用 的 数 据 类 型 boolean 类 型 的 取 值 非 常 简 单, 就 好 比 日 常 生 活 中 的 真 与 假, 在 Java 中 用 ture 与 false, 表 示 真 与 假 43

16 面 向 设 备 的 Java 程 序 设 计 MIANXIANG SHEBEIDE Java CHENGXU SHEJI 例 如 :boolean b1 = false; boolean b2 = true; 3 自 动 转 换 所 谓 自 动 转 换 就 是 不 需 要 明 确 指 出 所 要 转 换 的 类 型 是 什 么, 是 由 Java 虚 拟 机 自 动 来 转 换 的 转 换 的 规 则 就 是 小 数 据 类 型 变 大 数 据 类 型, 但 大 的 数 据 类 型 的 数 据 精 度 有 的 时 候 要 被 破 坏 下 面 看 一 段 代 码 定 义 各 种 数 据 类 型 : int i = 123; char c1 = 22; char c2 = c ; byte b = 2; 自 动 转 换 的 数 据 类 型 : int n = b; long l = i; 自 动 类 型 转 换 : 理 论 上 数 值 范 围 小 的 类 型 可 以 自 动 转 换 为 数 值 范 围 大 的 类 型, 如 下 : ( byte->short) char->int->long->float->double 4 强 制 转 换 所 谓 强 制 转 换, 是 有 一 种 强 制 性 的, 明 明 不 能 自 动 转 换, 而 强 制 性 地 进 行 转 换 看 下 面 的 例 子, 定 义 数 据 类 型 : int i = 22; long l= 33; 强 制 转 换 数 据 类 型 char c = (char)i; int n = (int)l; 在 其 中 i 原 来 是 一 个 int 整 型, 但 要 将 它 强 行 转 换 成 char 字 符 型 同 样 l 原 来 是 一 个 long 型, 但 要 将 它 强 行 转 换 成 int 整 型 通 过 前 面 的 学 习 已 经 知 道,long 型 的 取 值 范 围 最 大 值 可 以 为 2 的 63 次 方 减 1, 而 int 型 的 取 值 范 围 最 大 值 只 有 2 的 31 次 方 减 1, 所 以 如 果 l 为 一 个 大 于 2 的 31 次 方 减 1, 在 强 制 类 型 转 换 时 就 会 丢 失 精 度, 使 数 值 发 生 变 化, 这 也 是 需 要 注 意 的 地 方 5 引 用 类 型 引 用 类 型 变 量 由 类 的 构 造 函 数 创 建, 可 以 使 用 它 们 访 问 所 引 用 的 对 象 这 些 变 量 在 声 明 时 被 指 定 为 一 个 特 定 的 类 型, 比 如 Employee Manager 等 变 量 一 旦 声 明 后, 类 型 就 不 能 被 改 变 了 对 象 数 组 都 是 引 用 数 据 类 型 所 有 引 用 类 型 的 默 认 值 都 是 null 一 个 引 用 变 量 可 以 用 来 引 用 与 任 何 与 之 兼 容 的 类 型 例 子 :Animal animal = new Animal( tiger ) Java 中 所 有 对 象 都 要 通 过 对 象 引 用 访 问, 对 象 引 用 是 指 向 对 象 存 储 所 在 堆 中 某 个 区 域 的 44

17 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 指 针, 所 有 的 对 象 数 据 类 型 都 属 于 引 用 数 据 类 型 例 如 下 例 所 示,b 和 c 都 是 引 用 类 型 : int a=1; // 基 本 数 据 类 型 Integer b=new Integer(1); // 对 象 引 用 Integer c=b; // 对 象 引 用 引 用 类 型 和 基 本 数 据 类 型 具 有 不 同 的 特 征 和 用 法, 当 引 用 类 型 和 基 本 数 据 类 型 用 作 某 个 类 的 实 例 数 据 时 所 指 定 的 默 认 值 时, 对 象 引 用 实 例 变 量 的 默 认 值 为 null, 而 基 本 数 据 类 型 实 例 变 量 的 默 认 值 与 它 们 的 类 型 有 关 例 如, 不 能 对 基 本 数 据 类 型 调 用 方 法, 但 可 以 对 对 象 调 用 方 法 : int a=1; // 基 本 数 据 类 型 a.hashcode(); // 错 误 Integer b=new Integer(1); // 对 象 引 用 b.hashcode(); // 正 确 对 于 数 值 类 型 的 基 本 类 型 的 取 值 范 围, 我 们 无 需 强 制 去 记 忆, 因 为 它 们 的 值 都 已 经 以 常 量 的 形 式 定 义 在 对 应 的 包 装 类 中 了 请 看 下 面 的 例 子 : 例 2.3 新 建 一 个 Java 项 目, 新 建 类 PrimitiveTypeTest.java, 运 行 程 序 观 察 结 果, 代 码 清 单 如 下 public class PrimitiveTypeTest { public static void main(string[] args) { // byte System.out.println( 基 本 类 型 :byte 二 进 制 位 数 :" + Byte.SIZE); System.out.println( 包 装 类 :java.lang.byte"); System.out.println( 最 小 值 :Byte.MIN_VALUE=" + Byte.MIN_VALUE); System.out.println( 最 大 值 :Byte.MAX_VALUE=" + Byte.MAX_VALUE); System.out.println(); // short System.out.println( 基 本 类 型 :short 二 进 制 位 数 :" + Short.SIZE); System.out.println( 包 装 类 :java.lang.short"); System.out.println( 最 小 值 :Short.MIN_VALUE=" + Short.MIN_VALUE); System.out.println( 最 大 值 :Short.MAX_VALUE=" + Short.MAX_VALUE); System.out.println(); // int System.out.println( 基 本 类 型 :int 二 进 制 位 数 :" + Integer.SIZE); System.out.println( 包 装 类 :java.lang.integer"); System.out.println( 最 小 值 :Integer.MIN_VALUE=" + Integer.MIN_VALUE); System.out.println( 最 大 值 :Integer.MAX_VALUE=" + Integer.MAX_VALUE); System.out.println(); // long System.out.println( 基 本 类 型 :long 二 进 制 位 数 :" + Long.SIZE); 45

18 面 向 设 备 的 Java 程 序 设 计 MIANXIANG SHEBEIDE Java CHENGXU SHEJI System.out.println( 包 装 类 :java.lang.long"); System.out.println( 最 小 值 :Long.MIN_VALUE=" + Long.MIN_VALUE); System.out.println( 最 大 值 :Long.MAX_VALUE=" + Long.MAX_VALUE); System.out.println(); // float System.out.println( 基 本 类 型 :float 二 进 制 位 数 :" + Float.SIZE); System.out.println( 包 装 类 :java.lang.float"); System.out.println( 最 小 值 :Float.MIN_VALUE=" + Float.MIN_VALUE); System.out.println( 最 大 值 :Float.MAX_VALUE=" + Float.MAX_VALUE); System.out.println(); // double System.out.println( 基 本 类 型 :double 二 进 制 位 数 :" + Double.SIZE); System.out.println( 包 装 类 :java.lang.double"); System.out.println( 最 小 值 :Double.MIN_VALUE=" + Double.MIN_VALUE); System.out.println( 最 大 值 :Double.MAX_VALUE=" + Double.MAX_VALUE); System.out.println(); // char System.out.println( 基 本 类 型 :char 二 进 制 位 数 :" + Character.SIZE); System.out.println( 包 装 类 :java.lang.character"); // 以 数 值 形 式 而 不 是 字 符 形 式 将 Character.MIN_VALUE 输 出 到 控 制 台 System.out.println( 最 小 值 :Character.MIN_VALUE="+ (int) Character.MIN_VALUE); // 以 数 值 形 式 而 不 是 字 符 形 式 将 Character.MAX_VALUE 输 出 到 控 制 台 System.out.println( 最 大 值 :Character.MAX_VALUE="+ (int) Character.MAX_VALUE); 例 2.3 的 编 译 运 行 结 果 如 下 : 基 本 类 型 :byte 二 进 制 位 数 :8 包 装 类 :java.lang.byte 最 小 值 :Byte.MIN_VALUE=-128 最 大 值 :Byte.MAX_VALUE=127 基 本 类 型 :short 二 进 制 位 数 :16 包 装 类 :java.lang.short 最 小 值 :Short.MIN_VALUE= 最 大 值 :Short.MAX_VALUE=32767 基 本 类 型 :int 二 进 制 位 数 :32 包 装 类 :java.lang.integer 最 小 值 :Integer.MIN_VALUE= 最 大 值 :Integer.MAX_VALUE=

19 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 基 本 类 型 :long 二 进 制 位 数 :64 包 装 类 :java.lang.long 最 小 值 :Long.MIN_VALUE= 最 大 值 :Long.MAX_VALUE= 基 本 类 型 :float 二 进 制 位 数 :32 包 装 类 :java.lang.float 最 小 值 :Float.MIN_VALUE=1.4E-45 最 大 值 :Float.MAX_VALUE= E38 基 本 类 型 :double 二 进 制 位 数 :64 包 装 类 :java.lang.double 最 小 值 :Double.MIN_VALUE=4.9E-324 最 大 值 :Double.MAX_VALUE= E308 基 本 类 型 :char 二 进 制 位 数 :16 包 装 类 :java.lang.character 最 小 值 :Character.MIN_VALUE=0 最 大 值 :Character.MAX_VALUE= 变 量 与 常 量 1 标 识 符 Java 语 言 中, 对 于 变 量, 常 量, 函 数, 语 句 块 也 有 名 字, 我 们 统 统 称 之 为 Java 标 识 符 标 识 符 是 用 来 给 类 对 象 方 法 变 量 接 口 和 自 定 义 数 据 类 型 命 名 的 一 标 识 符 组 成 Java 标 识 符 由 数 字, 字 母 和 下 划 线 (_), 美 元 符 号 ($) 组 成 在 Java 中 是 区 分 大 小 写 的, 而 且 还 要 求 首 位 不 能 是 数 字 最 重 要 的 是,Java 关 键 字 不 能 当 作 Java 标 识 符 下 面 的 标 识 符 是 合 法 的 : myname,my_name,points,$points,_sys_ta,ok,_23b,_3_ 下 面 的 标 识 符 是 非 法 的 : 2Sun ciass // 以 数 字 2 开 头 // 是 Java 的 关 键 字 有 特 殊 含 义 47

20 面 向 设 备 的 Java 程 序 设 计 MIANXIANG SHEBEIDE Java CHENGXU SHEJI #myname // 含 有 其 他 符 号 # 注 意 : 符 合 标 识 符 的 命 名 规 则 并 不 是 一 种 最 好 的 命 名 方 法 给 一 个 标 识 符 命 名 首 先 要 符 合 命 名 规 范, 还 要 符 合 含 义 常 见 的 命 名 习 惯 有 : 包 名 一 般 用 小 写 字 母 和 少 量 的 数 字 组 成, 比 如 :org dao 等, 最 好 是 组 织 名 公 司 名 或 功 能 模 块 名 Java 包 定 义 的 官 方 建 议 是 把 域 名 以 点 号 分 隔 各 段 颠 倒 过 来 作 为 类 的 报 名 开 始 部 分, 这 样 就 能 保 证 不 会 命 名 冲 突 如 apache 的 域 名 为 :apache.org, 所 以 apapche 项 目 java 类 就 为 org.apache 开 头 ;sun 域 名 为 sun.com, 也 就 是 com.sun 开 头 类 名 和 接 口 名 一 般 由 一 个 或 几 个 单 词 组 成, 遵 循 驼 峰 规 则 方 法 名 除 了 第 一 个 单 词 首 字 母 小 写 外, 其 他 单 词 都 是 首 字 母 大 写, 与 类 名 取 名 类 似, 即 小 驼 峰 规 则 : 如 getusername() 属 性 名 如 果 是 基 本 数 据 类 型 的 变 量 一 般 小 写, 如 int name ; 引 用 数 据 类 型 的 变 量 一 般 与 类 名 取 名 类 似, 如 String UserNameTable 等 只 有 局 部 变 量 可 以 简 写, 如 int i; 或 int j 等 说 明 : 驼 峰 命 名 法 (Camel-Case) 就 是 当 变 量 名 或 函 数 名 是 由 一 个 或 多 个 单 词 连 结 在 一 起, 而 构 成 的 唯 一 识 别 字 时, 第 一 个 单 字 以 小 写 字 母 开 始 ; 第 二 个 单 字 的 首 字 母 大 写 或 每 一 个 单 字 的 首 字 母 都 采 用 大 写 字 母, 例 如 :myfirstname mylastname, 这 样 的 变 量 名 看 上 去 就 像 骆 驼 峰 一 样 此 起 彼 伏, 故 得 名 驼 峰 命 名 法 的 命 名 规 则 可 视 为 一 种 惯 例, 并 无 绝 对 与 强 制, 为 的 是 增 加 识 别 和 可 读 性 二 关 键 字 Java 中 的 关 键 字 见 表 2-4 所 示 表 2-4 Java 中 的 关 键 字 类 别 关 键 字 含 义 public 公 有 的 访 问 修 饰 符 的 关 键 字 protected 受 保 护 的 private 私 有 的 class 类 定 义 类 接 口 抽 象 类 和 实 interface 接 口 现 接 口 继 承 类 的 关 键 字 实 abstract 声 明 抽 象 implements 实 现 例 化 对 象 extends 继 承 new 创 建 新 对 象 48

21 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 ( 续 ) 类 别 关 键 字 含 义 包 的 关 键 字 数 据 类 型 的 关 键 字 条 件 循 环 ( 流 程 控 制 ) 修 饰 方 法 类 属 性 和 变 量 错 误 处 理 import 引 入 包 的 关 键 字 package 定 义 包 的 关 键 字 byte 字 节 型 char 字 符 型 boolean 布 尔 型 short 短 整 型 int 整 型 float 浮 点 型 long 长 整 型 double 双 精 度 void 无 返 回 null 空 值 true 真 false 假 if 如 果 else 否 则, 或 者 while 当 什 么 的 时 候 for 满 足 三 个 条 件 时 switch 开 关 case 返 回 开 关 里 的 结 果 default 默 认 do 运 行 break 跳 出 循 环 continue 继 续 return 返 回 instanceof 实 例 static 静 态 的 final 最 终 的 不 可 被 改 变 的 super 调 用 父 类 的 方 法 this 当 前 类 的 父 类 的 对 象 native 本 地 strictfp 严 格, 精 准 synchronized 线 程, 同 步 transient 短 暂 volatile 易 失 catch 处 理 异 常 try 捕 获 异 常 finally 有 没 有 异 常 都 执 行 throw 抛 出 一 个 异 常 对 象 throws 声 明 一 个 异 常 可 能 被 抛 出 枚 举 和 断 言 enum 枚 举 assert 断 言 49

22 面 向 设 备 的 Java 程 序 设 计 MIANXIANG SHEBEIDE Java CHENGXU SHEJI 2 常 量 常 量 就 是 一 个 固 定 值 它 们 不 需 要 计 算, 直 接 代 表 相 应 的 值 常 量 指 不 能 改 变 的 量 在 Java 中 用 final 标 志, 声 明 方 式 和 变 量 类 似 : final double PI = ; 虽 然 常 量 名 也 可 以 用 小 写, 但 为 了 便 于 识 别, 通 常 使 用 大 写 字 母 表 示 常 量 Java 中 的 常 量 包 括 整 型 常 量 浮 点 型 常 量 布 尔 常 量 字 符 常 量 等 整 型 常 量 : 十 进 制 : 不 能 以 0 开 头, 多 个 0~9 之 间 的 数 字 ; 十 六 进 制 : 以 0x 或 0X 开 头, 例 如 :0x8a 0X56d; 八 进 制 : 必 须 以 0 开 头, 例 如 : ; 长 整 型 : 必 须 以 L 结 尾, 例 如 :87L 345L 浮 点 数 常 量 : float 型 :2e3f 0.6f; double 型 :4.1d 1.23d; 布 尔 常 量 :true 和 false; 字 符 常 量 : a 5 ; 字 符 串 常 量 : hello 8698 \nmain ; 转 义 字 符 :\n 表 示 换 行 ; null 常 量 :null, 表 示 对 象 的 引 用 为 空 字 面 量 可 以 赋 给 任 何 内 置 类 型 的 变 量 例 如 : byte a = 68;char a = A byte int long 和 short 都 可 以 用 十 进 制 16 进 制 以 及 8 进 制 的 方 式 来 表 示 当 使 用 常 量 的 时 候, 前 缀 o 表 明 是 8 进 制, 而 前 缀 0x 代 表 16 进 制 例 如 : int decimal = 100;int octal = 0144;int hexa = 0x64; 和 其 他 语 言 一 样,Java 的 字 符 串 常 量 也 是 包 含 在 两 个 引 号 之 间 的 字 符 序 列 下 面 是 字 符 串 型 字 面 量 的 例 子 : Hello World two\nlines \ This is in quotes\ 字 符 串 常 量 和 字 符 常 量 都 可 以 包 含 任 何 Unicode 字 符 例 如 : char a = \u0001 ;String a = \u0001 ; 3 变 量 在 Java 语 言 中, 所 有 的 变 量 在 使 用 前 必 须 声 明 声 明 变 量 的 基 本 格 式 如 下 : 50

23 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 type identifier [ = value][, identifier [= value]...] 格 式 说 明 :type 为 Java 数 据 类 型 identifier 是 变 量 名 可 以 使 用 逗 号 隔 开 来 声 明 多 个 同 类 型 变 量 以 下 列 出 了 一 些 变 量 的 声 明 实 例 注 意 有 些 包 含 了 初 始 化 过 程 int a, b, c; // 声 明 三 个 int 型 整 数 :a b c int d = 3, e, f = 5; // d 声 明 三 个 整 数 并 赋 予 初 值 byte z = 22; // 声 明 并 初 始 化 z double pi = ; // 声 明 了 pi char x = x ; // 变 量 x 的 值 是 字 符 x Java 语 言 支 持 的 变 量 类 型 有 : 1. 局 部 变 量 2. 成 员 变 量 3. 类 变 量 一 局 部 变 量 局 部 变 量 声 明 在 方 法 构 造 方 法 或 者 语 句 块 中 ; 局 部 变 量 在 方 法 构 造 方 法 或 者 语 句 块 被 执 行 的 时 候 创 建, 当 它 们 执 行 完 成 后, 变 量 将 会 被 销 毁 ; 访 问 修 饰 符 不 能 用 于 局 部 变 量 ; 局 部 变 量 只 在 声 明 它 的 方 法 构 造 方 法 或 者 语 句 块 中 可 见 ; 局 部 变 量 没 有 默 认 值, 所 以 局 部 变 量 被 声 明 后, 必 须 经 过 初 始 化, 才 可 以 使 用 例 2.4 在 以 下 实 例 中 age 是 一 个 局 部 变 量 定 义 在 childage() 方 法 中, 它 的 作 用 域 就 限 制 在 这 个 方 法 中 public class Test { public void childage() { int age = 0; age = age + 7; System.out.println( Child age is : + age); public static void main(string args[]) { Test test = new Test(); 51

24 面 向 设 备 的 Java 程 序 设 计 MIANXIANG SHEBEIDE Java CHENGXU SHEJI test.childage(); 例 2.4 的 编 译 运 行 结 果 如 下 : Child age is: 7 例 2.5 在 下 面 的 例 子 中 age 变 量 没 有 初 始 化, 所 以 在 编 译 时 出 错 public class Test { public void childage() { int age; age = age + 7; System.out.println( Child age is : + age); public static void main(string args[]) { Test test = new Test(); test.childage(); 例 2.5 的 编 译 运 行 结 果 如 下 : java.lang.error: Unresolved compilation problem: The local variable age may not have been initialized 二 实 例 变 量 实 例 变 量 声 明 在 一 个 类 中, 但 在 方 法 构 造 方 法 和 语 句 块 之 外 ; 例 2.6 实 例 变 量 举 例 import java.io.*; public class Employee { // 这 个 成 员 变 量 对 子 类 可 见 public String name; // 私 有 变 量, 仅 在 该 类 可 见 private double salary; // 在 构 造 方 法 器 中 对 name 赋 值 public Employee(String empname) { name = empname; // 设 定 salary 的 值 52

25 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 public void setsalary(double empsal) { salary = empsal; // 打 印 员 工 信 息 public void printemp() { System.out.println( name : + name); System.out.println( salary : + salary); public static void main(string args[]) { Employee emp = new Employee( Mike ); emp.setsalary(1000); emp.printemp(); 例 2.6 的 编 译 运 行 结 果 如 下 : name : Mike salary : 三 类 变 量 ( 静 态 变 量 ) 所 谓 静 态 变 量 就 是 只 能 存 在 一 份, 它 属 于 类 的, 不 随 着 对 象 的 创 建 而 建 立 副 本 如 果 不 想 在 创 建 对 象 的 时 候 就 需 要 知 道 一 些 相 关 信 息, 那 么 就 声 明 为 static 类 型 的, 被 修 饰 为 static 类 型 的 成 员 变 量 不 属 于 对 象, 它 是 属 于 类 的 例 2.7 静 态 变 量 举 例 import java.io.*; public class Employee { // salary 是 静 态 的 私 有 变 量 private static double salary; // DEPARTMENT 是 一 个 常 量 public static final String DEPARTMENT = HR ; public static void main(string args[]) { salary = 5000; System.out.println(DEPARTMENT + average salary: + salary); 例 2.7 的 编 译 运 行 结 果 如 下 : HR average salary:5000 注 意 : 如 果 其 他 类 想 要 访 问 该 变 量, 可 以 通 过 类 名. 变 量 名 访 问 :Employee. DEPARTMENT 53

26 面 向 设 备 的 Java 程 序 设 计 MIANXIANG SHEBEIDE Java CHENGXU SHEJI 四 实 例 变 量 和 静 态 变 量 的 区 别 在 语 法 定 义 上 的 区 别 : 静 态 变 量 前 要 加 static 关 键 字, 而 实 例 变 量 前 则 不 加 在 程 序 运 行 时 的 区 别 : 实 例 变 量 属 于 某 个 对 象 的 属 性, 必 须 创 建 了 实 例 对 象, 其 中 的 实 例 变 量 才 会 被 分 配 空 间, 才 能 使 用 这 个 实 例 变 量 静 态 变 量 不 属 于 某 个 实 例 对 象, 而 是 属 于 类, 所 以 也 称 为 类 变 量, 只 要 程 序 加 载 了 类 的 字 节 码, 不 用 创 建 任 何 实 例 对 象, 静 态 变 量 就 会 被 分 配 空 间, 静 态 变 量 就 可 以 被 使 用 了 总 之, 实 例 变 量 必 须 创 建 对 象 后 才 可 以 通 过 这 个 对 象 来 使 用, 静 态 变 量 则 可 以 直 接 使 用 类 名 来 引 用 在 内 存 中 的 区 别 类 静 态 变 量 在 内 存 中 只 有 一 个,java 虚 拟 机 在 加 载 类 的 过 程 中 为 静 态 变 量 分 配 内 存, 静 态 变 量 位 于 方 法 区, 被 类 的 所 有 实 例 共 享, 静 态 变 量 可 以 通 过 类 名 直 接 访 问 静 态 变 量 的 生 命 周 期 取 决 于 类 的 生 命 周 期, 当 类 被 加 载 的 时 候, 静 态 变 量 被 创 建 并 分 配 内 存 空 间, 当 类 被 卸 载 时, 静 态 变 量 被 摧 毁, 并 释 放 所 占 有 的 内 存 类 的 每 一 个 实 例 都 有 相 应 的 实 例 变 量, 每 创 建 一 个 类 的 实 例,java 虚 拟 机 为 实 例 变 量 分 配 一 次 内 存, 实 例 变 量 位 于 堆 区 中, 实 例 变 量 的 生 命 周 期 取 决 于 实 例 的 生 命 周 期, 当 创 建 实 例 时, 为 实 例 变 量 背 创 建, 并 分 配 内 存, 当 实 例 被 销 毁 时, 实 例 变 量 被 销 毁, 并 释 放 所 占 有 的 内 存 空 间 例 2.8 实 例 变 量 和 局 部 变 量 的 区 别 public class Test { int t; // 实 例 变 量 public static void main(string args[]) { int t = 1; // 局 部 变 量 System.out.println(t); // 打 印 局 部 变 量 Test a = new Test(); // 创 建 实 例 System.out.println(a.t); // 通 过 实 例 访 问 实 例 变 量 例 2.8 的 编 译 运 行 结 果 如 下 : 1 0 注 意 : 成 员 变 量 具 有 缺 省 值 而 局 部 变 量 则 没 有 54

27 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 例 2.9 实 例 变 量 和 静 态 变 量 的 区 别 public class Test { static int t; // 静 态 变 量 public static void main(string args[]) { System.out.println(t); // 打 印 静 态 变 量 int t = 1; // 局 部 变 量 System.out.println(t); // 打 印 局 部 变 量 Test a = new Test(); // 创 建 实 例 System.out.println(a.t); // 通 过 实 例 访 问 实 例 变 量 例 2.9 的 编 译 运 行 结 果 如 下 : 运 算 符 与 表 达 式 1 算 术 运 算 符 假 如 a=3;b=2; 算 术 运 算 符 运 算 规 则 如 表 2-5 所 示 表 2-5 算 术 运 算 符 运 算 规 则 运 算 符 运 算 范 例 结 果 说 明 + 正 号 a=+b; a=2; - 负 号 a=-b; a=-2; + 加 a= a+b; a=5; 把 a 和 b 相 加 的 值 给 a - 减 a=a-b; a=1; * 乘 a=a*b; a=6; / 除 a=a/b; a=1; 由 于 是 整 形, 所 以 a/b 的 值 为 整 形 1 % 取 模 a=a%b; a=1; 把 a 除 b 的 余 数 赋 值 给 a ++ 自 增 ( 前 ) b=++a; b=4;a=4; 先 让 a 的 值 加 1, 再 把 a 的 值 赋 值 给 b ++ 自 增 ( 后 ) b=a++; b=3;a=4; 先 把 a 的 值 赋 值 给 b, 再 让 a 的 值 加 自 减 ( 前 ) b=- -a; b=2;a=2; 先 让 a 的 值 -1, 再 把 a 的 值 赋 值 给 b - - 自 减 ( 后 ) b=a- -; b=3;a=2; 先 把 a 的 值 赋 给 b, 再 让 a 减 1 + 字 符 串 相 加 Hello + World Hello World 55

28 面 向 设 备 的 Java 程 序 设 计 MIANXIANG SHEBEIDE Java CHENGXU SHEJI 例 2.10 public class Temp{ public static void main(string[] args){ int a=10; int b=10; System.out.println( 自 增 运 算 符 在 后 a="+(a++)); System.out.println( a 的 值 a="+a); System.out.println( 自 增 运 算 符 在 前 b="+(++b)); 例 2.10 的 编 译 运 行 结 果 如 下 : 自 增 运 算 符 在 后 a=10 a 的 值 a=11 自 增 运 算 符 在 前 b=11 2 关 系 运 算 符 Java 中 的 关 系 运 算 符 如 表 2-6 所 示 表 2-6 Java 中 的 关 系 运 算 符 运 算 符 含 义 示 例 == 等 于 a==b!= 不 等 于 a!=b > 大 于 a>b < 小 于 a<b >= 大 于 或 等 于 a>=b <= 小 于 或 等 于 a<=b instanceof 检 查 是 否 是 该 类 的 一 个 对 象 aa instanceof String 关 系 运 算 符 的 结 果 是 boolean 类 型 的, 只 有 两 种 true/false 注 意 : 关 系 运 算 符 中 的 == 不 能 误 写 成 = 例 2.11 public class Temp{ public static void main(string[] args){ int a=10; int b=21; System.out.println( a>b 的 值 为 "+(a>b)); 例 2.11 的 编 译 运 行 结 果 如 下 : a>b 的 值 为 false 56

29 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 3 逻 辑 运 算 符 Java 中 的 逻 辑 运 算 符 如 表 2-7 所 示 表 2-7 Java 中 的 逻 辑 运 算 符 运 算 符 含 义 示 例 & 逻 辑 与 A&B 逻 辑 或 A B ^ 逻 辑 异 或 A^B! 逻 辑 反!A 短 路 或 A B && 短 路 与 A&&B 逻 辑 运 算 符 中 的 & 和 && 的 区 别 : & 无 论 任 何 情 况,& 两 边 的 表 达 式 都 要 运 算 && 如 果 左 边 式 false, 则 不 会 计 算 右 边 的 表 达 式 和 的 区 别 : 无 论 任 何 情 况, 两 边 的 表 达 式 都 要 运 算 如 果 左 边 表 达 式 的 值 为 true, 则 不 会 计 算 右 边 表 达 式 的 值 例 2.12 public class Temp{ public static void main(string[] args){ boolean n = (5 > 3) && (2 > 8); System.out.println(n); 例 2.12 的 编 译 运 行 结 果 如 下 : false 将 上 例 中 && 改 成 : public class Temp{ public static void main(string[] args){ boolean n = (5 > 3) (2 > 8); System.out.println(n); 以 上 实 例 编 译 运 行 结 果 如 下 : true 57

30 面 向 设 备 的 Java 程 序 设 计 MIANXIANG SHEBEIDE Java CHENGXU SHEJI 例 2.13 public class Temp{ public static void main(string[] args){ boolean n =!(2 > 8); System.out.println(n); 例 2.13 的 编 译 运 行 结 果 如 下 : true 4 位 运 算 符 Java 中 的 位 运 算 符 如 表 2-8 所 示 表 2-8 Java 中 的 位 运 算 符 运 算 符 含 义 示 例 ~ 按 位 非 (NOT)/ 取 反 b=~a & 按 位 与 (AND) c=a&b 按 位 或 (OR) c=a b ^ 按 位 异 或 (XOR) c=a^b >> 右 移 b=a>>2 >>> 无 符 号 右 移, 左 边 空 出 的 位 以 0 填 充 b=a>>>2 << 左 移 b=a<<1 运 算 规 则 : 按 位 与 (&): 两 位 全 为 1, 结 果 为 1, 否 则 为 0; 按 位 或 ( ) : 两 位 有 一 个 为 1, 结 果 为 1, 否 则 为 0; 按 位 取 反 (~):0 变 1, 1 变 0; 按 位 异 或 (^): 两 位, 如 果 相 同, 结 果 为 0; 如 果 不 同, 结 果 为 1; 算 术 右 移 (>>): 低 位 溢 出, 符 号 位 不 变, 并 用 符 号 位 补 溢 出 的 高 位 ; 算 术 左 移 (<< ): 符 号 位 不 变, 低 位 补 0; 逻 辑 右 移 (>>>): 低 位 溢 出, 高 位 补 0; 注 意 : 逻 辑 右 移 (>>>) 中 的 符 号 位 ( 最 高 位 ) 也 跟 着 变 例 2.14 与 运 算 符 public class Temp{ public static void main(string[] args){ int a=129; 58

31 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 int b=128; System.out.println( a 和 b 与 的 结 果 是 :"+(a&b)); 例 2.14 的 编 译 运 行 结 果 如 下 : a 和 b 与 的 结 果 是 :128 分 析 :129 转 换 成 二 进 制 就 是 ,128 转 换 成 二 进 制 就 是 根 据 与 运 算 符 的 运 算 规 律, 只 有 两 个 位 都 是 1, 结 果 才 是 1, 可 以 知 道 结 果 就 是 , 即 128 例 2.15 或 运 算 符 public class Temp{ public static void main(string[] args){ int a=129; int b=128; System.out.println( a 和 b 或 的 结 果 是 :"+(a b)); 例 2.15 的 编 译 运 行 结 果 如 下 : a 和 b 或 的 结 果 是 :129 分 析 : 根 据 或 运 算 符 的 运 算 规 律, 只 有 两 个 位 有 一 个 是 1, 结 果 才 是 1, 可 知 结 果 就 是 , 即 129 例 2.16 取 反 运 算 符 public class Temp{ public static void main(string[] args){ int a=2; System.out.println( a 非 的 结 果 是 :"+(~a)); 例 2.16 的 编 译 运 行 结 果 如 下 : a 非 的 结 果 是 :-3 分 析 : 根 据 取 反 运 算 符 的 运 算 规 律,2 转 换 成 二 进 制 就 是 , 取 反 后 为 , 最 高 位 是 1, 即 负 数, 转 换 成 十 进 制 后 为 -3 例 2.17 异 或 运 算 符 public class Temp{ public static void main(string[] args){ int a=15; int b=2; 59

32 面 向 设 备 的 Java 程 序 设 计 MIANXIANG SHEBEIDE Java CHENGXU SHEJI System.out.println( a 与 b 异 或 的 结 果 是 :"+(a^b)); 例 2.17 的 编 译 运 行 结 果 如 下 : a 与 b 异 或 的 结 果 是 :13 分 析 : 15 转 换 成 二 进 制 为 1111, 2 转 换 成 二 进 制 为 0010, 根 据 异 或 的 运 算 规 律, 可 以 得 出 其 结 果 为 1101 即 13 例 2.18 右 移 运 算 符 public class Temp{ public static void main(string[] args){ int n = 5 >> 2 ; System.out.println(n); 例 2.18 的 编 译 运 行 结 果 如 下 : 1 例 2.19 左 移 运 算 符 public class Temp{ public static void main(string[] args){ int n = 5 << 2 ; System.out.println(n); 例 2.19 的 编 译 运 行 结 果 如 下 : 20 例 2.20 无 符 号 右 移 运 算 符 public class Temp{ public static void main(string[] args){ int n = 7 >>> 2 ; System.out.println(n); 例 2.20 的 编 译 运 行 结 果 如 下 : 1 注 意 : 移 位 运 算 符 ( 只 能 处 理 整 数 运 算 符 ) char byte short 类 型, 在 进 行 移 位 之 前, 都 将 被 转 换 成 int 类 型, 移 位 后 的 结 果 也 是 int 类 型 ; 移 位 符 号 右 边 的 操 作 数 只 截 取 其 二 进 60

33 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 制 的 后 5 位 ( 目 的 是 防 止 因 为 移 位 操 作 而 超 出 int 类 型 的 表 示 范 围 :2 的 5 次 方 是 32,int 类 型 的 最 大 范 围 是 32 位 ); 对 long 类 型 进 行 移 位, 结 果 仍 然 是 long 类 型, 移 位 符 号 右 边 的 操 作 符 只 截 取 其 二 进 制 的 后 6 位 << 和 >> : 若 符 号 位 为 正, 则 在 最 高 位 插 入 0; 若 符 号 位 为 负, 则 在 最 高 位 插 入 1 >>> : 无 论 正 负, 都 在 最 高 位 插 入 0 5 赋 值 运 算 符 假 如 a=3;b=2;java 中 的 赋 值 运 算 符 如 表 2-9 所 示 表 2-9 Java 中 的 赋 值 运 算 符 运 算 符 运 算 赋 值 范 例 结 果 说 明 = 赋 值 a=3;b=2; a=3;b=2; += 加 等 于 a=3;b=2;a+=b a=5;b=2; a=a+b; -= 减 等 于 a=3;b=2;a-=b; a=1;b=2; a=a-b; *= 乘 等 于 a=3;b=2;a*=b; a=6;b=2; a=a*b; /= 除 等 于 a=3;b=2;a/=b; a=1;b=2; a=a/b; %= 模 等 于 a=3;b=2;a%=b; a=1;b=2; a=a%b; 6 条 件 运 算 符 条 件? 表 达 式 1: 表 达 式 2; 如 果 条 件 的 值 为 true 则 这 个 表 达 式 的 值 为 表 达 式 1 的 值, 否 则 为 表 达 式 2 的 值 例 2.21 public class Temp{ public static void main(string[] args){ boolean n = (5 < 3)? true : false; System.out.println(n); 例 2.21 的 编 译 运 行 结 果 如 下 : false 7 运 算 符 的 优 先 级 Java 中 运 算 符 的 优 先 级 和 结 合 性 如 表 2-10 所 示 表 2-10 Java 中 运 算 符 的 优 先 级 和 结 合 性 序 列 号 符 号 名 称 结 合 性 目 数. 点 从 左 到 右 双 目 1 ( ) 圆 括 号 从 左 到 右 [ ] 方 括 号 从 左 到 右 61

34 面 向 设 备 的 Java 程 序 设 计 MIANXIANG SHEBEIDE Java CHENGXU SHEJI ( 续 ) 序 列 号 符 号 名 称 结 合 性 目 数 + 正 号 从 右 到 左 单 目 - 符 号 从 右 到 左 单 目 2 ++ 自 增 从 右 到 左 单 目 -- 自 减 从 右 到 左 单 目 ~ 按 位 非 从 右 到 左 单 目! 逻 辑 非 从 右 到 左 单 目 * 乘 从 左 到 右 双 目 3 / 除 从 左 到 右 双 目 % 取 余 从 左 到 右 双 目 4 + 加 从 左 到 右 双 目 - 减 从 左 到 右 双 目 << 左 移 位 运 算 符 从 左 到 右 双 目 5 >> 带 符 号 右 移 运 算 符 从 左 到 右 双 目 >>> 无 符 号 右 移 从 左 到 右 双 目 < 小 于 从 左 到 右 双 目 <= 小 于 或 等 于 从 左 到 右 双 目 6 > 大 于 从 左 到 右 双 目 >= 大 于 或 等 于 从 左 到 右 双 目 instance of 确 定 某 对 象 是 否 属 于 指 定 的 类 从 左 到 右 双 目 7 == 等 于 从 左 到 右 双 目!= 不 等 于 从 左 到 右 双 目 8 & 按 位 与 从 左 到 右 双 目 9 按 位 或 从 左 到 右 双 目 10 ^ 按 位 异 或 从 左 到 右 双 目 11 && 短 路 非 从 左 到 右 双 目 12 短 路 或 从 左 到 右 双 目 13?: 条 件 运 算 符 从 右 到 左 三 目 = 赋 值 运 算 符 从 右 到 左 双 目 += -= *= /= 14 %= &= 混 合 运 算 符 从 右 到 左 双 目 = ^= <<= >>= >>>= 62

35 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 说 明 : 单 目 运 算 符 就 是 只 有 需 要 一 个 操 作 数 的 运 算 符, 如 :-- ++; 双 目 运 算 符 就 是 需 要 两 个 操 作 数 的 运 算 符, 如 :+ - * / = 等 ; 三 目 运 算 符 需 要 三 个 操 作 数 8 表 达 式 表 达 式 是 由 操 作 数 和 运 算 符 按 一 定 的 语 法 形 式 组 成 的 符 号 序 列 一 个 常 量 或 一 个 变 量 是 最 简 单 的 表 达 式, 其 值 即 该 常 量 或 变 量 的 值 ; 表 达 式 的 值 还 可 以 用 作 其 他 运 算 的 操 作 数, 形 成 更 复 杂 的 表 达 式 例 如 : 布 尔 型 表 达 式 : x&&y z; 整 型 表 达 式 : num1+num2; 例 如, 根 据 运 算 符 优 先 级, 下 述 条 件 语 句 分 四 步 完 成 : result=sum==0?1:num/sum; 第 1 步 :result=sum==0?1:(num/sum) 第 2 步 :result=(sum==0)?1:(num/sum) 第 3 步 :result=((sum==0)?1:(num/sum)) 第 4 步 :result= 2.5 方 法 1 方 法 的 定 义 与 调 用 Java 中, 方 法 只 能 在 类 中 定 义, 由 方 法 头 和 方 法 体 两 部 分 组 成 格 式 : [ 修 饰 符 ] 返 回 值 类 型 方 法 名 ([ 形 参 列 表 ]) { 局 部 变 量 / 对 象 声 明 部 分 ; 语 句 部 分 ; 方 法 语 法 格 式 的 详 细 说 明 如 下 : 63

36 面 向 设 备 的 Java 程 序 设 计 MIANXIANG SHEBEIDE Java CHENGXU SHEJI 1. 修 饰 符 : 修 饰 符 可 以 省 略, 也 可 以 是 public protected private static final abstract 其 中 public protected private 三 个 最 多 只 能 出 现 其 中 之 一 ;abstract 和 final 最 多 只 能 出 现 其 中 之 一, 它 们 可 以 与 static 组 合 起 来 修 饰 方 法 2. 方 法 返 回 值 类 型 : 返 回 值 类 型 可 以 是 Java 语 言 允 许 的 任 何 数 据 类 型, 包 括 基 本 类 型 和 引 用 类 型 ; 如 果 声 明 了 方 法 返 回 值 类 型, 则 方 法 体 内 必 须 有 一 个 有 效 的 return 语 句, 该 语 句 返 回 一 个 变 量 或 一 个 表 达 式, 这 个 变 量 或 者 表 达 式 的 类 型 必 须 与 此 处 声 明 的 类 型 匹 配 除 此 之 外, 如 果 一 个 方 法 没 有 返 回 值, 则 必 须 使 用 void 来 声 明 没 有 返 回 值 3. 方 法 名 : 方 法 名 命 名 规 则 与 属 性 命 名 规 则 基 本 相 同, 但 通 常 建 议 方 法 名 以 英 文 中 的 动 词 开 头 4. 形 参 列 表 : 形 参 列 表 用 于 定 义 该 方 法 可 以 接 受 的 参 数, 形 参 列 表 由 零 组 到 多 组 参 数 类 型 形 参 名 组 合 而 成, 多 组 参 数 之 间 以 英 文 逗 号 (,) 隔 开, 形 参 类 型 和 形 参 名 之 间 以 英 文 空 格 隔 开 一 旦 在 定 义 方 法 时 指 定 了 形 参 列 表, 则 调 用 该 方 法 时 必 须 传 入 对 应 的 参 数 值 谁 调 用 方 法, 谁 负 责 为 形 参 赋 值 5.Java 程 序 的 入 口 main 就 为 一 个 方 法, 参 数 为 String[] args, 它 是 个 特 殊 的 方 法 方 法 体 里 多 条 可 执 行 性 语 句 之 间 有 严 格 的 执 行 顺 序, 排 在 方 法 体 前 面 的 语 句 总 是 先 执 行, 排 在 方 法 体 后 面 的 语 句 总 是 后 执 行 例 如 : 定 义 计 算 平 方 值 的 方 法 static int square(int x) { int s; s=x*x; return s; int 是 方 法 返 回 值 类 型,square 是 方 法 的 名 字 ;x 是 方 法 的 形 式 参 数,s 是 方 法 体 内 的 局 部 变 量 方 法 的 参 数 是 提 供 外 界 在 执 行 方 法 的 时 候 提 供 给 方 法 的 特 殊 描 述 信 息 的 例 如 上 例 中 需 要 计 算 平 方 值, 则 需 要 提 供 给 方 法 边 长 的 值, 即 参 数 x 的 值 一 形 参 方 法 头 定 义 时 所 带 的 参 数 称 为 形 参, 它 规 定 了 方 法 的 输 入 数 据, 调 用 时 所 带 的 参 数 称 为 实 参 带 多 个 参 数 时, 要 指 明 各 参 数 的 类 型, 并 用 逗 号 把 各 参 数 分 隔 开 来 二 返 回 值 方 法 的 返 回 值 是 方 法 的 输 出 数 据 定 义 方 法 头 时, 通 过 定 义 方 法 返 回 值 类 型 说 明 该 方 法 的 输 出 数 据 类 型, 用 return 语 句 返 回 确 定 数 值 64

37 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 方 法 无 返 回 值 时, 返 回 值 类 型 应 为 void 格 式 :return 表 达 式 ; 三 构 造 方 法 构 造 方 法 是 一 个 特 殊 的 方 法, 定 义 构 造 方 法 的 语 法 格 式 与 定 义 方 法 的 语 法 格 式 很 像, 语 法 格 式 如 下 : [ 修 饰 符 ] 构 造 方 法 名 ( 形 参 列 表 ) { // 由 零 条 到 多 条 可 执 行 性 语 句 组 成 的 构 造 方 法 执 行 体 1. 修 饰 符 : 修 饰 符 可 以 省 略, 也 可 以 是 public protected private 其 中 之 一 2. 构 造 方 法 名 : 构 造 方 法 名 必 须 和 类 名 相 同 3. 形 参 列 表 : 和 定 义 方 法 形 参 列 表 的 格 式 完 全 相 同 值 得 指 出 的 是, 构 造 方 法 不 能 定 义 返 回 值 类 型 声 明, 也 不 能 使 用 void 定 义 构 造 方 法 没 有 返 回 值 如 果 为 构 造 方 法 定 义 了 返 回 值 类 型, 或 使 用 void 定 义 构 造 方 法 没 有 返 回 值, 编 译 时 不 会 出 错, 但 Java 会 把 这 个 所 谓 的 构 造 方 法 当 成 方 法 来 处 理 四 方 法 的 使 用 1. 程 序 调 用 方 法 : 大 部 分 用 户 自 定 义 的 方 法 都 属 于 程 序 调 用 方 法 调 用 命 令 通 过 被 调 用 方 法 的 名 称 来 说 明 要 使 用 哪 个 自 定 义 的 方 法, 完 成 形 实 结 合, 为 被 调 用 方 法 的 各 形 参 赋 初 值 如 :x=isprime(i); 当 有 多 个 同 名 方 法 时, 根 据 参 数 列 表 来 区 分 2. 系 统 调 用 方 法 : 其 最 大 特 点 是 方 法 定 义 后, 系 统 会 在 程 序 运 行 过 程 中 自 动 去 调 用 此 方 法 才 完 成 它 所 定 义 的 任 务 如 :init() 调 用 方 法 的 语 句 通 过 使 用 方 法 名 和 实 际 参 数 列 表 来 通 知 系 统 它 要 调 用 哪 个 方 法, 方 法 名 相 同 的 方 法 其 参 数 列 表 一 定 不 同 实 际 参 数 列 表 与 形 式 参 数 列 表 必 须 有 完 全 相 同 的 参 数 数 目 类 型 和 顺 序, 也 可 以 用 数 目 类 型 和 顺 序 吻 合 的 常 量 来 代 替 实 际 参 数 列 表 2 方 法 调 用 中 的 数 据 传 递 执 行 方 法 调 用 语 句 时, 或 者 方 法 被 系 统 自 动 调 用 时, 程 序 的 流 程 将 转 移 到 被 调 用 方 法, 实 际 参 数 的 数 值 被 传 给 形 式 参 数 作 初 值, 流 程 从 被 调 用 方 法 的 第 一 个 语 句 开 始 执 行 65

38 面 向 设 备 的 Java 程 序 设 计 MIANXIANG SHEBEIDE Java CHENGXU SHEJI 一 传 递 的 参 数 为 基 本 类 型 时 例 2.22 当 传 递 类 型 为 基 本 类 型 时, 传 递 的 是 该 类 型 的 值 public class Temp { // 方 法 add 是 把 传 入 的 参 数 进 行 +1, 并 显 示 其 结 果 public void add(int i) { i = i + 1; System.out.println(i); // 程 序 的 运 行 方 法, 即 主 入 口 方 法 public static void main(string args[]) { // 基 本 类 型 的 局 部 变 量 int length = 10; // 创 建 bike 类 的 对 象 实 例, 即 bike 类 的 对 象 引 用 b Temp t = new Temp(); // 打 印 原 来 的 值 System.out.println(length); // 调 用 方 法 作 为 参 数 时 的 值 t.add(length); // 打 印 运 行 后 的 值 System.out.println(length); 例 2.22 的 编 译 运 行 结 果 如 下 : 分 析 : 在 参 数 为 基 本 类 型 进 行 传 递 的 时 候, 是 传 递 的 这 个 值 的 备 份, 不 论 在 方 法 中 怎 么 改 变 这 个 备 份, 都 不 是 操 作 原 来 的 数 据, 所 以 原 来 的 值 是 不 会 改 变 的 因 此 形 参 值 的 变 化 不 影 响 实 参 二 传 递 的 参 数 为 对 象 引 用 类 型 时 例 2.23 当 传 递 的 参 数 为 对 象 引 用 类 型 时, 也 是 利 用 的 传 值 的 方 式 进 行 的 public class Temp { public static void main(string[] args) { // 创 建 一 个 对 象 类 型 String s = new String( Hello Java ); // 打 印 其 值 66

39 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 System.out.println( before : + s); // 通 过 方 法 去 改 变 其 值 changestring(s); // 打 印 方 法 改 变 的 值 和 原 值 System.out.println( changestring : + s); System.out.println( after : + s); public static void changestring(string str) { str = new String( Hello ); str = str + china! ; 例 2.23 的 编 译 运 行 结 果 如 下 : before : Hello Java changestring : Hello Java after : Hello Java 分 析 : 当 把 对 象 引 用 s 传 递 到 一 个 方 法 后,str 引 用 同 一 个 字 符 串 Hello Java, 但 这 里 传 递 对 象 引 用 后, 又 通 过 这 个 引 用 去 创 建 了 一 个 新 的 String 类 型 的 字 符 串, 这 两 个 字 符 串 在 内 存 中 当 然 不 是 同 一 个 了, 因 此 对 于 s 来 说, 它 的 引 用 仍 然 不 变 例 2.24 public class Temp { private void test(a a) { a.age = 20; System.out.println( test1 方 法 中 的 age=" + a.age); public static void main(string[] args) { Temp t = new Temp(); A a = new A(); a.age = 10; // 方 法 调 用 前 System.out.println( main 方 法 中 之 前 的 age=" + a.age); t.test(a); // 方 法 调 用 后, 改 变 了 对 象 的 属 性 System.out.println( main 方 法 中 之 后 的 age=" + a.age); class A { 67

40 面 向 设 备 的 Java 程 序 设 计 MIANXIANG SHEBEIDE Java CHENGXU SHEJI public int age = 0; 例 2.24 的 编 译 运 行 结 果 如 下 : main 方 法 中 之 前 的 age=10 test1 方 法 中 的 age=20 main 方 法 中 之 后 的 age=20 分 析 : 和 上 例 不 同 的 是, 当 把 对 象 引 用 a 传 递 到 一 个 方 法 后, 这 个 方 法 可 以 改 变 这 个 对 象 的 age 属 性, 并 能 返 回 相 应 的 改 变 但 要 注 意 这 个 对 象 引 用 a 是 永 远 不 会 改 变 的 3 变 量 的 作 用 域 生 命 周 期 与 作 用 域 是 两 个 不 同 的 概 念 : 生 命 周 期 是 对 象 或 变 量 生 存 的 时 段, 作 用 域 是 对 象 或 变 量 起 作 用 的 地 方 即 生 命 周 期 定 义 的 是 时 间, 作 用 域 定 义 的 是 空 间 一 变 量 的 生 命 周 期 生 命 周 期 是 指 从 产 生 到 消 亡 的 过 程 例 如 : 静 态 变 量 : 类 的 静 态 变 量 在 内 存 中 只 有 一 个,Java 虚 拟 机 在 加 载 类 的 过 程 中 为 静 态 变 量 分 配 内 存, 静 态 变 量 位 于 方 法 区, 被 类 的 所 有 实 例 共 享 静 态 变 量 可 以 直 接 通 过 类 名 被 访 问 静 态 变 量 的 生 命 周 期 取 决 于 类 的 生 命 周 期, 当 加 载 类 的 时 候, 静 态 变 量 被 创 建 并 分 配 内 存, 当 卸 载 类 的 时 候, 静 态 变 量 被 销 毁 并 撤 销 所 占 用 的 内 存 实 例 变 量 : 类 的 每 个 实 例 都 有 相 应 的 实 例 变 量 每 创 建 一 个 类 的 实 例,Java 虚 拟 机 就 会 为 实 例 变 量 分 配 一 次 内 存, 实 例 变 量 位 于 堆 区 中 实 例 变 量 的 生 命 周 期 取 决 于 实 例 的 生 命 周 期, 当 创 建 实 例 的 时 候, 实 例 变 量 被 创 建 并 分 配 内 存, 当 销 毁 实 例 的 时 候, 实 例 变 量 被 销 毁 所 占 内 存 局 部 变 量 : 当 Java 虚 拟 机 调 用 一 个 方 法 时, 会 为 这 个 方 法 中 的 局 部 变 量 分 配 内 存 当 Java 虚 拟 机 结 束 调 用 一 个 方 法 时, 会 结 束 这 个 方 法 中 局 部 变 量 的 生 命 周 期 二 对 象 的 生 命 周 期 对 象 会 经 过 三 个 步 骤 : 声 明 创 建 和 赋 值 对 象 的 生 命 周 期 是 指 从 构 造 方 法 创 建 对 象, 到 对 象 不 再 被 使 用 时 ( 无 引 用 ),Java 的 垃 圾 收 集 器 将 回 收 该 对 象, 即 对 象 被 清 除 的 过 程 有 三 种 情 况 可 以 释 放 对 象 的 引 用, 即 Java 会 自 动 清 除 对 象 : 1. 引 用 永 久 性 地 离 开 它 的 范 围 通 常 是 方 法 调 用 完 毕, 释 放 方 法 的 变 量 对 象 如 : 68

41 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 void fun(){ Student stu = new Student(); 调 用 方 法 时 创 建 对 象 stu, 调 用 结 束 后 stu 消 失 2. 引 用 被 赋 值 到 其 他 对 象 上 Student stu1 = new Student( Tom,18); Student stu2 = new Student( Jack,19); stu1 = stu2; // stu1 原 来 引 用 的 对 象 被 释 放 3. 直 接 将 引 用 赋 值 为 空 null Student stu = new Student(); stu = null; //stu 原 来 引 用 的 对 象 会 被 释 放 三 变 量 的 作 用 域 变 量 的 作 用 域 指 变 量 起 作 用 的 范 围, 说 明 变 量 在 什 么 部 分 可 以 被 访 问 ; 变 量 的 作 用 域 属 于 声 明 它 的 代 码 块, 变 量 的 最 小 作 用 域 是 包 含 它 的 一 对 { 之 间 1. 在 一 个 方 法 内 部 定 义 的 变 量, 只 在 本 方 法 范 围 内 有 效 形 式 参 数 也 是 局 部 变 量 public static int max(int a, int b, int c) { int m; // a,b,c,m 有 效 public static int min(int x, int y, int z) { int n; // x,y,z,n 有 效 public static void main (String[] args) { int i,j,k ; // i,j,k 有 效 2. 不 同 方 法 中 可 以 使 用 相 同 名 字 的 变 量, 他 们 代 表 不 同 的 对 象, 仍 然 只 在 本 方 法 内 有 效, 互 不 干 扰 public static int max(int a, int b, int c){ int m; // a, b, c, m 有 效 public static int min(int a, int b, int c){ int m; // a, b, c, m 有 效 public static void main (String[] args){ int a,b,c ; // a, b, c 有 效 3. 在 一 个 方 法 内 部, 可 以 在 复 合 语 句 中 定 义 变 量, 这 些 变 量 只 在 本 复 合 语 句 中 有 效 69

42 面 向 设 备 的 Java 程 序 设 计 MIANXIANG SHEBEIDE Java CHENGXU SHEJI public static void main (String[] args) { int a, b; { int c; c= a+b ; 4 方 法 的 嵌 套 和 递 归 调 用 一 嵌 套 调 用 在 解 决 较 为 复 杂 的 问 题 时, 用 到 方 法 调 用 的 地 方 比 较 多 如 果 在 一 个 方 法 的 方 法 体 中 又 调 用 了 另 外 的 方 法, 这 就 被 称 为 方 法 的 嵌 套 调 用, 也 称 方 法 的 嵌 套 例 2.25 求 立 方 体 的 体 积 public class Temp { public static void main(string args[ ]) { int i=5,j=6,k=7,v; v=vol(i,j,k); System.out.println( 立 方 体 的 体 积 为 : +v); static int vol(int a,int b,int c) // 求 体 积 的 vol() 方 法 { return(a*area(b,c)); static int area(int x,int y) // 求 面 积 的 area() 方 法 { return(x*y); 例 2.25 的 编 译 运 行 结 果 如 下 : 立 方 体 的 体 积 为 :210 分 析 :main() 方 法 中, 调 用 vol() 方 法 求 立 方 体 的 体 积, 转 到 vol() 方 法 体 中 又 调 用 了 area() 方 法 求 面 积 这 种 在 调 用 一 个 方 法 vol() 的 方 法 体 中 又 调 用 另 外 的 一 个 方 法 area() 的 做 法, 就 是 方 法 的 嵌 套 70

43 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 二 递 归 调 用 如 果 在 一 个 方 法 的 方 法 体 中 又 调 用 它 自 身 的 方 法 嵌 套 称 为 方 法 的 递 归 例 2.26 采 用 递 归 算 法 求 n! public class Temp { static long fac(int n) { if(n==1) else return 1; return n*fac(n-1); public static void main(string[] args) { int k; long f; k=5; f=fac(k); System.out.println(f); 例 2.26 的 编 译 运 行 结 果 如 下 : 120 分 析 : 从 程 序 设 计 的 角 度 来 说, 递 归 调 用 必 须 解 决 两 个 问 题 : 一 是 递 归 计 算 的 公 式, 二 是 递 归 结 束 的 条 件 每 一 个 要 使 用 递 归 的 方 法 解 决 的 问 题, 都 要 先 考 虑 好 这 两 个 方 面 例 2.27 Fibonacci 数 列 是 这 样 的 一 列 数 :1,1,2,3,5,8,13,21,34, 55, 第 n 个 Fibonacci 数 的 递 归 描 述 为 : 1 n=1,2 f(n)= f(n 2)+f(n 1) n>2 public class Temp { public static void main(string args[ ]) { for(int i=1;i<=20;i++) { System.out.print(f(i)+ ); if (i%10==0) System.out.println(); 71

44 面 向 设 备 的 Java 程 序 设 计 MIANXIANG SHEBEIDE Java CHENGXU SHEJI static int f(int n) { if(n==1 n==2) return 1; else return (f(n-2)+f(n-1)); 例 2.27 的 编 译 运 行 结 果 如 下 : 分 析 : 本 例 说 到 的 递 归 描 述 中 就 包 含 了 两 个 条 件, 其 中 : 递 归 计 算 公 式 :f(n)=f(n-2)+f(n-1) 递 归 结 束 条 件 :f(1)=1,f(2)=1 2.6 Java 编 码 规 范 编 写 Java 程 序 是 要 按 照 Java 编 码 规 范 来 进 行 编 写 的 一 个 程 序 不 按 照 编 码 规 范 可 能 也 是 能 够 运 行 的, 但 是 不 按 照 编 码 规 范 编 写 的 程 序 不 是 一 个 好 程 序, 这 种 程 序 不 易 于 程 序 的 查 看 和 维 护 编 码 规 范 包 括 很 多 内 容, 例 如 代 码 的 编 写 规 则, 命 名 规 则, 代 码 注 释 等 多 项 内 容 1 代 码 编 写 规 则 代 码 必 须 有 缩 进, 缩 进 可 以 使 用 Tab 键, 或 者 四 个 空 格 因 为 4 个 空 格 在 eclipse 中 默 认 作 为 一 个 Tab 缩 进 单 位 每 行 代 码 不 要 超 过 80 个 字 符, 这 是 由 于 很 多 编 写 工 具 不 能 对 超 过 80 个 字 符 的 内 容 进 行 很 好 的 解 释 当 代 码 在 一 行 中 放 不 下 时, 应 进 行 换 行 但 是 换 行 不 能 自 动 换 行, 而 是 按 照 级 别 来 进 行 换 行, 并 且 同 级 别 对 齐 2 代 码 注 释 1. 行 注 释 所 谓 行 注 释 就 是 一 整 行 的 注 释 信 息, 单 行 注 释 也 是 最 常 用 的, 行 注 释 使 用 // 的 注 释 方 法 72

45 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 来 注 释 需 要 表 明 的 内 容 并 且 把 注 释 的 内 容 放 在 需 要 注 释 的 代 码 的 前 面 一 行 或 同 一 行 例 2.28 public class Temp { // 这 是 Java 程 序 的 入 口 方 法 public static void main(string args[]) { System.out.println( 欢 迎 学 习 Java 程 序 设 计! ); 2. 块 注 释 使 用 /** 和 */ 注 释 的 方 法 来 注 释 需 要 表 明 的 内 容 并 且 把 注 释 的 内 容 放 在 需 要 注 释 的 代 码 的 前 面 例 如 : Arthur */ 3. 文 档 注 释 注 释 文 档 将 用 来 生 成 HTML 格 式 的 代 码 报 告, 所 以 注 释 文 档 必 须 书 写 在 类 域 构 造 函 数 方 法 定 义 之 前 注 释 文 档 由 两 部 分 组 成 描 述 块 标 记 有 三 种 类 型 的 注 释 文 档, 它 们 对 应 于 位 于 注 释 后 面 的 元 素 : 类 变 量 或 者 方 法 也 就 是 说, 一 个 类 注 释 正 好 位 于 一 个 类 定 义 之 前 ; 变 量 注 释 正 好 位 于 变 量 定 义 之 前 ; 而 一 个 方 法 定 义 正 好 位 于 一 个 方 法 定 义 的 前 面 如 下 面 这 个 简 单 的 例 子 所 示 : /** 一 个 类 注 释 */ public class doctest { /** 一 个 变 量 注 释 */ public int i; /** 一 个 方 法 注 释 */ public void f() { 例 2.29 文 档 注 释 /** * method 方 法 的 简 述 * <p>method 方 法 的 详 细 说 明 第 一 行 <br> * method 方 法 的 详 细 说 明 第 二 行 b true 表 示 显 示,false 表 示 隐 藏 没 有 返 回 值 73

46 面 向 设 备 的 Java 程 序 设 计 MIANXIANG SHEBEIDE Java CHENGXU SHEJI */ public void method(boolean b) { 第 一 部 分 是 简 述 文 档 中, 对 于 属 性 和 方 法 都 是 先 有 一 个 列 表, 然 后 才 在 后 面 一 个 一 个 的 详 细 的 说 明 简 述 部 分 写 在 一 段 文 档 注 释 的 最 前 面, 第 一 个 点 号 (.) 之 前 ( 包 括 点 号 ) 换 句 话 说, 就 是 用 第 一 个 点 号 分 隔 文 档 注 释, 之 前 是 简 述, 之 后 是 第 二 部 分 和 第 三 部 分 第 二 部 分 是 详 细 说 明 部 分 该 部 分 对 属 性 或 者 方 法 进 行 详 细 的 说 明, 在 格 式 上 没 有 什 么 特 殊 的 要 求, 可 以 包 含 若 干 个 点 号 * show 方 法 的 简 述. * <p>show 方 法 的 详 细 说 明 第 一 行 <br> * show 方 法 的 详 细 说 明 第 二 行 第 三 部 分 是 特 殊 说 明 部 分 这 部 分 包 括 版 本 说 明 参 数 说 明 返 回 值 说 明 等 b true 表 示 显 示,false 表 示 隐 藏 没 有 返 回 值 2.7 案 例 拓 展 1 案 例 展 现 实 现 单 击 界 面 上 光 照 采 集 按 钮, 界 面 显 示 光 照 的 实 际 物 理 量 值 ; 并 判 断 光 照 是 否 大 于 文 本 输 入 框 的 给 定 值, 是 显 示 光 照 太 强, 否 则 显 示 光 照 太 弱 运 行 效 果 如 图 2-3,2-4 所 示 图 2-3 Case2_2 光 照 太 弱 运 行 效 果 图 2-4 Case2_2 光 照 太 强 运 行 效 果 74

47 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 2 代 码 开 发 实 现 任 务 分 析 (1) 创 建 一 个 空 白 安 卓 程 序 (2) 把 动 态 库 复 制 到 项 目 中 (3) 编 写 UI 布 局 xml 文 件, 自 行 设 计 合 适 UI 界 面 LinearLayout 布 局 使 用 标 签 嵌 套 控 件 渲 染 优 先 级 :android:layout_weight= 1, 当 控 件 有 宽 高 时, 是 渲 染 优 先 级,0 最 高 ( 如 若 控 件 a 宽 度 为 填 充 父 窗 体, 控 件 b 为 包 裹 内 容, 并 且 ab 在 同 一 排, 那 么 b 将 不 可 见 如 果 b 控 件 渲 染 级 别 高 于 a, 那 么 先 绘 制 控 件 b,a 控 件 宽 度 填 充 剩 余 空 间 ) 控 件 权 重 :android:layout_weight= 1, 当 控 件 有 宽 或 高 为 0 时, 是 控 件 为 0 的 宽 或 高 的 权 重, 按 权 重 分 配 宽 度 ( 如 果 某 控 件 宽 度 为 0, 那 么 它 的 宽 度 =( 控 件 权 重 / 所 在 排 所 有 控 件 权 重 和 )* 父 容 器 宽 度 ) (4) 编 写 后 台 代 码, 实 现 程 序 功 能 使 用 动 态 库 采 集 光 照 强 度 按 钮 点 击 事 件 监 控 处 理 使 用 DecimalFormat 类 格 式 化 浮 点 型 数 据 Stirng 转 换 到 Double 操 作 步 骤 (1) 新 建 安 卓 项 目, 把 素 材 文 件 \ 案 例 2\Case2_2\libs 文 件 夹 下 提 供 的 实 训 设 备 操 作 类 库 文 件 复 制 到 libs, 如 图 2-5 所 示 图 2-5 复 制 类 库 文 件 (2) 编 写 好 activity_main.xml 界 面 代 码 75

48 面 向 设 备 的 Java 程 序 设 计 MIANXIANG SHEBEIDE Java CHENGXU SHEJI (3) 打 开 MainActivity.java, 进 行 编 辑 后 台 代 码 public class MainActivity extends Activity { // 声 明 四 个 TextView, 一 个 EditText, 一 个 Button private TextView mtvlight,mtvstate; private EditText metsetlight; private Button mbtngether; // 声 明 刚 导 入 libs 的 NewlandLibrary 中 的 NewlandLibraryHelper 类 private NewlandLibraryHelper protected void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.activity_main); /* * 使 用 findviewbyid 方 法 * 根 据 id 找 到 布 局 文 件 activity_main.xml 中 的 一 个 EditText 和 四 个 TextView 和 一 个 Button * 并 强 制 转 化 为 EditText 和 TextView */ mbtngether = (Button)findViewById(R.id.btnGether); mtvlight = (TextView)findViewById(R.id.tvLight); mtvstate = (TextView)findViewById(R.id.tvState); metsetlight = (EditText)findViewById(R.id.etSetLight); // 实 例 化 NewlandLibraryHelper 类, 将 本 文 的 上 下 文 传 入 即 this // 并 且 调 用 createprovider 方 法 创 建 提 供 者 mlibrary = new NewlandLibraryHelper(this); mlibrary.createprovider(); // 设 置 采 集 按 钮 的 单 击 监 听 事 件 mbtngether.setonclicklistener(new OnClickListener() NewApi public void onclick(view v) { // 设 置 3 个 文 本 框 的 值 mtvlight.settext( 光 照 值 :"+format(mlibrary.getmlightdata())+"lux"); // 获 取 临 界 值 判 断 是 否 实 际 光 照 有 没 有 大 于 临 界 值, 如 果 大 于 则 设 置 文 本 光 照 太 强 否 则 设 置 文 本 光 照 太 弱 String setlight = metsetlight.gettext().tostring(); if(setlight.isempty())return; if(double.valueof(setlight)<mlibrary.getmlightdata()){ else{ mtvstate.settext( 光 照 太 强 "); 76

49 案 例 2 四 输 入 模 块 数 据 采 集 Java 语 法 基 础 mtvstate.settext( 光 照 太 弱 "); protected void ondestroy() { // TODO Auto-generated method stub super.ondestroy(); mlibrary.closeuert(); /** * 保 留 小 数 点 后 两 位 data 需 要 保 留 的 双 精 度 数 据 */ public String format(double data){ DecimalFormat df = new DecimalFormat( 0.00 ); return df.format(data); (4) 部 署 应 用 程 序, 将 ADAM4150 数 字 量 采 集 器 串 口 线 连 接 到 开 发 箱 COM2 口, 启 动 应 用 程 序 本 章 小 结 本 章 首 先 介 绍 了 Java 数 据 类 型 的 分 类 取 值 范 围, 以 及 变 量 的 生 命 周 期 等 内 容 内 存 是 宝 贵 的 有 限 资 源, 合 理 有 效 地 利 用 内 存 是 提 高 程 序 运 行 性 能 的 一 个 关 键 因 素 因 此, 在 编 写 程 序 时,Java 开 发 人 员 要 为 变 量 确 定 合 理 的 数 据 类 型 和 生 命 周 期, 总 的 原 则 是 在 保 证 该 变 量 能 正 常 行 使 使 命 的 前 提 下, 使 它 在 内 存 中 占 用 尽 可 能 小 的 空 间 和 尽 可 能 少 的 时 间 然 后 介 绍 了 Java 语 言 中 各 种 操 作 符 的 用 法, 要 掌 握 各 种 操 作 符 的 用 法, 需 要 了 解 以 下 内 容 : 1. 操 作 符 的 优 先 级 2. 操 作 符 的 结 合 性 3. 运 算 过 程 77