Java基础Day03

最新推荐文章于 2022-07-14 18:08:16 发布

Chen Yongguang

最新推荐文章于 2022-07-14 18:08:16 发布

阅读量207

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/qq_41383223/article/details/101168757

版权

java 专栏收录该内容

29 篇文章 0 订阅

订阅专栏

day03

运算符
运算符: 进行运算,逻辑业务处理的符号
1.1 算数运算符
1.1.1 基本算数运算符:

- - / %
:

单独作用在数据之前,表示这个数据时一个正数,举例: +3
进行数值之间的加法举例: 3 + 2 = 5
字符串的加法,字符串与任意的数据类型相加,表示拼接,相当于在字符串的末尾进行追加,
结果任然是一个字符串类型

单独作用在数据之前,表示负数举例 : -3
进行数值之间的减法举例 : 3-2 = 1

进行数值之间的相乘

/ :

进行两数的相除
a : 如果两个数值都是整数,相除的结果也是整数,如果没有除尽,那么小数全部舍掉
b: 如果两个数中,有一个是浮点类型,那么相除的结果就是浮点类型

% : 叫做取模运算,获取两数相除得到的余数
取模运算符的使用场景: 其实多数情况下做数据筛选

取模的结果是有正负的,根据%符号,前面的数据符号决定结果符号
举例: -7 % 2 = -1
7 % -2 = 1

要求 : 给你任意一个整数,判断,这个数是奇数还是偶数
分析: 偶数可以被2整除,奇数不能被2整数
如果数值与2进行取模,结果为0,那么这个数就是一个偶数
x % 2 == 0------> x就是个偶数
x % 2 == 1------> x就是一个奇数

代码
// 基本算数运算符
public class SuanShuYuanSuan {
public static void main(String[] args) {
// 1. +
System.out.println(3);
// 1) 作用在数据之前,表示这个数据时一个正数
System.out.println(+3);
// 2) 两个常量数值相加
System.out.println(5+10);
// 两个变量相加
int x = 8 ;
int y = 9 ;
System.out.println(x + y);
// 3) 字符串与任意的数据类型相加,表示拼接
String s = “5”;
String s1 = s + y ;// 59
System.out.println(s);
System.out.println(s1);

	System.out.println("-------------------");

	// 2. -
	// 1) 作用在数据之前,表示这个数据时一个负数
    System.out.println(-3);
	// 2) 两个常量数值相加
	System.out.println(5-10);


	// 3. *
	System.out.println(x*y);// 8*9 = 72

	// 4. /
	// 1) 两个整数类型相除,小数点全部舍掉
    System.out.println(x/y);// 8/9 = 0
	System.out.println(y/x);// 9/8 = 1

	// 2) 带有浮点型数据的相除,结果是浮点类型(可以带小数的结果)
    // 常量7.0 是double类型    常量2是int类型
    System.out.println(7.0/2);// 3.5
	System.out.println(7/2.0);// 3.5
	System.out.println(7.0/-2.0);// -3.5

    // 5. % 取模运算
    System.out.println(x%y);// 8%9 = 8/9 = 0...8
    System.out.println(y%x);// 9%8 = 9/8 = 1...1

	// 取模运算的符号,与符号前面的数据符号保持一致
    System.out.println(-7%2);// -1
	System.out.println(7%-2);// 1
}

}

1.1.2 自增自减运算
++ : 自增,表示每次让变量的值加1
– : 自减,表示每次让变量的减1

自增和自减都作用在变量上

自增和自减运算符的使用:

如果变量不参与运算,那么++ 或者 – 写在变量前或者是写在变量后,结果是一致的,都是变量值本身+1
如果变量参与运算
a: ++ 或 – 写在变量之前,那么先进行变量本身的自增或者自减,然后再参与运算
b : ++ 或 – 写在变量之后,先进行运算,运算结束,在进行变量本身的自增或自减

