Java是什么？

最新推荐文章于 2024-09-20 15:13:41 发布

置顶 lentao1010520

最新推荐文章于 2024-09-20 15:13:41 发布

阅读量818

点赞数 3

文章标签： java 编程语言

本文链接：https://blog.csdn.net/weixin_48601622/article/details/106943388

版权

1，什么是Java？

Java是一门非常火的计算机语言。（也叫做编程语言）

我们想要让计算机做一些事情，那么就可以通过Java语言告诉计算机就可以了。

2，Java的分类

JavaSE：是其他两个的基础。

温馨小提示：GUI,AWT的部分就可以不学了。

GUI和AWT是用于桌面应用的开发。

JavaSE现在已经不做桌面应用的开发了。现在就是其他两个的基础。

JavaME：Java语言的小型版，用于嵌入式消费类电子设备开发或者小型移动设备开发。

JavaEE：用于企业级别的WEB方向的网站开发（主要从事后台服务器的开发）

在服务器领域，JavaEE是当之无愧的龙头老大。

3，什么是跨平台？

可以在任意操作系统上运行

4，Java语言跨平台的原理

操作系统其实并不认识Java语言

但是针对于不同的操作系统，Java提供了不同的虚拟机。

虚拟机会把Java语言翻译成操作系统能看得懂的语言。

java是跨平台的，但是JVM虚拟机不是跨平台的。

5，JDK，JRE，JVM三者的包含关系

JDK：用来写代码的。里面包含了开发工具和JRE

JRE：用来运行代码的。里面包含了JVM和运行时需要用到的一些东西

JVM：是用来翻译代码的。也是代码真正运行的地方

JDK > JRE > JVM

6，JDK下载

针对于不同的操作系统，要下载不同版本的JDK。

7，什么是CMD

CMD就是利用命令行的方式去操作计算机。

可以通过命令去打开文件，打开文件夹，创建文件，创建文件夹，删除文件，删除文件夹等等操作。

8，常见的CMD命令

切换盘符：盘符名 + 英文状态下的冒号
dir：查看当前文件夹的内容
cd + 文件夹名称：进入单级文件夹
cd…：回退单级文件夹
cd + 文件夹名字1\文件夹名称2\文件夹名称3.

小技巧：如何快速打出文件夹的名字。先打文件夹的首字母，然后按下tab就可以了。

如果有多个文件夹的开头是一样的，那么多按几下tab就可以了。
cd\ ：直接退到根盘符。
cls ：清屏
exit：退出CMD。

9，要求掌握的练习

可以利用cmd和常见的命令，能成功运行java和javac
步骤：

1.win + r 打开运行窗口

2.输入cmd加回车。可以打开cmd窗口

3.使用cd命令进入到java和javac所在的文件夹（如果要切换盘符，可以使用盘符加冒号的形式）

4.运行java和javac。直接写他们的名字就可以了。

10，第一个小程序HelloWorld

步骤：

1，到JDK的安装目录下的bin文件夹里面新建一个文本文件。

再把这个文本文件的名字改为HelloWorld.java

2，右键点击java文件，选择编辑，用记事本打开。

3，编写代码。

public class HelloWorld{
	public static void main(String [] args){
		System.out.println("hello123");
	}
}
//注意事项：在代码当中所有的标点符号，都要是英文状态下的。
//分享一个小技巧：
	//在输入法的设置中,有一个中文状态下使用英文标点。可以把前面的勾选上就可以了。

4，写完之后，要保存文件

可以看文件上面的*，如果有，那么表示文件没有保存。

5，编译文件

打开CMD，进入到HelloWorld.java这个文件所在的文件夹。

javac HelloWorld.java

会产生一个class文件（字节码文件），这个文件就是操作系统能看得懂的东西了

6，运行代码

我们运行的时候，是翻译之后的内容。

java HelloWorld

11，配置环境变量的意义

我想要把代码写在任意的文件夹当中。

就要求，我们可以在任意的文件夹当中都可以使用javac和java才可以。

如何操作呢？

就必须要把java和javac配置到环境变量当中。

一旦配置了，那么在所有的文件夹里面都可以使用这两个命令了。

12，配置环境变量的步骤

配置环境变量的意义：想要在任意的文件夹里面都可以运行指定的程序。

步骤：

1，右键点击我的电脑，选择属性

2，再选择高级系统设置

3，再高级当中，选择环境变量

4，一定要配置在系统变量当中。

新建JAVA_HOME: 变量值就写JDK安装路径

双击打开PATH：%JAVA_HOME%\bin

问题：

在配置环境变量的过程中。

为什么要写JAVA_HOME？

因为后面会学习其他的软件，也会依赖JAVA_HOME

所以，现在，我们一次性配置到位。

%%又表示什么？

%表示引用的意思。

JAVA_HOME： D:\develop\JDK

PATH:%JAVA_HOME%\bin — 就相当于把JAVA_HOME里面的值直接拿过来用。

D:\develop\JDK\bin — 当我们使用了javac和java的时候，系统就自动的到这个文件夹里面去找。

配置完了环境变量之后，一定要重新打开CMD才可以。
有部分同学，电脑重启之后，发现java和javac不能用了。

其实是windows的一个小bug。经常出现在部分win10的电脑中。

请按照以下的方式配置：

1.JAVA_HOME：还是写JDK的安装目录。

2.Path：不需要再次引用JAVA_HOME，直接写完整的路径就可以了。

D:\develop\JDK\bin;

总结：

1，你就按照我们最为标准的方式进行配置。

JAVA_HOME：JDK的安装目录。

Path：%JAVA_HOME%\bin

2，如果你的电脑重启之后，出现了环境变量失效的问题。

JAVA_HOME：还是写JDK的安装目录。

Path：D:\develop\JDK\bin;—把完整的路径写在path当中。

13，Notepad++软件

安装：傻瓜式安装，直接点击下一步就可以了。

建议：把跟开发相关的所有软件都放在同一个文件夹下面。（这样方便后期管理）

**设置：**如果你没有设置，那么以后在写中文的时候，会出乱码。

点击设置 — 首选项 ---- 新建 — windows — java ---- ANSI

14，注释

分类和格式：

单行注释： // 写上注释的内容就可以了

多行注释： /* 写注释的内容 */

文档注释（目前用不到了解即可）：/** 写注释的内容 */

作用：

1，对代码的解释说明

2，注释掉的内容，不参与运行。

15，关键字

举例：

人体，由很多很多的细胞组成的。

细胞是人体最基本的组成单元。

同样的道理：

Java的项目。也是由一个又一个的类，组成的，所以说。类是Java最基本的组成单元。

public class HelloWorld{
	public static void main(String [] args){
		System.out.println("hello123");
	}
}

class：就表示我现在要定义一个类了。

后面跟随的就是这个类的名字。

HelloWorld 就是这个类的名字。也称之为：类名。

类名后面：有一对大括号。这个大括号就表示类的范围。

public：现在我们只讲其中一种用法。

当public写在class前面时，强制要求，类名一定要跟文件名保持一致。

16，关键字的注意点

1，关键字全部小写

2，在常用的编辑器中，关键字会高亮显示

17，常量

字符串常量：只要是用双引号引起来的，就是字符串常量。

比如：“HelloWorld” “黑马程序员”

" "//里面有一个空格

“”//里面什么都没有

“123” //也是字符串常量

答案：以上全部都是字符串常量。

技巧：只要用双引号引起来的。不管里面是什么内容，也不管里面有没有内容，都是字符串常量。

