Java学习第三天

已于 2024-09-16 20:12:03 修改
阅读量528 收藏 6
点赞数 19
文章标签： java 学习 开发语言
于 2024-09-16 19:59:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Y_Y1230704/article/details/142264893
版权

目录

1.算数运算符

1.1算数运算符的分类

1.2案例---数值拆分

1.2.1数值拆分公式

1.2.2运行结果

 1.3字符串拼接操作

2.自增自减运算符

 2.1案列：看程序说结果

3.类型转换

3.1隐式转换

 3.2强制转换

3.3类型转换面试题

 4.赋值运算符

 5.关系运算符

6.逻辑运算符

6.1普通逻辑运算符

6.2短路逻辑运算符

 7.三元运算符

7.1执行流程和格式

7.2案例: 求两个整数的最大值 

8.运算符优先级

1.算数运算符

1.1算数运算符的分类

import java.util.Scanner;

public class OperatorDemo1 {
    /*
    算数运算符:
        +
        -
        *
        -------------------
        /:整数相除，结果只能得到整数，想要得到带有小数的结果，需要有小数参与运算
        %:取模，作用是用来取余数的
        问题: 有什么作用？
        回答: %可以进行奇偶数的判断
                    - 任何一个数 % 2的结果，不是0，就是1

     */
    public static void main(String[] args) {
        System.out.println(5/2);//2
        System.out.println(5.0/2);//2.5
        System.out.println(5/2.0);//2.5
        System.out.println(5.0/2.0);//2.5
        System.out.println("---------------");
        System.out.println(5%2); // 5 / 2 = 2...1
        System.out.println(4%2); // 4 / 2 = 2...0

    }
}

1.2案例---数值拆分

需求：键盘录入一个三位数，将数值拆分出个位，十位，百位，随后打印在控制台

import java.util.Scanner;

public class OperatorTeat1 {
    /*
            需求:键盘录入一个三位数，将数值拆分出个位，十位，百位，随后打印在控制台

                数值拆分的公式 :

                      个位:数值 % 10
                      十位:数值 / 10 % 10
                      百位:数值 / 10 / 10 % 10
                      千位:数值 / 10 / 10 / 10 % 10
                      ...
                      对于数值的最高位，简化处理

                      123 : 百位     123/100 --->1
                      1234 : 千位     1234/1000 --->1
                      12345 : 万位     12345/10000 --->1
         */
    public static void main(String[] args) {

        //1.召唤Scanner精灵
        System.out.println("请输入三位数:");
        Scanner sc = new Scanner(System.in);
        //2.指挥精灵，从键盘录入一个整数
        int i = sc.nextInt();
        //3.数值拆分，打印语句
        System.out.println("整数"+i+"的个位数为:"+i%10);
        System.out.println("整数"+i+"的十位数为:"+i/10%10);
        System.out.println("整数"+i+"的百位数为:"+i/100);
    }
}
1.2.1数值拆分公式

1.2.2运行结果

 1.3字符串拼接操作

“贪吃蛇”型拼接：

字符串相当于贪吃蛇，后面的数据自然拼接

public class JoinCharacter {
    public static void main(String[] args) {
        System.out.println(1+23);//24
        System.out.println("年龄为:"+23+1);//231
        System.out.println("年龄为:"+(23+1));//24
        System.out.println(1+99+"年黑马");//100

    }
}

2.自增自减运算符

 自增自减运算符:

       ++ : 让变量自身的值 + 1
       -- : 让变量自身的值 - 1

       1.单独使用 : 一句代码中，只做++，或者--
                   ++，-- 在变量的前面还是后面没有区别

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

       2.参与运算使用:
                   ++ 在前:先自增，再操作
                   --------------------------
                   int a =10;
                   int b =++a;
                   System.out.println("a="+a);//11
                   System.out.println("b="+b);//11

                   ---------------------------
                   ++ 在后 :先操作，再自增
                                 -将该变量原本记录的值提取出来做操作，然后变量再自增
                   int a =10;
                   int b=a++;//b=10,a=11;
                   System.out.println("a="+a);//11
                   System.out.println("b="+b);//10

 2.1案列：看程序说结果

public class OperatorTest2 {
    /*
    看程序，说结果
     */
    public static void main(String[] args) {
        int x = 10;
        int y = x++; //y:10 x:11
        int z = ++y;//y:11 z:11

        System.out.println("x="+x); //11
        System.out.println("y="+y);//11
        System.out.println("z="+z);//11
        System.out.println("====================");
        int a=3;
        //       4   4     5
        int b=(++a)+(a++)+(a*10);
        System.out.println("a="+a);//5
        System.out.println("b="+b);//58


    }
}

