学习Java核心技术 卷Ⅰ（一）_java核心技术一

一个简单的Java程序

public class FirstSample
{
	public static void main(String[] args)
	{
		System.out.println("We will not use 'Hello , World'");
	}
}
1
2
3
4
5
6
7

以上是一段最基础的代码，里面有一些需要注意的规则：
  1.Java区分大小写
  2.关键字 public
  3.关键字 public 称为 访问修饰符
  4.关键词 class 表明Java程序中的全部内容都包含在类中
  5.FirstSample 表示类的类名，它也有一些规则：
     类名必须以字母开头，后面可以跟字母和数字的任意组合
     无长度限制
     不可使用Java保留字(如：public、class等)
     类名的标准命名法为 大驼峰
     代码的文件名必须与公共类的类名相同
  6.Java中任何方法的代码都必须以 “{” 开始，用 “}” 结束
  7.暂时不考虑关键字 static void
  8.每一个Java应用都应该有一个 main 方法
  9.代码片段中每个语句必须用分号结束，回车不是语句的结束标志，因此如果需要，一条语句可以跨多行
  10. println 用来打印字符，此实例中 println 方法接收一个字符串参数，这个方法将这个字符串参数显示在控制台上

数据类型

整形

浮点类型

所有的浮点数计算都遵循 IEEE 754 规范。具体来说，有 3 个特殊的浮点数值表示溢出和出错情况：

• 正无穷大
• 负无穷大
• NaN (不是一个数)

例如，一个正整数除以 0 的结果为正无穷大。计算 0/0 或者负数的平方根结果为 NaN。

char 类型(还不是很理解)

boolean 类型

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

变量与常量

声明变量

double salary;
int vacationDays;
1
2

   结构： 如上所示，声明一个变量时，先指定变量的类型，然后是变量名。
   规则：
        1.每个声明都以分号结束。
        2.变量的标识符由字母、数字、货币符号以及“标点连接符”组成。第一个字符不能是数字。
        3.'+'和’©’之类的符号不能出现在变量中，空格也不行。字母区分大小写。
        4.变量名一般使用小驼峰表示。
        5.不能使用 Java 关键字作为变量名。

初始化变量

// 代码片段一：
int vacationDays;
System.out.println(vacationDays); // ERROR--variable not initialized

// 代码片段二：
int vacationDays;
vacationDays = 12;
// 或者
int vacationDays = 12;

// 代码片段三：
double salary = 65000.0;
System.out.println(salary );
int vacationDays = 12;  // OK to declare a variable here
1
2
3
4
5
6
7
8
9
10
11
12
13
14

     代码片段一： 声明变量之后必须用赋值语句显式地初始化变量，且不能使用未初始化的变量的值，否则会报错。

     代码片段二： 对变量进行赋值的格式。

     代码片段三： Java 中可以将声明放在代码的任何地方。

常量

在Java中，可以用关键字final指示常量：

