程序猿:jdk
写好的程序：jre
jdk：(java development kit)-java开发工具包
--java开发工具: 编译器，调试器，javadoc.exe. java.exe,javac.exe
--jre(java runtime environment)--java运行环境
--jvm(java虚拟机)：使用程序模拟一台计算机，使java程序运行在此jvm上
--类库(资源库)
jdk与jre的区别
jdk是开发环境(开发程序所需要的环境)
包含开发工具和jre
开发工具有:编译器，调试器，javadoc（打包命令）等
jre是运行环境(程序运行所需要的环境)
包含jvm和类库
注意注意再注意： jdk安装路径一定不能有中文汉字。
java语言的一个特点：跨平台(操作系统)。
因为每个平台上都有自己版本的jvm,而任何版本的jvm都会执行class文件(字节码文件)
java语言的特点，除了跨平台运行，还有一个特点叫强类型的特点:就是变量必须在定义期间规定一个类型,赋值时类型必须匹配.
java语言的运行原理：
java源文件(.java)
|
|----编译过程(javac.exe)
| javac 源文件名称(一定要带上扩展名)
| javac Demo.java
java字节码文件(.class)
|
|---开启jvm，运行字节码文件
| java 字节码文件名称(千万不要写扩展名)
| java Demo
程序开始跑起来
javac.exe：调用编译器对源文件进行编译成字节码文件
注意:源文件只要更改，就需要重新编译,编译期间会检查源文件中的语法，如果语法没有错误，就会生出.class文件， 有错误，一
定不会产生.class文件。
编译期间的语法错误，我们称之编译错误
如果想使用简短的命令名称，我们需要配置jdk的环境变量：
在计算机-->属性-->高级系统设置-->高级-->环境变量-->系统变量里
(1) 新建一个环境变量名为：
JAVA_HOME
变量值：D:\Users\Michael\Apps\Java\jdk1.8.0_172， 即一堆命令所在的目录bin的父目录
(2) 新建一个环境变量名为：
CLASSPATH
变量值: .;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar；
(3) 找到系统变量里的path: 追加值。
追加的内容如下： ;%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
检查是否配置成功：打开命令提示符界面：输入两个命令：
java -version 回车
javac 回车
不出现" 不是内部或外部命令.........",即成功
注释有三种：
1、文档注释:
/** 注释 */
2、多行注释：
/* 注释 */
3、单行注释：
//注释
通常：文档注释用于解释类或方法，多行或单行注释用于解释方法内的逻辑
变量：就是jvm在内存中开辟的一个存储空间，作用是用来存储数据的。
1、程序通过操作变量名来操作存储空间。
2、变量必须定义一种类型变量的命名规则：
(1)名称由字母，数字，_和$任意组成，数字不能开头
(2)大小写敏感
(3)可以使用汉字，但是不建议使用
(4)驼峰命名法，见名知意
(5)不能使用关键字(java保留字)
变量的使用规则：
(1) 必须先定义(声明，创建)和初始化
(2) 变量可以重复使用，即可以进行多次存取操作。不需要强调类型，但是存储数据时一定要与第一次声明时的类型匹配
(3) 变量的作用域：变量有自己的使用范围。出了范围，变量失效。
作用域：即从定义开始，到所在的大括号的结束符号为止。出了作用域：想使用，需要重新定义和初始化
类型：java语言中共分两大类型
(1)基本数据类型-原始数据类型
(2)引用数据类型
基本数据类型：8种
byte,short,int,long,float,double,char,boolean
重写归纳分类：
整数类型：byte,short,int,long
浮点数类型：float,double
字符类型：char
布尔类型：boolean
(一)整数类型：
byte(不常用): 也叫字节类型，在内存中占8位二进制，即在内存中占1字节大小的空间，是数据存储的最小单位。
0000 0000 0
0111 1111 127
1000 0000 -128
1000 0001 -127
1111 1111 -1
范围：-128~127
幂表示：-2^7~2^7-1
short(不常用):也叫短整型。在内存中占16位二进制，2字节大小。
0000 0000 0000 0000 0
0111 1111 1111 1111 32767
1000 0000 0000 0000 -32768
1111 1111 1111 1111 -1
范围：-32768~32767
幂表示：-2^15~2^15-1
int(常用):也叫整型。在内存占32位的二进制，4字节大小。
范围：-2147483648~2147483647
幂表示：-2^31~2^31-1
long(常用)：也叫长整型。在内存占64位二进制，8字节大小.
范围:正负922亿亿左右
幂表示：-2^63~2^63-1
(二)浮点数类型：2种--小数类型
float:
在内存中占4字节大小，32位二进制
范围: -3.403E38~3.403E38
double:
在内存中占8字节大小，64位二进制
范围：-1.79E308~1.79E308
字面量:默认类型为double,即64位的浮点数类型, 如果想直接写32位的浮点数，需要在数值后添加f/F
比如：
double num = 3.14;
float num1 = 3.14F;
范围大小从大到小排序
double>float>long>int>short>byte
精度大小从大到小排序：(int,long,float,double)
long>int>double>float
(三)字符类型：char
在内存中占2字节大小，16位二进制。
赋值特点：
(1)值中，有且只有一个字符
(2)字符必须使用单引号引起来。
另外特点：底层二进制是无符号的整数类型，即 0~2^16-1--->0~65535。所以，赋值时，也可以赋值整数。但是，存入变量空间
后，其实是其整数对应的字符。
(四)boolean布尔类型：用来判断条件是否成立的。
在内存中占1字节大小。只有两个值 true/false
true:表示条件成立
false:表示条件不成立
类型转换:
1.自动转换(隐式转换): 占内存小的类型变量赋值给占内存大的类型变量， 会发生自动转换。
byte-->short-->int-->long-->float-->double
char
2、强制转换: 占内存大的类型变量赋值给占内存小的类型变量，需要强制转换。语法如下：
(占内存小的变量类型名)变量;
注意：有可能出现精度损失。
double->float-->long-->int-->short--byte
char
引用数据类型：
字符串类型：String
赋值特点：
1.必须使用双引号
2.引号内有0或0个以上的字符都可
3.字符串可以做拼接操作，拼接后的数据仍是字符串类型。
在做运算时，+前后只要有一个是字符串类型就会做拼接操作。结果是字符串类型
Math类
Math:是一个数学类型，此类型中有很多方法:即功能。如:
Math.random():功能是随机产生一个[0,1)区间内的任意浮点数
范围：0~0.9999999999999999999999999;
double num = Math.random();
如果想要[m,n)区间内的任意小数：Math.random()*(n-m)+m
如果想要[m,n)区间内的任意整数：(int)(Math.random()*(n-m)+m)
如果想要[m,n]区间内的任意整数：(int)(Math.random()*(n+1-m)+m);
Scanner类:是一个开启键盘输入的类型,此类型中有很多方法。
如：可以扫描键盘输入的整数，浮点数，布尔类型，字符串
nextInt():扫描整数
nextDouble():扫描浮点数
nextBoolean():扫描布尔类型
next():扫描字符串
nextLine():扫描字符串
这些功能都有阻塞程序的效果，当扫描到数据后，并回车，阻塞效果消失，程序继续向下运行
使用步骤：
(1)导包
import java.util.Scanner;
(2)新建对象
Scanner scan = new Scanner(System.in);
(3)使用功能
int num = scan.nextInt();
double num = scan.nextDouble();
String str = scan.nextLine();
String name = scan.next();
数组:
1、概念：一组相同类型的数据的组合。数组也是一种引用类型，
2、名称：数组名称不是固定的，与存放的数据的类型有关。
如: 存放一组int类型的数据，
数组名称 int[]
存放一组字符串数据
数组名称 String[]
存放一组Scanner类型的数据
数组名称 Scanner[]
存放一组字符类型的数据
数组名称 char[]
3、元素的概念：数组中的每个数据，都是这个数组的元素。
4、数组的声明与初始化
声明：元素类型[] 变量名;
元素类型 变量名[];--不建议此写法
变量的初始化的时机：2种
(1)声明时直接初始化
(2)先声明，再初始化(使用前初始化)
数组的变量初始化：3种情况
(1)静态初始化
String[] names = {"A","B"};
int[] nums = {};
(2)动态初始化
--规定数组长度的写法
int[] ages = new int[length];
其实有默认元素：
整数类型：默认是0
浮点数类型：默认0.0
字符类型：默认'\u0000'
布尔类型：默认false
引用数据类型：默认值null
--不规定长度的写法
int[] ages = new int[]{};
double[] counts = new double[]{1.2,3.14};
5、数组的长度： 即数组元素的个数
表示方式：变量名.length;
6、数组的下标(index):下标从0开始，最后一个元素的下标为：length-1;
下标范围：0~length-1
7、数组元素的访问(查看):通过下标进行查看
语法:变量名[index];
元素的遍历(从头到尾依次查看)
for(int i=0;i<变量名.length;i++){
System.out.println(变量名[i]);
}
8、数组元素的覆盖(赋值，替换)
语法：变量名[index] = value;
9、数组间的赋值，就是指变量之间的赋值。
通过一个变量对数组的元素进行修改，那么与之相关的变量对应的数组的元素也会发生变化。
10、数组下标越界异常：
java.lang.ArrayIndexOutOfBoundsException
出现的原因： 访问数组元素时的下标超出了范围
正确范围：0~length-1
错误下标：
变量名[-1]
变量名[length]
数组下标越界异常，编译器检查不出来此异常，运行时才会出现，出现的结果造成了程序的中断结束。
11、引用类型之Arrays
是数组的工具类。此类提供了很多对数组操作的功能方法
如：
String info = Arrays.toString(数组名);
Arrays.toString():此方法是将数组的元素
一一拼接成字符串.
格式如下：
"[元素1,元素2,.....元素length-1]"
12、数组的复制
数组的特点：一经创建，长度不可变。
系统复制法：
System.arraycopy(src,start1,des,start2,length);
src:源数组，即被复制的数组名
start1:源数组复制的开始下标
des:目标数组，即复制到的数组名
start2:目标数组复制的开始下标
length:复制的长度
工具类提供的复制方法:
元素类型[] 变量名=Arrays.copyOf(src,newLength);
src:源数组
newLength:新数组的长度
工具类的数组复制功能
此功能：有扩容或缩容的效果。
功能解释：从src的下标为0的元素开始复制，复制到长度为newLength的新数组中，新数组存放元素的开始位置为0
13.数组的排序：
冒泡排序的基本思想：
在要排序的数组中，对当前还未排好序的范围内的全部数，自上而下(自左到右)对相邻的两个数依次进行比较和调整，让较大的
往下沉(或向右移)，较小的往上冒(或向左移)。即：每当两相邻的数比较后他们的顺序与排序要求相反时，就将他们互换。
冒泡排序的改进：
对冒泡排序的常见的改进方法是 加入一个标志性的变量，用于标志某一轮排序过程中是否有数据交换，如果没有进行数据交换，
则说明数据已经按照要求排列好，可立即结束排序，避免不必要的比较过程。
简单选择排序：基本思想如下
在要排序的数组中，选择出最小(或者最大)的一个数与第一个位置的数交换；然后再剩下的数当中再找最小(或最大)的与第二个位
置的数交换，依次类推，直到第n-1个元素(倒数第二个)和第 n个元素(最后一个数)比较为止。
工具类Arrays里的排序方法：
Arrays.sort(数组名):对基本数据类型的数组与引用类型的数组都可排序
二维数组
概念：数组的元素依然是数组
初始化：
静态初始化
如：int[][] a = {{1},{1,2},{2,3,4}};
动态初始化：
(1)等长式初始化
int[][] a = new int[3][2];
表示a有三个元素，每个元素都是2个长度的数组。
(2)只规定高维数组的长度
int[][] a = new int[3][];
表示a有三个元素，但是都是null.null在使用时，需要新建数组对象(长度任意)
运算符：
两原一封：
两个原则：
1、不同类型的数据做运算时，一定会先转换成较大范围类型后再运算。
2、byte,short，char这些类型运算时，一定会先转成 int类型再运算，结果int类型
封：
一定要注意封闭式运算。（int,long）
1. 算术运算符：( +，-，*，/,%，++,--)
/：情况1:参与的类型都是整型时，做取整运算，即 商n余m, 结果为n。 2/3----商0余2。结果为0
情况2： 只要有一个浮点数参与，就会做 类似精确运算。
%：取余运算符号，也叫取模运算符号。做除法运算时，商n余m，结果为m。
情况1：参与运算都是整数时，余数是精确值
情况2: 有浮点数参与时，余数不一定是精确值。
注意： 取余运算一般被用来判断 某一个数能否被另外一个数整除。
++/--：是自增自减运算符
符号要与变量一起使用。表示变量自动+1，或自动-1。
如：++a/a++/--a/a--;
++a/a++:是a=a+1的简写， --a/a--:是a=a-1的简写
情况1: 即与变量在一起，不与其他任何符号连用时(单独使用)，此时，变量一定会+1或-1;
情况2:自增/自减运算与其他符号连用时需要考虑表达式的值（ ++a/a++/--a/a--整体看成表达式）
口诀： 符号在前，先运算再赋值
符号在后，先赋值在运算
解析：符号在前时，变量先自增/自减，新值赋值给表达式
符号在后时，先把变量的值赋值给表达式，然后变量再自增/自减
2. 关系运算符:（>,>=,<,<=,==,!=）
用来判断条件是否成立。一般都用在分支结构或循环结构中
关系运算与逻辑运算统称为条件运算
3.逻辑运算符（短路运算符）:
当有两个条件以上进行判断是否成立时，需要使用逻辑运算符。即与，或，非（&&,||,!）
写法如下： a>1&&a<3
&&(与):用于判断两个条件是否同时成立
||(或):用于判断是否有条件成立。
!： 用于条件的否定
&& a>b && c>d -->结果
true true true
true false false
false true false
false false false
|| a>b || c>d -->结果
true true true
true false true
false true true
false false false
！ a>b
true---------》false
false--------》true
&&: 全真为真，一假则假
||: 一真即真，全假则假
!： 非真即假，非假即真
当使用&&或者||时，第一个条件能确定结果时，就不会执行第二个条件，这种行为可视为短路现象。
单个符号的 &(与) |(或) 没有短路现象
4.赋值运算符：=，赋值运算，给前面的变量赋值
扩展赋值运算符（+=,-=,*=,/=,%=）
a+=1相当于 a = a + 1
a-=b相当于 a = a - b;
a*=b相当于 a = a * b;
a/=b相当于 a = a / b;
a%=b相当于 a = a % b;
5.字符串拼接符号（+）
当+前后，只要有一个是字符串类型，就做拼接操作拼接后的结果是字符串类型。
如:
int a = 1;
int b = 2;
String str = "3";
String result = a+b+str;
System.out.println(result);//"33"
result = str+a+b;
System.out.println(result);//"312"
result = a+str+b;
System.out.println(result);//"132"
System.out.println(1+2+a+str+b+3);//"4323"
System.out.println(1+2+a+"3"+a*b+str);//"4323"
6.三目运算符(三元运算符)
变量类型 变量= 条件表达式？值1:值2;
变量类型：需要与值1或值2的类型相同。而值1与值2的类型要么相同，要么就可以自动转换。
程序的运行顺序：
顺序结构:从程序开始，到程序结束
分支结构：在顺序结构基础上，根据条件进行选择执行方向。
循环结构：在顺序结构基础上，根据条件进行多次执行相同的或相似的代码
分支结构：根据条件的成立与否，选择执行方向。
(一)if分支结构：
语句1；
if(条件表达式){
代码块//条件成立时，执行的逻辑
}
语句2；
执行逻辑：执行完语句1后，碰到if，一定会执行条件表达式，结果为true,就执行代码块，然后再执行语句2。 结果为false,就跳过
代码块，执行语句2
if(条件表达式){
代码块1// 条件成立时执行此代码块
}else{
代码块2// 条件不成立时执行此代码块
}
执行逻辑：当程序执行到if时，一定会执行条件表达式进行判断，结果为true,就执行代码块1.结果为false,跳过代码块1，执行代码
块2
if(条件1){
代码块1；
}else if(条件2){
代码块2
}else if(条件3){
代码块3
}else{
代码块4
}
执行逻辑：程序执行到if时，一定会执行条件1,进行判断
结果为true,执行代码块1。
结果为false,执行条件2，进行判断
结果为true,执行代码块2.
结果为false,执行条件3，进行判断
............
当if语句中含有else{}部分时，一定会执行其中一条分支。没有else{}部分时，有可能一条分支都不执行
(二)switch-case语句
格式：
switch(整数表达式){
case value1: 代码块1;[break];
case value2: 代码块2;[break];
..........
[default: 代码块n;]---[]表示可有可无
}
整数表达式：即能获得一个整数的表达式。但是jdk1.7版本以后，支持字符串表达式
case后的值与()内的结果类型要相同
break:有打断，毁掉，跳出，结束的含义
执行逻辑：当程序遇到switch时，计算表达式的值，然后匹配case后的值，然后，执行对应的分支逻辑。如果此分支有break
就结束分支结构，如果此分支没有break,就继续执行下一条分支逻辑，直到遇到break或default或全部执行完后续的
所有分支。
if语句: 执行分支的是一个条件表达式:如果有else{}部分，一定会执行其中一条分支。
switch-case语句:执行分支的是一个整数或字符串表达式， 如果有default部分，一定会执行分支。 一般与break连用
循环结构：当重复执行相同的代码或者是相似的代码时。
循环三要素：
1): 循环变量的声明:用于控制循环次数的循环因子
2): 循环条件: 用于判断是否执行相同或相似内容(循环体)的条件
3)：循环变量的改变方向:向着循环结束的方向改变。
(1)for循环:
语法:
for(变量的声明和初始化;循环条件;变量的改变方向){
循环体;
}
执行逻辑：
程序遇到for时，一定执行 变量的声明和初始化，然后执行循环条件的判断
如果为false,会跳过循环结构，执行后续代码。
如果为true,执行循环体，然后再执行变量的改变
再执行循环条件的判断，
.......
循环体:是要重复执行的相同或相似逻辑
break关键字:用在循环结构中时，表示结束/打断循环
continue关键字:用在循环结构中，表示结束当次循环体，继续下一次循环
双层for循环
双层循环：
外层变量执行一次，内层变量执行一遍
或
外层变量控制行数，内层变量控制列数
(2)while循环
语法：
while(循环条件){
循环体
}
执行逻辑：
当程序遇到while时，一定执行循环条件，
如果判断结果为false,就结束循环结构，执行后续代码
如果判断结果为true,就执行循环体，
然后再判断循环条件......
(3)do-while循环
语法：
do{
循环体
}while(循环条件);
执行逻辑：当程序遇到do关键字时，一定先执行一次循环体，然后再判断循环条件，
如果条件为false，结束循环结构，执行后续代码
如果条件为true,再执行一次循环体，
然后再判断条件的成立与否
........
while/do-while/for的区别：
while/do-while:适合不知道循环次数的逻辑
for：适合知道循环次数的逻辑
while/for一般先判断条件，再执行循环体
do-while：一定先执行一次循环体，再判断条件
小技巧：什么时候使用while,什么时候使用do-while。某些逻辑可以翻译成如下：
当......就执行.....：适合使用while
做.....直到.......:适合使用do-while
方法：即功能，封装了一段逻辑代码。
方法的定义：
固定语法：
修饰词 返回值类型 方法名(形式参数){
逻辑代码
}
方法的位置：在类体中，与main方法是并列关系，类体中可以有多个方法。
修饰词：
(1)public--公共的
(2)protected--受保护的
(3)private --私有的
也可以不写修饰词，即默认的(default)
static修饰词可以与上述三个连用
返回值类型：
(1) void---无返回值类型
(2)java语言的任意一种类型可以是基本数据类型，也可以是引用数据类型
方法名：命名时尽量做到见名知意，驼峰命名法，首字母小写
形式参数：用于接收调用者传入的数据。与变量的声明语法相同。
关键字return:
作用1：结束方法逻辑
作用2：如果返回值类型标记的是java语言类型的某一个类型名，那么return关键字后 必须跟着一个此类型的数据或变量。当 方法有返回值类型时，return关键字后的数据就是此方法要返回的数据。返回给调用者。
如：
int num = Math.random();
方法random()返回一个数据给main方法。
main方法存入num变量中
如:
reg1:
public static void sum(){
int a = 3;
int b = 5;
System.out.println(a+b);
[return;]---返回值类型处写void时，return可有可无；
}
reg2: 计算两个整数a和b的和
public static void sum(int a,int b){
int sum = a+b;
System.out.println(sum);
}
PS: 方法定义期间，就是制定逻辑流程模板。
reg3:
public static int sum(){
int a = 3;
int b = 5;
int sum = a+b;
return sum;
}
reg4:
public static int sum(int a,int b){
int sum = a + b;
return sum*3;
}
方法的调用，即使用
reg1如何使用：
main(String[] args){
sum();
}
reg2如何使用：
main(String[] args){
/*
调用者main 在使用sum(int a,int b)时
需要给形式参数赋值，赋的值叫实际参数
*/
int x = 1;
int y = 2;
sum(x,y);
}
reg3如何使用
main(String[] args){
int n = sum();
}
reg4如何使用
main(String[] args){
int m = 10;
int n = 20;
int s = sum(m,n);
}
总结：
调用方法时：
无返回值时：
方法名(有参就传参);
有返回值时：
返回值类型 变量=方法名(有参就传参);
方法内：
引用数据类型与基本数据类型的区别：
引用数据类型的数据，称之为对象，存储在内存中 某一个特定区域，即:堆
引用类型的变量也存储在内存中的一个特定区域， 即:栈
引用类型的变量存储的内容 不是对象，而是对象在堆空间的位置信息
基本数据类型的数据，不叫对象。
基本数据类型的变量，存在栈里，存储的内容是基本类型的数据。
==================================================================================
class 是类的关键字，后面是class的名称，必须与文件名称一致。 首字母必须大写，紧跟着的{}称之为类体。
main方法，即主方法
作用：启动程序，使jvm调用它，执行main里的逻辑。
System.out.println()
换行输出语句：表示下一次输出另起一行，小括号中可以什么都不写
System.out.print()
不换行输出语句：表示下一次输出不换行，小括号内必须写数据。
byte,short,int,long在给变量赋值时，直接写的整数值，默认就是int类型的数，在内存占32位。直接写的整数值，叫字面量。
====================================================
System.currentTimeMillis();会返回一个long类型的
数据。此数据为 从1970年1月1日0时0分0秒到系统当前时间之间的
所有毫秒数。
======================================================
java语言默认使用的字符集为unicode。
unicode字符集: 无论字母，还是汉字，都占两个字节大小
java语言常用的字符：
'A'~'Z' ->65~90
'a'~'z' ->97~122
'0'~'9' ->48~57
java语言中的转义字符：
'\':将特殊字符变成相应意义的字符。
java语言中的特殊字符：
单引号，双引号，制表符，换行符，回车符号
'\'' 单引号
'\"' 双引号
'\\' 反斜线
'\t' 制表符
'\r' 换行符，(有翻页效果，看不到上一页的数据)
'\n' 回车符，
需求:查看字符集中，某一字符对应的整数 将字符赋值给int类型的变量即可
int num = '王';
===============================================================
eclipse(日食):
是eclipse基金会提供的一款集成开发环境(IDE)。
也是一款绿色免安装，免费的开发工具。
使用前，需要JDK开发环境。
其他开发工具如：myeclipse,ideas，netBean,JBiulder
使用步骤：
(1)新建项目
File-->new-->java Project--name-->finish
(2)新建包(package)
命名规则
域名后缀.域名.项目名.模块名
src-->new-->package--name--finish
(3)创建源文件(.java)
选中包-->new-->class--name--finish
补全键: alt+ ?
main方法的快捷方式
main+补全键
syso+补全键
===================================================================================
封闭式运算（int,long)：
max+1 等于min
min-1 等于max
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