整数常量：所有的不带小数点的整数都是整数常量。

比如：100,0，-100

小数常量：判断技巧：只要带小数点都是小数常量。
比如：1.1 1.2

字符常量：用单引号引起来的。

判断技巧：

1，必须用单引号引起来

2，单引号里面的内容，有且只能有一个。

布尔常量：目前先要记忆一下。

只有两个值： false true

空常量：目前先要记忆一下。不能直接使用。

null //表示什么都没有。这个在后面会详细的学习

问： “111” 这个是整数常量还是字符串常量？ 字符串常量

**问：10.0 这个是整数常量还是小数常量？**小数常量

问：‘’ //里面什么都没有。是不是字符常量？ 不是

‘ ’//里面有一个空格。是不是字符常量？是

‘中’//是不是字符常量？ 是

‘ab’//是不是字符常量？不是

问：“null” 这个是什么常量？是字符串常量。只不过里面的内容为 N,U,L,L而已。

咱们学习完了常量之后，只要达到一个什么目标？

我给你一个常量，你能告诉我，他是什么类型的常量就可以了。

1，常见的进制

学习目标：

1）知道什么是二进制

2）知道什么是十进制

3）了解八进制

4）了解十六进制

二进制：计算机中使用的就是二进制，每一位由0和1组成的，逢二进一。

十进制：现实生活中是十进制，每一位由0123456789组成，逢十进一。

八进制：每一位由01234567组成，逢八进一。

十六进制：每一位由0123456789abcdef，逢十六进一。

a其实就表示10，b就表示11，以此类推。。。

先不用考虑计算的规律，先把进制中的组成先看一下。

2，进制的表现形式

学习目标：

看到代码中的一串数字，知道他是几进制的表现形式，以及代码是否报错就可以了。

十进制：不加任何修饰的。

	System.out.println(10); //此时你发现10前面没有任何的前缀，
						 //那么就表示10是十进制下的。

二进制：0b开头的。

System.out.println(0b11);//此时你发现11前面有一个前缀，前缀是0b
						//那么就表示11是二进制下的。

八进制：0开头。

System.out.println(0123);//此时你发现123前面有一个前缀，前缀是0
						//那么就表示123是八进制下的。

十六进制：0x开头

System.out.println(0x123);//此时你发现123前面有一个前缀，前缀是0x
						//那么就表示123此时是十六进制下的。

判断技巧：看数字前面前缀

练习：

System.out.println(010);//8进制的，由0-7组成，不报错

System.out.println(0b123);//2进制的，报错。因为二进制是由0和1组成的。只有0和1，没有2和3

System.out.println(123);//十进制，由0-9组成，不报错

System.out.println(0x121a);//十六进制，右0-9a-f组成，不报错。

注意点：

这个前缀是在JDK7以上的版本才有效。

3，学会利用计算器进行进制之间的转换

把十进制的123转成二进制‭ 01111011‬

把二进制的 1111 转成十进制 ‭15‬

十进制125 --> 二进制 ‭01111101‬

把八进制下的123 --> 十进制 ‭83‬

4,计算机的存储规则

学习目标：

一个数字99如何存储到硬盘当中？

就是把99变成二进制存储到硬盘当中。

知道计算机中最小的存储单元是什么？

byte （因为一个bit只能表示0或者1，表示的内容太少了）
知道bit，byte，KB，MB，GB，TB之间的转换关系？

在二进制中，一个0或者一个1称之为比特位，bit

8个bit叫做一个字节（byte），字节也是计算机中最小的存储单元。

1024byte = 1KB

1024KB = 1MB

1024MB = 1GB

1024GB = 1TB

5，变量

学习目标：

什么是变量？

变量就是内存中的一个存储空间。空间中存储着经常发生改变的值。
变量的定义格式？

数据类型变量名 = 数据值;

数据类型：规定了这个小空间以后能存储的数据类型。

变量名：就是给这个小空间起的一个名字。

数据值：真正的存到小空间里面的值。（昨天学习的常量）

6，基本数据类型的四类八种

非常的重要，需要大家记住。

学习目标：记忆四类八种的名字。

整数类型：byte，short，int，long

浮点类型（小数类型）： float，double

字符类型：char

布尔类型：boolean

7，不同的数据类型在内存中占用字节个数

学习目标：

记住下面的7种数据类型，在内存中占用字节个数。

byte short int long float double char

1 2 4 8 4 8 2

8，不同的数据类型有不同的取值范围

学习目标：

1）记忆byte的取值范围

-128 ~ 127

把-200给byte行不行？不行，因为在byte当中最小到-128

把200给byte行不行？不行，因为在byte当中最大到127

2）知道int大概的取值范围

-21亿多 ~ 21亿多

3）知道小数的取值范围，跟整数的取值范围的关系

小数类型的取值范围要比整数类型的取值范围要大。
取值范围关系如下：

double > float > long > int > short > byte

4）默认使用的类型

如果以后定义整数类型的变量，默认使用 int

如果以后定义小数类型的变量，默认使用 double

9，变量的定义

学习完了数据类型，那么就可以结合对应的知识点来定义变量了。

学习目标：

会定义int类型，double类型，char类型，boolean类型的变量

定义格式：

数据类型变量名 = 数据值；

举例：

//定义一个整数类型的变量
int i = 100; //整数默认的数据类型
//定义一个小数的变量
double d = 10.1; //小数默认的数据类型
//定义一个字符类型的变量
char c = 'a';
//定义一个布尔类型的变量
boolean b = true;

学习目标：

1）知道什么是二进制

2）知道什么是十进制

3）了解八进制

4）了解十六进制

二进制：计算机中使用的就是二进制，每一位由0和1组成的，逢二进一。

十进制：现实生活中是十进制，每一位由0123456789组成，逢十进一。

八进制：每一位由01234567组成，逢八进一。

十六进制：每一位由0123456789abcdef，逢十六进一。

a其实就表示10，b就表示11，以此类推。。。

先不用考虑计算的规律，先把进制中的组成先看一下。

2，进制的表现形式

学习目标：

看到代码中的一串数字，知道他是几进制的表现形式，以及代码是否报错就可以了。

十进制：不加任何修饰的。

	System.out.println(10); //此时你发现10前面没有任何的前缀，
						 //那么就表示10是十进制下的。

二进制：0b开头的。

System.out.println(0b11);//此时你发现11前面有一个前缀，前缀是0b
						//那么就表示11是二进制下的。

八进制：0开头。

System.out.println(0123);//此时你发现123前面有一个前缀，前缀是0
						//那么就表示123是八进制下的。

十六进制：0x开头

System.out.println(0x123);//此时你发现123前面有一个前缀，前缀是0x
						//那么就表示123此时是十六进制下的。

判断技巧：看数字前面前缀

练习：

System.out.println(010);//8进制的，由0-7组成，不报错

System.out.println(0b123);//2进制的，报错。因为二进制是由0和1组成的。只有0和1，没有2和3

System.out.println(123);//十进制，由0-9组成，不报错

System.out.println(0x121a);//十六进制，右0-9a-f组成，不报错。

注意点：

这个前缀是在JDK7以上的版本才有效。

3，学会利用计算器进行进制之间的转换

把十进制的123转成二进制‭ 01111011‬

把二进制的 1111 转成十进制 ‭15‬

十进制125 --> 二进制 ‭01111101‬

把八进制下的123 --> 十进制 ‭83‬

4,计算机的存储规则

学习目标：

