Java笔记 Day03

1、运算符演示

注意：1、整数的除法运算，不会产生小数
2、如果要让运算结果是小数，那么参与运算的数据至少一个是浮点型的
（和直接将结果转成浮点型的比较）
3、+ 作为连接符使用时，和字符串相连任何数据都变成字符串
4、为了提高程序的易读性，强制使用（）提高优先级

++
--
num++;先使用再自增
++num;先自增再使用
在原数字上进行增1或减1操作

class Opt00
{
    public static void main(String[] args){
        int num1 = 10;
        int num2 = 4;
        //-----------------------------------
        int result1 = num1 + num2;
        System.out.println(result1);
        int result2 = num1 - num2;
        System.out.println(result2);
        int result3 = num1 * num2;
        System.out.println(result3);
        int result4 = num1 / num2;//只是取商，即2
        System.out.println(result4);

        int result5 = num1 % num2;//只是取余，即余数2
        System.out.println(result5);
        
        //如何使商是精确地小数2.5？------------------------------
        double result6 = (double)(num1 / num2);//结果是2.0 实际它只是将num1/num2的商2强转成浮点型2.0
        System.out.println(result6);
        double result7 = (double)num1 / num2;//正确，即将num1转成double型的再与int型的num2相除结果默认double型的
        System.out.println(result7);

        //用小括号提升运算优先级
        int result8 = (4 + 6) / 3;
        System.out.println(result8);

        // + 法 ----  还可以作为连接符

        System.out.println("10 + 4 = " + result1);

        //注意：若num1、num2对应的值换成其他值了这时打印结果10+4=是不变的但result1的值变了。如将num2改成5后就是10+4=15
        //解决：
        System.out.println(num1 + " + " + num2 + " = " + result1);//这样输出结果就会随num2、num1的变化而变化
        System.out.println("-------------------------------------------");
        System.out.println(num1 + " + " + num2 + " = " + num1 + num2);//错误(10+4=104); 在这里+作为连接符只是将字符串连接起来而已
        System.out.println(num1 + " + " + num2 + " = " + (num1 + num2));//正确(10+4=14)；小括号提升了优先级先运算num1+num2的值再进行连接
        System.out.println(num1 + " * " + num2 + " = " + num1 * num2);//这时不需要用小括号，因为*优先级大于+的优先级先运算*再连接
        //System.out.println(num1 + " - " + num2 + " = " + num1 - num2);//报错
        System.out.println(num1 + num2 + " = " + num1 + " + " + num2);//14=10+4 注意：读取时从左向右，先做加法运算再向右读时发现字符串则从此往后的所有数据都是字符串
        System.out.println(num1 - num2 + " = " + num1 + " - " + num2);//6=10-4
        System.out.println("----------------------------------------");
        int num3 = 1;
        //num3++;
        ++num3;//++放在前面或后面此时的结果都一样
        System.out.println("num3 = " + num3);
        int num4 = 1;
        System.out.println("num4 = " + num4++);//1（++在后面先使用在自增，即先使用num4=1打印出1在自增变为num4=2）
        System.out.println("num4 = " + num4);//2(在上一条语句中num4=2所以输出2)
        System.out.println("num4 = " + ++num4);//3 (先自增再使用，即上一条语句num4=2自增后为3所以打印出3)

    }
}

2、赋值运算符

从右向左运行
num1 += num2;即num1 = num1 + num2; -= *= /= 同理

注意：当参与运算的数据类型 <= int时，会默认向下强转

class Opt01
{
    public static void main(String[] args){
        int num1 = 1;
        int num2 = 2;
        //int sum = num1 + num2;
        //num1 = num1 + num2;

        num1 += num2;// num1 = num1 + num2;
        num1 *= num2;// num1 = num1 * num2;
        System.out.println("num1 = " + num1);

        System.out.println("----------------------------");
        short s1 = 1;
        //s1 = s1 + 1;//报错
        s1 += 1;//合法，此时系统默认向下强转 即s1 = (short)(s1 + 1);
        System.out.println("s1 = " + s1);
    }
}

3、比较运算符

