目录
Java学习总结
变量
变量: 一个可以装载“字面量”的容器
代码的结尾要用;（英文分号）
int a = 1;数据类型 变量名称 = 数据值（字面量） 变量声明：数据类型 变量名称
int b;变量的初始化：变量名称 = 数据值（字面量）
b = 2;数据类型 要与数据值（字面量）保持一致 数据类型(基本数据类型)：byte short int long float double char boolean 保持一致：int整数类型 === 11整数类型
int c = "张三"; //编译错误：有红线的代码区域 使用变量
System.out.println(a);
System.out.println(b);
变量相互赋值:将变量的值赋值给其他变量
int n1 = 1;
int n2 = n1;
变量的名称，规则（前、中后）：
1、变量名称的开头只能以_或$(￥ 人民币),英文字母 定义
2、变量名称的中间只能以_或$(￥ 人民币),英文字母,数字 定义
int _admin;
int $admin;
int admin;
int Admin;
int ￥admin;
int ad_min;
int ad$min;
int admin01;
int ad01min;在方法内，如果一个变量仅仅只声明，那么它不可以被使用 (在方法内，一个变量需要被初始化后才能使用)
int m;
System.out.println(m);补充：1、变量不能重名
2、变量名称的大小写敏感
3、变量可以多个一起定义
int s = 1;//字母大小写对Java来说，是不同的（敏感）。
int S = 2;多个变量声明
int a1,a2,a3,a4;
int a1,a2,a3,a4 = 12;
int a1=1,a2=2,a3=3,a4 = 12;单行注释：注释一行内容（内容上边，或者结尾右侧对变量或者常量注释，对某一行代码进行解释 快捷方式： Ctrl + / /* 多行注释：注释一个代码片段（方法、方法中的某几行） */ /* 快捷方式 /* + Enter */
数据类型
整数类型：int （byte short long）
整数类型：long
为什么要用long类型？ int数值范围无法表示的情况下所有整数数值类型默认为int
注意：long类型数值后需要加上L或者l
浮点类型：float 注释：float定义浮点数类型时，需要加上F或者f
浮点类型:double
字符类型：char （基本数据类型）
整数类型 byte < short < int < long
大范围的数值类型 ==> 小范围的数据类型 ：强制转化 口诀：大转小要强转 注意！运算方向是从右往左
小范围的数值类型 ==> 大范围的数据类型 ：自动转化
口诀：小转大自动转
数值范围大小：byte < short < int < long < float < double
浮点型由于表示数的范围有特殊方式（不同于整数），所以float > long > int
整数值的默认类型是int，小数值的默认类型是double
加、减、乘、除、取余（求模）
int a = 3;
int b = 7;
float c = 7.0f;
System.out.println(a + b);//10
System.out.println(a - b);//-4
System.out.println(a * b);//21
System.out.println(a / b);//0
//求模运算为 %
System.out.println(a % b);//3两数相除：1、两数都是整数类型，求整数商
2、两数任意一个是浮点数，求浮点数的商
System.out.println(a / c);//0.42857143
System.out.println(a % c);//3.0数据类型表达式：
运算表达式的最终类型，由运算表达式中的最大类型来决定。
int n = 1;
long m = 2;
long l = n + m; //最终类型是long，因为m是最高的long类型
double d = 1.2;
double d2 = n + d;
//注意：值溢出的风险。
int类型 2100000000
int n1 = 210000;
int n2 = 210000;
int n3 = n1 * n2;//int 值溢出风险
System.out.println(n3);程序逻辑在方法中是严格从上往下执行的
++ : 自加一
-- : 自减一
int a = 5;
a++;
a = a + 1 : =赋值运算从右往左
System.out.println(a);
a--;
a = a - 1
System.out.println(a);什么是表达式？
例如：a-b; b++; ++b :注意表达式最终都是以结果形式显示b（变量）的值，与b++,++b （表达式）的值是有区别的++，--在变量”左侧“和“右侧”的区别
判断依据： 看运算符在前，还是变量在前。
如果运算符在前，则先对值进行自加，再将值赋值给左侧
如果是变量在前，则先把值赋值给左侧，再自加。
字符串拼接符
String a = "abc";
String b = "123";
System.out.println(a + b); 重点：
字符串拼接符的判断依据：+ 的任意一侧有字符串出现时，它就是拼接符
字符串拼接符 与普通的加减运算的优先级一致。
运算符
赋值运算符 = ：1、优先等级最低 2、从右往左运算 赋值运算的扩展运算符： += -= /= *= %=
int a = 1;//将1赋值给a变量
int b = 2;
b += a; //b = b + a
System.out.println(b);//3
b *= a;
System.out.println(b);//3
int c = 5;
b %= c;//b = b % c
System.out.println(b);//3交换两个数的值
a = 7; b = 3;
int a = 3;
int b = 7;
a = b;//a = 7; b = 7;
b = a;//a = 7; b = 7;
需要定义一个中间量：
int tmp;
tmp = b;
b = a;
a = tmp;
System.out.println("a = " + a);
System.out.println("b = " + b);比较运算符 == 等号 === 恒等 引用数据类型 > , < , >= , <= ,!=
字符类型的比较:字符类型的比较是通过ASCII所对应的十进制编码进行比较 字符串类型的比较:字符串的不能用大小关系比较
if语句（如果)
格式：if(布尔表达式){ 执行语句 }
描述：如果布尔表达式成立，就会执行“执行语句”，否则直接跳过这一次判断
//案例： 大于等于60分：成绩及格
double score = 90;
if(score >= 60){
System.out.println("成绩及格");
}
System.out.println("结束");if...else 语句
格式：if(布尔表达式){ 执行语句 }else{ 执行语句 }
描述：如果布尔表达式成立，就会执行if中的“执行语句”，否则执行else中的“执行语句”
//案例：大于等于60分：成绩及格 小于60分：不及格
if(score >= 60){
System.out.println("成绩及格");
}else{
System.out.println("不及格");
}if...else if 语句
格式：if(布尔表达式){ 执行语句 }else if(布尔表达式){ 执行语句 }
描述：如果if中布尔表达式成立，就会执行if中的“执行语句”
如果else if中布尔表达式成立，就会执行else if中的“执行语句”
随着条件的增多，我们可以增加else if的数量。
案例：大于等于90 :优秀
80~90:良好
60~80：合格
0 ~60：差
if(score >= 90){
System.out.println("优秀");
}else if(score >= 80 && score < 90){//score < 90
System.out.println("良好");
}else if(score >= 60 && score < 80) {
System.out.println("合格");
}else if(score < 60){
System.out.println("差");
}控制台输入：java.util.Scanner 1、引入Scanner工具 ：
import java.util.Scanner;2、新建Scanner的对象：
Scanner scan = new Scanner(System.in);3、先使用System.out.println("请输入内容:");
4、使用scan.nextXXX 定义输入值的类型。
随机数 Math.random() Math.random() 创建一个0~1的数（且不包含1） double类型
switch语句
switch语句格式：switch(数据值或变量){ case 值1:...; case 值2 :...;... }
//选项卡：选择1 选择2 选择3...
int n = 2; //选择的数据变量
switch (n){
case 1:
System.out.println("n为1");
break;//通过break可以终止整个switch语句
case 2:
System.out.println("n为2");
break;//通过break可以终止整个switch语句
case 3:
System.out.println("n为3");
break;//通过break可以终止整个switch语句
}注意：1、switch括号中一般是变量，变量需要指定特殊的数据类型(byte short int char String(Character))
switch不可以设置的类型有：long,double,float
2、有无break的情况（break 跳出（停止）switch语句）,没有break情况，程序会继续往后执行。
3、关于if语句与switch的区别：switch不能判断范围条件.
4、default 除了case之外的其他条件，（default为了程序健壮性）
for循环
for循环格式 for(初始化内容;结束循环条件;变化方式){...}
初始化内容：int i = 0
结束循环条件: i < 5 (布尔表达式)
变化方式: i++
循环是什么：解决重复代码问题。
//举例：重复打印Hello World 50遍
for(int i = 0; i < 50; i++){
System.out.println(i);
}
循环的特殊结构
死循环:循环没有结束条件
for(int i = 0;;i++){}
for(int i = 0;i < 5;){}
for(;;){}while 循环
//while循环格式 while(布尔表达式){ ... }
int a = 1;
while (a < 10){
a++;
System.out.println(a);
}
//while循环特殊形式
//while死循环
while(true){}do-while 循环
格式： do{ 执行代码 }while(布尔表达式);
int a = 10;
while(a < 10){
a++;
System.out.println(a);
}
int b = 10;
do{
b++;
System.out.println(b);
}while(b < 10);while 和 do-while的区别 do-while 是先执行再判断 while是先判断再执行
注意：break 在switch中，退出switch break 在循环中出现，退出循环 continue 在循环中出现，跳过本地循环，开始下一次循环(本质：continue 到 i++ 开始下一次循环)
数组 :
简单定义：义将一类数据方到一个整体中 专业定义：将数据类型相同的数据，放到一个集合
数组的定义方式：1、静态初始化 2、动态初始化
1、静态初始化 : 在构建数组时就给予初始化的值
数组类型： 数据类型[]、变量[]
数组初始化 {数组元素,数组元素,....}
int[] a = {1,2,3};//1、数组有3个元素长度 2
int b[] = {1,2,3};2、动态初始化 ：先构建数组的对象，然后在逐一赋值初始化 基本格式： 数据类型[] 变量名 = new 数据类型[数组的长度]
int[] c = new int[3];注意：数组的类型决定了元素是什么样的类型
动态初始化过程 new: 对象创建 虽然new int[3] 开辟了三个空间，但是空间中是有指定类型的默认值
int[] b = new int[3];
System.out.println(b[0]);//输出默认值0
b[0] = 1;
System.out.println(b[0]);数组空间：
int[] a = {1,2,3};
1、数组a的地址，指向了1，2，3元素所在的堆内存空间
2、而数组a的地址等于 1元素所在空间的地址。
3、1，2，3元素所在的堆内存空间的地址是连续的
对指定下标的数组元素赋值，可以直接修改该数组
a[1] = 4;
//其他类型数组的默认值
float[] n1 = new float[3];//默认值0.0
char[] n2 = new char[3];
System.out.println(n2[0]);//空字符
boolean[] n3 = new boolean[3];
System.out.println(n3[0]);//false
//引用数据类型的默认值
String[] n4 = new String[3];
System.out.println(n4[0]);//null 空对象数组复制 System.arraycopy
System.arraycopy(src,srcPos,dest,destPos,length)
src : 被复制的数组（从哪个数组复制）
srcPos : 从src的哪个下标开始复制
dest : 粘贴到的数组
destPos : 从dest的哪个下标开始粘贴
length : 复制的数据元素的长度
int[] c = {7,8,9,10,11,12};
System.arraycopy(a,2,c,2,2);
System.out.println("c数组：" + Arrays.toString(c));
System.out.println("a数组：" + Arrays.toString(a));数组扩容
数组阔容的办法
Arrays.copyOf(src,length)
//src:需要扩容的数组
//length:扩容的长度
int[] c = {1,2,3};
c = Arrays.copyOf(c,4);
System.out.println(Arrays.toString(c));
冒泡排序
int[] a = {5,4,3,2,1};
//通过推理,总共有a.length - 1 次排序
for(int j = 0; j < a.length - 1; j++){
//一次排序
//1.考虑倒数的第二位元素结束: i < a.length - 1
//a.length - 1 - j : 考虑到不用比较的次数
for (int i = 0; i < a.length - 1 - j; i++){
//2.前面的数和后面的数比较大小
if(a[i] > a[i+1]){
//3.交换
int tmp;
tmp = a[i];
a[i] = a[i+1];
a[i+1] = tmp;
}
}
System.out.println(Arrays.toString(a));
}
System.out.println(Arrays.toString(a));排序函数
public static void main(String[] args) {
int[] a = {5,4,3,2,1};
Arrays.sort(a);//从小到大的排序
System.out.println(Arrays.toString(a));
}public static void main(String[] args) {
//问题 ["红","蓝","绿","蓝","红","绿"]
// 按照:' 绿 < 蓝 < 红 '的规则排序
String[] b = {"红","蓝","绿","蓝","红","绿"};
for(int j = 0; j < b.length - 1; j++){
for(int i = 0; i < b.length - 1; i++){
if(b[i] == "蓝" && b[i+1] == "绿" || b[i] == "红" && b[i+1] == "蓝"|| b[i] == "红" && b[i+1] == "绿" ){
String tmp;
tmp = b[i];
b[i] = b[i+1];
b[i+1] = tmp;
}
}
}
System.out.println(Arrays.toString(b));
}
二维数组
二维数组 : 二维数组的元素是一维数组 定义方式 int[][] 数组名称
静态初始化
int[][] n1 = {{1,2,3},{3,4,5}};动态初始化 理解方式一: new int[行][列] 理解方式二: new int[有几个一维数组][这些一维数组中有几个元素]
int[][] n2 = new int[3][3];
int[][] n3 = new int[3][];// = {[],[],[]};//元素是三个空的一维数组length 数组长度
System.out.println(n4.length);//有多少个一维数组
System.out.println(n4[n4.length - 1].length);//指定一维数组中的元素个数二维数组的遍历
for(int i = 0; i < n4.length; i++){
for(int j = 0; j < n4[i].length; j++){
System.out.println(n4[i][j]);
}
}
63
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
