Java基本语法和规范

Java基本语法和规范

语言按程序的执行方式分为编译型和解释型两种。
编译型：需要使用专门的编译器，针对特定平台（操作系统）翻译成可被该平台执行的机器码，编译生成的可执行程序可以脱离开发环境在特定平台独立运行，运行效率高，但因为编译型语言的程序被编译成特定平台的机器码，所以无法转移到其他平台运行。如：C C++
解释型：相当于把编译和解释过程同时完成，每次执行程序都进行一次编译且解释执行，所以执行效率较低。优势：跨平台容易，只需提供特定平台的解释器即可，如：Python javascript
java语言：不彻底的编译（编译成字节码文件），又有解释（每次运行时，将字节码翻译成对应平台的机器指令），先编译成与平台无关的字节码文件，再通过JVM(java虚拟机)解释执行，虽然各平台的JVM都不相同，但所有平台上的JVM向编译器提供相同的编程接口，编译器只需要面向虚拟机生成虚拟机能够理解的代码，然后由虚拟机来解释执行，字节码文件在各个平台都可以用相应的JVM运行，因此可以跨平台运行。
执行Java程序的两个步骤：
(编译器)使用javac编译 JVM虚拟机解释执行（java）
Java源文件--------------------------------->字节码文件(.class文件)------------------>特定平台的机器码
计算机语言：人与计算机之间交互所使用的 语言
计算机语言发展史：
第一代：机器语言，编写二进制码，不需要转换，打孔机为代表
第二代：低级语言，出现少量单词
第三代：高级语言c java python c++ 等
Java语言发展史：java之父：James Gosling
1991年sum公司JamesGoling领导green计划开发oak语言（因公司门前橡树取名）
1992年oak开发完成不能取得商业使用，发展被搁置
1994年完成java因oak商标被注册，改名为java(源自开发者手上的一杯hot java)
1995初sum公司发布java语言放到互联网，免费供大家使用，web技术规模流行，java开发者为web页面提供了动态内容（applet）
1996年sum公司发布JDK 1.0，包含两部分：运行环境（JRE）和开发环境（JDK）
java语言包括三大块
J2SE(JDK5.0后改名JavaSE)：平台标准版，可以做桌面程序开发
J2EE(JDK5.0后改名JavaEE)：平台企业版，可以做企业级应用：管理系统、网站
J2ME(JDK5.0后改名JavaME)：平台微型版，可以做移动端程序开发
计算机组成：
硬件：CPU（中央处理器）、输入设备、输出设备、存储设备、其他设备
CPU包括控制器和运算器：主要处理内存条中运行的数据
软件：系统软件：windows7 windows8 mac linux
应用软件：B/S:(browser)浏览器/服务器，可以直接在网页中使用的软件，如：12306
C/S(client):客户端/服务器，先下载，后应用，各种桌面软件
绝对路径：非常详细的路径 相对路径：相对当前所在位置的相对位置。
Java语言特性：
简单性：java舍弃了C++中难以掌握并不安全的功能，如：多继承、指针，java语言底层是C++实现的
面向对象；java和C++一样，是一种面向对象编程语言
安全性：如：运行时堆栈溢出，强制类型检查
健壮性：java语言在运行过程中产生的垃圾会自动回收，简称GC机制
可移植性：java程序编译一次，不做任何修改时到处运行，也就是跨平台。在不同操作系统上安装不同的JVM

JDK、JRE、JVM之间关系：
JDK开发工具包
JRE：java运行环境
JVM：java虚拟机
JDK包含JVM和JRE，JRE = JVM + 各种基础类库 + java类库（Sring\System）JRE包含JVM JVM不能单独安装，如果只运行程序，可以安装JRE，如果需要开发程序，安装JDK。 http://www.oracle.com/
安装路径：建议安装在根路径下，如：D:\JAVA\jdk-11.0.1
bin目录：主要包含java、javac等JDK的各种工具命令
Include:主要包含了一些java与C交互的头文件
Jmods:java的各个模块的jmod文件，从java9开始，庞大的java系统被分成各种不同的模块，从而使得java更加轻量化。
Lib:src.zip,该文件存放了java se的所有源代码，后期可以通过这些源代码进行学习优秀的java代码。
配置环境变量：右键计算机—>属性—>高级系统设置—>环境变量—>path前加JDK文件中bin目录的绝对路径。所有希望在命令行使用的工具，都应该将这些工具（所在路径）添加PATH环境变量中即可。
JAVA_HOME:告诉Eclipse、Tomcat、Ant、Maven、CXF、Activiti…JDK安装在哪个目录。
配置JAVA_HOME环境变量：右键计算机—>属性—>高级系统设置—>环境变量—>新建----->变量名：JAVA_HOME 变量值：JDK所在路径
Windows配置path环境变量：右键计算机—>属性—>高级系统设置—>环境变量—>path最前面加%JAVA_HOME%/bin 其中%JAVA_HOME%表示引用已有JAVA_HOME环境变量的路径。
Linux、MacOS:写$JAVA_HOME/bin $JAVA_HOME引用已有的JAVA_HOME环境变量的路径。