代码
// 基本运算符中的自增和自减运算
public class AddOrSub {
public static void main(String[] args) {
// 1. 自增或自减的变量,不参与运算
int x = 10;
x ++ ; // 相当于 x = x + 1 ;
System.out.println(x);//11
++ x ; // 相当于 x = x + 1 ;
System.out.println(x);//12

	// 2. 自增或自减的变量,参与运算
	int y = 5 ;
	int z = 10 ;
    // 1) y值参与运算  2) --自减作用在变量之前,先进行变量的自减操作 y = 4
	// 3) 再参与和Z的加法运算  y+z = 4 + 10 = 14
	int w = --y + z ;
	System.out.println(w);// 14
	System.out.println(y);// 4

	// 自增或自减作用在变量之后,变量参与运算
	int a = 8 ;
	int b = 9 ;
	// 1) a的值参与运算  2) ++ 作用在a的变量之后,先进行a+b的运算 8+9 = 17
	// 将17的值,赋值给变量c  3) a变量进行++ 自增,8------>9
	int c = (a++) + b;
	System.out.println(c);// 17
	System.out.println(a);// 9
}

}

1.2赋值运算符
基本赋值运算符:
= : 表示将等号右边的数值,赋值给等号左边的变量

扩展的赋值运算符:
+= : 先进行等号右边加法的运算,将运算结果赋值给等号左边变量
举例: int x = 5;
x += 3; // 相当于 x = x +3 ----> 5+3=8----->x=8
-= : 先进行等号右边的减法运算,将运算结果赋值给等号左边变量
*=: 先进行等号右边的乘法运算,将运算结果赋值给等号左边变量
/=: 先进行等号右边的除法运算,将运算结果赋值给等号左边变量
%=: 先进行等号右边的取模运算,将运算结果赋值给等号左边变量

代码
// 赋值运算符
public class FuZhiYunSuan{
public static void main(String[] args) {
// 1. =
int i = 9 ; // i 变量所表示的值就是9
System.out.println(i+2);// 11

    // 2. +=
	// 1) i += 3; 相当于 i = i + 3 ;  2) 先计算i+3 = 9 + 3 = 12
	// 3) 将计算结果赋值给变量i , i = 12;
	i += 3;
    System.out.println(i);//12

	// 3. *=
	i *= 2;// i = i * 2; 12 * 2 = 24 = i
    System.out.println(i);// 24
}

}

1.3比较运算符
主要进行数值的结果的比较,比较运算符的结果是布尔类型 boolean,结果只有true,false

== : 表示,判断符号两边的数值是否相等,相等返回true,不相等返回false
!= : 表示不等于,判断符号两边的数值是否不相等,不相等返回true,相等返回false

: 判断符号左边的数值是否大于符号右边的数值,大于返回true,不大于返回false
=: 判断符号左边的数值是否大于等于符号右边的数值,大于等于返回true,否则返回false
<:判断符号左边的数值是否小于符号右边的数值,小于返回true,不小于返回false
<= :判断符号左边的数值是否大于等于符号右边的数值,小于等于返回true,否则返回false

注意: 比较运算符的使用,不能做连续的比较

代码
// 比较运算符
public class BiJiaoYunSuan{
public static void main(String[] args) {
int x = 9 ;
int y = 8 ;
// 1. ==
boolean boo = x == y ;// 8 == 9 ? 不相等,返回就是false
System.out.println(boo);// false

    // 2. != 
    boolean boo1 = x != y ;// 8 != 9 ? 不相等,返回就是true
	System.out.println(boo1);// true

	// 3. >
	boolean boo2 = x > y ;
	System.out.println(boo2);

	boolean boo3 = x >= y ;
	System.out.println(boo3);

	// 4. <
    boolean boo4 = x < y ;// 9 < 8
	System.out.println(boo4);

	boolean boo5 = x <= y ;// 9 <= 8
	System.out.println(boo5);

	// 要求: 给出一个数值,判断一下,这个数,是不是大于等于5,同时小于等于10
	// 注意: 比较运算符的使用,不能做连续的比较
	// 实际开发: 5 <= w  并且 w <= 10
    int w = 7;
	// 1) 5 <= w -----> true <= 10-----> 类型比较错误 
	// boolean boo6 = 5 <= w <= 10 ; 错误代码,
    // System.out.println(boo6);
}

}