class Opt02
{
    public static void main(String[] args){
        int num1 = 10;
        int num2 = 5;
        boolean b = num1 == num2;
        System.out.println(num1 + " == " + num2 + "?" + b);
        System.out.println(num1 + " != " + num2 + "?" + (num1 != num2));
        System.out.println(num1 + " > " + num2 + "?" + (num1 > num2));
        System.out.println(num1 + " < " + num2 + "?" + (num1 < num2));
        System.out.println(num1 + " >= " + num2 + "?" + (num1 >= num2));
        System.out.println(num1 + " <= " + num2 + "?" + (num1 <= num2));
    
    }
}

4、逻辑运算符

参与运算与产生的结果都是boolean型的
& 与---->一个为false 结果就是false
| 或---->一个为true 结果就是true
! 非---->取反
^ 亦或---->同真为假，同假为真，一真一假为真

&& ----> 使用结果与 & 无区别 ---->底层实现细节不同
|| ----> 使用结果与 | 无区别
& ----->1、判断时，如果有多个表达式，那么每个都进行运算
2、与运算只要有一个false,就为false

问题：

当有一个为false时，结果就是false,其余表达式没必要运算。用&效率低

解决：

使用 &&
&& ----> 又称为短路与 ----> 使用&& 有一个false,就直接返回结果 效率高
|| ----> 又称为短路或 ----> 使用|| 有一个true,就直接返回结果 效率高

建议以后使用 && ||

class Opt03
{
    public static void main(String[] args){
        boolean b1 = true;
        boolean b2 = true;
        boolean b3 = false;
        boolean b4 = false;

        //boolean b1 = true, b2 = true, b3 = false, b4 = false;//合法，但可读性低，不建议这样写

        boolean result1 = b1 & b2;
        System.out.println(b1 + " & " + b2 + " = " + result1);
        System.out.println(b1 + " & " + b3 + " = " + (b1 & b3));
        System.out.println(b3 + " & " + b4 + " = " + (b3 & b4));

        System.out.println(b1 + " | " + b2 + " = " + (b1 | b2));
        System.out.println(b1 + " | " + b3 + " = " + (b1 | b3));
        System.out.println(b3 + " | " + b4 + " = " + (b3 | b4));

        System.out.println("!true = " + !true);
        System.out.println("!false = " + !false);
        System.out.println("---------------------------------");

        System.out.println(b1 + " ^ " + b2 + " = " + (b1 ^ b2));
        System.out.println(b1 + " ^ " + b3 + " = " + (b1 ^ b3));
        System.out.println(b3 + " ^ " + b4 + " = " + (b3 ^ b4));

        int b5 = 1;
        int b6 = 1;
        int b7 = 2;
        int b8 = 3;

        boolean result2 = b5 == b7 & b7 == b8;//&的两边都会进行运算
        System.out.println(result2);
        //             false  &   false

        boolean result3 = b5 == b7 && ++b5 == b6;//(使用&&运算符时左边b5==b7是错误的这时就不再向右运算直接得出false)
        System.out.println("b5 = " + b5);//b5 = 1而不是b5=2,因为&&前面的已经得出false不再向右进行
        boolean result4 = b5 == b7 & ++b5 == b6;//&的左右两边都要运算，即使左边已是false此时可以得出答案还是会把右边运算完
        System.out.println("b5 = " + b5);//b5 = 2 因为右边的还会继续运算
        

    
    }
}

5、位运算符

分析：
传统运算，在计算机底层实现，运算量比较大
所以出现了位运算符
2 * 2 ----> bit左移一位即可

3 * 10 ---> 30
3 * 100 --> 300

1 * 2 ----> 10
1 * 4 ----> 100
1 * 8 ----> 1000

右移：>>      无符号右移：>>>
无符号右移的作用：
1、如果是正数和右移没什么区别
如果是负数变整数
2、效率考虑 ---- 正数情况下，无符号右移效率高
3、使用时，整数的右移尽量使用无符号右移
4、负数一般不用无符号右移

0为false  1为true

位运算符：
1、位运算符运算的是二进制位
2、0 f  1 t
3、类似于逻辑运算

