《Java编程入门（阿里云大学）》笔记（文档+思维导图）

课程链接：https://edu.aliyun.com/course/1000
（同样建议直接去看课程，此笔记仅作为参考，其中有些为个人的总结或示例）

（思维导图在最后）

————————————————————————————————————

课时2：认识Java（Java发展简介）

• ​ Java是现在最流行的编程语言之一，并且自身拥有庞大且完善的生态系统。
• ​ Java是SUN公司开发的一套编程语言。
• ​ 1995年5月23日时正式推出了Java编程语言，同时推出了JDK1.0的开发包（1996年才开始可以提供陆续下载使用，到了1997年才传到了中国）。
• ​ Sun（Stanford University NetWork）公司是一家从事于硬件开发的技术性公司，最早的代表性产品：小型机（被广泛地应用在了amazon上）。
• ​ Java语言不同的发展：
  • ​ Java标准开发（J2SE / JAVA SE）：提供的是底层的支持，实现了桌面程序的开发（单机程序）；
  • ​ Java嵌入式开发（J2ME / JAVA ME）：SUN公司最早的时候就是想做嵌入式开发；
  • ​ Java企业开发（J2EE / JAVA EE）：主要是进行企业平台的搭建，现在主要的开发已经是互联网平台。

课时3：Java语言特点

• ​ Java之所以可以得到持续的发展力以及良好的生态系统，这完全取决于Java自身发展的技术特征。

1. 是一个行业内通用的基础实现标准（算是半开源产品，使得Java的开发更加透明）；
2. 是一门面向对象的语言（语法结构更加方便开发者接受）；
3. 提供有方便的内存回收处理机制（提供自动的内存回收操作）；
4. 避免了复杂的指针问题（使用简单的引用来代替指针）；
5. 是为数不多支持多线程编程的开发语言（使得单位时间内处理的性能得到提升）；
6. 提供有高效的网络处理能力（可以基于NIO实现更加高效的数据传输处理）；
7. 具有良好的可移植性（提升程序的适用范围）。

课时4：Java可移植性

• 可移植性指的是同一个程序可以在不同的操作系统之间进行部署。
• 依靠：JVM（Java虚拟机）：由软件和硬件模拟出来的计算机。
  
  

课时5：JDK简介

• JDK的标志性版本：
  • 【1995.05.23】JDK1.0的开发包发布，同时在1996年正式提供下载，标志Java的诞生；
  • 【1998.12.04】JDK1.2版本推出，而后Java正式更名为Java2（Java的升级版）；
  • 【2005.05.23】Java十周年大会上，推出了JDK1.5版本，同时这个版本也是带来新特性以及开发支持更多的历史版本，可以说这一版本直接决定了Java后续十年的技术核心；
  • 【2014年】Java提供了JDK1.8版本，并且支持Lambda表达式
  • 【2017年】Java提供了JDK1.9版本，进一步提供了JDK1.8的稳定性；
  • 【2018年】Java提供了JDK1.10版本，属于JDK1.9的稳定版。
• JDK1.9和JDK1.10的差别不大
• JRE指的是Java运行时的环境，也就是只提供有程序的解释功能。

课时6：JDK安装与配置

• 步骤：

1. 去oracle官网下载jdk包
   （目前下载链接：https://www.oracle.com/java/technologies/javase-jdk15-downloads.html）；
2. 下载完成后进行安装；
3. 配置系统环境变量；
4. cmd进入命令行，输入javac后正确显示则是安装配置成功。

课时7：Java编程起步

1. 编写Hello.java文件：

public class Hello {
public static void main(String[] args) {
System.out.println("Hello World !");
}
}


2. 执行Java程序：

· 对源代码程序进行编译：javac Hello.java，产生Hello.class的字节码文件
|- 利用JVM进行编译，编译出一套与平台无关的字节码文件（*.class）；
​ · 在JVM上进行程序的解释执行：java Hello
​ |- 解释字节码文件，字节码文件的后缀不需要输入


3. 程序代码解析：
   ​ ① 在本程序之中定义的类名称为“Hello”，而类的定义有两种形式：
   ​ · “public class 类名称 {}”：类名称必须与文件名称保持一致，一个文件里只允许有一个public class；
   ​ · “class 类名称 {}”：类名称可以与文件名称不一致，但编译后的class文件为定义的类名称。如有多个定义类，则每个定义类都会生成对应的class文件。
   ​ · 实际项目开发时，推荐一个*.java文件里就只定义一个public class类，不推荐定义多个class类。
   ​ · Java语言命名要求：类名称要求首字母大写。
   ② 主方法：
   ​ · 是所有程序执行的起点，并且一定要定义在类之中。
   ​ · 示例如下：

