【学习笔记】黑马程序员Java课程学习笔记（更新至第12章---集合）

1. Java概述

1.1 Java语言发展史

Java语言是美国Sun公司（Stanford University Network）在1995年推出的计算机语言， 2009年Oracle甲骨文公司收购Sun公司。Java之父：詹姆斯·高斯林（James Gosling）。

1.2 Java语言跨平台原理

Java可以在任意操作系统上运行，Windows、Mac、Linux。我们只需要在运行Java应用程序的操作系统上，安装一个与操作系统对应的Java虚拟机（JVM Java Virtual Machine）就可以实现Java的跨平台使用了。

1.3 JRE和JDK

（1）JRE（Java Runtime Environment） 是Java程序的运行时环境，它包括JVM和运行时所需要的核心类库。需要注意的是，JRE是包含JVM的，因此只安装JRE也是可以实现Java的跨平台使用的。
（2）JDK（Java Development Kit） 是Java程序的开发工具包，包含JRE和开发人员使用的工具。其中的开发工具包括：编译工具（javac.exe）和运行工具（java.exe）。如果想开发一个全新的Java程序，必须安装JDK。
（3）JDK、JRE和JVM的关系 由下图我们可以看出，JDK包含JRE，JRE包含JVM。对于开发人员来说，我们只需要使用JDK就可以满足一切开发和应用的需求。

1.4 JDK和Eclipse的下载和安装

（1）在这里，我引用了另一位博主的安装教程 ：eclipse安装教程（2021最新版）超级易懂到吐血
（2）JDK的安装目录及说明：**

2. 基础语法

2.1 注释

（1）什么是注释：注释是在程序指定位置添加的说明性信息。注释不参与程序运行，仅起到说明作用。

（2）注释的分类：

注释类别	格式
单行注释	// 注释信息
多行注释	/* 注释信息 */
文档注释	/** 注释信息 */

（3）示例

/*
	Java程序中最基本的组成单位是类。
	类的定义格式：
		public class 类名{
		
		}
	这是定义的HelloWorld类
*/
public class HelloWorld{
	/*
		这是main方法
		main方法是程序的入口，代码的执行是从main方法开始的
	*/
	public static void main(String[] args) {
		// 这是输出语句，“”里面的内容是可以改变的
		System.out.println("HelloWorld");
	}
}

2.2 关键字

（1）概念：关键字是被Java赋予了特定含义的单词。
（2）特点：
    *关键字的字母全部小写；
    *常用的代码编辑器，针对关键字有特殊的颜色标记，非常直观

2.3 常量

（1）概念：在程序运行过程中，其值不可以发生改变的量。
（2）常量分类：

2.4 数据类型

（1）计算机存储单元：计算机存储设备的最小信息单元是“位（bit）”，又称为比特位，常用小写字母“b”表示。计算机中最小的存储单元是“字节（byte）”，通常用大写字母“B”表示，字节是由连续的8个位组成。其他常用的存储单位如下：
    1B = 8bit；
    1KB = 1024B；
    1MB = 1024KB；
    1GB = 1024MB；
    1TB = 1024GB
（2）数据类型：Java语言是强类型语言，对于每一种数据都给出了明确的数据类型，不同的数据类型也分配了不同的内存空间，所有它们表示的数据大小也是不一样的。

（3）数据类型内存占用和取值范围：

2.5 变量

（1）概念：变量是在程序运行过程中，其值可以改变的量。从本质上讲，变量是内存中一小块区域。
（2）变量定义：数据类型 变量名 = 变量值； 例如，int a = 10;
（3）变量的使用：包括取值和修改值。

public class VariableDemo{
	public static void main(String[] args){
		//定义变量
		int a = 10;

		//输出变量
		System.out.println(a);

		//修改变量
		a = 20;
		System.out.println(a);
}
}

（4）变量使用的注意事项：
    *变量名称不能重复；
    *变量必须先赋值再使用；
    *long类型变量定义的时候，为了防止整数过大，后面要加L；
    *float类型变量定义的时候，为了防止类型不兼容，后面要加F。

2.6 标识符

（1）概念：标识符是给类、方法、变量等起名字的符号。

（2）标识符定义规则：
    *由数字、字母、下划线和美元符组成；
    *不能以数字开头；
    *不能是关键字；
    *要区分大小写

