《Java编程入门》笔记——阿里云大学

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

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

第1章：Java语言简介

一、课时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虚拟机）：由软件和硬件模拟出来的额计算机。
  
  

第2章：搭建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后正确显示则是安装配置成功。

第3章：初识Java开发

一、课时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 < x; y++) {
                if (3 == y) {
                    System.out.println();
                    continue point;
                }
                System.out.print("y = " + y + "\t");
            }
            System.out.println();
        }
    }
}

六、课时28：循环嵌套

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

第8章：方法的定义及使用

一、课时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;

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

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

本文地址：https://blog.csdn.net/weixin_43494837/article/details/112085145