一个数字99如何存储到硬盘当中？

就是把99变成二进制存储到硬盘当中。
知道计算机中最小的存储单元是什么？

byte （因为一个bit只能表示0或者1，表示的内容太少了）
知道bit，byte，KB，MB，GB，TB之间的转换关系？

在二进制中，一个0或者一个1称之为比特位，bit

8个bit叫做一个字节（byte），字节也是计算机中最小的存储单元。

1024byte = 1KB

1024KB = 1MB

1024MB = 1GB

1024GB = 1TB

10 月24日就是程序员节

5，变量

学习目标：

什么是变量？

变量就是内存中的一个存储空间。空间中存储着经常发生改变的值。
变量的定义格式？

数据类型变量名 = 数据值;

数据类型：规定了这个小空间以后能存储的数据类型。

变量名：就是给这个小空间起的一个名字。

数据值：真正的存到小空间里面的值。（昨天学习的常量）

6，基本数据类型的四类八种

非常的重要，需要大家记住。

学习目标：记忆四类八种的名字。

整数类型：byte，short，int，long

浮点类型（小数类型）： float，double

字符类型：char

布尔类型：boolean

额外：

如果想定义一个字符串类型的变量：String String s = “aaa”;

7，不同的数据类型在内存中占用字节个数

学习目标：

记住下面的7种数据类型，在内存中占用字节个数。

byte short int long float double char

1 2 4 8 4 8 2

8，不同的数据类型有不同的取值范围

学习目标：

1）记忆byte的取值范围

-128 ~ 127

把-200给byte行不行？不行，因为在byte当中最小到-128

把200给byte行不行？不行，因为在byte当中最大到127

2）知道int大概的取值范围

-21亿多 ~ 21亿多

3）知道小数的取值范围，跟整数的取值范围的关系

小数类型的取值范围要比整数类型的取值范围要大。
取值范围关系如下：

double > float > long > int > short > byte

4）默认使用的类型

如果以后定义整数类型的变量，默认使用 int

如果以后定义小数类型的变量，默认使用 double

9，变量的定义

学习完了数据类型，那么就可以结合对应的知识点来定义变量了。

学习目标：

会定义int类型，double类型，char类型，boolean类型，字符串类型的变量

定义格式：

数据类型变量名 = 数据值；

举例：

//定义一个整数类型的变量
int i = 100; //整数默认的数据类型
//定义一个小数的变量
double d = 10.1; //小数默认的数据类型
//定义一个字符类型的变量
char c = 'a';
//定义一个布尔类型的变量
boolean b = true;
//定义一个字符串类型的变量
String s = "aaa";

案例：

根据不同数据，来选择不同的数据类型去定义变量

//要求大家，能根据具体的数据，来选择不同的数据类型
//定义姓名为：播仔
String s = "播仔";
//定义年龄为：2
int i = 2;
//定义身高
double d = 1.5;
//定义兴趣
String ss = "唱，跳，Rap,Java";
//定义性别
char c = '公'; //因为只有一个汉字，所以我们选择字符

10，变量的使用

学习目标：能说出下面案例的输出结果就可以了

int a = 10;
System.out.println(a);//10 因为在小括号中写一个字母，就会把a当做是变量
					//此时，变量里面的值是什么，那么就输出什么。
System.out.println("a");//a 因为在小括号中，小a前后有双引号。
					//此时就是输出一个字符串。会把字符串的内容原样输出。

11，修改变量的值

学习目标：下面案例的输出结果和为什么？

//表示定义一个变量a，变量里面记录的值为10.
int a = 10;
//表示把30赋值给变量a，那么变量中原来记录的那个值，就被覆盖了。
a = 30;
System.out.println(a);//30

细节：变量同时只能记录一个值。

12，变量的使用细节

1）变量的作用范围：

变量只能在当前所属的大括号中有效。

如果超出了这个大括号，变量就会消失。

2）变量名不允许重复定义

当第一个变量没有消失，那么不能定义同名的变量。

3）变量在使用之前必须要赋值

4）定义float和long类型变量的注意事项。

//定义一个long类型的变量
//数值后面要加一个后缀L，这个l可以是大写的，也可以是小写的。
//建议写大写。 
long l = 100L;  

//定义float类型的变量
//数值后面要加一个后缀F，这个f可以是大写的，也可以是小写的。
//建议写大写
float f = 10.1F;

其他类型的变量 byte short int double char boolean 都不需要加后缀。

byte b = 10;
short s = 100;
int i = 1000;
double d = 1.1;
char c = 'a';
boolean q = true;

13，标识符的硬性要求

标识符：就是在代码中起的名字。

目前为止，我们会给类名，变量名起名字。

我们自己起的名字，就是标识符。

硬性要求：一定有要这么做，如果不这么干，代码就报错。

数字，字母，下划线，美元符$组成
不能以数字开头
不能是关键字（在高级的编译当中，关键字会变色。）
区分大小写

技巧：以后在起名字的时候，尽量用字母 + 数字就ok。数字不要开头。

14，标识符的软性建议

软性建议：如果不这么干，代码不会报错。

但是会非常的low

当我们要定义变量名的时候：— 小驼峰命名法

一个单词：全部小写。比如： name age

多个单词：从第二个开始首字母大写：比如：maxAge

当我们定义类名的时候： — 大驼峰命名法

一个单词：首字母大写。比如：Demo

多个单词：每一个单词首字母大写：比如：HelloWorld

注意点：不管起什么名字，那么都需要做到见名知意。

String name //大概猜出来，这变量可能表示一个姓名。

担心：英文不好。

建议：1，装一个有道词典。

2，拼音。

15，隐式转换

核心思想：

把取值范围小的，给取值范围大的，是不会有问题的。

而且系统底层是自动放的，不需要我们自己额外写代码实现。

16，代码中什么时候会出现隐式转换呢？

情况一：

直接赋值的时候。

技巧：把小的给大的，就没有问题。

//第一个案例：
//10默认是int类型的，int的取值范围比double小
//所以，小的给大的没有问题
double d = 10；

//第二个案例：
byte b = 10;
//不会有问题。因为byte的取值范围比int小。
//所以，小的给大的没有问题
int i = b;

//第三个案例：
//不会有问题。因为int的取值范围比long小。
//所以，小的给大的没有问题
int i = 10;
long l = i;

情况二：

不同的数据类型参与计算。

小的数据类型和大的数据类型参与运算，会提升为大的那个类型
byte short char int 在参与运算的时候，不管有没有其他类型，都先提升为int，再计算。

判断技巧：

取值范围以int为界限。

比int大的，在计算的时候，最终会提升到取值范围最大的那个。

取值范围比int小的。不管有没有其他类型的变量，先变成int，然后再算。

案例一：
int i = 10;
double d = 20;
//此时int + double。double的取值范围是大的。
//所以，int会变成double，再参与运算。
//其实就是两个double相加。最终的结果result 是double类型的。
??? result = i + d;

案例二：
int i = 10；
long l = 20L；
//此时int + long。long的取值范围是大的。
//所以，int会变成long，再参与运算。
//其实就是两个long相加。最终的结果result 是long类型的。
？？？ result = i + l;


案例三：
long l = 100L；
double d = 20.0；
//此时long + double。double的取值范围是大的。
//所以，long会变成double，再参与运算。
//其实就是两个double相加。最终的结果result是double类型的。
？？？ result = l + d；