[public] class 类名称 {
public static void main(String[] args) {
// 程序的代码由此开始执行
}
}


​ · 主方法所在的类为“主类”，所有的“主类”都将采用public class定义
③ 屏幕打印（系统输出）：执行结果的展示，语法形式如下：
​ · 输出之后换行：System.out.println(输出内容);
​ · 输出之后不换行：System.out.print(输出内容);

课时8：JShell工具

• Shell：脚本程序，大多数编程语言都会提供Shell交互式编程环境。
• 使用方法：

1. 直接在jshell中进行程序的编写，如下图所示：
   
2. 将程序内容定义在文件中，如下图所示：
   
   
3. 输入“/exit”进行退出，如下图所示：
   

课时9：CLASSPATH环境属性

1. 设置命令：

SET CLASSPATH = 路径（默认为 . ），此命令仅为当前命令行下的设置，关闭当前命令行窗口则失效；

2. 作用：

Java程序解释时会自动通过CLASSPATH所设置的路径进行类的加载。（CLASSPATH默认设置为当前所在目录）；

3. 全局设置：

全局CLASSPATH需在系统环境变量中设置。

面试题：请问PATH和CLASSPATH的区别？
​ · PATH：是操作系统提供的路径配置，定义所有可执行程序的路径；
​ · CLASSPATH：是由JRE提供的，用于定义Java程序解释时的类加载路径，默认设置的为当前所在目录，可以通过“SET CLASSPATH = 路径”来进行设置。
​ |- 关系： JVM → CLASSPATH定义的路径 → 加载字节码文件
第4章：Java基本概念

课时10：注释

1. 注释的本质：

编译器在进行程序编译时，如发现有注释的内容，则不对此部分进行编译处理。

2. 注释的形式：

​ · 单行注释： //
​ · 多行注释： /* ... */
· 文档注释： /** ... */ （建议重要的类或方法使用）


课时11：标识符与关键字

1. 标识符的定义规则：

由字母、数字、_、$组成，其中不能使用数字开头，不能使用java中的保留字（关键字）。

2. 关键字如下：
   
3. 关键字说明：

​ · JDK1.4时出现assert关键字，用于异常处理上；
· JDK1.5时出现enum关键字，用于枚举定义上；
· 未使用到的关键字：goto、const。
第5章：Java数据类型划分

课时12：Java数据类型简介

程序是一套数字处理的游戏框架，也就是说在整个程序开发过程中，所达到的最终目的就是对一些数据的处理过程，那么既然要进行数据的处理，就一定需要提供有各种类型的数据定义。

1. Java数据类型划分：

​ · 基本数据类型：描述的是一些具体的数字单元。
|- 数值型：
​ |- 整型：byte、short、int、long 默认值：0
​ |- 浮点型：float、double 默认值：0.0
​ |- 布尔型：boolean 默认值：false
​ |- 字符型：char 默认值：’\u0000’
​ · 引用数据类型：牵扯到内存关系的使用。
​ |- 数组、类、接口 默认值：null


2. 使用参考原则
   

课时13：整型数据类型

public class JavaDemo {
public static void main(String[] args) {
int max = Integer.MAX_VALUE; // 获取int的最大值
int min = Integer.MIN_VALUE; // 获取int的最小值
System.out.println(max); // 2147483647
System.out.println(min); // -2147483648
System.out.println("—————— 无以言表的分割线 ——————");
// int型变量 + int型变量 = int型计算结果
System.out.println(max + 1); // -2147483648，最大值 + 1 = 最小值
System.out.println(max + 2); // -2147483647，最大值 + 2 = 次最小值
// int型变量 - int型变量 = int型计算结果
System.out.println(min - 1); // 2147483647，最小值 - 1 = 最大值
}
}


• “数据溢出”：数字在进行处理时，超过了其最大的保存范围，出现有循环的情况。

public class JavaDemo {
public static void main(String[] args) {
// long long变量 = int的数值
long max = Integer.MAX_VALUE; // 获取int的最大值
long min = Integer.MIN_VALUE; // 获取int的最小值
System.out.println(max); // 2147483647
System.out.println(min); // -2147483648
System.out.println("—————— 无以言表的分割线 ——————");
// long型变量 + int型变量 = long型计算结果
System.out.println(max + 1); // 2147483648
System.out.println(max + 2); // 2147483649
// long型变量 - int型变量 = long型计算结果
System.out.println(min - 1); // -2147483649
}
}