（3）常见命名约定：
  *小骆峰命名法：方法、变量
     **约定1：标识符是一个单词的时候，首字母小写；
     **约定2：标识符由多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写；

  *大骆峰命名法：类
     **约定1：标识符是一个单词的时候，首字母大写；
     **约定2：标识符由多个单词组成的时候，每个单词的首字母大写；

2.7 类型转换

（1）类型转换分类：自动类型转换；强制类型转换

（2）自动类型转换：把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。
例如：double d = 10;

（3）强制类型转换：把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量。
例如：int k = (int)88.88

3. 运算符

3.1 算数运算符

3.1.1 运算符

运算符是对常量或者变量进行操作的符号。

3.1.2 表达式

用运算符把常量或者变量连接起来符合java语法的式子即为表达式。不同运算符连接的表达式体现的是不同类型的表达式。
   例如：int a =10; int b = 20; int c = a + b;
   +：是运算符，并且是算术运算符；a + b：是表达式，由于+是算术运算符，所以这个表达式称为算术表达式。

示例：

/*
	算术运算符
*/
public class OperatorDemo1{
	public static void main(String[] args){
		//定义两个变量
		int a = 6;
		int b = 4;

		System.out.println(a + b);			# out>>10
		System.out.println(a - b);			# out>>2
		System.out.println(a * b);			# out>>24
		System.out.println(a / b);			# out>>1
		System.out.println(a % b);			# out>>2
		//除法得到的是商，取余得到的是余数

		//整数相除只能得到整数，要想得到小数，必须有浮点数的参与
		System.out.println(6.0 / 4);	 	# out>>1.5
}
}

3.1.3 字符的 ‘+’ 操作

字符的 ‘+’ 操作是字符在计算机底层对应的数值来进行计算的。

算术表达式中包含多个基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。

提升规则：
  *byte类型，short类型和char类型将被提升到int类型；
  *整个表达式的类型自动提示到表达式中最高等级操作数同样的类型
  等级顺序：byte, short, char ->int->long->float->

3.1.4 字符串的 ‘+’ 操作

（1）当 ‘+’ 操作中出现字符串时，这个 ‘+’ 是字符串连接符，而不是算术运算；
（2）在 ‘+’ 操作中，如果出现了字符串，就是连接运算符，否则就说算术运算。当连续进行 ‘+’ 操作时，从左到右逐个执行。

示例：

/*
字符串的 ‘+’ 操作
*/
public class OperatorDemo03{
	public static void main(String[] args){
		System.out.println("it" + "heima");			# out>>itheima
		System.out.println("itheima" + "666");		# out>>itheima666
		System.out.println("666" + "itheima");		# out>>666itheima

		System.out.println("黑马" + 6 + 66);		# out>>黑马666
		System.out.println(1 + 99 + "年黑马");		# out>>100年黑马
	}
}

3.2 赋值运算符

3.3 自增自减运算符

3.4 关系运算符

3.5 逻辑运算符

概念：逻辑运算符是用来连接关系表达式的运算符，也可以直接连接布尔类型的常量或变量。

3.6 短路运算符

注意：
（1）逻辑与&，无论左边真假，右边都要执行。
（2）短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。
（3）逻辑或|，无论左边真假，右边都要执行。
（4）短路或|，如果左边为假，右边执行；如果左边为真，右边不执行。

3.7 三元运算符

格式：关系表达式？表达式1：表达式2

计算规则：首先计算关系表达式的值，如果值为true，表达式1的值就是运算结果；如果值为false，表达式2的值就是运算结果。

示例：

/*
	三元运算符
*/
public class OperatorDemo{
	public static void main(String[] args){
	//定义两个变量
	int a = 10;
	int b = 20;
	
	//获取两个数据中的较大值
	int max = a > b ? a : b;
	
	//输出结果
	System.out.println("max:" + max);			# out>>max:20
	}
}

4. 数据输入

Scanner使用的基本步骤：
（1）导包：import java.util.Scanner;           导包的动作必须出现在类定义的上边
（2）创建对象：Scanner sc = new Scanner(System.in);   这里面只有sc是变量名，可以改变。其他的都不能变
（3）接收数据：int i = sc.nextInt();             上面这个格式，只有i是变量名，可以变，其他都不能变
（4）示例：

/*
	数据输入：
		（1）导包：
				import java.util.Scanner;
		（2）创建对象：
				Scanner sc = new Scanner(System.in);
		（3）接收数据：
				int x = sc.nextInn();
*/
import java.util.Scanner;