案例四：
int i = 10；
long l = 100L；
double d = 20.0；
//int + long + double。double的取值范围是最大的。
//所以，最终会提升为取值范围最大的那个。
//所以result就是double类型的。
？？？ result = i + l + d;


案例五：
byte b1 = 10;
byte b2 = 20;
//取值范围比int小的。不管有没有其他类型的变量，先变成int，然后再算。
//b1和b2都是byte类型的，而byte类型的取值范围是比int小的。
//所以，在计算的时候，b1和b2先变成int
//其实就是两个int相加。最终result 就是int类型的。
??? result = b1 + b2;

案例六：
byte b1 = 10;
byte b2 = 20;
byte b3 = 30;
//跟上面两个byte相加，是一样的。
??? result = b1 + b2 + b3;


案例七：
byte b = 10;
short s = 20;
long l = 100L;
//取值范围以int为界限。
	//比int大的，在计算的时候，最终会提升到取值范围最大的那个。
	//取值范围比int小的。不管有没有其他类型的变量，先变成int，然后再算。

//因为b和s的取值范围是比int小的。所以，在计算的时候，先把b和s提升为int
//此时就是 int + int + long
//又因为long的取值范围要比int大，所以，最终结果是long类型的。
//result 就是long类型的。

??? result = b + s + l;

17，强制转换

强制转换：（原本放不进去的，但是硬塞）

把一个取值范围大的给取值范围小的。

此时，正常来讲，是不能给的，但是如果一定要给，那么可以使用强制转换。

格式：想要转成什么类型，就在前面的小括号中写什么类型就可以了

int i = (int)88.88;//表示把88.88强制变成整数，再赋值给i。

弊端：有可能导致精度的丢失。

18，代码中什么时候会出现强制转换呢？

情况一：直接赋值。

把一个取值范围大的硬塞给取值范围小的。

案例一：
int i = 10;
//i是int类型的，b是byte类型的。 int类型的取值范围要大于byte取值范围
//所以直接给肯定是不行的。
//byte b = i;
//那么怎么办？硬塞
byte b = (byte)i;


案例二：
double d = 10.0；
//i是int类型的，d是double类型的。double> int
//所以把大的直接给小的肯定是不行的。
//int i = d；
//那么怎么办？硬塞
int i = (int)d；

情况二：

在计算的过程中，把大的给小的。

案例一：
int i1 = 10;
int i2 = 20;
//等号的右边是两个int相加。
//此时把int赋值给byte，就是把一个大的给一个小的。肯定错误了。
//修改一：把b的类型变成int
byte b1 = i1 + i2;

//修改二：把最终的结果塞给b --- 正确的。
byte b2 = （byte）(i1 + i2);

//错误的硬塞方式
//把i1先变成byte，再把i2变成byte
//然后i1 + i2 --- 变成两个byte类型的变量相加。还会自动提升为int
byte b3 = (byte)i1 + (byte)i2



案例二：
//把20升的水放到11升的桶当中。能放。但是多出来的水会丢。
int i = 300；
//知道一个结论：如果塞的时候，数值过大，那么最终结果是错误的。
//具体最终的结果是多少，这个不需要研究。
byte b = (byte)i；//要知道，这个结果不是300就可以了。

19，转换的核心

隐式转换：把小的给大的。

强制转换：把大的给小的。

强调：强制转换的结果，不需要研究，因为这个会设计到底层很深的知识点。

就算是研究透了，对后面的学习也没什么太大的帮助。

咱们只要知道，如果超出范围还要强制转换，那么数值会出错，也就是跟和原来的不一样。

20，整数的常量优化机制

byte b = 10;
//在写代码的时候，这个不会报错。
//10是一个整数，默认是int类型
//int比byte大，为什么不报错啊？

判断技巧：

触发时机：等号的右边全部都是整数。

会看等号右边最终的结果，是不是在左边这个类型的范围中。

如果在，那么正常赋值，不会报错。

如果不在，就会报错。

byte b = 10;
//此时因为等号的右边都是整数。所以触发了整数的常量优化机制。
//会看10是否在byte的取值范围之内，如果在，正常赋值，不会报错。

byte b = 300;
//此时因为等号的右边都是整数。所以触发了整数的常量优化机制。
//会看300是否在byte的取值范围之内。此时不在，所以报错。

byte b = 3 + 4；
//因为等号的右边都是整数，所以触发了整数的常量优化机制。
//此时在编译的时候，等号的右边就变成了最终的结果7
//会看7是否在byte的取值范围之内，如果在，正常赋值，不会报错。

21，字符参与运算

技巧：

字符什么时候会去查询ASCII码表。

1，字符参与运算。

2，字符赋值给整数类型的变量，或者赋值给小数类型的变量。

案例一：
int i = 1;
char c = 'a';
//此时字符参与了运算。
//所以他要拿着字符a到ASCII码表中查，查到了数字97
//再拿着97 跟数字 1进行相加。 结果就是98
System.out.println(i + c); //98


案例二：
int a = 10；
char c = 'b';
//因为字符参与了运算，所以要查码表
//查到b字符对应的数字是98，所以98 + 10 结果为108
System.out.println(a + c); //108

案例三：
//把一个字符a。赋值给整数类型的变量。
//此时到ASCII码表中查，查到对应的数字为97，赋值给a变量
int a = 'a';
System.out.println(a); //97

建议：

‘a’ — 97

‘A’ — 65

‘0’ — 48

在ASCII码表中，字符跟数字，一一对应的。

double d = ‘a’;//首先还是查码表，变成97，再把97，赋值给double，最终变成97.0

JavaDay03

运算符（算术运算符、赋值运算符、逻辑运算符）
键盘录入（三元运算符、键盘录入）
IDEA （课程资料 - B课程软件 - b工具idea）

第一章运算符

第01节算术运算符

分类情况

算术运算符符号	算术运算符例子
+	a+b
-	a-b
*	a*b
/	a/b
%	a%b

字符参与加法运算

含义

如果我们是字符（char）类型的数据，进行加法的操作时候，拿着我们字符对应的 数据值进行相加。
一个字符数据，对应一个 整数值。

存在一个ASCII码表，他有对应关系

字符	整数
`'0'`	`48`
`'A'`	`65`
`'a'`	`97`

如果我们忘记了这个对应关系的数据值是多少应该怎么办？假设忘记了 'A' 对应的整数值是多少？

//验证，如果忘记了 字符'A' 对应的数据是多少的情况，应该怎么操作？  'A'->65
public class Test01 {

    //生成 main 方法，快捷键 psvm
    public static void main(String[] args) {
        //定义一个字符，他的数据值是 'A'
        char c1 = 'A';
        System.out.println(c1);  //A
        //如果我们需要显示出，当前的A值是多少
        System.out.println(c1 + 0);  //65
    }
}

练习：输出我爱你 三个汉字对应的整数值是多少

//我想要查看 "我爱你" 对应的数据值是多少？ 每一个汉字底层都是一个数字
public class Test02 {

    public static void main(String[] args) {
        //定义三个字符数据
        char c1 = '我';
        char c2 = '爱';
        char c3 = '你';

        //查看对应的整数值分别是多少
        System.out.println(c1 + 0);  //25105
        System.out.println(c2 + 0);  //29233
        System.out.println(c3 + 0);  //20320
    }
}

小学数学问题

题目

【小学三年级】
  	有14个苹果（apple） 交给4个小朋友（child） 进行分配，请问一个小朋友分配几个？剩余几个？
  	小学的计算方式：
  			14➗4=3.....2   这里的3就是商，2就是余数。
		Java程序的写法
  			int apple = 14;
				int child = 4;
				int shang = apple/child;
				int yuShu = apple%child;