• int型转long型：追加”L“或直接使用”(long)“进行转换。

public class JavaDemo {
public static void main(String[] args) {
int max = Integer.MAX_VALUE; // 获取int的最大值
int min = Integer.MIN_VALUE; // 获取int的最小值
System.out.println(max); // 2147483647
System.out.println(min); // -2147483648
System.out.println("—————— 无以言表的分割线 ——————");
// int型变量 + long型变量 = long型计算结果
System.out.println(max + 1L); // 2147483648
System.out.println(max + 2L); // 2147483649
// long型变量 - int型变量 = long型计算结果
System.out.println((long)min - 1); // -2147483649
}
}


• 范围小的数据类型可以自动转成范围大的数据类型；但范围大的数据类型转成范围小的数据类型，则要使用强制转换（不建议使用）。

public class JavaDemo {
public static void main(String[] args) {
long num = 2147483649L; // 此数据已经超过了int范围
int temp = (int) num; // long范围比int范围大，无法自动转换
System.out.println(temp);
}
}


课时14：浮点型数据

1. 定义double变量：

public class JavaDemo {
public static void main(String[] args) {
// 10.2是一个小鼠，其对应的类型为double
double x = 10.2;
int y = 10;
// double类型 * int类型 = double类型
double result = x * y;
System.out.println(result);
}
}


2. 定义float变量：

public class JavaDemo {
public static void main(String[] args) {
float x = (float) 10.2;
float y = 10.1F;
System.out.println(x * y); // float型
}
}


课时15：字符型

1. 定义字符型变量

public class JavaDemo {
public static void main(String[] args) {
char c = 'A'; // 一个字符变量
int num = c; // 可以获得该字符的编码
System.out.println(num); // 输出 65
}
}


• 在任何的编程语言中，字符都可以与int型进行互相的转换，也就是说可以通过int来描述该字符对应的系统编码。
• 编码范围：

​ |- 大写字母：'A'(65) ~ ‘Z’（90）
​ |- 小写字母：'a'(97) ~ ‘z’（122）
​ |- 数字：'0'(48) ~ ‘9’（57）
​ （大小写字母相差32个长度。）


public class JavaDemo {
public static void main(String[] args) {
char c = '加'; // 一个字符变量
int num = c; // 可以获得该字符的编码
System.out.println(num); // 输出 21152
}
}


• 在java中可以使用char型来进行中文数据的保存，这是因为java使用的是unicode这种十六进制的编码，这种编码可以包括任意的文字内容。

课时16：布尔型

• 布尔是一位数据家的名字。
• 布尔主要描述的是一种逻辑的处理结果。
• 在java中使用boolean来进行布尔类型的变量定义，其只有两种取值：true和false。

public class JavaDemo {
public static void main(String[] args) {
boolean flag = true;
if (flag) { // 判断flag的内容，如果是true就执行
System.out.println("我很帅，我很年轻！");
}
else {
System.out.println("不许问年龄！");
}
}
}


课时17：String字符串

• 任何编程语言都没有提供字符串这种数据类型，但为了方便程序的开发，都会提供有字符串的相应描述。
• String类的存在较为特殊，其可以像普通变量那样采用直接赋值的方式进行定义（使用双引号""）。

public class JavaDemo {
public static void main(String[] args) {
String str = "Hello World!";
System.out.println(str); // 输出 Hello world!
}
}


public class JavaDemo {
public static void main(String[] args) {
String str = "Hello";
str + " world!"; // 这里的“+”为字符串连接
System.out.println(str); // 输出 Hello world!
}
}


• “+”的两种描述：

|- 字符串的连接
​ |- 数字的加法计算


• 在进行数据类型转换的时候，如果有String字符串类型，则所有的数据类型无条件先转为String型。

public class JavaDemo {
public static void main(String[] args) {
double x = 10.1;
int y = 20;
System.out.println("计算结果：" + x + y); // 输出 计算结果：10.120
System.out.println("计算结果：" + (x + y)); // 输出 计算结果：30.1
}
}


• 在描述字符串时，也可以使用转义字符进行一些处理，例如：tab（\t）、"（"）、’（’）、换行（\n）。

public class JavaDemo {
public static void main(String[] args) {
System.out.println("\t Hello World!\nHello \"pikaqiu\"!");
}
}
第6章：Java运算符

课时18：运算符简介

