JAVA基础学习 01

Java程序的基本组成单元是 类

类体中又包括属性与方法两部分。

每一个应用程序都必须包含一个main()方法，含有main()方法的类成为主类。
下面 通过 程序 来 介绍 Java 主 类 结构。

【列 3.1】在 IDEA 下 依次 创建 项目 item、 包 Number 和 类 Frist。 在 类 体中 输入 以下 代码， 实现 在 控制 台上 输出“ 你好 Java”。

package Number;
public class First{
	static String s1 = "你好";
	public static void main(String[] args){
		String s2 ="Java";
		System.out.println(s1);
		System.out.println(s2);
		}
}

3.1.1包声明

一个 Java 应用 程序 是由 若干个 类 组成 的。 在 例 3. 1 中就 是 一个 类 名为 Frist 的 类，
语句 package Number 为 声明 该类 所 在的 包， package 为 包 的 关键字（ 关于 包 的 详细 介绍 可 参见 第 11 章）。
3. 1. 2 　 声明 成员 变量 和局 部 变量

通常 将 类 的 属性 称为 类 的 全局 变量（ 成员 变量）， 将 方法 中的 属性 称为 局部 变量。
全局 变量 声明 在 类 体中， 局部 变量 声明 在 方法 体中。
全局 变量 和局 部 变量 都有 各自 的 应用 范围。 在 例 3. 1 中 s1 是 成员 变量， s2 是 局部 变量。
3. 1. 3 编写 主 方法 main() 方法 是 类 体 中的 主 方法。

该 方法 从“{” 开始， 至“}” 结束。
public、 static 和 void 分别 是 main() 方法 的 权限 修饰 符、 静态 修饰 符 和 返回 值 修饰 符， Java 程序 中的 main() 方法 必须 声明 为 public static void。 String[] args 是 一个 字符串 类型 的 数组， 它是 main() 方法 的 参数（ 以后 章节 中将 作 详细 的 介绍）。 main() 方法 是 程序 开始 执行 的 位置。
3. 1. 4 导入 API 类 库 在 Java 语言 中 可以 通过 import 关键字 导入 相关 的 类。
在 JDK 的 API 中（ 应用 程序 接口） 提供 了 130 多个 包， 如 java. awt、 java. io 等。 可以 通过 JDK 的 API 文档 来 查看 这些 类， 其中 主要 包括 类 的 继承 结构、 类 的 应用、 成员 变 量表、 构造 方法 表 等， 并对 每个 变量 的 使用 目的 作了 详细 的 描述， API 文档 是 程序 开发 人员 不可 或 缺 的 工具。

在 Java 中有 8 种 基本 数据 类型 来 存储 数值、 字符 和 布尔 值，

十进制不能以0开头
八进制必须以0开头 八进制： 如 0123（ 转换 成 十进制 数 为 83）、- 0123（ 转换 成 十进制 数 为- 83）。
十六进制必须以0x 或者 0X开头 十六进制： 如 0x25（ 转换 成 十进制 数 为 37）、 0Xb01e（ 转换 成 十进制 数 为 45086）。

int的取值范围 2的32次方-1 到 -2的32次方。
long型 需要在数字后面加L或者l。

【例 3. 3】 在 项目 中 创建 类 Number， 在 主 方法 中 创建 不同 数值 型 变量， 并将 这些 变量 相加， 将 和 输出。

public class Number{                                                       //创建类
	public static void main(String[] args){							//主方法
		byte mybyte = 124;                                                  //声明byte型变量并赋值
		short myshort = 32564;											//声明short型变量并赋值
		int myint = 45784612;												//声明int型变量并赋值
		long mylong = 4678945l;										//
		long result = mybyte + myint + myshort +mylong;
		System.out.println("结果为：" + result);
	}
}

【例 3. 6】 在 项目 中 创建 类 Gess， 编写 如下 代码， 实 现将 unicode 表中 某些 位置 上 的 字符 以及 一些 字符 在 unicode 表中 的 位置 在 控制 台上 输出。

public class Gess {
    public static void main(String[] args) {
        char word = 'd',word2 = '@';
        int p =12345, p2 =4561;
        System.out.println("d在unicode表中的顺序为：" + (int)word);
        System.out.println("@在unicode表中的顺序为：" + (int)word2);
        System.out.println("p在unicode表中为：" + (char)p);
        System.out.println("p在unicode表中为：" + (char)p2);
    }
}

