Java的基本程序设计结构

标准的命名规范：（类名 FirstSample 就遵循了这个规范）：类名是以大写字母开头的名
词。如果名字由多个单词组成，每个单词的第一个字母都应该大写（这种在一个单词中间使，
用大写字母的方式称为骆驼命名法。以其自身为例， 应该写成 CamelCase)。
源代码的文件名必须与公共类的名字相同，并用 .java 作为扩展名。因此，存储这段源代
变量名必须是一个以字母开头并由字母或数字构成的序列,码的文件名必须为 FirstSample.java ，在编译这段源代码之后就会得到一个包含这个类字节码的文件。Java 编译器将字节码文件自动地命名为FirstSample. class, 并与源文件存储在同一个目录下。最后， 使用下面这行命令运行这个程序：java FirstSample

每个 Java 应用程序都必须有一个 main 方法，且main 方法必须声明为 public

float 4 字节 double 8 宇节，float 类型的数值有一个后缀 F 或 f (例如，3.14F。) 没有后缀 F 的浮点数值（如 3.14 ) 默认为 double 类型。当然，也可以在浮点数值后面添加后缀 D 或 d (例如，3.14D)
boolean (布尔）类型有两个值：false 和 true, 用来判定逻辑条件 整型值和布尔值之间不能进行相互转换

关键字 final 表示这个变量只能被赋值一次。一旦被赋值之后，就不能够再更改了。习惯上,常量名使用全大写。在 Java 中，经常希望某个常量可以在一个类中的多个方法中使用，通常将这些常量称为类常量。可以使用关键字 static fina丨设置一个类常量

当参与 / 运算的两个操作数都是整数时， 表示整数除法；否则， 表示浮点除法。 整数的求余操作（有时称为取模) 用 ％ 表示。例如，15/2 等于 7，15%2 等于 1 , 15.0/2 等于 7.50需要注意， 整数被 0 除将会产生一个异常， 而浮点数被 0 除将会得到无穷大或 NaN 结果。

在 Java中，没有幂运算， 因此需要借助于 Math 类的 pow 方法。语句：
double y = Math.pow(x, a); 将 y 的值设置为 x 的 a 次幂。pow 方法有两个 double 类型的参数， 其返回结果也为
double 类型。
int 4 子节
short 2 字节
long 8字节
byte 1 字节
float 4 字节 大约 ± 3.402 823 47E+38F (有效位数为 6 ~ 7 位）
double 8 宇节 大约 ± 1.797 693 134 862 315 70E+308 (有效位数为 15 位>
面两个数值进行二元操作时（例如 n + f，n 是整数， f 是浮点数，)数据类型转换关系如下（总的来说是字节少的向多的数据类型转换）int 类型的值将会自动地转换为 double 类型。有时也需要将 double 转换成 int。 这有可能会丢失一些信息。在这种情况下，需要通过强制类型转换（ cast) 实现这个操作。强制类型转换的语法格式是在圆括号中给出想要转换的目标类型，后面紧跟待转换的变量名。例如：
double x = 9.997;
int nx = (int) x;//变量 nx 的值为 9。强制类型转换通过截断小数部分将浮点值转换为整型,将一个数值从一种类型强制转换为另一种类型， 而又超出了目标类型的表示范围，结果就会截断成一个完全不同的值。例如，（byte ) 300 的实际值为 44。(取低八位)。如果运算符得到一个值， 其类型与左侧操作数的类型不同， 就会发生强制类型转换。 例如，如果 X 是一个 int, 则以下语句：x += 3.5;是合法的， 将把 X 设置为（int)(x + 3.5。

位运算符： & (“and”) | (“or”) A (“XOr”) ~ (“not”) 这些运算符与 && 和丨丨运
算符很类似，不过 & 和丨运算符不采用“ 短路” 方式来求值， 也就是说，得到计算结果之前两个操作数都需要计算
另外，还有>>,<<和 运算符将位模式左移或右移,移位运算符的右操作数要完成模 32 的运算（除非左操作数是 long 类型， 在这种情况下需要对右操作數模 64 )。
例如， 1 «35 的值等同于 1 «3 或 8。
括号与算符级别：&& 的优先级比 || 的优先级高所以表达式a && b || c等价于
(a&&b)||c
+= 是右结合运算符， 所以表达式 a += b += c 等价于 a += (b += c)
也就是将 b += c 的结果（加上 c 之后的 b) 加到 a 上。

String 类的 substring 方法可以从一个较大的字符串提取出一个子串。例如：

