第3章 Java的基本程序设计结构

3.1 一个简单的Java应用程序
public class FirstSample{
public static void main(String[] args){
System.out.println("We will not use 'Hello World!'");
}
}

Java对大小写敏感

public关键字称为访问修饰符（access modifier），用于控制程序的其他部分对这段代码的访问级别

class关键字 - 类是构建所有Java应用程序的构建块，Java应用程序中的全部内容都必须放置在类中。

类名命名规范：

1)以大写字母开头，后面可以跟字母和数字的任意组合，但不能使用Java保留字作为类名
2)骆驼命名法：如果类名中有多个单词组成，每个单词的第一个字母都应该大写
3)源代码文件名必须与公共类的名字相同，并用.java作为扩展名。对于上面源代码，文件命名为FirstSample.

javac FirstSample.java

编译源代码就会得到一个包含这个类字节码的文件。编译器将字节码文件自动命名为FirstSample.class，并与源文件存储在同一目录下。

java FirstSample

运行程序时，Java虚拟机将从指定类中的main方法开始执行，因此，在类的源代码中必须包含main方法。main方法必须声明为public

每条语句必须由分号结束

可以将一条语句写在多行上，回车不是语句结束的标志。

3.2 注释

三种注释方式

1)最常用的方式// ----单行注释
2)/* */ -----多行注释，注释内容可以写在多行，此注释方式不能嵌套
3)/**
*This is the first sample program in Core Java
*@version 1.01 1997-03-22
*@author Gary Cornell
*/
public class FirstSample{
public static void main(String[] args){
System.out.println("We will not use 'Hello World!'");
}
}

这种方式的注释可以用来自动生成文档

3.3 数据类型

Java是一种强类型语言，即必须为每一个变量声明一种数据类型。

8种基本类型（primitive type）

1)4种整型 byte short int long
2)2种浮点型 float double
3)1种字符类型char ---用于表示Unicode编码的字符单元的字符类型char
4)1种用于表示真值的boolean类型

整型 ----用于表示没有小数部分的数值，允许是负数



1)int类型最常用
2)表示地球上的人数，就要用long型了
3)byte和short类型主要用于特定场合
4)Java中整型的范围与运行Java代码的机器无关。这就解决了软件在不同平台或同平台不同操作系统间移植的问题。由于Java程序必须保证在所有机器上都能够得到相同的运行结果，所以每种数据类型的取值范围必须固定。
5)长整型数值有一个后缀L（如4000000000L）
6)十六进制数有一个前缀0x（如0xCAFE）
7)八进制数有一个前缀0（如010）
8)二进制数有一个前缀（如0b1001，就是9） 【Java7开始】
9)可以为数字字面量加下划线,，（如1_000_000或0b1111_0100_0010_0000 表示1百万），只是为了更易读，Java编译器会去除这些下划线。
10)Java没有任何无符号类型（unsighed）

浮点类型 -----用于表示有小数部分的数值



1)double表示这种类型的数据精度是float类型的两倍，绝大部分应用程序都采用double类型
2)只有很少情况下，使用使用float类型
3)float类型的数值有一个后缀F(如3.14F)，没有后缀F的浮点数值（如3.14）默认为double型
4)三个特殊的浮点数值 ---- 用于表示溢出和出错的情况
a)正无穷大 ---- 对应常量Double.POSITIVE_INFINITY
一个正整数除以0的结果为正无穷大
b)负无穷大 ---- 对应常量Double.NEGATIVE_INFINITY
c)NaN（不是一个数字） ----- 对应常量Double.NaN
0/0或者负数的平方根结果为NaN
5)所有非数值的值都是不相同的，可以使用Double.isNaN方法来检验某个值是否为NaN
if(Double.isNaN(x))
而不能使用如下方式检验
if(x==Double.NaN)
6)如果需要在数值计算中不含任何舍入误差，就用该使用BigDecimal类

char类型 ----用于表示单个字符。通常用来表示字符常量。

1)特殊字符的转义序列符



2)强烈建议不要在程序中使用char类型，最好将需要处理的字符串用抽象数据类型表示。