3.3.2声明变量
变量 的 使用 是 程序设计 中 一个 十分重要 的 环节。 定义 变量 就是 要 告诉 编译器（ compiler） 这个 变量 的 数据 类型， 这样 编译器 才 知道 需要 配置 多少 空间 给 它， 以及 它 能 存放 什么样 的 数据。 在 程序 运行 过程中， 空 间内 的 值 是 变化 的， 这个 内存 空间 就 称为 变量。 为了 便于 操作， 给 这个 空间 取 个 名字， 称为 变量 名。 变量 的 命名 必须 是 合法 的 标识符。 内存 空 间内 的 值 就是 变 量值。 在 声明 变量 时 可以 是 没有 赋值， 也可以 是 直接 赋 给 初值。
3. 3. 3 　 声明 常量 在 程序 运行 过程中 一直 不会 改 变的 量 称为 常量（ constant）， 通常 也 被称为“ final 变量”。 常量 在 整个 程序 中 只能 被 赋值 一次。 在 为所 有的 对象 共享 值 时， 常量 是非 常有 用的。
在 Java 语言 中 声明 一个 常量， 除了 要 指定 数据 类型 外， 还需 要 通过 final 关键字 进行 限定。 声明 常量 的 标准 语法 如下：

final 数据类型 常量名称（可以赋值=值）

常量 名 通常 使用 大写字母， 但这 并不是 必需 的。 很多 Java 程序员 使用 大写字母 表示 常量， 是 为了 清楚 地表 明 正在 使用 常量。 【例 3. 10】 声明 常量， 实例 代码 如下：

final double PI = 3.1415926D;      //声明常量并赋值
final boolean BOOL = true;    

当 定义 的 final 变量 属于“ 成员 变量” 时， 必须 在 定义 时 就 设定 它的 初值， 否则 将会 产生 编译 错误。 从下 面的 实例 中 可 看出 变量 与 常量 的 区别。
【例 3. 11】 在 项目 中 创建 类 Part， 在 类 体中 创建 变量 age 与 常量 PI。 在 主 方法 中 分别 将 变量 与 常量 赋值， 通过 输出 信息 可测 试 变量 与 常量 的 有效 范围。

public class Part {    //新建类
    //声明常量PI，此时如果不对PI赋值，则会出现错误提示
    static final double PI = 3.14;
    static int age = 23;

    public static void main(String[] args) {
        final int number;   //声明int类型number
        number = 12456;    //对常量进行赋值
        age = 22;   //对变量进行赋值
        //number = 123456 ；   错误代码，因为常量只能赋值一次
        System.out.println("常量PI的值为："+ PI);
        System.out.println("常量number的值为："+ number);
        System.out.println("变量age的值为："+ age);
    }
}

~
3. 3. 4 　 变量的有效范围
由于变量被定义出来后 只是 暂存 在 内存中，等到程序执行到某一个点，该变量会被释放掉，也就是说变量有它的生命周期。
因此，变量 的 有效 范围 是指 程序 代码 能够 访问 该 变量 的 区域， 若 超出 该 区域， 则在 编译 时会 出现 错误。 在 程序 中， 一般 会 根据 变量 的“ 有效 范围” 将 变量 分为“ 成员 变量” 和“ 局部 变量”。
~1. 成员 变量
在 类 体中 所 定义 的 变量 被称为 成员 变量， 成员 变量 在 整个 类 中 都 有效。 类 的 成员 变量 又可 分为 两种， 即 静态 变量 和 实例 变量。
【例 3. 12】 声明 静态 变量 和 实例 变量， 实例 代码 如下：

class var{
	int x =45;
	static int y =90;
}

其中， x 为 实例 变量， y 为 静态 变量（ 也称 类变量）。 如果 在 成员 变量 的 类型 前面 加上 关键字 static， 这样 的 成员 变量 称为 静态 变量。 静态 变量 的 有效 范围 可以 跨 类， 甚至 可达到 整个 应用 程序 之内。 对于 静态 变量， 除了 能在 定义 它的 类 内 存取， 还能 直接 以**“ 类 名. 静态 变量”** 的 方式 在 其他 类 内 使用。
~2.局部变量
在 类 的 方法 体中 定义 的 变量（ 方法 内部 定义，“{” 与“}” 之间 的 代码 中 声明 的 变量） 称为 局部 变量。 局部 变量 只在 当前 代码 块 中 有效。 在 类 的 方法 中 声明 的 变量， 包括 方法 的 参数， 都 属于 局部 变量。 局部 变量 只在 当前 定义 的 方法 内 有效， 不能 用于 类 的 其他 方法 中。 局部 变量 的 生命 周期 取决于 方法， 当 方法 被 调用 时， Java 虚拟 机 为 方法 中的 局部 变量 分配 内存 空间， 当 该 方法 的 调用 结束 后， 则 会 释放 方法 中局 部 变量 占用 的 内存 空间， 局部 变量 也 将会 销毁。 局部 变量 可与 成员 变量 的 名字 相同， 此时 成员 变量 将被 隐藏， 即 这个 成员 变量 在此 方法 中 暂时 失效。
变量 的 有效 范围 如图 3. 7 所示。

【例 3. 13】 在 项目 中 创建 类 Val， 分别 定义 名称 相同 的 局部 变量 与 成员 变量， 当 名称 相同 时 成员 变量 将被 隐藏。

public class Val{           //新建类
	static int times = 3;   //定义成员变量times
	public static void main(String[] args){
		int times = 4;            //定义局部变量times
		System.out.println("times 的值为;" + times);   //将times的值输出
	}
}