JAVA 学习 - Java 的基本程序设计结构

因公司 python 项目结束，暂时也没有 python 的项目，所有需要我们 python 小组的人去转到 Java 项目组，给了一段时间学习，公司的全栈工程师大佬给我们安排了学习计划，给了基本 Java 的电子书，开始一段时间的带薪学习，顺便在这里发一下学习的笔记。
公司目前其他两个 Java 项目的架构都是使用 spring boot 加 spring cloud 微服务架构，这个目前也只是听听，没有具体的概念，往后学就知道了。

学习计划安排

• Java 基础和 Java 高级跟着《Java 核心编程第 10 版这本书进行学习》
• servlet(Jsp)
• spring
• spring boot
• spring cloud

JAVA 核心编程第 10 版 第三章 Java 的基本程序设计结构

注释

注释有三种方式

// 常用单行注释  类似于 python 的 # 

/*
多段注释，类似于 python 的 """

"""
*/

/**
多段注释，用于自动生成文档

*/

3.3 数据类型

3.3.1 整型

整型用于表示没有小数部分的数值， 它允许是负数。Java 提供了 4 种整型，

类型	存储需求	取值范围
int	4字节	-2 147 483 648 - 2 147 483 647 (正好超过 20 亿)
short	2字节	-32 768 - 32 767
long	8字节	-9 223 372 036 854 775 B08 - 9 223 372 036 854 775 807
byte	1字节	-128 ~ 127

一般使用 int，长的值使用 long，特殊情况使用 short,byte

3.3.2 浮点类型

浮点类型用于表示有小数部分的数值。在 Java 中有两种浮点类型，

一般使用 double 类型，因为 float一般满足不了精度

类型	存储需求	取值范围
float	4字节	大约 ± 3.402 823 47E+38F (有效位数为 6 ~ 7 位）
double	8字节	大约 ± 1.797 693 134 862 315 70E+308 (有效位数为 15 位）

• double 表示这种类型的数值精度是 float 类型的两倍（有人称之为双精度数值)。绝大部分应用程序都采用 double 类型。在很多情况下，float 类型的精度很难满足需求。实际上，只有很少的情况适合使用 float 类型，例如，需要单精度数据的库， 或者需要存储大量数据。
• float 类型的数值有一个后缀 F 或 f (例如，3.14F。) 没有后缀 F 的浮点数值（如 3.14 ) 默认为 double 类型。当然，也可以在浮点数值后面添加后缀 D 或 d (例如，3.14D) 。
• NaN 不是一个数字，判断的时候需要注意。
• 金额计算不要使用浮点数，使用特殊的类 BigDecimal

3.3.3 char 类型

char 类型基本上用于表示单个字符。现在和 Unicode 有一些交互

特殊字符的专业序列

转义序列	名称	Unicode 值
\b	退格	\u0008
\t	制表	\u0009
\n	换行	\u000a
\r	回车	\u000d
\"	双引号	\u0022
\’	单引号	\u0027
\\	反斜杠	\u005c

3.3.4 Unicode 和 char类型

UTF - 16

3.3.5 boolean类型

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

3.4 变量

在Java 中，每个变量的都有一个类型(type)。在声明变量时，变量的类型位于变量名之前。

示例：

double salary;
int vacationDays;
long earthPopulation;
boolean done;

// 每个声明以分号结束。

由于声明是一条完整的 Java 语句，所以必须以分号结束。

Java 语句需要以分号 ； 结束。

• 变量名必须是一个以字母开头并由字母或数据构成的序列；

• 需要注意，与大多数程序设计语言相比，Java 中的 “字母” 和 “数字” 的范围更大；

• 字母包括 ’ A’ ~ ’ Z’、 ’ a’ ~ ‘z’、‘_’、‘$’ 或在某种语言中表示字母的任何 Unicode 字符；

• 变量名中所有的字符都是有意义的，并且大小写敏感；

• 变量名的长度基本上没有限制；

• 不能使用 Java 保留字作为变量名；

• 可以在一行中声明多个变量：

  int i,j; 
  

  不提倡使用这种风格，逐一声明每一个变量可以提高程序的可读性。

3.4.1 变量初始化

• 声明一个变量之后，必须用赋值语句对变量进行显式初始化，千万不要使用未初始化的变量。

  // 例如， Java 编译器认为下面的语句序列是错误的：
  int vacationDays;
  System.out.println(vacationDays): // ERROR variable not initialized
  

• 要想对一个已经声明过的变量进行赋值， 就需要将变量名放在等号（=) 左侧， 相应取值 的 Java 表达式放在等号的右侧。

  int vacationDays; 
  vacationDays:12; 
  

  也可以将变量的声明和初始化放在同一行中。例如：

  int vacationDays = 12; 
  