public class Constants
{
	public static void main(String[] args)
	{
		// 使用final指示常量
		final double CM_PER_INCH = 2.54;
		double paperWidth = 8.5;
		double paperHeight = 11;
		System.out.println("Paper size in centimeters: "
			+ paperWidth * CM_PER_INCH + " by " + paperHeight * CM_PER_INCH);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

     关键字final表示这个变量只能被赋值一次。一旦赋值，就不能再更改了。习惯上，常量名使用全大写,并用下划线相连接。

     在 Java 中，可能经常需要创建一个常量以便在一个类的多个方法中使用，通常将这些常量称为类常量(classconstant)。可以使用关键字 static final 设置一个类常量。下面是使用类常量的一个例子：

public class Constants2
{
	// 使用static final设置类常量，可以在一个类的多个方法中使用
	public static final double CM_PER_INCH = 2.54;
	public static void main(String[] args)
	{
		double paperWidth = 8.5;
		double paperHeight = 11;
		System.out.println("Paper size in centimeters: "
			+ paperWidth * CM_PER_INCH + " by " + paperHeight * CM_PER_INCH);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

枚举类型

    枚举类型包括有限个命名值：

enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARGE };
// 声明枚举类型的变量：
Size s = Size.MEDIUM;
1
2
3

    Size 类型的变量只能存储这个类型声明中所列的某个值，或者特殊值 null，null 表示这个变量没有设置任何值。

运算符

算数运算符

+  -  *  /  %
1

数学函数与常量

    Math 类中包含各种数学函数给我们使用：

// 计算一个数的平方根
double x = 4;
double y = Math.sqrt(x);
System.out.println(y); // prints 2.0

// 幂运算
// 表示将 y 的值设置为 x 的 a 次幂。pow方法有两个double类型的参数，其返回结果也为double类型。
double y = Math.pow(x, a);

// 三角函数
Math.sin
Math.cos
Math.tan
Math.atan
Math.atan2

// 指数函数以及它的反函数--自然对数和以10为底的对数：
Math.exp
Math.log
Math.log10

// 表示 Π 和 e 常量最接近的近似值
Math.PI
Math.E
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

    为了使用 Math 方便，可以直接在源文件最上面添加以下代码即可：

import static java.lang.Math.*;
1

    使用：

System.out.println("The square root of \u03c0 is" + sqrt(PI));
1

数值类型之间的转换

    图中实线箭头表示无信息丢失的转换；虚线表示可能有精度损失的转换。

    当用一个二元运算符连接两个值时，先要将两个操作数转换(隐式转换)为同一种类型，然后进行计算。转换规则：

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

强制类型转换

    有时候需要逆箭头转换，如将 double 类型转换成 int 类型，在 Java 中允许进行这种强制转换，当然这样会可能会丢失一些信息。

// 强制类型转换格式：
double x = 9.997;
int nx = (int) x;

// 使用 Math.round 方法进行舍入浮点数来得到最接近的整数(大多数情况下，这种操作更有用)
// Math.round 方法返回的是 long 数据类型，因此需要强制转换城 int 类型才能赋值给 int 类型
double x = 9.997;
int nx = (int) Math.round(x);
1
2
3
4
5
6
7
8

    警告：如果试图将一个数从一种数据类型强制转换成另一种类型，而又超出了目标类型的表示范围，结果就会截断成一个完全不同的值。例如，(byte)300 实际上会得到 44。

赋值运算符

// 赋值
+=  -=  *=  /=  ...

// 书写格式
x += 4; 
// 等价于
x = x + 4;

// 可以将赋值语句赋值给一个特定的值：
int x = 1;
int y = x += 4; // 将 x += 4 赋值给 y
// 上面的格式容易混淆，以下是程序员更喜欢的格式：
int x = 1;
x += 4;
int y = x;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

    警告： 如果运算符得到一个值，其类型与左侧操作数的类型不同，就会发生强制类型转换。例如，如果 x 是一个 int，则以下语句

x += 3.5;
1

是合法的，将把 x 设置为 (int)(x + 3.5)。

自增自减运算符

// 自増自减运算符
n++  n--  ++n  --n
1
2

    后缀形式会使用变量原来的值，前缀会先完成加1

    由于这些运算符会改变变量的值，所以不能对数值本身应用这些运算符。例如，4++ 就不是一个合法的语句。

    在Java中，通常建议将这些自增自减运算符用在单独的语句中，以提高代码的可读性，并避免潜在的混淆。

关系和 boolean 运算符

==    !=    <    >    <=    >=    &&    ||    !    ^    true    false
1

与或非异或详情参考链接

条件运算符

// 条件运算符书写格式
// condition 为 true 则选中第一个表达式否则选中第二个
condition ? expression1 : expression2
1
2
3

switch 表达式(Java 14 中引入)

    当需要两个以上的值中做出选择时，可以使用 switch 表达式。

// switch 书写格式：
// case 标签还可以是字符串或枚举类型常量
String seasonName = switch (seasonCode)
	{
		case 0 -> "Spring";
		case 1 -> "Summer";
		case 2 -> "Fall";
		case 3 -> "Winter";
		default -> "???";
	};

// 也可以为各个 case 提供多个标签，用逗号分隔：
int numLetters = switch (seasonName)
	{
		case "Spring", "Summer", "Winter" -> 6;
		case "Fall" -> 4;
		default -> -1;
	};

// switch 表达式中使用枚举常量时，不需要为各个标签提供枚举名，这可以从 switch 值推导得出。
// 在这个例子中，完全可以省略 default，因为每一个可能的值都有相应的一个 case。
enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARGE }; . . .
Size itemSize = . . .;
String label = switch (itemSize)
	{
		case SMALL -> "S"; // no need to use Size.SMALL
		case MEDIUM -> "M";
		case LARGE -> "L";
		case EXTRA_LARGE -> "XL";
	};
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
29
30

    警告： 使用整数或 String 操作数的 switch 表达式必须有一个 default ，因为不论操作数值是什么，这个表达式都必须生成一个值。
    警告： 如果操作数为 null ，会抛出一个 NullPointerException

位运算符

// 位运算符
&("and")    |("or")    ^("xor")    ~("not")
1
2

     警告： 移位运算符的右操作数要完成模32的运算(除非左操作数时 long 类型，在这种情况下需要对右操作数完成模64运算)。例如，1 << 35 的值等同于 1 << 3或 8。

     位运算符相关知识链接：
     位运算符详解
     进制转换详解
     负数的二进制表示方法以及原、反、补码详解

括号与运算符级别

计算中如果不使用圆括号，那么就按照下表的优先级进行计算

除了public还有以下的访问修饰符：
    default: (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

    private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

    public : 对所有类可见。使用对象：类、接口、变量、方法

    protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。