java基础day_02整理

最新推荐文章于 2024-10-01 18:51:18 发布

装着二筒的包

最新推荐文章于 2024-10-01 18:51:18 发布

阅读量38

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/Jtyazs/article/details/132119005

版权

运算符

算术运算符

表达式

定义：指的是用运算符连接起来的式子，比如a>b,a=3,a+b<10

一元运算符
只需要一个数据就可以进行操作的运算符。例如：自增++、自减--、-负号
++ 表示让某个值自身加1
-- 表示让某个值自身减1
++和-- 可以写在变量之前，或者写在变量之后，写法： a++或者++a
++在前和在后面的区别：
1，如果是自身的运算，结果上是没有区别的
2，如果是做混合计算，存在区别
a++ ，先将a参与表达式运算，然后再给自身加1
++a，先给自身加1，然后再参与表达式的运算

int a = 10;
int b = a++; b=10
int c = --b; c=9 b=9
int d = ++c + b++; //d=10 + 9
abcd的值分别为 11 10 10 19

    	//int a = 10;
        //a++;
        //++a;
        //System.out.println(a++);
        //System.out.println(a);
        //System.out.println(++a);

        int a = 10;
        int b = a++;
        int c = --b;
        int d = ++c + b++;
        System.out.println( a + "--" + b + "--" + c + "--" + d);

二元运算符

二元运算符：需要两个数据才可以进行操作的运算符。例如：加法+、赋值=

四则运算 + - * /

求余 %

加法： +

如果是数字类型使用+，那么就是求和

如果是char类型使用+，那么会将char转为对应的数值(ascii码值)参与计算

如果是字符串类型使用+，那么会将后面的内容，拼接到字符串的后面

减法：- 没有特殊的用法，用来给数值求差值

乘法：* 用来给数值求乘积的

除法：/ ，用来给数值求商，整数参与运算后，会将结果的小数部分省略，保留整数部分

求余：% , 用来求两个数值之间的余数

    	int a = 10,b=10;
		System.out.println(a + b);   //20 
        System.out.println('a' + 10); //107
        System.out.println("100" + 10); //10010

        System.out.println(100 / 3);  //33 除法会取整
        System.out.println(2.55 / 1.2);  //2.125 浮点数之间的除法结果仍然是浮点数

        System.out.println(100 % 3); //1   取余数

练习：

有一个随机的五位数数字，例如12325 ，希望这个数字和 10 做运算，得出这个5位数的个十百千万位的值

练习代码如下

  int i =12325;
        int a,b,c,d,e;
        a=i/10/10/10/10;
        b=i/10/10/10%10;
        c=i/10/10%10;
        d=i/10%10;
        e=i%10;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
        System.out.println(e);

关系运算符

（显示结果为 true和false）

关系运算符也可以称为“比较运算符”，用于用来比较判断两个变量或者常量的大小,结果是true或者false

> , >= , < , <= , ==

public class Demo02 {
    public static void main(String[] args) {
        //比较运算符
        //比较变量
        int a = 10, b = 20;
        System.out.println(a > b ); //false
        System.out.println(b > a ); //true
        System.out.println(b >= a); //true

        //比较常量
        System.out.println(a > 5);  //true

        //和多个数值比较
        //System.out.println(5 < a < 20);  //不允许写在一起
        System.out.println(a > 5 && a < 20);

        //== 判断数值是否相等
        //直接比较基本类型
        System.out.println(10 == 10); //true
        System.out.println(a == 10); //true
        System.out.println(a == b);  //false

        System.out.println('a' == 97); //true

        //System.out.println("10" == a);  //字符串不能和基本类型使用==比较

        System.out.println(a % 2 == 0); //true
    }
}

重点

不可以将一个变量同时与多个变量进行比较，需要使用到 &&进行连接
字符串作为引用类型不能和基本数据类型使用 == 来进行数值判断

逻辑运算符

（结果为true或false）

逻辑运算符是把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式,以判断程序中的表达式是否成立,判断结果为true或false

&& 逻辑与(短路与)

|| 逻辑或(短路或)

! 逻辑取反

& 逻辑与

| 逻辑或

下面将对其中部分进行介绍解释

