java学习笔记

最新推荐文章于 2024-07-23 21:45:09 发布

圆圆的肚子

最新推荐文章于 2024-07-23 21:45:09 发布

阅读量994

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_52332769/article/details/117078238

版权

文章目录

第一章 Java概述

1.1 什么是Java语言

Java语言是美国Sun公司（sun Microsystems公司)，在1995年推出的高级编程语言。所谓编程语言，是计算机的语言，人们可以使用编程语言对计算机下达命令，让计算机完成人们需要的功能。

1.2 Java语言发展史

●1995年Sun公司发布Java1.0版本
●1997年发布Java 1.1版本
●1998年发布Java 1.2版本
●2000年发布Java 1.3版本
●2002年发布Java 1.4版本
●2004年发布Java 5版本
●2006年发布Java 6版本
●2009年Oracle甲骨文公司收购Sun公司，并于201 1发布Java 7版本
●2014年发布Java 8版本
●2017年9月发布Java 9版本
●2018年3月发布Java 10版本

2004年JAVA5.0更新密度非常大，让JAVA进入了发展的快车道。

2014年JAVA8.0是公司中使用最多的版本。

2018年9月JAVA11.0是我们学习JAVA基础使用的版本

1.3 JVM

1.JAVA可以在任意操作平台上运行。在需要运行JAVA应用程序的操作系统上，安装一个与操作系统对应的JAVA虚拟机JVM （JAVA Virtual Machine)即可。

1.4 JRE和JDK

JRE（Java Runtime Environment）是Java程序的运行时环境，包含JVM和运行时所需要的核心类库。我们想要运行一个已有的Java程序，那么只需安装JRE即可。
JDK（Java Development Kit）是Java程序开发工具包，包含JRE和和开发人员使用的工具。其中的开发工具：编译工具（javac.exe)和运行工具（java。exe）我们想要开发一个全新的Java程序，那么必须安装JDK。

第二章 HolleWorld入门程序

2.1 程序开发步骤说明

Java程序开发三步骤:编写、编译、运行。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FAMJ5ktt-1621495396997)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210426173243262.png)]

//第一行的第三个单词必须和所在的文件 名称完全-一样，大小写也要一样
// public class后面代表定义一个类的名称，类是Java当中所有源代码的基本组织单位。
public class HelloWorld {
	//第二行的内容是万年不变的固定写法，代表main方法
	//这一行代表程序执行的起点
	public   void main(String[] args) {
	//第三行代表打印输出语句(其实就是屏幕显示)|
		System. out . println("Hello, World!!!");
}

2.2 标识符

**标识符:**是指在程序中，我们自己定义内容。比如类的名字、方法的名字和变量的名字等等，都是标识符。
o HelloWorld案例中，出现的标识符有类名字Helloworld 。
**命名规则: **硬性要求

标识符可以包含英文字母26个(区分大小写)、0-9数字、 $ (美元符号)和_ (下划线)。
标识符不能以数字开头
标识符不能是关键字（关键字：完全小写的纯英文字母，有特殊颜色）

**命名规范: **软性建议

类名规范:首字母大写，后面每个单词首字母大写(大驼峰式) 。
变量名规范:首字母小写，后面每个单词首字母大写(小驼峰式)。
方法名规范:首字母小写，后面每个单词首字母大写(小驼峰式)。

第三章常量

3.1 常量的分类:

字符串常量:凡是用双引号引起来的部分，叫做字符串常量。例如: “abc”、 “Hello”、 “123”,字符串两个双引号中间的内容为空
整数常量:直接写上的数字，没有小数点。例如: 100、 200、0、-250
浮点数常量:直接写上的数字，有小数点。例如: 2.5、-3.14、 0.0
字符常量:凡是用单引号引起来的单个字符，就做字符常量。例如: ‘A’、 ‘b’、 ‘9’、‘中’, 两个单引号中间必须有且仅有一个字符，没有不行
布尔常量:只有量中取值。true、 false。
空常量: null。代表没有任何数据。空常量不能打印

public class Demo01Const {
	public static void main(String[] args) {
		//字符串常量
		System.out. println("ABC");
		System. out. println(""); //字符串两个双引号中间的内容为空
		System. out . println("XYZ");
        
		//整数常量
		System. out. println(30);
		System. out. println( -500);
        
		//浮点数常量(小数)
		System. out . println(3.14);
		System. out . println(-2.5);
		
        //字符常量
		System.out. println('A');
		System. out. println('6');
		// System. out . println('"'); //两个单引号中间必须有且仅有一个字符，没有不行。
		// System. out . println('AB'); //两个单引号中间必须有且仅有一个字符，有两个不行。
		
        //布尔常量
		System. out. println(true); 
		System. out. println(false);
		
        //空常量。空常量不能直接用来打印输出。
		// System. out. println(nu1l);
}

第四章变量和数据类型

4.1 变量概述

4.1.1 变量:常量是固定不变的数据，那么在程序中可以变化的量称为变量。

数学中，可以使用字母代替数字运算,例如x=1+5或者6=x+5。
程序中，可以使用字母保存数字的方式进行运算，提高计算能力，可以解决更多的问题。比如x保存5，x也可以保存6，这样x保存的数据是可以改变的，也就是我们所讲解的变量。
Java中要求一个变量每次只能保存一个数据，必须要明确保存的数据类型。

4.1.2 注意事项：

如果创建多个变量，那么变量之间的名称不可以重复。

对于float和long类型来说，字母后缀F和L不要丢掉。

如果使用byte或者short类型的变量，那么右侧的数据值不能超过左侧类型的范围。
没有进行赋值的变量，不能直接使用;一定要赋值之后，才能使用。

变量使用不能超过作用域的范围。
[作用域] :从定义变量的一行开始，一直到直接所属的大括号结束为止。

4.2 数据类型的分类

Java的数据类型分为两大类:

●基本数据类型: （数字为字节数）（四种八类）

整型 : byte(1) short(2) int(4)(默认) long(8) （二进制存储）

浮点数: float(4 ) double(8)（默认）（存储采用科学计数，近似存储）

字符: char（2）（范围：0~65535，可直接存储汉字）

布尔: boolean（1）
●引用数据类型: 类、数组、接口、字符串、Lambda。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R1HncCwc-1621495396999)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210426223045674.png)]

注意事项:

字符串不是基本类型，而是引用类型。
浮点型可能只是一一个近似值，并非精确的值。
数据范围与字节数不一定相关，例如float数据范围比long更加广泛，但是float是4字节，long是8字节。
浮点数当中默认类型是double。如果一定要使用float类型，需要加上一个后缀F。
整数，默认为int类型，如果一定要使用long类型，需要加上一个后缀L。推荐使用大写字母后缀。

第五章数据类型转换

Java程序中要求参与的计算的数据，必须要保证数据类型的一致性，如果数据类型不一致将发生类型的转换。

5.1 自动转换

特点:代码不需要进行特殊处理，自动完成。
规则:数据范围从小到大。(保存数值范围的大小)

/*当数据类型不一样时，将会发生数据类型转换。

自动类型转换(隐式)
	1.特点:代码不需要进行特殊处理，自动完成。
	2.规则:数据范围从小到大。(保存数值范围的大小)
	
强制类型转换(显式)*/
public class Demo01DataType {
	public static void main(String[] args) {
		System. out. println(1024); //这就是一个整数，默认就是int类型
		System . out.println(3.14); //这就是一个浮点数，默认就是double类型
		//左边是long类型，右边是默认的int类型，左右不一样
		//一个等号代表赋值，将右侧的int常量，交给左侧的long变量进行存储
		// int --> long， 符合了数据范围从小到大的要求
		//这一行代码发生了自动类型转换。
		long num1 = 100;
		System . out. println(num1); // 100
		//左边是double类型，右边是float类型，左右不一样
		// float --> double, 符合从小到大的规则
		//也发生了 自动类型转换
		double num2 = 2.5F;
		System. out . println(num2); // 2.5
		//左边是float类型，右边是long类型，左右不一样
		// long --> float, 范围是float更大一些， 符合从小到大的规则
		// 也发生了 自动类型转换
    }
}

5.2 强制转换

特点:代码需要进行特殊的格式处理，不能自动完成。(如未转换则报错)

int i = 2.5 （浮点型范围大于整型，所以赋值错误）

int i = （int）2.5 强制类型转换
格式:范围小的类型范围小的变量名 = (范围小的类型) 原本范围大的数据;
主意事项:
1.强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出。

/*强制类型转换
1.特点:代码需要进行特殊的格式处理，不能自动完成。
2.格式:范围小的类型范围小的变量名= (范围小的类型)原本范围大的数据;
*/
public class Demo02DataType {
	public static void main(String[] args) {
		//左边是int类型，右边是long类型，不一样
		// long --> int, 不是从小到大
		//不能发生自动类型转换!
		//格式:范围小的类型范围小的变量名 = (范围小的类型)原本范围大的数据;
		int num = (int) 100L;
		System. out. println(num);
        
        // long强制转换成为int类型
        int num2 = 60000000000;//赋值错误（超出int范围）
		int num2 = (int) 6000000000L;//int最多存2147483647，数据溢出
		System. out. println(num2); // 1705032704 I
    }
}

5.3 运算符

注意事项：

对于一个整数的表达式来说，除法用的是整除，整数除以整数，结果仍然是整数。只看商，不看余数。I
只有对于整数的除法来说，取模运算符才有余数的意义。
一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ADAxS0pQ-1621495397000)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210427163717632.png)]

注意 byte short char 运算时先提升至int型在运算

四则运算当中的加号 “+” 有常见的三种用法:
1.对于数值来说，那就是加法。
2.对于字符char类型来说，在计算之前，char会被提升成为int,然后再计算。
char类型字符，和int类型数字，之间的对照关系表: ASCII、 Unicode
3.对于字符串String (首字母大写，并不是关键字)来说，加号代表字符串连接操作。
任何数据类型和字符串进行连接的时候，结果都会变成字符串

5.4 比较运算符

注意事项:

比较运算符的结果一定是一个boolean值，成立就是true,不成立就是false
如果进行多次判断，不能连着写。
- 数学当中的写法，例如:1< x< 3
- 程序当中[不允许]这种写法。

5.5 逻辑运算符（链接多个boolean 值）

与(并且) && 全都是true,才是true;否则就是false
或(或者) || 至少一个是true,就是true; 全都是false, 才是false
非(取反) ！本来是true,变成false; 本来是false,变成true

与“&&”，或“||”，具有短路效果:如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，从而节省一定的性能。

注意事项:

逻辑运算符只能用于boolean值。
与、或 需要左右各自有一个boolean值，但是取反只要有唯一的一个boolean值即可。
与、或两种运算符，如果有多个条件，可以连续写。
两个条件:条件A &&条件B
条件:条件A &&条件B &&条件C

5.6 三元运算符

格式:
数据类型变量名称=条件判断?表达式A:表达式B;
流程:
首先判断条件是否成立:
如果成立为true,那么将表达式A的值赋值给左侧的变量;
如果不成立为false,那么将表达式B的值赋值给左侧的变量;
二者选其-一。

注意事项:

必须同时保证表达式A和表达式B都符合左侧数据类型的要求。
三元运算符的结果必须被使用。

第六章方法入门

6.1 概述

我们在学习运算符的时候，都为每个运算符单独的创建一个新的类和main方法，我们会发现这样编写代码非常的繁琐，而且重复的代码过多。能否避免这些重复的代码呢，就需要使用方法来实现。
.方法:就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。当我们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。（类似于c语言的定义函数，使代码模块化）

6.2 方法的定义

定义一个方法的格式:

public static void 方法名称() {
方法体

}

方法名称的命名规则和变量一样，使用小驼峰。
方法体: 也就是大括号当中可以包含任意条语句。

注意事项:

方法定义的先后顺序无所谓。
方法的定义不能产生嵌套包含关系。
方法定义好了之后，不会执行的。如果要想执行，一定要进行方法的[调用]。

补充

对于byte/ short/char三种类型来说，如果右侧赋值的数值没有超过范围，
那么javac编译器将会自动隐含地为我们补上-一个(byte)( short)(char)。
//int–>byte,不是自动类型转换
byte num1 = /* (byte) */ 30; //右侧没有超过左侧的范围
1.如果没有超过左侧的范围，编译器补上强转。
2.如果右侧超过了左侧范围，那么直接编译器报错。

编译器的常量优化：

/*在给变量进行赋值的时候，如果右侧的表达式当中全都是常量，没有任何变量，
那么编译器javac将会直接将若干个常量表达式计算得到结果。
short result = 5 + 8; //等号右边全都是常量，没有任何变量参与运算编译之后，得到的.class字节码文件当中相当于[直接就是] :
short result = 13;(编译后直接将常量相加)
右侧的常量结果数值，没有超过左侧范围，所以正确。

这称为“编译器的常量优化”。

但是注意:一旦表达式当中有变量参与，那么就不能进行这种优化了。| T
*/
public class Demo13Notice {
	public static void main(String[] args) {	
		short num1 = 10;//正确写法，右侧没有超过左侧的范围，
		
        short a = 5;
		short b = 8;
		// short + short --> int + int --> int
		// short result = a + b; //错误写法!左侧需要是int类型

        //右侧不用变量，而是采用常量，而且只有两个常量，没有别人
		short result = 5 + 8;
		System.out.println(result);
		short result2 = 5 + a + 8;//18
}

第七章流程控制（和c语言基本一样）

switch语句使用的注意事项:

多个case后面的数值不可以重复。
switch后面小括号当中只能是下列数据类型:
基本数据类型: byte/ short/char/int
引用数据类型: String字符串、enum枚举

第八章开发工具intellij IDEA

8.1 开发工具概述

IDEA是一个专门针对Java的集成开发工具(IDE),由Java语言编写。所以，需要有JRE运行环境并配置好环境变量。
它可以极大地提升我们的开发效率。可以自动编译，检查错误。在公司中，使用的就是IDEA进行开发。

8.2 项目结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t80gWRR4-1621495397002)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210427214520227.png)]