public class ScannerDemo{
	public static void main(String[] args){
	//创建对象
	Scanner sc = new Scanner(System.in);

	//接收数据
	int x = sc.nextInt();

	//输出数据
	System.out.println("x:" + x);
	}
}

5. 分支语句

5.1 流程控制

流程控制语句分类：（1）顺序结构；（2）分支结构（if, switch）；（3）循环结构(for, while, do…while)

5.2 顺序结构

概念：顺序结构是程序中最简单、最基本的流程控制，没用特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

5.3 if语句

（1）格式1：

if (关系表达式){
	语句体；
}

执行流程：
首先计算关系表达式的值；
如果关系表达式的值为true，则执行语句体；
如果关系表达式的值为false就不执行语句体；
继续执行后面的语句内容。

（2）格式2：

if (关系表达式){
	语句体1；
}else{
	语句体2；
}

执行流程：
首先计算关系表达式的值；
如果关系表达式的值为true，则执行语句体1；
如果关系表达式的值为false，则执行语句体2；
继续执行后面的语句内容。

（3）格式3：

if (关系表达式1){
	语句体1;
}else if(关系表达式2){
	语句体2;
}
···
else{
	语句体n+1;
}

执行流程：
（1）首先计算关系表达式的值；
（2）如果关系表达式的值为true，则执行语句体1；
（3）如果关系表达式的值为false，则执行语句体2；
（4）继续执行后面的语句内容。

5.4 switch语句

格式：

switch(表达式){
case 值1：
			语句体1;
			break;
case 值2：
			语句体2；
			break;
···
default：
			语句体n+1;
			[break;]
}

格式说明：
（1）表达式：取值为byte, short, int, char, string.
（2）case：后面跟的是要和表达式进行比较的值。
（3）break：表示中断，结束的意思，用来结束switch语句。
（4）default：表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。

6. 循环语句

6.1 for 循环语句

格式：

for (初始化语句;条件判断语句;条件控制语句){
	循环体语句;
}

执行流程：
（1）执行初始化语句；
（2）执行条件判断语句，看其结果是true还是false，如果是false，循环结束，如果是true，继续执行；
（3）执行循环体语句；
（4）执行条件控制语句；
（5）回到（2）继续。

6.2 while 循环语句

格式：

初始化语句;
while (条件判断语句){
	循环体语句;
	条件控制语句;
}

执行流程：
（1）执行初始化语句；
（2）执行条件判断语句，看其结果是true还是false，如果是false，循环结束，如果是true，继续执行；
（3）执行循环体语句；
（4）执行条件控制语句；
（5）回到（2）继续。

6.3 do…while 循环语句

格式：

初始化语句;
do{
	循环体语句;
	条件控制语句;
}while(条件判断语句);

执行流程：
（1）执行初始化语句；
（2）执行循环体语句；
（3）执行条件控制语句；
（2）执行条件判断语句，看其结果是true还是false，如果是false，循环结束，如果是true，继续执行；
（5）回到（2）继续。

6.4 三种循环的区别

三种循环的区别：
（1）for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）；
（2）do…while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）。

for和while的区别：
（1）条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问了；
（2）条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用。

死循环格式：
（1）for(; ; ){}
（2）while(true){}
（3）do{}while(true);

6.5 Random

作用： 产生一个随机数。

使用步骤：
（1）导包：import java.util.Random;
（2）创建对象：Random r = new Random();
（3）获取随机数：int number = r.nextInt(10); //获取数据的范围：[0,10]，包括0，不包括10

示例：

/*
	Random
*/
import java.util.Random

public class RandomDemo{
	public static void main(String[] args){
		//创建对象
		Random r = new Random();
	
		//用循环获取10个随机数
		for(int i=0; i<10; i++){
			//获取随机数
			int number = r.nextInt(10);
			System.out.println("number:" + number);
		
		//需求：获取一个1-100之间的随机数
		int x = r.nextInt(100) + 1;
		System.out.println(x);
		}
	}
}

7. IDEA

7.1 IDEA概述

（1）IDEA概述：IDEA全称IntelliJ IDEA，是用于Java语言开发的集成环境，是业界公认的目前用于Java程序开发最好的工具。
是可以把代码编写、编译、执行、调试等多种功能综合到一起的开发工具。
（2）IDEA的下载和安装： 参考这篇博客：IDEA的下载和使用安装