&& 逻辑与（短路与）连接多个表达式，并判断，
当所有表达式都为true时才返回true，否则返回false
&&逻辑与具有短路效果：在&&中前面的表达式如果为真（true）,则不再判断&&后面的
表达式（后面都不再执行），而是直接输出结果true

|| 逻辑或（短路或）连接多个表达式，并判断，
当所有表达式有一个为true时就返回true,所有表达式都false时返回false
|| 逻辑或的短路作用与逻辑与类似：当||连接的表达式中找出第一个值为false的表达式部分时，
直接会输出结果false,不再判断执行后面连接的表达式

！逻辑取反（非）

& 逻辑与，效果与双& 即&&的作用相同，
但是没有短路效果（必须执行完连接的所有表达式部分）

| 逻辑或，效果与双| 即 || 的作用相同，
但是没有短路效果（必须执行完连接的所有表达式部分）

下面是各种逻辑运算符部分代码演示


        //逻辑运算符
        //&& 将多个表达式连接起来，如果每个表达式的结果都为true，最终的结果才为true，有短路效果

        int a = 10,b = 20;
        System.out.println(a > 5 && b > 10); //true
        System.out.println(a < 5 && b > 10); //false
        //& 将多个表达式连接起来，如果每个表达式的结果都为true，最终的结果才为true
        System.out.println(a > 5 & b > 10); //true
        System.out.println(a < 5 & b > 10); //false

        //短路效果，&&中，前面的表达式如果是false，后面的表达式就不会执行了
        //a<5 是false，后面的表达式就不计算了，这里的b++没有执行
        System.out.println( a < 5 && b++ > 10);
        System.out.println(b);//20

        System.out.println( a < 5 & b++ > 10);
        System.out.println(b); //21

        // || 逻辑或，如果表达式都为false，结果采为false，有一个为true，最终结果就为true
        System.out.println( a < 5 || b > 10); //true
        System.out.println( a < 5 | b > 10); //true

        //  ||短路效果，前面表达式为true，后面表达式就不计算了
        System.out.println(a > 5 || b++ < 10);
        System.out.println(b);  //21

        // ! 逻辑取反 ，值是true，取反后为false ，值是false，取反后为true
        System.out.println(!(a > 5)); //false
        System.out.println(!true);  //false

位运算符(二进制)

& 位与运算符，连接两个数值进行运算，将数值转成二进制后，按位做运算，如果同时为1，结果为1，否则为0

100&20

0110 0100

0001 0100

0000 0100 4

| 位或运算符，连接两个数值进行运算，将数值转成二进制后，按位做运算，有一位为1，结果为1，否则为0

100 | 20

0110 0100

0001 0100

0111 0100 116

^位异或运算符，连接两个数值进行运算，将数值转成二进制后，按位做运算，位不同为1，位相同为0

100 ^20

0110 0100

0001 0100

0111 0000 112

~位取反运算符，只对一个数值进行运算，将数值转成2进制后，对补码进行运算，运算完之后，再将补码变回原码

正数的原码、反码、补码都是一样的

~100

原码0110 0100

取反1001 1011

减1 1001 1010

符号位不变取反 1110 0101 ==> -101

~-100

原码1110 0100

反码1001 1011

补码(反码+1) 1001 1100

补码取反 0110 0011 99

位移运算符(二进制)

把数值，转为二进制后，往左或者往右移动指定的位数

>> 右移位运算符

<< 左位移运算符



import java.util.HashMap;