1.4逻辑运算符
可以进行逻辑运算的符号,称为逻辑运算符,结果是boolean类型
例如: 有一个登录的界面,需要客户输入用户名,输入一个密码,客户如何能成功登录
客户所输入的用户名正确并且客户输入的密码正确 ,才能登录成功

& : 与,和,并且,符号两边都需要是boolean类型的表达式,只有符号两边的表达式都为true,那么&的结果才为true,否则结果就是false
true&true true
true&false false
false&true false
false&false false

&& : 短路与, 与&的结果完全一致,实际开发中,&&的使用率是绝对高
&& 在进行逻辑运算的时候,效率高
效率高的原因: 如果&&左边的表达式,为false,那么&&的结果其实已经确定为false,&&就直接返回false,不进行&&右边表达式的运算和判断

| : 或者,符号两边的表达式都需要boolean类型,两个表达式中,只要有一个是true,那么或的返回值就是true
true | true true
true | false true
false | true true
false | false false

||: 短路或,与|结果,完全一致,短路或性能高,在实际开发中使用率高
效率高的原因: 如果|| 左边的表达式结果为true, 那么||的结果已经确定为true,所以就直接返回true, 右边表达式不管是什么,都不再进行判断和运行

举例: 需要客户输入电话号码,输入客户的手机或者是家庭座机

! : 表示取反,针对于boolean类型的表达式进行取反
!true false
!false true
^ : 异或,表示符号两边的boolean类型表达式结果相同为false,不同为true
true^true false
false^false false
true ^ false true
false ^ true true

代码
// 逻辑运算符
public class LuoJiYunSuan{
public static void main(String[] args) {
// 要求: 给出一个数值,判断一下,这个数,是不是大于等于5,同时小于等于10
// & : 与逻辑运算
int w = 7;
boolean boo = w >= 5 & w <= 10 ;
System.out.println(boo);// true

	// &&
	// 1) 4 < 3 结果为false , 如果&&左边表达是为false,那么右边不运行,直接返回false
	boolean boo1 = 4 < 3 && ++w >= 8 ;
	System.out.println(boo1);// flase
    System.out.println(w);// 7

	// 2) & 运算,符号两边的表达式都会进行运算和判断
	int q = 7 ;
	boolean boo2 = 4 < 3 & ++q >= 8 ;
	System.out.println(boo2);// flase
    System.out.println(q);// 8

    System.out.println("------------------");

	// 或运算符
	int a = 10 ;
	int b = 20 ;
    // false | true -----> true
    boolean boo3 = a >= 20 | b >= 20 ;
    System.out.println(boo3);// true

	// 验证||效率高
    boolean boo4 = b >= 20 | ++a >= 20 ;
	System.out.println(boo4);// true
	System.out.println(a);// 11

	// 验证||效率高
	int aa = 10;
    boolean boo5 = b >= 20 || ++aa >= 20 ;
	System.out.println(boo5);// true
	System.out.println(aa);// 10

    System.out.println("------------------");

	// ! :	取反
    System.out.println(!true);// false
	System.out.println(!false);// true

	// ^ : 相同为false,不同为true
	boolean boo6 = true ^ false ;
	System.out.println(boo6);// true

	boolean boo7 = true ^ true ;
	System.out.println(boo7);// false
}

}

1.5位移运算符(了解)
正常在进行数值的计算的场景: 如果需要乘2或者除2这种场景,可以使用位移运算
针对于2或者是2的倍数乘和除,位移运算速度快

<< : 左位移,能让数值乘以2,或者是乘以2的倍数