案例代码

public class Test03 {

    public static void main(String[] args) {
        int apple = 14;
        int child = 4;
        int shang = apple/child;
        int yuShu = apple%child;
        //快捷键，可以直接展示出，变量的名称+变量值 这种形式。 soutv
        System.out.println("shang = " + shang);  //shang = 3
        System.out.println("yuShu = " + yuShu);  //yuShu = 2
    }
}

题目

【小学五年级】
  	有14个苹果（apple） 交给4个小朋友（child） 进行分配，请问一个小朋友平均分配多少个？（苹果可以切开）
  	小学的计算方式：
  			14➗4=3.5   需要得到小数的结果。
		Java程序的写法
  			int apple = 14;
				int child = 4;
				//如果需要得到小数的结果，必须有浮点数参与运算。
				double result = 1.0*apple/child;

案例代码

public class Test04 {

    public static void main(String[] args) {
        int apple = 14;
        int child = 4;
        //如果需要得到小数的结果，必须有浮点数参与运算。
        double result = 1.0*apple/child;
        //快捷键输出结果 soutv
        System.out.println("result = " + result);  //result = 3.5
    }
}

第02节赋值运算符

基础的赋值运算符

就是 = 基础的赋值运算符。
  int a = 3;
	//将数据3赋值给 int 类型的变量 a    说法：从右往左

拓展的赋值运算符

short s = 1;
s+=1; 相当于是  s = (short)(s+1)

也就是说，我们在拓展的赋值运算符当中，如果写。 x+=y 这样的式子的时候。相当于是 x = (x的数据类型)(x+y);

第03节逻辑运算符

逻辑运算符的作用

逻辑运算符主要是用来，连接关系表达式的。

//我们在代码当中，不能写 3<m<8 这样的式子，这是数学当中的写法，程序是无法识别的，需要分开写。 m>3 && m<8

常用的逻辑运算符

逻辑运算符	规则
&&	有false 则 false
｜｜	有true 则 true
！	非 true 则 false，非 false 则 true

与和或的符号是如何输出的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KIJqs07U-1592980421978)(C:/Users/冷韬/Desktop/新建文件夹/JavaDay03.assets/image-20200523195016948.png)]

第二章键盘录入

第01节键盘录入

为什么需要有键盘录入

键盘录入就是为了 让我们能够动态的输入数据到程序当中，由程序帮我们进行一系列的运算过程。展示出结果。
最开始的数据，一般来自于键盘录入， Java 为我们提供了 Scanner 类可以去实现键盘录入。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zvRRUjZJ-1592980421983)(C:/Users/冷韬/Snipaste_05-23_19-55-58.png)]

上面有个输入框，输入框的数据，就是来自于键盘录入。我们在百度的输入框里面，输入了一个数据，点击搜索按钮的时候，查询得到结果。后期的键盘录入，都是和浏览器（前端）结合使用的，我们现在的键盘录入，只是基础阶段会使用到。

第02节键盘录入操作步骤

【1】 import java.util.Scanner;    //导包
【2】 Scanner  sc = new Scanner(System.in);   //创建对象
【3】 int  num = sc.nextInt();     //录入数据

为什么要这样写，前期不做过多的解释，需要学习了面向对象之后，才能明白。

只需要知道是三个步骤，这样写就行了。大概在 6月15日学完了面向对象之后，就明白了。

案例代码

//[1]导包
import java.util.Scanner;

//键盘录入入门案例
public class Test01 {

    public static void main(String[] args) {
        //[2]创建对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数据：");
        //[3]输入数据
        int num = sc.nextInt();
        System.out.println(num);
    }
}

第03节三个数据求最小值

题目需求：

键盘录入三个数据，找到最小的，打印输出。

案例代码

//【1】导包
import java.util.Scanner;

//键盘录入 三个数据求最小值
public class Test02 {

    public static void main(String[] args) {
        //【2】创建对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个数据：");
        int a = sc.nextInt();
        System.out.println("请输入第二个数据：");
        int b = sc.nextInt();
        System.out.println("请输入第三个数据：");
        int c = sc.nextInt();
        //---------
        //三个数据找到最小值，采用三元运算符
        //I.  判断a<b 条件成立吗？
        //II. 如果条件成立， temp=a
        //III.如果条件不成立, temp=b
        int temp = a<b ? a:b;
        //再次采用三元运算符，求出temp和c的最小值
        int min = temp<c ? temp:c;
        //打印输出结果 soutv
        System.out.println("min = " + min);
    }
}

JavaDay05笔记

三种循环的基础回顾
循环常规的解题思路

第一章三种循环的基础回顾

第01节 for 循环

//for循环基础案例
public class DemoFor {
    public static void main(String[] args) {
        //[1]初始化语句   int i = 1;
        //[2]判断条件语句  i<5;
        //[3]循环体语句   System.out.println(i);
        //[4]循环控制语句  i++;
        for (int i = 1; i < 5; i++) {
            System.out.println(i);
        }
    }
}

//执行的顺序是：  
//第一次： [1][2][3][4]   打印输出的数据1
//第二次： [2][3][4]      打印输出的数据2
//第三次： [2][3][4]    	打印输出的数据3
//第四次： [2][3][4]			打印输出的数据4
//第五次： [2]					  条件不满足,循环结束

第02节 while循环

//while循环基础案例
public class DemoWhile {
    public static void main(String[] args) {
        //[1]初始化语句   int i = 1;
        //[2]判断条件语句  i<5;
        //[3]循环体语句   System.out.println(i);
        //[4]循环控制语句  i++;
        int i = 1;
        while(i<5){
            System.out.println(i);
            i++;
        }
    }
}

//执行的顺序是：  
//第一次： [1][2][3][4]   打印输出的数据1
//第二次： [2][3][4]      打印输出的数据2
//第三次： [2][3][4]    	打印输出的数据3
//第四次： [2][3][4]			打印输出的数据4
//第五次： [2]					  条件不满足,循环结束

第03节 do…while循环

//do...while循环基础案例
public class DemoDoWhile {
    public static void main(String[] args) {
        //[1]初始化语句   int i = 1;
        //[2]判断条件语句  i<5;
        //[3]循环体语句   System.out.println(i);
        //[4]循环控制语句  i++;
        int i = 1;
        do{
            System.out.println(i);
            i++;
        }while(i<5);
    }
}

//执行顺序：
//第一次：  [1][3][4][2]    打印输出的数据1
//第二次：  [3][4][2]				打印输出的数据2
//第三次：  [3][4][2] 			打印输出的数据3
//第四次：  [3][4][2]				打印输出的数据4
//第五次：	没有继续执行了， 因为在第4次执行[2]判断条件语句的时候 i=5 条件不成立，整个循环结束。

第二章循环的常规解题思路

第01节练习打印输出1-5 和 5-1

案例代码

//循环输出数据 1-5 和 5-1
public class Test01 {
    public static void main(String[] args) {
        System.out.println("循环输出数据 1-5：");
        for (int i = 1; i <= 5; i++) {
            System.out.println(i);
        }
        //最终展示的结果是 1，2，3，4，5
        System.out.println("循环输出数据 5-1：");
        for (int i = 5; i > 0; i--) {
            System.out.println(i);
        }
    }
}

运行效果

循环输出数据 1-5：
1
2
3
4
5
循环输出数据 5-1：
5
4
3
2
1

思考问题