避免文件后缀过多(如:*.java.txt)，且默认被隐藏，导致文件类型错误，因设置不隐藏扩展名，步骤：资源管理器（计算机）----->组织----->文件夹和搜索选项---->查看---->隐藏已知文件类型扩展名（去掉√）
Windows常用dos命令
Javac -version 查看JDK当前版本
Dir:查看当前目录中包含所有的目录及文件。Linux用ls
cd\返回当前目录的根目录 \代表根目录
mkdir/md:创建文件夹
编译java程序：Javac -d(目录) 源文件 -d指定将生成的’字节码文件’放到指定位置。
运行java程序：java 类名
Java -cp 目录1;目录2 类名 ：系统到cp选项所指定的系列目录下找类（覆盖classpath环境变量的值）
Java文件命名，必须以.java结尾且文件名与定义为public的类名一致
Jshell工具（java9开始新增工具）：相当于python交互式解释工具，命令行输入jshell进入。
输入/exit退出交互工具，交互式工具的目的：能让学习者、工作者迅速测试某个功能。

注释：单行注释：//注释内容 多行注释：/注释内容/
文档注释：语法：/注释内容/ 只能放在类、成员变量、方法、构造器、内部类之前才有意义，javadoc默认只提取public或protected成员之前的文档注释。
javadoc工具可以提取文档注释来生成API文档
API文档：为java类提供的实用说明书。
生成文档注释，语法：
Javadoc -d(目录) 源文件 -d指定生成的“api文档”放到指定的位置
当方法中有参数时，需要在文档注释中加语法：@param 参数名 参数说明
当方法中有返回值，需要加语法：@return 返回值说明 如：
/*
*@param a 第一个加数
*@param b 第二个加数
*@return 返回的是a、b的和
*/
public int add(int a,int b)
{
Return a + b
}
Public class 和 class的区别：public为修饰词可有可无，如果使用public修饰类，则文件名必须与修饰类名一致，如果没有public修饰，则文件名可以和类名不一致（建议一致），编译成功后会生成对应类名的字节码文件。
类中main方法可有可无，如果没有，能编译成功，但是不能运行，一个文件编写多个类，编译成功后会生成对应类的个数的字节码文件，一个文件最多有一个类前面使用Public修饰.

配置classpath:使得编译和运行指定一个路径，在文件的任何位置都能编译和运行。
在JDK1.4以前，使用java 类名语法不会在当前路径下搜索（没有设计这个功能），因此必须配置classpath环境变量，除此之外，编译和运行java程序还需要JDK的lib路径下的dt.jar和tools.jar文件中的java类，因此还要将两个文件添加到classpath环境变量里，JDK11已经将这两个文件删除。如果使用jdk1.4以后版本，无需配置也可以在当前目录搜索。
临时配置：set classpath=绝对路径
如：set classpath= D:\计算机学习\java\java_project\day-01
Set classpath=D:\计算机学习\java\java_project\day-01;.; 后加;.;表示先在绝对路径中寻找，如果找不到会在当前目录找，如果需要写多个路径，则用英文分号隔开。
关闭dos命令窗口或者设置set classpath= 都能删除classpath临时配置
永久配置classpath:到环境变量中配置。新建—>变量名：classpath 变量值：绝对路径

标识符：就是一个名字，如类名、变量名、接口名、方法名、包名等。用于给程序中变量、类、方法命名的符号。
标识符命名规则：以字母、下划线_或$开头，其后可以是字母、数字、下划线或$，不能使用关键字。
标识符命名规范：
1、见名知意（编写对应单词意思）
2、类中每个单词首字母大写
3、变量名称、方法名称、参数名称采用驼峰命名法：除首单词外其后单词首字母大写
4、标识符长度不要超过15个字符。
5、可以由字母、数字、下划线和$组成，但数字不能放开头.
6、不能包含空格和其他特殊符号，不能只是关键字，但可以包含关键字。
如：保留字：goto、const和直接量：true、false、null不能作为标识符

字面值（直接量）：其实就是一个数据（值），根据字面值知道数据类型。
整数类型字面值、浮点类型字面值、字符串类型字面值、字符类型字面值、布尔类型字面值

关键字：在java中具有特殊意义的，全部用小写字母。共51个

true,false,null不是关键字，但也不能使用这三个特殊的直接量命名。
goto，const是保留字（暂时没有使用，以后可能使用）

Java是“强类型”的语言：1、所有变量必须要先声明、后使用。2、指定类型的变量只能只能接受类型与之匹配的值。所以每个变量和表达式都有一个在编译时就确定的类型。
弱类型语言可以直接使用。
变量：用来存放数据，可变化的数据，在计算机内存开辟一块记忆空间。
程序所用的的数据都保存在内存中，变量可以看成一个盛装数据的有名称的容器，每个变量代表了某一小块内存，程序对变量赋值，实际上就是把数据装入变量所代表的内存区的过程。
操作：声明变量（int a;）---->赋值(a =10)----->使用
声明并赋值多个变量：int a =10,b = 200,d=15;
分类：
按作用位置（声明位置）分为：
局部变量：在方法中声明的
成员变量：在类中声明的。
按数据类型分为：
基本数据类型变量：在内存中存放真正的值，包括：数值类型和boolean类型
引用数据类型变量：在内存中存放的内存地址（引用）包括：String、接口、数组、null等
引用数据类型实际是对一个对象的引用，对象包括实例和数组。空引用（null）可以转换为任何引用类型，即可以为所有引用类型赋值，是一个引用类型的特殊的直接量。
基本数据类型：分为4大类，8种
整数类型：byte short int long 整数类型默认为int
取值范围：

2^6=64 2^8=256 2^10=1024 2^16=65536 2^20=M(百万) 2^30=G(十亿) 2^40=T
存储单位：8bit = 1byte 1024byte = 1kb 1024kb = 1mb 1024mb = 1gb 1024gb = 1tb