• 最后，在 Java 中可以将声明放在代码中的任何地方。例如，下列代码的书写形式在 Java 中是完全合法的：

  double salary = 65000.0; 
  System,out.println(salary); 
  int vacationDays = 12; // OK to declare a variable here 
  

  在 Java 中， 变量的声明尽可能地靠近变量第一次使用的地方， 这是一种良好的程序编写风格。

3.4.2 常量

• 在 Java 中， 利用关键字 final 指示常量；
• 关键字 final 表示这个变量只能被赋值一次。一旦被赋值之后，就不能够再更改了；
• 习惯上, 常量名使用全大写；
• 在 Java 中，经常希望某个常量可以在一个类中的多个方法中使用，通常将这些常量称为 类常量。可以使用关键字 static final设置一个类常量；
• 常量被声明为 public，那么其他类的方法也可以使用这个常量；

3.5 运算符

• +、-、*、/ 表示加、减、乘、除；

• 除法运算 / 时，两个操作数都是整数时，表示整数除法；否则表示浮点除法；

• 整除的求余操作（取模）用 % 号表示；

• // demo
  15 / 2 等于 7
  15 % 2 等于 1
  15.0 / 2  等于 7.5
  

• 注意：整数被 0 除 将会产生一个异常，而浮点数被 0 除将会得到无穷大或 NaN 结果

3.5.1 数学函数与常量

Java 里面提供的 Math 类来进行一些数学计算；

在 Math类中，包含了各种各样的数学函数。在编写不同类别的程序时，可能需要的函 数也不同。

// 不必在数学方法名和常量名前添加前缀“ Math”， 只要在源文件的顶部加上下面这行代码就可以了。
import static java.1ang.Math.*;

// sqrt 方法
// 要想计算一个数值的平方根， 可以使用 sqrt 方法：
double x = 4;
double y = Math.sqrt(x);
System.out.println(y); // prints 2.0

// pow 方法
// 在 Java中，没有幂运算， 因此需要借助于 Math 类的 pow 方法。语句：
double y = Math.pow(x, a);
// 将 y 的值设置为 x 的 a 次幂（ xa)。pow 方法有两个 double 类型的参数， 其返回结果也为double 类型

// floorMod 方法
// floorMod 方法的目的是解决一个长期存在的有关整数余数的问题。
floorMod(position + adjustment, 12)
// 总会得到一个 0 ~ 11 之间的数。

// Math 类提供了一些常用的三角函数：
Math,sin
Math.cos
Math.tan
Math.atan
Math.atan2

// 还有指数函数以及它的反函数—自然对数以及以 10 为底的对数：
Math.exp
Math.log
Math.loglO

// 最后 Java 还提供了两个用于表示 TC 和 e 常量的近似值：
Math.PI
Math.E

3.5.2 数值类型之间的转换

经常需要将一种数值类型转换为另一种数值类型。

在图中有 6 个实心箭头，表示无信息丢失的转换；有 3 个虚箭头， 表示可能有精度 损失的转换。 例如，123 456 789 是一个大整数， 它所包含的位数比 float 类型所能够表达的 位数多。 当将这个整型数值转换为 float 类型时， 将会得到同样大小的结果，但却失去了一定 的精度。

int n = 123456789; 
float  = n; // f is 1.23456792E8 

当使用上面两个数值进行二元操作时（例如 n + f，n 是整数， f 是浮点数，) 先要将两个操作数转换为同一种类型，然后再进行计算。

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

3.5.3 强制类型转换

double x = 9.997;
int nx = (int) x;
// nx = 9

// round 取最接近的整数
double x = 9.997;
int nx = (int) Math.round(x);
// nx = 10

3.5.4 结合赋值和运算符

x += 4 // 相当于 x = x + 4

3.5.5 自增与自减运算符

n++ // 将当前变量加 1
n-- // 将当前变量减 1

// ++ 的位置影响运算
int m = 7;
int n = 7;
int a = 2 * ++m; // now a is 16, m is 8
int b = 2 * n++; // now b is 14, n is 8

3.5.6 关系和 Boolean 运算符

• Java 判等使用 ==

• 不等 !=

