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

Java 的基本程序设计结构

▲ 一个简单的 java 应用程序 　　 ▲ 字符串
▲ 注释　　　　　　　　　　　　▲ 输入输出
▲ 数据类型　　　　　　　　　　▲ 控制流
▲ 变量　　　　　　　　　　　　▲ 大数值
▲ 运算符　　　　　　　　　　　▲ 数组

---

1.一个简单的 Java 应用程序

public class FirstSample 
{  //作用域 修饰词 类型 类名\变量名\方法名
    public static void main(String[] args) 
    { //PSVM, main的必备缩写
        System.out.println("We will not use 'Hello, World!"); 
    } 
}

1. Java 使用的通用语法是
   object.method(parameters)
2. Java 中定义类名的规则很宽松。名字必须以字母开头。
3. 驼峰规则:类名是以大写字母开头的名词，变量名，方法是小写字母开头；如果名字由多个单词组成，每个单词的第一个字母都应该大写。

Main函数：

1. 严格意义上来说main函数并不是类的成员函数，是Java程序的总入口
2. main 方法必须声明为 public，Java 中的 main 方法必须是静态的。（PSVM）
3. 一个类中只有一个main函数 或 没有

1.1 XXX.Java文件

• 一个Java文件只能有一个public class，public class名字与文件名字相同
• 一个Java文件可以有多个class
• 不提倡在一个Java文件中放多个class（内部类除外）

---

2.注 释

//：单行注释
/* */：多行注释
/** */：文档注释，可以自动生成文档

---

3.数据类型

在 Java 中,一共有 8 种基本类型， 其中有 4 种整型、2 种浮点类型、1 种用于表示Unicode编码的字符单元的字符类型 char和 1 种用于表示真值的 boolean类型

3.1 Java整形：

• 都是有符号类型
• long的定义末尾要+ L，float + f，double + d

3.2 浮点类型：

三个特殊的浮点数值：

• 无穷大：Double_POSITIVE_INFINITY
• 无穷小：Double.NEGATIVEJNFINITY
• NaN（不是一个数）：Double.NaN
  例如，一正整数除以 0 的结果为正无穷大。计算 0/0 或者负数的平方根结果为 NaN。

3.3 char型：

Java中的字符编码是利用Unicode字符，其中有的用一个字符描述，有的用两个字符描述。
在 Java中，char 类型描述了 UTF-16 编码中的一个代码单元。

• string不是基本数据类型，是一个类

3.4 boolean类型：