常用进制：二进制、八进制、十进制、十六进制。
二进制整数以0b或0B开头，八进制以0开头，十六进制以0x或0X开头。十六进制的10_15分别以af来表示。
二进制与十进制之间转换：
十进制转二进制：除二取余法 二进制转十进制：乘2叠加法

二进制转8进制：每三位数代表8进制的一位，如0b011 010 001 ----->0321
二进制转16进制：每四位数代表16进制的一位，如：0B0 1101 0001----->0x0d1
当定义32位的二进制整数时，最高位其实是符号位，符号位为1表示负数，为0表示整数，因为整数值默认是int类型，二进制整数默认占32位，第32位就是符号位，如：
Int a = 0B10000000000000000000000000000011;
以上的a就是负数，计算机里以补码的形式保存所有的整数（在程序中写的二进制数字就是补码），正数的补码和原码一样，负数的补码是原码的反码加1，反码是对原码按位取反，只是最高位（符号位）保持不变。
将a换算成十进制输出：
补码：10000000000000000000000000000011 即给a赋值的二进制数
反码：11111111111111111111111111111100 补码按位取反
原码：11111111111111111111111111111101 反码+1
所以输出得到该原码的值为：-2147483645
若在二进制整数后加l或L后缀，则这个二进制整数默认占64位，第64位为符号位。如：
long b = 0B100000000000000000000000000000011L;
以上的b是一个正数，虽然32位是1，但后缀加了L表示该整数位L类型，占64位，64位才是符号位，所以b是一个整数，值为2^32 + 2 + 1
定义8位的二进制整数，数值默认是占32位，是一个正数，但由于强制转换成byte时产生溢出，溢出规则用该数-目标类型的大小n（保证n取值后，减后的值在目标类型的取值范围内，且为范围内最小的整数）导致c变成了-23如下：
byte c = 0B11101001;// c最后的值为-23
计算二进制数得到：232，溢出后c = 232 - 2561 = -23;

浮点类型：float double 浮点类型默认为double，希望一个浮点值当成float处理，必须在值后加f或F。浮点类型都有精度丢失，float丢失更严重，所以浮点数比较时 ，应该用“差值法”，如：
double f1 = 0.01, f2 = 0.05 //由于精度丢失,f1 + f2 不等于0.06,所以不能用f1+f2==0.06做比较.
System.out.println(f1 + f2 - 0.06 <0.0001) //差值法，减0.06后小于一个很小的数，说明为true

如果编译出现非法字符：一般是因为输入了全角字符，需要换成半角字符。
取值范围：

科学计算法：5.12e2(即5.1210^2) 公式:数eN=数10^N只有浮点数能用科学技术法。2e-6的值为，2乘以10的-6次方，只要用科学计数法，就一定是浮点数。如：51200是int类型，但512e2是浮点类型。
浮点数：正数除0，得到正无穷大（Infinity）负数除0，得到负无穷大(-Infinity)，0除0得到非数(NaN，即not a number)，所有正无穷数相等，所有负无穷数也相等，非数和任何数都不相等，和自己也不相等。
只有浮点型除以0才能得到正无穷大或负无穷大，因为java会把0当成0.0处理，如果是整数除以0，会报异常：ArithmeticException
定义二进制数是，位数过高可以使用下划线分隔，如：int a = 0B1111_0000_1111_0000;

字符类型：char 字符类型一次只能存放一个字符，使用英文单引号引起来。可以存转义字符、普通字符、字符的Unicode编号。
表示方式：\u十六进制 如:\u00a 表示换行。
一个汉字表示一个字符。整数值能给字符类型直接赋值，字符中存放的就是ASCII对应的字符，如：char ch = 100; //此处ch为d,因为a对应97。Char字符取值范围为：0—65535，占2个字节，char ch = -1 会报错，同时，整数类型也可以直接用字符赋值，如：Int i = ‘a’;//此处i为97.即字符当成无符号整数使用，实际使用的是字符的编号。如果是将int类型转换成char，即将取值范围大的类型赋值给范围小的类型，需要进行强转，如 int a = 65, char = (char)a; byte、short、int、chart类型，如果要赋值的数值在取值范围内，都可以直接赋值。如char ch = 100+5;这个式子是对的 ，但char a = 5; char cd = 100 + a;这个式子会报错，在表达式中有变量 + 数值，则数值会默认当成Int类型处理，所以会报错。

字符集：为了在计算机底层保存字符，为所有字符编号，计算机在保存某个字符时，只是将该字符的编号转换成二进制码，然后保存起来，读取字符内容时，读取是二进制的编号，还需要参照编号表才能得到对应的字符。（字符集实际就是为所有字符进行编号）所以字符型也可以当成基本数据类型。
常用字符编码：
ASCII：只支持英文、数字、标点符号，只占一个字节，即能存放2^8次方(256)个字符
Iso8859-1:西欧编码语言，兼容ASCII
GB2312(中文简体字符集):中文编码------->GBK----->GB18030(字符最多,目前的简体的字符集)

Unicode:统一全球所有国家的文字（java源代码采用unicode编码）前256个字符（\u0000~\u00FF）和ASCII码中的字符完全重合
各字符对应编码数：
a----z 97 ~97+25 A----Z 65~65+25 0_9--------4857 \n----10 ‘------39 “-------34 \r-----13