String greeting = "Hello";
String s = greeting.substring(0, 3);

创建了一个由字符“ Hel” 组成的字符串。取[0,3)位置的元素
Java语言允许使用 + 号连接（拼接）两个字符串。

String expletive = "Expletive";
String PC13 = "deleted";
String message = expletive + PC13;

上述代码将“ Expletivedeleted” 赋给变量 message (注意， 单词之间没有空格， + 号按照给定的次序将两个字符串拼接起来)。
当将一个字符串与一个非字符串的值进行拼接时，后者被转换成字符串，任何一个 Java 对象都可以转换成字符串）。例如：

int age = 13;
String rating = "PC" + age;

rating 设置为“ PC13”。
如果需要把多个字符串放在一起， 用一个定界符分隔，可以使用静态 join 方法：

String all = String.join(" / ", "S", "M", "L", "XL"); 
// all is the string "S / H / L / XL"

检测字符串是否相等
可以使用 equals 方法检测两个字符串是否相等。对于表达式： s.equals(t)
如果字符串 s 与字符串 t 相等， 则返回 true ; 否则， 返回 false。需要注意，s与 t 可以是字符串变量， 也可以是字符串字面量。 例如， 下列表达式是合法的： “Hello”.equals(greeting)要想检测两个字符串是否相等，而不区分大小写， 可以使用 equalsIgnoreCase 方法。 “Hello”.equalsIgnoreCase(“hello”)
==运算符检测两个字串是否放置在同一个位置上。当然， 如果字符串放置在同一个位置上， 它们必然相等。但是完全有可能将内容相同的多个字符串的拷贝放置在不同的位置上。
String greeting = “Hello”;
调用 s.charAt(n) 将返回位置 n 的代码单元，n 介于 0 ~ s.length()-1 之间。例如：
char first = greeting.charAtO); // first is ‘H’
读取输入::打印输出到“ 标准输出流”（即控制台窗口）是一件非常容易的事情，只要
调用 System.out.println 即可。然而，读取“ 标准输人流” System.in 首先需要构造一个 Scanner 对象，并与“ 标准输人流” System.in 关联。Scanner in = new Scanner(System.in);
块作用域： 块（即复合语句）是指由一对大括号括起来的若干条简单的 Java 语句。块确定了变量的作用域。一个块可以嵌套在另一个块中。但是，不能在嵌套的两个块中声明同名的变量。例如，下面的代码就有错误，而无法通过编译：

public static void main(String口 args) {
   int n; 
  { 
    int k;
    int n; // Error can't redefine n in inner block
  } 
}

while循环：当条件为 true 时，while 循环执行一条语句（也可以是一个语句块）。一般格式为：while { condition ) statement 如果开始循环条件的值就为 false, 则 while 循环体一次也不执行。while 循环语句首先检测循环条件。因此， 循环体中的代码有可能不被执行t 如果希望循环体至少执行一次， 则应该将检测条件放在最后。 使用 do/while 循环语句可以实现这种操作方式。它的语法格式为：
do statement while { condition);
这种循环语句先执行语句 （通常是一个语句块，) 再检测循环条件；然后重复语句再检测循环条件， 以此类推:,for 循环语句只不过是 while 循环的一种简化形式
多重选择：switch语句将从与选项值相匹配的 case 标签处开始执行直到遇到 break 语句，或者执行到switch 语句的结束处为止。如果没有相匹配的 case 标签， 而有 default 子句， 就执行这个子句。如果在 case 分支语句的末尾没有 break 语句， 那么就会接着执行下一个 case 分支语句。
continue 语句与 break 语句一样， 它将中断正常的控制流程。continue语句将控制转移到最内层循环的首部。例如：

  Scanner in = new Scanner(System.in);
  while (sum < goal ) {
      System.out.print("Enter a number: ");
      int n = in.nextlnt；
      if (n < 0) continue;
      sum += n; // not executed if n < 0 
      }
  }

如果 n<0, 则 continue语句越过了当前循环体的剩余部分， 立刻跳到循环首部。
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.multiply(b.add(Biglnteger.valueOf(2))); // d = c * (b + 2)

如果使用大数值， 则相应的语句为：

lotteryOdds = lotteryOdds.multiply(BigInteger.valueOf(n - i + l)).divide(Biglnteger.valueOf(i));

