03-01 Java运算符、选择结构if语句

(1)算术运算符

        A:+,-,*,/,%,++,--
        B:+的用法
            a:加法
            b:正号
            c:字符串连接符
        C:/和%的区别
            数据做除法操作的时候，/取得是商，%取得是余数
        D:++和--的用法
            a:他们的作用是自增或者自减
            b:使用
                **单独使用
                    放在操作数据的前面和后面效果一样。
                    a++或者++a效果一样。
                **参与操作使用
                    放在操作数的前面：先自增或者自减，再参与操作
                        int a = 10;
                        int b = ++a;
                    放在操作数的后面：先参与操作，再自增或者自减
                        int a = 10;
                        int b = a++;

/和%的区别：

/*
    注意事项：
        A:整数相除只能得到整数。如果想得到小数，必须把数据变化为浮点数类型
        B:/获取的是除法操作的商，%获取的是除法操作的余数
*/

class OperatorDemo {
    public static void main(String[] args) {
        //定义变量
        int x = 3;  //把3赋值给int类型的变量x
        int y = 4;

        System.out.println(x+y);
        System.out.println(x-y);
        System.out.println(x*y);
        System.out.println(x/y); //得到0，整数相除只能得到整数

        //我就想得到小数，该肿么办呢?
        //只需要把操作的数据中任意的一个数据变为浮点数
        System.out.println(x*1.0/y);

        //%的应用
        System.out.println(x%y); //得到的是余数
    }
}

++,--运算符的使用;

/*
    ++,--运算符的使用：
        单独使用：
            放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)
        参与运算使用：
            放在操作数的前面，先自增或者自减，然后再参与运算。
            放在操作数的后面，先参与运算，再自增或者自减。

    作用：就是对变量进行自增1或者自减1。
*/
class OperatorDemo2 {
        public static void main(String[] args) {
            //定义两个变量
            int x = 3;
            int y = 4;

            //字符串的拼接，字符串在前面
            //System.out.println("x:"+x);
            //System.out.println("y:"+y);

            System.out.println("x:"+x+",y:"+y);

            //单独使用
            //x++;
            //y--;
            ++x;
            --y;
            //System.out.println(x);
            System.out.println("x:"+x+",y:"+y);

            //意外的类型,常量是不可以这样做的
            //System.out.println(10++);

            System.out.println("-------------------");
            //参与运算使用
            int a = 3;
            int b = 4;

            //int c = a++;
            //int d = b--;

            int c = ++a; //++放在操作数前面，先自增或者自减，然后再赋值
            int d = --b;

            System.out.println("a:"+a); //4, 4
            System.out.println("b:"+b); //3, 3
            System.out.println("c:"+c); //3, 4
            System.out.println("d:"+d); //4, 3
        }
}

运算符的优先级：

+的用法：

/*
    +的用法：
        A:加法
        B:正号
        C:字符串连接符
*/
class OperatorDemo3 {
    public static void main(String[] args) {
        //加法
        System.out.println(3+4);

        //正号
        System.out.println(+4);

        System.out.println(‘a‘);//直接输出字符a
        System.out.println(‘a‘+1); //字符a和1的加法，这里是加法输出98

        //字符串连接符，注意是字符串而不是字符
        System.out.println("hello"+‘a‘+1);//helloa1，字符串hello和字符a链接，得到字符串helloa，再和链接
        System.out.println(‘a‘+1+"hello");//98hello，先进行字符a和1的加法运算，再和字符串hello链接

    }
}

(2)赋值运算符

(2)赋值运算符
        A:=,+=,-=,*=,/=,%=等
        B:=叫做赋值运算符，也是最基本的赋值运算符
            int x = 10; 把10赋值给int类型的变量x。
        C:扩展的赋值运算符的特点
            隐含了自动强制转换。

            例子：
                short s = 1;
                s = s + 1;

                short s = 1;
                s += 1;
                请问上面的代码哪个有问题?

赋值运算符：

/*
    赋值运算符：
        基本的赋值运算符：=
            把=右边的数据赋值给左边。

        扩展的赋值运算符：+=,-=,*=,/=,%=
            += 把左边和右边做加法，然后赋值给左边。
*/
class OperatorDemo {
    public static void main(String[] args) {
        //定义一个变量
        int x = 10;

        //其他用法
        int a,b;
        a = b = 10;//把10赋给b,再把b赋值给a。这种写法不建议
        System.out.println(a);
        System.out.println(b);
        System.out.println("-----------");

        //定义一个变量
        int y = 10;

        y += 20;//y = y + 20

        System.out.println(y);

    }
}

扩展的赋值运算符其实隐含了一个强制类型转换：