• 运算符优先级
  

课时19：数学运算符

• 支持四则运算
• 提供简化运算符：+=、-=、*=、/=
• 自增与自减

​ |- ++ 变量、-- 变量：先进行变量的自增/自减，而后再进行数字的计算；
​ |- 变量 ++、变量 --：先使用变量进行计算，而后再进行自增/自减。


课时20：关系运算符

• 主要特征：进行大小的比较处理
• 包括：大于（>）、小于（<）、大于等于（>=）、小于等于（<=）、不等于（!=）、相等于（==）
• 返回结果：布尔类型

课时21：逻辑运算符

• 三目运算：
  ​ |- 基本语法：关系运算 ? 关系满足时的内容 : 关系不满足时的内容

public class JavaDemo {
public static void main(String[] args) {
int x = 10;
int y = 20;
// 判断x与y的大小关系来决定最终max变量的值
int max = x > y ? x : y;
System.out.println(max);
}
}


课时22：位运算

• ​定义：可以直接进行二进制数据的计算处理
• 包括：与（&）、或（|）、异或（^）、反码（~）、移位处理
• 十进制转二进制：除2，倒序取余

​ 13
2
———————
6 ······ 1
2
———————
3 ······ 0
2
———————
1 ······ 1
2
———————
0 ······ 1

所以13的二进制为1101


• & 计算（使用二进制进行逐位计算，都为1的结果才为1）：

public class JavaDemo {
public static void main(String[] args) {
int x = 13;
int y = 7;
System.out.println(x & y); // 输出 5
}
}


13的二进制： 1 1 0 1
7的二进制： 1 1 1
&计算： 1 0 1 → 5


• | 计算（使用二进制进行逐位计算，有1的都为1）：

public class JavaDemo {
public static void main(String[] args) {
int x = 13;
int y = 7;
System.out.println(x | y); // 输出 15
}
}


13的二进制： 1 1 0 1
7的二进制： 1 1 1
&计算： 1 1 0 1 → 15


• 移位处理：

public class JavaDemo {
public static void main(String[] args) {
int x = 2;
System.out.println(x <<1); // 向左移1位，输出 4
}
}


​ 2的二进制： 0 1 0
​ 向左移1位： 1 0 0 → 4


面试题：请解释&和&&、|和||的区别？（视频答案）
​ · &和|可以进行位运算与逻辑运算
​ |- 在进行逻辑运算时，所有的判断条件都要执行；
​ |- 在进行位运算时，只是针对当前的数据进行与和或的处理；
​ · 在逻辑运算上还可以使用&&、||
​ |- &&：在多个条件判断时，如前面的条件已经返回了false，则不会再走后续的判断，结果就是false
​ |- ||：在多个条件判断时，如前面的条件已经返回了true，则不会再走后续的判断，结果就是true


面试题：请解释&和&&、|和||的区别？（个人答案）
​ · 按位与&、按位或|可以进行位运算与逻辑运算；而逻辑与&&、逻辑或||只能进行逻辑运算；
​ · 在进行逻辑运算时
​ |- 按位与&、按位或|对所有的条件都要进行判断；
​ |- 逻辑与&&、逻辑或||具有短路功能。
第7章：Java程序逻辑控制

课时23：if分支结构

• 程序结构：顺序结构、分支结构、循环结构
• IF分支结构：

​ |- 主要针对关系表达式进行判断处理的分支操作。
​ |- 使用关键字：if、else
​ |- 使用格式：
​ if (布尔表达式) {
条件满足时执行
}
​ [else if (布尔表达式) {
条件满足时执行
}]
​ [else {
上述条件都不满足时执行
}]


课时24：switch开关语句

• switch是一个开关语句，主要是根据内容来进行的判断。
• 判断类型：int、char、枚举、String（JDK1.7）
• 使用格式：

​ switch(数据) {
​ case 数值 : {
​ 数值满足时执行
​ [break;]
​ }
​ case 数值 : {
​ 数值满足时执行
​ [break;]
​ }
​ [default : {
​ 其余数值均不满足时执行
​ [break;]
​ }]
​ }


public class JavaDemo {
public static void main(String[] args) {
String str = "hello";
switch(str) {
case "Hello" :
System.out.println("Hello");
break;
case "hello" :
System.out.println("hello");
break;
default :
System.out.println("no match");
}
}
}


• 如果符合条件的case后没有追加break语句，那么会继续执行下个case，直到遇见break。

课时25：while循环

• 循环结构：某一段代码被重复执行的操作
• 使用格式：

