Java基础总结——基本程序结构

作者: adXiang | 来源:发表于2017-11-06 22:41 被阅读27次

1 数据类型

Java 是一种强类型语言。这就意味着必须为每一个变量声明一种类型: 在 Java 中，一共有 8种基本类型（primitive type )，其中有 4 种整型、 2 种浮点类型、 1 种用于表示 Unicode 编码的字符单元的字符类型 char (请参见论述 char 类型的章节）和 1 种用于表示真值的 boolean 类型。

1.1 整型

整型用于表示没有小数部分的数值，它允许是负数。 Java 提供了 4 种整型，具体内容如表 3-1 所示。

1.2 浮点类型

浮点类型用于表示有小数部分的数值。在 Java 中有两种浮点类型，具体内容如表 3-2 所示。

所有的浮点数值计算都遵循 IEEE 754 规范。具体来说，下面是用于表示溢出和出错情况的三个特殊的浮点数值：

正无穷大
负无穷大
NaN (不是一个数字）

例如，一正整数除以 0 的结果为正无穷大。计算 0/0 或者负数的平方根结果为 NaN。

特别要说明的是，不能这样检测一个特定值是否等于 Double.NaN:
if (x = Double.NaN) // is never true
所有“ 非数值” 的值都认为是不相同的。然而，可以使用 Double.isNaN 方法：
if (Double.isNaN(x)) // check whether x is "not a number"

1.3 char类型

char 类型原本用于表示单个字符。不过，现在情况已经有所变化。如今，有些 Unicode字符可以用一个char值描述，另外一些 Unicode 字符则需要两个 char 值。

char 类型的字面量值要用单引号括起来。例如： 'A'是编码值为 65 所对应的字符常量。它与 "A" 不同，"A" 是包含一个字符 A 的字符串。

1.4 boolean类型

boolean (布尔）类型有两个值： false 和 true，用来判定逻辑条件整型值和布尔值之间不能进行相互转换。

2 变量

在 Java 中，每个变量都有一个类型（type)。在声明变量时，变量的类型位于变量名之前。这里列举一些声明变量的示例：

double salary;
int vacationDays;
long earthPopulation;
boolean done;

可以看到，每个声明以分号结束。由于声明是一条完整的 Java语句，所以必须以分号结束。

变量名必须是一个以字母开头并由字母或数字构成的序列。需要注意，与大多数程序设计语言相比，Java 中“字母” 和“ 数字” 的范围更大。字母包括 'A' ~ 'Z'、 'a' ~ 'z'、'_'、'$'或在某种语言中表示字母的任何 Unicode 字符。

2.1 变量初始化

声明一个变量之后，必须用赋值语句对变量进行显式初始化，千万不要使用未初始化的变量。例如， Java 编译器认为下面的语句序列是错误的：

int vacationDays;
System.out.println(vacationDays): // ERROR variable not initialized

要想对一个已经声明过的变量进行赋值，就需要将变量名放在等号（=) 左侧，相应取值的 Java 表达式放在等号的右侧。

int vacationDays;
vacationDays:12;

也可以将变量的声明和初始化放在同一行中。例如：

int vacationDays = 12;

2.2 常量

在 Java 中，利用关键字 final 指示常量。例如：

public class Constants
{
    public static void main(String[] args)
    {
        final double CM_PER_INCH = 2.54;
        double paperWidth = 8.5;
        double paperHeight = 11;
        System,out.println("Paper size in centimeters: "
          + paperWidth * CM PER INCH + " by " + paperHeight * CM.PER.INCH);
    }
}

关键字 final 表示这个变量只能被赋值一次。一旦被赋值之后，就不能够再更改了。习惯上，常量名使用全大写。

3 运算符

在 Java 中，使用算术运算符 +、-、 *、 / 表示加、减、乘、除运算。当参与 / 运算的两个操作数都是整数时，表示整数除法；否则，表示浮点除法。整数的求余操作（有时称为取模 )用％表示。例如， 15/2 等于7， 15%2 等于 1，15.0/2 等于 7.5。

需要注意，整数被 0 除将会产生一个异常，而浮点数被 0 除将会得到无穷大或 NaN 结果。

3.1 数学函数与常量

在 Math 类中，包含了各种各样的数学函数。在编写不同类别的程序时，可能需要的函数也不同。

要想计算一个数值的平方根，可以使用 sqrt 方法：

double x = 4;
double y = Math.sqrt(x);
System.out.println(y); // prints 2.0

在 Java 中，没有幂运算，因此需要借助于 Math 类的 pow 方法。语句：

double y = Math.pow(x, a);