一个数字连续^同一个数字两次，返回仍然是自身

class Opt04
{
    public static void main(String[] args){
        //左移：左移n位，就是 *2^n
        //左移就是追加n个0，前面的舍弃

        int num = 3;
        int result = num << 3;
        System.out.println("result = " + result);//3 * 8 = 24

        //问题：
        int num1 = 3;
        int result2 = num << 31;
        System.out.println("result2 = " + result2);// -2147483648

        //右移：右移n位，就是 /2^n
        //1、最右边的n位舍弃
        //2、前面根据标志位补，如果是0 补0 是1 补1

        int num2 = 16;
        int result3 = num2 >> 2;
        System.out.println("result3 = " + result3);// 4

        //无符号右移，统统补0

        int num3 = -16;
        int result4 = num3 >>> 2;//预期 -4
        System.out.println("result4 = " + result4);// 1073741820

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

        int num4 = 8;
        int num5 = 9;
        int result5 = num4 & num5;
        System.out.println("result5 = " + result5);
        System.out.println("result6 = " + (num4 | num5));
        System.out.println("result7 = " + (num4 ^ num5));
        System.out.println("result7 = " + ~num4);

        //^的使用
        System.out.println(num4 ^ num5 ^ num5);
        System.out.println(122 ^ 7 ^ 7);
        System.out.println(120 ^ 9 ^ 9);
        System.out.println(12 ^ 110 ^ 110);

    }
}

6、注意：

1、使用（）提升优先级
2、char类型可以参与运算

class Opt05
{
    public static void main(String[] args){
        //数据类型 result = 布尔表达式 ？ 结果1 ： 结果2;
        //结果1是布尔表达式为true时返回，结果2是false时返回
        int num1 = 1;
        int num2 = 2;
        char result = num1 > num2 ? '是' :'否';
        System.out.println("result = " + result);
        System.out.println("------------------------------");
        char c1 = 'A';
        int result2 = c1 + 1;
        System.out.println("result2 = " + result2);
        
    }
}

7、键盘录入

import java.util.Scanner;
class Opt06
{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数据");
        int num = scanner.nextInt();//程序挂起，等待键盘输入---注意输入的类型
        //
        System.out.println("您输入的数字 = " + num);
        System.out.println("请输入文本");
        String text = scanner.next();
        System.out.println("您输入的文本 = " + text);
    }
}

8、条件语句

选择执行的if:
格式1：if（条件表达式）
执行代码

注意：1、以后代码格式：
if（条件表达式）{
        执行代码
}
2、if（条件表达式）
        执行代码
    执行代码格式：
    A、单条语句 ----- 容易造成代码误读
    B、块语句 ------- {} ---提高程序的易读性和易维护性
    C、带标签的块语句
编码规范：
    1、只跟块语句
    2、如果非要跟单条语句
        格式：if（条件表达式）code;

import java.util.Scanner;
class FlowPath00
{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个数字:");
        int num = scanner.nextInt();
        if(num > 0){
            System.out.println(num + "是正数");
        }
        if(num == 0){
            System.out.println(num + "是0");
        }
        if(num < 0){
            System.out.println(num + "是负数");
        }
    }
}

1、当if判断时，结果不是true就是false
2、如果使用两次if，判断两次，资源浪费
3、使用 if else

格式：
if（条件表达式）{
    code;
} else {
    code;
}

class FlowPath01
{
    public static void main(String[] args){
        int num1 = 1;
        int num2 = 2;

        /*if(num1 - num2 > 0){
            System.out.println("num1比num2大");
        }
        if(num1 - num2 <= 0){
            System.out.println("num1不比num2大");
        }*/
        if(num1 - num2 > 0){
            System.out.println("num1比num2大");
        } else {
            System.out.println("num1不比num2大");
        }
    }
}

格式三：
if（条件表达式）{
code
}else if（条件表达式）{
code
}else if（条件表达式）{
code
}else if（条件表达式）{
code
}else {
code
}
注意：只要有一个符合条件，其余都不执行

判断一个数字是正数负数还是0

