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

2019-11-15 00:36:50

字体：大中小

来源：转载

供稿：网友

第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 staticfinal 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.*;

public class InputTest {

public static void main(String[] args) {
Scanner in = new Scanner(System.in); //构造一个Scanner对象，并于标准输入流关联
System.out.print("What's your name?");
String name = in.nextLine(); //输入一行
System.out.print("How old are you?");
int age = in.nextInt(); //输入一个整型数值
System.out.println("Hello, " + name + ". Next year, you'll be" + (age + 1));
}

}

格式化输出
文件输入与输出

package corejava;import java.io.FileNotFoundException;import java.io.IOException;import java.io.PrintWriter;import java.nio.file.Paths;import java.util.*;public class FileInOutput {public static void main(String[] args) throws FileNotFoundException,IOException {

//PrintWriter out = new PrintWriter("F://Java//corejava//book.txt"); 绝对路径写法
PrintWriter out = new PrintWriter("book.txt"); //相对路径写法
out.println("code complete");
out.println("Spring in action");
out.close();
//Scanner in = new Scanner(Paths.get("F://Java//corejava//book.txt"));
Scanner in = new Scanner(Paths.get("book.txt"));
String book1 = in.nextLine();
String book2 = in.nextLine();
in.close();
System.out.println("book1:" + book1);
System.out.println("book2:" + book2);
System.out.println(System.getProperty("user.dir")); //Java虚拟机启动路径为F:/Java/corejava/ 因此上面的绝对路径和相对路径写法是等价的。
}

}

3.8 控制流程

块（block）作用域

1)块（即复合语句），是指由以对花括号括起来的若干简单的Java语句。2)块确定了变量的作用域3)一个块可以嵌套在另一个块中，但是不能在两个嵌套的块中声明同名的变量。

条件语句

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)

import java.math.BigInteger;

public class BigIntegerTest {
public static void main(String[] args) {
BigInteger a = BigInteger.valueOf(5);
BigInteger b = BigInteger.valueOf(6);
BigInteger c = a.add(b);
BigInteger d = a.multiply(b);
System.out.println(c);
System.out.println(d);
}
}

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;

public class CommandLineArgs {

public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(args.length);
for(String s:args){
System.out.println(s);
}

}}

java CommandLineArgs -jrr tmac -lbj

数组排序

package corejava;

import java.util.Arrays;public class SortTest {

public static void main(String[] args) {
// TODO Auto-generated method stub
int[] a = {1,3,2,5,9,7};
System.out.println(Arrays.toString(a));
Arrays.sort(a); //采用优化的快速排序法，对数组进行排序
System.out.println(Arrays.toString(a));
}

}

数组搜索

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[n] = new int[n+1];

上一篇：JavaWeb学习总结第五篇--认识Cookie机制

下一篇：Struts2框架实现简单的用户登入