乱码：由于编码和解码时用的字符编码不一致导致。
一个字节占八位，即可以存放2的8次方个编号，即可以存放2的8次方个字符，2个字节可以存放2的16次方，即可以存放2的16次方个字符。Unicode编码占两个字节。
转义序列符：\n换行 \t制表符 \输出\ \”输出” \’输出’
\u0000（Unicode转义序列符）输出一个空格

布尔类型：boolean 布尔类型只有两种取值，分别是True、false,布尔类型只占一个字节,

方法区中的常量池：存放.Class文件的一些数据,包括类、方法、解控中的常量等以及字符串中的字面值。

Long d = 6//取值范围小的可以直接赋值给取值范围大的，构成自动类型转换
d = 12345678901//会出现编译错误，整型默认为Int,该数值超过Int范围。
解决办法：在右侧的数据后加L或l，此时该值为Long,构成强制类型转换。
float y = 0.87 //出现编译错误，原因：浮点型默认为double,取值范围大的类型不能直接给取值范围小的类型赋值
//解决办法一：在数据后添加f或F，然后再给左侧float赋值,如：float y = 0.87f;该处没有构成类型转换。
//方法二：进行强制类型转换，在值前面添加（类型） 如：float y = (float)0.87，构成类型转换。
需要将一个float类型数据当成double处理，可以在数据后加D或d。
如果是整型，只要赋值的数值在类型的范围内，可以直接进行赋值。如：byte =97 + 1;此代码在编译的时候，已经计算完成，相当于byte=98 ,在byte范围之内，赋值成功。如果赋值的数值超过127，就会得到默认的类型int。但是：byte a = 2; a = a+1//此时会报错，因为在表达式运算时，如果表达式有变量，类型会自动提升为最大范围的类型，编译时a并不知道是多少，此处1为Int类型，所以表达式默认为int类型，所以编译报错。

基本类型之间转换：
自动类型转换：也叫隐式类型转换，当取值范围小的类型赋值给取值范围大的类型时。
强制类型转换：也叫显式类型转换。当取值范围大的类型赋值给取值范围小的类型时。必须进行强制类型转换，进行强制类型转换可能存在精度丢失。
字符串和任何基本类型的值进行连接运算时，都会自动转换成字符串类型，将单个数值转换成字符串可以使用 10 + “” 这种加空字符串的方式。
System.out.println(3 + 4 + “hello”)//会输出7hello,会先进行运算再拼接，从左到右
System.out.println( “hello ” + 3 + 4)//输出hello34
Int a = 23/5 //此时a = 4 除出来的小数部分会去除，两个整数相除可以赋值
类型转换6条规则：
1、基本数据类型中除了Boolean类型以外，剩余7种类型可以进行相互转换。
2、取值范围小的类型可以直接给取值范围大的类型直接赋值。当取值范围小的类型赋值给取值范围大的类型，构成自动类型转换（隐式类型转换）
取值范围从小到大排序：
char当整数使用时，是无符号整数，且占两个字节，所以取值范围为：2^16 即0~65535
3、取值范围大的类型不能直接给取值范围小的类型赋值，要赋值必须进行强制类型转换（显式类型转换），但是可能存在精度丢失。会溢出，溢出规则：用该数-目标类型的大小n（保证n取值后，减后的值在目标类型的取值范围内，且为范围内最小的整数） 如：int a = 560 byte b = (byte)a;//则b的值=560-2562=48； 如：int c = 200,byte d = (byte)c则c=200- 2561=-56
4、当对整型byte short char类型赋值时，如果没有超过该类型取值范围，则可以直接赋值。
5、当对byte short char类型进行混合运算时，则需要转换成int类型再计算,
如：byte a= 3 short b = a int c = a + b//6 c = a + ‘A’ //68
表达式类型的自动提升：当多种数据类型进行混合运算时，则自动转为取值范围最大的类型，再运算，（即整个表达式的类型，与该表达式中最高级的操作数的类型相同）
6、将浮点型强制（显式）转换成整型时，小数点后的数会去掉。
例子：
Int a = 233;byte b = (byte)a;
上方将int转换成byte，int占32位，byte占8位。转换后会截取前面的24位，只保留右边8位，此时最左边的1是符号位，是负数，以补码的形式存在，需要转换成原码。如图：
32位的int类型：00000000000000000000000011101001
8位的byte类型: 前面被截取的24位 11101001 补码形式
11101000 反码形式
10010111 原码形式
-23 十进制数，第一位转换成符号位
公式：该数的补码 - 目标类型的大小n（保证n取值后，减后的值在目标类型的取值范围内，且为范围内最小的整数）

直接量：指在程序中通过源代码直接给出的值，能指定直接量的通常只有三种类型：基本类型、字符串类型和null类型。如：int a = 10; float b = 1.2f; char c = ‘a’; Stirng d = “宏盛”;这些对变量所赋的值10、1.2f等就是直接量。
字符串直接量不能赋给其他类型的变量，null类型的变量可以赋给任何引用类型的变量，包括String类型，bolean类型的直接量只能赋给boolean类型的变量，不能赋给其他类型的变量。
当程序第一次使用某个字符串直接量时，Java会使用常量池（constant pool）来缓存该字符串直接量，如果程序后面的部分需要用到该字符串直接量时，Java会直接使用常量池中的字符串直接量。
常量池指的是在编译器被确定，并被保存在已编译的.class文件中的一些数据，包括类、方法、接口中的常量，也包括字符串直接量。