8.3 IDEA常用快捷键

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P8WR03pS-1621495397003)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210427223728314.png)]

第八章方法

方法其实就是若干语句的功能集合。 （与c不同，定义在main函数后的方法不需要提前声明）

Java中各类修饰符的使用总结(https://blog.csdn.net/u012723673/article/details/80613557)

8.1 方法的定义格式

8.1.1 定义方法的完整格式:

修饰符返回值类型方法名称 (参数类型参数名称，…){
方法体
return返回值;

}

修饰符: 现阶段的固定写法，public（访问控制修饰符） static（非访问控制修饰符）
返回值类型: 也就是方法最终产生的数据结果是什么类型
方法名称: 方法的名字，规则和变量- -样，小驼峰
参数类型: 进入方法的数据是什么类型
参数名称: 进入方法的数据对应的变量名称
PS: 参数如果有多个，使用逗号进行分隔
方法体: 方法需要做的事情，若干行代码
roturn: 两个作用，第一停止当前方法，第二将后面的返回值还给调用处
返回值: 也就是方法执行后最终产生的数据结果
return后面的“返回值”，必须和方法名称前面的“返回值类型”，保持对应。

8.2方法的三种调用格式。

单独调用:方法名称(参数);
打印调用: System. out. println(方法名称(参数));
赋值调用:数据类型变量名称=方法名称(参数);

注意:
此前学习的方法，返回值类型固定写为void,这种方法只能够单独调用，不能进行打印调用或者赋值调用。|
心:

8.2.1 注意事项：

函数返回值可不被接受使用（第47行），即该调用点被丢弃

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DR1qc6Kx-1621495397004)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210428175352908.png)]

8.3 方法使用注意事项

方法应该定义在类当中，但是不能在方法当中再定义方法。不能嵌套。
方法定义的前后顺序无所谓。
方法定义之后不会执行，如果希望执行，- -定要调用:单独调用、打印调用、赋值调用。
如果方法有返回值，那么必须写上“return返回值;”，不能没有。
return后面的返回值数据，必须和方法的返回值类型，对应起来。
对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。
对于void方法当中最后一行的return可以省略不写。
一个方法当中可以有多个return语句，但是必须保证同时只有一个会被执行到（下面代码会报错，与c不同）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5l084IgW-1621495397004)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210428200847951.png)]

8.4 方法重载

对于功能类似的方法来说，因为参数列表不-样，却需要记住那么多不同的方法名称，太麻烦。

方法的重载(Overload) : 多个方法的名称一样，但是参数列表不一样。

好处:只需要记住唯一一个方法名称，就可以实现类似的多个协能。

在调用输出语句的时候，println方法其实就是进行了多种数据类型的重载形式。

解释： 一个方法名可匹配多组方法，不同的个数的参数的录入，ＩＤＥＡ自动匹配与之对应的方法，但参数个数不得没有定义

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WRvJnI1y-1621495397005)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210428203316416.png)]

方法重载与下列因素相关：

参数个数不同
参数类型不同
参数的多类型顺序不同

方法重载与下列因素无关:

与参数的名称无关
与方法的返回值类型无关

第九章数组

9.1 数组的概念

数组的概念: 是一-种容器，可以同时存放多个相同类型数据值。

数组的特点:

数组是一种引用数据类型
数组当中的多个数据，类型必须统一
数组的长度在程序运行期间不可改变

9.2 数组的初始化

数组的初始化: 在内存当中创建一个数组，并且向其中赋予一些默认值。

两种常见的初始化方式:

1.动态初始化(指定长度)

2.静态初始化(指定内容)

动态初始化数组的格式:

数据类型 [] 数组名称 = new 数据类型 [数组长度];

int [] = array;
```
  	array  = new  int  [100];
```

静态初始化初始化的格式

基本格式: 数据类型[] 数组名称 = new 数据类型[] {元素1,元素2，… };

int [] array;

array = new int [] {元素1，元素2 …};
**省略格式:**数据类型[] 数组名称= {元素1,元素2,};

注意事项:

静态初始化没有直接指定长度，但是仍然会自动推算得到长度。
静态初始化标准格式可以拆分成为两个步骤。
动态初始化也可以拆分成为两个步骤。
静态初始化一旦使用省略格式，就不能拆分成为两个步骤了。

使用建议： 如果不确定数组当中的具体内容，用动态初始化;否则，已经确定了具体的内容,用静态初始化。

解析含义:

左侧数据类型:也就是数组当中保存的数据，全都是统一的什么类型
左侧的中括号:代表我是一个数组
左侧数组名称:给数组取-个名字
右侧的new:代表创建数组的动作
右侧数据类型:必须和左边的数据类型保持-致
右侧中括号的长度: 也就是数组当中，到底可以保存多少个数据，是一个int数字

9.3 访问数组元素进行获取

使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值。 规则如下:

如果是整数类型，那么默认为0;
如果是浮点类型，那么默认为0.0;
如果是字符类型，那么默认为’\u0000’;（一个不可见的字符，不是空格）
如果是布尔类型，那么默认为false;
如果是引用类型，那么默认为null。

注意事项:

静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成为了大括号当中的具体数值。（先等于默认值，再等于大括号中的值）

9.4 java中的内存的划分

Java的内存需要划分成为5个部分:

1.栈(Stack) : 存放的都是方法中的局部变量。方法的运行一定要在栈当中。

局部变量:方法的参数，或者是方法{}内部的变量
作用域: -一旦超出作用域，立刻从栈内存当中消失。

2.堆(Heap) : 凡是new出来的东西，都在堆当中。

堆内存里面的东西都有一个地址值: 16进制
堆内存里面的数据，都有默认值。规则:同上

3.方法区(Method Area) 静态存储区（static storage） : 存储.class相关信息，包含方法的信息。

4.本地方法栈(Native Method Stack) :与操作系统相关。

5.寄存器(pc Register) : 与CPU相关。

9.1.1 一个数组内存图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3qQrGFaV-1621495397006)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210429171256171.png)]

9.1.2 两个数组的内存图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7A9YUjx5-1621495397006)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210429171839601.png)]

常见问题：所有的引用类型变量，都可以赋值为一个null值。但是代表其中什么都没有。（起标记作用）

数组必须进行new初始化才能使用其中的元素。

如果只是赋值了一个null,没有进行new创建。

那么将会发生:

空指针异常 NullPointerException

原因:忘了new

解决:补上new（给地址分配内存）

9.5 获取数组长度

int len = 数组名.length;

数组名称.fori 自动生成遍历数组的循环

9.6 数组做方法返回值——返回地址

数组作为方法的参数，传递进去的其实是数组的地址值
数组作为方法的返回值，返回的其实也是数组的地址值。

第十章面向对象思想

10.1 面向对象思想的概述

面向过程: 当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节。
面向对象: 当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事儿。

面向对象的特点：

面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化,并将我们从执行者变成了指挥者。
面向对象的语言中，包含了三大基本特征，即封装、继承和多态。

10.1.1 面向对象的好处：

易维护

采用面向对象思想设计的结构,可读性高,由于继承的存在,即使改变需求,那么维护也只是在局部模块,所以维护起来是非常方便和较低成本的.
质量高

在设计时,可重用现有的,在以前的项目的领域中已被测试过的类使系统满足业务需求并具有较高的质量.
效率高

在软件开发时,根据设计的需要对现实世界的事物进行抽象,产生类.使用这样的方法解决问题,接近于日常生活和自然的思考方式,势必提高软件开发的效率和质量.
易扩展

由于继承,封装,多态的特性,自然设计出高内聚,低耦合的系统结构,使得系统更灵活,更容易扩展,而且成本较低.

10.2 类和对象

环顾周围，你会发现很多对象，比如桌子，椅子,同学,老师等。桌椅属于办公用品，师生都是人类。那么什么是类呢?什么是对象呢?

10.2.1 什么是类

类: 是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。

现实中，描述一类事物:

属性: 就是该事物的状态信息。
**行为:**就是该事物能够做什么。

举例: 小猫。

属性: 名字、体重、年龄、颜色。

行为: 走、跑、叫。

10.2.2 什么是对象

10.3 类的定义

10.3.1 事物与类的对比：

现实世界的一类事物:

属性: 事物的状态信息。

行为: 事物能够做什么。

Java中用class（类）描述事物也是如此:

成员变量:对应事物的属性

成员方法:对应事物的行为

10.3.2 类的定义格式：

public class ClassName{
    //成员变量（类的属性）
    //成员方法（类的行为）
}

定义类: 就是定义类的成员，包括成员变量和成员方法。
**成员变量: ** 和以前定义变量几乎是一样的。只不过位置发生了改变,直接定义在类当中。在类中,方法外。
成员方法: 和以前定义方法几乎是一样的。只不过把static去掉，static的作用在面向对象后面课程中再详细
讲解。

package dome01;

/*
定义一个类，用来模拟“学生"事物。其中就有两个组成部分: .

属性(是什么)
	姓名
	年龄
行为(能做什么):
	吃饭.
	睡觉
	学习

对应到Java的类当中:

成员变量(属性) :
	String name; //姓名
	int age; //年龄
成员方法(行为) :
	public void eat() {} //吃饭
	public void sleep() {} //睡觉
	public void study() {} //学习
	
注意事项:
1。成员变量是直接定义在类当中的，在方法外边。
2.成员方法不要写static关键字。
*/

public class Student {
    //成员变量
    int name;//姓名
    int age;//年龄

    //成员方法
    public void eat(){
        System.out.println("吃饭饭！");
    }
    public void sleep(){
        System.out.println("睡觉觉！");
    }
    public void study(){
        System.out.println("学习！");
    }
}

10.4 对象的创建及使用

通常情况下，一个类并不能直接使用（静态方法可直接使用，不用创建对象），需要根据类创建一个对象，才能使用。

创建对象流程： 先声明对象，为对象分配内存空间，对对象初始化，然后才能使用对象

1.导包:也就是指出需要使用的类，在什么位置。

import 包名称.类名称;
import demo01. Student;
对于和当前类属于同一一个包的情况，可以省略导包语句不写。

2.创建，格式:

类名称对象名 = new 类名称();
Student stu = new Student();

3.使用，分为两种情况: .

使用成员变量:对象名.成员变量名
使用成员方法:对象名.成员方法名(参数)

(也就是，想用谁，就用对象名点儿谁。)

package demo01;

public class Student01 {

    public static void main(String[] args) {
        //1.导包
        //我需要使用的Student类，和我自己Student01位于同一包下，所以省略导包语句不写

        //2.创建， 格式
        类名  称对象名  = new 类名称();
        根据Student类，创建了一个名为stu的对象
        Student stu = new Student();

        // 3.使用其中的成员变量， 格式:
        //对象名.成员变量名
        System . out. println(stu.name); // null
        System. out.println(stu.age); // 0
        System. out . println("=============");
        //改变对象当中的成员变量数值内容
        //将右侧的字符串，赋值交给stu对象当中的name成员变量
        stu. name = "赵丽颖";
        stu.age = 18;
        System.out.println(stu.name); //赵丽颖
        System.out.println(stu.age); // 18
        System.out.println("============");
        // 4.使用对象的成员方法， 格式:
        //对象名.成员方法名()

    }
}

10.5 手机类练习

类的定义：

package demo02;

/*
定义一个类，用来模拟“手机”事物
属性： 品牌，价格，颜色
行为：打电话，发短信

对应类当中：
成员变量(属性)：
    String brand;//品牌
    double prince;//价格
    String color;//颜色
成员方法（行为）：
    public void call(String who){};//打电话
    public void sendMessage(){};//发短信
 */
public class Phone {
    //成员变量
    String brand;//品牌
    double prince;//价格
    String color;//颜色

    //成员方法
    public void call(String who){
        System.out.println("给" + who + "打电话");
    };//打电话
    public void sendMessage(){
        System.out.println("群发消息");
    };//发短信
    public void sendMassage02(String name, String str2){
        System.out.println("给" + name + "发信息为：" + str2);
    }
}

定义对象，类的使用：

package demo02;

public class PhoneOne {
    public static void main(String[] args){
        Phone phone = new Phone();
        phone.brand = "红米";
        phone.prince = 2799.99;
        phone.color = "白色";

        System.out.println(phone.brand);
        System.out.println(phone.prince);
        System.out.println(phone.color);

        phone.call("马瑞杰");
        phone.sendMessage();
        phone.sendMassage02("马瑞杰","你好帅啊！！！");
    }
}

10.6 一个对象的内存图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2Dm4VQ6z-1621495397007)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210507200736051.png)]

10.7 两个对象的内存图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jofgQyvM-1621495397008)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210507214305692.png)]

10.8 两个引用指向同一对象的内存

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1BgRF0kq-1621495397009)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210507214526241.png)]

10.9 面向对象的三大特点

1. 封装性：

方法就是一种封装
关键字private也是一种封装（将其限制在当前类当中）（一旦使用了private进行修饰，那么本类当中仍然可以随意访问。但是!超出了本类范围之外就不能再直接访问了。）
- 间接访问：间接访问private成员变量，就是定义一对儿Getter/Setter方法
- 必须叫setXxx或者是getXxx命名规则，对于基本类类型当中的boolean值，他的geeter方法命名为isXxx。
  - 对于Getter来说，不能有参数，返回值类型和成员变量对应;
  - 对于Setter来说，不能有返回值，参数类型和成员变量对应。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LwTxzDIZ-1621495397010)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210508210108499.png)]

