JavaSE笔记 30天学Java打卡 Day03

最新推荐文章于 2024-07-13 13:55:40 发布

港岛妹夫_

最新推荐文章于 2024-07-13 13:55:40 发布

阅读量182

点赞数 1

分类专栏： JavaSE 30天打卡文章标签： java 开发语言算法

本文链接：https://blog.csdn.net/weixin_46546415/article/details/126574050

版权

JavaSE 30天打卡专栏收录该内容

8 篇文章 0 订阅

订阅专栏

JavaSE笔记 30天学Java打卡 Day03

本笔记配套【零基础快速学Java】韩顺平零基础30天学会Java 视频一起食用

链接🔗：【零基础快速学Java】韩顺平零基础30天学会Java

运算符

介绍

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

有以下几种运算符

算术运算符
赋值运算符
关系运算符[比较运算符]
逻辑运算符
位运算符[需要二进制基础]
三元运算符

算数运算符

介绍

算术运算符是对数值类型的变量进行运算的，在 Java 程序中使用的非常多。

算数运算符一览

运算符	运算	例子	结果
+	正号	+7	7
-	负号	b=11; -b	-11
+	加	9 + 9	18
-	减	10 - 8	2
*	乘	7*8	56
/	除	9/9	1
%	取模（取余）	11%9	2
++	自增在前：先运算后取值自增在后：先取值后运算	a=2;b=++a a=2;b=a++	a=3;b=3 a=3;b=2
–	自增在前：先运算后取值自增在后：先取值后运算	a=2;b=–a a=2;b=a–	a=1;b=1 a=1;b=2
+	字符串相加	“I”+“LOVE”	“ILOVE”

案例演示

/**
* 演示算术运算符的使用
*/
public class ArithmeticOperator {
//编写一个 main 方法
	public static void main(String[] args) {
// /使用
		System.out.println(10 / 4); //从数学来看是 2.5, java 中 2
		System.out.println(10.0 / 4); //java 是 2.5
// 注释快捷键 ctrl + /, 再次输入 ctrl + / 取消注释
		double d = 10 / 4;//java 中 10 / 4 = 2, 2=>2.0
		System.out.println(d);// 是 2.0
// % 取模 ,取余
// 在 % 的本质 看一个公式!!!! a % b = a - a / b * b
// -10 % 3 => -10 - (-10) / 3 * 3 = -10 + 9 = -1
// 10 % -3 = 10 - 10 / (-3) * (-3) = 10 - 9 = 1
// -10 % -3 = (-10) - (-10) / (-3) * (-3) = -10 + 9 = -1
   		System.out.println(10 % 3); //1
		System.out.println(-10 % 3); // -1
		System.out.println(10 % -3); //1
		System.out.println(-10 % -3);//-1
//++的使用
//
		int i = 10;
		i++;//自增 等价于 i = i + 1; => i = 11
		++i;//自增 等价于 i = i + 1; => i = 12
		System.out.println("i=" + i);//12
/*
作为表达式使用
前++：++i 先自增后赋值
后++：i++先赋值后自增
*/
		int j = 8;
//int k = ++j; //等价 j=j+1;k=j;
		int k = j++; // 等价 k =j;j=j+1;
		System.out.println("k=" + k + "j=" + j);//8 9
	}
}

细节说明

对于除号"/"，它的整数除和小数除是有区别的：整数之间做除法时。只保留整数部分而舍弃小数部分。例如：int x = 10/3 ，结果是3
当对一个数取模时，可以等价 a%b = a-a/b*b ,这样我们可以看到取模的一个本质运算。
当自增当作一个独立语言使用时，不管是 ++i; 还是 i++; 都是一样的

自增自减练习

//练习1
public class ArithmeticOperatorExercise01 {
		//编写一个 main 方法
		public static void main(String[] args){
		// int i = 1;//i->1
		// i = i++; //规则使用临时变量: (1) temp=i;(2) i=i+1;(3)i=temp;
		// System.out.println(i); // 1
		// int i=1;
		// i=++i; //规则使用临时变量: (1) i=i+1;(2) temp=i;(3)i=temp;
		// System.out.println(i); //2
		//
		// 测试输出
		int i1 = 10;
		int i2 = 20;
		int i = i1++;
		System.out.print("i="+i);//10
		System.out.println("i2="+i2);//20
		i = --i2;
		System.out.print("i="+i);//19
		System.out.println("i2="+i2);//19
	}
		}

假如还有 59 天放假，问：合 xx个星期零xx天
定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为：5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度。