将 y 的值设置为 x 的 a 次幂（xa）。 pow 方法有两个 double 类型的参数，其返回结果也为double 类型。

3.2 数值类型之间的转换

经常需要将一种数值类型转换为另一种数值类型。图 3-1 给出了数值类型之间的合法转换。

在图 3-1 中有 6 个实心箭头，表示无信息丢失的转换；有 3 个虚箭头，表示可能有精度损失的转换。例如，123 456 789 是一个大整数，它所包含的位数比 float 类型所能够表达的位数多。当将这个整型数值转换为 float 类型时，将会得到同样大小的结果，但却失去了一定的精度。

int n = 123456789;
float f = n; // f is 1.23456792E8

当使用上面两个数值进行二元操作时（例如 n + f， n 是整数， f 是浮点数)，先要将两个操作数转换为同一种类型，然后再进行计算。

如果两个操作数中有一个是 double 类型，另一个操作数就会转换为 double 类型。
否则，如果其中一个操作数是 float 类型，另一个操作数将会转换为 float 类型。
否则，如果其中一个操作数是 long 类型，另一个操作数将会转换为 long 类型。
否则，两个操作数都将被转换为 int 类型。

3.3 强制类型转换

在上一小节中看到，在必要的时候， int 类型的值将会自动地转换为 double 类型。但另一方面，有时也需要将 double 转换成 int。在 Java 中，允许进行这种数值之间的类型转换。当然，有可能会丢失一些信息。在这种情况下，需要通过强制类型转换（ cast) 实现这个操作。强制类型转换的语法格式是在圆括号中给出想要转换的目标类型，后面紧跟待转换的变量名。例如：

double x = 9.997;
int nx = (int) x;

这样，变量 nx 的值为 9。强制类型转换通过截断小数部分将浮点值转换为整型。

如果想对浮点数进行舍人运算，以便得到最接近的整数（在很多情况下，这种操作更有用，) 那就需要使用 Math_round 方法：

double x = 9.997;
int nx = (int) Math.round(x);

现在，变量 nx 的值为 10。当调用 round 的时候，仍然需要使用强制类型转换（ int）。其原因是 round 方法返回的结果为 long 类型，由于存在信息丢失的可能性，所以只有使用显式的强制类型转换才能够将 long 类型转换成 int 类型。

3.4 逻辑运算符

3.5 括号与运算符级别

4 大数值

如果基本的整数和浮点数精度不能够满足需求，那么可以使用 java.math 包中的两个很有用的类： Biglnteger 和 BigDecimal。这两个类可以处理包含任意长度数字序列的数值。Biglnteger 类实现了任意精度的整数运算，BigDecimal 实现了任意精度的浮点数运算。

使用静态的 valueOf 方法可以将普通的数值转换为大数值：

Biglnteger a = Biglnteger.valueOf(100);

遗憾的是，不能使用人们熟悉的算术运算符（如：+ 和 *) 处理大数值。而需要使用大数值类中的 add 和 multiply 方法。

Biglnteger c = a.add(b); // c = a + b
Biglnteger d = c.nulti piy(b.add(Biglnteger.val ueOf(2))); // d = c * (b + 2)

API java.math.BigInteger

Biglnteger add(Biglnteger other)
Biglnteger subtract(Biglnteger other)
Biglnteger multipiy(Biginteger other)
Biglnteger divide(Biglnteger other)
Biglnteger mod(Biglnteger other) 返回这个大整数和另一个大整数 other的和、差、积、商以及余数。
int compareTo(Biglnteger other) 如果这个大整数与另一个大整数 other 相等，返回 0; 如果这个大整数小于另一个大整数 other, 返回负数；否则，返回正数。
static Biglnteger valueOf(1ong x) 返回值等于 x 的大整数。

API java.math.BigDecimal

BigDecimal add(BigDecimal other)
BigDecimal subtract(BigDecimal other)
BigDecimal multipiy(BigDecimal other)
BigDecimal divide(BigDecimal other RoundingMode mode) 返回这个大实数与另一个大实数 other 的和、差、积、商。要想计算商，必须给出舍入方式（ rounding mode。)RoundingMode.HALF_UP 是在学校中学习的四舍五入方式（ BP , 数值 0 到 4 舍去，数值 5 到 9 进位）。它适用于常规的计算。有关其他的舍入方式请参看 Apr文档。
int compareTo(BigDecimal other) 如果这个大实数与另一个大实数相等，返回 0 ; 如果这个大实数小于另一个大实数，返回负数；否则，返回正数。
static BigDecimal valueOf(long x)
static BigDecimal valueOf(long x ,int scale) 返回值为 X 或 x / 10scale 的一个大实数。