3.类型转换

3.1隐式转换

类型转换 - 隐式转换
介绍: 将取值范围小的数据或变量，给取值范围大的变量赋值，可以直接赋值
简单记: 小的给大的，可以直接给

public class TypeConversionDemo1 {
    public static void main(String[] args) {
        int a =10;
        double b = a;
        System.out.println(b);//10.0
        System.out.println(a);//10
    }
}
取值范围小的数据和取值范围大的数据进行运算，小的会先提升为大的之后，再进行运算
public class TypeConversionDemo2 {
    public static void main(String[] args) {
        int a = 10;
        double b = 12.3;
        // int a -->double a
        double c = a+b;
        System.out.println(c);
    }
}
byte short char 三种数据在运算的时候，都会提升为int ,然后再进行运算

public class TypeConversionDemo3 {
    public static void main(String[] args) {
        byte a =10;
        byte b = 20;
        int c = a+b;
        System.out.println(c);

        int aa =1;
        char bb = 'a';//97
        int cc = aa+bb;
        System.out.println(cc);//98
    }
}

 3.2强制转换

类型转换-强制转换
        介绍:把一个 取值范围大的数值或者变量，赋值给另一个取值范围小的变量，
        不允许直接赋值，需要加入强制转换
        格式: 目标数据类型 变量名 = (目标数据类型)被转换的数据;
        注意: 强制转换 [有可能] 会出现精度损失

public class TypeConversionDemo4 {
    public static void main(String[] args) {
        double a = 12.3;
        // 大-->小
        int b = (int) a;
        System.out.println(b);//12 精度损失
        System.out.println("=============");

        int c = 10;
        byte d = (byte)c;
        System.out.println(d);//10 精度不损失
        System.out.println("----------------");

        //进制
        int num1 =130;
        byte num2 =(byte) num1;
        System.out.println(num2);//-126
    }
}

3.3类型转换面试题

public class TypeConversionTest {
    /*
    类型转换面试题 : 下列代码是否存在错误，如果有，请指出说明，并改正

        byte b1 = 3;
        byte b2 = 4;
        byte b3 = b1+b2;

        错误原因 :
                b1和b2是两个byte类型，在运算的时候，会提升为int类型
                提升之后就是两个int类型在运算了，运算的结果还是int
                将int类型的结果，赋值给byte类型，属于大给小，不能直接给

                byte b1=3;
                byte b2=4;
//              int b3 = b1+b2;
                byte b3=(byte)(b1+b2);
                System.out.println(b3);

               byte b = 3+4;
               思考: 为什么不用转换就能通过编译阶段
               Java存在常量优化机制:在编译的时候(javac)就会将3和4是两个字面量进行运算，
               产生的字节码文件 : byte b = 7;
                
                 byte b = 3+4;
        System.out.println(b);//7
     */
    public static void main(String[] args) {
           

    }
}

 4.赋值运算符

注意： 扩展赋值运算符，内部自带强转效果

赋值运算符:
    1.基本赋值运算符
        = : 将符号右侧的数据，赋值给左边的变量
        int num = 10;
    2.扩展赋值运算符

        += : 将符号左右两边的数据，做加法运算，再将结果赋值给左边
        int num = 20;
        num+=10;
        System.out.println(num);//30
        -= : 将符号左右两边的数据，做减法运算，再将结果赋值给左边，
        *= : 将符号左右两边的数据，做乘法运算，再将结果赋值给左边，
        /= : 将符号左右两边的数据，做除法运算，再将结果赋值给左边，
        %= : 将符号左右两边的数据，做取模运算，再将结果赋值给左边，

        细节补充:
                扩展赋值运算符，内部自带强转效果
                short s =1;
                s+=1;// s=(short)(s+1)

                double a = 12.3;
                int b = 10;
                b+=a;   //b=22;
                System.out.println(b);  //22

package com.operator;
public class OperatorDemo1 {
    public static void main(String[] args) {
        int num1 = 20;
        num1+=10;
        System.out.println(num1);//30
        int num2 = 20;
        num2*=10;
        System.out.println(num2);//200
        int num3 = 20;
        num3/=10;
        System.out.println(num3);//2
        int num4 = 20;
        num4%=10;
        System.out.println(num4);//0
    }
}

 5.关系运算符