通过这个题目，我们学会了什么问题？ 什么时候考虑循环操作？
  	在我们遇到【范围】问题的时候，需要考虑循环操作。
		例如： 上面的 1-5 和 5-1 这里都是 "范围" 所以需要使用循环操作。
		范围存在 开始位置 和 结束位置。
		开始位置就是 循环的初始化语句，结束位置 就是循环的判断条件语句。

第02节练习求和操作，计算1-5数据和

案例代码

//循环求和操作，计算 1+2+3+4+5 总和
public class Test02 {
    public static void main(String[] args) {
        // 循环前，定义 求和变量
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            // 循环中，累加 累加求和
            sum += i;
        }
        // 循环后，输出 输出求和结果
        System.out.println(sum);
    }
}

运行结果

思考问题

通过这个题目，我们学会了什么操作 ？ 学会了求和操作。
求和操作的固定套路： 三步走
  	1. 循环前， 定义    int sum = 0;
		2. 循环中， 求和		sum += i;
  	3. 循环后， 打印		System.out.println(sum);

第03节练习求偶数和 1-100

案例代码

// 循环求1-100偶数总和
public class Test03 {

    public static void main(String[] args) {
        //定义求和变量
        int sum = 0;
        //遍历范围在 1-100之间
        for (int i = 1; i <= 100; i++) {
            //判断是否满足偶数要求
            if (i % 2 == 0) {
                //累加求和操作
                sum += i;
            }
        }
        //输出结果
        System.out.println(sum);
    }
}

运行结果

思考问题

通过这个题目，我们学会了什么操作 ？  学会了 for 循环 和 if 语句搭配使用。
		for 循环和 if 语句搭配使用的含义是什么？
		我们前面的时候，说过 for 循环，表示的是 "范围"  if 语句实际上表示的是 "筛选"
		当 for 循环 和 if 语句搭配使用的时候，实际上就是说 "在一定范围内，筛选满足要求的数据，采用for和if搭配使用"

第04节练习求水仙花数

案例代码

//求出所有的水仙花数据
public class Test04 {

    public static void main(String[] args) {

        //水仙花数据是一个三位数，满足以下条件：
        //百位的立方 + 十位的立方 + 个位的立方 = 这个数据本身
        //1*1*1 + 5*5*5 + 3*3*3 = 153
        //-----------
        for (int i = 100; i < 1000; i++) {
            //求出个位、十位、百位 数字
            int ge = i%10;
            int shi = i/10%10;
            int bai = i/100%10;
            //判断是否满足水仙花的要求
            if (bai*bai*bai + shi*shi*shi + ge*ge*ge == i){
                System.out.println(i);
            }
        }
    }
}

运行结果

思考问题

通过这个题目，我们学会了什么操作 ？  
  	还是在介绍。for循环和if语句搭配使用的情况。 在一定范围内，筛选满足要求的数据。
		在三位数（100 - 1000）之间，筛选满足水仙花数据要求的

第05节练习求水仙花数据的个数

案例代码

//水仙花数，个数统计
public class Test05 {

    public static void main(String[] args) {
        //循环前，定义统计变量
        int count = 0;
        //获取所有的三位数
        for (int i = 100; i < 1000; i++) {
            int ge = i%10;
            int shi = i/10%10;
            int bai = i/100%10;
            //判断是否是水仙花数据
            if (bai*bai*bai + shi*shi*shi + ge*ge*ge == i){
                //循环中，统计变量自增
                count++;
            }
        }
        //输出统计变量
        System.out.println(count);
    }
}

运行结果

思考问题

通过这个题目，我们学会了什么操作 ？ 学会了统计的操作。
		统计操作的 三步走：
  		1. 循环前， 定义   int count = 0;
			2. 循环中， 自增   count++;
			3. 循环后， 打印   System.out.println(count);

第06节打印输出语句的问题

疑问

老师，我们的 打印输出语句 什么时候，写在循环里面？ 什么时候，写在循环外面？  System.out.println();

回答

如果你想要一个结果，那么写在循环外。 如果你想要多个结果，那么写在循环内。 //循环是多次出现。

思考问题： 
  	求和是几个结果？  
  		1个结果，打印输出语句写在循环外。
		求个数 统计多少个，有几个结果？
  		1个结果，打印输出语句写在循环外。
		打印输出所有的水仙花数，请问这里是几个结果？
  		不止1个结果，应该写在循环内。

JavaDay07

数组的快速入门
数组基础练习

第一章数组的快速入门

第01节为什么需要使用数组

数组的由来

我们之前定义变量的时候，一次只能定义一个变量。
如果是遇到多个变量的情况，需要定义多次，但是实际操作的过程当中，不可能全部采用变量形式去定义。
//例如： 班级当中，有200个学生，需要定义200个学生的姓名，如果采用定义变量的写法，非常的麻烦。
遇到多个变量，如何定义的呢？
采用的是 数组。

数组用于解决什么问题

1. 多个相同数据类型
2. 多个变量

学习数组的目的

1. 了解 容器 的概念。 为后面的课程【集合】做准备的。
2. 了解 引用数据类型的概念。 为后面的课程【面向对象】做准备。

第02节数组的定义格式

动态初始化

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

例如：
  	int[]  arr1 = new  int[3];  //定义了一个int类型的数组，长度是3
		double[] arr2 = new double[5]; //定义了一个double类型的数组,长度是5

静态初始化

格式：
  	数据类型[]  数组名称 = new 数据类型[]{ 数值1,数值2,数值3,数值4 .... };     //完整格式
		数据类型[]  数组名称 = { 数值1,数值2,数值3,数值4 ....  };  //省略格式

例如：
  	int[]  arr1 = new int[]{ 11,22,33,44 };
		char[] arr2 = { 'A','B','C','D','E'};

如何选择对应的格式初始化

动态初始化： 只是知道数组的长度大小，不知道具体的元素。那么采用的是动态初始化。
静态初始化： 知道了具体的元素，不需要操心长度大小，采用静态初始化。
// 评判的依据 "是否知道了具体所有的元素"

第03节快速入门案例

//数组的快速入门
public class Demo {

    //川哥，想要招募 LOL战队的队友，需要5名队友去韩国参加LOL比赛
    public static void main(String[] args) {
        //定义数组，需要5名队友
        String[] fhcqArr = new String[5];

        //招募队友
        fhcqArr[0] = "上单提莫旭义";
        fhcqArr[1] = "打野亚索森源";
        fhcqArr[2] = "中单劫刘佣";
        fhcqArr[3] = "下路ADC佳卓";
        fhcqArr[4] = "辅助锤石舒迪";

        //展示数据
        System.out.println(fhcqArr); //[Ljava.lang.String;@77459877
        System.out.println(fhcqArr[0]); //上单提莫旭义
        System.out.println(fhcqArr[1]); //打野亚索森源
        System.out.println(fhcqArr[2]); //中单劫刘佣
        System.out.println(fhcqArr[3]); //下路ADC佳卓
        System.out.println(fhcqArr[4]); //辅助锤石舒迪

        System.out.println("===========");
        //例如： 去韩国比赛的过程当中，下路ADC佳卓，身体不适，不能参赛，换成替补队员上场
        fhcqArr[3] = "下路星妈梁涌";

        //一般情况下，会采用数组的遍历操作。使用的方式是 数组名称.fori 回车
        for (int i = 0; i < fhcqArr.length; i++) {
            System.out.println(fhcqArr[i]);
        }
    }
}

第二章数组的基础练习