7.2 IDEA中HelloWorld

步骤：
（1）创建一个空项目（JavaSE_Code）
（2）创建一个新模块（idea_test）
（3）在idea_test模块下的src下创建一个包（com.itheima）
（4）在com.itheima包下新建一个类（Helloworld）
（5）在Helloworld类中编写代码
（6）在idea中执行程序

7.3 IDEA中项目结构

Project–>模块–>包–>类

7.4 IDEA中内容辅助键和快捷键

（1）快速生成语句：
快速生成main()方法：psvm，回车
快速生成输出语句：sout，回车

（2）内容辅助键：
ctrl+alt+space，内容提示，代码补全等

（3）快捷键：
注释：
  单行：选中代码，ctrl+/
  多行：选址代码，ctrl+shift+/

格式化：
  ctrl+alt+L

8. 数组

8.1 数组定义格式

概念：数组（array）是一种用于存储多个相同类型数据的存储模型

数组的定义格式：
（1）格式1：数据类型[ ] 变量名，例如：int [ ] arr。定义了一个int类型的数组，数组名是arr。
（2）格式2：数据类型 变量名[ ]， 例如：int arr[ ]。定义了一个int类型的变量，变量名是arr数组。

8.2 数组初始化之动态初始化

初始化：就说为数组中的数组元素分配内存空间，并为每个数组元素赋值。

数组初始化类型：动态初始化、静态初始化

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。

动态初始化格式：数据类型 [ ] 变量名 = new 数据类型[数组长度]，例如：int [] arr = new int[3]

示例：