//课堂练习
public class ArithmeticOperatorExercise02 {
//编写一个 main 方法
public static void main(String[] args) {
    //1.需求:
    //假如还有 59 天放假，问：合 xx 个星期零 xx 天
    //2.思路分析
    //(1) 使用 int 变量 days 保存 天数
    //(2) 一个星期是 7 天 星期数 weeks： days / 7 零 xx 天 leftDays days % 7
    //(3) 输出
    //3.走代码
    int days = 25911;
    int weeks = days / 7;
    int leftDays = days % 7;
    System.out.println(days + "天 合" + weeks + "星期零" + leftDays + "天");
    //1.需求
    //定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为
    //：5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度
    //
    //2 思路分析
    //(1) 先定义一个 double huaShi 变量保存 华氏温度
    //(2) 根据给出的公式，进行计算即可 5/9*(华氏温度-100)
    // 考虑数学公式和 java 语言的特性
    //(3) 将得到的结果保存到 double sheShi
    //3 走代码
    double huaShi = 1234.6;
    double sheShi = 5.0 / 9 * (huaShi - 100);
    System.out.println("华氏温度" + huaShi
                       + " 对应的摄氏温度=" + sheShi);
	}
}

关系运算符（比较运算符）

介绍

关系运算符的结果都是 boolean 型，也就是要么是 true，要么是 false
关系表达式经常用在 if 结构的条件中或循环结构的条件中

关系运算符一览

运算符	运算	范例	结果
==	相等于	8 == 7	false
!=	不等于	8 != 7	true
<	小于	8 < 7	false
>	大于	8 > 7	true
<=	小于等于	8 <= 7	false
>=	大于等于	8 >= 7	true
instanceof	检查是否是类的对象	“love” instanceof String	true

案例演示

//演示关系运算符的使用
//
public class RelationalOperator {
//编写一个 main 方法
public static void main(String[] args) {
        int a = 9; //老韩提示: 开发中，不可以使用 a, b
        int b = 8;
        System.out.println(a > b); //T
        System.out.println(a >= b); //T
        System.out.println(a <= b); //F
        System.out.println(a < b);//F
        System.out.println(a == b); //F
        System.out.println(a != b); //T
        boolean flag = a > b; //T
        System.out.println("flag=" + flag);
	}
}

细节说明

关系运算符的结果都是 boolean 型，也就是要么是 true，要么是 false。
关系运算符组成的表达式，我们称为关系表达式。 a > b
比较运算符"==“不能误写成”="

逻辑运算符

介绍

用于连接多个条件（多个关系表达式），最终的结果也是一个 boolean 值。

逻辑运算符一览

短路与 && ，短路或 ||，取反 !
逻辑与 &，逻辑或 |，^ 逻辑异或

a	b	c	a&b	a&&b	a\|b	a\|\|b	!a	a^b
true	true	true	true	true	true	true	false	false
true	false	false	false	false	true	true	false	true
false	true	false	false	false	true	true	true	true
false	false	false	false	false	false	false	true	false

逻辑运算规则

a&b : & 叫逻辑与：规则：当 a 和 b 同时为 true ,则结果为 true, 否则为 false
a&&b : && 叫短路与：规则：当 a 和 b 同时为 true ,则结果为 true,否则为 false
a|b : | 叫逻辑或，规则：当 a 和 b ，有一个为 true ,则结果为 true,否则为 false
a||b : || 叫短路或，规则：当 a 和 b ，有一个为 true ,则结果为 true,否则为 false
!a : 叫取反，或者非运算。当 a 为 true, 则结果为 false, 当 a 为 false 是，结果为 true
a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false

&& 和 & 基本规则

名称	语法	特点
短路与&&	条件1 && 条件2	两个条件都为true，结果为true，否则false
逻辑与&	条件1 & 条件2	两个条件都为true，结果为true，否则false

案例演示

/**
* 演示逻辑运算符的使用
*/
public class LogicOperator01 {
//编写一个 main 方法
    public static void main(String[] args) {
    //&&短路与 和 & 案例演示
    int age = 50;
    if(age > 20 && age < 90){
    System.out.println("ok100");
    }
    //&逻辑与使用
    if(age > 20 & age < 90) {
    System.out.println("ok200");
    }
    //区别
    int a = 4;
    int b = 9;
    //对于&&短路与而言，如果第一个条件为 false ,后面的条件不再判断
    //对于&逻辑与而言，如果第一个条件为 false ,后面的条件仍然会判断
    if(a < 1 & ++b < 50) {
    System.out.println("ok300");
    }
    System.out.println("a=" + a + " b=" + b);// 4 10
    }
}