: 右位移,能让数值除2,或者是除2的倍数

一个整数,是十进制
10-----> 表示十进制的数值2
11-----> 表示十进制的数值3
100----> 表示十进制的数值4

<< : 表示将十进制数所对应的2进制,向左移动1位
000010000----> 16

: 表示将十进制数所对应的2进制,向右移动1位
00000010 —> 2

代码
// 位移运算
public class WeiYiYunSuan{
public static void main(String[] args) {

	int w = 10 ;
	// 表示将w所对应的2进制数,向左移动2位,变成原来值的4倍
	int y = w << 2 ;
	System.out.println(y);// 40

    y = y >> 1 ;
	System.out.println(y);// 20
}

}

1.6三元运算
三元运算又称三目运算
三元运算: 如果有两个选择,必须要选择出一个,这种场景可以使用三元运算
三元运算公式:
表达式1 ? 表达式2 : 表达式3 ;

解释:

表达式1, 必须是布尔boolean类型的表达式,结果 true 真, false 假
? : 问,表达式1的结果是真还是假
如果表达式1结果为true,那么只执行表达式2的内容
如果表达式1的结果为false,那么只执行表达式3的内容
表达式2和表达式3数据的结果可以任意,但是尽量要求大家让表达式2和表达式3数据类型结果一致

要求 : 给你任意一个整数,判断,这个数是奇数还是偶数

代码
// 三元运算
public class SanYuanYunSuan{
public static void main(String[] args) {
//公式: 表达式1 ? 表达式2 : 表达式3 ;
// 1. 要求 : 给你任意一个整数,判断,这个数是奇数还是偶数
int w = 70 ;
// w % 2 结果可能是1 也可能是0 ,通过==比较运算符,验证一下,w 和2 取模的
// 结果是否和0相等,如果和0相等,证明是偶数,否则是奇数
String s = w % 2 == 0 ? “这个数是一个偶数” : “这个数是一个奇数” ;
System.out.println(s);

    // 2. 要求 : 给你任意一个整数,数是奇数,得到的结果是原值+1 
	// 数是偶数,得到的结果是原值-1

    int t = w % 2 == 0 ? w-- : w++ ;
	System.out.println(t);// 70
    System.out.println(w);// 69
}

}

引用数据类型键盘输入和随机数
2.1 Scanner类键盘录入
Scanner 类 : 功能,就是可以接收键盘输入的数据,可以接收整数,可以接收字符串
Scanner类是JDK已经写好的一个类,存在于JDK的src.zip压缩包中,存在于java.util的文件夹下,Scanner 是一个引用数据类型

引用数据类型的功能实现过程:

导包: 导入所要使用的类它所在的路径
import : 关键字,功能就是进行类它所在的路径的导入
在导包时,文件夹之间使用英文 . 来进行分隔
import java.util.Scanner ;
解释: 1) import java.util.Scanner ; 写在类上面
为什么需要import导包
通过import导入了Scanner类所在的具体的路径,在你自己的Java代码中,要使用Scanner的时候,可以通过import快速的确定Scanner的位置,将Scanner加载进内存运行,Scanner中功能才能被使用
创建一个Scanner对象
公式:
Scanner sc = new Scanner(System.in);
调用Scanner中的功能: 接收键盘输入的数据
名字.方法();
sc.nextInt() ;
Scanner 中的方法(功能)

nextInt() : 表示接收键盘输入的整数
next() : 表示接收键盘输入的字符串