public class ArrayDemo{
	public static void main(String[] args){
	int[] arr = new int[3]
	/*
	左边：
		int：说明数组中的元素是int类型
		[]：说明这是一个数组
		arr：这是数组的名称
	右边：
		new：为数组申请内存空间
		int：说明数组中的元素类型是int类型
		[]：说明这是一个数组
		3：数组长度，其实就说数组中的元素个数
	}
}

8.3 数组元素访问

数组变量访问方式：数组名

数组内部保存数据的访问方式：数组名[索引]

什么是索引：索引是数组中数据的编号方式，用于访问数组中的数据使用，数组名[索引]等同于变量名，是一种特殊的变量名。注意：索引是从0开始的、索引是连续的、索引逐一增加，每次加1。

示例：

public class ArrayDemo{
	public static void main(String[] args){
	int[] arr = new int[3]
	
	//输出数组名
	System.out.println(arr);		# out>> [i@880ec60 内存地址

	//输出数组中的元素
	System.out.println(arr[0]);		# out>> 0
	System.out.println(arr[0]);		# out>> 0
	System.out.println(arr[0]);		# out>> 0
	}
}

8.4 Java中内存分配

8.5 数组初始化之静态初始化

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

格式1：数据类型 [ ] 变量名 = new 数据类型[ ] {数据1， 数据2， 数据3， …}，例如：int [ ] arr = new int[ ] {1, 2, 3};

格式2：数据类型 [ ] 变量名 = {数据1， 数据2， 数据3， …}，例如：int [ ] arr = {1, 2, 3};

8.6 数组操作的两个常见小问题

（1）索引越界
（2）空指针异常

8.7 数组常见操作

** 遍历**：for循环 + 数组名.length

示例：

public class ArrayTest01{
	public static void main(String[] args){
		//定义数组
		int[] arr = {1 , 2, 3, 4, 5};
		
		//使用通用的遍历格式
		for(int x=0; x<arr.length; x++){
			System.out.println(arr[x]);
		}
	}
}

9. 方法

9.1 方法概述

概念：方法（Method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集。
注意：
（1）方法必须先创建才可以使用，该过程称为方法定义；
（2）方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为方法调用。

9.2 方法的定义和调用

方法定义与调用：

// 方法定义
public static void method_name(){
	//方法体
}

//方法调用
method_name()

示例：

public class MethodDemo
{
	public static void main(String[] args)
	{
		//调用方法
		isEvenNumber();
	}
	
	//需求：定义一个方法，在方法中定义一个变量，判断该数据是否是偶数
	public static void isEvenNumber()
	{
		//定义变量
		int number = 10;
		number = 9;
		
		//判断该数是否是偶数
		if(number%2 ==0)
		{
			System.out.println(true);	
		}
		else
		{
			Systm.println(false);
		}
	}
}

9.3 带参数方法的定义和调用

带参数方法定义：

（1）格式： public static void 方法名(参数){... ...}
（2）格式（单个参数）：public static void 方法名(数据类型 变量名){... ...}
（3）格式（多个参数）：public static void 方法名（数据类型 变量名1, 数据类型 变量名2, ......）{... ...}

注意
（1）方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错；
（2）方法定义时，多个参数之间使用逗号分隔。

带参数方法调用：

（1）格式：方法名(参数)；
（2）格式（单个参数）：方法名(变量名/常量值)；
（3）格式（多个参数）：方法名(变量名1/常量值1， 变量名2/常量值2);

注意：
（1）方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错。

形参和实参：

形参：方法定义中的参数，等同于变量定义格式；
实参：方法调用中的参数，等同于使用变量或常量

9.3 方法的注意事项

（1）方法不能嵌套定义
（2）void表示无返回值，可以省略return，也可以单独书写return，后面不加数据。

（3）方法的通用格式：

public static 返回值类型 方法名(参数)
{
	方法体；
	return 数据;
}
其中：
public static----修饰符，目前先记住这个格式
返回值类型--------方法操作完毕之后返回的数据的数据类型
方法名------------调用方法的时候使用的标识
参数--------------由数据类型和变量名组成，多个参数之间使用逗号隔开
方法体------------完成功能的代码块
return-----------如果方法操作完毕，有数据返回，用于把数据返回给调用者

（4）定义方法时需要注意：

明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没用，写void；如果有，写对应的数据类型；
明确参数：主要是明确参数的类型和数量

（5）调用方法时需要注意：

void类型的方法可以直接调用；
非void类型的方法，推荐用变量接收调用；

9.4 方法重载

方法重载概念：方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载：
（1）多个方法在同一个类中；
（2）多个方法具有相同的方法名；
（3）多个方法的参数不相同，类型不同或者数量不同。

方法重载特点：
（1）重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式；
（2）重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判断两个方法是否相互构成重载。

示例;

/*
	方法重载：
		多个方法在同一个类中；
		多个方法具有相同的方法名；
		多个方法的参数不相同，类型不同或者数量不同

		与返回值无关，在调用方法的时候，Java虚拟机会通过参数的不同来区分同名的方法
*/
public class MethoDemo
{
	public static void main(String[] args)
	{
		//调用方法
		int result = sum(a:10, b:20);
		System.out.println(result);
		
		double result2 = sum(a:10.0, b:20.0);
		System.out.println(result2);

		int reslult3 = sum(a:10, b:20, c:30);
		System.out.println(result3);
		
	//需求1：求两个int类型数据和的方法
	public static int sum(int a, int b)
	{
		return a + b;
	}

	//需求2：求两个double类型数据和的方法
	public static int sum(double a, double b)
	{
		return a + b;
	}

	//需求3：求三个int类型数据和的方法
	public static int sum(int a, int b, int c)
	{
		return a + b + c;
	}
}

9.5 方法的参数的传递

（1）对于基本数据类型的参数，形参的改变，不影响实际参数的值。

（2）对于引用类型的参数，形参的改变，影响实际参数的值。

10 面向对象基础

10.1 类和对象

1. 什么是对象：万物皆对象，客观存在的事物皆为对象。
2. 什么是对象的属性： 对象具有的各种特征，每个对象的每个属性都拥有特定的值。
3. 什么是对象的行为： 对象能够执行的操作。

4. 什么是类：类是对现实生活中一类具有共同属性和行为的事物的抽象，确定对象将会拥有的属性和行为。类是JAVA程序的基本组成单位。
  类的特点：
  （1）类是对象的数据类型；
  （2）类是具有相同属性和行为的一组对象的集合。
5. 类和对象的关系：类是对象的抽象，对象是类的实体。

6. 类的组成：属性和行为。
  属性：在类中通过成员变量来体现（类中方法外的变量）
  行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）

7. 类的定义：

public calss 类名{
	// 成员变量
	变量1的数据类型 变量1;
	变量2的数据类型 变量2;
	...
	//成员方法
	方法1;
	方法2;
	...
}

8. 对象的使用:
  （1）创建对象：类名 对象名 = new 类名();
  （2）使用对象：使用成员变量：对象名.变量名；使用成员方法：对象名.方法名()

10.2 成员变量和局部变量

1. 成员变量：类中方法外的变量。
2. 局部变量：类中方法中的变量。

public class Student{
	String name;					// 成员变量

	public void study(){
		int i = 0;					// 局部变量
		System.out.println('Good good study!');
	}

	int age;						// 成员变量
}

3. 成员变量和局部变量的区别：

10.3 封装

10.3.1 private关键字

作用：private是一个关键字；它可以修饰成员（成员变量和成员方法）；作用是保护成员不被别的类使用，被private修饰的成员只能在本类中才能访问。
使用：针对private修饰的成员变量，如果需要被其他类使用，应提供相应的操作。
（1）提供 get变量名() 方法，用于获取成员变量的值，方法用public修饰；
（2）提供 set变量名(参数)方法，用于设置成员变量的值，方法用public修饰。

public class Student{
	//成员变量
	String name;
	private int age;

	//提供get/set方法
	public void setAge(int a){
		if (a<0 || a>120){
			System.out.println("你给的年龄有误");
		}else{
			age = a;
		}
	}
	
	public int getAge(){
		return age;
	}

}

10.3.2 this关键字

（1）this修饰的变量用于指代成员变量。
    方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量；
    方法的形参没用与成员变量同名，不带this修饰的变量指的是成员变量。
（2）this代表所在类的对象引用。方法被哪个对象调用，this就代表哪个对象。

10.3.3 封装

1. 封装概述：封装是面向对象三大特征之一（封装、继承、多态），是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的。
2. 封装原则：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供对应的getXxx() / setXxx()方法。
3. 封装优点：通过方法来控制成员变量的操作，提高了代码的安全性。把代码用方法进行封装，提高了代码的复用性。

10.3.4 构造方法

概念：构造方法是一种特殊的方法，用于创建对象，功能是完成对数据的初始化。
格式：

public class 类名{
	修饰符 类名(参数){
	}
}

注意事项：
（1）构造方法的创建：如果没有定义构造方法，系统将给出一个默认的无参数构造方法；如果定义了构造方法，系统将不再提供默认的构造方法。
（2）构造方法的重载：如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法。
（3）推荐的使用方式：无论是否使用，都手工书写无参数构造方法。

10.3.5 标准类的制作

（1）成员变量：使用private修饰
（2）构造方法：提供一个无参构造方法、提供一个带多个参数的构造方法。
（3）成员方法：提供每一个成员变量对应的setXxx() / getXxx()；提供一个显示对象信息的show()。
（4）创建对象并为其成员变量赋值的两种方式：无参构造方法创建对象后使用setXxx()赋值；使用带参构造方法直接创建带有属性值的对象。

public class Student{
	// 成员变量
	private String name;
	private int age;

	// 构造方法
	public Student() {}

	public Student(String name, int age){
		this.name = name;
		this.age = age;
	}

	// 成员方法
	public void setName(String name){
		this.name = name;
	}

	public String getName(){
		return name;
	}

	public void setAge(){
		this.age = age;
	}
	
	public int getAge(){
		return age;
	}

	public void show(){
		System.out.println(name + "," + age);
	}

}

public class StudentTest{
	public static void main(String[] args){
		// 无参数构造方法创建对象后使用setXxx()赋值
		Student s1 = new Student();
		s1.setName("Kobe");
		s1.setAge("24");
		s1.show();

		// 使用带参构造方法直接创建带有属性值的对象
		Student s2 = new Student(name:"Kobe", age:24);
		s2.show();

	}

}

11. String

String类在java.lang包下，所以使用的时候不需要导包。

11.1 String构造方法

11.2 案例：用户登录

package string;

import java.util.Scanner;

public class string001 {
    public static void main(String[] args){
         // 已知用户名和密码
        String username = "Kobe";
        String password = "24&8";

        // 用循环实现多次机会，这里的次数明确，采用for循环实现
        for(int i=0; i<3; i++){

            // 键盘要录入登录的用户名和密码，用Scanner实现
            Scanner sc = new Scanner(System.in);

            System.out.println("请输入用户名：");
            String name = sc.nextLine();

            System.out.println("请输入密码：");
            String pwd = sc.nextLine();

            // 用键盘录入的用户名和密码和已知的用户名和密码进行比较，并给出相应的提示
            if (username.equals(name) && password.equals(pwd)){
                System.out.println("登录成功");
                break;
            } else{
                if ((2-i) == 0){
                    System.out.println("登录失败，你的账号已被冻结！");
                } else{
                    System.out.println("用户名或密码输入错误，你还有" + (2-i) + "次输入机会！");
                }
            }
        }
    }
}

11.3 案例：遍历字符串

package string;

import java.util.Scanner;

public class string002 {
    public static void main(String[] args){
        // new一个Scanner对象接收输入的字符串
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();

        // 定义for循环，用charAt()方法遍历字符串
        for (int i=0; i< line.length(); i++){
            System.out.println(line.charAt(i));
        }
    }

11.4 StringBuilder

11.4.1 StringBuilder概述

StringBuilder是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是StringBuilder对象中的内容是可变的。

11.4.2 String和StringBuilder的区别

String的内容是不可变的；StringBuilder的内容是可变的。

11.4.3 StringBuilder构造方法

package string;

/*
    StringBuilder构造方法：
        public StringBuilder():创建一个空白可变字符串对象，不含有任何内容。
        public StringBuilder(String str):根据字符串的内容，来创建可变字符串对象。
 */

public class string003 {
    public static void main(String[] args){
        // public StringBuilder()
        StringBuilder sb = new StringBuilder();
        System.out.println("sb:" + sb);
        System.out.println("sb.length():" + sb.length());

        // public StringBuilder(String str)
        StringBuilder sb2 = new StringBuilder("hello");
        System.out.println("sb2:" + sb2);
        System.out.println("sb2.length():" + sb2.length());
    }
}

11.4.4 StringBuilder的添加和反转方法

package string;

/*
    StringBuilder的添加和反转方法：
        pubic StringBuilder append(任意类型)：添加数据，并返回对象本身；
        public StringBuilder reverse(): 返回相反的字符序列
 */

public class string004 {
    public static void main(String[] args){
        // 创建对象
        StringBuilder sb = new StringBuilder();

        // 链式编程
        sb.append("hello ").append("world ").append("!");
        System.out.println("sb: " + sb);

        // public StringBuilder reverse():返回相反的字符序列
        sb.reverse();
        System.out.println("sb: " + sb);
    }
}

11.4.5 StringBuilder 和 String 的相互转换

1. StringBuilder转换为String

public String toString()：通过toString()就可以实现把StringBuilder转换为String。

2. String转换为StringBuilder
public StringBuilder(String s):通过构造方法就可以实现把String转换为StringBuilder。

package string;

public class string005 {
    public static void main(String[] args){
        // 先创建一个对象
        StringBuilder sb = new StringBuilder();
        sb.append("hello");

        // 将StringBuilder转换为String
        String s = sb.toString();
        System.out.println(s);

        // 将String转换为StringBuilder
        StringBuilder s2 = new StringBuilder(s);
        System.out.println(s2);
    }
}

11.4.6 案例：拼接字符串

需求：定义一个方法，把int数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果。例如，数组为int [] arr = {1, 2, 3}; ，执行方法后的输出结果为：[1,2,3]。

public class string006 {
    public static void main(String[] args){
        int[] arr = {1,2,3,4,5};

        //调用方法，用一个变量接收结果
        String s = array2string(arr);          // 对数组的格式进行转换

        // 输出结果
        System.out.println(s);


    }

    public static String array2string(int[] arr){
        // 在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回。
        StringBuilder sb = new StringBuilder();         // new一个StringBuilder对象

        sb.append('[');

        for (int i=0; i<arr.length; i++){
            if(i == arr.length-1){
                sb.append(arr[i]);
            }
            else{
                sb.append(arr[i]).append(',');              // 这里不可以用 + 号来拼接字符串
            }
        }

        sb.append(']');

        String s = sb.toString();

        return s;
    }
}

11.4.7 案例：字符串反转

需求：定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果。例如，键盘录入abc，输出结果cba。

import java.util.Scanner;

public class string007 {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();

        // 调用方法，传入输入的字符串，返回反转后的字符串
        String s = reverse(line);

        System.out.println(s);
    }

    public static String reverse(String s){
        StringBuilder sb = new StringBuilder(s);
        String reverse_s = sb.reverse().toString();

        return reverse_s;
        // 简便的语句：return new StringBuilder(s).reverse().toString();
    }
}

12. 集合

12.1 集合基础

集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以发生改变。集合类有很多，本章着重介绍：ArrayList。
**ArrayList：是可调整大小的数组实现。是一种特殊的数据类型，泛型。

12.2 ArrayList构造方法和添加方法

12.3 ArrayList集合常用方法