boolean类型

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

3.4 变量

每一个变量属于一种类型（type），声明变量时，变量所属的类型位于变量名之前。声明是完整语句，必须由分号结尾。变量名必须以字母开头的由字母、下划线和数字组成。

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

也可以在一行中声明多个同类型的变量，但不提倡这种做法，可读性差。

int i,j;

变量名是大小写敏感的。hireDay和hireday是两个完全不同的变量。

变量名不能使用java保留字。

变量初始化

1)声明一个变量后，必须使用赋值语句对一个变量进行显示的初始化，千万不能使用未经初始化的变量。
int vacationDays; //声明变量
System.out.println(vacationDays); //未被初始化就使用了，出错 variable not initialized
2)对已经声明过的变量进行赋值
int vacationDays;
vacationDays = 12;
3)也可以将变量的声明和初始化放在同一行
int vacationDays = 12;
4)Java中可以将变量声明放在代码中的任何位置（有些语言必须将所有变量声明放在最前面的位置）
5)在Java中，变量的声明尽可能的靠近变量第一次使用的地方，这是一种良好的编程风格。

常量

1)函数作用域内的常量
利用关键字final定义。表示这个变量只能被赋值一次，一旦被赋值之后，就不能再被改变了。习惯上常量名使用全大写。
public class Constants{
public static void main(String[] args){
final double CM_PER_INCH = 2.54; //位于main方法内部
double paperWidth = 8.5;
double paperHeight = 11;
System.out.println("Pager size in centimeters:" + paperWidth * CM_PER_INCH + " by " + paperHeight * CM_PER_INCH);
}
}
2)类常量
Java中，经常希望某个常量能在一个类中的多个方法中使用，或者提供给其他类使用，通常将这些常量称为类常量。可以使用关键字static final设置一个类常量。

public class Constants2{
public static final double CM_PER_INCH = 2.54; //位于main方法外部（类的成员变量），因此可供类内部的所有方法使用，而且由于定义为public，因此其他类的方法也能使用这个常量，使用方法为Constants2.CM_PER_INCH
public static void main(String[] args){
double paperWidth = 8.5;
double paperHeight = 11;
System.out.println("Pager size in centimeters:" + paperWidth * CM_PER_INCH + " by " + paperHeight * CM_PER_INCH);
}
}

3.5 运算符

算术运算符

1) 加 +
2) 减 -
3) 乘 *
4) 除 /
a)当参与/运算的两个操作数都是整数时，表示整数除法；
15/2等于7
整数被0整除会产生一个异常
b)否则，表示浮点除法。
15.0/2等于7.5
浮点数被0除会得到无穷大或NaN结果。
5)求余（取模） %

15%2等于1
6)可以在赋值语句中采用简化格式书写二元算术运算符
x += 4;
等价于：
x = x+4;
类似还有：*=或%=

自增运算符与自减运算符

int m = 7;
int n = 7;
int a = 2 * ++m; //a为16，m为8 前缀方式，先自增，后使用
int b = 2 * n++; //b为14, n为8 后缀方式，先使用，后自增

关系运算符和boolean运算符

1)关系运算符
a) == 检测是否相等
3 == 7 的值为false
b) != 检测是否不想等
3 != 7 的值为true
c) 经常使用的关系运算符还有：
< 小于
> 大于
<= 小于等于
>= 大于等于
2)boolean逻辑运算符
a) && 表示逻辑“与”
按照短路方式求值，如果第一个操作数能够确定表达式的值，第二个操作数就不必计算了。
expression1 && expression2
若expression1值为false，则整个逻辑表达式的值为false，因此expression2就不计算了，即expression2有异常也不会报错。
b) || 表示逻辑“或”
按照短路方式求值，如果第一个操作数能够确定表达式的值，第二个操作数就不必计算了。
expression1 || expression2
若expression1值为true，则整个逻辑表达式的值为true，因此expression2就不计算了，即expression2有异常也不会报错。
c) ！ 表示逻辑“非”
3) ? 三元操作符
condition ? expression1 : expression2
当条件condition为真时，计算第一个表达式，并将表达式值作为整个三元表达式的值。
当条件condition为假时，计算第二个表达式，并将表达式值作为整个三元表达式的值。