结果：lotteryOdds = lotteryOdds * (n - i + 1) / i;
数组： 创建一个数字数组时， 所有元素都初始化为 0。boolean 数组的元素会初始化为 false 对象数组的元素则初始化为一个特殊值 null, 这表示这些元素（还）未存放任何对象。初学者对此可能有些不解。例如，
String[] names = new String[10];
会创建一个包含 10 个字符串的数组， 所有字符串都为 null。
for each 循环是增强的 for 循环的语句格式为：for (variable : collection) statement
定义一个变量用于暂存集合中的每一个元素， 并执行相应的语句（当然，也可以是语句块)。collection 这一集合表达式必须是一个数组或者是一个实现了 Iterable 接口的类对象，例如：

for (int element : a)
   System.out.println(element)

效果和下面代码是一样的：

 for (int i = 0; i < a.length; i++)
     System,out.println(a[i]);

for each 循环语句显得更加简洁、 更不易出错（不必为下标的起始值和终止值而操心。)
public String toString() 返回该对象的字符串表示。通常，ToString方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。 即利用 Arrays 类的 toString 方法。 调 用 Arrays.toString(a), 返回一个包含数组元素的字符串，这些元素被放置在括号内， 并用逗号分隔， 例如，“ [2,3,5,7，11，13]” 、 要想打印数组，可以调用
System.out.println(Arrays.toString(a));

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

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

如果希望将一个数组的所有值拷贝到一个新的数组中去，就要使用 Arrays 类的 copyOf方法：

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

第 2 个参数是新数组的长度。这个方法通常用来增加数组的大小：
luckyNumbers = Arrays.copyOf(luckyNumbers , 2 * luckyNumbers.length);

public class LotteryOdds {
    public static void main(String[] args)
{
    int[] luckyNumbers = {12,0,1,2,5};
    int[] copiedLuckyNumbers = Arrays.copyOf(luckyNumbers , 2*luckyNumbers .length);
    System.out.println("this is " +  Arrays.toString(copiedLuckyNumbers));  
 }
}

如果数组元素是数值型，那么多余的元素将被赋值为 0 ; 如果数组元素是布尔型，则将赋值为 false。相反，如果长度小于原始数组的长度，则只拷贝最前面的数据元素。
static type copyOfRange(type[]a , int start, int end)
返回与 a 类型相同的一个数组， 其长度为 length 或者 end-start， 数组元素为 a 的值
要想对数值型数组进行排序， 可以使用 Arrays 类中的 sort 方法(这个方法使用了优化的快速排序算法)：

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

• static boolean equals(type[]a, type[]b) //如果两个数组大小相同， 并且下标相同的元素都对应相等， 返回 true
• static void fill(type[]a , type v) //将数组的所有数据元素值设置为 V。
• static int binarySearch(type[]a , type v)
• static int binarySearch(type[]a, int start, int end, type v)
/* 二分查找 start 起始下标（包含这个值）end 终止下标（不包含这个值。) v 同 a 的数据元素类型相同的值。a 类型为 int、 long、 short、 char、 byte、 boolean 、 float 或 double 的有序数组。*/
采用二分搜索算法查找值 v。如果查找成功， 则返回相应的下标值； 否则， 返回一个负数值 r, -r-1 是为保持 a 有序 v 应插入的位置。
声明一个二维数组相当简单。例如：double[][] balances;
与一维数组一样， 在调用 new 对多维数组进行初始化之前不能使用它。 在这里可以这样初始化：
balances = new double[NYEARS] [NRATES]:
for each 循环语句不能自动处理二维数组的每一个元素。它是按照行， 也就是一维数组处理的，要想访问二维教组 a 的所有元素， 需要使用两个嵌套的循环， 如下所示：

for (double[] row : a)  //把一行当成一个单位，n行就是一个长度为n的一维数组
   for (double value : row)   //把这个单位恢复成一维数组 进行处理，
        do something with value

balances[i][j] 引用这个数组的第 j 项。由于可以单独地存取数组的某一行， 所以可以让两行交换。
doubleQ temp = balances[i]:
balances[i] = balances[i + 1];
balances[i + 1] = temp; //相当于交换这两行
创建一个不规则的数组， 首先需要分配一个具有所含行数的数组。

int[][] odds = new int[NMAX + 1] [] ;//接下来， 分配这些行。
for (int n = 0; n <= NMAX ; n++)
      odds [n] = new int[n + 1];
for (int n = 0; n < odds.length; n++)
    for (int k = 0; k < odds [n] .length; k++) {
     // compute lotteryOdds
       odds [n] [k] = lotteryOdds; //赋值
       }
for (int[] row : odds) {
    for (int odd : row)
       System.out.printf("%4d", odd);//输出这个二维数组
}

当需要不规则的数组时， 只能单独地创建行数组。