目录
1 注释
单行注释：//注释内容
多行注释：/* 注释内容 */
文档注释：文档注释以/**开始，以*/结束
2 常量与变量
2.1常量：在程序运行过程中，其值不可以发生改变的量
字符串常量：用双引号括起来的多个字符 如："a" "aa" "吴磊"
整数常量：整数 如：-10，0，99
小数常量：小数 如：-0.22，0.22
字符常量：用单引号括起来的一个字符 如：'a' '中'
布尔常量：布尔值，表示真假，只有true和false两个值
空常量：一个特殊的值 空值 值为null
2.2变量：在程序运行过程中，其值可以发生改变的量
（1） 变量公式：数据类型 变量名 =数据值
（2）注意事项：☆在同一个花括号下变量名不能重复
☆变量在使用之前，必须初始化（赋值）
☆定义long类型的变量时，需要在整数后面加个L（大小写均可，建议大写）。因为 整数默认是int类型，整数太大可能超出int范围。
☆定义float类型的变量时，需要在整数后面加个F（大小写均可，建议大写)。 因为浮点数的默认类型为double，double取值范围大于float的，类型不兼容。
（3）类型转换
★数据类型从小到大关系图
★说明：☆整数默认是int类型，byte，short和char类型数据参与运算会自动转换为int类型。
☆boolean类型不能与其他基本数据类型进行转换。
★强制转换：
把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量
double num1 =5.5;
int a= (int)num1;//将double类型的num1强制转换成int类型的a。
System.out.println(a);//输出5（小数位直接舍掉，不是四舍五入）。★常量优化机制：
在编译时，整数常量的计算会直接算出结果，并且自动判断该结果是否在该数据类型的取值范围内，如果在则编译通过，否则失败。
byte a =4;
byte b =5;
byte c =a+b;//❌，因为两个byte变量相加，会先提升为int类型。
byte d =4+5;//✔，常量优化机制。byte b1 =10;
byte b2 =20;
byte b3 =b1+b2; //报错，b1 和 b2会自动转换成int类型 int赋值给byte需要强转
修改为 int num =b1+b2； 或 byte b3 =（byte）（b1+b2）；★赋值运算符隐含了强制转换类型
short s =10;
s=s+10;//报错，因为运算中S提升为int类型，运算结果int赋值给short可能损失精度
s+=10;//正确，隐含着s=(short)(s+10);3 数据类型
Java是一个强类型语言，Java中数据必须明确数据类型。在Java中的数据类型包含基本数据类型和引用数据类型两种。
（1）Java中的基本数据类型
ps：e+38表示是乘以10的38次方，同样，e-45是表示乘以10的负45次方。
ps：在Java中整数默认是int类型，浮点数默认是double类型。
（2）Java中常见的引用数据类型：类(class)，接口（interface), 数组( [ ] )。
4 运算符
4.1 基本算数运算符：
加（+） 减（-） 乘（*） 除（/） 取余（%）
ps：整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。
★字符也可参与算数运算，使用的是计算机底层对应的十进制数。
'A'--65 'a'--97 '0'--48
char ch ='a';
System.out.println(ch+3);结果为100★当”+“操作中出现字符串时，这个”+“是字符串连接符，而不是算数运算。
ps：在”+“操作中，如果出现了字符串，就是连接运算符，否则就是算数运算。当连续进行+操作时，从左到右逐个执行。
System.out.println(1+"lijiannan");结果1lijiannan
System.out.println(1+2+"lijiannan"+3+4); 结果3lijiannan34
System.out.println(1+2+"lijiannan"+(3+4));结果3lijiannan74.2 自增自减运算
++ 自增 变量的值+1；
-- 自减 变量的值-1;
ps：++或--放在前面叫做前置递增（递减），先拿变量做++或--，后拿变量参与操作。
++或--放置后面叫做后置递增（递减），先拿变量参与操作，后进行++或--。
int x =10;
int y =x++; //x输出的结果为11，y输出的结果为10。
//***************************************************************************
int x =10；
int y = x++ +x++ +x++; //(10+11+12) 结果x=13，y=33.4.3 赋值运算符
4.4 关系运算符
== != > >= < <=
Ps:共6种关系，判断a，b是否符合关系，返回类型为布尔类型（true和false）
4.5 逻辑运算符
& 逻辑与 全真才真
| 逻辑或 全假才假
^ 逻辑异或 a^b a和b结果不同为true，结果相同为false
！逻辑非 !a 表示与a的结果相反
4.6 短路逻辑运算符
4.7 三元运算符
关系表达式？表达式1：表达式2；
问号前面是判断条件，返回类型为布尔类型，若为true则调用表达式1，若为false则调用表达式2。
5 流程控制语句
顺序结构：按照代码从前往后执行
分支结构（if switch）
循环结构（for，while，do....while）
5.1 if语句
语法1
if（关系表达式）{
语句体；
}
语法2
if（关系表达式）{
语句体1；
} else{
语句体2；
}
语法3
if（关系表达式1）{
语句体1；
}
else if(关系表达式2){
语句体2；
}
.....
else{
语句体n+1；
}
5.2 switch语句
语法
switch（表达式）{
case 1：
语句体1；
break；
case 2 ：
语句体2；
break；
...
default ：
语句体n+1；
break；
}
流程：首先计算表达式的值，其次和case依次比较，一旦有对应的值就会执行相应的语句，在执行过程中，遇到break，就会结束。最后如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
case穿透：如果switch语句中case省略了break语句，就会开始case穿透。
例如：case1 ：
case 2：
case 3：
case 4：System.out.println（"穿透力"）；//表达式结果为1234都会输出：穿透力
5.3 for循环
语法
for(初始化语句；条件判断语句；条件控制语句){
循环体语句；
}
5.4 while 循环
while（条件判断语句）{
循环体语句；
条件控制语句；
}
5.5 do while循环
初始化语句；
do{
循环体语句；
条件控制语句；
}while（条件判断语句）；
5.6 break 和continue
break 跳出循环，结束循环。
continue 跳过本次循环，继续下次循环。（只能在循环中使用）
6 键盘录入和随机数的产生
★ 键盘录入：
1 导包 import java.util.Scanner；
2 创建Scanner对象 Scanner sc =new Scanner（System.in)；
3 接受数据 int i=sc.nextInt（）；//将键盘录入的数，作为int数返回。
★产生随机数：
1 导包 import java.util.Random；
2 创建对象 Random r =new Random（）；
3 产生随机数 int num =r.nextInt(10)；
ps：10代表一个范围，如果括号写10，则产生的随机数的范围是0-9，括号写20，则生成随机数的范围为0-19.
7 数组
7.1 一维数组
★数组定义：数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。
★数组的定义格式
第一种：int [ ] arr;
第二种：int arr [ ];
★数组的初始化
☆动态初始化：只给定数组的长度，由系统给出默认初始化值。
格式 ：数据类型 [ ] 数组名 = new 数据类型 [数组长度]；
int [ ] arr =new int [3]；
☆静态初始化：在创建数组的时候，直接将元素确定。
完整版：数据类型 [ ] 数组名 =new 数据类型 [ ] {元素1，元素2....}；
简化版：数据类型 [ ] 数组名 ={元素1，元素2....};
★说明
（1）输出数组名会得到的是数组的内存地址，例如 [B@b4c966a
[ 表示的是当前空间是一个数组类型 B表是数据类型是Byte @是分隔符 b4c966a是16进制内存地址。
（2）索引：每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。这个自动编号称为数组索引，可以通过数组索引访问数组中的元素。
（3）数组名.length 可以获得数组的长度
7.2 二维数组
★数组定义：二维数组也是一种容器，不同于一维数组，该容器存储的都是一维数组容器。
★二维数组初始化
☆动态初始化：数据类型 【】【】 变量名 =new 数据类型 【m】【n】；
m表示这个二维数组，可以存放多少个一维数组。
n表示每一个一维数组，可以存放多少个元素。
☆静态初始化：
（1)数据类型【】【】 变量名=new 数据类型【】【】{{元素1，元素2...},{元素1，元素2...}，....}；
（2)数据类型【】【】 变量名={{元素1，元素2...},{元素1，元素2...}，....}；
★说明
（1）输出数组名会得到的是数组的内存地址，例如 [[B@b4c966a
[ [表示的是当前空间是一个二维数组类型（几个[代表几维数组） B表是数据类型是Byte @是分隔符 b4c966a是16进制内存地址
8 方法
8.1 方法的概念
方法：是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集
注意：
（1）方法必须先创立才可以使用，该过程称为方法定义。
（2）方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程称为方法调用。
8.2 方法的定义与调用
（1）无参数方法的定义与调用
方法：
public static void 方法名（）{
//方法体；
}
调用：
方法名（）；
（2）带参数方法定义与调用
方法：
public static void 方法名（参数1）{ //形参
方法体；
}
调用：
方法名（参数）；//实参
注意：
（3）带返回的方法定义与调用
方法：
public static 数据类型 方法名（参数）{
return 数据；
}
调用：
数据类型 变量名=方法名（参数）；
注意：
（1）方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错。
（2）return语句只能带一个返回值
说明：
（1）方法不能嵌套使用
（2）void表示无返回值，可以省略return，也可以单独书写return，后面不加数据。（如：return；)
8.3 方法重载
★定义：方法重载指的是同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
（1）多个方法在同一个类中
（2）多个方法具有相同的方法名
（3）多个方法的参数不同（类型或者数量不同）
★注意：
（1）重载仅是对方法的定义，与方法的调用无关，调用方式参照标准格式。
（2）重载仅针对同一类中方法的名称和参数进行识别，与返回值无关（数据类型），换句话说不能通过返回值来判定两个方法是否构成重载。
正确实例
public class Test{
public static void(int a){
//方法体
}
public static int (double a){
//方法体
return 0;
}
}
错误实例
public class Test{
public static void fn（int a）{
//方法体
}
public static int fn（int a）{
//方法体
}
}8.4 方法的参数传递
☆基本数据类型的参数传递
public class Test01 {
public static void main(String[] args) {
int num =100;
System.out.println("改变前"+num); //100
change(num);
System.out.println("改变后"+num); //100
}
private static void change(int num) {
num =200;
}
}★结论：
（1）基本数据类型的参数，形式参数的改变，不影响实际参数。
（2）每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失。
☆应用数据类型的参数传递
public class Test01 {
public static void main(String[] args) {
int [] num ={10,20,30};
System.out.println("前"+num[0]); //10
change(num);
System.out.println("后"+num[0]); //99
}
private static void change(int [] arr) {
arr[0] =99;
}
}结论：
（1）对于引用类型的参数，形式参数的改变，影响实际参数的值
（2）引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以即使方法弹栈，堆内存的数据也已经是改变后的结果。
159
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
