就是在windows操作系统中，利用命令行的方式去操作计算机。
我们可以利用cmd命令去操作计算机，比如：打开文件，打开文件夹，创建文件夹等。
按下快捷键：win + R。
此时会出现运行窗口。
在运行窗口中输出cmd
输出回车。
解惑：
cmd默认操作C盘下的users文件夹下的XXX文件夹。（XXX就是计算机名）
扩展一个小点：
在很多资料中都说成是DOS命令，其实是不对的。真正的DOS命令是1981年微软和IBM出品的MS-DOS操作系统中的命令才叫做DOS命令。
而在Windows中，win98之前的操作系统是以非图形化的DOS为基础的，可以叫做DOS命令。到了2000年以后，windows逐渐的以图形化界面为主了，这个时候就不能叫DOS命令了，他只是模拟了DOS环境而已，很多的原本的DOS命令已经无法使用了，所以这个时候叫做CMD命令会更准确一些。
常见的CMD命令如下：
需求：
利用cmd命令打开自己电脑上的QQ。
完成步骤：
1,确定自己电脑上的QQ安装在哪里
2,启动cmd
3,进入到启动程序QQ.exe所在的路径。
4,输出qq.exe加回车表示启动qq。
在windows操作系统当中，文件名或者文件夹名是忽略大小写的。
语言：人与人交流沟通的表达方式
计算机语言：人与计算机之间进行信息交流沟通的一种特殊语言
Java是一门非常火的计算机语言。（也叫做编程语言）
我们想要让计算机做一些事情，那么就可以通过Java语言告诉计算机就可以了
开发Java程序，需要三个步骤：编写程序，编译程序，运行程序。
三个版本：
Java5.0：这是Java的第一个大版本更新。
Java8.0：这个是目前绝大数公司正在使用的版本。因为这个版本最为稳定。
Java17.0：这个也是一个永久版本
解惑：
我们学的跟工作中使用的版本不太一样啊。会不会影响以后工作呢？
向下兼容。新的版本只是在原有的基础上添加了一些新的功能而已。
举例：
用8版本开发的代码，用11版本能运行吗？必须可以的。
用11版本开发的代码，用8版本能运行吗？不一定。
如果11版本开发的代码，没有用到9~11的新特性，那么用8是可以运行的。
如果11版本开发的代码，用到了9~11的新特性，那么用8就无法运行了。
JavaSE、JavaME、JavaEE
1.8.1 JavaSE
是其他两个版本的基础。
1.8.2 JavaME
Java语言的小型版，用于嵌入式消费类电子设备或者小型移动设备的开发。
其中最为主要的还是小型移动设备的开发（手机）。渐渐的没落了，已经被安卓和IOS给替代了。
但是，安卓也是可以用Java来开发的。
1.8.3 JavaEE
用于Web方向的网站开发。（主要从事后台服务器的开发）
在服务器领域，Java是当之无愧的龙头老大。
面向对象
安全性
多线程
简单易用
开源
跨平台
操作系统本身其实是不认识Java语言的。
但是针对于不同的操作系统，Java提供了不同的虚拟机。
虚拟机会把Java语言翻译成操作系统能看得懂的语言。
单行注释 //
多行注释：/* */ 多行注释不能嵌套使用的
文档注释 /** */ 我们用来给函数注释是最好的
比如说我们构建这么一个函数
/**
* 这个是个输出函数
*
* @param a 整形数据
* @param b 浮点型数据
*/
public static void print(int a, double b) {
System.out.println("======");
System.out.println("hello world " + (a + b));
System.out.println("======");
}
一个文档注释就可以很清晰的帮我们搞明白这个函数的参数的作用是什么,函数的功能是什么
被Java赋予了特定含义的英文单词。
当我们在代码中写了关键字之后，程序在运行的时候，就知道要做什么事情了。
注意：关键字很多，不用刻意去记。
表示定义一个类。创建一个类。
类：Java项目最基本的组成单元，一个完整的Java项目有可能会有成千上万个类来组成的。
class后面跟随的就是这个类的名字，简称：类名。
在类名后面会有一对大括号，表示这个类的内容。
举例：
public class HelloWorld{
}
解释：class表示定义类。
类名：HelloWorld
HelloWorld后面的大括号表示这个类的范围。
字面量的作用是：告诉程序员，数据在程序中的书写格式
public class Demo {
public static void main(String[] args) {
System.out.println(10); // 输出一个整数
System.out.println(5.5); // 输出一个小数
System.out.println('a'); // 输出一个字符
System.out.println(true); // 输出boolean值true
System.out.println("欢迎来到黑马程序员"); // 输出字符串
}
}
不带小数点的数字都是整数类型的字面量。
只要带了小数点，那么就是小数类型的字面量。
只要用双引号引起来的，不管里面的内容是什么，不管里面有没有内容，都是字符串类型的字面量。
字符类型的字面量必须用单引号引起来，不管内容是什么，但是个数有且只能有一个。
字符类型的字面量只有两个值，true、false。
空类型的字面量只有一个值，null。
关键字final表示一个值,一旦赋值后就不能改变了,这种值称为常量
常量的名称一般是大写字母
常量的初始化是可以进行延时的,我们只需要在首次执行的时候被恰好初始化以此就可以了,但是要注意这个只能初始化以此,一旦被赋值就是最终的值.
什么是变量，变量就是程序中，临时存储数据的容器，但是这个容器只能存在一个值
数据类型 变量名 = 数据值；
我们可以给数字添加下划线，例如
int a = 100_333_5555;
System.out.println(a);//1003335555
java编辑器会自动删除这个下划线,但是这样可以让我们看的更加清晰
数据类型：限定了变量当中能存储什么类型的数据。
如果要存10，那么数据类型就需要写整数类型。
如果要存10.0，那么数据类型就需要写小数类型。
变量名：其实就是这个容器的名字。
当以后想要使用变量里面的数据时，直接使用变量名就可以了。
数据值：真正存储在容器中的数据。
分号：表示语句的结束，就跟以前写作文时候的句号是一样的。
整数：int
小数：（浮点数）double
举例
public class VariableDemo{
public static void main(String[] args){
//定义一个整数类型的变量
//数据类型 变量名 = 数据值;
int a = 16;
System.out.println(a);//16
//定义一个小数类型的变量
double b = 10.1;
System.out.println(b);//10.1
}
}
变量名不能重复
在一条语句中，可以定义多个变量。但是这种方式影响代码的阅读，所以了解一下即可。
变量在使用之前必须要赋值，也就是初始化。
案例：
public class VariableDemo2{
public static void main(String[] args){
//1.变量名不允许重复
//int a = 10;
//int a = 20;
//System.out.println(a);
//2.一条语句可以定义多个变量
//了解。
//int a = 10, b = 20, c = 20,d = 20;
//System.out.println(a);//?
//System.out.println(b);//?
//3.变量在使用之前必须要赋值
int a = 30;
System.out.println(a);
}
}
基本数据类型 整形和浮点型,其中整形的long的范围几乎已经够我们用了,当我们需要大数据的时候并不一定需要用这个double,这个long也可以
合理用好这个数据类型,根据所需范围进行数据类型的选择,而不是统一的用int和double,这样可以让我们所占用的空间,更加简单
引用数据类型（面向对象的时候再深入学习）
说明
e+38表示是乘以10的38次方，同样，e-45表示乘以10的负45次方。
在java中整数默认是int类型，浮点数默认是double类型。
所有的整形类型都有MIN_VALUE,和MAX_VALUE我们可以用这些整形数据类型的包装类来调用这两个函数,返回当前数据类型的最大值
包装类后面会提到
举个例子就是int的包装类是Interger ,double的包装类是Double
对于浮点型的数据我们通过这个Double.POSITIVE_INFINITY代表正无穷,Double.NEGETIVE_INFINITY代表 负无穷,Double.NaN代表非数值
所有的“非数值”都被认为是彼此不同的。因此，你不能使用测试if(x == Double.NaN)来检查x是否为NaN。但是，你可以这样调用if (Double.isNaN(x))。还有方法Double.isInfinite可以测试是否是正负无穷大，方法Double.isFinite可以检查浮点数既不是无穷也不是NaN。
业内大多数程序员都在遵守阿里巴巴的命名规则。
在day02的资料文件夹中有。
必须要这么做，否则代码会报错。
如果不这么做，代码不会报错，但是会让代码显得比较low。
适用于变量名和方法名
适用于类名
不管起什么名字，都要做到见名知意。
##3# 阿里巴巴命名规范细节：
Scanner是一个输入流,我们在里面绑定这个System.in就是绑定终端,使得他可以读取终端输入
键盘录入的实际功能Java已经帮我们写好了，不需要我们自己再实现了，而Java写好的功能都放在了Scanner这个类中，所以，我们只要直接使用Scanner这个类就可以了。
使用步骤：
第一步：
导包：其实就是表示先找到Scanner这个类在哪。
第二步：
创建对象：其实就表示申明一下，我准备开始用Scanner这个类了。
第三步：
接收数据：也是真正干活的代码。
//导包，其实就是先找到Scanner这个类在哪
import java.util.Scanner;
public class ScannerDemo1{
public static void main(String[] args){ //2.创建对象，其实就是申明一下，我准备开始用Scanner这个类了。
Scanner sc = new Scanner(System.in); //3.接收数据当程序运行之后，我们在键盘输入的数据就会被变量i给接收了
System.out.println("请输入一个数字"); int i = sc.nextInt(); System.out.println(i);
}
}
常用的输出方式
System.out.println()——作用是可以进行字符串的相加和，字符串和变量相加的时候得到的是字符串，变量和变量相加得到的是变量，且带有换行效果,这个输出本身也能输出常用的标识符,比如说制表符和换行符之类的
System.out.print()——和上面的一样作用，就是没有换行
System.out.printf("标识符"，变量)——和C语言中printf效果一样，不过这里的标识符可以是一个字符串变量，并没有换行效果，换行效果可以通过"\n"实现
运算符：
就是对常量或者变量进行操作的符号。
比如： + - * /
表达式：
用运算符把常量或者变量连接起来的，符合Java语法的式子就是表达式。
比如：a + b 这个整体就是表达式。
而其中+是算术运算符的一种，所以这个表达式也称之为算术表达式。
就是普通的加减乘除，没什么区别的，不过要注意以下几点
1.整数相除结果只能得到整除，如果结果想要是小数，必须要有小数参数。
2.小数直接参与运算，得到的结果有可能是不精确的。
系统自动进行的类型转换，
就是把一个取值范围小的数据或者变量，赋值给另一个取值范围大的变量。此时不需要我们额外写代码单独实现，是程序自动帮我们完成的。
简单的记忆
就是小的给大的，可以直接给。
取值范围小的，和取值范围大的进行运算，小的会先提升为大的，再进行运算。
byte、short、char三种类型的数据在运算的时候，都会直接先提升为int，然后再进行运算。
概念：
如果要把一个取值范围大的数据或者变量赋值给另一个取值范围小的变量。是不允许直接操作。
如果一定要这么干，就需要加入强制转换。
书写格式：
目标数据类型 变量名 = （目标数据类型）被强转的数据；
简单理解：
要转成什么类型的，那么就在小括号中写什么类型就可以了。
强制转换有可能会导致数据发生错误。（数据的精度丢失）
核心技巧：
当+操作中出现字符串时，此时就是字符串的连接符，会将前后的数据进行拼接，并产生一个新的字符串。
当连续进行+操作时，从左到右逐个执行的。
我们需要注意的是，只有字符串才会互相连接，如果不是字符串那么就是做加法运算
案例1
1 + 2 + "abc" + 2 + 1
结果：“3abc21”
解释：
第一步：1 + 2 。在这个过程中，没有字符串参与的，所以做的是加法运算，结果为3。
第二步：3 + "abc"。在这个过程中，有字符串参与的，所以做的是拼接操作，产生一个新的字符串"3abc"。
第三步："3abc" + 2。在这个过程中，有字符串参与的，所以做的是拼接操作，产生一个新的字符串"3abc2"。
第四步："3abc2" + 1。在这个过程中，有字符串参与的，所以做的是拼接操作，产生一个新的字符串“3abc21”
案例2
String name = "黑默丁格";
System.out.println("我的名字是" + name);
结果： 我的名字是黑默丁格
解释：当字符串跟变量相加的时候，实际上是跟变量里面的值进行拼接。
规则：
当+操作中出现了字符，会拿着字符到计算机内置的ASCII码表中去查对应的数字，然后再进行计算。
char c = 'a';
int result = c + 0;
System.out.println(result);//97
最后输出的并不是一个字符，而是一个数字
注意点：
/ 和 % 的区别：他们两个都是做除法运算，/取结果的商。% 取结果的余数。
整数操作只能得到整数，如果想要得到小数，必须有浮点数参与运算。
算术运算符的高级用法：
是以+为例进行的讲解，其余减法，乘法，除法的运算规则也是一样的。
特例：字符串只有+操作，没有其他操作。
++：就是把变量里面的值+1
–：就是把变量里面的值-1
这两个运算符放在前面，就是先运算这个自增运算
如果放在后面就先运算与其相连接的其他的运算，在运算这个
& 和 | 的使用：
&：逻辑与（而且）
两边都为真，结果才是真，只要有一个为假，那么结果就是假。
|：逻辑或（或者）
两边都为假，结果才是假，只要有一个为真，那么结果就是真。
java中也是会存在逻辑短路的问题，但是逻辑短路问题不是存在于这个&和|中，而是存在&&和||里两个是不一样的
// & //两边都是真，结果才是真。
System.out.println(true & true);//true
System.out.println(false & false);//false
System.out.println(true & false);//false
System.out.println(false & true);//false
System.out.println("===================================");
// | 或 //两边都是假，结果才是假，如果有一个为真，那么结果就是真。
System.out.println(true | true);//true
System.out.println(false | false);//false
System.out.println(true | false);//true
System.out.println(false | true);//true
^（异或）的使用：
在以后用的不多，了解一下即可。
计算规则：如果两边相同，结果为false，如果两边不同，结果为true
代码示例：
分类： && ||
&&：
运算结果跟&是一模一样的，只不过具有短路效果。
||：
运算结果跟|是一模一样的。只不过具有短路效果。
逻辑核心：
当左边不能确定整个表达式的结果，右边才会执行。
当左边能确定整个表达式的结果，那么右边就不会执行了。从而提高了代码的运行效率。
又叫做：三元表达式或者问号冒号表达式。
格式：
关系表达式 ？ 表达式1 ：表达式2 ；
计算规则：
计算关系表达式的值。
如果关系表达式的值为真，那么执行表达式1。
如果关系表达式的值为假，那么执行表达式2。
注意点：
三元运算符的最终结果一定要被使用，要么赋值给一个变量，要么直接打印出来。
public class OperatorDemo12 {
public static void main(String[] args) {
//需求：求两个数的较大值
int a = 10;
int b = 20;
//格式：关系表达式 ？ 表达式1 ： 表达式2 ；
//注意点：
//三元运算符的最终结果一定要被使用。
//要么赋值给一个变量，要么直接输出。
int max = a > b ? a : b ;
System.out.println(max);
System.out.println(a > b ? a : b);
}
}
格式一：
数据类型 [] 数组名
比如：int [] array
格式二：
数据类型 数组名 []
比如： int array []
详解：
数据类型：限定了数组以后能存什么类型的数据。
方括号：表示现在定义的是一个数组。
数组名：就是一个名字而已，方便以后使用。
注意点：
方法括号跟数组名，谁写在前面，谁写在后面都是一样的。
平时习惯性使用第一种方式
完整格式：
数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3，元素4…};
比如：
int[] arr = new int[]{11,22,33};
double[] arr = new double[]{1.1,1.2,1.3};
格式详解：
数据类型：限定了数组以后能存什么类型的数据。
方括号：表示现在定义的是一个数组。其实类似于C语言中的指针了，用来和整型变量做区分
数组名：其实就是名字而已，方便以后使用，在起名字的时候遵循小驼峰命名法。
arr namesArr
new：就是给数组在内存中开辟了一个空间。
数据类型：限定了数组以后能存什么类型的数据。
前面和后面的数据类型一定要保持一致。
int[] arr = new double[]{11,22,33};//错误写法
方括号：表示现在定义的是一个数组。
大括号：表示数组里面的元素。元素也就是存入到数组中的数据。
注意点：
多个元素之间，一定要用逗号隔开。
数组一旦创建后，长度不能改变
简化格式:
数据类型[] 数组名 = {元素1，元素2，元素3，元素4…};
比如：
int[] array = {1,2,3,4,5};
double[] array = {1.1,1.2,1.3};
int[] arr = {1,2,3,4,5};
System.out.println(arr);//[I@6d03e736
double[] arr2 = {1.1,2.2,3.3};
System.out.println(arr2);//[D@568db2f2
打印数组的时候，实际出现的是数组的地址值。
数组的地址值：就表示数组在内存中的位置。
以[I@6d03e736为例：
[ ：表示现在打印的是一个数组。
I：表示现在打印的数组是int类型的。
@：仅仅是一个间隔符号而已。
6d03e736：就是数组在内存中真正的地址值。（十六进制的）
但是，我们习惯性会把[I@6d03e736这个整体称之为数组的地址值。
地址值对于我们来京，作用不大，简单了解。
格式：
数据类型[] 数组名 = new 数据类型[数组的长度];
这里面的数组的长度可以是一个变量
数组的默认初始化值：
整数类型：0
小数类型：0.0
布尔类型：false
字符类型：‘\ u0000’
引用类型：null
//1.定义一个数组，存3个人的年龄，年龄未知
int[] agesArr = new int[3];
//2.定义一个数组，存班级10名学生的考试成绩，考试成绩暂时未知，考完才知道。
int[] scoresArr = new int[10];
静态初始化：int[] arr = {1,2,3,4,5};
动态初始化：int[] arr = new int[3];
静态初始化：手动指定数组的元素，系统会根据元素的个数，计算出数组的长度。
动态初始化：手动指定数组长度，由系统给出默认初始化值。
使用场景：
只明确元素个数，但是不明确具体的数据，推荐使用动态初始化。
已经明确了要操作的所有数据，推荐使用静态初始化。
举例：
使用数组来存储键盘录入的5个整数。
int[] arr = new int[5];
将全班的学生成绩存入数组中，已知学生成绩为：66,77,88,99,100
int[] arr = new int[5];
arr[0] = 66;
arr[1] = 77;
... 虽然可以实现，但是太麻烦了。
建议使用静态初始化：int[] arr = {66,77,88,99,100};
我们可以将数组变量复制到另外一个数组变量中, 但是那样两个变量引用同一个数组
例如
int [] num = {1,2,3,4,5,6,7};
int [] num2 = num;
num2[2]=10;
sout(num);
sout(num2)
结果是两者结果相同,都是1,2,10,4,5,6,7即两个变量引用的是同一个数组
这种情况同样的对集合也是一样的
ArrayList<String> people = new ArrayList<>();
ArrayList<String> friends = people;
people.add("范冰冰");
System.out.println(people);
System.out.println(friends);
[范冰冰]
[范冰冰]
如果我们只是单纯的想要复制数组我们可以通过这个 Arrays.copyof 来进行复制, 集合的话就通过 new 方法来创建 ArrayList<String> friends = new ArrayList<>(people) ;
这个方法是一个静态方法 ,我们可以直接通过这个 Arrays 类来进行使用.
第一个是 Array.toString ()这个对于我们输出数组信息进行调试有很大的好处
第二个是 Arrat.sort ()它可以利用二分搜索算法对一个数组进行排序
这两个方法都是静态方法., 我们通过对象名加方法名进行调用.
int[][] num ={{12,2},{2,3}};
如果不提供初始值的话就必须使用这个 new 操作符并指定行数和列数
如果我们想要输出所有的二维数组的元素行
我们可以使用这个 Arrays. deepToString ()
sout(Arrays. deepToString (num))
方法（method）是程序中最小的执行单元
注意：
方法必须先创建才可以使用，该过程成为方法定义
方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用
方法在哪一个类里调用，我们就最好在哪一个类里面写这个函数
定义格式
public static void 方法名 ( ) {
// 方法体;
}
范例
public static void method ( ) {
// 方法体;
}
调用格式
方法名();
范例
method();
方法必须先调用，在使用，否则程序将会报错
形参：方法定义中的参数
等同于变量定义格式，例如：int number
实参：方法调用中的参数
等同于使用变量或常量，例如： 10 number
有些方法允许调用者提供数目可变的参数。你已经看到了这样的方法: printf。例如、调用
System.out.printf("sd"，n);
与
System.Out.Printf ("d &s"，n，"widgets");
虽然它们调用同样的方法，但是第一个调用有两个参数，而第二个调用有三个参数。我们定义一个 average 方法，它可以接收变长的参数，这样我们就可以以任意参数长度调用 average，例如，average (3， 4.5，-5， 0)。在类型之后加上…声明“变长参数”
public static double average(double... values)
参数实际上是 double 类型的数组。当方法被调用时，创建了一个数组并且以参数填充该数组。在方法体中，你可以像使用数组一样使用。
public static double average(double... values) (
double sum=0;
for (double v : values)
sum += v;
return values.length == 0 ?0: sum / values.length;
}
现在你可以这样调用
Double avg = average (3，4.5，10，0);
如果参数已经在数组中，则不必解开。你可以直接传递数组，代替参数列表:
注意事项
方法不能嵌套定义
void 无返回值，可以省略return ，也可以单独写个return用于退出程序，但是后面不要跟内容
方法重载概念
方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
多个方法在同一个类中
多个方法具有相同的方法名
多个方法的参数不相同，类型不同或者数量不同
注意：
重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载
Random跟Scanner一样，也是Java提前写好的类，我们不需要关心是如何实现的，只要直接使用就可以了。
import java.util.Random;
导包的动作必须出现在类定义的上边。
Random r = new Random ();
上面这个格式里面，只有r是变量名，可以变，其他的都不允许变。
int number = r.nextInt(随机数的范围);
上面这个格式里面，只有number是变量名，可以变，其他的都不允许变。
随机数范围的特点：从0开始，不包含指定值。比如：参数为10，生成的范围[0,10)
//1.导包
import java.util.Random;
public class RandomDemo1 {
public static void main(String[] args) {
//2.创建对象
Random r = new Random();
//3.生成随机数
int number = r.nextInt(100);//包左不包右，包头不包尾
//0 ~ 99
System.out.println(number);
}
}
我们可以通过Scanner类进行创建输入函数
Scanner 变量名 = new Scanner(System.in);
数据类型 = 变量名.next数据类型();
其中
nextInt()接受整形
nextDouble()接受double型
next()接受字符串型
nextLine()同样接受字符串型,
这些有什么区别呢
next()接受字符串型,但是遇到空格,制表符回车就会自动终止
nextLine()同样接受字符串型,并且可以同时接受这个空格,遇到回车才会终止
两者混用会造成这个空间产生错误的输入,因为你输入的回车和空格虽然没被接受,但是并没有消失,只是在缓冲区里面而已.
常见的方法
pow平方sqrt开方min取最小值max 取最大值multiplyExact,addExact,substractExact,incrementExact,decrementExact,negateExact这些方法可以让整数的运算更加安全,当遇到错误情况,会抛出异常,或者让程序终止
round四舍五入