第01节数组的遍历

//数组的遍历操作
public class Test01 {

    public static void main(String[] args) {
        //定义数组
        int[] arr = {
                11,22,33,44
        };

        //正向遍历数组。 快捷键 数组名称.fori 回车
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        //11   22   33  44

        System.out.println("==============");
        //反向遍历数组。 快捷键 数组名称.forr 回车
        for (int i = arr.length - 1; i >= 0; i--) {
            System.out.println(arr[i]);
        }
        //44  33  22  11
    }
}

第02节制作随机点名

import java.util.Random;

//数组制作随机点名效果
public class Test02 {

    public static void main(String[] args) {

        //定义字符串类型的数组，存放的是大家的姓名
        String[] nameArr = {
                "尼古拉斯阿伟","爱谁谁","我不知道","阿紫","老严"
        };

        //需要进行随机数点名的效果，采用随机数 Random
        Random r = new Random();

        //我们随机的操作，应该是随机 数组的索引值，索引是从0开始到数组的最大长度减去1
        int index = r.nextInt(nameArr.length);

        //获取到具体的人的姓名
        System.out.println(nameArr[index]);
    }
}

1，数组的介绍

数组是一个容器，可以同时存储多个值。

建议：数组的类型要跟实际存储数据的类型保持一致。

举例1：

要存入 1，2 ，3，4，5。

可以定义int类型的数组去存储这5个值。

举例2：

要存入1.1，2.2 ，3.3 ，4.4， 5.5， 6.6

可以定义double类型的数组去存储这6个值。

举例3：

要存入 “aaa”， “bbb”，“ccc”

可以定义String类型的数组去存储这3个值。

练习1：

我要存储10个同学的姓名？问：我要定义什么类型的数组？

“成语” “陈瑜超” “李宗翰” ----> String

练习2：

我要存储10个同学的年龄？问：我要定义什么类型的数组？

16，15，15 ----> 整数，所以选择int类型的数组。

2，数组的定义

格式一：

数据类型 [] 数组名

举例：

int [] arr

解释：

int：是数据类型，表示数组以后只能存储int类型的整数

[] ：表示我现在定义的是一个数组

arr：其实就是一个变量名。在定义的时候要遵守小驼峰命名法。

现在他表示数组的名字。

格式二：

数据类型数组名 []

举例：

int arr []

解释：

请参见格式一的解释。

练习1：

我要存储多个同学的姓名？ —> 该怎么写？

String [] namesArr //最为常用的。

String namesArr[]

练习2：

我要存储多个同学的年龄？ —> 该怎么写？

int [] agesArr //最为常用的。

int agesArr []

练习3：

我要存储多个同学的身高？ —> 该怎么写？

double [] heightsArr //最为常用的。

double heightsArr []

3，数组的动态初始化

格式：

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

举例：

//创建一个长度为3的数组，数组类型为int
int [] arr = new int [3];
//int : 就表示数组以后只能存int类型的整数
//[] : 定义的是一个数组
//arr： 数组的名字
//new：关键字。在内存中开辟了一个小空间。
//int：就表示数组以后只能存int类型的整数
//[3]: 表示现在的这个数组长度为3.

注意点：

1，等号前面和后面的数据类型要完全保持一致。

2，new关键字，表示在内存中开辟了一个小空间。

3，方括号中的数字3，表示数组的长度。

数组一旦创建好了，长度是不能发生变化的。

这个3，就好比把数组里面分为了3个小格子，每一个小格子可以存储一个数据。

如果数组的长度为10，那么就好比把数组里面分为了10个小格子，每一个小格子可以存储一个数据。

如果数组的长度为20，那么就好比把数组里面分为了20个小格子，每一个小格子可以存储一个数据。

4，索引

索引就是数组中每一个小格子的编号。

特点：

索引是从0开始的。

索引是连续的。

索引是逐一增加的，每次加1。

索引的范围：

最小索引：0

最大索引：数组长度 - 1

5，索引的使用

利用索引获取数组中的元素。

举例：

//创建了一个长度为3的数组
int [] arr = new int[3];
//在这个数组中，索引的范围：0 1 2

//1.我想获取0索引上的数据。
int number1 = arr[0];//表示我要获取arr这个数组0索引上的元素。
System.out.println(arr[0]);


//2.我想获取1索引上的数据。
int number2 = arr[1];
System.out.println(arr[1]);

//3.我想获取2索引上的数据。
int number3 = arr[2];
System.out.println(arr[2]);

6，数组的默认值

整数：默认值0

小数：默认值0.0

布尔：默认值false

字符：默认值空字符

引用数据类型：默认值null

举例：

int [] arr = new int[3];

解释：

仅仅是等号右边这段代码的内存解释：

会在内存中开辟了一个小空间，然后再把这个小空间分为了3个小格子。

每一个小格子，都有对应的索引，分别为0 1 2

因为数组是int类型的，所以每一个小格子里面，都有一个默认值0

所以，我们通过arr+索引的方式可以获取出来的，其实就是数组的默认值。

7，一个数组的内存图

请参见资料中的图解：

一个数组的内存图.png

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JIjMIyOY-1592980421985)(C:/Users/冷韬/Desktop/新建文件夹/一个数组的内存图.png)]

8，两个数组的内存图

请参见资料中的图解：两个数组的内存图解.png[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JChzQtKB-1592980421987)(C:/Users/冷韬/Desktop/新建文件夹/两个数组的内存图解.png)]

注意点：

只要看到new，就是在堆里面开辟了一个新的小空间。

8，两个数组指向同一个小空间

代码：

		int [] arr1 = new int [3];
        int [] arr2 = arr1;//把变量arr1记录的地址值赋值给了变量arr2
                        //是不是又开了一个空间？
                        //不是的。因为这里只有一个new

        arr2[0] = 10;
        arr2[1] = 20;
        arr2[2] = 30;

        System.out.println(arr1[0]);//10
        System.out.println(arr1[1]);//20
        System.out.println(arr1[2]);//30
        System.out.println("=================");
        System.out.println(arr2[0]);//10
        System.out.println(arr2[1]);//20
        System.out.println(arr2[2]);//30

图解：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rw5VcXfY-1592980421988)(C:/Users/冷韬/Desktop/新建文件夹/两个数组指向同一个小空间的图解.png)]

注意点：

arr[索引] = 值；

值到底赋值给谁？就看arr这个变量记录的是谁的地址值。

JavaDay09

方法重载
参数传递
断点调试
练习题
考试细节

第一章方法重载

第01节方法重载有什么作用

方法重载有什么作用，有什么好处，为什么需要使用方法重载

方法重载：可以减少对于方法的命名次数。

//例如：
//定义求两个数据和的方法，名称叫做 getSum2
//定义求三个数据和的方法，名称叫做 getSum3
//定义求四个数据和的方法，名称叫做 getSum4
//----》对于方法的命名次数就非常的多了，现实操作的过程当中，可能有N种求和的方式，最好的方式是只有一个名称，那么就是 getSum

第02节方法重载的特点

如何辨别是否是正确的方法重载呢？

十二个字：
  	"同一个类，同名方法，参数不同"

方法的重载发生在 同一个类当中，方法的名称是相同的，参数是不相同的。（参数指的是类型不同、顺序不同、个数不同）

第二章参数传递

第01节两种参数

两种参数

1. 形式参数：形参。 写在方法定义的小括号里面的
2. 实际参数：实参。 写在方法调用的小括号里面的

例如

