目录
常量使用：
在Java语言中，主要是利用final关键字来定义常量。当常量被设定后，一般情况下就不允许再进行更改。如下的形式来定义一个常量：
final double PI=3.1315；
在定义这个常量时，需要注意如下内容：
1.常量在定义的时候，必须对常量进行初始化。
2.当在常量定义的时候初始化过后，在应用程序中就无法再次对这个常量进行赋值。如果强行赋值的话，会跳出错误信息。
3.常量名要全部大写
一、关键字与标识符
1.java关键字的使用
定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
特点：关键字中所字母都为小写
具体哪些关键字：
2.保留字
保留字：现Java版本尚未使用，但以后版本可能会作为关键字使用
具体哪些保留字：goto 、const
注意：自己命名标识符时要避免使用这些保留字
3.标识符的使用
定义：凡是自己可以起名字的地方都叫标识符。
涉及到的结构：
包名、类名、接口名、变量名、方法名、常量名
3.1标识符命名规则
规则：(必须要遵守。否则，编译不通过)
> 由26个英文字母大小写，0-9 ，_或 $ 组成
> 数字不可以开头。
> 不可以使用关键字和保留字，但能包含关键字和保留字。
> Java中严格区分大小写，长度无限制。
> 标识符不能包含空格。
3.2标识符命名规范
规范：（可以不遵守，不影响编译和运行。但是要求大家遵守）
注意点：
注意1：在起名字时，为了提高阅读性，要尽量意义，“见名知意”。
注意2：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。
Java命名规范：《代码整洁之道》_chasing鱼的博客-CSDN博客
二、变量的使用
1.变量的分类
1.1 按数据类型分类
详细说明：
1.整型：byte（1字节=8bit）\short(2字节)\int（4字节）\long（8字节）
bit:位，计算机中最小的单位，1bit代表二进制中的一个“0”或一个“1”
①byte范围：-128~127
②声名long型的变量，必须以L或l结尾
③通常定义整型变量是用int
注：一般在java中写整数时，默认的数据类型是整型
例子：short a = 1;short b=2;
short c = a+b;//会报错，int类型不能赋值给short类型
2.浮点型：float（4字节）\double（8字节）
①浮点型：表示带小数点的数值
②float表示数值的范围比long还大
③定义float类型变量时，变量要以“f”或“F”结尾
④通常，定义浮点型变量时，使用double型。
⑤浮点型的常量，默认类型为：double
获取float、double所能表示的最大值和最小值（其他数据类型也适用,int类型要使用包装类（Integer））？
System,out,println(Float.MAX_VALUE);//最大值
System.out.println(Double.MIN_VALUE);//最小值
3.字符型：char（一个字符=2字节）
① 定义char型变量，通常使用一对''，内部只能写一个字符
②表示方式：1.声名一个字符
2.转义字符
3.直接使用Unicode值来表示字符型变量
4.布尔类型：boolean
①只能取两个值之一：true、false
②常常在条件判断、循环结构中使用
1.2 按声明的位置分类(了解)
2.定义变量的格式：
数据类型 变量名 =变量值;
或
数据类型 变量名；
变量名 变量值；
3.变量使用的注意点：
①变量必须先声明，后使用；
②变量都定义在其作用域内，在作用域内，它是有效的。换句话说，出了作用域，就失效了。
③同一个作用域，不可以声名两个同名的变量。声名的变量名不能重复。
4.基本数据类型变量间运算规则
4.1 涉及到的基本数据类型：不包含boolean类型的剩余7种基本类型变量间的运算。
4.2 自动类型转换(只涉及7种基本数据类型）
结论：当容量小的数据类型与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
short、char、byte -->short -->int -->long -->float -->double
特别的：bute、short、char三种类型做运算时，结果为int类型
说明：此时的容量大小指的是：表示数的范围的大和小。比如：float的容量要大于long
注：char的对应数值的取值范围（0-65535）
char在被转换成int时值要对应ASCII码表，字符’0‘：48；字符’a‘:97;字符’A‘：65，向下不断变大
4.3 强制类型转换(只涉及7种基本数据类型）：自动类型提升运算的逆运算。
1.需要使用强转符:()
2.注意点：强制转换类型，可能导致精度损失。
注：强制转换也可以由容量小的转换为容量大的
4.4 String与8种基本数据类型间的运算
1.String类型为引用数据类型，翻译为：字符串
2.声名Stirng类型变量时，必须使用一对"";
3.String可以和8种数据类型做运算，且运算只能是连接运算: +;
4.运算的结果仍然是String类型
5.String类型进行运算时，也遵守基本运算规则：先乘除后加减;‘+’连接运算也要在乘除运算之后进行
注：如何判断‘+’为连接运算还是加法运算？
查看运算前后是否出现String类型的变量，有则为连接运算，没有则是加法运算。
String类型变量之后一般都是连接运算;
避免（以下为错误编写）：
String s=123;//编译错误
String s1="123";//正确
int i=(int)s1;//编译错误
通过Integer.parseInt()这个包可以使String类型的变量转换为int类型
int num1=Integer.parseInt(str1);//正确
三、进制（了解）
1.编程中涉及的进制及表示方式：
2.二进制的使用说明：
2.1 计算机底层的存储方式：所有数字在计算机底层都以二进制形式存在。
2.2 二进制数据的存储方式：所有数值，不管正负，底层都以补码的方式存储
2.3 原码、反码、补码的说明：
正数：三码合一，原码、反码、补码都相同；
负数：
3.进制间的转换：
3.1 图示：
3.2 图示二进制转换为十进制：
3.3 图示十进制转换为二进制：
3.4 二进制与八进制、十六进制间的转换：
四、运算符
运算符优先级：算术运算符 > 关系运算符 > 逻辑运算符
1.算术运算符
算术运算符： + - + - * / % (前)++ (后)++ (前)-- (后)-- +
byte、short、char在进行运算时，会转换成int型的在进行运算
注：字符串相加“+”：当“+”操作中出现字符串时，这个“+”就变成了字符串的连接符而不是算术运算符了。它会将当前的数据进行拼接，并产生一个新的字符串
例子：
System.out.println(1+"abc");//1abc
//注意区分+所处的位置
System.out.println(1+2+"def");//3def
System.out.println("htm"+1+2);//htm12注2：字符进行相加时，字符+字符，字符+数字，字符都会转换成int型在进行运算，可以参考ASCII码；注意A：65，a:97，0:48；
例子：
【典型代码】
//除号：/
int num1 = 12;
int num2 = 5;
int result1 = num1 / num2;
System.out.println(result1);//2
// %:取余运算
//结果的符号与被模数的符号相同
//开发中，经常使用%来判断能否被除尽的情况。
int m1 = 12;
int n1 = 5;
System.out.println("m1 % n1 = " + m1 % n1);
int m2 = -12;
int n2 = 5;
System.out.println("m2 % n2 = " + m2 % n2);
int m3 = 12;
int n3 = -5;
System.out.println("m3 % n3 = " + m3 % n3);
int m4 = -12;
int n4 = -5;
System.out.println("m4 % n4 = " + m4 % n4);
//(前)++ :先自增1，后运算
//(后)++ :先运算，后自增1
int a1 = 10;
int b1 = ++a1;
System.out.println("a1 = " + a1 + ",b1 = " + b1);
int a2 = 10;
int b2 = a2++;
System.out.println("a2 = " + a2 + ",b2 = " + b2);
int a3 = 10;
++a3;//a3++;
int b3 = a3;
//(前)-- :先自减1，后运算
//(后)-- :先运算，后自减1
int a4 = 10;
int b4 = a4--;//int b4 = --a4;
System.out.println("a4 = " + a4 + ",b4 = " + b4);
【特别说明的】
1.(前)++ :先自增1，后运算
(后)++ :先运算，后自增1
2.(前)-- :先自减1，后运算
(后)-- :先运算，后自减1
3.连接符：+：只能使用在String与其他数据类型变量之间使用。
注：int num=10;
①num +=num++;//num=num+(num++)-->10+10
System.out.println(num);//20
②num +=++num;//num=num+ (++num)--->10+(10+1)
System.out.println(num);//21
2.赋值运算符
赋值运算符：= += -= *= /= %=
【典型代码】
int i2,j2;
//连续赋值
i2 = j2 = 10;
//***************
int i3 = 10,j3 = 20;
int num1 = 10;
num1 += 2;//num1 = num1 + 2;
System.out.println(num1);//12
int num2 = 12;
num2 %= 5;//num2 = num2 % 5;
System.out.println(num2);
short s1 = 10;
//s1 = s1 + 2;//编译失败，自动类型提升
s1 += 2;//结论：不会改变变量本身的数据类型
System.out.println(s1);
【特别说明的】
1.运算的结果不会改变变量本身的数据类型
2.
开发中，如果希望变量实现+2的操作，有几种方法？(前提：int num = 10;)
方式一：num = num + 2;
方式二：num += 2; (推荐)
开发中，如果希望变量实现+1的操作，有几种方法？(前提：int num = 10;)
方式一：num = num + 1;
方式二：num += 1;
方式三：num++; (推荐)
3.int n=10;n+=(n++)+(++n)结果是多少？
n+=(n++)+(++n)--->n=n+(n++)+(++n)--->10+10+12=32
n+(n++)-->10+10,n++,n由10自+1变为11
（++n），n变为了11，（++n）为12
若，直接输出n +=n++,n=20，n+n=20运算结束将值赋值给n，n++=11不会再进行赋值;
若，n+(n++)+(++n),在运算n+(n++)时,运算没有结束，n++进行运算将值赋给n;
n += (n++) + (++n)的运算过程相当于：
第一步： int n1=n+n;//先运算
第二步： n++;//在自增1
第三步：++n;//先自增1
第四步： n=n1+n;//在运算
最后得出结果n=32
3.比较运算符（关系运算符）
比较运算符（关系运算符）: == != > < >= <= instanceof
【典型代码】
int i = 10;
int j = 20;
System.out.println(i == j);//false
System.out.println(i = j);//20
boolean b1 = true;
boolean b2 = false;
System.out.println(b2 == b1);//false
System.out.println(b2 = b1);//true
System.out.println("-------------练习题：z= ----------------");
boolean x=true;
boolean y=false;
short z=42;
//if(y == true)
if((z++==42)&&(y=true))z++;//y=true为赋值运算区分“==”与“=”
if((x=false) || (++z==45)) z++;
System.out.println("z="+z);//46
【特别说明的】
1.比较运算符的结果是boolean类型
2.> < >= <= :只能使用在数值类型的数据之间。
3. == 和 !=: 不仅可以使用在数值类型数据之间，还可以使用在其他引用类型变量之间。
Account acct1 = new Account(1000);
Account acct2 = new Account(1000);
boolean b1 = (acct1 == acct2);比较两个Account是否是同一个账户。
boolean b2 = (acct1 != acct2);
4.逻辑运算符
逻辑运算符：& && | || ! ^
【典型代码】
//区分& 与 &&
//相同点1：& 与 && 的运算结果相同
//相同点2：当符号左边是true时，二者都会执行符号右边的运算
//不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
//开发中，推荐使用&&
boolean b1 = true;
b1 = false;
int num1 = 10;
if(b1 & (num1++ > 0)){
System.out.println("我现在在北京");
}else{
System.out.println("我现在在南京");
}
System.out.println("num1 = " + num1);
boolean b2 = true;
b2 = false;
int num2 = 10;
if(b2 && (num2++ > 0)){
System.out.println("我现在在北京");
}else{
System.out.println("我现在在南京");
}
System.out.println("num2 = " + num2);
// 区分：| 与 ||
//相同点1：| 与 || 的运算结果相同
//相同点2：当符号左边是false时，二者都会执行符号右边的运算
//不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
//开发中，推荐使用||
boolean b3 = false;
b3 = true;
int num3 = 10;
if(b3 | (num3++ > 0)){
System.out.println("我现在在北京");
}else{
System.out.println("我现在在南京");
}
System.out.println("num3 = " + num3);
boolean b4 = false;
b4 = true;
int num4 = 10;
if(b4 || (num4++ > 0)){
System.out.println("我现在在北京");
}else{
System.out.println("我现在在南京");
}
System.out.println("num4 = " + num4);
【特别说明的】
1.逻辑运算符操作的都是boolean类型的变量。而且结果也是boolean类型
5.位运算符
位运算符：<< >> >>> & | ^ ~
【典型代码】
int i = 21;
i = -21;
System.out.println("i << 2 :" + (i << 2));
System.out.println("i << 3 :" + (i << 3));
System.out.println("i << 27 :" + (i << 27));
int m = 12;
int n = 5;
System.out.println("m & n :" + (m & n));
System.out.println("m | n :" + (m | n));
System.out.println("m ^ n :" + (m ^ n));
【面试题】 你能否写出最高效的2 * 8的实现方式？
答案：2 << 3 或 8 << 1
【特别说明的】
1. 位运算符操作的都是整型的数据
2. << ：在一定范围内，每向左移1位，相当于 * 2
>> :在一定范围内，每向右移1位，相当于 / 2
典型题目：
1.交换两个变量的值。
2.实现60的二进制到十六进制的转换
6.三元运算符
三元运算符：(条件表达式)? 表达式1 : 表达式2
【典型代码】
1.获取两个整数的较大值
//获取两个整数的较大值
int m = 12;
int n = 5;
int max=(m>n)?m:n;
System.out.println(max);
2.获取三个数的最大值
//获取三个数的的最大值
int n1=12;
int n2=30;
int n3=-43;
//第一种写法
int num1=(n1>n2)?((n1>n3)?n1:n3):((n2>n3)?n2:n3);
System.out.println("最大数为："+num1);
//第二种写法
int max1 = (n1>n2)?n1:n2;
int max2 = (max1>n3)?max1:n3;
System.out.println("最大数为："+max2);
//if-else:
if(m>n){
System.out.println(m);
}else{
System.out.println(n);
}
【特别说明的】
1. 说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假，决定执行表达式1，还是表达式2.
如果表达式为true，则执行表达式1。
如果表达式为false，则执行表达式2。
③ 表达式1 和表达式2要求是一致的。
④ 三元运算符可以嵌套使用
2. 凡是可以使用三元运算符的地方，都可以改写为if-else
反之，不成立。
3. 如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁、执行效率高。
五、流程控制
• 流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
• 其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：
>顺序结构：程序从上到下执行。
>分支结构：
if-else if - else
switch-case
>循环结构：
for
while
do-while
1.分支结构
1.if-else条件判断结构
1.1.
结构一：只有一个条件时
if(条件表达式){
执行表达式；
}
结构二：二选一
if(条件表达式){
执行表达式1；
}else{
执行表达式2；
}
结构三：多选一
if(条件表达式){
执行表达式1；
}else if(条件表达式){
执行表达式2；
}else if(条件表达式){
执行表达式3；
}
...
else{
执行表达式n；
}
1.2.说明：
1. else 结构是可选的。
2. 针对于条件表达式：
> 如果多个条件表达式之间是“互斥”关系(或没有交集的关系),哪个判断和执行语句声明在上面还是下面，无所谓。
> 如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面。
> 如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了。
3. if-else结构是可以相互嵌套的。
4. 如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略的。但是，不建议大家省略。但有时会出现在选择题中，要认识。
5.if语句是用来进行判断的
6.如果对于一个boolean类型的变量进行进行判断时，不要用“==”，直接将变量写在小括号里即可
注意：if-else嵌套最好是不要超过三层，太多容易混乱，若写的超过三层，最好是回头看看精简精简；当然多层的嵌套也不为错误
2.switch-case选择结构
switch(表达式){
case 常量1:
执行语句1;
//break;
case 常量2:
执行语句2;
//break;
...
default:
执行语句n;
//break;
}
JDK12,新特性：省略了break关键字，且如果执行语句只有一条的话，那么可以省略大括号
switch(表达式){
case 常量 - > {
执行语句；
}
case 常量 - > {
执行语句；
}
default: ->{
执行语句；
}
}
2.说明：
① 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。
当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾结束为止。
② break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构
case穿透就是没有写break导致的，如果case中的语句体重复了，我们可以考虑case穿透，不过几乎不用
如果没有break，那么程序会继续执行下一个case的语句体，一直遇到break或者有👉大括号为止
③ switch结构中的表达式，只能是如下的6种数据类型之一：
byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)
④ case 之后只能声明常量。不能声明范围。
⑤ break关键字是可选的。
⑥ default:相当于if-else结构中的else.
default结构是可选的，而且位置是灵活的。
3.如果switch-case结构中的多个case的执行语句相同，则可以考虑进行合并。
4.break在switch-case中是可选的:一般在开发中都会带有break
5.if-else与Switch-case的关系
1.凡是可以使用switch-case的结构，都可以转换为if-else.反之。不成立。
2.当我们写分支结构时，当发现既可以使用switch-case，（同时，switch中表达式的取值情况不太多）,
又可以使用if-else时，我们有先用switch-case。原因：switch-case执行效率稍高。
3.switch：把有限个数据一一列举出来，让我们任选其一
if-else的多选一格式：一般用于对范围的判断
3.错误示例
注： /* ----------错误示例：-------------------
1.switch结构中的表达式，只能是如下6种数据类型之一：
byte、short、char、int、枚举类型（JDK5.0新增）、String类型（JDK7.0新增）
boolean isHandsome = true;
switch(isHandsome){//Boolean类型不能使用
case true:
System.out.pritln("来了老弟~~");
break;
case false:
System.out.println("好嗨哟~~~");
break;
default:
System.out.println("感觉人生到达了高潮！！！");
}
2.case后只能跟常量：
//switch-case是用来同一变量对不同的值进行相应的选择操作。
int age = 10;
switch(age){
case age>18://case后只能为常量
System.out.println("成年了");
break;
default:
System.out.println("未成年");
}
2.循环结构
循环结构：在满足一定条件的情况下重复的做某件事情
定义循环的步骤：
1.判断是不是循环，有没有重复的操作（循环操作）
2.
1.循环结构的四要素
①初始化条件
②循环条件----->是Boolean类型：为了退出循环
③循环体
④迭代条件（循环迭代：循环变量的改变）
说明：通常情况下，循环结束都是因为②中循环条件返回false了
2.三种循环结构
2.1 for循环结构：数组，字符串之类经常用
for(①;②;④){
③
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④-.......- ②
2.2 while循环结构：初始化条件比较复杂常用它
①：循环初始化
while（②）{
③;
④;
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④-...-②
说明：
1.写while循环前往不能丢了迭代条件。一旦丢了，就可能导致死循环。
for和while总结：
1.开发中，基本上我们都会从for、while中进行选择，实现循环结构
2.for循环和while循环是可以互相转换的！
区别：for循环和while循环的初始化条件部分的作用范围不同。for循环中控制的变量，因为归属于for循环的语法结构中，因此只能在for循环中使用，循环结束后就不能再被访问了。
while循环中，控制循环的变量，对于while来说不归属于其语法结构中，在while循环结束后，该变量还可以继续使用。
3.我们写程序，要避免出现死循环。4.相同点：运行规则相同
for和while的使用区别
for循环中：知道循环次数或者循环的范围
while循环：不知道循环的次数和范围，只知道循环结束的条件。
2.3 do-while循环结构
①
do{
③;
④;
}while(②);
执行过程：① - ③ - ④ - ② - ③ - ④ - ② -.....- ②
说明：
1.do-while循环至少会执行一次循环体！
2.开发中，使用for和while结构更多一些，较少使用do-while
3.“无限循环”结构：while(true)或for(;;)
总结：如何结束一个循环结构？
方式一：当循环条件是false时
方式二：当循环体中，执行break
3.嵌套循环
1.嵌套循环：将一个循环结构A声名在另一个循环结构B的循环体中，就构成了嵌套循环
内层循环：循环结构A
外层循环：循环结构B
2.说明：
①内层循环结构遍历一遍，只相当于外层循环体执行一次
②假设外层循环需要执行m次，内层循环需要执行n次，此时内层循环的循环体一共执行了m*n次
③外层循环控制行数，内层循环控制列数
【典型练习】
//练习一
/*
******
******
******
******
*/
for(int j =1;j<=4;j++){
for(int i=1;i<=6;i++){
System.out.print('*');
}
System.out.println();
}
System.out.println("-----------------");
//练习二
/* i(行数) j(*的个数)
* 1 1
** 2 2
*** 3 3
**** 4 4
***** 5 5
****** 6 6
*/
for(int i=1;i<=6;i++){//控制行数
for(int j=1;j<=i;j++){//控制每一行有几个星：控制列数
System.out.print("*");
}
System.out.println();
}
//练习三：九九乘法表
//练习四：输出100以内的质数
补充:衡量一个功能代码的优劣：
1.正确性：代码没错误
2.可读性：让其他人可以读懂
3.健壮性：经得住考验，考虑所有可能出现的情况
4.高效率与低存储：时间复杂度、空间复杂度（衡量算法的好坏）
如何理解流程控制的练习：
流程控制结构的使用+算法逻辑
跳转控制语句：
关键字continue、break
continue:跳出当次循环
break:跳出当前循环
例子：
public class ConutinueBreak { public static void main(String[] args) { for(int i = 1;i<=5;i++) { if(i == 4) { continue; } System.out.println("小老虎吃第"+i+"个包子"); } } //运行结果continue //小老虎吃第1个包子 //小老虎吃第2个包子 //小老虎吃第3个包子 //小老虎吃第5个包子public class ConutinueBreak { public static void main(String[] args) { for(int i = 1;i<=5;i++) { if(i == 4) { break; } System.out.println("小老虎吃第"+i+"个包子"); } } /* 小老虎吃第1个包子 小老虎吃第2个包子 小老虎吃第3个包子*/
1442
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