位运算符

1) & 与
2) | 或
3) ^ 异或
4) ~ 非
5) >> 右移位
6) << 左移位
7) >>> 右移位

public class BitOperator {

public static void main(String[] args) {
//转换为十进制输出，结果为8
int i = 0b1000;
System.out.println(i);

//取非,结果为-9，不明白为什么？
int j = ~i;
System.out.println(j);

//取余，结果为8
int x = i & 0b11000;
System.out.println(x);

//取或，结果为9
int y = i | 0b0001;
System.out.println(y);

//取异或，结果为5
int z = i ^ 0b1101;
System.out.println(z);

//向左移两位，结果为32
int a = i << 2;
System.out.println(a);

//向右移两位，结果为2
int b = i >> 2;
System.out.println(b);

//向右移两位，结果为2.和上面的区别还是不清楚。>>>运算符将用0填充高位；>>运算符用符号位填充高位
int c = i >>> 2;
System.out.println(c);

//当int类型时，需要对>>右侧的操作数求摸32预算后，再移位.结果为2
int d = i >> 34;
System.out.println(d);

//当int类型时，需要对>>右侧的操作数求摸64预算后，再移位,结果为2
long e = i >> 66;
System.out.println(e);
}

数学函数与常量

1) Math(java.lang.Math)类中，包含了各种各样的数学函数
a) Math.sqrt(x) //计算一个数值的平方根
b) Math.power(x,a) //幂运算 求x的a次幂
c) 常用三角函数
Math.sin
Math.cos
Math.tan
Math.atan
Math.atan2
d) 指数函数以及他的反函数——自然对数以及以10为底的对数
Math.exp
Math.log
Math.log10
e) Math.round(x) //舍入运算符，返回long类型的数值
2)Java还提供两个表示π和e常量的近似值
Math.PI
Math.E

数值类型之间的转换



1)上图6个实心箭头，表示无信息丢失的转换。有三个虚箭头，表示可能有精度损失的转换。
当两个数值进行二元操作时，先要将两个操作数转换为同一种类型，然后再进行计算。
如果两个操作数中有一个是double类型，另一个操作数就会转换为double类型。
否则，如果其中一个操作数是float类型，另一个操作数将会转换为float类型。
否则，如果其中一个操作数是long类型，另一个操作数将会转换为long类型。
否则，两个操作数都会被转换成int类型。

强制类型转换

1)强制类型转换（cast）的语法格式是在圆括号里给出想要转换的目标类型，后面紧跟待转换的变量名。

括号 与运算符级别



枚举类型

1)有时候，变量的取值只在一个有限的集合内，可以定义枚举类型。枚举类型包含有限个命名的值。
enum Size {SMALL, MEDIUM, LARGE, EXTRA_LARGE};
Size s = Size.MEDIUM;
Size类型的变量只能存储这个类型声明中给定的某个枚举值，或者null值。null表示这个变量没有设置任何值。

3.6 字符串

Java字符串就是Unicode字符序列。Java没有内置的字符串类型，而是在标准的Java类库中提供一个预定义类，很自然的叫做String。每个用双引号括起来的字符串都是String类的一个实例。

String e=""; //an empty string
String greeting="Hello";

子串

String类的substring方法，从一个较大的字符串中提取出一个字串。
String greeting = "Hello";
String s = greeting.substring(0,3); //第二个参数是不想赋值的第一个位置，从0开始计数，指导3为止，但不包含3.
创建一个由“Hel”组成的字符串
substring的工作方式有一个优点：容易计算字串的长度，字符串s.substring(a,b)的长度为b-a

拼接

Java语言允许使用+号连接（拼接）两个字符串
当将一个字符串与一个非字符串拼接时，后者被转换成字符串，任何一个Java对象都可以转换为字符串

不可变字符串

