从今天开始，笔者将更加规范正文相关内容的字体，不同的内容将以不同的字体表示
如
- 引用的公认的专业性定义（无序列表）
所有代码
我自己的总结性语句（加粗加下划线）
相关知识的重点、例题（标红）
1 运算符
1.1 算术运算符（理解）
- 运算符：对常量或者变量记性操作的符号
- 表达式：用运算符把常量或者变量链接起来的符合java语法的字符串 称为表达式
public static void main(String[] args) {
int a = 10;
int b = 20;
//int c = a + b ;
int c;
c = a + b;//表达式 类型 将a+b的结果赋值给c
}1.2 算术运算符
+ - * / %
算术运算的规则 符合我们小学数学
//算术运算
int aa = 15;
int bb = 2;
int dd = aa / bb;//商
int ee = aa % bb;//余数 取余运算
System.out.println(dd);
System.out.println(ee);1.3 算术运算的规则
int i1 = 20;
int i2 = 30;
int sum1 = i1 + i2; // int
byte b1 = 3;
short s1 = 5;
int sum2 = b1 +s1 ;// int
long l1 = 23L;
long sum3 = i1 + l1;// long整数运算：
如果两个操作数有一个是long 则表达式的类型一定是long；
如果在一个表达式中，所有的操作数都是整数，且不为long 则结果为int
浮点运算：
//4. 浮点运算规则
float f1 = 3.14F;
float f2 = 2.56F;
float sumf = f1 + f2;// 如果两个操作数都是float类型 则结果可以使用float保存也可以使用double（这是类型自动转换）
System.out.println(sumf);
double d1 = 4.5;
double sumd = f1 + d1 ;//浮点数在进行运算的时候 如果有一个操作数为double 则结果肯定为double取模（求余）运算
//5. 取模求余运算
int ss1 = 7 % 3;// 1
int ss2 = -7 % 3; //-1
int ss3 = 7 % -3 ; // 1求余可以使用浮点数，一般使用的都是整数。
取模运算的结果为两个数的余数，余数的符号和左边操作数的符号相同（被余数）
1.4 字符的“+”操作
char类型参与算术运算。使用的是字符的ascii码 。
'a'------------------97 a ---z 是连续的
'A'-----------------65 A ---Z 是连续的
'0'-----------------48 0---9 是连续的
算术表达式中包含多个基本类型的操作数的时候，整个算术表达式的类型会自动提升：
提升规则：
- byte类型 short char类型都将被提升为int类型
- 整个表达式的类型自动提升到表达式中最高等级的操作数的同样的类型。
等级顺序： byte，short char-->int --- > long --->float---->double
1.5 字符串
//7.字符串的操作
String str1 = "hello";
int aa = 22;
String str2 = str1 + aa;// hello22当字符串和数值型的数据进行运算时（+） 此时进行的是字符串拼接 而不是算术运算 ，因此在字符串运算中，“+”称为字符串连接符 当字符串链接的时候 是从左至右 依次拼接
String str3 = 1 + 999 + "年中国";// 1000年中国
System.out.println(2000+ 20 +"中国"+6+666);//2020中国6666
2.赋值运算符
赋值运算符 =
扩展的赋值运算符： += -= *= /= %= 先进行算术运算 后赋值
// 1 赋值运算符
int a1 = 10;
a1 += 10; // a1 = a1 + 10
System.out.println(a1);
short s1 = 20;
s1 = (short)(s1 + 10);
s1 += 10;// 类似于 s1 = s1 + 10 之所以说扩展赋值运算符 s+=1是类似s=s+1
因为当s定义为short或byte类型时，如果直接s=s+1，就会报错，需要强制类型转换的！
但是用扩展赋值运算符就不会报错，诶，算完之后还是原来的类型
3.自增自减运算符
++自增 --自减
//2 自增自减
int a2 = 11;
a2--;//先取值 后运算
System.out.println(a2);// 10
--a2;// 先运算 后取值
System.out.println(a2);//9 ++和-- 既可以在变量的左边也可以在变量的右边
//2 自增自减
int a2 = 11;
int a3;
a3= a2--;// 先取值（a3 = a2） 后运算（a2=a2-1）
System.out.println(a3);//a3 =11 a2 =10
a3= --a2;// 先运算（a2= a2-1）a2=9 后取值 a3= a2
System.out.println(a3);//9
练习：
//3 自增自减的练习
int x = 10;
int y = x++ + x++ + x++;
System.out.println(y);// 10 +11 + 12 = 33
System.out.println(x);// 13
4 关系运算符
== ！ = > < >= <=
注意： 关系运算符的结果都是boolean类型 结果要么是true 要么是false
//4 关系运算
int m = 10;
int n = 20;
System.out.println(m==n);
System.out.println(m!=n);
System.out.println(m>n);
System.out.println(m<n);
System.out.println(m>=n);
System.out.println(m<=n);
//如果在开发中， 比较的结果在后续程序中需要使用，此时我们则需要使用一个变量将比较的结果保存起来
boolean flag = m > n;
System.out.println(flag);5 逻辑运算符
在数学中 如果表示一个数是大于3 小于6 3<x <6
但是在java中 不能这样写。我们需要拆分成两部分：
- 拆解为： x> 3 和x <6
- 合并为： x>3 && x<6
逻辑运算符：
- &(与) a & b a和b都是true的时候 结果才为true 否则都为false（只要有一个为false结果就false）
- | （或） a | b a 和b都是false 结果false 否则都为true（只要有一个为true结果就true）
- ！（非） ！a 取反 true变false false变true
- ^（异或） a ^ b a 和b结果不同为true 相同为false
//5 逻辑运算
int i = 10;
int j = 20;
int k = 30;
System.out.println((i > j) & (i >k));//false
System.out.println((i < j)&(i > k));//false
System.out.println((i>j) | (i < k)); // true5.1 短路逻辑运算符
&& 短路与 作用和& 相同 但是有短路效果
|| 短路或 作用和|相同 但是有短路效果
&逻辑与 无论左边真或假 右边都会执行
&& 短路与 若果左边为真 右边肯定会执行 。如果左边为false 右边就不执行
| 无论左边为真或假 右边都是要执行
|| 如果左边为true 右边不执行 如果左边为false 此时右边才需要执
//6 短路逻辑
int p = 3;
int c = 4;
// System.out.println(p++ >4 & c++ >5);
// System.out.println(p+"----"+c);// 4 ---5
System.out.println(p++ >4 && c++ >5);//左边为false 右边则不参与运算
System.out.println(p+"----"+c);//4---4总之：以后都用&&和||，别用&和|
6 位运算
位运算指的是进行二进制位的运算
- ~ 取反
- & 按位与
- | 按位或
- ^ 按位异或
- << 左移 将整个2进制数据左移一位 相当与将原来的数乘2
- n >>右移 将整个的2进制右移一位 相当与将原来的数除2
&和| 如果两边的操作数类型是boolean类型 则是逻辑运算 如果两边的操作数是整数 则为位运算
//7 位运算
int a4 = 5;
int a5 = 3;
int a6=2;
System.out.println(~a4);
System.out.println(a4 & a5);
// 使用最高效的方法 计算2的三次方
System.out.println(a6 * a6 * a6);
System.out.println(a6 << 2); //8 面试题
int a7 = 5;
int a8 = 6;
// 需求 在不增加变量的情况下 交换两个整数
// int a9 = a7;
// a7 = a8;
// a8 = a9;
// System.out.println(a7 +"-------"+ a8);
//经过三次异或 就可以交换两个数的位置
a7 = a7 ^ a8;
a8 = a7 ^ a8;
a7 = a7 ^ a8;
System.out.println(a7 +"-------"+ a8);
有两种方法交换两个变量：
一、再定义一个变量
二、做三次“异或”
7 三元运算符
格式： 关系表达式 ? 表达式1： 表达式2
a > b? a : b
计算规则：
- 1 计算关系表达式的值
- 2 如果关系表达式的值为true 则结果为表达式1的值
- 3 如果关系表达式的值为fasle 则结果为表达式2的值
// 9 三元运算符
int a9 = 10;
int a10 = 20;
System.out.println(a9 > a10 ? a10 : a9);
需求：一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，请用程序实现获取这三个和尚的最高身高
/*需求：一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，
请用程序实现获取这三个和尚的最高身高*/
public class Homework {
public static void main(String[] args){
int a,b,c;
a=150;b=210;c=165;
System.out.print((a>b?(a>c?a:c):(b>c?b:c)));//210
}
}8 流程控制语句
分类：
- 顺序结构
- 分支结构（选择结构）（if switch）
- 循环结构（for while do...while）
8.1 顺序结构
程序的执行是从main方法开始 自上而下 依次执行。
public static void main(String[] args) {
int n1 = 12;
int n2 = n1 +23;
//错误
int n2 = n1 +23;//解析不到n1
int n1 = 12;
}8.2 分支结构/选择结构
8.2.1 if
单分支：
if(关系表达式){// 关系表达式为true 则执行if下的语句
语句;
}
public static void main(String[] args) {
// 1 if 单分支
int a = 10;
int b = 20;
// 需求 判断a和b是否相同
if (a == b){
System.out.println("a等于b");
}
if(a != b){
System.out.println("a不等于b");
}
}双分支： if --- else
if(关系表达式){
语句体1;
}else{
语句体2;
}
/*2 双分支 if else
* 需求 给出任意的整数，使用程序来判断该整数是奇数还是偶数 并在控制台输出判断结果
*/
//获取键盘输入数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入您要判断的整数：");
int in = sc.nextInt();// 保存用户输入的整数到变量in中
// 判断整数是奇数还是偶数
if(in % 2 == 0 ){
System.out.println("您输入的整数为偶数");
}else{
System.out.println("您输入的整数为奇数");
}多分支
if(条件表达式1){
语句1；
}else if(条件表达式2){
语句2；
}...else{
语句n;
}
/*3 多分支
需求：在该高考时，父母许诺，
如果考上211 奖励一个mac笔记本
如果考上一本 奖励 iphone
如果考上二本 奖励小米手机
如果没考上 奖励回去复读
*/
System.out.println("等待成绩公布,请录入您的高考成绩：");
int score = sc.nextInt();
if(score >=0 && score <= 750){
if(score >= 600){
System.out.println("奖励mac笔记本");
}else if (score >= 550 && score < 600){
System.out.println("奖励 iphone");
}else if(score >= 500 && score < 550){
System.out.println("奖励小米手机");
}else{
System.out.println("奖励回去复读");
}
}else{
System.out.println("您输入的成绩有误，请查证后重新输入");
}8.2.2 switch
switch(表达式){
case 值1：
语句1;
break;
case 值2：
语句2；
break；
case 值3：
语句3；
break；
default：
语句n+1;
break;
}
- switch的表达式的类型： char, byte, short, int, enum（枚举） ， String（jdk7+）
- break的作用：结束当前执行 如果没有break 将发生case穿透
- default的位置：default可以出现在任意位置
- 对于case如果对应相同的代码 则可以省略前边的case下的语句
switch (month){
case 1:
case 2:
case 12:
System.out.println("当前月份属于冬季");
break;
case 3:
case 4:
case 5:
System.out.println("当前月份属于春季");
break;
case 6:
case 7:
case 8:
System.out.println("当前月份属于夏季");
break;
case 9:
case 10:
case 11:
System.out.println("当前月份属于秋季");
break;
default:
System.out.println("您输入的数据有误，请重新输入!!!");
break;
}switch的表达式类型可以使string
String str = "audi";
switch (str){
case "audi":
System.out.println("这是奥迪");
break;
case "bmw":
System.out.println("这是宝马");
break;
}if 和switch区别：
- 1 if 判断的是一个范围 switch判断的是一些具体的值
- 2 switch判断的数据的值 一定是可列举的 有穷的
- 3 能用Switch去实现的 一定也能够使用if 但是能使用if 的 不一定能使用switch
8.3 循环结构
for
while
do。。。while
特点：所执行的代码是重复；需要有明确的开始和停止标志
8.3.1for循环
for(初始化语句;条件判断语句;条件控制语句){
循环语句;
}
循环结构的语法：
- 1 初始化语句 可以使一条或者多条语句 这些语句主要完成一些初始化工作；
- 2 条件判断语句 该语句的执行结果一定是一个boolean值。 这个语句决定了循环体是否执行
- 3 循环体语句 这里可以使一条或者多条语句 也可以是其他结构
- 4 条件控制语句：通常是一条语句，用来改变判断条件的值 从而达到控制语句是否继续向下执行的效果。此处使用自增自减操作居多。
水仙花数= 个位 +十位 +百位的立方和等于原数 输出1-1000范围内的所有的水仙花数 水仙花数一定是一个三位数 100--999
// 水仙花数 = 个位 +十位 +百位的立方和等于原数
// 输出1-1000范围内的所有的水仙花数 水仙花数一定是一个三位数 100--999
//统计水仙花数
public class Homework {
public static void main(String[] args){
int g,s,b;
int count=0;
for(int i = 100;i<1000;i++){
g=i%10;
s=(i/10)%10;
b=i/100;
if(g*g*g+s*s*s+b*b*b==i){
count++;
System.out.println(i);}
}
System.out.println("共有"+count+"个水仙花数");
}
}8.3.2 while循环
先判断 后执行
while(条件判断语句){
循环体语句；
条件控制语句；
}
// 需求 珠穆朗玛峰高度 8844.43 米 = 8844430毫米 加入我们有一张足够大的纸，值得厚度是0.1毫米
// 计算将纸对着多少次 可以折成珠穆朗玛峰的高度
// 统计折叠的次数
public static void main(String[] args) {
// 需求 珠穆朗玛峰高度 8844.43 米 = 8844430毫米 加入我们有一张足够大的纸，值得厚度是0.1毫米
// 计算将纸对着多少次 可以折成珠穆朗玛峰的高度
// 统计折叠的次数
int count = 0;
// 定义纸的厚度
double paper = 0.1;
// 珠穆朗玛峰的高度
int zf = 8844430;
while(paper <= zf){
// 完成纸的折叠
paper *= 2;
// 此时的折叠次数加一
count++;
}
System.out.println("总共折叠的次数为：" +count);
}8.3.3 do ... while
先执行 后判断 无论条件是否成立 至少会执行依次
do{
循环语句；
条件控制语句
}while(条件判断语句)
do...while的使用场景：
比如用户登录：
三种循环的区别：
1 for循环和while循环先判断条件是否成立 然后决定是否执行循环体 （先判断后执行）
2 do --- while 循环先执行一次循环体 然后判断条件是否成立 是否执行循环体。（先执行后判断）
3 for循环的变量的作用范围仅限于for循环内 而while循环的变量的作用范围大于循环的范围
在java中 变量的作用范围 是距离他最近的一对大括号（脱离定义的那个大括号，就不能存活了）
死循环：
循环一直执行，无法自动结束，只能人为干预停止虚拟机
for(;;){// 两个分号在任何时候都不能少
System.out.println("aaaa");
}
while(true){
}
do{
}while(true);
8.4 跳转控制语句
在任何循环语句的主体部分，可以采用break来控制循环的流程。break用于强制退出循环，不执行循环中的剩余部分。
public static void main(String[] args) {
// 在控制台输出100次helloworld。
int count = 0 ;
while(true){
System.out.println("hello world");
count++;
if(count == 100){
break;//终止循环的执行。
}
}
}
continue
// 把100--150 之间不能被3 整除的数输出 并且每行输出5个
int count = 0 ; //定义一个计数器
for(int i = 100 ; i <150; i++){
if(i % 3 == 0 ){// 则说明该数不满足我们的需求
continue;//结束本次循环 继续下次循环
}
// 否则 就是不能被3整除的数
System.out.print(i+"、");//这个输出语句不换行 println后边会自带换行符
count++;
if(count % 5== 0 ){//只要是5的倍数 就换行
System.out.println();//输出一个换行符
}
}
带标签的break和continue
outter: for(int i = 101; i < 150 ;i ++){
for(int j = 2; j < i/2 ; j++){
if(i % j == 0 ){
continue outter;
}
}
System.out.println(i);
}
嵌套循环
//模拟时钟的时针和分针 时针 1--24 分针1-60 当分钟走一圈 时针走一次
for(int hour = 0 ; hour < 24; hour++){// 模拟时针循环
for(int minute = 0 ; minute < 60;minute++){
System.out.println("当前时间为：" + hour +":" + minute);
}
System.out.println("-----------------------------------------");
}在控制台输出九九乘法表
//九九乘法表
public class Homework {
public static void main(String[] args){
for(int i = 1;i <= 9;i++){
for(int j = 1;j <= i;j++){
System.out.print(i+"*"+j+'\t');
}
System.out.println();
}
}
}
扫一扫
147
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