import java.util.Scanner;
class FlowPath02
{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个数字");
        int num = scanner.nextInt();
        /*if (num < 0){
            System.out.println(num + "是负数");
        }else if(num == 0){
            System.out.println(num + "是0");
        }else {
            System.out.println(num + "是正数");
        }*/
        if (num < 0){
            System.out.println(num + "是负数");
        }else if(num == 0){
            System.out.println(num + "是0");
        }else if(num < -10){
            System.out.println("num小于-10");//输入-100运行结果是-100是负数而当前这条语句不执行（前面有符合条件的其余的都不执行）
        }else {
            System.out.println(num + "是正数");
        }
    }
}

class FlowPath03
{
    public static void main(String[] args){
        int num1 = 1;
        int num2 = 2;
        int result = num1 > num2 ? num1 : num2;
        System.out.println("result = " + result);

        //定义一个接收的数据
        int max;
        if(num1 > num2){
            max = num1;
        }else{
            max = num2;
        }
        System.out.println("max = " + max);
        //--------------------------------------------
        if(num1 > num2){
            System.out.println("max = " + num1);
        }else{
            System.out.println("max = " + num2);
        }
    }
}

判断一个数据是否属于一个区间，常规的数学格式 60 <= score < 70 非法

正确格式：score >= 60 && score < 70

import java.util.Scanner;
class FlowPath04
{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个成绩：");
        int score = scanner.nextInt();
        if(score >= 0 && score < 60){
            System.out.println("不及格");
        } else if(score >= 60 && score < 70){
            System.out.println("及格");
        }else if(score >= 70 && score < 80){
            System.out.println("一般");
        }else if(score >= 80 && score < 90){
            System.out.println("良好");
        }else if(score >= 90 && score <=100){
            System.out.println("优秀");
        }else {
            System.out.println("非法数据");
        }
    }
}

switch（数据）{
case 常量1：
code
break;
case 常量2：
code
break;
.......
default:
code
break;

}

注意事项：
1、使用的数据类型：byte short int char -------(int型)
enum(枚举) string ------字符串
2、case后必须是常量
3、规范：break必须加，除非极特殊情况
4、default可以用也可以不用
5、default位置无所谓 ----都是最后执行
6、default如果在最后，可以不使用break

import java.util.Scanner;
class FlowPath05
{
    public static void main(String[] args){
        /*String str1 = "ABC";
        String str2 = "DEF";
        String str = "ABC";
        switch(str){
            case str1:  -----------非法的
                System.out.println("ABC");
            break;
            case str2:
                System.out.println("DEF");
            break;
        }*/
        /*String str = "ABC";
        switch(str){
            case "ABC":
                System.out.println("ABC");
            break;
            case "DEF":
                System.out.println("DEF");
            break;
        }*/
        /*long l = 1L;
        switch((int)1){
            case 1:
                System.out.println("A");
            break;
            case 2:
                System.out.println("B");
            break;
        }*/
        Scanner scanner = new Scanner(System.in);
        int level = scanner.nextInt();
        switch(level){
            case 1:
                System.out.println("初级");
            break;
            case 2:
                System.out.println("中级");
            break;
            case 3:
                System.out.println("高级");
            break;
            default:
                System.out.println("非法数据");
            break;
        }
        char c = 'A';
        switch(c){
            case 'A':
                System.out.println("A");
            break;
            case 'B':
                System.out.println("B");
            break;
        }
    }
}

需求：根据输入的月份查找季节
switch case 和if else 比较：
1、if else ------更常用
2、if else 适应性更广 ---- 区间判断，if else 更适合
3、switch case 效率更高
移动端开发，比如游戏：选择少，效率要求高使用switch case