使用var定义局部变量（从java10开始才引入的特征，在java9以前都不行）
语法：var 变量名 = 值; //每个变量总有固定的类型，指定类型的变量只能装对应类型的值。
Var并不是关键字,var相当于一个动态类型，类型由java的编译器根据变量所赋的值来推断。
Var并没有改变java的本质，var只是一个简化写法–无论你是何种类型的局部变量，最终都可以使用val来声明，其类型由java的编译器根据变量所赋的值来推断。
很多语言都支持var定义变量,java10为了迎合开发者才引入var，对java功能没有任何影响。
注意：
1、Var只能在方法中定义变量（即只能定义局部变量），不允许在类中定义成员变量。
2、Var声明的变量，必须在声明的时候指定初始值，如果不指定，编译器无法推断类型。
3、Var每次只能声明一个变量！Var不允许在复合声明中使用。如：错误：var a = 1,b = 3.4;
使用var声明变量的优缺点：
优点：编程更简洁，代码可以更整齐。
缺点：使用var声明变量，会降低程序的可读性。
所以，如果声明变量时，为该变量指定了一个直观的初始值（5、2.3），此时可以使用var来声明变量。
如果变量所赋的值是很复杂的方法调用（很复杂的表达值），导致它的返回值类型并不直观，此时不应该用var声明，如：Var a = def(abc().xyz()); 此处a的类型很难看出，因此不应该使用var声明。除此之外，当变量的作用域很大的（即方法很长，）var变量影响很远，此时也不建议使用var声明。

算数运算符：+ - * / %求余 ++ –
当 + 号两边的操作数都是数值类型,则进行加法运算,当+号两边有一个为非数值类型,则+号作为连接符号,最终连接后的结果为String 如：
int a =3,b = 4;
System.out.println(“sum=” + a + b) //输出sum=34
System.out.println(“sum=” + (a + b))//输出sum=7
System.out.println(“sum” + a - b)//编译错误，因此，数值运算连接字符串时，建议加括号。
System.out.println(“sim=” + a*b)//输出sum=12 因为先算乘法，不报错，除法相同用法。
System.out.println(11/4)//2 因为两个数值都是Int类型，结果也为整型
System.out.println(7/2.0)//3.5 有浮点型的运算，结果都是浮点型。
System.out.println(4%6.0)//4.0 商0，余4
System.out.println(0%10)//0
System.out.println(6%0)//编译不出错，运行会报错，除数不能为0。
System.out.println(6%0.0)//NaN
System.out.println(5.0%0)//NaN
System.out.println(5.2%3.1)//2.1
//计算123数中各个位之和
int num =123;
int gw = num % 10;
int sw = num % 100 / 10;//int sw = num /10 %10
int bw = num / 100;
int sum = gw + sw + bw;
++表示自加：自身加1，++根据书写在变量名前后分为：前置++、后置++
前置++：先自身加1，再用变量的值（再做其他运算）
自加和自减都只能操作变量，不能操作数值、常量或表达式，如5++或6–都是错的。
Int a=3;
Int b = ++a//a=4 b=4 a自身加1，所以a=4,加完再做赋值运算，所以b = 4
后置++：先用变量的值（做运算），后再自身+1，
Int x = 5;
Int y = x++ +5;//x=6 y=10 先运算，即y = 5+5=10 运算完后x自加1，即x= 6
–表示自减：自身减1，–根据书写在变量名前后分为：前置–和后置–
前置–：先自身减1，再用变量的值（再做其他运算）
后置–：先用变量的值（做运算），后再自身-1，
int x=30,y=18;
int z = x++ - --y + y++/2 + ++x - --x + y;
System.out.println(“x = " + x + " y = " + y + " z =” + z); //输出x=31 y=18 z=40
运算逻辑：x++是先运算再自加，在运算到-号时即自加1，此时x为31，因此，下一个++x的值为31+1，然后代入表达式运算。
完成复杂运算：如乘方、开方等，需要导入模块：import java.lang.Math Math类提供了一些工具方法，完成初高中的数学运算，Math可以不用导包，直接用
Double a = 2.5,
Double b = Math.pow(a,5);//表示求a的5次方
Double c = Math.sqrt(a); //表示求a平方根，即开方
Double d = Math.random();//表示返回一个0~1之间的伪随机数
Double e = Math.sin(1.57); //表示求1.57的sin函数值
Double f = Math.round(4.5);//四舍五入，5
Double g = Math.ceil(4.5);//向上取整 5
Double h = Math.floor(4.5);//向下取整4
连接运算符：+ 作用：求和、连接
赋值运算符：= 将右侧的值赋给左侧的变量名称。
定义多个变量，一次赋值多个变量，Int a,b,c; a = b = b = 7;
扩展的（复合）赋值运算符：+= -= *= /= %=
当使用扩展的（复合）赋值运算符时，变量最终的数据类型没有发生改变。
int c = 10;
c = x + 0.5;//会报错，显示不兼容的类型，10.5为double类型，是取值范围大的类型，不能给取值范围小的int类型赋值，
C += 0.5;//结果为x =10，有扩展赋值运算符时，数据类型不会改变,会自动完成类型转换。
C += 0.5 相当于 c = (c的类型)(c+0.5)
Day02代码笔记

位运算符：只能对整型（byte short int long char）运算,针对二进制码进行运算的。
负数的二进制码保存的是补码，所以需要先将原码转换成补码，先用源码按位取反得到反码，反码+1得到补码，整数的原码跟补码是一样的。对比的是补码。如果最后的结果还是负数，补码需要换算成源码进行计算，补码-1得到反码，反码取反得到原码。