&& 和 &使用区别

&&短路与：如果第一个条件为 false，则第二个条件不会判断，最终结果为 false，效率高
& 逻辑与：不管第一个条件是否为 false，第二个条件都要判断，效率低
开发中，我们使用的基本是使用短路与&&,效率高

|| 和 | 基本规则

名称	语法	特点
短路或\|\|	条件1 \|\| 条件2	两个条件中只要有一个成立，结果为true，否则为false
逻辑或\|	条件1 \| 条件2	两个条件中只要有一个成立，结果为true，否则为false

案例演示

//演示| || 使用
public class LogicOperator02 {
//编写一个 main 方法
public static void main(String[] args) {
    //||短路或 和 |逻辑或 案例演示
    //|| 规则: 两个条件中只要有一个成立，结果为 true,否则为 false
    //| 规则: 两个条件中只要有一个成立，结果为 true,否则为 false
    int age = 50;
    if(age > 20 || age < 30) {
    System.out.println("ok100");
    }
    //&逻辑与使用
    if(age > 20 | age < 30 ){
    System.out.println("ok200");
    }
    //看看区别
    //(1)||短路或：如果第一个条件为 true，
    //则第二个条件不会判断，最终结果为 true，效率高
    //(2)| 逻辑或：不管第一个条件是否为 true，第二个条件都要判断，效率低
    int a = 4;
    int b = 9;
    if( a > 1 || ++b > 4) { // 可以换成 | 测试
    System.out.println("ok300");
    }
    System.out.println("a=" + a + " b=" + b); //4 10
    }
}

|| 和 | 使用区别

||短路或：如果第一个条件为 true，则第二个条件不会判断，最终结果为 true，效率高
| 逻辑或：不管第一个条件是否为 true，第二个条件都要判断，效率低
开发中，我们基本使用 ||

! 取反基本规则

名称	语法	特点
!非（取反）	!条件	如果条件本身成立，结果为false，否则为true

案例演示

//!和^案例演示
public class InverseOperator {
//编写一个 main 方法
public static void main(String[] args) {
    //! 操作是取反 T->F , F -> T
    System.out.println(60 > 20); //T
    System.out.println(!(60 > 20)); //F
    //a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false
    boolean b = (10 > 1) ^ ( 3 > 5);
    System.out.println("b=" + b);//T
    }
}

^基本规则

a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false ^逻辑异或。

System.out.println((4 < 1)^(6 > 3));//true

练习题

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-umQuMurA-1661690209753)(C:\Users\Liu\AppData\Roaming\Typora\typora-user-images\image-20220828195433659.png)]$

赋值运算符

介绍

赋值运算符就是将某个运算后的值，赋给指定的变量。

赋值运算符的分类

基本赋值运算符

int a = 10;

复合赋值运算符

+= ，-= ，*= ， /= ，%= 等 , 重点讲解一个 += ，其它的使用是一个道理

a += b; [等价 a = a + b; ]

a -= b; [等价 a = a - b; ]

赋值运算符特点

运算顺序从右往左 int num = a + b + c;
赋值运算符的左边只能是变量,右边可以是变量、表达式、常量值 int num = 20; int num2= 78 * 34 - 10; int num3 = a;
复合赋值运算符等价于下面的效果比如：a+=3;等价于 a=a+3; 其他类推
复合赋值运算符会进行类型转换。 byte b = 2; b+=3; b++;

//演示赋值运算符的使用
public class AssignOperator {
public static void main(String[] args) {
    int n1 = 10;
    n1 += 4;// n1 = n1 + 4;
    System.out.println(n1); // 14
    n1 /= 3;// n1 = n1 / 3;//4
    System.out.println(n1); // 4
    //复合赋值运算符会进行类型转换
    byte b = 3;
    b += 2; // 等价 b = (byte)(b + 2);
    b++; // b = (byte)(b+1);
    }
}

三元运算符

基本语法

条件表达式 ? 表达式 1: 表达式 2;

运算规则：

如果条件表达式为 true，运算后的结果是表达式 1；
如果条件表达式为 false，运算后的结果是表达式 2；

口诀: [一灯大师：一真大师]

//三元运算符使用
public class TernaryOperator {
    //编写一个 main 方法
    public static void main(String[] args) {
    int a = 10;
    int b = 99;
    // 解读
    // 1. a > b 为 false
    // 2. 返回 b--, 先返回 b 的值,然后在 b-1
    // 3. 返回的结果是 99
    int result = a > b ? a++ : b--;
    System.out.println("result=" + result);
    System.out.println("a=" + a);
    System.out.println("b=" + b);
    }
}