//定义一个类（属于java_home java_3）package demo03;public class Student {    private String name;    private int age;    private boolean male;//是不是男人    public void setMale(boolean a){        male = a;    }    public boolean isMale(){        return male;    }    public void setName(String str){        name = str;    }    public String getName(){        return name;    }    public void setAge(int num){        age = num;    }    public int getAge(){        return age;    }}

//应用类package demo03;public class demo03Student {    public static void main(String[] args){        Student student = new Student();        student.setAge(18);        student.setName("杨怡萍");        student.setMale(false);        System.out.println("她的名字是：" + student.getName());        System.out.println("她的年龄是：" + student.getAge());        System.out.println("她的性别是：" + student.isMale());    }}

this 关键字：解决成员变量名和局部变量名分不开的情况

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7RhEHZII-1621495397011)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210508213829633.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4W9sW5Qe-1621495397011)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210508213804031.png)]

10.10 构造方法

构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。
格式:

public 类名称 (参数类型参数名称) {

方法体

}

注意事项:

构造方法的名称必须和所在的类名称完全一-样，就连大小写也要-样
构造方法不要写返回值类型，连void都不写
构造方法不能return一个具体的返回值
如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做。

public Student() {}
一旦编写了至少-一个构造方法，那么编译器将不再赠送。

//类。位置为java_home java_3package demo04;public class Person {    private int age;    private String name;    public Person(){        System.out.println("无参构造函数执行");    }    public Person(int age,String name){        System.out.println("全参构造函数执行");        this.age = age;        this.name = name;    }    public void setName(String name){        this.name = name;    }    public String getName(){        return name;    }    public void setAge(int age){        this.age = age;    }    public int getAge(){        return age;    }}

package demo04;public class Demo04Person {    public static void main(String[] args){        Person person01 = new Person();        Person person02 = new Person(18,"女朋友！");        System.out.println("她的年龄是：" + person02.getAge() + "她是我的：" + person02.getName());        System.out.println("============================");        person02.setAge(19);        person02.setName("小泽玛利亚");        System.out.println("她的年龄是：" + person02.getAge() + "她是我的女朋友：" + person02.getName());    }}

10.11 定义一个标准类

一个标准的类通常要拥有下面四个组成部分:

所有的成员变量都要使用private关键字修饰
为每一个成员变量编写一对儿Getter/Setter方法
编写一个无参数的构造方法
编写一个全参数的构造方法
这样标准的类也叫做Java Bean

//位置：java_3 package demo05;public class Student {    private int age;    private String name;    public Student() {    }    public Student(int age, String name) {        this.age = age;        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }}

package demo05;public class demo05Student {    public static void main(String[] args){        Student stu1 = new Student();        stu1.setAge(18);        stu1.setName("yyp");        System.out.println("她的名字是：" + stu1.getName() + "她的年龄是:" + stu1.getAge());        System.out.println("==================");        Student stu2 = new Student(18,"yangyiping");//可以在创建对象时完成赋值        System.out.println("她的名字是：" + stu2.getName() + "她的年龄是：" + stu2.getAge());    }}

第十一章常用API(Scanner类 Random类 Arraylist类)

11.1 API

概述：

API(Application Programming Interface),应用程序编程接口。Java API是一本程序员的字典]，是DK中提供给

我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学

习这些类如何使用即可。所以我们可以通过查询API的方式，来学习ava提供的类,并得知如何使用它们。

11.2 Scanner类

11.2.1 什么是Scanner类

一个可以解析基本类型和字符串的简单文本扫描器。

例如，以以代码使用户能够从System.in中读取-个数:

Scanner SC = new Scanner(System. in);
int i = sc.nextInt( );

备注: System.in 系统输入指的是通过键盘录入数据。

11.2.2 引用类型使用步骤

导包

使用import关键字导包，在类的所有代码之前导包，引入要使用的类型, java.lang包下的所有类无需导入。

格式:

import 包名.类名;

举例:

Scanner类的功能:可以实现键盘输入数据，到程序当中。

引用类型的一般使用步骤:

导包
- import 包路径.类名称;
- 如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写。
- 只有java. lang包下的内容不需要导包，其他的包都需要import语句。
创建：
- 类名称对象名 = new .类名称();
使用
- 对象名.成员方法名()

11.2.3 Scanner的使用步骤：

package demo01;import java.util.Scanner;//导包public class DSemo01Scanner {    
public static void main(String[] args) 
{        Scanner sc = new Scanner(System.in);//定义对象        int num = sc.nextInt();        System.out.println(num);        String str = sc.next();        System.out.println(str);    }}

获取键盘输入的一个int数字: int num = sc.nextInt();

获取键盘输入的一个字符串: String str = sc.next();

11.2.4 Scanner 练习

题目：输入两个int数字，并且求和值。

package demo01;import java.util.Scanner;public class Demo01ScannerSum {    public static void main(String[] args){        Scanner sc = new Scanner(System.in);        int num1 = sc.nextInt();        int num2 = sc.nextInt();        System.out.println("它们的和是：" + (num1 + num2));    }}

package demo01;import java.util.Scanner;public class Demo01ScannerMax {    public static void main(String[] args){        Scanner sc = new Scanner(System.in);        int num1 = sc.nextInt();        int num2 = sc.nextInt();        int num3 = sc.nextInt();        int max = num1;        if(max < num2)            max = num2;        if(max < num3)            max = num3;        System.out.println("最大值是：" + max);    }}

11.3 匿名对象的说明

(由于只对其申请空间，并未命名，所以只能使用一次，多次使用通过对象的地址对其多次操作)

创建对象的标准格式:

类名称对象名 = new 类名称();

匿名对象就是只有右边的对象，没有左边的名字和赋值运算符。

new 类名称();

注意事项:匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象。（只能通过创建时对其操作一次）

使用建议:如果确定有一个对象只需要使用唯一的一-次，就可以用匿名对象。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yjxPV7VF-1621495397012)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210509150356937.png)]

11.3.1 匿名对象作参数的参数和返回值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bEsZIPS5-1621495397013)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210509151249486.png)]

11.4 Random类的概述和基本使用

Random类用来生成随机数字。使用起来也是三个步骤:

1.导包

import java. util. Random;

2.创建

Random r = new Random(); //小括号当中留空即可

3.使用

获取一个随机的int数字(范围是int所有范围，有正负两种) : int num = r. nextInt()

package demo02;import java.util.Random;public class Demo01Random {    public static void main(String[] args){        Random r = new Random();        int num1 = r.nextInt();        System.out.println("随机数是：" + num1);            }}

package demo02;

import java.util.Random;

public class Demo02Random {
    public static void main(String[] args) {
        Random r = new Random();

        for (int i = 0; i < 13; i++) {
            int num1 = r.nextInt(10);//10表示随机数字的范围为0~9，且此数不能为负.
            System.out.println(num1);
        }
    }
}

11.5 对象数组

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yCYwZKao-1621495397014)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210510195822215.png)]

11.6. ArrayList(集合) 是一个类

数组的长度不可以发生改变。

但是ArrayL ist集合的长度是可以随意变化的。

对于ArrayList来说，有一一个尖括号**代表泛型。E表示泛型**

**泛型:**也就是装在集合当中的所有元素，全都是统一的什么类型。

注意:泛型只能是引用类型，不能是基本类型。

注意事项:

对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。

如果内容是空，得到的是空的中括号: []

创建了一个Arraylist集合，集合的名称是list,里面装的全都是String字符串类型的数据.

备注:从JDK 1.7+开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写的。

**使用：**向集合增添元素，对象名.add(添加内容);

package demo02;import java.util.ArrayList;public class Demo06ArrayList {    public static void main(String[] args) {        //创建了一个ArrayList集合，集合的名称是list,里面装的全都是String字符串类型的数据		//备注:从JDK 1.7+开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写的。        ArrayList<String> list = new ArrayList<>();        list.add("王皓炜");        list.add("杨怡萍");        list.add("马瑞杰");        list.add("小泽玛丽亚");        System.out.println(list);    }}

11.6.1 ArrayList常用方法

public boolean add(E e):向集合当中添加元素，参数的类型和泛型-致。返回值代表添加是否成功。

**备注:**对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。但是对于其他集合(今后学习)来说，add添加动作不一定成功。
public E get(int index): 从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。
public E remove(int index): 从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素。
public int size(): 获取集合的尺寸长度，返回值是集合中包含的元素个数。

package demo02;import java.util.ArrayList;public class Demo06ArrayList {    public static void main(String[] args) {        ArrayList<String> list = new ArrayList<>();        list.add("王皓炜");        list.add("杨怡萍");        list.add("马瑞杰");        list.add("小泽玛丽亚");        System.out.println(list);        String name = list.get(2);        System.out.println(name);        String whoRemove = list.remove(0);        System.out.println("被删除的人是：" + whoRemove);        System.out.println(list);        int size = list.size();        System.out.println("集合长度为：" + size);    }}

//遍历集合package demo02;import java.util.ArrayList;public class Demo07ArrayListEach {    public static void main(String[] args) {        ArrayList<String> list = new ArrayList<>();        list.add("王皓炜");        list.add("马瑞杰");        list.add("yyp");        list.add("ccr");        System.out.println(list);        for (int i = 0; i < list.size(); i++) {            System.out.println(list.get(i));        }    }}

11.6.2 ArrayList集合存储基本数据类型

如果希望向集合ArrayL ist当中存储基本类型数据，必须使用基本类型对应的“包装类”。将基本数据类型包装为引用类型

基本类型 包装类(引用类型，包装类都位于java. lang包下)
byte Byte
short Short
int Integer[特殊]
long Long
float Float
double Double
char Character[特殊]
boolean Boolean

从JDK 1.5+开始，支持自动装箱、自动拆箱。

自动装箱:基本类型–>包装类型

自动拆箱:包装类型–> 基本类型

11.6.3 ArrayList练习

//生成六个随机数，并求和package demo02;import java.util.ArrayList;import java.util.Random;public class Demo08ArrayListRandom {    public static void main(String[] args) {        Random r = new Random();        ArrayList<Integer> list = new ArrayList<>();        for (int j = 0; j < 6; j++) {            int i = r.nextInt(33) + 1;            list.add(i);        }        System.out.println(list);        int sum = list.get(0);        for (int i = 1; i < list.size(); i++) {            sum += list.get(i);        }        System.out.println(sum);    }}

//定义标准学生类package demo02;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(int age){        this.age = age;    }    public int getAge(){        return age;    }}

//创建存储对象的集合，定义六个对象并存入集合，最后遍历集合，输出package demo02;import java.util.ArrayList;public class Demo09ArrayListStudent {    public static void main(String[] args) {        ArrayList<Student> list = new ArrayList<>();        Student stu1 = new Student("马瑞杰",18);        Student stu2 = new Student("yyp",19);        Student stu3 = new Student("zzd",20);        Student stu4 = new Student("yyd",21);        Student stu5 = new Student("gww",22);        Student stu6 = new Student("lc",22);        list.add(stu1);        list.add(stu2);        list.add(stu3);        list.add(stu4);        list.add(stu5);        list.add(stu6);        for (int i = 0; i < list.size(); i++) {            System.out.println("她的名字是：" + list.get(i).getName() + "     她的年龄是：" + list.get(i).getAge());        }    }}

//定义输出方法，以{xxx@xxx@xxx}格式输出集合package demo02;import java.util.ArrayList;public class Demo10ArrayListPrint {    public static void main(String[] args) {        ArrayList<String> list = new ArrayList<>();        list.add("yyp");        list.add("mrj");        list.add("zzx");        list.add("gww");        ArrayListPrint(list);    }    public static void ArrayListPrint(ArrayList<String> list){        System.out.print("{");        for (int i = 0; i < list.size(); i++) {            if(i == list.size() - 1){                System.out.print(list.get(i) + "}");                break;            }            System.out.print(list.get(i) + "@");        }    }}

//用一个大集合存入20个随机数字，然后筛选其中的偶数元素，放到小集合当中。//要求使用自定义的方法来实现筛选。package demo02;import java.util.ArrayList;import java.util.Random;public class Demo11ArrayListReturn {    public static void main(String[] args) {        ArrayList<Integer> list1 = new ArrayList<>();        ArrayList<Integer> list2 = new ArrayList<>();        Random r = new Random();        for (int i = 0; i < 20; i++) {            list1.add(r.nextInt(100) + 1);        }        System.out.println(list1);        for (int i = 0; i < list1.size(); i++) {            if(list1.get(i) % 2 == 0)                list2.add(list1.get(i));        }        System.out.println(list2);    }}

//接上一例题package demo02;import java.util.ArrayList;import java.util.Random;public class Demo11ArrayListReturn {    public static void main(String[] args) {        ArrayList<Integer> list1 = new ArrayList<>();        Random r = new Random();        for (int i = 0; i < 20; i++) {            list1.add(r.nextInt(100) + 1);        }        System.out.println(list1);        System.out.println(getSmallList(list1));    }    public static ArrayList<Integer> getSmallList(ArrayList<Integer> list){        ArrayList<Integer> list2 = new ArrayList<>();        for (int i = 0; i < list.size(); i++) {            if(list.get(i) % 2 == 0)                list2.add(list.get(i));        }        return list2;    }}

第十二章（java_home\java_5）

12.1 字符串

12.1.1 字符串的概述和特点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eY1xy3t3-1621495397014)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210511165149468.png)]

12.1.2 字符串的构造方法和直接构造

创建字符串的常见3+1种方式。

三种构造方法:

public String(): 创建一个空白字符串，不含有任何内容。
public String(char[] array): 根据字符数组的内容，来创建对应的字符串。
public String(byte[] array): 根据字节数组的内容，来创建对应的字符串。

一种直接创建:

String str = “Hello”; //右边直接用双引号

**注意：**直接写上双引号，就是字符串对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qR8Aq0ba-1621495397015)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210511173331097.png)]

package Demo01;

import java.lang.String;

public class Demo01String {
    public static void main(String[] args) {
        String str1 = new String("");
        System.out.println("字符串为:" + str1);

        char[] array1;
        array1 = new char[] {'a', 'h', 'h', 'h'};
        String str2 = new String(array1);

        char[] array2 = {'啊','哈','哈','哈'};
        String str3 = new String(array2);

        byte[] array3 = new byte[5];//必须是字节型数组
        for (int i = 0; i < 5; i++) {
            array3[i] = (byte)(i + 97);
        }
        String str4 = new String(array3);

        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
        System.out.println(str4);

    }
}

12.1.3 字符串的常量池

在这里插入图片描述

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tYEA63of-1621495397016)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210511175235107.png)]

12.1.4 字符串的比较相关方法（equals方法）

==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法:

public boolean equals(Object obj): 参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true;否则返回false。

public boolean equalsIgnoreCase(String str):忽略大小写进行字符串的比较

注意事项:

任何对象都能用object进行接收。
equals方法具有对称性，也就是a. eqeals(b)和b. equals(a)效果-样。
如果比较双方一个常量一个变量，推荐把常量字符串写在前面。
推荐: “abc”. equals(str) 不推荐: str. equals(“abc”)

package Demo01;

public class Demo02StringEquals {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "hello";

        char[] charArray = {'h', 'e', 'l', 'l', 'o'};
        String str3 = new String(charArray);

        String str4 = "Hello";
        System.out.println(str1.equals(str2));
        System.out.println(str2.equals(str3));
        System.out.println(str3.equals("hello"));
        System.out.println("hello".equals(25));//参数可以是任何对象
        System.out.println(str4.equals(str1));
        System.out.println("=========================");

        String strA = "Java";
        String strB = "java";
        System.out.println(strA.equalsIgnoreCase(strB));
    }
}

12.1.5 字符串的获取相关的方法

String当中与获取相关的常用方法有:

public int length(): 获取字符串当中含有的字符个数，拿到字符串长度。
public String concat(String str): 将当前字符串和参数字符串拼接成为返回值新的字符串。
public char charAt(int index): 获取指定索引位置的单个字符。(索引从开始。)
public int indexOf(String str): 查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1值。

package Demo01;

public class Demo03StringGet {
    public static void main(String[] args) {
        String str1 = "hello";
        int length = str1.length();
        System.out.println(length);

        String str2 = "World";
        String str3 = str1.concat(str2);
        System.out.println(str3);

        System.out.println(str3.charAt(1));

        System.out.println(str3.indexOf("world"));
        System.out.println(str3.indexOf("abc"));
    }

}

12.1.6 字符串的截取方法

public String substring（int index）：截取从参数位置一直到字符串末尾，返回新字符串

public String substring( int begin,int end) :截取从begin开始，一直到end结束，中间的字符串。

备注：【begin， end）,包含左边，不包含右边

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-241d9fO2-1621495397016)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210511212815319.png)]

12.1.7 字符串的转换相关方法

String当中与转换相关的常用方法有:

public char[] toCharArray(): 将当前字符串拆分成为字符数组作为返回值。
public byte[] getBytes(): 获得当前字符串底层的字节数组。
public String replace(CharSequence oldString, CharSequence newString):将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。

package Demo01;import java.nio.charset.StandardCharsets;public class Demo04StringConvert {    public static void main(String[] args) {        String str1 = "abc";        char[] charArray = str1.toCharArray();        for (int j = 0; j < charArray.length; j++) {            System.out.println(charArray[j]);        }        byte[] bytes = str1.getBytes();        for (int i = 0; i < bytes.length; i++) {            System.out.println(bytes[i]);        }        String strA = "草泥马我中意你啦！草泥马";        System.out.println(strA);        String strB = strA.replace("草泥马", "永永远远！！");        System.out.println(strB);    }}

12.1.8 字符串的分割方法

分割字符串的方法:

public String[] split(String regex): 按照参数的规则，将字符串切分成为若干部分。（返回值是一个字符串数组）

注意事项:
split方法的参数其实是一个**“正则表达式”**，今后学习。
今天要注意: 如果按照英文句点“.”进行切分，必须写"\ \.”(两个反斜杠)

package Demo01;public class Demo06StringSplit {    public static void main(String[] args) {        String str1 = "aaa,bbb,ccc";        String[] array1 = str1.split(",");        for (int i = 0; i < array1.length; i++) {            System.out.println(array1[i]);        }        String str2 = "love java me";        String[] array2 = str2.split("java");        for (int i = 0; i < array2.length; i++) {            System.out.print(array2[i]);        }        System.out.println("");        String str3 = "aaa.bbb.ccc";        String[] array3 = str3.split("\\.");        for (int i = 0; i < array3.length; i++) {            System.out.println(array3[i]);        }    }}

12.1.9 字符串的练习

题目一:

定义一个方法，把数组{1,2, 3}按照指定格式拼接成一个字符串。格式参照如下: [word1#word2#word3]。

package Demo01;public class Demo07StringPractise {    public static void main(String[] args) {        int[] array = {1, 2, 3};        String str = formArrayToString(array);        System.out.println(str);    }    public static String formArrayToString(int[] array){        String str = "[";        for (int i = 0; i < array.length; i++) {            if(i == array.length - 1){                str += "word" +array[i] + "]";//只有字符串才能进行相加过程，将其更换为单个字符则添加其阿斯克码值                break;            }            str += "word" + array[i] + "#";        }        return str;    }}

题目二:
键盘输入一个字符串，并且统计其中各种字符出现的次数。

种类有:大写字母、小写字母、数字、其他

package Demo01;import java.util.Scanner;public class Demo08StringCount {    public static void main(String[] args) {        String str = new String();        Scanner sc = new Scanner(System.in);        str = sc.next();        int countUpper = 0;        int countLower = 0;        int countNumber = 0;        int countOther = 0;        char[] charArray = str.toCharArray();        for (int i = 0; i < charArray.length; i++) {            if (charArray[i] >= 'a' && charArray[i] <= 'z')                countLower++;            else if (charArray[i] >= 'A' && charArray[i] <= 'Z')                countUpper++;            else if (charArray[i] >= '0' && charArray[i] <= '9')                countNumber++;            else                countOther++;        }        System.out.println("大写字母有：" + countUpper + "\n" + "小写字母有：" + countLower + "\n" + "数字有：" + countNumber + "\n"+ "别的字符有：" + countOther);    }}

12.2 静态Static 关键字

12.2.1 静态Static 关键字概述

一旦用了static关键字，

那么这样的内容不再属于对象自己，而是属于类的，

所以凡是本类的对象，都共享同一份。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zfwBp0QC-1621495397017)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210512200530830.png)]

12.2.2 静态Static 关键字修饰成员变量

package demo02;public class Student {    private int id;//学号    private int age;//年龄    private String name;//姓名    static String room;//所在教师    private static int idCount = 0;//计数器，每new一个新对象，计数器++    public Student(String name, int age) {        this.age = age;        this.name = name;        this.id = ++idCount;    }    public static int getIdCount() {        return idCount;    }    public static void setIdCount(int idCount) {        Student.idCount = idCount;    }    public int getId() {        return id;    }    public void setId(int id) {        this.id = id;    }    public Student() {        this.id = ++idCount;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }}

package demo02;public class Demo01StaticFiled {    public static void main(String[] args) {        Student one = new Student("yyp", 18);        one.room = "软工2004";        System.out.println("姓名是：" + one.getName()                + "年龄是：" + one.getAge() + ",教室是" + one.room + "，学号是：" + Student.getIdCount());//静态方法可通过类名称直接调用        Student two = new Student("mrj", 19);        System.out.println("姓名是：" + two.getName()                + "年龄是：" + two.getAge() + ",教室是" + two.room + "，学号是：" + two.getId());    }}

12.2.3 静态Static 关键字修饰成员方法

一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。

如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。.

如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。

无论是成员变量，还是成员方法。如果有了static,都推荐使用类名称进行调用。

静态变量:类名称.静态变量
静态方法:类名称.静态方法()

注意事项:

1.静态不能直接访问非静态。
- 原因:因为在内存当中是[先]有的静态内容，[后 ]有的非静态内容。
- “先人不知道后人，但是后人知道先人。”
2.静态方法当中不能用this.
- 原因: this代表当前对象，通过谁调用的方法，谁就是当前对象。

package demo02;public class MyClass {    int num;    static int numStatic;    public void method(){        System.out.println("这是一个成员方法");        System.out.println(num);        System.out.println(numStatic);    }    public static void methodStatic(){        System.out.println("这是一个静态方法");        //静态方法不能调用非静态变量        //System.out.println(num);//报错        System.out.println(numStatic);    }}

package demo02;public class Demo02StaticMethod {    public static void main(String[] args) {        MyClass obj = new MyClass();//首先创建对象        //然后才能使用没有static关键字的内容        obj.method();        //对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用。        obj.methodStatic();//也没错，但不推荐，这种写法在编译后也会被java翻译成为“类名称.静态方法名”        MyClass.methodStatic();//正确，推荐        //对于本来当中的静态方法，可以省略类名称        myMethod();        Demo02StaticMethod.myMethod();//完全等效    }    public static void myMethod(){        System.out.println("自己的方法");    }}

12.2.4 静态Static 的内存图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0hlk4isF-1621495397018)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210512211809327.png)]

12.2.5 静态代码块

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t0hgZnyG-1621495397018)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210512212319217.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jHUp1XoY-1621495397019)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210512212400198.png)]

12.3 数组工具类Arrays

12.3.1 数组工具类Arrays

java. util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。

public static String toString(数组): 将参数数组变成字符串(按照默认格式: [元素1,元素2,元素3…])
public static void sort(数组):按照默认升序(从小到大)对数组的元素进行排序。

备注:

1如果是数值，sort默认按照升序从小到大
2.如果是字符串，sort默认按照字母升序
3.如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。 (今后学习)

12.3.2 练习

题目:

请使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印。

package demo03;

import java.util.Arrays;

public class Demo0ArraysPractise {
    public static void main(String[] args) {
        String str = "agdhfyabsuy748785";

        char[] charArray = str.toCharArray();
        Arrays.sort(charArray);
        for(int i = charArray.length - 1; i >= 0; i--){
            System.out.println(charArray[i]);
        }
    }
}

12.4 数学工具类Math

java. util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。

public static double abs(double num): 获取绝对值。有多种重载。
public static double ceil(double num): 向上取整。
public static double floor(double num): 向下取整。
public static long round(double num): 四舍五入。返回整数，不带小数点

Math.PI PI近似圆周率（double）

第十三章（java_6）

13.1 继承

13.1.1 继承的概述

继承是多态的前提
继承主要解决的问题是：共性抽取

继承关系当中的特点

1.子类可以拥有父类的“内容”；

2.子类还可以拥有自己专有的内容

父类：也可叫基类，超类。

子类：也可叫派生类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PzxSm0px-1621495397019)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210512220241403.png)]

13.1.2 继承的格式

在继承的关系中，“子类就是一个父类”。也就是说，子类可以被当做父类看待。

例如父类是员工，子类是讲师，那么“讲师就是一个员工”。关系: is-a。

定义父类的格式: (一个普通的类定义)

public class 父类名称{

// …

}

定义子类的格式:

public class 子类名称 extends 父类名称{

// …

}

package demo01;

//定义一个父类：员工
public class Employee {
    public void method(){
        System.out.println("方法执行啦！");
    }
}

package demo01;

//定义一个子类：讲师
public class Teacher extends Employee{
    public static void method1(){
        System.out.println("自己的方法执行啦");
    }
}

package demo01;

public class Demo01Extends {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.method();
        Teacher.method1();
    }
}

13.1.3 继承中访问成员变量的特点

在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式:

直接通过子类对象访问成员变量:

创建对象时，等号左边是谁，就优先用谁，没有则向上找。

间接通过成员方法访问成员变量:

该方法属于谁，就优先用谁，没有则向上找

package demo02;

public class Fu {
    int numFu = 20;

    int  num = 100;

    public void methodFu(){
        System.out.println(num);
    }
}

package demo02;

public class Zi extends Fu{
    int numZi = 20;

    int num = 200;

    public void methodZi(){
        System.out.println(num);
    }
}

