目录
1-3 第一个程序的讲解
这是一个简单的 Java 程序，包含了类的定义、方法调用、变量声明等基本概念。下面逐步解析程序中的每个部分：
package com.mir.demo; // 用来定位当前类文件的位置
package: 这行代码定义了该类所属的包。com.mir.demo是包名，通常用于组织 Java 类，帮助管理和避免类名冲突。在 Java 中，包是一种命名空间，它可以确保类文件的唯一性。若没有指定包，则类默认属于default包。
public class Main { // 定义了一个公共的类 Main
public class Main: 这里定义了一个公共类Main，其中public关键词表示该类是公开的，可以被任何其他类访问，class是 Java 中定义类的关键字。类名Main是程序的入口类。每个 Java 程序都有一个主类，并且必须包含一个main方法作为程序的入口点。
// main函数：程序入口点
public static void main(String[] args) {
-
public static void main(String[] args):
main方法是 Java 程序的入口点。当程序启动时，JVM（Java 虚拟机）会从
main方法开始执行。它的签名是固定的：
public表示该方法是公共的，可以被外部调用。static表示方法是静态的，不需要创建类的实例就能调用。void表示该方法没有返回值。String[] args是命令行参数的数组，用于接收启动 Java 程序时的参数。
int number_a = 1, number_b = 2; // 定义了两个整数变量
int number_a = 1, number_b = 2;: 这里声明并初始化了两个整数变量number_a和number_b，分别赋值为 1 和 2。
int sum = sum(number_a, number_b); // 调用sum方法，传递number_a和number_b
int sum = sum(number_a, number_b);: 通过调用方法sum来计算两个数的和。方法sum的返回值被赋值给变量sum。
System.out.println("sum = " + sum); // 输出sum的结果
System.out.println("sum = " + sum);: 该语句输出sum的值，"sum = "是字符串拼接，+ sum会将sum的值转化为字符串并与"sum = "拼接，最终输出格式为sum = 3（因为number_a和number_b相加为 3）。
System.out.println("Hello"); // 输出"Hello"
System.out.println("Hello");: 这行代码直接输出"Hello"到控制台。
}
- 结束
main方法的定义。
public static int sum(int number_a, int number_b) {
return number_a + number_b;
}
-
- 这是一个静态方法
public static int sum(int number_a, int number_b)sum，用于计算两个整数的和。
int sum(int number_a, int number_b): 方法名为sum，接收两个整数参数number_a和number_b，返回它们的和。return number_a + number_b;: 返回number_a和number_b的和。
总结：
这个程序包含了以下几个关键点：
- 类的定义：
public class Main定义了一个公共类Main，并且是程序的入口类。 main方法：public static void main(String[] args)是程序的入口方法，是每个 Java 应用的必需方法。- 方法的定义和调用：定义了一个静态方法
sum来计算两个整数的和，并在main方法中调用该方法。 - 变量的声明和使用：在
main方法中声明并初始化了两个整数变量number_a和number_b，并用它们计算和。
程序输出：
sum = 3
Hello
这是程序的执行结果，sum = 3 是由 sum 方法计算得出的和，Hello 是直接输出的字符串。
1-4 注释和文档
在 Java 中，注释是用来解释代码的文字，帮助开发者理解代码的逻辑或者标明某些代码的用途。注释不会影响程序的执行。
代码解析：
package com.nix.demo; // 这是包的声明，指明该类属于哪个包
package: 这一行是包声明，用于组织类文件，避免类名冲突。com.nix.demo是包名。
public class Main {
public class Main: 这是类的声明，定义了一个公共类Main。
// Java中函数叫方法
- 行注释: 这是一个行注释，用
//表示。该行注释描述了 Java 中函数的另一种叫法：方法。
// 行注释
- 行注释: 该注释标明下面的代码是单行注释。
/*
段落注释
*/
- 段落注释: 这部分是多行注释（段落注释），它可以注释掉多行内容，适合用来写较长的注释块。使用
/*开始，*/结束。
public static void main(String[] args) {
int sum = sum(1, 2); // 调用sum方法，计算1和2的和
System.out.println("sum = " + sum); // 打印和
System.out.println(Math.random()); // 打印一个随机数
System.out.println("Hello, World!"); // 打印"Hello, World!"
}
public static void main(String[] args): 这是 Java 程序的入口方法。当程序运行时，JVM 会从main方法开始执行。- 在
main方法中，我们调用了sum(1, 2)方法来计算 1 和 2 的和，并输出结果。 Math.random()会生成一个介于 0.0 和 1.0 之间的随机数并输出。- 最后，
System.out.println("Hello, World!")会输出 “Hello, World!”。
/** 类注释（方法注释）
* 该方法（函数）传递两个int类型参数，用来求和
* @param number_a 第一个加数
* @param number_b 第二个加数
* @return 返回一个求和后的结果
*/
public static int sum(int number_a, int number_b) {
return number_a + number_b;
}
-
-
方法注释（Javadoc注释）
- 这是使用 Javadoc 风格的注释。在 Java 中，使用
/**开始的注释块是专门用于生成文档的注释格式。
@param: 描述方法参数的含义，number_a和number_b是方法的两个参数，分别表示加数。@return: 描述方法返回值的含义，表示该方法返回两个参数的和。sum(int number_a, int number_b): 该方法用于计算并返回两个整数的和。
程序输出：
sum = 3
0.235427
Hello, World!
sum = 3是通过调用sum方法计算的 1 + 2 的结果。- 第二行
0.235427是Math.random()生成的一个随机数（每次运行会不同）。 - 最后，输出
"Hello, World!"。
总结：
在这个例子中，展示了三种不同的注释类型：
- 行注释（
//）：用于注释掉单行代码。 - 段落注释（
/* */）：用于注释掉多行代码，通常用于代码块或者较长的解释。 - Javadoc 注释（
/** */）：用于生成方法的文档说明，这种注释通常包含@param和@return等标签，用来描述方法的参数和返回值，帮助生成 API 文档。
这些注释帮助开发者理解程序的功能和结构，特别是在团队合作中，注释尤为重要。
2-0 一带而过
在这个简单的程序中，展示了如何使用方法来完成求和操作，并且调用了 Math.random() 来生成一个随机数。代码实现比较基础，主要目的是帮助理解方法的调用和使用。
代码解析：
package com.nix.demo;
package: 定义了程序的包，com.nix.demo包含了Main类。包用于组织类，并避免类名冲突。
public class Main {
public class Main: 定义一个名为Main的公共类。在 Java 中，每个应用程序都必须至少有一个公共类。
public static void main(String[] args) {
sum(1,2); // 调用 sum 方法并传递 1 和 2
System.out.println(Math.random()); // 打印一个随机数
}
public static void main(String[] args):main方法是程序的入口点，程序从此方法开始执行。sum(1, 2)调用sum方法计算 1 和 2 的和，但它的返回值没有被保存或输出。System.out.println(Math.random())会打印一个随机数。Math.random()生成一个 [0, 1) 之间的浮动随机数。
/** 类注释（方法注释）
* 该方法（函数）传递两个int类型参数，用来求和
* @param number_a 第一个加数
* @param number_b 第二个加数
* @return 返回一个求和后的结果
*/
public static int sum(int number_a, int number_b) {
return number_a + number_b;
}
- Javadoc 注释: 使用 Javadoc 风格的注释为
sum方法提供文档说明。@param标签描述了方法的两个参数，number_a和number_b，并且解释了它们的含义，分别是两个加数。@return标签描述了方法返回的值，即两个参数的和。 sum(int number_a, int number_b): 该方法接受两个整数作为参数并返回它们的和。
程序行为：
- 调用
sum(1, 2)计算 1 和 2 的和，但没有打印或保存结果，因此程序没有显示sum方法的结果。 - 调用
Math.random()生成一个随机数并打印。每次运行时会得到不同的随机数。 - 由于没有输出
sum(1, 2)的结果，程序仅打印了一个随机数。
运行输出：
0.5948487438283359 // Math.random() 输出的随机数
- 每次运行时，
Math.random()输出的值都会有所不同。
总结：
- 这个示例展示了方法的调用、返回值、和 Javadoc 注释的使用。
sum方法被调用但没有处理返回值，可能是一个简化的示例。在实际应用中，通常会使用返回值或将其打印出来，以便查看结果。- 该程序的输出只是一个随机数，因为
sum方法的返回值并未在main方法中使用。
2-1 字符串演示
在这个 Java 示例中，我们演示了字符串的使用，以及如何将字符串从字符数组中创建出来。通过比较 C 语言和 Java 中字符串的不同，代码清晰地展示了字符串的一些常见操作。
代码解析：
package com.nix.demo;
package: 该行声明了 Java 类所在的包com.nix.demo，组织和管理代码。
public class Main {
public static void main(String[] args) {
public class Main: 定义了一个Main类，作为程序的入口。public static void main(String[] args):main方法是程序的启动点，Java 程序的执行总是从main方法开始。
// 在 C 语言中，字符串实际上是使用空字符 \0 结尾的一维字符数组。
char[] helloArray = {'r', 'u', 'n', 'o', 'o', 'b'};
System.out.println("helloArray = " + helloArray);
String helloString = new String(helloArray);
System.out.println(helloString);
char[] helloArray: 在 Java 中，我们可以使用字符数组来存储一个字符串。在 C 语言中，字符串是以空字符\0结束的，而 Java 的字符串不需要显式地以\0结束，Java 会自动处理这个问题。System.out.println("helloArray = " + helloArray)直接打印字符数组，会输出一个地址或类似[C@15db9742的内容，这并不是期望的字符串格式。- 然后通过
new String(helloArray)将字符数组转换为字符串helloString，并打印出来。
String str_1 = "hello";
String str_2 = "world";
System.out.println("str_1 = " + str_1);
System.out.println("str_2 = " + str_2);
String str_1 = "hello";: 在 Java 中，字符串是一个对象，不像 C 语言中的字符数组那样。你可以直接通过字面量赋值，"hello"会自动转换为String类型。System.out.println: 打印两个字符串变量str_1和str_2。
System.out.println("str_1 -> length : " + str_1.length());
str_1.length(): 使用length()方法获取字符串的长度，输出str_1的长度。
System.out.println("我的名字是 ".concat("Tom"));
System.out.println("我的名字是 " + "Tom");
concat(): 用于连接两个字符串。输出字符串"我的名字是 Tom"。- 使用
+操作符也可以连接字符串。结果相同。
char[] chars = str_1.toCharArray();
System.out.println("chars =" + chars);
for (int i = 0; i < chars.length; i++) {
System.out.println(chars[i]);
}
toCharArray():String类型的toCharArray()方法将字符串转换为字符数组，然后逐个打印数组中的每个字符。
System.out.println(str_1.toUpperCase());
toUpperCase(): 将字符串转换为大写字母，并输出"HELLO"。
运行输出：
helloArray = [C@15db9742
hello
str_1 = hello
str_2 = world
str_1 -> length : 5
我的名字是 Tom
我的名字是 Tom
chars =hello
h
e
l
l
o
HELLO
主要点总结：
- 字符串和字符数组：
- 在 Java 中，字符串是
String类型的对象，直接用字符串字面量或new String()创建。 - 字符串可以通过字符数组
toCharArray()转换。
- 在 Java 中，字符串是
- 字符串常用方法：
length()获取字符串的长度。concat()用于字符串连接。toUpperCase()将字符串转换为大写。
- 与 C 语言的区别：
- Java 的字符串自动管理结束标志，避免了 C 语言中需要手动处理
\0的问题。
- Java 的字符串自动管理结束标志，避免了 C 语言中需要手动处理
代码改进建议：
- 打印字符数组时，
System.out.println("helloArray = " + helloArray)可能会打印内存地址而不是字符串。可以使用new String(helloArray)来打印字符数组的内容，而不是直接打印字符数组对象。
System.out.println("helloArray = " + new String(helloArray));
chars输出：使用System.out.println("chars = " + chars)会输出字符数组的内存地址，而不是数组内容。建议使用循环逐个打印字符，或者使用String.valueOf(chars)来输出数组内容。
System.out.println("chars = " + String.valueOf(chars));
总结：
- 本程序展示了如何在 Java 中处理字符串，使用字符数组与字符串转换，常见字符串操作方法，以及如何进行字符串连接和大写转换。
2-2 字符串结束符的那些事
在这个 Java 示例中，我们再次讨论了 Java 中字符串的使用，特别是与 C 语言中的字符串结束符 \0 的比较。通过这个示例，我们可以更好地理解 Java 字符串如何处理结束符，并比较 Java 和 C 语言在这方面的不同。
代码解析：
package com.nix.demo;
package: 该行声明了 Java 类所在的包com.nix.demo，用于代码的组织和管理。
public class Main {
public static void main(String[] args) {
public class Main: 定义了一个Main类，作为程序的入口。public static void main(String[] args):main方法是 Java 程序的启动点，程序从main方法开始执行。
// 在 C 语言中，字符串实际上是使用空字符 \0 结尾的一维字符数组。
// 在Java语言中，字符串不需要\0, 但是实际上是有\0只是没显示出来，因为Java语言爽就完事了！
char[] helloArray = {'r', 'u', 'n', 'o', 'o', 'b'};
System.out.println("helloArray = " + helloArray);
String helloString = new String(helloArray);
System.out.println(helloString);
-
- 定义了一个字符数组，包含字符串
char[] helloArrayr,
u,
n,
o,
o,
b。
- 在 C 语言中，字符串以空字符
\0结尾来标识字符串的结束，Java 字符串不显式包含\0，但实际上它的底层实现是包含\0作为终止标记的，只是对用户不可见。
-
System.out.println("helloArray = " + helloArray)直接打印字符数组时，结果会是类似[C@15db9742这样的内存地址（并非期望的字符串格式），需要用new String(helloArray)将字符数组转换为字符串helloString，然后打印出来。
String str_1 = "hello";
String str_2 = "world";
System.out.println("str_1 = " + str_1);
System.out.println("str_2 = " + str_2);
String str_1 = "hello";: 这里是字符串字面量赋值，Java 会自动创建String对象。System.out.println: 打印两个字符串变量str_1和str_2。
System.out.println("str_1 -> length : " + str_1.length());
str_1.length():length()方法返回字符串的长度，这里返回"hello"的长度5。
System.out.println("我的名字是 ".concat("Tom"));
System.out.println("我的名字是 " + "Tom");
concat():concat()用于将两个字符串连接起来，输出"我的名字是 Tom"。- 使用
+操作符也可以连接字符串，效果相同。
char[] chars = str_1.toCharArray();
System.out.println("chars =" + chars);
for (int i = 0; i < chars.length; i++) {
System.out.println(chars[i]);
}
toCharArray():String的toCharArray()方法将字符串转换为字符数组，然后逐个打印字符数组的内容。- 打印字符数组时，
System.out.println("chars =" + chars)会输出字符数组的内存地址。为了更好地展示数组内容，建议逐个打印数组元素，或者使用String.valueOf(chars)。
System.out.println(str_1.toUpperCase());
toUpperCase():toUpperCase()方法将字符串中的所有字符转换为大写字母并返回"HELLO"。
运行输出：
helloArray = [C@15db9742
hello
str_1 = hello
str_2 = world
str_1 -> length : 5
我的名字是 Tom
我的名字是 Tom
chars =hello
h
e
l
l
o
HELLO
主要点总结：
- C语言中的字符串结束符
\0：- 在 C 语言中，字符串是字符数组，字符串的结束是通过空字符
\0来标识的。 - Java 中，字符串是
String类型，不需要显式地添加\0，但实际上底层是以\0结束的，Java 会自动处理这个问题。
- 在 C 语言中，字符串是字符数组，字符串的结束是通过空字符
- Java中的字符串操作：
length()：获取字符串的长度。concat()：连接字符串，可以使用+操作符连接，也可以使用concat()方法。toCharArray()：将字符串转换为字符数组。toUpperCase()：将字符串转换为大写。
- 字符数组与字符串的关系：
- 字符数组 (
char[]) 可以通过new String(helloArray)转换为字符串。 - Java 字符串是对象，字符数组是基本类型，不同的内存管理机制。
- 字符数组 (
改进建议：
- 打印字符数组：
System.out.println("helloArray = " + helloArray)输出字符数组时应改为使用new String(helloArray)来打印字符内容。
System.out.println("helloArray = " + new String(helloArray));
- 字符数组输出：对于字符数组的打印，使用
String.valueOf(chars)可以直接输出字符数组内容。
System.out.println("chars = " + String.valueOf(chars));
总结：
- 本程序通过对比 Java 和 C 语言中字符串的处理方式，展示了 Java 中字符串的常见操作，包括长度、拼接、转换为字符数组、转换为大写等。同时，程序还展示了如何通过字符数组构建字符串，以及 Java 如何自动处理字符串结束符。
2-3 自动类型那些事儿（自动类型转换）
在这段代码中，我们演示了 Java 中 自动类型转换 和 强制类型转换 的使用，以及如何在不同类型间进行转换。特别是对 char 类型到 int 类型的自动转换进行了展示。
代码解析：
public class Main {
// 2-3 自动类型那些事儿（自动类型转换）
// 低 ------------------------------------------> 高
// byte,short,char -> int -> long -> float -> double
// 只能从低等级转换成高等级
// （看小品学的这节课，哈哈哈哈Frank教学果然不是这么枯燥无味！）
// 自动类型转换
public static void main(String[] args) {
char c1 = 'a';
int i1 = c1;
System.out.println(i1);
char c2 = 'A';
int i2 = c2;
System.out.println(i2);
// 强制类型转换
// 格式：(type)value type是要强制类型转换后的数据类型
int i3 = 123;
byte b = (byte)i3; //强制类型转换为byte
System.out.println("int强制类型转换为byte后的值等于" + b);
}
}
主要内容解释：
1. 自动类型转换（Widening Conversion）
Java 允许更低等级的数据类型自动转换为更高等级的数据类型。例如：
byte、short、char->int->long->float->double。- 这种转换是 自动的，我们不需要做任何额外的操作。
示例：
char c1 = 'a';
int i1 = c1;
System.out.println(i1); // 输出：97
char c1 = 'a';：char类型的变量c1存储字符'a'。int i1 = c1;：字符'a'的 ASCII 码是 97，char类型自动转换为int类型，得到97。
char c2 = 'A';
int i2 = c2;
System.out.println(i2); // 输出：65
char c2 = 'A';：字符'A'的 ASCII 码是 65。int i2 = c2;：同样是自动将char类型转换为int类型，得到65。
2. 强制类型转换（Narrowing Conversion）
当我们从高等级的类型转换为低等级的类型时，Java 不会自动进行转换，因为这可能会丢失数据或者引发错误。所以需要使用 强制类型转换。
强制类型转换的格式是 (type)value，其中 type 是目标数据类型，value 是要转换的值。
示例：
int i3 = 123;
byte b = (byte)i3; // 强制类型转换为byte
System.out.println("int强制类型转换为byte后的值等于" + b); // 输出：int强制类型转换为byte后的值等于123
int i3 = 123;：定义一个int类型的变量i3，值为123。byte b = (byte)i3;：将int类型的i3强制转换为byte类型。由于byte的取值范围是 -128 到 127，123可以安全地存储到byte中，因此输出为123。- 如果
i3的值超过byte的取值范围，可能会出现 溢出 或 数据丢失。
输出：
97
65
int强制类型转换为byte后的值等于123
主要概念总结：
- 自动类型转换：低级类型（如
byte、short、char）可以自动转换为更高级的类型（如int、long、float、double）。 - 强制类型转换：高级类型需要手动强制转换为低级类型，如果转换过程中数据会丢失或溢出，开发者需要自行处理。
char到int的转换：char类型可以自动转换为int类型，表示字符的 ASCII 值。
注意事项：
- 自动类型转换是 无损的（不会丢失数据），因为转换后的类型容量足够大。
- 强制类型转换可能会 丢失数据，特别是当从更大范围的类型转换为更小范围的类型时。
通过这段代码，您可以更好地理解 Java 中不同类型之间的转换机制，特别是自动转换和强制转换的使用场景。
2-4 import 导包和 API 文档
在 Java 中，import 语句用于导入其他类或包，使得我们能够在当前类中使用其他类中的功能而无需使用完整的类路径。通过 import，我们可以方便地使用 Java 标准库中的类或自己创建的类。
这段代码演示了如何导入外部类，以及如何使用 charAt() 方法访问字符串中的某个字符。
代码解析：
package com.nix.demo;
import com.nix.tools.Student; // 导入Student文件
// 2-4 import导包和API文档
public class Main {
public static void main(String[] args) {
String s = "www.google.com";
// 0 1 2 3 4 5 6 7 8
// char charAt(int index)
// 返回指定索引处的 char 值。
char result = s.charAt(8);
System.out.println(result);
Student stu; // 创建一个Student对象
}
}
主要内容说明：
1. 导入外部类 (import)
import com.nix.tools.Student; // 导入Student文件
import语句用于导入其他类。通过import，我们可以直接使用Student类，而不需要写出完整的类路径com.nix.tools.Student。- 如果你创建了一个自定义类
Student，这个类位于com.nix.tools包下，使用import后就可以直接使用该类，而不需要再次指定完整的包路径。
2. 字符串的 charAt(int index) 方法
String s = "www.google.com";
char result = s.charAt(8);
System.out.println(result); // 输出：c
charAt(int index)方法用于返回指定索引处的字符。- 在字符串
"www.google.com"中，索引从 0 开始，charAt(8)会返回索引为 8 的字符，即字符'c'。 - 该方法的返回值是
char类型。
3. 创建 Student 对象
Student stu; // 创建一个Student对象
-
在当前代码中，
Student类的定义没有展示，但它应该是位于com.nix.tools包中的一个类。此行代码声明了一个Student类型的变量stu。 -
要实例化这个对象并使用它，我们需要使用
new关键字，比如：
Student stu = new Student();
小结：
import语句用于导入其他类或包，使得我们可以在代码中直接使用它们而无需写完整的类路径。charAt(int index)是String类的方法，它返回指定索引位置的字符。- 通过导入外部类，我们能够在代码中引用和使用自定义的类（如
Student）。
API 文档说明：
如果你想查看某个方法或类的详细说明，可以查看 Java 的官方 API 文档。例如，charAt(int index) 方法的 API 文档可以在 Java官方API 中找到详细说明。
这使得 Java 的开发更加灵活和高效，尤其是在与外部库或类进行交互时。
2-5 Java中的数组
在 Java 中，数组是一个数据结构，它能够存储多个相同类型的数据元素。Java 数组有两种主要的声明方式：一种是静态初始化，另一种是动态初始化。Java 数组是对象类型，它是一个引用类型。
代码解析
package com.nix.demo;
// 2-5 Java中的数组
public class Main {
public static void main(String[] args) {
// C语言中定义数组： int arr[] = {1,2,3};
// int arr[5];
// 静态数组 一旦声明，就不能改变数组长度
// Java中的数组
// 1. 初始化
int[] arr_1 = {1, 2, 3, 4, 5};
// 2. 分配方式
// dataType[] arrayRefVar = new dataType[arraySize];
int[] arr_2 = new int[2];
arr_2[0] = 1;
arr_2[1] = 2;
System.out.println("arr_1 = " + arr_1[0]);
System.out.println("arr_1.length = " + arr_1.length);
// java数组里的length不带括号 String里的length带括号length()
for (int i = 0; i < arr_1.length; i++) {
System.out.println("arr_1 = " + arr_1[i]);
}
// for each 增强for循环
double[] myList = {1.9, 2.9, 3.4, 3.5};
// 打印所有数组元素
for (double element: myList) {
System.out.println("element = " + element);
}
printArray(arr_2);
}
public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
}
代码说明：
1. 静态数组初始化
int[] arr_1 = {1, 2, 3, 4, 5};
- 静态初始化：通过花括号
{}直接给数组赋初值，数组长度由 Java 自动确定。 - 数组的大小一旦被确定，就不能改变。
2. 动态数组初始化
int[] arr_2 = new int[2];
arr_2[0] = 1;
arr_2[1] = 2;
- 动态初始化：使用
new关键字创建一个固定大小的数组。 new int[2]表示创建一个包含 2 个元素的整数数组，并且数组的默认值是 0。- 在此之后，可以通过索引为数组元素赋值。
3. 打印数组的第一个元素
System.out.println("arr_1 = " + arr_1[0]);
- 打印
arr_1数组的第一个元素（索引为 0 的元素）。
4. 获取数组的长度
System.out.println("arr_1.length = " + arr_1.length);
arr_1.length返回数组的长度，注意：length是一个属性，不需要加括号。与String类的length()方法不同，数组的length是一个固定的值。
5. 使用 for 循环遍历数组
for (int i = 0; i < arr_1.length; i++) {
System.out.println("arr_1 = " + arr_1[i]);
}
- 使用
for循环遍历arr_1数组，并打印出每一个元素。
6. 使用增强的 for 循环
double[] myList = {1.9, 2.9, 3.4, 3.5};
for (double element: myList) {
System.out.println("element = " + element);
}
- 增强的 for 循环（也叫做 “foreach” 循环）简化了数组遍历过程，无需通过索引来访问每个元素。该方式非常适合用于遍历所有元素的场景。
7. 自定义方法打印数组
public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
- 创建了一个方法
printArray()，该方法接受一个整数数组作为参数，并使用普通的for循环打印数组的所有元素。
小结：
- 静态数组通过在声明时初始化赋值，大小由 Java 自动确定。
- 动态数组使用
new关键字指定数组大小，并且可以在后续代码中为数组元素赋值。 - 使用
.length获取数组的长度，注意这是一个属性，而不是方法。 - 增强的
for循环（foreach）是遍历数组时的一种简洁方式。 printArray()是一个自定义的方法，展示了如何在方法中传递和操作数组。
补充：
- Java 中的数组是对象，它们会被分配在堆内存中，且数组的大小在创建时就确定了。
2-6-1 Arrays 第一讲
在 Java 中，java.util.Arrays 类提供了许多静态方法，用于操作数组。它简化了数组的各种常见操作，如排序、赋值、比较等。对于数组的常规操作，直接使用这些方法会比手动编写代码更加简洁和高效。
代码解析
package com.nix.text;
import java.util.Arrays; // 导入 Arrays 类
// 2-6-1 Arrays 第一讲
public class Main {
public static void main(String[] args) {
// 普通的静态数组，缺陷：长度是固定的，不能扩容，没有灵活性
// int[] arr = {1, 2, 3, 4, 5};
// for (int i = 0; i <arr.length ; i++) {
// System.out.println("arr = " + arr[i]);
// }
// Arrays 类
// java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。
// 具有以下功能：
// 给数组赋值：通过 fill 方法。
// 对数组排序：通过 sort 方法, 按升序。
// 比较数组：通过 equals 方法比较数组中元素值是否相等。
// 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找操作。
int[] arr_1 = {1431, 23, 523, 4, 5, 234, 65, 98};
// 使用 Arrays.sort() 对数组进行排序（按升序排序）
Arrays.sort(arr_1);
// 打印排序后的数组
for (int element : arr_1) {
System.out.println(element);
}
}
}
代码说明：
1. 导入 Arrays 类
import java.util.Arrays;
Arrays类是 Java 中专门用于操作数组的工具类。它提供了多种静态方法，如sort()、fill()、equals()和binarySearch()等，简化了数组的操作。
2. 排序数组
Arrays.sort(arr_1);
Arrays.sort()是对数组进行排序的静态方法，默认按升序排序。该方法使用了 双轴快速排序 或 归并排序（具体的排序算法取决于数组的大小和类型）。arr_1数组被排序后，数组中的元素从小到大排列。
3. 打印排序后的数组
for (int element : arr_1) {
System.out.println(element);
}
- 通过增强的
for循环（即foreach循环），遍历排序后的数组，并输出每个元素。
Arrays 类的常用方法：
Arrays.sort()：对数组进行排序。对数值数组，它会按升序排序。- 示例：
Arrays.sort(arr_1);
- 示例：
Arrays.fill()：给数组中的每个元素赋值。- 示例：
Arrays.fill(arr_1, 0);// 将数组arr_1中的每个元素都设置为0。
- 示例：
Arrays.equals()：比较两个数组的元素是否相同（按元素顺序逐一比较）。- 示例：
Arrays.equals(arr_1, arr_2);// 返回true如果两个数组的元素完全相同。
- 示例：
Arrays.binarySearch()：对排序数组进行二分查找。如果数组未排序，结果不确定。- 示例：
Arrays.binarySearch(arr_1, 5);// 查找5在arr_1中的索引位置。
- 示例：
Arrays.toString()：将数组转换为字符串，方便打印。- 示例：
System.out.println(Arrays.toString(arr_1));
- 示例：
示例输出：
4
5
23
65
98
234
523
1431
这是数组 arr_1 排序后的结果，按升序排列。
总结：
Arrays类提供了一些非常实用的静态方法，帮助你简化数组的操作，如排序、填充、比较和查找。- 本例演示了如何使用
Arrays.sort()对数组进行排序，并通过增强的for循环输出排序后的数组。
2-6-2 Arrays 第二讲
在这节课中，我们将进一步学习 java.util.Arrays 类的常用方法，包括：
sort()：对数组进行排序equals()：比较两个数组的元素是否相同binarySearch()：在排序数组中查找元素
代码解析
package com.nix.test;
import java.util.Arrays; // 导入 Arrays 类
// 2-6-2 Arrays 第二讲
public class Main {
public static void main(String[] args) {
// 普通的静态数组，缺陷：长度是固定的，不能扩容，没有灵活性
// int[] arr = {1, 2, 3, 4, 5};
// for (int i = 0; i <arr.length ; i++) {
// System.out.println("arr = " + arr[i]);
// }
// Arrays 类
// java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。
// 具有以下功能：
// 给数组赋值：通过 fill 方法。
// 对数组排序：通过 sort 方法, 按升序。
// 比较数组：通过 equals 方法比较数组中元素值是否相等。
// 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找操作。
// sort
int[] arr_1 = {1431, 23, 523, 4, 5, 234, 65, 98};
Arrays.sort(arr_1); // 对数组 arr_1 进行排序
// 打印排序后的数组
for (int element : arr_1) {
System.out.println(element);
}
// equals 比较两个数组是否相等（顺序也必须相同）
int[] arr_2 = {1, 2, 3};
int[] arr_3 = {1, 2, 3};
boolean result = Arrays.equals(arr_2, arr_3); // 判断 arr_2 和 arr_3 是否相等
System.out.println("数组中的元素值是否相等：" + result);
// binarySearch 二分查找
// 二分查找要求数组必须是已排序的
int result_index = Arrays.binarySearch(arr_1, 5); // 查找元素 5 在 arr_1 中的位置
System.out.println("result_index = " + result_index); // 输出查找结果的索引
}
}
代码说明：
1. Arrays.sort()
Arrays.sort(arr_1);
Arrays.sort()用于对数组进行排序。排序的顺序是 升序。它采用的是 快速排序 或 归并排序，具体取决于数组的大小和类型。- 本例中，数组
arr_1被排序后，数组元素从小到大排列。
排序后的数组输出：
4
5
23
65
98
234
523
1431
2. Arrays.equals()
boolean result = Arrays.equals(arr_2, arr_3);
-
Arrays.equals()用于比较两个数组是否相等。数组相等的标准是：
- 数组的 长度相同。
- 数组的 元素相同 且顺序一致。
-
如果两个数组的元素和顺序都相同，返回
true，否则返回false。
输出结果：
数组中的元素值是否相等：true
3. Arrays.binarySearch()
int result_index = Arrays.binarySearch(arr_1, 5);
Arrays.binarySearch()是用于在已排序数组中查找特定元素的索引。注意：使用此方法之前，数组必须是排序过的，否则结果无法确定。- 如果找到了元素，返回该元素的索引；如果没有找到，返回一个负数，表示该元素如果存在，则应该插入的位置。
输出结果：
result_index = 1
这里，数组 arr_1 排序后为 [4, 5, 23, 65, 98, 234, 523, 1431]，元素 5 在索引位置 1。
总结：
Arrays.sort()：对数组进行排序。Arrays.equals()：比较两个数组是否完全相同（顺序一致且元素相同）。Arrays.binarySearch()：在已排序的数组中查找元素，返回元素的索引位置。
这些方法使得数组的操作变得更加高效和方便，尤其是当你需要对数组进行排序、查找或比较时，使用 Arrays 类提供的这些方法可以大大简化代码。
2-7-1 函数和方法
在 Java 中，函数和方法的概念是非常相似的。实际上，Java 中并没有单独的“函数”这个概念，所有的函数都是定义在类中的，并且必须使用 方法 的形式进行定义和调用。因此，Java 中的函数通常叫做“方法”。
代码解析
package com.nix.demo;
// 2-7-1 函数和方法
public class Main {
public static void main(String[] args) {
int age = 10; // 定义一个整型变量 age，值为 10
}
// 函数 -> 方法
public static void addMoney(int numberA, int numberB) {
// 方法体，两个整型参数 numberA 和 numberB，暂时没有实现功能
}
}
代码详细解释
-
类定义
public class Main {- Java 中的所有代码都必须包含在类中，这个类的名字是
Main，它是我们程序的入口点。
- Java 中的所有代码都必须包含在类中，这个类的名字是
-
main方法public static void main(String[] args) { int age = 10; }main方法是 Java 程序的入口点，是程序启动时首先执行的方法。public：该方法可以被外部调用（例如 Java 虚拟机（JVM）调用）。static：静态方法，不需要实例化类就可以直接调用。void：该方法没有返回值。String[] args：命令行参数。
-
方法定义
public static void addMoney(int numberA, int numberB) { }addMoney是一个静态方法，接收两个参数numberA和numberB，但没有实现任何功能。void：该方法没有返回值。int numberA, int numberB：这两个是方法的参数，表示将传入的整数值。
总结
- 函数和方法：在 Java 中，我们使用“方法”这个术语，表示在类中定义的具有特定功能的代码块。虽然其他编程语言（如 C）称其为“函数”，但在 Java 中无论是否是静态方法，都会被称为“方法”。
main方法：这是 Java 程序的启动方法，所有的 Java 应用程序都必须有一个main方法。- 方法的定义：方法定义时，可以指定返回类型（如
int,String），如果不需要返回值，则使用void，并且方法可以带有参数。
2-7-2 方法的重载
在 Java 中，方法重载（Method Overloading）指的是在同一个类中，允许存在多个方法具有相同的名称，但它们的参数个数或参数类型必须不同。需要注意的是，方法的返回值类型不能成为重载的区分标准，即不能仅通过返回类型的不同来重载方法。
代码解析
package com.nix.demo;
// 2-7-2 方法的重载
// (允许函数名可以一样，允许返回值类型和参数类型不一样)
// 一是方法名（函数）相同， 二是参数个数或参数类型不相同
public class Main {
public static void main(String[] args) {
// 调用不同参数的方法
int sum_1 = sum(1, 2); // 调用sum(int, int)
System.out.println("sum_1 = " + sum_1);
double sum_2 = sum(1.1, 2.2); // 调用sum(double, double)
System.out.println("sum_2 = " + sum_2);
int sum_3 = sum(1, 2, 3); // 调用sum(int, int, int)
System.out.println("sum_3 = " + sum_3);
}
// 参数类型和个数不一样，方法名相同
public static int sum(int x, int y) {
return x + y;
}
public static double sum(double x, double y) {
return x + y;
}
public static int sum(int x, int y, int z) {
return x + y + z;
}
}
代码详细解释
-
方法重载的定义：
-
在 Java 中，允许定义多个名称相同的方法，这些方法通过参数类型或参数个数的不同来区分。例如，
sum方法有多个版本：
- 一个接受两个整数参数。
- 一个接受两个浮点数参数。
- 一个接受三个整数参数。
-
-
main方法中的调用：int sum_1 = sum(1, 2); // 调用sum(int, int) System.out.println("sum_1 = " + sum_1); double sum_2 = sum(1.1, 2.2); // 调用sum(double, double) System.out.println("sum_2 = " + sum_2); int sum_3 = sum(1, 2, 3); // 调用sum(int, int, int) System.out.println("sum_3 = " + sum_3);sum(1, 2)会调用sum(int, int)方法，返回3。sum(1.1, 2.2)会调用sum(double, double)方法，返回3.3。sum(1, 2, 3)会调用sum(int, int, int)方法，返回6。
-
重载规则：
- 方法名相同：重载的方法必须有相同的方法名（在本例中是
sum）。 - 参数个数或类型不同：方法重载的关键是方法的参数个数或参数类型必须不同。即使返回类型不同，Java 也不会认为这是重载。
- 返回类型不参与重载：如果两个方法的返回类型不同，但参数类型和个数相同，Java 会报错，因为不能仅仅根据返回类型来区分重载的方法。
- 方法名相同：重载的方法必须有相同的方法名（在本例中是
-
方法签名：
- 方法签名是方法名和参数类型、顺序的组合。在 Java 中，方法重载是通过方法签名来区分的。
总结
- 方法重载使得一个类可以有多个同名方法，便于代码的简洁和易读。重载的方法必须有不同的参数个数或参数类型。
- 在方法重载中，返回类型不能作为重载的区分条件。
2-8-1 规范约束第一讲
在本节中，提到的“规范约束”主要指的是 编程规范 或 代码约定，这对于开发团队和整个项目的维护至关重要。规范的目的是提高代码的可读性、可维护性和一致性。
阿里巴巴Java开发手册（华山版）
阿里巴巴Java开发手册是国内广泛使用的Java开发规范之一，涵盖了编码风格、最佳实践、安全性建议、性能优化等方面。通过遵循这些规范，团队能够确保项目代码的一致性，减少潜在的错误，提升开发效率。
主要规范约束的一些示例：
- 命名规范：
- 类名采用大驼峰命名法（例如：
MyClass）。 - 方法名采用小驼峰命名法（例如：
getUserName()）。 - 常量使用全大写字母和下划线分隔（例如：
MAX_LENGTH）。
- 类名采用大驼峰命名法（例如：
- 代码格式：
- 每个代码块之间应使用适当的缩进，通常使用 4 个空格进行缩进，避免使用 tab 键。
- 每行代码不超过 120 个字符，以确保代码清晰易读。
- 控制语句（如
if、for等）后应有一个空格，且大括号应与语句放在同一行。
- 注释规范：
- 类和方法的注释要简洁明了，并使用 JavaDoc 格式。
- 对复杂的逻辑代码要进行必要的注释，帮助后人理解和维护。
- 异常处理：
- 异常类应该明确，捕获异常时应该具体化捕获的异常类型，而不是捕获所有的异常（例如：
catch (Exception e)）。 - 在捕获异常时，应该记录异常的详细信息，避免遗漏。
- 异常类应该明确，捕获异常时应该具体化捕获的异常类型，而不是捕获所有的异常（例如：
- 常用设计模式和实践：
- 单例模式：在需要控制某个类的实例化次数时，使用单例模式（例如：
public class Singleton）。 - 接口与实现分离：当涉及到接口与类实现时，要优先定义接口，降低耦合度。
- 避免硬编码：尽量避免在代码中直接写死值，使用常量或配置文件代替。
- 单例模式：在需要控制某个类的实例化次数时，使用单例模式（例如：
下一步的学习建议
若要深入理解和掌握这些规范，可以参考以下学习资源：
- 阿里巴巴Java开发手册：阅读并逐步实现手册中推荐的代码规范。
- Java代码审查工具：使用一些静态代码检查工具（如 Checkstyle、PMD、SonarQube）来自动化检查代码是否符合规范。
- 参与代码评审：定期参与团队的代码评审，以实际项目为基础实践代码规范。
通过遵循这些规范，能够有效提高代码质量和团队的开发效率。
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
