JAVA核心技术，卷1_java核心技术卷一

JAVA 核心技术 第三章 java的基本程序设计结构

---

前言

---

一、注释

java注释有三种方式：

1. System.out.println("hello world !");// 输出语句
2. /*System.out.println("hello world !");*/
3. 自动的生成文档，/**开始 */结束

二、数据类型

一共有8种类型，4种整型，2中浮点型，1种字符类型，1种表示真值类型

1.整型

int：4字节
short: 2字节
long:8字节
byte: 1字节

2.浮点类型

float:4字节
double:8字节，double这种类型的数值精度是float类型的两倍。
float有一个后缀，比如3.14f，没有后缀或者后缀是D的为double型，例如，3.14D。

3.char类型

用于表示单个字符，例如’A’，而“A”表示的是一个包含字符A的字符串。

4.boolean类型

boolean有两个值：false和true。

三、变量

变量使用前需要声明，例如：

double salary;
int number;
boolean done;
1
2
3

变量初始化，在对变量声明以后，千万要用赋值语句对变量进行显示的初始化，例如：

int num;
num=12;
//另一种方式
int num=12;
1
2
3
4

常量：使用关键字final指示常量。final表示这个变量只能被赋值一次，一旦被赋值后，就不可以更改了，一般常量名使用大写，例如：

final double NUM=12;
1

如果希望某个常量可以在一个类中的多个方法中使用，通常将这些常量称为类常量。类常量的定义位于main函数的外部，因此，在同一个类中的其他方法中也可以使用这个常量，如果一个常量被声明为public，那么其他类的方法也可以使用这个类常量，例如：

public static final double NUM=12;
1

四、运算符

算术运算符+、-、*、/，整数求余操作也为取模，例如15%2=1，整数被0除会产生异常，而浮点数被0除会得到无穷大或者NAN结果。
自增运算符和自减运算符：n++、n–、++n、–n
关系运算符和boolean运算符：使用==检测是否相等，结果用true和false来表示，！=检测是否不相等，<、>、<=、>=，&&表示逻辑与，||表示逻辑或，！表示逻辑非，三元运算符：？：例如：x<y?x:y
位运算符：&（与）、｜（或）、^（异或）、～（非）用来屏蔽整数中各个位。>>将二进制右移，<<将二进制左移，>>>用0填充高位，没有<<<。
数学函数与常量：Math类中，计算一个数值的平方，使用sqrt方法。幂运算，使用pow方法。

五、数值类型之间的转换

1.类型转换

无信息丢失的转换：byte->short->int->long char->int->long byte->short->int->double. float->double
有信息丢失的转换：int->float long->double long->float
当使用一个整数数值和一个浮点数数值进行二元操作时，先将两个操作数转换为同一类型，然后再进行计算。
如果两个操作数中有一个是double型，另一个操作数会转换为double，否则，如果其中一个操作数是float型，另一个操作数会被转换为float型，否则，如果一个操作数是long型，另一个操作数会转换为long型，否则，两个操作数都将被转换为int型。

2.强制类型转换

在1中，可以将int型自动转换为double，但是有时也需要将double转换为int型，这种叫做强制类型转换。强制类型转换的格式为在圆括号中给出要转换的目标类型，在后面紧跟转换的变量。例如：
double x=9.99;
int nx=(int)x;
输出的nx值为9，可以看出强制类型转换通过截断小数部分将浮点值转换为整型。如果想要对浮点数进行舍入操作，那么需要使用Math.round()。例如：
double x=9.9;
int nx=(int) Math.round(x);

3.括号与运算符级别

如果不给出圆括号，优先级为：[].()方法调用，！～++ – + - （）（从右到左），*/%，±，<< >> >>>, < <= > >= instanceof,== !=,&,^,|,&& ,||,?:,= += -= *= /= %= &= |= ^= <<= >>= >>>=（从右到左）。
不同级别按照以上优先级进行计算，同一个级别的运算符按照从左到右的顺序进行计算，其中，标出从右到左的除外。

4.枚举类型

枚举类型包括有限个命名的值，例如：
enum size {SMALL,LARGE,MEDIUM};
声明枚举类型的变量：
Size s=Size .MEDIUM；
Size类型的变量只能存储这个类型声明中给定的某个枚举值，或者null值。

六、字符串

1.字串

String 类的substring可以从一个较大的字符串中提取出字串，其优点是可以容易计算出字串的长度。例如：

String greeting="hello";
String s=greeting.substring(0,3);
1
2

下标从0开始，到下标为2结束的字串即：hel，字串长度为3-0=3;

2.拼接

使用+来拼接两个字符串，如果一个字符串和一个非字符串进行拼接，java自动将非字符串转换为字符串。

3.不可变字符串

不能修改字符串中的字符，string类对象称为不可变字符串。如果想改变可以通过以下方式，例如，将greeting=“hello”改为“help！”，原理为修改了字符串变量greeting ,让它引用另一个字符串。

String greeting="hello";
greeting=greeting.substring(0,3)+"p!";
1
2

4.检测字符串是否相等

使用equals方法检测两个字符串是否相等，例如：

s.equals(t);
1

一定不能使用运算符来比较两个字符串是否相等，因为这个运算符只能够确定两个字符串是否放置在同一个位置上，如果两个字符串放置在同一个位置上，肯定是相等的，但是也存在放置在不同位置上相等的字符串。

5 .空串和null串

空串是长度为0的字符串，例如“”，用以下方式来检查：