package demo02;public class Demo01ExtendsFiled {    public static void main(String[] args) {        Fu fu = new Fu();        System.out.println(fu.numFu);        Zi zi = new Zi();        System.out.println(zi.numZi);        System.out.println(zi.numFu);        //等号左边是谁，就优先用谁        System.out.println(zi.num);        //方法属于谁就优先访问谁        zi.methodZi();//200        zi.methodFu();//100    }}

13.1.4 区分子类方法中重名的三种变量

两个关键字：this本类，super父类

package demo03;public class Fu {    int num = 10;}

package demo03;public class Zi extends Fu{    int num = 20;    public void method(){        int num = 30;        System.out.println(num);//30    局部变量        System.out.println(this.num);//20       本类成员变量        System.out.println(super.num);//10      父类的成员变量    }}

package demo03;/*局部变量        直接写本类的成员变量     this.成员变量名父类的成员变量     super.成员变量 */public class Demo01ExtendsFiled {    public static void main(String[] args) {        Zi zi = new Zi();        zi.method();    }}

13.1.5 继承中访问成员方法的特点

在父子类的继承关系当中，创建子类对象，访问成员方法的规则:

创建的new对象是谁，就优先用谁，如果没有则向上找。

注意事项:

无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。

13.1.6 继承中方法的覆盖重写（对父类继承来方法的功能进行修改，增添）

重写（Override）概念

概念：在继承关系当中，方法的名称一样，参数列表也一样。

重载（Overload）：方法名称一样，参数列表不一样

重写（Override）：方法名称一样，参数列表也一样。方法的覆盖，覆写。

方法的覆盖重写特点：创建的是子类对象，则优先用子类对象。
覆盖重写的注意事项：

**1.**必须保证父子类之间方法的名称相同，参数列表也相同。

@Override: 写在方法前面，用来检测是不是有效的正确覆盖重写。

这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。

**2.**子类方法的返回值必须【小于等于】父类方法的返回值范围。

小扩展提示: java. lang . Object类是所有类的公共最高父类(祖宗类)，java. lang. String就是object的子类。

**3.**子类方法的权限必须【大于等于】父类方法的权限修饰符。

小扩展提示: public > protected > (default) > private

备注: (default)不是关键字default，而是什么都不写，留空。
覆盖重写的应用场景（创建新的类对父类进行继承，优化，修改）

设计原则:
对于已经投入使用的类，尽量不要进行修改。
推荐定义一个新的类，来重复利用其中共性内
**容,**并添加改动新内容。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XHIM9AY8-1621495397020)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210513162140854.png)]

package demo06;public class Phone {    public void call() {        System.out.println("打电话");    }    public void send() {        System.out.println("发短信");    }    public void show() {        System.out.println("显示来电");    }}

package demo06;public class NewPhone extends Phone {    public void show() {        super.show();        System.out.println("显示姓名");        System.out.println("显示年龄");    }}

package demo06;public class Demo0Phone {    public static void main(String[] args) {        Phone phone = new Phone();        phone.call();        phone.send();        phone.send();        System.out.println("==================");        NewPhone newPhone = new NewPhone();        newPhone.call();        newPhone.send();        newPhone.show();    }}

13.1.7 继承中构造方法的访问特点

1.子类构造方法当中有一个默认隐含的“super()"调用，所以一定是先调用的父类构造，后执行的子类构造。

2.子类构造可以通过super关键字来调用父类重载构造。

3.super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。

总结：

**子类必须调用父类构造方法，**不写则赠送super();写了则用写的指定的super调用，super只能有一个， 还必须是

第一个语句。

父类构造的调用必须是在子类的构造函数中被调用（只有构造方法才能带调用构造方法，且一个构造方法只能调用一个构造方法）

package demo07;public class Fu {    public Fu(){        System.out.println("父类无参构造方法执行啦");    }    public Fu(int num){        System.out.println("父类含参构造方法执行啦");    }}

package demo07;public class Zi extends Fu{    public Zi(){        //super(10);//没有则便提起给你赠送一个"super(）",执行方法默认赠送的那个构造函数        super();        System.out.println("子类构造方法执行啦");    }}

package demo07;public class Demo01Constructor {    public static void main(String[] args) {        Zi zi = new Zi();    }}

13.1.8 关键字总结

super关键字的三种用法：

1.在子类的成员方法中，访问父类的成员变量。

2.在子类的成员方法中，访问父类的成员方法。

3.在子类的构造方法中，访问父类的构造方法。

this关键字的三种用法：

1.在本类的成员方法中，访问本类的成员变量。

2.在本类的成员方法中，访问本类的另一个成员方法。

3.在本类的构造方法中，访问本类的另一个构造方法。

在第三种用法当中要注意:

A. this(… )调用也必须是构造方法的第一个语句，唯一一个。

B. super和this两种构造调用，不能同时使用。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-j2f7FrLL-1621495397021)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210513170751441.png)]

13.1.9 this 和 super的图解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KTntCjWe-1621495397021)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210513172356945.png)]

（子类方法method（）中调用了父类method（））

13.1.10 java继承的三个特点

java语言是单继承的

一个类的直接父类只能有一个

java语言可以多级继承

我有一个父亲，我父亲还有一个父亲，也就是爷爷 (层层递进)

3.一个子类的直接父类是唯一的，但是一个父类可以拥有很多个子类。可以有很多个兄弟姐妹，生胎。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FI8RDfHD-1621495397022)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210513173658304.png)]

13.2 抽象

13.2.1 抽象的概念

什么叫抽象：由于概念太过迷糊，无法直接回答

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rsVPa2MB-1621495397022)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210513174318681.png)]

13.2.2 抽象方法和抽象类的格式和使用(可以存在普通方法和静态方法)

**抽象方法:**就是加上abstract关键字，然后去掉大括号，直接分号结束。

抽象类:抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。.

如何使用抽象类和抽象方法：

不能直接创建new抽象对象。
必须用一个子类来继承抽象父类
子类必须覆盖重写抽象父类当中的所有抽象方法
覆盖重写(实现):子类去掉抽象方法的abstract关键字，然后补上方法体大括号。
创建子类对象进行使用

//抽象父类package demo08;public abstract class Animal {    //这是一个抽象方法，代表吃东西，但是具体吃什么（大括号的内容）不确定    public abstract void eat();    //这是抽象类当中的一个普通方法.    public void method(){        System.out.println("这是抽象类当中的一个普通方法");    }    //这是抽象类当中的一个静态方法    public static void methodStatic() {        System.out.println("这是抽象类当中的一个静态方法");    }}

//继承抽象父类，对其抽象方法进行覆盖重写package demo08;public class Cat extends Animal{	//对抽象方法进行覆盖重写    public void eat(){        System.out.println("猫吃鱼！");    }}

package demo08;public class Demo01Main {    public static void main(String[] args) {        Cat cat = new Cat();        cat.eat();        cat.method();        Animal.methodStatic();    }}

关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多,但若理解了抽象的本质，无需死记硬背。

1.抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
- 理解: 假设创建了抽象类的对象,调用抽象的方法，而抽象方法没有具体的方法体,没有意义。
2.抽象类中，可以有构造方法，是供子类创建对象时,初始化父类成员使用的。
- 理解: 子类的构造方法中，有默认的super(),需要访问父类构造方法。
3.抽象类中，不一定包含抽象方法, 但是有抽象方法的类必定是抽象类。
- 理解:未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。
4.抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。
- **理解:**假设不重写所有抽象方法,则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义

13.2.4 继承的综合案例

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NzaLQvyu-1621495397023)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210513212200653.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hlVJ1K0Z-1621495397023)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210513212138319.png)]

//公共父类package demo09;public class User {    private String name;    private int money;    public User() {    }    public User(String name, int money) {        this.name = name;        this.money = money;    }    // 展示当前    public void show() {        System.out.println("我叫什么名字：" + name + "，我有多少钱：" + money);    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getMoney() {        return money;    }    public void setMoney(int money) {        this.money = money;    }}

//群主package demo09;import java.util.ArrayList;public class Manager extends User {    public Manager() {    }    public Manager(String name, int money) {        super(name, money);    }    public ArrayList<Integer> send(int totalMoney, int count) {        ArrayList<Integer> redList = new ArrayList<>();        int leftMoney = super.getMoney();        if (leftMoney < totalMoney) {            System.out.println("余额不足");            return redList;        }        super.setMoney(leftMoney - totalMoney);        int avg = totalMoney / count;        int mod = totalMoney % count;        for (int i = 0; i < count - 1; i++) {            redList.add(avg);        }        int last = avg + mod;        redList.add(last);        return redList;    }}

//成员package demo09;import java.util.ArrayList;import java.util.Random;public class Member extends User{    public Member(){    }    public Member(String name, int money){        super(name, money);    }    public void receive(ArrayList<Integer> list) {        int index = new Random().nextInt(list.size());        super.setMoney(super.getMoney() + list.remove(index));    }}

package demo09;import java.util.ArrayList;public class MainRedPacket {    public static void main(String[] args) {        Manager manager = new Manager("群主", 100);        Member member1 = new Member("张三", 0);        Member member2 = new Member("李四", 3);        Member member3 = new Member("yyp",52);        Member member4 = new Member("马瑞杰",66);        manager.show();        member1.show();        member2.show();        member3.show();        member4.show();        System.out.println("====================");        ArrayList<Integer> list = manager.send(33,4);        member1.receive(list);        member2.receive(list);        member3.receive(list);        member4.receive(list);        manager.show();        member1.show();        member2.show();        member3.show();        member4.show();    }}

第十四章（java_7）

14.1 接口（可以多继承）

14.1.1 接口的定义基本格式

**概述：**接口就是多个类的公共规范。

接口是一种引用数据类型，最重要的内容就是其中的:抽象方法。

如何定义一个接口的格式:

public interface 接口名称 {

// 接口内容

}

**备注:**换成了关键字interface之后，编译生成的字节码文件仍然是: .java --> .class。

如果是Java 7那么接口中可以包含的内容有:

1.只能是常量（public static final）

2.抽象方法

如果是Java 8,还可以额外包含有:

3.默认方法

4.静态方法

如果是Java 9，还可以额外包含有:

5.私有方法

14.1.2 接口的抽象方法定义和使用

定义

在任何版本的Java中，接口都能定义抽象方法。

格式:

public abstract 返回值类型方法名称(参数列表);

注意事项:

接口当中的抽象方法，修饰符必须是两个固定的关键字: public abstract
这两个关键字修饰符，可以选择性地省略。(今天刚学，所以不推荐。)
方法的三要素，可以随意定义。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y5IV765h-1621495397024)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210513221930749.png)]

package demo01;//都正确public interface MyInterfaceAbstract {    public abstract void methodAbs1();        abstract void methodAbs2();        public void methodAbs3();        void methodAbs4();    }

使用

接口使用步骤:

1.接口不能直接使用，必须有一一个“实现类"来“实现该接口。

格式:

public class 实现类名称 implements 接口名称{

//……

}

2.接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。

实现：去掉abstract关键字，加上方法体大括号。

3.创建实现类的对象，进行使用

注意事项：

package demo01;public interface MyInterfaceAbstract {    public abstract void methodAbs1();    abstract void methodAbs2();    public void methodAbs3();    void methodAbs4();	//这是一个默认方法    public default void methodDefault(){        System.out.println("这是一个默认方法！");    }	//这是一个静态方法    public static void methodStatic() {        System.out.println("这是一个静态方法！");    }}

package demo01;//创建一个实现类,覆盖重写接口中所有抽象方法（类似抽象类的实现）//这里可以对接口的默认方法进行覆盖重写public class MyInterfaceAbstractImpl implements MyInterfaceAbstract{    @Override    public void methodAbs1() {        System.out.println("这是第一个方法");    }    @Override    public void methodAbs2() {        System.out.println("这是第二个方法");    }    @Override    public void methodAbs3() {        System.out.println("这是第三个方法");    }    @Override    public void methodAbs4() {        System.out.println("这是第四个方法");    }}

package demo01;//创建接口的实现类对象，使用方法public class Demo01Interface {    public static void main(String[] args) {        MyInterfaceAbstractImpl myInterfaceAbstract = new MyInterfaceAbstractImpl();        myInterfaceAbstract.methodAbs1();        myInterfaceAbstract.methodAbs2();        myInterfaceAbstract.methodAbs3();        myInterfaceAbstract.methodAbs4();        myInterfaceAbstract.methodDefault();        MyInterfaceAbstract.methodStatic();    }}

14.1.3 接口默认方法的定义及使用

格式:

public default 返回值类型方法名称 (参数列表) {

方法体

}

**备注:**接口当中的默认方法，可以解决接口升级的问题。

补充：

接口的默认方法，可以通过接口实现类对象，直接调用。
接口的默认方法，也可以被接口实现类进行覆盖重写。

14.1.4 接口静态方法的定义及使用

注意事项: 不能通过接口实现类的对象来调用接口当中的静态方法。

**正确用法:**通过接口名称，直接调用其中的静态方法。

格式:

接口名称.静态方法名(参数);

14.1.5 私有方法的定义及使用

问题描述: .

我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。

但是这个共有方法不应该让实现类使用，应该是私有化的。（类的私有化通过private来实现）

解决方案:

从Java 9开始，接口当中允许定义私有方法。

1.普通私有方法，解决多个默认方法之间重复代码问题

格式:

pgivate 返回值类型方法名称(参数列表) {

方法体

}

2.静态私有方法，解诀多个静态方法之间重复代码问题

格式:

private static 返回值类型方法名称(参数列表) {

方法体

}

默认方法对私有方法的使用

package demo02;//创建一个接口public interface MyInterfacePrivate {    public abstract void method1();    public default void method2() {        System.out.println("默认方法1");        common();    }    public default void method3() {        System.out.println("默认方法2");        common();    }    private void common() {        System.out.println("aaa");        System.out.println("bbb");        System.out.println("ccc");    }}

package demo02;//接口的实现类public class MyInterfacePrivateImpl implements MyInterfacePrivate{    public void method1() {        System.out.println("这是那个抽象方法");    }    public void method4() {        System.out.println("这是子类自己的方法");    }}

package demo02;public class Demo02InterfacePrivate {    public static void main(String[] args) {        MyInterfacePrivateImpl inter = new MyInterfacePrivateImpl();        inter.method1();        inter.method2();        inter.method3();        inter.method4();    }}

静态方法对私有方法的使用

package demo02;//创建一个接口public interface MyInterfacePrivateB {    public abstract void method1();    public static void method2() {        System.out.println("默认方法1");        common();    }    public static void method3() {        System.out.println("默认方法2");        common();    }    private static void common() {        System.out.println("aaa");        System.out.println("bbb");        System.out.println("ccc");    }}

package demo02;//创建接口的实现类public class MyInterfacePrivateImpl implements MyInterfacePrivateB{    public void method1() {        System.out.println("这是那个抽象方法");    }    public void method4() {        System.out.println("这是子类自己的方法");    }}

package demo02;public class Demo02InterfacePrivate {    public static void main(String[] args) {        MyInterfacePrivateImpl inter = new MyInterfacePrivateImpl();        inter.method1();        MyInterfacePrivateB.method2();        MyInterfacePrivateB.method3();        inter.method4();    }}

14.1.6 常量的定义即使用

接口当中也可以定义“成员变量”，但是必须使用 public static final三个关键字进行修饰。

从效果上看，这其实就是接口的【常量】。

格式:

public static final 数据类型常量名称 = 数据值;（必须一开始就赋值）

备注:

一旦使用final关键字进行修饰，说明不可改变。

注意事项:

接口当中的常量，可以省略public static final, **注意:**不写也照样是这样。
接口当中的常量，必须进行赋值; 不能不赋值。
接口中常量的名称，使用完全大写的字母，用下划线分隔。（推荐命名）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ly5ZYA8E-1621495397025)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210514215540733.png)]

