yyrm3.html

关于java学习的一些基本知识！

            <P>文 档 注 释 一 般 放 在 一 个 变 量 或 函 数 定 义 ?reg; 前,指 示 在任 何 自 动 生 成 文 档 系 
            统 中 调 入。 这 ?copy; 注 释 都 是 声 明 条目 的 描 述.。 </P>
            <H3 align=center>3.1.3 标 识 符 </H3>
            <P>变 量， 函 数， 类 和 对 象 的 名 称 都 是 标 识 符， 程 序 员 需 要标 识 和 使 用 的 东 西 都 需 要 
            标 识 符。 在Java语 言 里,标 识 符 以字 符 或_,$开 头,后 面 可 以 包 含 数 字， 标 识 符 是 大 小 写 
            有 区 别的,没 有 长 度 限 制。 </P>
            <P>有 效 的 标 识 符 myname ict_network Hello _sys_path $bill </P>
            <P>例 子： int a_number; char _onechar; float $bill; </P>
            <P>关 键 词 abstract continue for new switch </P>
            <P>boolean default goto null synchronized </P>
            <P>break do if package this </P>
            <P>byte double implements private threadsafe </P>
            <P>byvalue else import protected throw </P>
            <P>case extends instanceof public transient </P>
            <P>catch false int return true </P>
            <P>char final interface short try </P>
            <P>class finally long static void </P>
            <P>const float native super while </P>
            <P>其 它 保 留 词 以 下 单 词 被 保 留 使 用： cast future generic inner </P>
            <P>operator outer rest var </P>
            <H3 align=center>3.1.4 数 据 类 型</H3>
            <P>Java使 用 五 种 基 本 类 型:integer(整 数),floating(浮点 
            数),point(指针),Boolean(布 尔 变 量),Character or String(字 符 或 字 符 ?reg;)。 
            integer 整 数 下 边 给 出 的 数 据 表 示 都 是 整 数 的 例 子： 4 ， 15 ， 089 ， 0xAD00 
            </P>
            <P>整 数 长 度 数 据 类 型 表 示 </P>
            <P>8 bits byte </P>
            <P>16 bits short </P>
            <P>32 bits int </P>
            <P>64 bits long </P>
            <P>floating 浮点 数 下 边 给 出 的 数 据 表 示 都 是浮点 数 的 例 子： 6.37 ， 3.7E15 ， 
            3e8 </P>
            <P>浮点 数 长 度 数 据 类 型 表 示 </P>
            <P>32 bits float </P>
            <P>64 bits double </P>
            <P>Boolean 布 尔 变 量 下 边 是 布 尔 变 量 的 两 种 可 能 取 值： true false </P>
            <P>Character 字 符 下 边 给 出 的 都 是 字 符 的 例 子： a \t (tab) \u????(unicode) 
            </P>
            <P>String 字 符 ?reg; 下 边 给 出 的 都 是 字 符 ?reg; 的 例 子： "This is a string 
            literal" "中 国 科 学 院 计 算 所" </P>
            <P>数 组 你 可 以 定 义 任 意 类 型 的 数 组. char s[]; 这 是 字 符 型数 组； int [] 
            array; 这 是 整 型 数 组； 你 还 可 以 定 义 数 组 的数 组. int block[][]=new int 
            [2][3]; 数 组 边 界 在 运 行 时 被 检 测,避免 堆 栈 溢 出 和 内 存 崩 溃. </P>
            <P>在Java里,数 组 实 际 上 是 一 个 对 象,数 组 有 一 个 成 员 变 量：length。你 可 以 用 这 个 成 
            员 函 数 来 查 看 任 意 数 组 的 长 度. int a[][] = new int [10][3] a.length /* 
            10 */ a[0].length /* 3 */ </P>
            <P>创 建 数 组 在Java里 创 建 数 组,你 可 使 用 两 种 基 本 方 法 ?reg; 一。 创 建 一 个 空 数 
            组： int list[]=new int[50]; 或 你 可 以 用 初始 数 值 填 充 数 组. String names[] 
            = { "Chenji","Yuan","Chun","Yang" }; 相 当 于 下 面 功 能: String names[]; 
            names = new String[4]; names[0]=new String("Chenji"); names[1]=new 
            String("Yuan"); names[2]=new String("Chun"); names[3]=new 
            String("Yang"); </P>
            <P>在 编 译 时 你 不 能 象 下 例 那 样 创 建 静 态 数 组。 int name[50];//将产 生 一 个 编 译 
            错 误 </P>
            <P>你 也 不 能 用new操 作 去 填 充 一 个 没 定 义 大 小 的 数 组。 int name[]; for (int 
            i=0;i&lt;9;i++) { name[i] = i; } </P>
            <H3 align=center>3.1.5 表 达 式 </H3>
            <P>Java语 言 的 表 达 式 和C语 言 非 常 类 似。 </P>
            <P>运 算 符 运 算 符(operator)优 先 级 从 高 到 底 排 列 如 下： . [ ] () ++ -- ! ～ 
            instanceof * / % + - &lt;&lt; &gt;&gt; &gt;&gt;&gt; &lt; &gt; &lt;= 
            &gt;\ == ! = &amp; ^ &amp;&amp; || ? : = op = , </P>
            <P>整 数 运 算 符 在 整 数 运 算 时， 如 果 操 作 数 是long类 型， 则 运算 结 果 是long类 型， 否 则 
            为int类 型， 绝 不 会 是byte，short或char型。这 样， 如 果 变 量i被 声 明 为short或byte，i+1的 
            结 果 会 是int。 如 果结 果 超 过 该 类 型 的 取 值 范 围， 则 按 该 类 型 的 最 大 值 取 模。单 目 整 
            数 运 算 符 是： </P>
            <P>运 算 符 操 作 - 单 目 非 ～ 位 补 码 ++ 加1 -- 减1 </P>
            <P>++运 算 符 用 于 表 示 直 接 加1操 作。 增 量 操 作 也 可 以 用 加 运算 符 和 赋 值 操 作 间 接 完 
            成。++ lvalue （左 值?copy; 表 示lvalue+=1, ++lvalue 也 表 示lvalue =lvalue +1 
            (只 要lvalue没 有 副 作 用)。--运 算符 用 于 表 示 减1操 作。++和--运 算 符 既 可 以 作 为 前 缀 运 
            算 符，也 可 以 做 为 后 缀 运 算 符。 双 目 整 数 运 算 符 是： </P>
            <P>运 算 符 操 作** + 加 - 减 * 乘 / 除 % 取 模 &amp; 位 与 ｜ 位 或 ^ 位 异 或 
            &lt;&lt; 左 移 &gt;&gt; 右 移(带 符 号) &gt;&gt;&gt; 添 零 右移 </P>
            <P>整 数 除 法 按 零 舍 入。 除 法 和 取 模 遵 守 以 下 等 式： ( a/b ) * b + ( a%b ) == 
            a 整 数 算 术 运 算 的 异 常 是 由 于 除 零 或 按 零 取模 造 成 的。 它 将 引 发 一 个 算 术 异 常。 下 
            溢 产 生 零， 上 溢 导致 越 界。 例 如： 加1超 过 整 数 最 大 值， 取 模 后， 变 成 最 小 值。一 个op=赋 
            值 运 算 符， 和 上 表 中 的 各 双 目 整 数 运 算 符 联 用，构 成 一 个 表 达 式。 整 数 关 系 运 算 
            符&lt;， &gt;，&lt;=，&gt;=，==和!=产生boolean类 型 的 数 据。 </P>
            <P>布 尔 运 算 符 布 尔(boolean)变 量 或 表 达 式 的 组 合 运 算 可 以产 生 新 的boolean值。 单 
            目 运 算 符!是 布 尔 非。 双 目 运 算 符 ＆，｜ 和^是 逻 辑AND，OR和XOR运 算 符， 它 们 强 制 两 个 操 
            作 数 求 布 尔值。 为 避 免 右 侧 操 作 数 冗 余 求 值， 用 户 可 以 使 用 短 路 求 值运 算 符 ＆ ＆ 和 
            ｜ ｜。 用 户 可 以 使 用==和!=， 赋 值 运 算 符 也 可以 用 &amp;=、|=、^=。 三 元 条 件 操 作 符? 
            : 和C语 言 中 的 一 样。 </P>
            <P>浮点 运 算 符 浮点 运 算 符 可 以 使 用 常 规 运 算 符 的 组 合： 如单 目 运 算 符++、--， 双 目 运 
            算 符+、-、* 和/， 以 及 赋 值 运 算 符+=，-=，*=，和/=。 此 外， 还 有 取 模 运 算： %和%=也 可 以 
            作 用 于浮点 数， 例 如： a%b和a-((int) (a/b)*b)的 语 义 相 同。 这 表 示a%b的 结 果 是 除 完 
            后剩 下 的浮点 数 部 分。 只 有 单 精 度 操 作 数 的浮点 表 达 式 按 照 单精 度 运 算 求 值， 产 生 单 精 
            度 结 果。 如 果浮点 表 达 式 中 含 有一 个 或 一 个 以 上 的 双 精 度 操 作 数， 则 按 双 精 度 运 算， 
            结 果是 双 精 度浮点 数。 </P>
            <P>数 组 运 算 符 数 组 运 算 符 形 式 如 下： &lt;expression&gt; [ 
            &lt;expression&gt;] 可 给 出 数 组 中 某 个 元 素 的 值。 合 法 的 取 值 范 围 是 从0到 数组 
            的 长 度 减1。 取 值 范 围 的 检 查 只 在 运 行 时 刻 实 ?copy;。 </P>
            <P>?reg; 运 算 符 ?reg; 以String对 象 实 现。 运 算 符"+"完成 并 ?reg; 操 作， 如 果 必 要 
            则 自 动 把 操 作 数 转 换 为String型。如 果 操 作 数 是 一 个 对 象， 它 可 定 义 一 个 方 
            法toString ( ) 返回 该 对 象 的String方 式， 例 如 float a = 1.0 print (“The 
            value of a is”+ a +“\n”); +运 算 符 用 到 ?reg; 上 的 例 子 String s=“a=”+ a; 
            +=运 算 符 也 可 以 用 于String。 注 意， 左 边(下 例 中 的s1)仅 求 值一 次。 s1+=a; 
            //s1=s1+a //若a非String型， 自 动 转 换 为String型。 </P>
            <P>对 象 运 算 符 双 目 运 算 符instanceof 测 试 某 个 对 象 是 否 是 指定 类 或 其 子 类 的 实 
            例。 例 如： if (myObject instanceof MyClass) { MyClass anothermyObject=( 
            MyClass) myObject; … } 是 判 定myObject是 否是MyClass的 实 例 或 是 其 子 类 的 实 
            例。 </P>
            <P>强 制 和 转 换 Java语 言 和 解 释 器 限 制 使 用 强 制 和 转 换， 以防 止 出 错 导 致 系 统 崩 
            溃。 整 数 和浮点 数 ?reg; 间 可 以 来 回 强制 转 换， 但 整 数 不 能 强 制 转 换 成 数 组 或 对 象。 
            对 象 不 能 被强 制 为 基 本 类 型。 </P>
            <H3 align=center>3.1.6 Java流 控 制 </H3>
            <P>下 面 几 个 控 制 结 构 是 从C语 言 借 鉴 的。 </P>
            <P>分 支 结 构 </P>
            <P>if/else分 支 结 构 </P>
            <P>if (Boolean) { statemanets; } else { statements; } </P>
            <P>switch分 支 结 构 </P>
            <P>switch(expr1) { case expr2: statements; break; case expr3: 
            statements; break; default: statements; break; } </P>
            <P>循 环 结 构 for循 环 结 构 </P>
            <P>for (init expr1;test expr2;increment expr3) { statements; } </P>
            <P>While循 环 结 构 </P>
            <P>While(Boolean) { statements; } </P>
            <P>Do循 环 结 构 </P>
            <P>do { statements; } while (Boolean); </P>
            <P>一 般 顺 序 控 制 </P>
            <P>break [label] continue [label] reutrn expr; label:statement; </P>
            <P>for循 环 例 子 下 面 是 一 个 程 序 例 子， 画 几 条 线， 分 别 用 红,绿,蓝颜 色， 这 段 程 序 可 
            能 是Java函 数 的 一 部 分： </P>
            <P>int count; for (count=1;count&lt;=12;count++) { switch (count % 
            3) } case 0: setColor(Color.red); break; case 1: 
            setColor(Color.blue); break; case 2: setColor(Color.green); break; } 
            g.drawLine(10,count*10,80,count*10); } </P>
            <H2 align=center>3.2 Java变 量 和 函 数 的 实 例 </H2>
            <P>Java的 类 包 含 变 量 和 函 数。 数 据 变 量 可 以 是 一 ?copy; 原始 的 类 
            型,如int,char等。 成 员 函 数 是 一 ?copy; 可 执 行 的 过 程。例 如,下 面 程 序 里： public 
            class ClassOne { int i; public ClassOne() { i=10; } </P>
            <P>public void Add_i(int j) { i=i+j; } } </P>
            <P>ClassOne包 含 一 个 变 量i和 两 个 成 员 函 数,ClassOne(int first)和Add_i(int 
            j)。 </P>
            <P>成 员 函 数 成 员 函 数 是 一 ?copy; 可 被 其 它 类 或 自 己 类 调用 的 处 理 子 程 序。 一 个 
            特 殊 的 成 员 函 数 叫 构 造 函 数, 这 个函 数 名 称 一 般 与 本 类 名 程 相 同。 它 没 有 返 回 值。 
            </P>
            <P>构 造 函 数 和 成 员 函 数 当 你 在Java里 定 义 一 个 类 时,你 可 定义 一 个 或 多 个 可 选 的 构 
            造 函 数,当 创 建 本 类 的 一 个 对 象 时用 某 一 个 构 造 函 数 来 初 始 化 本 对 象。 用 前 面 的 程 
            序 例 子来 说 明,当ClassOne类 创 建 一 个 新 实 例 时, 所 有 成 员 函 数 和 变量 被 创 建(创 建 实 
            例)。 构 造 函 数 被 调 用。 ClassOne mc: mc = new ClassOne(); </P>
            <P>关 键 词new用 来 创 建 一 个 类 的 实 例,一 个 类 用new初 始 化 ?reg; 前 并 不 占 用 内 存,它 
            只 是 一 个 类 型 定 义, 当mc对 象 初 始 化 后,mc对象 里 的i变 量 等 于10。 你 可 以 通 过 对 象 名 
            来 引 用 变 量i。(有 时称 ?reg; 为 实 例 变 量) mc.i++;//mc实 例 变 量 加1 因