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>>10System.out.println(a - b);           # out>>2System.out.println(a * b);            # out>>24System.out.println(a / b);           # out>>1System.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>>itheimaSystem.out.println("itheima" + "666");     # out>>itheima666System.out.println("666" + "itheima");      # out>>666itheimaSystem.out.println("黑马" + 6 + 66);       # out>>黑马666System.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.Randompublic 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>> 0System.out.println(arr[0]);      # out>> 0System.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转换为StringString s = sb.toString();System.out.println(s);// 将String转换为StringBuilderStringBuilder 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集合常用方法

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

1. 黑马程序员Java教程学习笔记（五）

   学习视频:https://www.bilibili.com/video/BV1Cv411372m 如侵权,请私信联系本人删除 文章目录 黑马程序员Java教程学习笔记(五) 日期时间:Date.Sim ...

2. 黑马程序员Java教程学习笔记（三）

   学习视频:https://www.bilibili.com/video/BV1Cv411372m 如侵权,请私信联系本人删除 文章目录 黑马程序员Java教程学习笔记(三) 面向对象:设计对象.注意事 ...

3. 黑马程序员 JAVA基础学习笔记

   ------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- ------小弟在因特网的小窝,祝愿所有的朋友身体健康------- 面向对象: 就是更加透明, ...

4. 黑马程序员-JAVA基础学习日志——通篇大总结及学习方法思想

   ------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- Java基础知识总结 回首是为了更好向前,天空没有翅膀的痕迹,而我已飞过,人总是这样,害怕回首, ...

5. 2023年黑马程序员Java学习路线图

   2023年Java学科免费学习资源放送40+套课程,超过600小时的内容! 在过去的一年里,为了帮助更多人线上充电,学会更多技能,黑马程序员举办了 150+ 场免费直播公开课,新增精品视频教程 80+ ...

6. 黑马程序员_java自学学习笔记(八)----网络编程

   黑马程序员_java自学学习笔记(八)----网络编程 android培训. java培训.期待与您交流! 网络编程对于很多的初学者来说,都是很向往的一种编程技能,但是很多的初学者却因为很长一段时间无 ...

7. 【黑马程序员新版Linux学习笔记】Linux系统实用操作命令——操作演示

   [黑马程序员新版Linux学习笔记]Linux 零基础快速入门: (一)Linux基本命令--操作演示 (二)Linux用户和权限 -- 操作演示 (三)Linux 小技巧快捷键 (四)Linux系统 ...

8. 黑马程序员 c++视频学习详细笔记 下载地址

   黑马程序员 c++视频学习详细笔记 下载地址: https://download.csdn.net/download/m0_47891203/84348174 建议结合博主博文学习

9. SSM 框架学习（黑马程序员）

   (Spring+SpringMVC+MyBatis) SSM框架教程 黑马程序员最全SSM框架教程|Spring+SpringMVC+MyBatis全套教程 01. Spring 简介 1.1 Spr ...

10. 黑马程序员——c语言学习心得——函数传递二维数组

    黑马程序员--c语言学习心得--函数传递二维数组 -------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 一.定义指针的时候一定要初始化.    变量 ...

最新文章

1. EEG伪影详解和过滤工具的汇总(二)
2. SQL语言之DDL语言学习-----数据定义语言学习
3. KAFKA分布式消息系统
4. 为什么自己编写的页面总是在那里抖动_「内存抖动」？别再吓唬面试者们了行吗...
5. rf框架的缺点_2017热门开源自动化测试框架优缺点对比
6. Apache Commons DbUtils 入门
7. 【python】整理的 Python 库
8. Linux 启动过程剖析
9. NLP --- 文本分类(基于LDA的隐语意分析训练算法详解)
10. 上传文件实时显示网速怎么实现_“双11”来了！三亚1487个5G基站带你拼网速_政务_澎湃新闻...
11. python3 zip()函数笔记
12. 客户需求分析工具-$APPEALS
13. java 实现打印机_JAVA实现连接本地打印机并打印文件的实现代码
14. java计算两个时间差的方法_java计算两个时间相差天数的方法汇总
15. 如何打开注册表编辑器
16. 微信外部链接无法使用浏览器打开 微信链接打不开的解决方案
17. 读书笔记：《群论彩图版》
18. Android 手机录制wav格式音频文件实现
19. Electron渲染页面(Renderer Process)引入ipcRenderer
20. aspose将word转换为pdf[aspose.word.java 18.11]

热门文章

1. 嗑药简史：咖啡上瘾，喝还是不喝？
2. CF 815C 树形背包
3. Android下拉状态栏快捷开关的添加
4. mysql 死锁分析_【mysql】MySQL知识整理-死锁分析-性能优化等
5. 修复iPhone系统白苹果问题
6. canvas图片合成
7. 人际关系差不能当跳槽理由，原因在这里
8. 视频格式720P、1080i 和 1080P
9. Pull Request 到底是什么意思
10. 双非大学计算机专业有不考408,2020河北大学计算机专业课改考408