&：按位与。上下两位都是1时，得到的结果才是1
int占四个字节是32位，所以要32位二进制 码
先将数字转换成二进制码
23：0000_0000_0000_0000_0000_0000_0001_0111
69：0000_0000_0000_0000_0000_0000_0100_0101

0000_0000_0000_0000_0000_0000_0000_0101
System.out.println(23 & 69);//按位与，所以两个都是1，二进制码才是1，最后结果是5
|：按位或。上下两位有一个是1时，得到的结果就是1.当表示状态时，会用特定的数代表开关，表示文本状态：粗体(1即00000001)、斜体(2即00000010)、下划算(4即00000100)、中划线(8即00001000)等。粗体加斜体就是000000011 = 1 |2
Day-02位运算符
_{：按位取反，原来是0变成1，原来是1变成0。正数结果变成—(绝对值+1)（如}5,结果为-6）。负数结果变成+（绝对值-1）。
^：按位异或，上下两位相同的时候得到的结果是0，不同的时候得到的结果是1
<< :左移，左移N位就相当于原数乘以2的n次方，2乘以8，最快的算法：2 << 3（相当于得到2 * 2^3）将一个数扩大一倍，只需要左移1位，如int a = 1, a << 1

:右移，右移N位就相当于原数除以2的n次方，2 >> 3 （相当于2 / 2^3）
//右移三位，除以2的3次方
//除不尽的情况下，实际结果总是比除得结果略小的整数
System.out.println(34 >> 3);//4 结果为4.几，略小就是4
System.out.println(-34 >> 3); //-5，结果为-4.几，略小于-4.几，结果-5

:无符号右移，如果被移位的数是正数，那么该运算符与>>运算符一样，如果被移位的数是负数，被空出来的高位总是补0----这个数就会变成正数。

关系运算符：> < >= <= == !=不等 结果为true 或false 运算优先级：
Boolean b = 7/4 + 5%2 == 16/8 -5*2%3/
逻辑运算符：逻辑与& 逻辑或| 逻辑异或^ 逻辑非! 短路与&&短路或|| 结果为boolean
逻辑与：表示而且，两边都为true，则结果为true ,否则为false
逻辑或：表示或者，只要一边为true 则结果为true，两边为false时才为false
逻辑异或，当两边结果相同时为false.当两边的结果不相同时得到true。
逻辑非：表示对boolean类型的值取反，加运算条件时需要在运算条件加括号，如：!(1 > 9);
短路与：类似于逻辑与,都表示并且,短路与、逻辑与的运行结果都相同,但是执行过程可能不同，当使用短路与，并且第一个条件为false时，则结果直接为false，第二个条件不会判断。
短路或：类似于逻辑或,都表示或者,短路或、逻辑或的运行结果都相同,但是执行过程可能不同，当使用短路或，并且第一个条件为true时，则结果直接为true，第二个条件不会判断。
编程中，建议使用短路与和短路或，

= 与==，=属于赋值运算符，将右侧的值赋给左侧的变量名称
==属于关系运算符，判断左右两边的值是否想等，结果为boolean类型
优先运算级别：算数运算符>关系运算符>逻辑运算符

三目运算符：也叫条件运算符。
语法格式：条件？条件为true执行的代码1：条件为false执行的代码2
判断一个数，如果大于0，则输出1，如果小于0，则输出-1，否则输出0
Int a = 0, String i = a > 0?”1”:(a==0?”0”:-1)
三目运算符的嵌套：嵌套后可以返回3个或更多的值
条件1？代码1：（条件2？代码2：代码3）//条件1位false执行的代码需要括号（）

键盘接收用户输入：
第一步：导包import java.util.Scanner
第二步：创建Scanner对象 Scanner input = new Scanner(System.in);
第三步：友好提示，打印个消息，让用户知道该干啥
System.out.print(“请输入一个数：”);
第四步：键盘输入
int a = input.nextInt();
键盘输入接收字符串类型时，没有nextString()而使用的是next()，如：
String s = input.next();
键盘不能接收字符类型，而是先接收字符串类型,然后在字符串中获取第0个位置中的值，需要使用charAt(0)方法进行获取，语法：字符串名.charAt(获取的位置) 如：
String gender = input.next();
gender.charAt(0);

顺序结构：按顺序逐行代码进行执行。
程序流程控制有两大结构：
选择结构：
If 选择结构，语法格式：if(条件){
条件为true执行的代码块
}
当if语句代码块只有一条语句时，大括号{}可以省略，省略后相当于if只有一条语句，再写语句，就不包含在括号内，不管条件是否为ture，都会默认执行，此时，if条件只控制到紧跟if条件的第一个分号；
If else选择结构
语法：if(条件){
条件为true执行的代码块
}
else{
条件为false执行的代码块
}
多重if选择结构:当做两种或两种以上的情况时,则可以使用多重if选择结构完成。
If(条件1){
条件1满足时执行的代码块1
}else if(条件1不满足时判断的条件2){
条件2满足时执行的代码块2
}
If中的else是可有可无的，如果有，编写在多重If最后，最多编写一个，当所有条件都不满足时才执行。
多重if选择结构中的条件顺序可以颠倒，但是有可能会影响程序的运行结果。所以处理条件时，先处理条件范围最小的。当颠倒顺序时，条件必须编写完整严谨。