public class Demo04 {
    public static void main(String[] args) {
        System.out.println(100 & 20);
        System.out.println(100 | 20);
        System.out.println(100 ^ 20);
        System.out.println(~100);
        System.out.println(~-100); //99

        int i = 200;
        // 1100 1000   int类型的是32位，前面都是0，符号位0表示正数，1表示负数
        //200转为byte类型后，byte只有8位，1100 1000  只被保留8位，第一位就被当做符号位
        //1100 1000 除符号位外，做取反 +1
        //10110111 +1 = 10111000   ==>-56
        System.out.println((byte)i); //-56


        //位移运算
        //0000 0010  往左移 4位  0010 0000 32
        System.out.println(2 << 4);  // 2 * 2^4

        //右位移运算符
        //0010 0000   往右移2位 ==>  0000 1000  8
        System.out.println(32 >> 2);  // 32 / 2^2

    }

总结：

左右位移公式

数字a向左左移几位就是 a * 2^移动次数

例如:

左移
2 << 4
把 2转成二进制然后整体向左移

简单计算：2*2^4 = 2*16 = 32

右移与左移类似，即被移动的数 / （除以）2^被移动的次数

下面是部分代码演示



import java.util.HashMap;

public class Demo04 {
    public static void main(String[] args) {
        System.out.println(100 & 20);
        System.out.println(100 | 20);
        System.out.println(100 ^ 20);
        System.out.println(~100);
        System.out.println(~-100); //99

        int i = 200;
        // 1100 1000   int类型的是32位，前面都是0，符号位0表示正数，1表示负数
        //200转为byte类型后，byte只有8位，1100 1000  只被保留8位，第一位就被当做符号位
        //1100 1000 除符号位外，做取反 +1
        //10110111 +1 = 10111000   ==>-56
        System.out.println((byte)i); //-56


        //位移运算
        //0000 0010  往左移 4位  0010 0000 32
        System.out.println(2 << 4);  // 2 * 2^4

        //右位移运算符
        //0010 0000   往右移2位 ==>  0000 1000  8
        System.out.println(32 >> 2);  // 32 / 2^2

    }
}

赋值运算符

= , += , -= , *= ,/= ,%=

int a = 10; 将10 赋值给a这个变量

public class Demo05 {
    public static void main(String[] args) {
        //赋值运算符
        //+=  -=  *=   /=  %=
        //a += 2;  表示  a = a + 2;
        int a = 10;
        a += 5;  // a = a + 5;  =左边的a，表示a这个变量名， =右边的a，表示找上面的a变量带入到这里
        System.out.println(a);  //15
        a -= 5; // a = a - 5;
        System.out.println(a); // 10
        a *= 5;  // a = a * 5
        System.out.println(a); // 50
        a /= 5;  //a = a/5;
        System.out.println(a); //10
        a %= 3;  //a = a%3;
        System.out.println(a);//1
    }
}

三元运算符(三目运算符)：嵌套使用

语法：变量 = 表达式？值1 : 值2;

如果前面的表达式的结果是true，最终的变量的结果就是值1，

如果是false，变量的结果就是值2

演示案例代码如下

public class Demo06 {
    public static void main(String[] args) {
        //三元运算符
        //声明一个变量a = 10， 声明一个变量b，如果a > 20 ,那么b 的值就等于a，否则b的值就等于20
        int a  = 10;
        int b;
        b = a > 20 ? a : 20;
        System.out.println(b);

        //价格的计算，如果购买物品价格超过了500，那么结算总价就打9折，否则就按原价结算
        int price = 600;
        double total = price > 500 ? price * 0.9 : price;
        System.out.println(total);

        //定义 x = 10, y = 20 ,z = 30 ,使用三元表达式，找出abc中的最大值
        int x = 10,y = 20, z = 30;
        int max = x > y ? x : y;
        max = max > z ? max : z;
        System.out.println(max);

         max = (x > y ? x : y) > z ? (x > y ? x : y) : z;
        System.out.println(max);
    }
}

Scanner(键盘录入)

Scanner 是一个已经被系统定义好的类，用于接收用户的输入，用来进行接下来的赋值与计算等操作。并不需要我们额外去定义，而只需要导入使用。因为类似于Scanner这样的系统方法类被封装在各种跑包内，所以在使用前需要先导入所在的jar包。导入jar包语法为 import 包所在路径 .包名

使用步骤：

1，导包

import java.util.Scanner;

2，创建对象

Scanner sc = new Scanner(System.in);

3，使用对象scanner调用方法,并把输入的值赋值给定义好的变量a

int a = scanner.nextInt();

代码演示如下

import java.util.Scanner;

public class Demo07 {
    public static void main(String[] args) {
        //创建Scanner类的对象（变量）
        //语法 ： 类型  变量名 = 值;
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个数字a:");
        //使用对象scanner调用方法,并把输入的值赋值给变量
        int a = scanner.nextInt();
        System.out.println("请输入一个数字b:");
        //使用对象scanner调用方法,并把输入的值赋值给变量
        int b = scanner.nextInt();

        System.out.println("输入的两个数字的和是:" + (a + b));

//这里输出语句里的 a+b要加括号，不然会被系统当成与前面的字符串做操作，进行字符串拼接


    }
}