使用：

直接接口名称.常量名称

14.1.7 接口小结

在Java 9+版本中，接口的内容可以有:

1.成员变量其实是常量，格式:

[public] [static] [final] 数据类型常量名称 = 数据值;

注意:

常量必须进行赋值，而且一旦赋值不能改变。
常量名称完全大写，用下划线进行分隔。

2.接口中最重要的就是抽象方法，格式:

[public] [abstract] 返回值类型方法名称 (参数列表);

注意:

实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类。

3.从Java 8开始，接口里允许定义默认方法，格式:

[public] default 返回值类型方法名称(参数列表) {方法体}

注意:

默认方法也可以被覆盖重写

4.从Java 8开始，接口里允许定义静态方法，格式:

[public] static 返回值类型方法名称(参数列表) {方法体 }

注意:

应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法

5.从Java 9开始，接口里允许定义私有方法，格式:

普通私有方法: private 返回值类型方法名称(参数列表) {方法体}

静态私有方法: private static 返回值类型方法名称(参数列表) {方法体}

注意:

private的方法只有接口自己才能调用，不能被实现类或别人使用。（只能本类，本接口使用）

14.1.8 继承父类并实现多个接口

使用接口的时候，需要注意:

1.接口是没有静态代码块或者构造方法的。

2.一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。

格式:

public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {

//覆盖重写所有抽象方法

3.如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。

4.如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。

5.如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。

6.一个类如果直接父类当中的方法和接口当中的默认方法产生了冲突，优先用父类当中的方法。

package demo03;public interface MyInterfaceA {    public abstract void method1 ();    public abstract void methodAbs ();    public default void methodDefault(){        System.out.println();    }}

package demo03;public interface MyInterfaceB {    public abstract void method2();    public abstract void methodAbs();}

package demo03;public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {    @Override    public void method1() {        System.out.println("这里覆盖重写了1方法");    }    @Override    public void methodAbs() {        System.out.println("这里覆盖重写了AB接口的Abs方法");    }    @Override    public void method2() {        System.out.println("这里覆盖重写了2方法");    }}

package demo03;public class Dmo01Interface {    public static void main(String[] args) {        MyInterfaceImpl inter = new MyInterfaceImpl();        inter.method1();        inter.method2();        inter.methodAbs();    }}

14.1.9 接口之间的多继承

1.类与类之间是单继承的。直接父类只有一个。

2.类与接口之间是多实现的。-个类可以实现多个接口。

3.接口与接口之间是多继承的。

注意事项:

1.多个父接口当中的抽象方法如果重复，没关系。

2.多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，【而且带着default关键字】。

3.静态方法不会被实现类和接口继承（接口的静态方法被强制使用接口名调用）

package demo03;public interface MyInterfaceA {    public abstract void method1 ();    public abstract void methodAbs ();    public static void method(){        System.out.println("这是A接口的静态方法");    }    public default void methodDefault(){        System.out.println();    }}

package demo03;public interface MyInterfaceB {    public abstract void method2();    public abstract void methodAbs();    public static void method(){        System.out.println("这是B接口的静态方法");    }}

package demo03;public interface MyInterface extends MyInterfaceA,MyInterfaceB{    public default void method(){    }}

package demo03;public class MyInterfaceImpl implements MyInterface {    @Override    public void method1() {        System.out.println("这里覆盖重写了1方法");    }    @Override    public void methodAbs() {        System.out.println("这里覆盖重写了AB接口的Abs方法");    }    @Override    public void method2() {        System.out.println("这里覆盖重写了2方法");    }}

package demo03;public class Dmo01Interface {    public static void main(String[] args) {        MyInterfaceImpl inter = new MyInterfaceImpl();        inter.method1();        inter.method2();        inter.methodAbs();        MyInterfaceA.method();        MyInterfaceB.method();    }}

14.2 多态

14.2.1 多态的概述

一个对象拥有多种形态，这就是：对象的多态性
多态的前提：extends 和 implements

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-60whyExh-1621495397026)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210515212616182.png)]

14.2.2 多态的格式与使用

多态（polymorphism）

代码当中体现多态性：父类引用指向子类对象（引用即地址）左父右子就是多态

格式:
父类名称对象名 = new 子类名称();
或者:
接口名称对象名 = new 实现类名称();

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PcPGopWQ-1621495397027)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210515213553175.png)]

14.2.3 成员变量的使用特点（成员变量无法在子类覆盖重写）

1.直接通过对象名称访问成员变量:看等号左边是谁，优先用谁，没有则向上找。

2.间接通过成员方法访问成员变量:看该方法属于谁，优先用谁，没有则向上找。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XAbZv3kM-1621495397027)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210515214305857.png)]

多态对象名所指对象仍为子类对象，向上找源于对父类的继承关系

14.2.4 成员方法的使用特点（编译）

口诀：
成员变量:编译看左边，运行还看左边。（运行时优先子类，子类没有则向父类找）

成员方法:编译看左边，运行看右边。

14.2.5 使用多态的好处

**好处:**无论右边new的时候换成哪个子类对象，等号左边调用方法都不会变化。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JYug5O6m-1621495397028)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210516202412224.png)]

package demo04;public class Animal {    public void eat(){        System.out.println("吃东西");    }}

package demo04;public class Cat extends Animal{    public void eat() {        System.out.println("猫吃鱼");    }}

package demo04;public class Dog extends Animal{    public void eat() {        System.out.println("狗吃骨头");    }}

package demo04;public class Demo01Instanceof {    public static void main(String[] args) {        Animal animal1 = new Cat();        Animal animal2 = new Dog();        animal1.eat();        animal2.eat();    }}

14.2.6 对象的向上转型

1.对象的向上转型，其实就是多态写法:

格式: 父类名称对象名 = new 子类名称 ( );

Animal animal = new Cat( ):

**含义:**右侧创建一个子类对象，把它当做父类来看待使用。

创建了一只猫，当做动物看待，没问题。

弊端：

对象一旦向上转型，那么就无法调用子类原本特有的内容（多态特点）

注意事项:向上转型一定是安全的。从小范围转向了大范围，从小范围的猫，向上转换成为更大范围的动物。

类似于:

double num = 100; //正确，int --> double,自动类型转换。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2bKc8bw2-1621495397028)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210516203022739.png)]

14.2.7 对象的向下转型

1.对象的向下转型，其实是一个【还原】的动作。

**格式:**子类名称对象名 = (子类名称) 父类对象;

含义:将父类对象，【还原】成为本来的子类对象。

Animal animal = new CatO; //本来是猫，向上转型成为动物

Cat cat = (Cat) animal; //本来是猫，已经被当做动物了，还原回来成为本来的猫

注意事项:

必须保证对象本来创建的时候，就是猫，才能向下转型成为猫。
如果对象创建的时候本来不是猫，现在非要向下转型成为猫，就会报错。ClassCastException

类似于： int num = (int) 10.0;//可以 int num = (int) 10.5 //会造成精度损失

14.2.8 用instanceof关键字进行类型判断

如何才能知道一个父类引用的对象，本来是什么子类?

格式:

对象 instanceof 类名称

这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例。

package demo04;public class Animal {    public void eat(){        System.out.println("吃东西");    }}

package demo04;public class Dog extends Animal{    public void eat() {        System.out.println("狗吃骨头");    }    public void dogMethod() {        System.out.println("狗看门");    }}

package demo04;public class Cat extends Animal{    public void eat() {        System.out.println("猫吃鱼");    }    public void catMethod () {        System.out.println("猫抓老鼠");    }}

package demo04;public class Demo01Instanceof {    public static void main(String[] args) {        Animal animal1 = new Cat();        Animal animal2 = new Dog();        animal1.eat();        animal2.eat();        System.out.println("=================");        if (animal1 instanceof Cat) {            Cat cat = (Cat) animal1;            cat.catMethod();        }        if (animal1 instanceof Dog) {            Dog dog = (Dog) animal1;            dog.dogMethod();        }        if (animal2 instanceof Dog) {            Dog dog = (Dog) animal2;            dog.dogMethod();        }        if (animal2 instanceof Cat) {            Cat cat = (Cat) animal1;            cat.catMethod();        }        giveMeAnAnimal(new Dog());    }    public static void giveMeAnAnimal(Animal animal) {        if (animal instanceof Dog) {            Dog dog = (Dog) animal;            dog.dogMethod();        }        if (animal instanceof Cat) {            Cat cat = (Cat) animal;            cat.catMethod();        }    }}

14.2.9 接口多态的综合案例

电脑USB接口案例分析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-umQNbQoi-1621495397029)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210516213458450.png)]
电脑USB接口案例实现

package demo05;public interface UsbInterface {    public abstract void open();    public abstract void close();}

package demo05;public class Keyboard implements UsbInterface{    @Override    public void open() {        System.out.println("打开键盘");    }    @Override    public void close() {        System.out.println("关闭键盘");    }    public void type() {        System.out.println("键盘输入！");    }}

package demo05;public class Mouse implements UsbInterface{    @Override    public void open() {        System.out.println("打开鼠标");    }    @Override    public void close() {        System.out.println("关闭鼠标");    }    public void clik() {        System.out.println("点击鼠标！");    }}

package demo05;import java.awt.event.MouseAdapter;public class Computer {    public void openComputer() {        System.out.println("打开笔记本电脑");    }    public void closeComputer() {        System.out.println("关闭笔记本电脑");    }    public void useEquipmentsOpen(UsbInterface equipment) {        equipment.open();    }    public void useFunction(UsbInterface equipment) {        if (equipment instanceof Mouse){            Mouse mouse = (Mouse) equipment;            mouse.clik();        }        else if(equipment instanceof Keyboard){            Keyboard keyboard = (Keyboard) equipment;            keyboard.type();        }    }    public void useEquipmentClose(UsbInterface equipment) {        equipment.close();    }}

package demo05;public class Demo01Usb {    public static void main(String[] args) {        UsbInterface mouse = new Mouse();        UsbInterface keyBoard = new Keyboard();        Computer computer = new Computer();        computer.openComputer();        computer.useEquipmentsOpen(mouse);        //方法参数时UsbInterface类型，传递进去的是实现类对象        computer.useEquipmentsOpen(keyBoard);//正确写法！也发生了向上转型（类似与小范围对大范围的自动转型）        //使用子类对象的匿名对象也是可以的        //computer.useEquipmentsOpen(new Keyboard());//也是正确写法        computer.useFunction(keyBoard);        computer.useFunction(mouse);        computer.useEquipmentClose(mouse);        computer.useEquipmentClose(keyBoard);        computer.closeComputer();    }}

第十五章（java_8）

15.1 final 关键字

15.1.1 final关键字的概念与四种用法

1.概述：final关键字代表最终，不可改变的

2.常见的四种用法：

可以用来修饰一个类
可以用来修饰一个方法
可以用来修饰一个局部变量
可以用来修饰一个成员变量

15.1.2 final关键字用来修饰类

1.final修饰的类不能有任何子类（太监类）

当final关键字用来修饰一个类的时候，格式:

public final class 类名称{

// 主体

}

2.**注意：**一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没子类无法重写，但方法仍可被重写），但其可对父类成员方法紧凑型覆盖重写。

15.1.3 final关键字用来修饰成员方法

1.当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。

格式:

修饰符 final 返回值类型方法名称 (参数列表) {

//方法体

}

注意事项:

对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾（抽象的必须被重写，但final的不能被重写）。

15.1.4 final关键字用来修饰局部变量

1.final关键字特点

对于基本类型来说，不可变说的是变量当中的数据不可改变
对于引用类型来说，不可变说的是变量当中的地址值不可改变

2.final关键字使用特点：

一次赋值，终生不变

package demo01;public class Student {    public Student() {    }    private String name;    public Student(String name) {        this.name = name;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }}

package demo01;public class Demo01Final {    public static void main(String[] args) {        int num1 = 20;        System.out.println(num1);        num1 = 520;        System.out.println(num1);        System.out.println("===============");        final int num2 = 520;        System.out.println(num2);        //num2 = 1314;//错误，final修饰的变量只能赋值一次        final int num3;        num3 = 5201314;//正确        System.out.println(num3);        System.out.println("===============");        final Student stu1;//也只可进行一次赋值操作        stu1 = new Student();        stu1.setName("wjx");        System.out.println(stu1.getName());        //stu1 = new Student();//错误写法，新对象拥有新的地址值        stu1.setName("yyp");        System.out.println(stu1.getName());//地址不变，内容可变    }}

15.1.5 final关键字用来修饰成员变量

对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。
使用特点：
- 由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
- 对于final的成员变量， 要么使用直接赋值，要么通过构造方法赋值。
- 必须保证类当中所有的重载的构造方法，都最终会对final的成员变量进行赋值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JJ8cXZhE-1621495397030)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210517160704954.png)]

不能包含对成员变量修改的方法

15.2 四种权限修饰符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3LADQ78v-1621495397031)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210517193543750.png)]