If嵌套：
if(条件一){
If(条件二){ //条件一满足会继续判断条件二
If(条件三){ //条件二满足会继续判断条件三

}
}
}else{

}
String score==“第一名” /score是字符串类型，存放的内存地址，和第一名不会相等。因此字符串比较时，使用==比较的是地址是否一致。如果想要比较内容，则必须使用equals(),如果相等。则为true，否则为false.
当字符串进行比较内容时，建议固定值编写在前面。语法:值.equals(字符串变量名)/
如： “第一名”.equals(score)

Swith case选择结构，当做等值操作时，可以使用swith case语法格式：
Swith(表达式)
{
case 常量值1(和表达式对比的值)：
当常量值1和表达式相等时执行的代码;
break;
case 常量值2(和表达式对比的值):
当常量值2和表达式相等时执行的代码;
break;
case 常量值3(和表达式对比的值):
当常量值3和表达式相等时执行的代码;
break;
default:
当所有case都不满足时执行的代码;
}
注意：
Swith case中表达式只能是byte short int char类型，在JDK7.0及以后还可以是枚举类型,String类型但不能是StringBuffer或StringBuilder类型，也不能是boolean类型。
在switch中编写任意多个case,有几种情况就写几个case,case后边写常量值（即和表达式对比的值）,常量值的类型必须与表达式的类型相同。执行完case下方代码后，遇到break，表示终止，则执行switch case外面的语句。
Default是可有可无的，如果有则一个swithc最多编写一个default,当所有case都不满足时，则执行default
Case后面常量值的顺序可以任意，一般按顺序编写。default也可以编写在任意位置。建议default编写在所有case的后面.Break可有可无，当没有编写break，java会先判断是否有相等的case值，一旦遇到相等的值，程序就开始执行这个case标签后的代码，不再判断后面case、default标签的条件是否匹配，从当前第一个匹配的case块开始执行，执行每个case下的所有代码（也就是穿透），除非遇到break才结束。

Java11编译器做了一些改进，如果开发者忘记了case块后面的break语句，Java 11编译器会生成警告：“[]fallthrough 可能无法实现case”，这个警告以前需要为javac -X:fallthrough选项才能显示出来。
根据题意适当编写break. case也可以合并
如多种情形下都执行同样代码块：
case ‘三’:
case ‘五’:
System.out.println(“自习”);

【主要两大注意点】：
1、switch语句后的括号的表达式数据类型只能是byte short char int四种整数类型，Java7还可以是枚举和String类型，
2、Case后代码块要跟一个break，否则会引入一个陷阱。

多重If与switch case区别：
多重if：可以做等值操作、也可以做区间操作。
Switch case:只能做等值操作
建议：等值操作时优先用switch case，其余操作只能用if。

