Java运算符和分支结构-------------------基础语法Day03

Aff源

已于 2025-05-09 10:39:06 修改

阅读量572

点赞数 18

分类专栏： java从0基础学习到实战教学文章标签： java 开发语言

于 2025-05-06 18:00:44 首次发布

本文链接：https://blog.csdn.net/weixin_65118692/article/details/147744427

版权

java从0基础学习到实战教学专栏收录该内容

7 篇文章

订阅专栏

1.运算符

1.1算术运算符

1.1 算术运算符：+，-，*，/，%，++，--
%:取模/取余，余数为0即为整除

System.out.println(5%2); //1，商2余1
System.out.println(2%5); //2，商0余2
System.out.println(8%2); //0，商4余0----整除

++/--:自增1/自减1，可在变量前也可在变量后
单独使用时，在前在后都一样
被使用时，在前在后不一样
a++的值为a------------(a--的值为a)
++a的值为a+1--------(--a的值为a-1)

//演示++单独使用:
int a=5,b=5;
a++; //相当于a=a+1
++b; //相当于b=b+1
System.out.println(a); //6
System.out.println(b); //6

//演示++被使用
int c=5,d=5;
int e = c++; //将c++的值5赋值给e，同时c自增1变为6
int f = ++d; //将++d的值6赋值给f，同时d自增1变为6
System.out.println(c); //6
System.out.println(d); //6
System.out.println(e); //5
System.out.println(f); //6

//演示--单独使用:
int a=5,b=5;
a--; //相当于a=a-1
--b; //相当于b=b-1
System.out.println(a); //4
System.out.println(b); //4
System.out.println("--------------------");

//演示--被使用:
int c=5,d=5;
int e = c--; //将c--的值5赋值给e，同时c自减1变为4
int f = --d; //将--d的值4赋值给f，同时d自减1变为4
System.out.println(c); //4
System.out.println(d); //4
System.out.println(e); //5
System.out.println(f); //4

1.2关系运算符

1)>(大于)、<(小于)>=(大于或等于)、<=(小于或等于)==(等于)、!=(不等于)
2)关系运算的结果为boolean型，
关系成立则为true，关系不成立则为false

int a=5,b=10,c=5;
boolean b1 = a>b;
System.out.println(b1);   //false
System.out.println(c<b);  //true
System.out.println(a>=c); //true
System.out.println(a<=b); //true
System.out.println(a==c); //true
System.out.println(a!=c); //false

System.out.println(a%2==0); //false
System.out.println(a+c>b);  //false
System.out.println(a++>5); //false------a自增1变为6
System.out.println(a++>5); //true-------a自增1变为7
System.out.println(a);     //7

1.3 逻辑运算符：&&、||、!

逻辑运算是建立在关系运算的基础之上的
逻辑运算的结果也是boolean型
&&：短路与(并且)，两边都为真则为真，见false则false
第1个条件为false时，则发生短路(后面的不执行了)

int a=5,b=10,c=5;
boolean b1 = b>=a && b<c;
System.out.println(b1);          //true&&false=false
System.out.println(b<=c && b>a); //false&&true=false
System.out.println(a==b && c>b); //false&&false=false
System.out.println(b!=c && a<b); //true&&true=true
int age = 40;
System.out.println(age>=18 && age<=50); //年龄在18到50之间

//演示短路:
boolean b3 = a>b && c++>2;
System.out.println(b3); //false
System.out.println(c);  //5，发生短路了

||：短路或(或者)，有真则为真，见true则true
第1个条件为true时，则发生短路(后面的不执行了)

int a=5,b=10,c=5;
System.out.println(b>=a || b<c); //true||false=true
System.out.println(b<=c || b>a); //false||true=true
System.out.println(b!=c || a<b); //true||true=true
System.out.println(a==b || b<c); //false||false=false
int score = 90;
System.out.println(score<0 || score>100); //成绩不合法(不在0到100之间)

//演示短路:
boolean b4 = a<b || c++>2;
System.out.println(b4); //true
System.out.println(c);  //5，发生短路了

!：逻辑非(取反)，非真则假，非假则真

int a=5,b=10,c=5;
boolean b2 = !(a<b);
System.out.println(b2);     //!true=false
System.out.println(!(a>b)); //!false=true

1.4 赋值运算符：=、+=、-=、*=、/=、%=

简单赋值运算符：=
扩展赋值运算符：+=,-=,*=,/=,%=
注意:扩展赋值运算符自带强转功能

int a = 5;
a += 10; //相当于a=(int)(a+10)
System.out.println(a); //15
a *= 2; //相当于a=(int)(a*2)
System.out.println(a); //30
a /= 6; //相当于a=(int)(a/6)
System.out.println(a); //5

//小面试题:
short s = 5;
//s = s+10; //编译错误，需强转，改为:s=(short)(s+10);
s += 10; //相当于s=(short)(s+10);

1.5 字符串连接运算符：+

若两边为数字，则做加法运算
若两边(任意边)出现了字符串，则做字符串连接