boolean (布尔）类型有两个值：false 和 true, 用来判定逻辑条件。

• 整型值和布尔值之间不能进行相互转换。

3.5 大数值:

Biglnteger 和 BigDecimaL 类: 这两个类可以处理包含任意长度数字序列的数值。

• 不能使用算术运算符而是使用成员方法

Biglnteger c = a.add(b); /* c = a + b */
Biglnteger d = c.nultipiy(b.add(Biglnteger.valueOf(2))); /* d = c * (b + 2)*/

---

4. 变量

4.1 变量名：

• 驼峰规则
• 对大小写敏感

4.2 声明与定义：

• 不要使用未初始化的变量
• 在 Java 中，不区分变量的声明与定义。

4.3 常量：

final double CM_PER_INCH = 2.54;

• final指示常量（相当于Cpp中的const）
• 习惯上, 常量名使用全大写。

4.4 枚举类型:enum

enum Size {SMALL, MEDIUM, LARGE, EXTRA.LARCE};
Size s = Size.MEDIUM;

• Size类型的变量只能存储这个类型声明中给定的某个枚举值，或者 null 值

---

5. 运算符

算术运算符： +、-、 *、/
关系运算符：&&，||，！
（&& 和丨 |运算符是按照“ 短路” 方 式来求值的）
位运算符：& (and) ，| (or) , ^ (xor), ~(not)
>> 和 <<运算符将位模式左移或右移
>>> 运算符会用 0 填充高位，这与>> 不同，它会用符号位填充高位
数学函数：Math类

5.1 数值类型转换：n+f

先要将两个操作数转换为同一种类型，然后再进行计算。会优先像高精度转换

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

5.2 强制类型转换

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

• 强制类型转换通过截断小数部分将浮点值转换为整型

---

6. 字符串

String：从概念上讲，Java 字符串就是 Unicode 字符序列，标准Java类库中提供了一个预定义类叫做 String

String str="i" //分配到常量池中
String str=new String(“i”)//分配到堆内存中

public class StringNewTest {
	public static void main(String[] args) {
		String s0 = "abcdef";
		String s1 = "abc";
		String s2 = "abc";
		String s3 = new String("abc");
		String s4 = new String("abc");
		System.out.println(s1 == s2); //true 常量池
		System.out.println(s1 == s3); //false 一个栈内存，一个堆内存
		System.out.println(s3 == s4); //false 两个都是堆内存
		System.out.println("=========================");
		
		String s5 = s1 + "def";    //涉及到变量，故编译器不优化
		String s6 = "abc" + "def"; //都是常量 编译器会自动优化成abcdef
		String s7 = "abc" + new String ("def");//涉及到new对象，编译器不优化
		System.out.println(s5 == s6); //false
		System.out.println(s5 == s7); //false
		System.out.println(s6 == s7); //false
		System.out.println(s0 == s6); //true 
		System.out.println("=========================");

		
		String s8 = s3 + "def";//涉及到new对象，编译器不优化
		String s9 = s4 + "def";//涉及到new对象，编译器不优化
		String s10 = s3 + new String("def");//涉及到new对象，编译器不优化
		System.out.println(s8 == s9); //false
		System.out.println(s8 == s10); //false
		System.out.println(s9 == s10); //false
	}
}

库函数：API文档

• String 声明的是不可变的对象，每次操作都会生成新的 String 对象，然后将指针指向新的 String 对象
• 允许使用 + 号连接（拼接）两个字符串，当将一个字符串与一个非字符串的值进行拼接时，后者被转换成字符串
• String类不能在原字符串上做修改，需要重新定义赋值
• s.equals(t)检验是否相等，“==”是判断地址是否相等

StringBuffer（线程安全）、StringBuilder（线程不安全）
：可以在原有对象的基础上进行操作

5.1 空串与Null串

空串：S = “”，长度为0的字符串
Null串：S = null

5.2 码点与码元

s.charAt(n) ：将返回位置 n 的代码单元

• 若一个字符需要两个代码单元则会出问题
• 使用 codePoints 方法

5.3 不可变的对象

：一旦创建，这个对象（状态/值）不能被更改了，其内在的成员变量的值就不能修改了。

典型的不可变对象：

1. 八个基本型别的包装类的对象
2. String，BigInteger和BigDecimal等的对象

如何创建不可变对象：

1. immutable对象是不可改变，有改变，请clone/new一个对象进行修改
2. 所有的属性都是final和private的
3. 不提供setter方法
4. 类是final的，或者所有的方法都是final
5. 类中包含mutable对象，那么返回拷贝需要深度clone

5.4 可变对象

• 普通对象

---

6. 输入输出

6.1 控制台

输入：需要构造一个 Scanner 对象，并与“ 标准输人流” System.in 关联

Scanner in = new Scanner(System.in);

输出：

 System.out.println()

1. String nextLine( ) 读取输入的下一行内容。
2. String next( ) 读取输入的下一个单词（以空格作为分隔符)。
3. int nextlnt( )
   double nextDouble( ) 读取并转换下一个表示整数或浮点数的字符序列。

• Java SE 沿用了 C 语言库函数中的 printf方法,能够进行格式化输出

System.out.printf("Hello, %s. Next year, you'll be SSd", name, age); 

6.2 文件

输入：
要想对文件进行读取，就需要一个用 File 对象构造一个 Scanner 对象

Scanner in = new Scanner(Paths.get("niyflle.txt"), "UTF-8"); //文件路径，不能是字符串

• 如果文件名中包含反斜杠符号，就要记住在每个反斜杠之前再加一个额外的反斜杠： “c:\\mydirectory\\myfile.txt”

输出：
要想写入文件，就需要构造一个 PrintWriter对象。在构造器中，只需要提供文件名。

PrintWriter out = new PrintlulriterC'myfile.txt", "UTF-8");

• 如果文件不存在，创建该文件。

---

7. 控制流程

7.1 作用域：

块确定了变量的作用域，与Cpp不同的是不能在嵌套的两个块中声明同名的变量。

7.2 循环：

for(),while(),do…while()。…

---

8. 数组

8.1 声明与定义:

int[] a;/*声明*/
int[ ] a = new int[100];/*定义*/

• 数组长度定义时不要求是常量

初始化：

1. 数字数组初始化时：所有元素都为 0。
2. boolean 数组初始化：所有元素都为 false。
3. 字符串数组初试化： 所有字符串都为null。

• 创建了数组，就不能再改变它的大小。若在运算中改变则使用动态数组-- 数组列表（array list）

8.2 初始化方式

中括号{}

int[] smallPrimes = { 2, 3, 5, 7, 11, 13 };
smallPrimes = new int[] { 17, 19, 23, 29, 31, 37};

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

8.3 数组拷贝

地址拷贝：两个变量将引用同 一个数组

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

数值拷贝： Arrays 类的 copyOf方法

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

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

8.4 多维数组

多维数组：即数组元素也是数组
不规则数组：数组的每一行有不同的长度。

1 
1 1 
1 2 1 
1 3 3 1 

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