/*

        short s=1;s = s+1; 

        short s=1;s+=1;
        上面两个代码有没有问题，如果有，那里有问题。

        为什么第二个木有问题呢?
            扩展的赋值运算符其实隐含了一个强制类型转换。

            s += 1;
            不是等价于 s = s + 1;
            而是等价于 s = (s的数据类型)(s + 1);
*/
class OperatorTest {
    public static void main(String[] args) {
        //short s = 1;
        //s = s + 1;
        //System.out.println(s);
        //s = s + 1;//short类型，先转成int,和1相加，再赋值给short类型，报错
        short s = 1;
        s += 1; //好像是 s = s + 1;
        System.out.println(s);
    }
}

(3)比较运算符

/*
    比较运算符：
        ==,!=,>,>=,<,<=

    特点：
        无论你的操作是简单还是复杂，结果是boolean类型。

    注意事项：
        "=="不能写成"="。
*/
class OperatorDemo {
    public static void main(String[] args) {
        int x = 3;
        int y = 4;
        int z = 3;

        System.out.println(x == y);
        System.out.println(x == z);
        System.out.println((x+y) == (x+z));
        System.out.println("------------");

        System.out.println(x != y);
        System.out.println(x > y);
        System.out.println(x >= y);
        System.out.println(x < y);
        System.out.println(x <= y);
        System.out.println("------------");

        int a = 10;
        int b = 20;

        //boolean flag = (a == b);
        //boolean flag = (a = b); //这个是有问题的，不兼容的类型。
        //把b赋值给a，然后把a留下来，而a是int类型，赋值给flag的布尔类型，报错
        //System.out.println(flag);

        int c = (a = b); //把b赋值给a，然后把a留下来，而a是int类型，赋值给flag的布尔类型，出错
        System.out.println(c);

(4)逻辑运算符

        A:&,|,^,!,&&,||
        B:逻辑运算符用于连接boolean类型的式子
        C:结论
            &:有false则false
            |:有true则true
            ^:相同则false，不同则true。
                情侣关系。
            !:非true则false，非false则true

            &&:结果和&是一样的，只不过有短路效果。左边是false，右边不执行。
            ||:结果和|是一样的，只不过有短路效果。左边是true，右边不执行。

/*
    逻辑运算符：
        &,|,^,!
        &&,||

    特点：
        逻辑运算符一般用于连接boolean类型的表达式或者值。

        表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
            算术表达式：a + b
            比较表达式：a == b

    结论：
        &逻辑与:有false则false。
        |逻辑或:有true则true。
        ^逻辑异或:相同为false，不同为true。
            举例：情侣关系。男男,男女,女男,女女
        !逻辑非:非false则true，非true则false。
            特点：偶数个不改变本身。
*/
class OperatorDemo {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        int c = 5;

        //&逻辑与
        System.out.println((a > b) & (a > c)); //false & false = false
        System.out.println((a > b) & (a < c)); //false & true = false
        System.out.println((a < b) & (a > c)); //true & false = false
        System.out.println((a < b) & (a < c)); //true & true = true
        System.out.println("---------------");

        //|逻辑或
        System.out.println((a > b) | (a > c)); //false | false = false
        System.out.println((a > b) | (a < c)); //false | true = true
        System.out.println((a < b) | (a > c)); //true | false = true
        System.out.println((a < b) | (a < c)); //true | true = true
        System.out.println("---------------");

        //^逻辑异或
        System.out.println((a > b) ^ (a > c)); //false ^ false = false
        System.out.println((a > b) ^ (a < c)); //false ^ true = true
        System.out.println((a < b) ^ (a > c)); //true ^ false = true
        System.out.println((a < b) ^ (a < c)); //true ^ true = false
        System.out.println("---------------");

        //!逻辑非
        System.out.println(!(a > b)); //!false = true
        System.out.println(!(a < b)); //!true = false
        System.out.println(!!(a > b)); //!!false = false
        System.out.println(!!!(a > b)); //!!false = true
    }
}

&&和&的区别? 同理||和|的区别?

/*
    &&和&的区别? 同理||和|的区别?
        A:最终结果一样。
        B:&&具有短路效果。左边是false，右边不执行。

    开发中常用的逻辑运算符：
        &&,||,!
*/
class OperatorDemo2 {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        int c = 5;

        //&&双与
        System.out.println((a > b) && (a > c)); //false && false = false
        System.out.println((a > b) && (a < c)); //false && true = false
        System.out.println((a < b) && (a > c)); //true && false = false
        System.out.println((a < b) && (a < c)); //true && true = true
        System.out.println("----------------");

        int x = 3;
        int y = 4;

        //boolean b1 = ((x++ == 3) & (y++ == 4));
        //boolean b1 = ((x++ == 3) && (y++ == 4));
        //boolean b1 = ((++x == 3) & (y++ == 4));
        boolean b1 = ((++x == 3) && (y++ == 4));
        System.out.println("x:"+x);
        System.out.println("y:"+y);
        System.out.println(b1);
    }
}