15.3 内部类

15.3.1 内部类的概念与分类

如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。

例如:身体和心脏的关系。又如:汽车和发动机的关系。

分类:

成员内部类
局部内部类(包含匿名内部类) |

15.3.2 成员内部类的定义

成员内部类的定义格式:

修饰符 class 外部类名称{
修饰符 class 内部类名称{
//……
}
//……
}

注意: 内用外，随意访问；外用内，需要内部类对象。

15.3.3 使用成员内部类

两种方法：

**间接方法：**在内部类的方法当中，使用内部类，然后main只是调用外部类的方法。
直接方式: 公式:

类名称对象名 = new 类名称();

外部类名称.内部类名称对象名 = new 外部类名称(). new内部类();

package demo02;

public class Body {

    public class Heart {
        //内部类的方法
        public void beat() {
            System.out.println("心脏跳动，蹦蹦蹦");
            System.out.println("心脏的名字是：" + name);
        }
    }

    //外部类的成员变量
    private String name = "mrj";
    //外部类的方法
    public void methodBody() {
        System.out.println("外部类的方法");
        Heart heart = new Heart();
        heart.beat();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package demo02;

public class Demo01InnerClass {
    public static void main(String[] args) {
        Body body = new Body();
        Body.Heart heart = new Body().new Heart();
        heart.beat();
        body.methodBody();
    }
}

15.3.4 内部类的同名变量的访问

package demo02;

public class Outer {
    int num = 10;

    public class Inner {
        int num = 20;
        public void method() {
            int num = 30;
            System.out.println(num);//访问同名局部变量
            System.out.println(this.num);//访问内部类同名变量
            System.out.println(Outer.this.num);//访问外部类同名变量
        }
    }
}

package demo02;

public class Demo02InnerClass {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();
        inner.method();
    }
}

15.3.5 局部内部类的定义

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。

“局部”:只有当前所属的方法才能使用它，出了这个方法外面就不能用了。

定义格式:

修饰符 class 外部类名称{

修饰符返回值类型外部类方法名称(参数列表) {

** ** 局部内部类名称 {

// …

}

package demo03;

public class Outer {

    public void methodOuter() {
        class Inner {
             int num = 10;
             public void method() {
                 System.out.println(num);
             }
        }

        Inner inner = new Inner();
        inner.method();
    }
}

package demo03;

public class Demo01InnerClass {
    public static void main(String[] args) {
        Outer obj = new Outer();
        obj.methodOuter();
    }
}

小节一下类的权限修饰符:

public > protected > (default) > private

定义一个类的时候，权限修饰符规则:

外部类: public / (default)
成员内部类: public / protected / (default) / private
局部内部类: 什么都不能写

15.3.5.2 局部内部类的final问题

局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的]】。

**备注:**从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略。|

原因:

new出来的对象在堆内存当中。
局部变量是跟着方法走的，在栈内存当中。
方法运行结束之后，立刻出栈，局部变量就会立刻消失。
但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。

package demo03;

public class MyOuter {

    public void methodOuter() {
        final int num = 10;//局部内部类访问局部变量必须是有效的final或确定事实不变的变量

        class MyInner {//类在调用变量时会copy一个等大常量进来
            public void methodInner() {
                System.out.println(num);//给num
            }
        }
    }
}

15.3.6 匿名内部类（省略的是类名称，只能对抽象方法进行覆盖重写）

如果接口的实现类(或者是父类的子类)只需要使用唯一的一次。

那么这种情况下就可以省略掉该类的定义，而改为使用[匿名内部类]。

匿名内部类的定义格式:

接口名称对象名 = new 接口名称() {

//覆盖重写所有抽象方法

};

对格式 “new 接口名称 ( ) {… } “进行解析:

new代表创建对象的动作
接口名称就是匿名内部类需要实现哪个接口
{… } 这才是匿名内部类的内容

注意事项：

1.匿名内部类，在【创建对象】的时候，只能使用唯一次。

如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了。

2.匿名对象，在【调用方法】的时候，只能调用唯一次。

如果希望同一个对象，调用多次方法，那么必须给对象起个名字。

3.匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】

**强调：**匿名内部类和匿名对象不是一回事！！！！

package demo04;

public interface MyInterface {
    public abstract void method1();//抽象方法
    public abstract void method2();
}

package demo04;

public class MyInterfaceImpl implements MyInterface{
    @Override
    public void method1() {
        System.out.println("在实现类重写了抽象方法1");
    }
    @Override
    public void method2() {
        System.out.println("在实现类重写了抽象方法2");
    }
}

package demo04;

public class Demo01Main {
    public static void main(String[] args) {
        MyInterface impl = new MyInterfaceImpl();
        impl.method1();
        impl.method2();
        System.out.println("=============");

        MyInterface obj = new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类对方法进行了重写方法1");
            }
            @Override
            public void method2() {
                System.out.println("匿名内部类对方法进行了重写方法2");
            }
        };//这里有分号

        obj.method1();
        obj.method2();

        System.out.println("==============");
        //匿名对象使用方法
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类对方法进行了重写方法1");
            }
            @Override
            public void method2() {
                System.out.println("匿名内部类对方法进行了重写方法2");
            }
        }.method1();

        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类对方法进行了重写方法1");
            }
            @Override
            public void method2() {
                System.out.println("匿名内部类对方法进行了重写方法2");
            }
        }.method2();
    }
}

15.3.7 类作为成员变量类型

类作为成员变量