循环概念：在java中做重复事情，并且重复的代码只编写一次
常用的循环：
for循环、while循环、do while循环。
循环特点：循环条件、循环操作（循环体）
for循环:
语法格式：
For(初始化语句;循环条件;迭代语句){
循环体（循环条件为true时执行的代码）
}
初始化语句完成变量的初始值，如：int i = 1;循环条件完成循环条件判断，如： i <=5;如果条件为true，则执行循环体，否则执行循环外面的语句。循环体主要做重复事情，重复做的事情在循环体只编写一次，循环体可以编写Java中任何语句。迭代语句完成变量值的更改如：i++ 初始化语句和循环条件都可以写多个。但是初始化语句只能有一个声明语句，所以如果要声明多个变量，这些变量应该具有相同的数据类型。
for(int i = 1;i <=5;i++){
System.out.print(“野兽，永不为奴”);
}
执行流程，先赋值i=1,然后判断1<=5,条件为true，执行循环体输出，再进行迭代i++.
即执行流程为：初始化语句—>判断循环条件–>循环体–>迭代语句—>判断循环条件->循环体—>迭代语句—>判断循环条件 直到循环条件为false时，结束循环，执行循环外的代码。
双重循环：也叫二重循环：在一个完整的循环中包含另一个完整的循环（即循环的嵌套）
for(初始化语句;循环条件;迭代语句)//外层循环
{
For(初始化语句（变量以及赋值等）;循环条件;迭代语句)//内层循环
{
}
}
结论：当外层循环执行一次，内层循环执行一遍。
for循环注意事项：
For循环中的表达式都可以省略，但是分号必须编写。
如果三个表达式都省略，如for(;😉{} 是一个死循环。
如果只省略初始化语句，如for(;i <=5;i++),会报错，因为没有声明i变量，解决办法：在for循环上边声明int i = 1;
如果省略循环条件，如for(int i;;i++){},条件默认是true，是一个死循环，每次执行循环体，i都自加1.
如果省略迭代语句，如for(int i = 1;i <=5;){},因为I的值一直没变，所以条件一直为true,所以也是一个死循环.解决办法：将表达式三（i++）写在循环体中最末尾的位置（最后一条语句）
for(int i =1;i <=5;i++){
System.out.print(i)
}
System.out.print(i) //会报错，显示无法找到变量i
当for循环中表达式1变量中的值在循环外进行使用，出现编译错误，解决办法：将表达式1中声明的变量，编写在循环的上边。
For循环：尽量不要在循环体内改变循环计数器的值（即进行迭代）。初始化语句可以有多条，但声明语句只有一条，所以在初始化语句声明多个变量时它们的数据类型必须相同，循环条件可以是一个包含逻辑运算符的表达式，迭代语句也可以用多条，用逗号隔开。
如：for(int i = 0, j = 0, k = 0 ; ( i + j ) * 10 >= k * k & 10 < 20 ; System.out.println(“i: ” + i++),System.out.println(“j: ” + j++),System.out.println(“k: ” + k++)) //也是对的。就是可读性比较差
注意：for循环的循环迭代语句并没有与循环体放在一起，因此即使在执行循环体时遇到continue语句结束本次循环，循环迭代语句也一样会得到执行。但while和do while的迭代语句都放在循环体内，如果用continue在迭代语句前结束循环，则迭代语句不会被执行。

如果for循环体只有一行语句，花括号也可以省略。

While循环：
语法格式：
初始化语句
While(循环条件){
循环体
迭代语句
}
执行流程：判断循环条件----->循环体、迭代语句----->继续判断循环条件---->循环体、迭代语句------>继续判断循环条件 一直到条件为false，执行次数：循环条件 == 循环体 + 1
While循环的循环体如果只有一条语句，可以省略花括号，如果省略花括号，循环只能控制他后面紧跟的第一个分号；如while(i < 10); 此处是一个死循环，因为省略了花括号，循环只能控制紧跟的第一个分号，相当于是一条空语句，会无限执行空语句。
如果希望迭代语句写在条件上，可以这么写
While(i++ < 10) //此处的i++为后置，所以先做运算再自加，即先判断循环条件，再迭代。
{
System.out.println(“HelloWorld”);
}
Int i =1;
while(i <= 10)
{
System.out.println(i);
i++;
}

do while循环:
特点：先执行，然后再判断。Do while的循环体至少执行一次。
语法格式；
初始化语句
do{
循环体
迭代语句
}while(循环条件); //最后必须加英文分号
执行流程：先执行循环体、迭代语句----->循环条件判断---->循环体、迭代语句—条件判断，直到条件为false结束。
循环条件执行次数 == 循环体执行次数
//假如对张三进行机试题测试，要求：先编写上机题代码，如果检查不合格
//继续编写代码，然后老师再检查。…一直到检查合格为止。
Scanner input = new Scanner(System.in);
char info;//info必须编写在循环外面进行声明，否则在循环条件中不能使用。

do
{
	System.out.println("编写代码....");
	System.out.println("老师检查是否合格？(y/n)");
	info = input.next().charAt(0);
}while(info == 'n');

三种循环异同点：
语法格式不同：
for(初始化语句;循环条件;迭代语句){循环体}
While(循环条件){循环体 迭代语句}
Do{循环体}while(循环条件 迭代语句);
执行顺序不同：
For循环和while先判断条件后再执行循环体,do while循环先执行循环体再判断条件。
使用情况不同：
当循环次数固定时，建议使用for循环。
当循环次数不固定时，建议使用while循环或者do while循环。
循环次数不固定，如果先判断再执行，则使用while循环
循环次数不固定，如果先执行再判断，则使用do while循环

当循环条件第一次为false时，则：For循环和while循环执行0次循环体，do while循环执行一次循环体。即for和while循环至少执行0次循环体,do while循环至少执行1次循环体.
因为while循环和do while循环的迭代语句总是放在循环体的最后，所以如果在迭代语句前用continue,则迭代语句不会执行，直接执行下一次循环，而for循环的迭代语句放在for循环的参数中，所以用不用continue,执行完循环体都会去执行一次迭代语句。

控制循环结构：
在循环中使用break语句：
表示中断，当在循环中遇到break，则结束当前所在循环，执行循环外面的语句，比如：在内循环中遇到，则终止的是内循环，外循环不受影响。
Break也可以直接结束其外层循环，此时需要在break后紧跟一个标签，这个标签用于表示一个外层循环，Java中的标签就是一个紧跟着英文冒号(:)的标识符，该标签需要放在需要终止的循环语句之前。标签名可以随意起，如：

outer:
	for (var i =0;i < 5;i++)
	{
		for(var j = 0;j < 3;j++)
		{
			System.out.println("i的值：" + i + "j的值：" + j)
			if(j==1)
		    {
				break outer;
			}
		}
	}

当j =1时，结束标签outer:标记的循环。此时输出的值如下：
i的值：0j的值：0
i的值：0j的值：1
即外层循环终止，内层循环也会终止，因为内层循环其实就是外层循环的循环体。
注意：break后的标签必须是一个有效的标签，即这个标签必须在需要终止的循环之前定义。

在循环中使用continue语句：
表示继续，当遇到continue语句时，则结束本次循环去继续执行下一次循环，即不再执行本次循环中continue以下的代码，直接进入下一次循环。
与break类似，continue后跟标签也用于跳过标签所标志循环的当次循环剩下的语句，重新开始下一次标签所代表的循环。

outer:
for (var i =0;i < 5;i++)
{
	for(var j = 0;j < 3;j++)
	{
		System.out.println("i的值：" + i + "j的值：" + j)
		if(j==1)
		{
			continue outer;
		}
	}
}

上面语句的J无法超过1，因为每当等于1时，continue outer语句就结束了外层循环的当次循环，内层循环没有机会执行完成。不带标签的continue，如果在循环体最后一行，没有任何意义。
break和continue的区别：
使用场合不同：
break:可以在循环、switch case中使用。 continue:只能在循环中使用。
作用不同：
break:表示中断，当在swithc case 中或在循环中遇到break，结束当前整个switch case或循环，执行外面的语句。
Continue:表示继续，当在循环中遇到continue,则结束当次循环，继续执行下一次循环。
Return：功能是结束一个方法，当一个方法执行到一个return语句时，这个方法将被结束，因此方法中的所有循环及代码都会结束。