public class Demo{
  	public static void main(String[] args){
     			//定义两个变量
      		int x = 3;
      		int y = 4;
      		//调用方法
      		getSum(x,y);
      		//----------
      		//调用方法
      		getSum(10,20);
    }
  
  	//定义方法
  	public static int getSum(int a,int b){
      	int result = a + b;
      	return result;
    }
}

备注说明：

上述案例当中，谁是形参，谁是实参。

形参： int a 和 int b

实参： x , y , 10, 20

第02节参数传递的结论

结论：

如果方法的参数是 【基本数据类型】 那么 形式参数的改变 【不影响】 实际参数。   //值传递
如果方法的参数是 【引用数据类型】 那么 形式参数的改变 【影响】 实际参数。			//地址传递

回顾：

基本数据类型： 四类八种
  	A. 整数。    byte short int long
  	B. 浮点数。  float. double
		C. 字符。  char
		D. 布尔。  boolean

引用数据类型：
  	A. 数组 int[] 
		B. 字符串 String
		C. 类

第三章断点调试

第01节断点调试的作用

为什么需要使用断点调试呢？它有什么好处？

两个作用：
  	1. 查看程序的执行流程（前期）
		2. 调试应用程序，检查错误（后期）

//应用场景： 我们会发现，课堂当中讲解的内容，当时可以听明白，课后下去看代码的时候，发现看不懂了。需要使用断点调试。

第02节如何使用断点调试

使用断点调试的方式

三个步骤：
  	1. 添加断点（哪里不会点哪里）
		2. debug运行 （两个快捷键 F7,F8）
		3. 清除断点

具体的操作，可以参考 川哥笔记 CHM 格式 ---》 预习资料，在QQ群共享当中有，可以随时查看。

第四章练习题

第01节需求说明

大家应该去网吧上过网。上网的过程当中，会存在收取网费的问题。
	
例如：
		1个小时，网费收取为5元。 不满1个小时，按照1小时进行计算， 超过1小时，按照2小时进行计算。
		那么现在，请通过键盘录入的形式，录入具体上网的时间，计算花费的网费数目，打印输出。

效果：
		请输入你的上网时长：
  	30
		你上网时长为30分钟，共计网费5元。
		请输入你的上网时长：
  	320
		你上网时长为320分钟，共计网费30元。

第02节代码实现

方式1:

import java.util.Scanner;

//计算网费
public class Test {

    public static void main(String[] args) {

        //因为需要使用到 键盘录入的操作，采用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的上网时长：");
        int minute = sc.nextInt();   //minute:分钟

        //计算花了多少钱？  30->5元   320->30元。
        //1. 需要先计算小时数目，将分钟，转换成为 整数的小时。（取整数）
        //第一步：先计算 minute%60==0 是否成立，是否能够整除
        //第二步：如果可以整除，那么 商就是结果 （minute/60）
        //第三步：如果不能整除，那么 商+1就是结果 （minute/60+1）
        int hour = (minute % 60 == 0) ? (minute / 60) : (minute / 60 + 1);

        //2. 根据小时数目，去计算花费多少钱
        int money = hour * 5;

        System.out.println("你上网时长为" + minute + "分钟，共计网费" + money + "元");
    }
}

方式2:

import java.util.Scanner;

//计算网费
public class Demo {

    public static void main(String[] args) {

        //因为需要使用到 键盘录入的操作，采用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的上网时长：");
        int minute = sc.nextInt();   //minute:分钟

        //计算花了多少钱？  30->5元   320->30元。
        //1. 需要先计算小时数目，将分钟，转换成为 整数的小时。（取整数）
        //第一步：先计算 minute%60==0 是否成立，是否能够整除
        //第二步：如果可以整除，那么 商就是结果 （minute/60）
        //第三步：如果不能整除，那么 商+1就是结果 （minute/60+1）
        int hour;
        //进行判断
        if (minute % 60 == 0){
            hour = minute / 60;
        }else{
            hour = minute / 60 + 1;
        }

        //2. 根据小时数目，去计算花费多少钱
        int money = hour * 5;
        System.out.println("你上网时长"+minute+"网费"+money);
    }
}

【影响】实际参数。 //地址传递




回顾：

```java
基本数据类型： 四类八种
  	A. 整数。    byte short int long
  	B. 浮点数。  float. double
		C. 字符。  char
		D. 布尔。  boolean

引用数据类型：
  	A. 数组 int[] 
		B. 字符串 String
		C. 类

第三章断点调试

第01节断点调试的作用

为什么需要使用断点调试呢？它有什么好处？

两个作用：
  	1. 查看程序的执行流程（前期）
		2. 调试应用程序，检查错误（后期）

//应用场景： 我们会发现，课堂当中讲解的内容，当时可以听明白，课后下去看代码的时候，发现看不懂了。需要使用断点调试。

第02节如何使用断点调试

使用断点调试的方式

三个步骤：
  	1. 添加断点（哪里不会点哪里）
		2. debug运行 （两个快捷键 F7,F8）
		3. 清除断点

具体的操作，可以参考 川哥笔记 CHM 格式 ---》 预习资料，在QQ群共享当中有，可以随时查看。

第四章练习题

第01节需求说明

大家应该去网吧上过网。上网的过程当中，会存在收取网费的问题。
	
例如：
		1个小时，网费收取为5元。 不满1个小时，按照1小时进行计算， 超过1小时，按照2小时进行计算。
		那么现在，请通过键盘录入的形式，录入具体上网的时间，计算花费的网费数目，打印输出。

效果：
		请输入你的上网时长：
  	30
		你上网时长为30分钟，共计网费5元。
		请输入你的上网时长：
  	320
		你上网时长为320分钟，共计网费30元。

第02节代码实现

方式1:

import java.util.Scanner;

//计算网费
public class Test {

    public static void main(String[] args) {

        //因为需要使用到 键盘录入的操作，采用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的上网时长：");
        int minute = sc.nextInt();   //minute:分钟

        //计算花了多少钱？  30->5元   320->30元。
        //1. 需要先计算小时数目，将分钟，转换成为 整数的小时。（取整数）
        //第一步：先计算 minute%60==0 是否成立，是否能够整除
        //第二步：如果可以整除，那么 商就是结果 （minute/60）
        //第三步：如果不能整除，那么 商+1就是结果 （minute/60+1）
        int hour = (minute % 60 == 0) ? (minute / 60) : (minute / 60 + 1);

        //2. 根据小时数目，去计算花费多少钱
        int money = hour * 5;

        System.out.println("你上网时长为" + minute + "分钟，共计网费" + money + "元");
    }
}

方式2:

import java.util.Scanner;

//计算网费
public class Demo {

    public static void main(String[] args) {

        //因为需要使用到 键盘录入的操作，采用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的上网时长：");
        int minute = sc.nextInt();   //minute:分钟

        //计算花了多少钱？  30->5元   320->30元。
        //1. 需要先计算小时数目，将分钟，转换成为 整数的小时。（取整数）
        //第一步：先计算 minute%60==0 是否成立，是否能够整除
        //第二步：如果可以整除，那么 商就是结果 （minute/60）
        //第三步：如果不能整除，那么 商+1就是结果 （minute/60+1）
        int hour;
        //进行判断
        if (minute % 60 == 0){
            hour = minute / 60;
        }else{
            hour = minute / 60 + 1;
        }

        //2. 根据小时数目，去计算花费多少钱
        int money = hour * 5;
        System.out.println("你上网时长"+minute+"网费"+money);
    }
}