使用细节

表达式 1 和表达式 2 要为可以赋给接收变量的类型(或可以自动转换)
三元运算符可以转成 if–else 语句

//三元运算符细节
public class TernaryOperatorDetail {
//编写一个 main 方法
public static void main(String[] args) {
    //表达式 1 和表达式 2 要为可以赋给接收变量的类型
    //(或可以自动转换/或者强制转换)
    int a = 3;
    int b = 8;
    int c = a > b ? (int)1.1 : (int)3.4;//可以的
    double d = a > b ? a : b + 3;//可以的，满足 int -> double
    }
}

public class TernaryOperatorExercise {
//编写一个 main 方法
public static void main(String[] args){
    //案例：实现三个数的最大值
    int n1 = 553;
    int n2 = 33;
    int n3 = 123;
    //思路
    //1. 先得到 n1 和 n2 中最大数 , 保存到 max1
    //2. 然后再 求出 max1 和 n3 中的最大数，保存到 max2
    int max1 = n1 > n2 ? n1 : n2;
    int max2 = max1 > n3 ? max1 : n3;
    System.out.println("最大数=" + max2);
    //使用一条语句实现, 推荐使用上面方法
    //老师提示: 后面我们可以使用更好方法,比如排序
    // int max = (n1 > n2 ? n1 : n2) > n3 ?
    // (n1 > n2 ? n1 : n2) : n3;
    // System.out.println("最大数=" + max);
    //
    int abcclass = 10;
    int n = 40;
    int N = 50;
    System.out.println("n=" + n);//40
    System.out.println("N=" + N);//50
    //? abc 和 aBc
    int abc = 100;
    int aBc = 200;
    //int a b = 300;
    //int a-b=10;
    int goto1 = 10;
    }
}

运算符优先级

运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如右表，上一行运算符总优先于下一行。
只有单目运算符、赋值运算符是从右向左运算的。
一览表, 不要背，使用多了，就熟悉了。

在这里插入图片描述

标识符

标识符概念

java对各种变量、方法和类等命名时使用的字符序列称为标识符
凡是自己可以起名字的地方都叫标识符

标识符命名规范

包名：多单词组成时所有字母都小写：aaa.bbb.ccc //比如 com.hsp.crm
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz [大驼峰] 比如： TankShotGame
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz [小驼峰，简称驼峰法] 比如： tankShotGame
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ 比如：定义一个所得税率 TAX_RATE
后面我们学习到类，包，接口，等时，我们的命名规范要这样遵守,更加详细的看文档.

判断下列变量名是否正确

hsp //ok
hsp12 //ok
1hsp //错误, 数字不能开头
h-s // 错误 , 不能有 - x h // 错误， 有空格
h$4 // ok
class //错误，class 关键字
int // 错误 ,int 是关键字
double //错误 ,double 是关键字
public //错误 ,public 是关键字
static //错误 ,static 是关键字
goto //错误, goto 是保留字
stu_name //ok

关键字和保留字

关键字

定义：被 Java 语言赋予了特殊含义，用做专门用途的字符串（单词）特点：关键字中所有字母都为小写。

保留字

现有 Java 版本尚未使用，但以后版本可能会作为关键字使用。

用于定义数字类型的关键字：

int byte short long double
char float boolean class void
enum interface

用于定义流程控制类型的关键字：

if else switch case default
do while for break continue
return

用于定义访问修饰符的关键字：

public private protected

用于定义类，函数，变量修饰符的关键字：

abstract final static

用于定义类与类之间的关键字：

extends implement

用于定义建立实例及引用实例，判断实例的关键字：

new this super instanceof

用于处理异常的关键字：

try catch finally throw throws

用于包的关键字：

package import

其他修饰符关键字：

native strictfp transient volatile assert

保留字：

byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、const

这里要特别注意一下，true、false、null

严格意义上讲这三个并不是关键字，但是这三个可以当关键字使用，我们命名的时候也要避开这三个

键盘输入语句

介绍

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。

步骤

导入该类的所在包, java.util.*
创建该类对象（声明变量）
调用里面的功能

案例演示

