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.
编译源代码就会得到一个包含这个类字节码的文件。编译器将字节码文件自动命名为FirstSample.class，并与源文件存储在同一目录下。
运行程序时，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类型，最好将需要处理的字符串用抽象数据类型表示。
有两个值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 后缀方式，先使用，后自增
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等操作的结果并不是共享的。
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是相同的。
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 控制流程
1)块（即复合语句），是指由以对花括号括起来的若干简单的Java语句。
2)块确定了变量的作用域
3)一个块可以嵌套在另一个块中，但是不能在两个嵌套的块中声明同名的变量。
if(condition) {
statement;
}
1) while循环
while (condition) statement; //循环体中的内容，可能一次都不被执行
2)do..while循环
do statement while(condition); //循环体中的内容，至少被执行一次
3)for循环
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}
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];
原标题：第3章 Java的基本程序设计结构
关键词：JAVA
我知道了 