if(str.length()==0);
if(str.equals(""));
1
2

null串表示目前没有任何对象与该变量关联

if(str==null);
1

检查一个字符串既不是null也不是空串

if(str!=null && str.length()!=0);
1

5.构建字符串

如果需要用许多小段的字符串构建一个字符串，按照以下步骤进行：

StringBuilder builder=new StringBuilder();//首先，构建一个空的字符串构造器
builder.append(ch);
bulider.append(str);//一个一个添加
//调用toString方法，得到新的string对象。
String completedstring=bulider.toString();
1
2
3
4
5

七、输入输出

1.输入

//添加包
import java.util.*;
//第一步
String in=new Scanner(System.in);
//输入一行
String name=in.nextLine();
//读取一个单词
String firtname=in.next();
//读取一个整数
int age=in.nextInt();
//读取一个浮点数
double num=in.nextDouble();
1
2
3
4
5
6
7
8
9
10
11
12

2.输出

System.out.printf("%8.2f",x);
//可以使用多个参数
System.out.printf("hello,%s.next year,you'll be %d“,name,age);
//可以使用静态的String.format()创建一个格式化的字符串，而不打印输出
String message=String.format("hello,%s.next year,you'll be%d",name,age);
//打印当前日期和时间
System.out.printf("%1$s %2$tB %2$te,%2$tY","Due date:",new Date());

1
2
3
4
5
6
7
8

3.文件输入输出
3.1文件输入

//文件读取
Scanner in=new Scanner(Path.get("myfile.txt"));
//写入文件
PrintWriter out=new PrintWriter("myfile.txt");
1
2
3
4

3.2输出和普通的用法一样

八、大数值

在基本的整数和浮点数精度不能够满足需求的情况下，可以使用java.math包里面的类：BigInteger和BigDecimal，这两个类可以处理包含任意长度数字序列的数值，第一个类实现了任意精度的整数运算，第二个类实现了任意精度的浮点数运算，使用静态的valueOf方法可以将普通的数值转换为大数值。

BigInteger a=BigInteger.valueOf(100);
1

不能使用算术运算符来计算大数值，使用类中的add和multiply方法。

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

1
2
3

九、数组

数组是用来存储同一类型值的集合，通过一个整型下标可以访问数组中的每一个值。在声明数组变量时，需要指出数组类型和数组变量的名称，并需要初始化例如：

int[] a=new int[100]; //创建可以存储100个整数的数组
int[] a=new int[n];//也可以创建长度为n的数组
1
2

通过以上方式创建一个数组的时候，所有元素初始化为0，对象元素的数组则初始化为一个特殊值null,表示这些元素还没有放置任何对象。

String[] names=new String[100];//创建一个包含10个字符串的数组，数组初始化值为null.
1

想要获取数组中的元素个数，可以使用array.length例如：

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

1.for each 循环
主要用来依次处理数组中的每个元素而不必为指定下标而分心。例如：

for(int element:a)
System.out.println(element);//打印a数组中的每一个元素，一个元素占一行
1
2

2数组初始化以及匿名数组
java提供了一种创建数组对象并同时赋予初始值的简化书写形式，例如：

int[] samllPrimes={1,2,4,5,7,9};
new int[] {1,2,6,5,16,27,19};//可以初始化一个匿名的数组
1
2

初始化一个匿名数组可以在不创建新变量的情况下重新初始化一个数组，例如：

samllPrimes=new int[] {1,2,6,5,16,27,19};
1

3.数组拷贝
将一个数组变量拷贝给另一个数组变量，这时两个变量引用同一个数组，例如：

int[] luckyNumbers=samllPrimes;
luckyNumbers[5]=90;
1
2

将一个数组的所有值拷贝到一个新数组中，使用如下方式：

int[] copiedluckyNumbers=Arrays.copyOf(luckyNumbers,luckyNumbers.length);//第二个参数是新数组的长度
luckyNumbers=Arrays.copyOf(luckyNumbers,2*luckyNumbers.length);//一般用来增加数组的大小，如果数组元素是数值型，多余元素赋值为0，元素是布尔型，赋值为false,相反，如果长度小于原始数组的长度，则拷贝前面的元素。
1
2

4.数组排序
要想对数值型数组进行排序，可以使用Arrays类中的sort方法，例如：

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

5.多维数值
使用多个下标访问数组元素，适用于表格或更加复杂的排列形式，例如，声明一个二维数组，例如：

double[][] balances;
balances=new double[M][N];//初始化
int[][] magicSquare={
	{16,3,2,13},
	{5,10,11,8},
	{9,6,7,12},
	{4,15,14,1}
};//另外一种初始化方式
1
2
3
4
5
6
7
8

6 不规则数组

package java01;

public class lotterArray {
	public static void main(String[] args) {
		final int Xmax=10;
		int[][] odds=new int[Xmax+1][];
		for(int n=0;n<=Xmax;n++) {
			odds[n]=new int[n+1];
		}
		for(int n=0;n<odds.length;n++) {
			for(int k=0;k<odds[n].length;k++) {
				int lotteyOdds=1;
				for(int i=1;i<=k;i++) {
					lotteyOdds=lotteyOdds*(n-i+1)/i;
					odds[n][k]=lotteyOdds;
				}
			}
		}
		for(int row[]:odds) {
			for(int odd:row) {
				System.out.printf("%4d",odd);
			}
			System.out.println();
		}
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

输出：

`