1)String类没有提供用于修改字符串的方法。
greeting = greeting.substring(0,3) + "p!";
2)由于不能修改Java字符串中的字符，所以在Java文档中将String类对象称为不可变字符串。当然可以修改字符串变量 greeting，让他引用另外一个字符串。
3)不可变字符串有一个优点，编译器可以让字符串共享。字符串放在公共的存储池中，字符串变量指向存储池中相应的位置，如果复制一个字符串变量，原始字符串变量和复制的字符串变量共享相同的字符。Java设计者认为，共享的效率远远胜过提取、拼接字符串带来的低效率。

检测字符串是否相等

1)可以使用equals方法检测两个字符串是否相等
s.equals(t)
相等返回true，不相等返回false。
s与t可以是字符串变量，也可以是字符串常量。
"Hello".equals(greeting);
检查两个字符串是否相等，而不区分大小写
"Hello".equalsIgnoreCase("hello");
2)一定不能使用==运算符检测两个字符串是否相等。这个预算符只能检查这两个字符串是否放在同一个位置上。当然如果字符串放置在同一个位置上必然相等，但是，完全有可能将内容相同的多个字符串拷贝放置在不同的位置上。
String greeting = "Hello";
if(greeting == "Hello") ...
也许返回true
if(greeting.substring(0,3) == "Hel")...
也许返回false
如果虚拟机始终将相同的字符串共享，就可以使用==运算符检测是否相等。但实际上只有字符串常量是共享的，而+或substring等操作的结果并不是共享的。

空串和Null串

1)空串""是长度为0的字符串。可以调用以下代码检查一个字符串是否为空。
if(str.length() == 0)
或
if(str.equals(""))
空串是一个Java对象，有自己的串长度（0）和内容（空）
2)String变量还可以存放一个特殊值，null
表示目前没有任何对象与该变量关联。
要检查一个字符串是否为null，要使用以下条件：
if(str == null)
要检查一个字符串即不是null也不为空
if(str != null && str.length() != 0)
如果在一个null值上调用方法，会出现错误。

代码点与代码单元

字符串API

阅读联机API文档

构建字符串

1)StringBuilder
由较短的字符串构建字符串，解决字符串连接方式低效率问题。
StringBuilder builder = new StringBuilder();
builder.append(ch); //追加单个字符
builder.append(str); //追加字符串
在需要构建字符串时，就调用toString()方法，得到一个String对象。
String completeString = builder.toString();
2)StringBuffer
是StringBuilder的前身，其效率稍低。但允许采用多线程执行添加或删除字符的操作。如果所有字符串在一个单线程中编辑（通常都是这样），则应该用StringBuilder替代。这两个类的API是相同的。

读取输入（标准输入流 System.in）

1)采用Scanner类进行收入

import java.util.*;














格式化输出

文件输入与输出





































3.8 控制流程

块（block）作用域



条件语句

if(condition) {
statement;
}

循环

1) while循环
while (condition) statement; //循环体中的内容，可能一次都不被执行
2)do..while循环
do statement while(condition); //循环体中的内容，至少被执行一次
3)for循环

多重选择：switch语句

1)case标签类型支持：char、byte、short或int或对应的包装器类（Character、Byte、Short和Integer）
2)枚举常量
enum Size{SMALL, MEDIUM, LARGE, EXTRA_LARGE};
Size sz = Size.LARGE;
switch(sz)
{
case SMALL: //no need to use Size.SMALL
....
break;
...
}
3)Java SE7开始，case标签还可以是字符串字面量
String input = ...;
switch(input.toLowerCase())
{
case "yes";
....
break;
.....
}

中断控制流程语句

1) break语句
用于退出switch语句、while语句、do..while语句、for语句
2)带标签的break语句，用于跳出多重嵌套的循环语句。只能跳出语句块，而不能跳入语句块。
......
read_data:
while(...)
{
....
for(...)
{
......
break read_data:
.......
}
}
//跳出标签后，从下面语句开始执行
................

3)continue语句
越过当前循环体的剩余部分，立刻跳到循环首部。计数器自增后，继续执行循环体。
4)带标签的continue语句
将跳到与标签匹配的循环首部。

3.9 大数值

java.Math包中的两个很有用的类：BigInteger和BigDecimal