import java.util.Scanner;
class FlowPath06
{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        int month = scanner.nextInt();
        if(month >= 3 && month <= 5){
            System.out.println("春季");
        } else if(month >= 6 && month <= 8){
            System.out.println("夏季");
        } else if(month >= 9 && month <= 11){
            System.out.println("秋季");
        } else if(month >= 1 && month <= 2 || month ==12){
            System.out.println("冬季");
        } else {
            System.out.println("非法数据");
        }
        /*switch(month){
                case 1:
                System.out.println("冬季");
                break;
                case 2:
                System.out.println("冬季");
                break;
                case 3:
                System.out.println("春季");
                break;
                case 4:
                System.out.println("春季");
                break;
                case 5:
                System.out.println("春季");
                break;
                case 6:
                System.out.println("夏季");
                break;
                case 7:
                System.out.println("夏季");
                break;
                case 8:
                System.out.println("夏季");
                break;
                case 9:
                System.out.println("秋季");
                break;
                case 10:
                System.out.println("秋季");
                break;
                case 11:
                System.out.println("秋季");
                break;
                case 12:
                System.out.println("冬季");
                break;
                default:
                System.out.println("非法数据");
                break;     // -----方式一


                
                case 3:
                case 4:
                case 5:
                System.out.println("春季");
                break;
                case 6:
                case 7:
                case 8:
                System.out.println("夏季");
                break;
                case 9:
                case 10:
                case 11:
                System.out.println("秋季");
                break;
                case 12:
                case 1:
                case 2:
                System.out.println("冬季");
                break;
                default:
                System.out.println("非法数据");
                break;// ------方式二 

        }*/
    }
}

练习

class Test00
{
    public static void test01(){
        System.out.println('a');//a
        System.out.println('a'+1);//98 --- 字符参与运算，自动转型 --->字符本质就是数字

        System.out.println("hello"+'a'+1);//helloa1 --->字符串与任意数据相连都变成字符串
        System.out.println('a'+1+"hello");//98hello --->同优先级，从左到右
        System.out.println("5+5="+5+5);//5+5=55
        System.out.println(5+5+"=5+5");//10=5+5
    }
    public static void main(String[] args){
        test01();
    }
}

class Test01
{
    public static void main(String[] args){
        int num1 = 10;
        int num2 = 20;
        //1、三元运算符
        int max = num1 > num2 ? num1 : num2;
        System.out.println("max = " + max);
        //2、if else
        int max2;
        if(num1 > num2){
            max2 = num1;
        } else {
            max2 = num2;
        }
        System.out.println("max2 = "+max2);
        //---------------三个数字比较------------------------
        
        int num3 = 10;
        int num4 = 100;
        int num5 = 50;
        //1、三元运算符
        //获取前两个数中的大的
        int max3 = num3 > num4 ? num3 : num4;
        //和第三个比较
        int max4 = max3 > num5 ? max3 : num5;
        System.out.println("max4 = " + max4);
        //方法二：
        int max5 = num3 > num4 ? (num3 > num5 ? num3 : num5) : (num4 > num5 ? num4 : num5);
        System.out.println("max5 = " + max5);
        //----------比较两个数是否相等---------------------------
        
        int num6 = 10;
        int num7 = 20;
        boolean isEquals = num6 == num7;
        System.out.println("isEquals = " + isEquals);
    }
}

获取两个整数中的最大值
输入的数据：两个数 --- 参数
输出的数据：最大值

获取三个整数中的最大值

比较两个整数是否相同
输入的数据：两个数 ---参数
返回的数据：返回true 或false --- boolean

class Test02
{
    public static int max(int num1,int num2){
        //int result = num1 > num2 ? num1 : num2;
        //return result;
        //方式二：
        return  num1 > num2 ? num1 : num2;
    }
    public static boolean isEquals(int num1, int num2){
        //boolean isEquals = num1 == num2;
        //return isEquals;
        //方式二：
        return num1 == num2;
    }
    public static void main(String[] args){
    int max = max(3,4);
    System.out.println("max = " + max);
    boolean isEquals = isEquals(4,4);
    System.out.println("isEquals = " + isEquals);
    }
}

键盘录入两个数据，并对这两个数据求和，输出其结果

import java.util.Scanner;
class Test03
{
    public static void main(String[] args){
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入第一个数字：");
    int num1 = scanner.nextInt();
    System.out.println("请输入第二个数字");
    int num2 = scanner.nextInt();

    int sum = num1 + num2;
    System.out.println(num1 + " + " + num2 + " = " + sum);
    }
}