package demo05;public class Hero {    private String name;//英雄名字    private int age;    private Weapon weapon;//定义 类 类型成员变量    public Hero() {    }    public Hero(String name, int age, Weapon weapon) {        this.name = name;        this.age = age;        this.weapon = weapon;    }    public void attack() {        System.out.println("年龄为" + age + "的" + name + "用" + weapon.getCode() + "打怪兽！！");    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    public Weapon getWeapon() {        return weapon;    }    public void setWeapon(Weapon weapon) {        this.weapon = weapon;    }}

package demo05;public class Weapon {    private String code;//武器的代号    public Weapon() {    }    public Weapon(String code) {        this.code = code;    }    public String getCode() {        return code;    }    public void setCode(String code) {        this.code = code;    }}

package demo05;public class Demo01Main {    public static void main(String[] args) {        Hero hero = new Hero();        hero.setName("盖伦");        hero.setAge(18);        //创建一个武器对象        Weapon weapon = new Weapon("AK-47");        //将武器交给英雄        hero.setWeapon(weapon);        hero.attack();    }}

15.3.8 接口作为成员变量类型

package demo06;public interface Skill {    public abstract void use();}

package demo06;public class Hero {    private String name;    private Skill skill;//定义接口类型变量    public Hero() {    }    public Hero(String name, Skill skill) {        this.name = name;        this.skill = skill;    }    public void attack() {        System.out.println(name + "使用技能");        skill.use();        System.out.println("打怪兽！！！");    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public Skill getSkill() {        return skill;    }    public void setSkill(Skill skill) {        this.skill = skill;    }}

package demo06;public class Demo01Main {    public static void main(String[] args) {        Hero hero = new Hero();        hero.setName("永恩");//英雄名称       /* Skill skill = new Skill() {//使用匿名内部类            public void use() {                System.out.println("释放双剑滑斩");            }        };*/        hero.setSkill(new Skill() {//既使用匿名内部类，还是用匿名对象            public void use() {                System.out.println("释放双剑滑斩");            }        });        hero.attack();    }}

15.3.9 接口作为方法的参数和返回值

package demo07;import java.util.ArrayList;import java.util.List;//List包public class DemoInterface {    public static void main(String[] args) {        List<String> list = new ArrayList<>();//多态创建接口类型类型变量        list = addNames(list);        System.out.println(list);    }    public static List<String> addNames(List<String> list) {        list.add("迪丽热巴");        list.add("古力娜扎");        list.add("马儿扎哈");        return list;    }}

15.3.10 升级版发红包案例（没看明白，所以没写，以后再弄）

第十六章（java_house\java_1）

16.1 Object类

Object类提供了十一个方法，

https://blog.csdn.net/weixin_43232955/article/details/89705350

pubLic final native CLass<?> getCLass()public native int hashCode()pubLic booLean equals(0bject obj)//常用protected native Object cLone() throws CLoneNotSupportedExceptionpubLic String toString(//常用public final native void notify() public final native void notifyALl()pubLic final native void wait(long timeout) throws InterruptedExceptionpubLic final void wait(Long timeout, int nanos) throws InterruptedExceptionpublic final void wait() throws InterruptedExceptionprotected void finalize() throws Throwable { }

16.1.1 Object类的概述

包位置： java. lang. 0bject类

类object是类层次结构的根(最顶层)类。每个类都使用object 作为超(父)类。
所有对象(包括数组)都实现这个类的方法。

16.1.2 Object类的toString方法（主要作用：获取对象的信息）

概述：返回该对象的字符串表示（即对象的引用，java对地址的表示并不是一个具体数值，而是一串字符串：该字符串由类名（对象是该类的一个实例）、at 标记符（类名称） “@”和此对象哈希码的无符号十六进制表示组成，如demo01.Person@776ec8df）**格式：**getClass().getName() + ‘@’ + Integer.toHexString(hashCode())

该方法用得比较多，一般子类都有覆盖，来获取对象的信息。

package demo01;public class Person {    private String name;    private int age;    public Person(String name, int age) {        this.name = name;        this.age = age;    }    public Person() {    }    //对toString方法进行覆盖重写。   /* @Override    public String  toString(){        return "Person{name = " + name + "，age = " + age + "}";    }*/    @Override    public String toString() {        return "Person{" +                "name='" + name + '\'' +                ", age=" + age +                '}';    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }}

package demo01;public class Demo01ToString {    public static void main(String[] args) {        Person person = new Person("mrj", 18);        String str = person.toString();        System.out.println(str);    }}

16.1.3 Object类的Equals方法

Person类默认继承了0bject类,所以可以使用object类的equals方法

boolean equals(object obj) 指示其他某个对象是否与此对象“相等”。

equals 方法源码:

public boolean equals(0bject obj) {

return (this == obj);

参数:

object obj :可以传递任意的对象（多态：Object可为所有类的父类）

== 比较运算符,返回的是一个布尔值 true false

**基本数据类型:**比较的是值

引用数据类型:比较的是两个对象的地址值

this是谁? 那个对象调用的方法,方法中的this就是那个对象; p1调用的equals方法所以this就是p1

obj是谁? 传递过来的参数p2

this==odj --> p1 == p2

package demo01;public class Person {    private String name;    private int age;    public Person(String name, int age) {        this.name = name;        this.age = age;    }    public Person() {    }   /* @Override    public String  toString(){        return "Person{name = " + name + "，age = " + age + "}";    }*/    /*@Override    public String toString() {        return "Person{" +                "name='" + name + '\'' +                ", age=" + age +                '}';    }*/    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }}

package demo01;public class Demo02Equals {    public static void main(String[] args) {        Person person1 = new Person();        Person person2 = new Person();        System.out.println(person1);        System.out.println(person2);//此处输出语句会去访问该对象类当中的toString方法来获取对象信息，所以在Person类当中如果未对同String方法重写，默认继承Object类的方法，返回地址值        boolean bool = person1.equals(person2);        System.out.println(bool);    }}

16.1.4 重写Object 类的equals方法

object类的equals方法,默认比较两个对象的地址值,没有意义

所以我们要重写equals方法, 比较两个对象的属性 (name, age)

问题:

隐含着一个多态

**多态的弊端:**无法使用子类特有的内容(属性和方法.

**解决:**可以使用向下转型(强转)把object类型转换为PersonEquals

package demo01;public class PersonEquals {     private String name;     private int age;    public PersonEquals(String name, int age) {        this.name = name;        this.age = age;    }    public PersonEquals() {    }    @Override    public String toString() {        return "Person{" +                "name='" + name + '\'' +                ", age=" + age +                '}';    }    @Override    public boolean equals(Object obj) {        //提高程序效率        if(obj == this){            return true;        }        if(obj == null){            return false;        }                if(obj instanceof PersonEquals){            PersonEquals p = (PersonEquals) obj;//将Object类对象向下转型为PersonEquals类对象            return this.name.equals(p.name) && this.age == p.age;//this表示在隐式传入参数（.前对象的地址值），private修饰变量，如果是在本类当中，那么本类的对象可以通过 .成员变量名 访问成员变量        }        return false;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }}

package demo01;import java.util.ArrayList;public class Demo02Equals {    public static void main(String[] args) {        PersonEquals person1 = new PersonEquals("mrj",19);        PersonEquals person2 = new PersonEquals("mrj",19);        System.out.println(person1);        System.out.println(person2);        ArrayList<String> list = new ArrayList();        boolean bool = person1.equals(list);        System.out.println(bool);    }}

16.1.5 Objects 类的equals方法

Objects类概述：

1.它的空指针安全，容忍空指针，

2.**导包地址：**java.util.Objects

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DseOdM9B-1621495397032)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210519162222568.png)]

objects类的equals方法: 对两个对象进行比较, 防止空指针异常

public static boolean equals (object a, object b) {

return (a == b) || (a != null && a.equals(b));

}

package demo01;import java.util.Objects;public class Demo03ObjectsEquals {    public static void main(String[] args) {        String str1 = "abc";        String str2 = null;        //Boolean bool1 = str2.equals(str1);//抛出空指针异常，因为空指针无法调用方法        Boolean bool1 = Objects.equals(str1,str1);    }}

16.2 日期时间类

16.2.1 Data类概述

概述：Java.util.Date 类，表示特定的瞬间，精确到毫秒（千分之一秒）

继续查阅Date类的描述,发现Date拥有多个构造函数,只是部分已经过时,但是其中有未过时的构造函数可以把

毫秒值转成日期对象。

**public Date(): ** 分配Date对象并初始化此对象,以表示分配它的时间(精确到毫秒)。
public Date(long date) : 分配Date对象并初始化此对象,以表示自从标准基准时间(称为”历元( epoch )",即1970年1月1日00:00:00 GMT )以来的指定毫秒数。

tips(时间原点):由于我们处于东八区,所以我们的基准时间为1970年1月1日 0时0分0秒。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2Q8MwEQa-1621495397032)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210519170207400.png)]

System.currentTimeMillis()//获取当前系统时间的毫秒值

16.2.2 Date类的构造方法和成员方法

**补充：**Date类对继承Object类的toString方法进行了覆盖重写.

1.构造方法：

Date() :无参构造方法，创建对象，并初始化对象为当前系统时间日期。
Dtae(long obj): 含参的构造方法，参数为毫秒值，创建对象，并初始化对象为所传参数在时间原点上累加后的日期

2.成员方法：

long getTime()： 把日期转换为毫秒值(相当于System. currentTimeMillis()方法)
返回自1970年1月1 00:00:00 GMT 以来此Date对象表示的毫秒数。

package demo02;

import java.util.Date;

public class Demo01Date {
    public static void main(String[] args) {
        demo01();//当前系统时间日期
        demo02();//所传参数在时间原点上累加后的日期
        System.out.println(System.currentTimeMillis());//获取系统当前时间与时间原点相差的毫秒值
        demo03();//获取系统当前时间与时间原点相差的毫秒值
    }

    private static void demo03() {
        Date date = new Date();
        long time = date.getTime();
        System.out.println(time);
    }

    private static void demo01() {
        Date date = new Date();
        System.out.println(date);
    }

    private static void demo02() {
        Date date = new Date(1621415080337L);//将参数毫秒值增加到时间原点上，并返回日期
        System.out.println(date);
    }
}

16.2.3 DateFormat类(format格式化）

概述：java.text .DateFormat类是日期/时间格式化子类的抽象类,我们通过这个类可以帮我们完成日期和文本之间的转换也就是可以在Date对象与String对象之间进行来回转换，由于其为抽象类，所以使用其子类SimpleDateFormat类，他继承了父类方法。

**格式化:**按照指定的格式,从Date对象转换为String对象。（从日期->文本）
**解析:**按照指定的格式,从String对象转换为Date对象。(从文本->日期)

1.成员方法：

String format(Date date) : 按照指定的模式,把Date日期，格式化为符合模式的字符串
Date parse(String source) : 把**符合模式的字符串,**解析为Date日期

16.2.3.1 SimpleDateFormat类：

构造方法：（含参构造，参数为字符串）
- SimpleDateFormat (String pattern)：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat对象.（此构造模式会用于调用方法格式化或解析时的模式返回和判断）
  - 参数：String pattern： 传递指定的模式。
    
    **模式:**区分大小写的
    y 年
    M 月
    d 日
    H 时
    m 分
    S 秒
    
    写对应的模式,会把模式替换为对应的日期和时间
    "yyyy-MM-dd HH:mm:ss ”
    注意:
    模式中的字母不能更改连接模式的符号可以改变
    "“yyyy年M月dd日 HH时mm分ss秒 ”
成员方法：
- String format(Date date) : 按照指定的模式,把Date日期，格式化为符合模式的字符串
  
  使用DateFormat类中的方法format,把日期格式化为文本
  
  使用步骤:
  
  1.创建SimpleDateFormat对象,构造方法中传递指定的模式
  
  2.调用Simpl eDateFormat对象中的方法format,按照构造方法中指定的模式，把Date日期格式化为符合模式的字符串(文本)

package demo02;

import java.text.SimpleDateFormat;
import java.util.Date;
//DateFormat类为一个抽象类，无法直接创建对象，所以使用SimpleDateFormat类，它继承了DateFormat类。

public class Demo02DateFormat {
    public static void main(String[] args) {
        demo01();
    }
    private static void demo01() {//格式化
        SimpleDateFormat sdf  = new SimpleDateFormat("yyyy年M月dd日HH时ss秒S毫秒");//只要存在一个标识符即可识别，多了无所谓
        Date date = new Date();
        String str = sdf.format(date);
        System.out.println(date);
        System.out.println(str);
    }
}

Date parse(String source) : 把**符合模式的字符串,**解析为Date日期

使用DateFormat类中的方法parse,把文本解析为日期

使用步骤:

1.创建SimpleDateFormat对象,构造方法中传递指定的模式

2.调用SimpleDateFormat对象中的方法parse,把符合构造方法中模式的字符串,解析为Date日期

注意:

public Date parse(String source) throws ParseException

parse方法声明了一个异常叫 ParseException

如果字符串和构造方法的模式不一样,那么程序就会抛出此异常（解决：Alt + Enter）

调用一个抛出了异常的方法,就必须的处理这个异常,要么throws继续抛出这个异常要么try catch自己处理

package demo02;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
//DateFormat类为一个抽象类，无法直接创建对象，所以使用SimpleDateFormat类，它继承了DateFormat类。

public class Demo02DateParse {
    public static void main(String[] args) throws ParseException {
        demo01();
        demo02();
    }

    private static void demo01() {//格式化
        SimpleDateFormat sdf  = new SimpleDateFormat("yyyy年M月dd日HH时ss秒S毫秒");//只要存在一个标识符即可识别，
        // 多了无所谓
        Date date = new Date();
        String str = sdf.format(date);
        System.out.println(date);
        System.out.println(str);
    }

    private static void demo02() throws ParseException {//将字符串解析为Date类数据
        SimpleDateFormat sdf  = new SimpleDateFormat("yyyy年M月dd日HH时ss秒S毫秒");
        Date date = sdf.parse("2021年5月19日20时18秒503毫秒");
        System.out.println(date);
    }

}

格式：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iquJDMsw-1621495397033)(C:\Users\过客\AppData\Roaming\Typora\typora-user-images\image-20210519174233058.png)]

16.2.4 练习题

练习：
请使用日期时间相关的API,计算出一个人已经出生了多少天。

package demo02;

import java.text.ParseException;//抛出异常时引入的包
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class Demo04DatePractice {
    public static void main(String[] args) throws ParseException {//throws是抛出异常时增加的
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的出生日期，格式为：yyyy-MM-dd");
        String str = sc.next();
        Date dateNow = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("y-M-d");
        long num1 = dateNow.getTime();
        Date dateStart = sdf.parse(str);//抛出异常引入了一个新包
        long num2 = dateStart.getTime();
        long num3 = num1 - num2;
        System.out.println("你以出生：" + (num3 / 1000 / 60/ 60/ 24) + "天");
    }
}

16.3 日历类

理解：日历类是对日期类的升级，它可将日期中的每一元素单独拿出进行操作，而日期类只能显示日期，无法更改数据（也可通过format格式化显示单一元素）

16.3.1 Calendar类概述

概述： java.util.calendar 是日历类 , 在Date后出现,替换掉了许多Date的方法。该类将所有可能用到的时间信息封

装为静态成员变量,方便获取。日历类就是方便获取各个时间属性的。Calendar类是一个**抽象类,**里边提供了很多操作日历字段的方法(YEAR、MONTH、 DAY_ OF_ _MONTH、HOUR )

1.获取对象方式：此类为抽象类，无法直接创建对象，其内含一个抽象静态方法getInstance()，该方法返回calendar类的子类对象，使用父类名运行子类方法，多态创建对象，（父类声明对象，子类分配内存，初始化对象）

创建对象格式：

calendar 对象名 = calendar.getInstance();//创建完成并初始化对象为当前日历。

16.3.2 calendar类常用成员方法（虽为子类对象，但会继承父类方法）

public int get(int field) : 返回给定日历字段的值。（field 字段）
public void set(int field, int value) : 将给定的日历字段设置为给定值。
public abstract void add(int field, int amount) : 根据日历的规则,为给定的日历字段添加或减去指定的时间量。（此方法在子类被覆盖重写，其他方法可时父普通方法）
public Date getTime() : 返回一一个表示此Calendar时间值**(从历元到现在的毫秒偏移量)**的Date对象。

解析：

成员参数：int field：日历类的字段，可以使用calendar类的静态成员变量来获取

public static final int YEAR = 1; 年

public static final int MONTH = 2; 月

public static final int DATE = 5; 月中的某一天

public static final int DAY_ OF_ MONTH = 5; 月中的某一天

public static final int HOUR = 10; 时

public static final int MINUTE = 12; 分

public static final int SECOND = 13; 秒

1.public int get(int field) : //按格式获取当前对象的日历数据

package demo03;

import java.util.Calendar;

public class Demo01Calendar {
    public static void main(String[] args) {
        demo01();
    }

    private static void demo01() {
        Calendar c = Calendar.getInstance();
        int year = c.get(Calendar.YEAR);
        System.out.println(year);

        int month = c.get(Calendar.MONTH);
        System.out.println(month+1);//西方的月份为0~11月

        int day1 = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(day1);

        int day2 = c.get(Calendar.DAY_OF_WEEK);//西方从周日开始第一天
        System.out.println(day2);
    }
}

2.public void set(int field, int value) : //按格式对对象的日历数据进行修改

参数:

int field: 传递指定的日历字段(YEAR, MONTH…)

int value: 给指定字段设置的值

package demo03;

import java.util.Calendar;

public class Demo02CalendarSet {
    public static void main(String[] args) {
        demo01();
    }

    private static void demo01() {
        Calendar c = Calendar.getInstance();
        c.set(Calendar.MONTH, 5);
        c.set(Calendar.YEAR, 1520);
        c.set(Calendar.DAY_OF_MONTH, 20);

        //同时设置三个参数
        c.set(2520,5,21);
        int year = c.get(Calendar.YEAR);
        System.out.println(year);

        int month = c.get(Calendar.MONTH);
        System.out.println(month);

        int day = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);
    }
}

3.public abstract void add(int field, int amount) :把指定的字段增加/减少指定的值

参数:
int field:传递指定的日历字段(YEAR, MONTH…)

int amount :增加减少指定的值

正数:增加

负数:减少

注意： 此方法为抽象方法，所运行的为子类方法

package demo03;

import java.util.Calendar;

public class Demo03CalendarAdd {
    public static void main(String[] args) {
        demo01();
    }

    private static void demo01() {
        Calendar c = Calendar.getInstance();
        c.set(Calendar.MONTH, 5);
        c.set(Calendar.YEAR, 1520);
        c.set(Calendar.DAY_OF_MONTH, 20);

        //同时设置三个参数
        c.set(2520,5,21);

        c.add(Calendar.YEAR, 1);//将年份增加一年
        c.add(Calendar.MONTH, -2);//将月份减少两月
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH);
        int day = c.get(Calendar.DAY_OF_MONTH);

        System.out.println(year + "-" + month + "-" + day);
    }
}

4.public Date getTime() :

package demo03;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class Demo04CalendarGetTime {
    public static void main(String[] args) {
        demo01();
    }

    private static void  demo01() {
        Calendar c = Calendar.getInstance();
        Date date = c.getTime();
        System.out.println(date);
        SimpleDateFormat sdf = new SimpleDateFormat("y-M-d-s-S");
        String str = sdf.format(date);
        System.out.println(str);
    }
}

16.4 System类

java. lang.System类中提供了大量的静态方法,可以获取与系统相关的信息或系统级操作,在System类的API文
档中,常用的方法有:

public static long currentTimeMillis() ：返回以毫秒为单位的当前时间。
public static void arraycopy(object src, int srcPos, object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。

public static long currentTimeMillis() ：常用来计算测试程序的效率，运行所用时间

验证for循环打印1~9999所需时间（毫秒）

package demo04;

public class Demo01CurrentTimeMillis {
    public static void main(String[] args) {
        demo01();
    }

    private static void demo01() {
        long start = System.currentTimeMillis();
        for (int i = 0; i <= 9999; i++) {
            if(i % 10 == 0)
                System.out.println();
            System.out.print(i + " ");
        }
        long end = System.currentTimeMillis();
        System.out.println("运行共耗时：" + (end - start) + "毫秒");
    }
}

public static void arraycopy(object src, int srcPos, object dest, int destPos, int length)：

参数:

src - 源数组。

srcPos - 源数组中的起始位置（起始索引）。

dest - 目标数组。

destPos - 目标数据中的起始位置。

Length - 要复制的数组元素的数量。

package demo04;


public class Demo02SystemArrayCopy {
    public static void main(String[] args) {
        demo01();
    }

    private static void demo01() {
        int[] src = new int[]{1, 2, 3, 4, 5};
        int[] dest = new int[]{6, 7, 8, 9, 10};

        System.arraycopy(src,0,dest,0,3);
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }
    }
}

圆圆的肚子

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
java学习笔记

文章目录第一章 Java概述1.1 什么是Java语言1.2 Java语言发展史1.3 JVM1.4 JRE和JDK第二章 HolleWorld入门程序2.1 程序开发步骤说明2.2 标识符第三章常量3.1 常量的分类:第四章变量和数据类型4.1 变量概述4.1.1 变量:常量是固定不变的数据，那么在程序中**可以变化的量称为变量**。4.1.2 注意事项：4.2 数据类型的分类Java的数据类型分为两大类:第五章数据类型转换5.1 自动转换5.2 强制转换5.3 运算符
复制链接

扫一扫