这两个类实现了可以处理包含任意长度数字序列的数值

BigInteger a= BigInteger.valueOf(100); //使用静态的valueOf方法将普通的数值转换为大数值

不能使用普通的算术运算符 + - * /来处理大数值，而需要使用大数值类中的add和multipy方法。

BigInteger c = a.add(b); //c= a+b;
BigInteger d = c.multiply(b.add(BigInter.valueOf(2))); // d= c*(b + 2)















3.10 数组

数组是一种数据结构，用来存储同类型的值的集合。

通过一个整型小标可以访问数组中的每个值。a[i]表示整型数组中，第i个元素。

申明数据变量

int[] a; //只声明了变量a，并没有将a初始化为一个真正的数组。

初始化数组

int[] a = new int[100]; //这个数组的下标是0-99，若访问a[100]，或任何在0-99之外下标的元素，就会引发“array index out of bounds”异常而终止执行。

创建一个数字数组时，所有元素都初始为0，boolean数组的元素会初始化为false。对象数组的元素则初始化为null

String[] names = new String[10]; //此时，数组中的元素都为null
for(int i =0;i<10;i++){
names[i] = "";
}
//此时，数组中的元素都为""，空串。

一旦创建了数组，就不能改变它的大小，尽管可以改变数组中的每个元素的值。

如果经常需要在运行的过程中扩展数组的大小，则应该使用另一种数据结构：数组列表(array list)

for each循环

for(variable : collection){
statement;
}
//variable--定义一个变量用于暂存集合中的每一个元素
//collection--这一集合表达式必须是一个数组或者是一个实现了Iterable接口的类对象。如，ArrayList

在很多情况下，还是需要使用传统的for循环，例如，不希望遍历集合中的每个元素，或者在循环内部需要使用下标等。

打印数组中的所有值

Arrays类的toString方法:
Arrays.toString(a); //返回一个包含数组元素的字符串 [2,3,5,10]

数组初始化

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}

Java中，允许数组长度为0

new elementType[0]; //数组长度为0与null不同。

数组拷贝

1)Java中允许将一个数组变量拷贝给另一个数组变量。这时，两个变量将引用同一个数组。
int[] a = {1,2,3,4,5};
int[] b = a; //两个引用指向堆上的相同数组数组对象。
b[2] = 30; //此时a[2]的值也变成了30
2)将一个数组的值拷贝到新的数组中去（开辟新的空间保存，互不影响），则使用Arrays类的copyTo方法：
int[] b= Arrays.copyOf(a,a.length);
//第二个参数是新数组的长度，这个方法通常用来增加数组的大小。
int[] c =Arrays.copyOf(b,b.length*2);
如果数组元素的类型是数值型，那么多余的元素将被赋予0；如果数组元素是布尔型，则将赋值为false。相反，如果长度小于原始数组的长度，则只拷贝最前面的数据元素。

命令行参数

//main方法接受一个字符串数组，也就是命令行参数。
package corejava;











java CommandLineArgs -jrr tmac -lbj

数组排序

package corejava;












数组搜索

Arrays.binarySearch

Arrays.equals(type[] a,type[] b)

如果两个数组大小相同，并且下标相同的元素都对应相等，则返回true

多维数组

double[][] balance; //声明数组
balance = new double[2][3]; //初始化数组
//另一种初始化方式
int[][] magicSquare ={
{16,3,2,13},
{5,10,11,8},
{9,6,7,12},
{4,15,14,1}
}
一旦数组被初始化，就可以利用两个方括号访问每个元素，balances[i][j]

for each循环处理二维数组时，必须使用两个for each循环进行嵌套遍历
for(double[] row:a)
for(double value:row)
do something with value;

快速打印一个二维数组元素的列表
System.out.println(Arrays.deepToString(a));

不规则数组

1)Java实际上没有多维数组，只有一维数组，多维数组被解释为“数组的数组”
2)不规则数组：即数组的每一行有不同的长度
//首先需要分配一个具有所含行数的数组
int[][] odds = new int[NMAX + 1][];

for(int n=0; n < NMAX; n++)
odds
= new int[n+1];