int age = 39;
System.out.println("age="); //age=
System.out.println(age);    //39
System.out.println("age="+age); //age=39
System.out.println("我今年"+age+"岁了"); //我今年39岁了
so
String name = "WKJ"; //声明字符串型变量name，并赋值为WKJ
System.out.println("大家好，我叫"+name); //大家好，我叫WKJ
System.out.println("大家好，我叫"+name+"，今年"+age+"岁了"); //大家好，我叫WKJ，今年39岁了

任何类型的数据与字符串连接，结果都会变为字符串型

System.out.println(10+20+""+30); //3030---------String
System.out.println(""+10+20+30); //102030-------String
System.out.println(10+20+30+""); //60-----------String

1.6 条件运算符：boolean？数1：数2

语法：
boolean?数1:数2
执行过程：
整个条件运算是有值的，它的值要么是?号后的数1，要么是:号后的数2
计算boolean的值:
若为true，则整个表达式的值为?号后的数1
若为false，则整个表达式的值为:号后的数2

int num = 5;
int flag = num>0?1:-1;
System.out.println(flag); //1

int a=8,b=5;
int max = a>b?a:b;
System.out.println("max="+max); //max=8

2. 分支结构：基于条件执行

2.1 if结构：1条路

1)语法:
if(boolean){
语句块--------------基于条件执行的语句
}
2)执行过程:
判断boolean的值:
若为true，则执行语句块(整个结束)
若为false，则直接结束

//1)满500打8折:
double price = 300.0; //消费金额  带数(600.0,300.0)
if(price>=500){   //满500
    price *= 0.8; //打8折
}
System.out.println("最终结算金额为:"+price);

//2)判断成绩是否合法，若合法则输出---0到100之间为合法成绩
double score = 555; //成绩  带数(95.5,-5,555)
if(score>=0 && score<=100){
    System.out.println(score+"是合法成绩");
}
System.out.println("继续执行...");

2.2 if...else结构：2条路

1)语法:
if(boolean){
语句块1
}else{
语句块2
}
2)执行过程:
判断boolean的值:
若为true，则执行语句块1(整个结束)
若为false，则执行语句块2(整个结束)
3)说明:
语句块1和语句块2，必走其中之一-------------2选1

//1)满500打8折，不满500打9折:
double price = 300.0;   //带数(600.0,300.0)
if(price>=500){ //满
    price*=0.8;
}else{ //不满
    price*=0.9;
}
System.out.println("最终结算金额为:"+price);

//2)判断成绩合法还是不合法:
double score = 95; //带数(95,-5,555)
if(score>=0 && score<=100){
    System.out.println(score+"是合法成绩");
}else{
    System.out.println(score+"是不合法成绩");
}

2.3 if...else if结构：多条路

1)语法:
if(boolean-1){
语句块1
}else if(boolean-2){
语句块2
}else if(boolean-3){
语句块3
}else{
语句块4
}
2)执行过程:
判断boolean-1，若为true则执行语句块1(结束)，若为false则再判断boolean-2，若为true则执行语句块2(结束)，若为false则再判断boolean-3，若为true则执行语句块3(结束)，若为false则执行语句块4(结束)
3)说明:
语句块1/2/3/4，必走其中之一--------多选1

//1)满2000打5折，满1000不满2000打7折，满500不满1000打8折，不满500打9折:
double price = 6000.0; //带数(6000.0,1000.0,600.0,300.0)
if(price>=2000){
    price*=0.5;
}else if(price>=1000){
    price*=0.7;
}else if(price>=500){
    price*=0.8;
}else{
    price*=0.9;
}
System.out.println("最终结算金额为:"+price);

2.4 switch...case结构：多条路

- 优点：效率高、结构清晰
- 缺点：只能对整数判断相等
- break：跳出switch
- switch中数据的类型：byte,short,int,char,String,枚举

package day03;
/**
 * switch...case结构的演示
 */
public class SwitchCaseDemo {
    public static void main(String[] args) {
        int num = 2;
        switch(num){ //byte,short,char,int,String和枚举
            case 1: //if(num==1)
                System.out.println(111);
                break;
            case 2: //以此为入口
                System.out.println(222);
                break; //跳出switch
            case 3:
                System.out.println(333);
                break;
            default: //所有case都未匹配时执行
                System.out.println(666);
        }
    }
}
package day04;
import java.util.Scanner;
//命令解析程序
public class CommandBySwitch {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请选择功能: 1.存款 2.取款 3.查询余额 4.退卡");
        int command = scan.nextInt();

        switch(command){
            case 1:
                System.out.println("存款业务...");
                break;
            case 2:
                System.out.println("取款业务...");
                break;
            case 3:
                System.out.println("查询余额业务...");
                break;
            case 4:
                System.out.println("退卡成功");
                break;
            default:
                System.out.println("输入错误");
        }
    }
}

补充：
1. 任何复杂的程序逻辑都可以通过三种结构来实现：
- 顺序结构：从上往下逐行执行，每句必走
- 分支结构：有条件的执行某语句，并非每句必走
- 循环结构：