import java.util.Scanner;//表示把 java.util 下的 Scanner 类导入
public class Input {
//编写一个 main 方法
public static void main(String[] args) {
    //演示接受用户的输入
    //步骤
    //Scanner 类 表示 简单文本扫描器，在 java.util 包
    //1. 引入/导入 Scanner 类所在的包
    //2. 创建 Scanner 对象 , new 创建一个对象,体会
    // myScanner 就是 Scanner 类的对象
    Scanner myScanner = new Scanner(System.in);
    //3. 接收用户输入了， 使用 相关的方法
    System.out.println("请输入名字");
    //当程序执行到 next 方法时，会等待用户输入~~~ String name = myScanner.next(); //接收用户输入字符串
    System.out.println("请输入年龄");
    int age = myScanner.nextInt(); //接收用户输入 int
    System.out.println("请输入薪水");
    double sal = myScanner.nextDouble(); //接收用户输入 double
    System.out.println("人的信息如下:");
    System.out.println("名字=" + name
    + " 年龄=" + age + " 薪水=" + sal);
    }
}

进制（程序员的基本功）

介绍

对于整数，有四种表示方式：

二进制：0,1 ，满 2 进 1.以 0b 或 0B 开头。

十进制：0-9 ，满 10 进 1。

八进制：0-7 ，满 8 进 1. 以数字 0 开头表示。

十六进制：0-9 及 A(10)-F(15)，满 16 进 1. 以 0x 或 0X 开头表示。此处的 A-F 不区分大小写。

//演示四种进制
//
public class BinaryTest {
//编写一个 main 方法
public static void main(String[] args) {
    //n1 二进制
    int n1 = 0b1010;
    //n2 10 进制
    int n2 = 1010;
    //n3 8 进制
    int n3 = 01010;
    //n4 16 进制
    int n4 = 0X10101;
    System.out.println("n1=" + n1);
    System.out.println("n2=" + n2);
    System.out.println("n3=" + n3);
    System.out.println("n4=" + n4);
    System.out.println(0x23A);
    }
}

原码、反码、补码

二进制的最高位时符号位：0表示正数，1表示负数
正数的原码，反码，补码都一样
负数的反码 = 它的原码符号位不变，其它位取反
负数的补码 = 它的反码+1，负数的反码 = 负数的补码 - 1
0的反码，补码都是0
java没有无符号数，换言之，java中的数都是有符号的
在计算机运算的时候，都是以补码的方式来运算的
当我们看运算结果的时候，要看它的原码

位运算符

java 中有 7 个位运算(&、|、 ^ 、~、>>、<<和 >>>)

按位与&	按位或\|	按位异或^	按位取反~
两位全为1，结果为1，否则为0	两位有一个为1，结果为1，否则为0	两位一个为0，一个为1，结果为1，否则为0	0变成1，1变成0

3 个位运算符 >>、<< 和 >>>

规则

算术右移 >>：低位溢出,符号位不变,并用符号位补溢出的高位
算术左移 <<: 符号位不变,低位补 0 3)
> > > 逻辑右移也叫无符号右移,运算规则是: 低位溢出，高位补 0
特别说明：没有 <<< 符号

本章作业

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vH01zn3w-1661690209754)(C:\Users\Liu\AppData\Roaming\Typora\typora-user-images\image-20220828203521688.png)]

0的反码，补码都是0
java没有无符号数，换言之，java中的数都是有符号的
在计算机运算的时候，都是以补码的方式来运算的
当我们看运算结果的时候，要看它的原码

位运算符

java 中有 7 个位运算(&、|、 ^ 、~、>>、<<和 >>>)

按位与&	按位或\|	按位异或^	按位取反~
两位全为1，结果为1，否则为0	两位有一个为1，结果为1，否则为0	两位一个为0，一个为1，结果为1，否则为0	0变成1，1变成0

3 个位运算符 >>、<< 和 >>>

规则

算术右移 >>：低位溢出,符号位不变,并用符号位补溢出的高位
算术左移 <<: 符号位不变,低位补 0 3)
> > > 逻辑右移也叫无符号右移,运算规则是: 低位溢出，高位补 0
特别说明：没有 <<< 符号

本章作业

在这里插入图片描述

港岛妹夫_

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JavaSE笔记 30天学Java打卡 Day03

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。有以下几种运算符算术运算符赋值运算符关系运算符[比较运算符]逻辑运算符位运算符[需要二进制基础]三元运算符算术运算符是对数值类型的变量进行运算的，在 Java 程序中使用的非常多。关系运算符的结果都是 boolean 型，也就是要么是 true，要么是 false关系表达式经常用在 if 结构的条件中或循环结构的条件中用于连接多个条件（多个关系表达式），最终的结果也是一个 boolean 值。...
复制链接

扫一扫