package com.operator;
public class OperatorDemo2 {
        /*
            关系运算符 (比较运算符) :
                >,>=,<,<=,==,!=
            总结: 让数据之间做比较的符号, 返回true, false
         */
        public static void main(String[] args) {
            System.out.println(10 > 20);        // false
            System.out.println(10 >= 20);       // false
            System.out.println(10 < 20);        // true
            System.out.println(10 <= 20);       // true
            System.out.println(10 == 20);       // false
            System.out.println(10 != 20);       // true
        }
    }

6.逻辑运算符

6.1普通逻辑运算符

逻辑运算符 :
            1. 用于连接boolean类型的表达式, 或者是值
            2. 整合多个条件, 为一段整体的逻辑
分类:
            &(与) : 并且, 遇false, 则false
            场景: 范围性的判断查找
            举例: 键盘录入一个学生成绩, 判断该成绩是否是90~100之间
            伪代码: 不能运行, 仅供理解
            int score = 95;
            如果(score >= 90 & score <= 100){
                    }
            |(或) : 或者, 遇true, 则true
            场景: 多个条件任选其一
            举例: 键盘录入一个学生学号, 学号 3 5 12
            int id = 3;
            如果(id == 3 | id == 5 | id == 12){
                    }
            !(非) : 取反
            场景: 对一段逻辑整体做取反操作
            举例: 键盘录入一个学生学号, 学号除了 3 5 12 都要
            如果(  ! (id == 3 | id == 5 | id == 12)  ){
                    }
            ^(异或) : 相同为false, 不同为true

 

package com.operator;
public class OperatorDemo3 {
    public static void main(String[] args) {
        System.out.println(true & true);//true
        System.out.println(true & false);//false
        System.out.println(false & true);//false
        System.out.println(false & false);//false
        System.out.println("------------------------------");
        System.out.println(true | true);//true
        System.out.println(true | false);//true
        System.out.println(false | true);//true
        System.out.println(false | false);//false
        System.out.println("------------------------------");
        System.out.println(!true);//false
        System.out.println(!false);//true
        System.out.println("------------------------------");
        System.out.println(true ^ true);//false
        System.out.println(true ^ false);//true
        System.out.println(false ^ true);//true
        System.out.println(false ^ false);//false

    }
}

6.2短路逻辑运算符

短路逻辑运算符 :
    & : 没有短路效果, 无论左边是true, false, 右边都要继续执行
    && : 具有短路效果, 左边为false, 右边不执行了
            左边为true, 右边要继续执行
    | : 没有短路效果, 无论左边是true, false, 右边都要继续执行
    || : 具有短路效果, 左边为true, 右边不执行了
            左边为false, 右边要继续执行
---------------------------------------------------
    常用的逻辑运算符:   &&  ||   !

& : 没有短路效果, 无论左边是true, false, 右边都要继续执行 

public static void main(String[] args) {
            int x = 3;
            int y = 4;
            // false
            boolean result1 = ++x > 5 & y-- < 4;
            System.out.println(x);          // 4 左边为false
            System.out.println(y);          // 3 右边执行
            System.out.println(result1);     // false
}

 && : 具有短路效果, 左边为false, 右边不执行了 左边为true, 右边要继续执行

public static void main(String[] args) {
            int x = 3;
            int y = 4;
            // false
            boolean result1 = ++x > 5 && y-- < 4;
            System.out.println(x);          // 4 左边为false
            System.out.println(y);          // 4 右边不执行
            System.out.println(result1);     // false

 7.三元运算符

7.1执行流程和格式

三元运算符 (三目运算符)
    格式:
            判断条件 ? 值1 : 值2; 
    执行流程
            1. 执行判断条件, 看其返回结果是true, false
            2. true : 值1就是最终结果
            3. false : 值2就是最终结果 

public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;
 
        // hold?fish:palm;
 
        int max = num1 > num2 ? num1 : num2;
 
        System.out.println(max);

7.2案例: 求两个整数的最大值 

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num1 = sc.nextInt();
        int num2 = sc.nextInt();
        int num3 = sc.nextInt();
        int tempMax = num1>num2 ? num1:num2;
        int max = tempMax>num3 ? tempMax:num3;
        System.out.println("最大值为:"+max);

8.运算符优先级

        int a = 10;
        int b = 20;
        System.out.println(a<b||a<b&&a>b);
        //运算符优先级 先执行&& 左边为true 右边继续执行 为false 整体为false
        //||运算  a<b为true 整体为true

全栈小精灵
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值