三 . 运算符和流程控制
1. 运算符
1 . 赋值运算符
1.2.1 基本语法
-
符号：=
- 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
- 支持
连续赋值。
-
扩展赋值运算符： +=、 -=、*=、 /=、%=
赋值运算符 符号解释 +=将符号 左边的值和右边的值进行相加操作，最后将结果赋值给左边的变量-=将符号 左边的值和右边的值进行相减操作，最后将结果赋值给左边的变量*=将符号 左边的值和右边的值进行相乘操作，最后将结果赋值给左边的变量/=将符号 左边的值和右边的值进行相除操作，最后将结果赋值给左边的变量%=将符号 左边的值和右边的值进行取余操作，最后将结果赋值给左边的变量
注意：赋值运算符不会更改原有的数据类型
public class OperatorTest1 {
public static void main(String[] args) {
char c='a';
c-=32;//省去了强转数据类型的步骤
System.out.println("c = " + c);
// char c='a';
//
// int result=c-32;
// System.out.println("result = " + result);
// //将数字转为字符
// char temp=(char)result;
// System.out.println("temp = " + temp);
/*
a:97
A:65
*/
System.out.println("------------------------");
int m = 10;
System.out.println("m = " + m);
m+=30;//m = m + 30;
System.out.println("m = " + m);
m*=10;//m=m*10
System.out.println("m = " + m);
int n=30;
n%=7; //n=n=n%7;
System.out.println("n = " + n);
}
}
2 . 比较运算符
-
比较运算符的结果都是boolean型，也就是要么是true，要么是false。
-
> < >= <= ：只适用于基本数据类型（除boolean类型之外）
== != ：适用于基本数据类型和引用数据类型
class CompareTest { public static void main(String[] args) { int i1 = 10; int i2 = 20; System.out.println(i1 == i2);//false System.out.println(i1 != i2);//true System.out.println(i1 >= i2);//false int m = 10; int n = 20; System.out.println(m == n);//false System.out.println(m = n);//20 boolean b1 = false; boolean b2 = true; System.out.println(b1 == b2);//false System.out.println(b1 = b2);//true } }
3 . 逻辑运算符
逻辑运算符，操作的都是boolean类型的变量或常量，而且运算得结果也是boolean类型的值。
-
运算符说明：
- & 和 &&：“且”，true=true--------true 两边布尔值都是true时，结果才能为true。否则，为false。
- | 和 || ：“或”，true=flase或者false=true-------true false=fasle------false 当符号两边布尔值有一边为true时，结果为true。当两边都为false时，结果为false
- ! ：“非”，当变量布尔值为true时，结果为false。当变量布尔值为false时，结果为true。
- ^ ：当符号左右两边布尔值不同时，结果为true。当两边布尔值相同时，结果为false。
- 理解：
异或，追求的是“异”！
- 理解：
-
区分“&”和“&&”：
-
相同点：如果符号左边是true，则二者都执行符号右边的操作
-
不同点：& ： 如果符号左边是false,则继续执行符号右边的操作
&& ：如果符号左边是false,则不再继续执行符号右边的操作
- 建议：开发中，推荐使用 &&
-
-
区分“|”和“||”：
-
相同点：如果符号左边是false，则二者都执行符号右边的操作
-
不同点：| ： 如果符号左边是true，则继续执行符号右边的操作
|| ：如果符号左边是true，则不再继续执行符号右边的操作
-
逻辑运算符：
&:与：所有的表达式都是true，结果才是true，能false就false
|:或：所有的表达式都是flase，结果才是false,能true就true
^:异或：相同为false，不同为true
!:非：取反
----
&&:短路与：前面的表达式为true，则不再计算后面的表达式
||:短路或：前面的表达式为false，则不再计算后面的表达式
注意:
1、&|^是逻辑运算符时 两边表达式时boolean布尔类型 则逻辑
2、&|^是逻辑运算符时 两边表达式时int数字 则位
*/
class OperatorTest_2{
public static void main(String[] args) {
boolean t1 = true, t2 = true;
boolean f1 = false, f2 = false;
System.out.println("----- --||--- -----");
System.out.println(f1 || f2 || f1 || f2 || t1); //true
System.out.println(f1 || f2 || f1 || f2); //false
int a=10;
int b=20;
//boolean result=b>a | ++a>b; //result = true,a=11
boolean result=b>a || ++a>b; //result = true,a=10
System.out.println("result = " + result+",a="+a);
System.out.println("---------------------&&------------------");
System.out.println(t1 && t2 && t1 && f1); //false
System.out.println(t1 && t2 && t1 && t2); //true
int m=66;
int n=99;
// result=m>n & ++m<n; //result = false,m=67
result=m>n && ++m<n; //result = false,m=66
System.out.println("result = " + result+",m="+m);
}
}
public class OperatorTest4 {
public static void main(String[] args) {
boolean t1 = true, t2 = true;
boolean f1 = false, f2 = false;
System.out.println("-------！--------");
System.out.println(!t1);//false
System.out.println(!f1);//true
System.out.println("-------^--------");
System.out.println(f1^t1);//true
System.out.println(f1^f1);//false
System.out.println(t2^t2);//false
System.out.println(t2^f2);//ture
System.out.println("-------|--------");
System.out.println(f1 | f2 | f1 | f2 | t1); //true
System.out.println(f1 | f2 | f1 | f2); //false
System.out.println("-------&--------");
//结果都是true是结果才是true，只要有一个是false，结果就是false
System.out.println(t1 & t2 & t1 & f1); //false
System.out.println(t1 & t2 & t1 & t2); //true
}
}
4 . 位运算
- 位运算符的运算过程都是基于二进制的补码运算
（1）左移：<<
运算规则：在一定范围内，数据每向左移动一位，相当于原数据*2。（正数、负数都适用）
【注意】当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位
3<<4 类似于 3*2的4次幂 => 3*16 => 48
-3<<4 类似于 -3*2的4次幂 => -3*16 => -48
（2）右移：>>
运算规则：在一定范围内，数据每向右移动一位，相当于原数据/2。（正数、负数都适用）
【注意】如果不能整除，向下取整。
69>>4 类似于 69/2的4次 = 69/16 =4
-69>>4 类似于 -69/2的4次 = -69/16 = -5
（3）无符号右移：>>>
运算规则：往右移动后，左边空出来的位直接补0。（正数、负数都适用）
69>>>4 类似于 69/2的4次 = 69/16 =4
-69>>>4 结果：268435451
（4）按位与：&
运算规则：对应位都是1才为1，否则为0。
-
1 & 1 结果为1
-
1 & 0 结果为0
-
0 & 1 结果为0
-
0 & 0 结果为0
9 & 7 = 1
-9 & 7 = 7
（5）按位或：|
运算规则：对应位只要有1即为1，否则为0。
-
1 | 1 结果为1
-
1 | 0 结果为1
-
0 | 1 结果为1
-
0 & 0 结果为0
9 | 7 //结果： 15
-9 | 7 //结果： -9
（6）按位异或：^
运算规则：对应位一个为1一个为0，才为1，否则为0。
-
1 ^ 1 结果为0
-
1 ^ 0 结果为1
-
0 ^ 1 结果为1
-
0 ^ 0 结果为0
9 ^ 7 //结果为14
-9 ^ 7 //结果为-16
（7）按位取反：~
运算规则：对应位为1，则结果为0；对应位为0，则结果为1。
-
~0就是1
-
~1就是0
~9 //结果：-10
~-9 //结果：8
/*
位运算符（按照二进制进行运算）：
&:与
|：或
^：异或
~：取反
<<：左移
>>：右移
>>>：无符号右移
无论是正数还是负数，移动后最高位都补0
一个更小的负数移动后会变为一个更大的正数
十进制转二进制：0B开头+十进制，
System.out.println(0B0000000000000000000000000000000000001000);
*/
public class OperatorTest3 {
public static void main(String[] args) {
System.out.println("----------无符号右移>>>-----------");
/*
0000 0000 0000 0000 0000 0000 0000 0000 0000 1000|
0000 0000 0000 0000 0000 0000 0000 0000 0000 100|0 //4
0000 0000 0000 0000 0000 0000 0000 0000 0000 10|00 //2
*/
System.out.println(0B0000000000000000000000000000000000001000);
System.out.println(8>>>1);
System.out.println(8>>>2);
System.out.println(-8>>>1);
System.out.println("----------右移>>-----------");
/*
10000
1000 //8
100 //4
*/
System.out.println(16>>1);
System.out.println(16>>2);
System.out.println("----------<<-----------");
/*
100
1000 //8
10000 //16
注意：左移一位乘以2，就是向左移一位，后面补0
*/
System.out.println(4 << 1);
System.out.println(4<<2);
System.out.println("----------&|~^------------");
System.out.println(5 & 3);//1
/*
1 0 1
0 1 1
& //上下都为1，才是1
---------------
0 0 1
System.out.println(5 | 3);//1
/*
1 0 1
0 1 1
| //上下有1，才是1
---------------
1 1 1
*/
System.out.println(5 ^ 3);//1
/*
1 0 1
0 1 1
^ //不同为1，相同为0
---------------
1 1 0
*/
System.out.println(~5);//-6
/*
0000 0101
~ 取反 1111 1010
补码 1111 1010
反码 1111 1001 反码+1才是补码
原码 1000 0110 源码最高位不变，其余1变0，0变1
*/
}
}
5 . 条件运算符
- 条件运算符格式：
(条件表达式)? 表达式1:表达式2
- 说明：条件表达式是boolean类型的结果，根据boolean的值选择表达式1或表达式2
- 如果运算后的结果赋给新的变量，要求表达式1和表达式2为同种或兼容的类型
/*
条件运算符/三目运算符/三元运算符：
X?Y:Z;
X:true-->Y
X:false-->Z
*/
public class OperatorTest5 {
public static void main(String[] args) {
//定义年龄
int age=19;
String result=age>18?"成年了":"未成年";
System.out.println("result = " + result);
//定义一个整数
int num=19;
String result2 = 19 % 2 == 0 ? "时偶数" : "不是整数";
System.out.println("result2 = " + result2);
int m=10;
int n=20;
int result3 = m > n ? m : n;
System.out.println("result3 = " + result3);
/*
定义三个数字，求最大值，要求一行三目
*/
int a = 20, b = 300, c = 60;
int MaxNum3 = a > b ? (a > c ? a : c) : (b > c ? b : c);
System.out.println("MaxNum3 = " + MaxNum3);
// //1、获取前两个数中的最大值
// int tempMaxNum = a > b ? a : b;
// //2、最大值与第三个数进行比较
// int MaxNum2 = tempMaxNum > c ? tempMaxNum : c;
// System.out.println("MaxNum2 = " + MaxNum2);
}
}
2. Scanner：键盘输入功能的实现
键盘输入：Scanner
一、基本操作：
1、创建键盘输入的对象
in:对象名 是可以改变的
Scanner in=new Scanner(System.in);
2、提供提示语句（可选）
3、对象调用的方法接收数据
in.nextInt();
4、展示数据
5、关闭资源
in.nextInt();
二、键盘输入获取其他基本数据类型的值
nextByte()
nextShart()
nextInt()
nextLong()
nextFloat()
nextDouble()
nextBoolean()
注意：
1、如果输入的类型不满足要求，输入异常，会显示inputMismatchExceltion
2、键盘输入不存在nextChar（）。。
通过字符串中的charAt(index)获取char值
三、键盘输入获取字符串数据
next()：只能接收空格之前的数据
nextLine()：可以接受一整行数据，若是要输入多行数据，得使用in.nextLine()进行过渡
class OperatorTest7_4{
public static void main(String[] args) {
//1、创建对象
Scanner in=new Scanner(System.in);
//2、提示语句
System.out.println("请您输入一句话：");
//3、对象调用方法来接受数据
String message=in.nextLine();
//4、展示数据
System.out.println("message = " + message);
//5、关闭资源
in.close();
}
}
class OperatorTest7_3{
public static void main(String[] args) {
//1、创建对象
Scanner in=new Scanner(System.in);
//2、提示语句
System.out.println("请您输入一句话：");
//3、对象调用方法来接受数据
String message=in.next();
//4、展示数据
System.out.println("message = " + message);
//5、关闭资源
in.close();
}
}
class OperatorTest7_2{
public static void main(String[] args) {
//通过字符串中的charAt(index)获取char值
String s="ABCDE";
char ele =s.charAt(2);
System.out.println("ele = " + ele);
//1、创建输入对象
Scanner in=new Scanner(System.in);
//2、提示语句
System.out.println("请您输入一个名字：");
//3、接受数据
String name = in.next();
//4、获取名字得第一个字符
char c = name.charAt(0);
// char c2 = in.next().charAt(0);
//5、展示数据
System.out.println("c = " + c);
//6、关闭资源
in.close();
}
}
class OperatorTest7_1{
public static void main(String[] args) {
//1、创建键盘输入对象
Scanner input=new Scanner(System.in);
//2、接受并展示一个long值
System.out.println("请您输入一个long值");
long l = input.nextLong();
System.out.println("l = " + l);
//3、接受并展示一个dluble值
System.out.println("请您输入一个double值");
double d = input.nextDouble();
System.out.println("d = " + d);
//4、接受并展示一个boolean值
System.out.println("请您输入一个boolean值");
boolean b = input.nextBoolean();
System.out.println("b = " + b);
//5、接受并展示一个char值
//6、关闭资源
input.close();
}
}
public class OperatorTest7 {
public static void main(String[] args) {
// 1、创建键盘输入的对象
Scanner in=new Scanner(System.in);
// 2、提供提示语句
System.out.println("请您输入年龄：");
// 3、对象调用的方法接收数据
int age=in.nextInt();
// 4、展示数据
System.out.println("age = " + age);
// 5、关闭资源
in.close();
}
}
Math.random()会获取随机数[0,1)
[m,n]之间的随机数就用这个公式
(int)(Math.random()*(n-m+1)+m);
public class ScannerExer2 {
public static void main(String[] args) {
double random = Math.random();
System.out.println("random = " + random);
for(int i=1;i<=50;i++){
int num=(int)(Math.random()*(44-22+1)+22);
System.out.println(i+"-->" + num);
}
}
}
3 .程序执行结构 ( 单\双—if )
流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
程序得执行结构：
顺序结构
分支结构
循环结构
分支结构：
1. if分支
1.1 if单分支
if(布尔类型的表达式){
分支内容
}
1.2 if双分支
1.3 if多分支
注意：//使用if时若是没有括号，是对靠近它的一条语句有作用
后++：先运算再+1.
前++：先+1再运算。
使用if时若是没有括号，是对靠近它的第一条语句有作用
class IfExer{
public static void main(String[] args) {
int x=1;
int y =1;
if(x++==2 & ++y==2){
//x++就是x先运算与2比较，结果不等于，所以是false；++y就是先+1再运算，x原本=1，再+1=2，与2进行比较，所以是true
//false & ture结果是（&能false就false）false
x=7;
}
System.out.println("x = " + x+",y = " + y);
}
}
class IfText_3{
public static void main(String[] args) {
boolean b=false;
if(b=true){
System.out.println("AAAAA");
}
System.out.println("GameOver");
boolean flag=true;
if(flag){
System.out.println("888888");
}
System.out.println("GameOver");
}
}
class IfText_2{
public static void main(String[] args) {
int num=2;
if(num>10)
//使用if时若是没有括号，是对靠近它的第一条语句有作用
System.out.println("AAAAA");
System.out.println("BBBBB");
System.out.println("CXCCC");
System.out.println("DDDDD");
System.out.println("GameOver");
}
}
public class IfText1 {
public static void main(String[] args) {
int age=20;
if(age>=18){
System.out.println("成年了");
}
System.out.println("GameOver");
}
}
-----闰年判断练习
class IfText2_4{
public static void main(String[] args) {
//简单的if双分支可以使用三目运算符代替,与IfText2对应
int age=45;
String s=age>=30?"上年纪了":"还年轻";
System.out.println(age+s);
int num=19;
String s1=num%2!=0?"是奇数":"不是奇数";
System.out.println(num+s1);
int year=2001;
String s2 = year % 400 == 0 || year % 100 != 0 ? "是闰年" : "不是闰年";
System.out.println(year+s2);
}
}
class IfText2_3{
public static void main(String[] args) {
/*
判断闰年：
1、能被400整除
2、能被4整除，不能被100整除
*/
int year=2000;
if(year%400==0 || year%4==0 && year%100!=0){
System.out.println("是闰年");
}else{
System.out.println("不是闰年");
}
System.out.println("GameOver");
}
}
class IfText2_2{
public static void main(String[] args) {
int num=19;
String message="";
if(num%2!=0){
message="是奇数";
// System.out.println(num+"是奇数");
}else{
message="不是奇数";
// System.out.println(num+"不是奇数");
}
System.out.println(num+message);
}
}
public class IfText2 {
public static void main(String[] args) {
//1、创建键盘输入对象
Scanner in = new Scanner(System.in);
//2、提示
System.out.println("请您输入年龄：");
//3、接受
int age = in.nextInt();
//4、对数据进行校验
if(age>=30){
System.out.println("上年纪了！");
}else{
System.out.println("你还年轻！");
}
//5、关闭资源
in.close();
}
}
4 . if多分支
if 多分支
if(布尔表达式1){
内容1
}else if(布尔表达式2){
内容2
}else{
内容3
}
/*
如果x>=3, 则y=2*x
如果x在[-1,3), 则y=3*x+1
如果x<-1, 则y=2*x
*/
public class ifText3 {
public static void main(String[] args) {
int x=2;
if(x>=3){
System.out.println("y="+2*x);
}else if(x>=-1 && x<3){
System.out.println("y="+(3*x+1));
}else if(x<-1){
System.out.println("y="+4*x);
}
}
}
/*
1.键盘输入一个分数判断分数的等级
90~100 A
80~89 B
70~79 C
60~69 D
<60 E
希望使用一条输出语句展示结果
99 A
56 E
2.
大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出一定的条件：高：180cm以上；富：财富1千万以上；帅：是。
如果这三个条件同时满足，则：“我一定要嫁给他!!!”
如果三个条件有为真的情况，则：“嫁吧，比上不足，比下有余。”
如果三个条件都不满足，则：“不嫁！”
*/
class IfIfIfExer3{
public static void main(String[] args) {
//1.创建键盘输入对象
Scanner in = new Scanner(System.in);
//2.接收成绩
System.out.println("请您输入成绩");
int score = in.nextInt();
//todo 定义变量记录分数等级
String level = "";
if (score >= 90 ) {
level = "A";
} else if (score >= 80 ) {
level = "B";
} else if (score >= 70) {
level = "C";
} else if (score >= 60 ) {
level = "D";
} else {
level = "E";
}
//4.输出结果
System.out.println(score + " 等级是 " + level);
//5.关闭资源
in.close();
}
}
class IfIfIfExer2 {
public static void main(String[] args) {
//1.创建键盘输入对象
Scanner in = new Scanner(System.in);
//2.接收成绩
System.out.println("请您输入成绩");
int score = in.nextInt();
//todo 定义变量记录分数等级
String level = "";
//todo 对成绩进行安全校验 满足[0,100]
if(score>=0 && score<=100){
if(score>=90 && score<=100){
level="A";
}else if(score>=80 && score<90){
level = "B";
}else if(score>=70 && score<=79){
level = "C";
}else if(score>=60 && score<=69){
level = "D";
}else{
level = "E";
}
//4.输出结果
System.out.println(score+" 等级是 "+ level);
}else{
System.out.println("您的成绩输入有误");
}
//5.关闭资源
in.close();
}
}
public class IfIfIfExer {
public static void main(String[] args) {
//1.创建键盘输入对象
Scanner in = new Scanner(System.in);
//2.获取身高信息
System.out.println("请输入您的身高");
double height = in.nextDouble();
//3.获取财富信息
System.out.println("去输入财富");
int money = in.nextInt();
//4.是否帅的信息
System.out.println("是不是很帅");
boolean handSome = in.nextBoolean();
//5.对各种条件进行校验
if(height>1.8 && money>10000000&& handSome==true){
System.out.println("我一定要嫁给他!!!");
}else if(height>180 || money>10000000|| handSome){
System.out.println("嫁吧，比上不足，比下有余");
}else{
System.out.println("不嫁");
}
//7.关闭资源
in.close();
}
}