时间： 2024-11-24 09:30:18

03-01 Java运算符、选择结构if语句的相关文章

Java基本知识(运算符/选择结构语句/循环结构语句/方法/标识符)

Java基本知识(运算符/选择结构语句/循环结构语句/方法/标识符)一.Java标识符给类.接口.方法等命名的字符序列.1.标识符组成(1)英文字母大小写:(2)数字(不能以数字开头):(3)$和_.2.命名规则常量:每个单次字母均大写,若由多个单词组成,则每个单词间用下划线隔开.变量.方法:第一个单词全部小写,若由多个单词组成,则第一个单词全部小写,从第二个单词开始,每个单词首字母大写其他单词首字母小写.包:所有字母都小写,多级包采用域名反写,每级用"."隔开.类.接口:每个单词首字

Java选择结构------------if语句 switch语句

Java选择结构(if语句 switch语句) 1.if选择结构: ①if(布尔表达式){ //如果布尔表达式为true,就执行的语句 } *如果if语句后只有一条语句,那么if语句的大括号可以不要 ②if(布尔表达式){ //如果布尔表达式为true时执行 }else{ //如果布尔表达式为false时执行 } *一个else只能跟随一个相关的if,else语句不能单独出现 ③if(布尔表达式){ //

选择结构if语句和switch语句的区别

1.选择结构if语句格式及其使用 A:if语句的格式: if(比较表达式1) { 语句体1; }else if(比较表达式2) { 语句体2; }else if(比较表达式3) { 语句体3; } ... else { 语句体n+1; } B:执行流程: 首先计算比较表达式1看其返回值是true还是false, 如果是true,就执行语句体1,if语句结束. 如果是false,接着计算比较表达式2看其返回值是true还是false, 如果是true,就执行语句体2,if语句结束. 如果是fals

java基础：流程控制语句(选择结构if语句)

(1)顺序结构从上往下,依次执行 Demo: class ShunXuJieGouDemo { public static void main(String[] args) { System.out.println("程序开始了"); System.out.println("我爱Java"); System.out.println("程序结束了"); } } (2)选择结构按照不同的选择,执行不同的代码 Java语言提供了两种选

shell条件测试,运算符,选择结构,for循环结构

一.shell条件测试 man bash //查看帮助条件测试的命令 test 选项文件名或目录名或 [ 选项文件名或目录名 ] 例: [ -e /etc/passd ] 文件状态 -f //判断是不是文件,是文件为真 -d //判断是不是目录,是目录为真 -e //判断是不是存在,存在为真 -r //判断是否可以阅读,可以阅读为真 -w //判断是否可写,可写为真 -x //判断是否可执行,可执行为真 -l //判断是否为链接,是链接为真数值比较

2.38 选择结构switch语句的基本使用

/* switch语句格式: switch(表达式) { case 值1: 语句体1; break; case 值2: 语句体2; break; ... default: 语句体n+1; break; } 格式的解释: switch:表示这是switch选择结构表达式:这个地方的取值是有限定的 byte,short,int,char JDK5以后可以是枚举 JDK7以后可以是字符串 case:后面跟的是要和表达式进行比较的值语句体:要执行的代码 break:表示中断,结束的意思,可以控制sw

Java——switch选择结构

switch语句是由一个控制表达式和case标签组成的,和 if 语句不同的是 ,switch语句后面控制表达式的数据类型只能是整型,不能是boolean型,·case 标签后面紧跟一个代码块.case作为这个代码块的表示. switch语法格式: switch选择结构用到了四个关键字 : >switch:表示"开关"这个开关就是switch关键字后面小括号里的表达式的值,jdk1.7后,switch语句小括号里面可以是 int .short .byte .char .枚举.S

java基础---选择结构(一)

1.什么是if选择结构? 可以处理单一或组合条件的情况(if选择结构是根据条件判断之后再做处理) 基本的if选择结构 if ( 条件 ) { //代码块 } 条件必须是boolean值举例 import java.util.Scanner; public class GetPrize { public static void main(String[] args) { Scanner input = new Scanner(System.in); System.out.print("请输入一个

java基础：流程控制（选择结构switch语句）

(1)格式: switch(表达式) { case 值1: 语句体1; break; case 值2: 语句体2; break; ... default: 语句体n+1; break; } 格式解释说明: switch:说明这是switch语句. 表达式:可以是byte,short,int,char JDK5以后可以是枚举 JDK7以后可以是字符串 case:后面的值就是要和表达式进行比较的值 break:表示程序到这里中断,跳出switch语句 default:如果所有的情况都不匹配,就执行这