​ |- while（先判断再执行，所以内层代码可能一次都不执行，99%使用）：
​ while() {
​ 条件满足时执行
​ 修改循环条件
​ }
​ |- do...while（先执行再判断，所以内层代码至少会执行一次，1%使用）：
​ do {
​ 条件满足时执行
​ 修改循环条件
​ } while(布尔表达式);


课时26：for循环

• 使用格式：

​ for (定义循环的初始化数值 ; 循环的判断条件 ; 修改循环变量) {
​ 循环语句的执行
​ }


public class JavaDemo {
public static void main(String[] args) {
int sum = 0; // 保存最终的计算总和
for (int i = 0; x <= 100; x ++) {
sum += x; // 累加
}
System.out.println(sum);
}
}


上述代码等价于：

public class JavaDemo {
public static void main(String[] args) {
int sum = 0; // 保存最终的计算总和
int x = 1; // 循环条件初始化
for (; x <= 100;) {
sum += x; // 累加
x ++; // 修改循环变量
}
System.out.println(sum);
}
}


• 对于while和for循环选择的参考标准：

​ |- 在明确确定循环次数时，优先选择for循环；
​ |- 在不明确确定循环次数，但知道循环结束条件时，使用while循环。


课时27：循环控制

• 循环语句定义的控制语句：break、continue

​ |- break：退出整个循环结构
​ |- continue：跳出当前的循环，继续执行下一次循环
​ |- 可以使用continue实现goto功能（java中不提供goto语句），但不建议使用


// 个人示例
public class JavaDemo {
public static void main(String[] args) {
point :
for (int x = 0; x <10; x++) {
System.out.print("x = " + x + "\t");
for (int y = 0; y if (3 == y) {
System.out.println();
continue point;
}
System.out.print("y = " + y + "\t");
}
System.out.println();
}
}
}


课时28：循环嵌套

• 定义：在一个循环语句中嵌套其它的循环语句

课时29：方法的定义

• 使用格式：

权限修饰符 [static] 返回值类型 方法名称([参数类型 定义参数名, ...]) {
​ // 该方法要执行的代码
​ [ return [返回值]; ]
​ }


• 本质：方便使用者进行重复的调用
• 所有的程序一定都是通过主方法开始执行的。

课时30：方法重载

• 定义：方法名称相同，参数的类型或个数不同

public class JavaDemo {
public static void main(String[] args) {
int resultA = sum(10, 20); // 调用两个int参数的方法
int resultB = sum(10, 20, 30); // 调用三个int参数的方法
double resultC = sum(10.2, 20.3); // 调用两个double参数的方法
System.out.println(resultA);
System.out.println(resultB);
System.out.println(resultC);
}
public static int sum(int x, int y) { return x + y; }
public static int sum(int x, int y, int z) { return x + y + z; }
public static int sum(double x, double y) { return x + y; }
}


• 方法重载与方法的返回值类型没有任何关系，它只跟参数有关。
• 基本开发原则：强烈建议方法重载时，使用相同的返回值类型。

public class JavaDemo {
public static void main(String[] args) {
System.out.println(1);
System.out.println(1.1);
System.out.println(true);
System.out.println('A');
System.out.println("Hello World!");
}
}


• 可以发现，输出操作支持各种数据类型，因此System.out.println()就使用了方法重载。

课时31：方法递归调用

• 定义：指一个方法自己调用自己。

• 作用：可以解决一些重复且麻烦的问题。

• 使用时需要注意的问题：

​ |- 一定要设置方法递归调用的结束条件；
​ |- 每一次调用的过程中，一定要修改传递的参数条件。


public class JavaDemo {
public static void main(String[] args) {
System.out.println(sum(100));
}
public static int sum(int num) {
if (1 == num) return 1;
return num + sum(num - 1); // 递归调用，将当前num与前面的sum相加
}
}


代码分析：

​ 【第1次执行sum()，主方法执行】return 100 + sum(99);
​ 【第2次执行sum()，sum()递归调用】return 99 + sum(98);
​ 【第3次执行sum()，sum()递归调用】return 98 + sum(97);
​ ………………………………
​ 【第99次执行sum()，sum()递归调用】return 2 + sum(1);
​ 【第100次执行sum()，sum()递归调用】return 1;


• 实际开发中使用递归调用较少的原因：

​ |- 大部分情况下考虑的都只是一些简单的处理逻辑；
​ |- 如果处理不当，则会造成内存溢出


————————————————————————————————————