• < (小于)、 > (大于)、<=(小于等于）和 >= (大于等于）

• &&(与)、||(或)、!(非)

• 三元操作符 ?

  x < y ? x : y
  // 会返回 x 和 y 中较小的一个。
  

3.5.7 位运算符

// 位运算符包括：
& ("and") | ("or") A ("xor") ~ ("not") 
   
// 还有 >> 和 << 运算符将位模式左移或右移

3.5.8 括号与运算符级别

• 如果不使用圆括号， 就按照给出的运算符优先级次序进 行计算。
• 同一个级别的运算符按照从左到右的次序进行计算（除了表中给出的右结合运算符外）.

// 例如，由于 && 的优先级比 || 的优先级高， 所以表达式
a && b || c
// 等价于
// (a && b) || c

// 又因为 += 是右结合运算符， 所以表达式
a += b += c
// 等价于
a += (b += c)
// 也就是将 b += c 的结果（加上 c 之后的 b) 加到 a 上。

运算符优先级

3.5.9 枚举类型

// 在变量中很可能保存的是一个错误的值（如 0 或 m)。
// 针对这种情况， 可以自定义枚举类型。枚举类型包括有限个命名的值。 例如，
enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARCE };
// 现在，可以声明这种类型的变量：
Size s = Size.MEDIUM
// Size 类型的变量只能存储这个类型声明中给定的某个枚举值，或者 null 值，null 表示这个变量没有设置任何值。

3.6 字符串

3.6.1 子串

// String 类的 substring 方法可以从一个较大的字符串提取出一个子串。例如：
String greeting = "Hello";
String s = greeting.substring(0, 3);
//创建了一个由字符“ Hel” 组成的字符串。

// 相当于 python 里面使用索引的方式来切割字符串

3.6.2 拼接

拼接方式和 python 一样，使用 + 号进行拼接即可

3.6.3 不可变字符串

String 类没有提供用于修改字符串的方法

// 先取出然后再拼接，实现字符串修改想·
greeting = greeting.substring(0, 3) + "p!";

3.6.4 检测字符串是否相等

可以使用 equals 方法检测两个字符串是否相等。对于表达式：

s.equals(t)

要想检测两个字符串是否相等，而不区分大小写， 可以使用 equalsIgnoreCase 方法。

“Hello”.equalsIgnoreCase(“hel1o”)

一定不要使用=运算符检测两个字符串是否相等！ 这个运算符只能够确定两个字串是否放置在同一个位置上。当然， 如果字符串放置在同一个位置上， 它们必然相等。但是， 完全有可能将内容相同的多个字符串的拷贝放置在不同的位置上。

3.7 输入输出

3.7.1 读取输入

// 首先需要构造一个 Scanner 对象，并与“ 标准输人流” System.in 关联
Scanner in = new Scanner(System.in);
System.out.print("What is your name? ");
String name = in.nextLine();
// get second input
System.out.print("How old are you? ");
int age = in.nextInt();

// display output on console
System.out.println("Hello, " + name + ".Next year, you'll be" + (age + 1));

3.7.2 格式化输出

double x = 10000.0 / 3.0;
System.out.print(x);

System.out.printf("%8.2f", x);

3.8 控制流程：

块作用域：变量的使用区域

if 判断、for 循环、while 循环：这三个类似于 python；break、continue 用于结束循环

switch 语句：一种逻辑判断方式，一般不使用

3.9 大数值操作：

如果基本的整数和浮点数精度不能够满足需求， 那么可以使用jaVa.math 包中的两个很有用的类：Biglnteger 和 BigDecimaL 这两个类可以处理包含任意长度数字序列的数值。

Biglnteger 类实现了任意精度的整数运算， BigDecimal 实现了任意精度的浮点数运算。

Biglnteger 和 BigDecimal， Java 中的大数值操作需要使用这两个类

3.10 数组

数组是一种数据结构， 用来存储同一类型值的集合。通过一个整型下标可以访问数组中的每一个值。

类似于 python 中的列表，操作方式有些不一样，感觉没有 python 中的方便；

在声明数组变量时， 需要指出数组类型 （ 数据元素类型紧跟 []) 和数组变量的名字。下

面声明了整型数组 a:

int[] a; 

不过， 这条语句只声明了变量 a， 并没有将 a 初始化为一个真正的数组。应该使用 new 运算

符创建数组。

int[] a = new int[100];

这条语句创建了一个可以存储 100 个整数的数组。数组长度不要求是常量： newint[n] 会创建

一个长度为 n 的数组。

数组赋值：

int[] a = new int[100];
for (int i = 0; i < 100; i++)
    a[i] = i; // fills the array with numbers 0 to 99

匿名数组

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;

数组拷贝

// 数组拷贝
int[] luckyNumbers = smallPrimes;
luckyNumbers[5] = 12; // now smallPrimes[5] is also 12

// Arrays 类的 copyOf方法：   这个方法通常用来增加数组的大小
//int[] copiedLuckyNumbers = Arrays.copyOf(luckyNumbers , luckyNumbers .length);
luckyNumbers = Arrays.copyOf(luckyNumbers , 2 * luckyNumbers.length);

数组排序

 // 数组排序  sort 方法
int[] a = new int[10000];
Arrays.sort(a);

多维数组

相当于 python 列表的嵌套，注意构建方式

// 多维数组
int[][] magicSquare = {
    {16, 3, 2, 13},
    {5, 10, 11, 8},
    {9, 6, 7, 12}, 
    {4, 15, 14, 1}
};