Java是什么？

最新推荐文章于 2021-08-07 17:14:09 发布

置顶 lentao1010520

最新推荐文章于 2021-08-07 17:14:09 发布

阅读量774

点赞数 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);
    }
}

lentao1010520

关注

3
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
Java是什么？

1，什么是Java？Java是一门非常火的计算机语言。（也叫做编程语言）我们想要让计算机做一些事情，那么就可以通过Java语言告诉计算机就可以了。2，Java的分类JavaSE：是其他两个的基础。温馨小提示：GUI,AWT的部分就可以不学了。 GUI和AWT是用于桌面应用的开发。 JavaSE现在已经不做桌面应用的开发了。现在就是其他两个的基础。JavaME：Java语言的小型版，用于嵌入式消费类电子设备开发或者小型移动设备开发。JavaEE：用于企业级别的WEB方向的网站开
复制链接

扫一扫

Java是什么？

1，什么是Java？

2，Java的分类

3，什么是跨平台？

4，Java语言跨平台的原理

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

6，JDK下载

7，什么是CMD

8，常见的CMD命令

9，要求掌握的练习

10，第一个小程序HelloWorld

11，配置环境变量的意义

12，配置环境变量的步骤

13，Notepad++软件

14，注释

15，关键字

16，关键字的注意点

17，常量

1，常见的进制

1）知道什么是二进制

2）知道什么是十进制

3）了解八进制

4）了解十六进制

2，进制的表现形式

学习目标：

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

二进制：0b开头的。

八进制：0开头。

十六进制：0x开头

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

练习：

注意点：

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

4,计算机的存储规则

学习目标：

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

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

知道bit，byte，KB，MB，GB，TB之间的转换关系？

5，变量

学习目标：

什么是变量？

变量的定义格式？

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

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

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

学习目标：

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

学习目标：

1）记忆byte的取值范围

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

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

4）默认使用的类型

9，变量的定义

学习目标：

1）知道什么是二进制

2）知道什么是十进制

3）了解八进制

4）了解十六进制

2，进制的表现形式

学习目标：

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

二进制：0b开头的。

八进制：0开头。

十六进制：0x开头

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

练习：

注意点：

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

4,计算机的存储规则

学习目标：

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

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

知道bit，byte，KB，MB，GB，TB之间的转换关系？

5，变量

学习目标：

什么是变量？

变量的定义格式？

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

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

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

第一章运算符

第01节算术运算符

第02节赋值运算符

第03节逻辑运算符

第二章键盘录入

第01节键盘录入

第02节键盘录入操作步骤

第03节三个数据求最小值

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

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

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

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

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

第04节练习求水仙花数

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

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

第一章数组的快速入门

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

第02节数组的定义格式

第03节快速入门案例

第二章数组的基础练习

第01节数组的遍历

第02节制作随机点名

数据类型数组名 []

第一章方法重载

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