5 数组

5.1 数组初始化以及匿名数组

在 Java中，提供了一种创建数组对象并同时赋予初始值的简化书写形式。下面是一例子：

int[] smallPrimes = { 2, 3, 5, 7, 11, 13 };

请注意，在使用这种语句时，不需要调用 new。

甚至还可以初始化一个匿名的数组：

new int[] { 17, 19, 23, 29, 31, 37 }

这种表示法将创建一个新数组并利用括号中提供的值进行初始化，数组的大小就是初始值的个数。使用这种语法形式可以在不创建新变量的情况下重新初始化一个数组。例如：

smallPrimes = new int[] { 17, 19, 23, 29, 31, 37 };

这是下列语句的简写形式：

int[] anonymous = { 17, 19, 23, 29, 31, 37 };
smallPrimes = anonymous;

5.2 数组拷贝

在 Java 中，允许将一个数组变量拷贝给另一个数组变量。这时，两个变量将引用同一个数组：

int[] luckyNumbers = smallPrimes;
luckyNumbers[5] = 12; // now smallPrimes[5] is also 12

图 3-14 显示了拷贝的结果。如果希望将一个数组的所有值拷贝到一个新的数组中去，就要使用 Arrays 类的 copyOf方法：

int[] copiedLuckyNumbers = Arrays.copyOf(luckyNumbers, luckyNumbers.length) ;

第 2 个参数是新数组的长度。这个方法通常用来增加数组的大小：

luckyNumbers = Arrays.copyOf(luckyNumbers, 2 * luckyNumbers.length);

如果数组元素是数值型，那么多余的元素将被赋值为 0 ；如果数组元素是布尔型，则将赋值为 false。相反，如果长度小于原始数组的长度，则只拷贝最前面的数据元素。

5.3 命令行参数

前面已经看到多个使用 Java 数组的示例。每一个 Java 应用程序都有一个带 String arg[]参数的 main 方法。这个参数表明 main 方法将接收一个字符串数组，也就是命令行参数。

如果使用下面这种形式运行这个程序：

java Message -g cruel world

args 数组将包含下列内容:

args[0]："-g"
args[l]："cruel"
args[2]："world"

这个程序将显示下列信息:

Goodbye, cruel world!

5.4 数组排序

要想对数值型数组进行排序，可以使用 Arrays 类中的 sort 方法：

int[] a = new int[10000];
...
Arrays.sort(a)

这个方法使用了优化的快速排序算法。快速排序算法对于大多数数据集合来说都是效率比较高的。 Arrays 类还提供了几个使用很便捷的方法，在稍后的 API 注释中将介绍它们。

java,util.Arrays

static String toString(type[] a) 返回包含 a 中数据元素的字符串，这些数据元素被放在括号内，并用逗号分隔。
参数： a 类型为 int、long、short、 char、 byte、boolean、float 或 double 的数组。
static type copyOf(type[] a, int length)
static type copyOfRange(type[] a , int start , int end) 返回与 a 类型相同的一个数组，其长度为 length 或者 end-start，数组元素为 a 的值。
参数： a     类型为 int、 long、 short、 char、 byte、boolean、 float 或 double 的数组。
start     起始下标（包含这个值）0
end     终止下标（不包含这个值）。这个值可能大于 a.length。在这种情况下，结果为 0 或 false。
length     拷贝的数据元素长度。如果 length 值大于 a.length，结果为 0 或 false ;否则，数组中只有前面 length 个数据元素的拷贝值。

static void sort(type[] a) 采用优化的快速排序算法对数组进行排序。
参数： a 类型为 int、long、short、char、byte、boolean、float 或 double 的数组。
static int binarySearch(type[] a , type v)
static int binarySearch(type[] a, int start, int end , type v) 采用二分搜索算法查找值 v。如果查找成功，则返回相应的下标值；否则，返回一个负数值r。 -r-1 是为保持 a 有序 v 应插入的位置。
参数： a     类型为 int、 long、 short、 char、 byte、 boolean 、 float 或 double 的有序数组。
start     起始下标（包含这个值）。
end     终止下标（不包含这个值。)
v     同 a 的数据元素类型相同的值。
static void fill(type[] a , type v) 将数组的所有数据元素值设置为 v。
参数： a 类型为 int、 long、short、 char、byte、boolean 、 float 或 double 的数组。
v 与 a 数据元素类型相同的一个值。
static boolean equals(type[] a, type[] b) 如果两个数组大小相同，并且下标相同的元素都对应相等，返回 true。
参数： a、 b 类型为 int、long、short、char、byte、boolean、float 或 double 的两个数组。