键盘输入整数代码
// Scanner类接收键盘输入数据的使用
// 1. 先导入Scanner类的存在路径
import java.util.Scanner;
public class ScannerDemo {
public static void main(String[] args) {
// 2. 创建一个Scanner对象
// System.in -----> 系统输入----->System系统 in 输入
Scanner sc = new Scanner(System.in);
// 3. 通过变量名sc调用Scanner类中的方法(功能)
// nextInt() : 表示接收键盘输入的整数
System.out.println(“请输入一个整数”);
int x = sc.nextInt();
System.out.println(“我获取到了键盘输入的数据”+x);

	// 要求 : 给你任意一个整数,判断,这个数是奇数还是偶数
	//1. 获取到一个键盘输入的任意的整数
	System.out.println("请输入一个整数判断奇偶数:");
	int w = sc.nextInt();
	// 2. 判断这个数是奇数还是偶数
	String ss = w % 2 == 0 ? "是一个偶数" : "是一个奇数" ;
    System.out.println(ss);
}

}

键盘输入字符串代码
//接收键盘录入的字符串
// 1. 先导入Scanner类所在的路径
import java.util.Scanner;
public class ScannerDemo2{
public static void main(String[] args) {
// 2. 创建一个Scanner对象
Scanner sc = new Scanner(System.in);
// 3. 调用Scanner中的方法,接收键盘输入的字符串
// next()
System.out.println(“请输入一个字符串”);
String s = sc.next();
System.out.println("字符串 “+s + " 已经获取到”);
}
}

练习1:
接收键盘录入的任意两个整数,输出两个数中的较大数

代码
// 接收键盘录入的任意两个整数,输出两个数中的较大数
/*
分析: 1. 通过键盘,获取到2个数----> 获取一个整数 nextInt(),方法调用两次
2. 通过三元运算,判断出两个数中的较大数,输出到控制台
*/
// 1. 先导入Scanner类的所在路径
import java.util.Scanner;
public class ScannerMaxNumber{
public static void main(String[] args) {
// 2. 创建一个Scanner 对象
Scanner sc = new Scanner(System.in);
// 3. 获取到两个整数,使用nextInt() 方法
System.out.println(“请输入第一个整数:”);
int x = sc.nextInt();
System.out.println(“请输入第二个整数:”);
int y = sc.nextInt();
// 4. 输出一个较大的数
int result = x >= y ? x : y ;
System.out.println(“两个数中较大值为:”+result);
}
}

2.2 Random 类生成随机数(扩展)
Random 也是JDK写好的一个类,功能主要是生成随机数
来自于 java.util

如果要使用Random生成一个随机数,步骤如下:

先导包: import java.util.Random;
创建一个Random对象 : Random ran = new Random();
创建的类对象的名字.方法();
Random 类功能:
nextInt() : 生成一个随机的int类型范围的整数
需求升级: 我需要生成指定范围内的随机整数nextInt(int类型数据)
举例: nextInt(5): 表示生成[0-5)之间的整数,包含0,不包含5
nextDouble() : 生成一个随机的小数,[0-1)

代码
// 生成随机数案例
// 1. 先导入Random类所在路径
import java.util.Random;
public class RandomDemo{
public static void main(String[] args) {
// 2. 创建一个Random对象
Random ran = new Random();
// 3. 使用ran对象名.调用方法
// nextInt() : 随机生成一个int类型的整数
int x = ran.nextInt();
System.out.println(x);

	//4. nextInt(50): 表示生成的随机数的范围[0,50)
	// 数据范围在0-50之间,包含0不包含50
	int y = ran.nextInt(3);// 0-2
	System.out.println(y);

	// 5. 要求: 生成的数1-33之间
	int w = ran.nextInt(33)+1;// 0-32  + 1   ----> 1-33

	// 6. 生成一个小于1的随机小数
	double d = ran.nextDouble();
    System.out.println(d);
}

}

Chen Yongguang

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java基础Day03

day03运算符运算符: 进行运算,逻辑业务处理的符号1.1 算数运算符1.1.1 基本算数运算符:/ %:单独作用在数据之前,表示这个数据时一个正数,举例: +3进行数值之间的加法举例: 3 + 2 = 5字符串的加法,字符串与任意的数据类型相加,表示拼接,相当于在字符串的末尾进行追加,结果任然是一个字符串类型:单独作用在数据之...
复制链接

扫一扫