day03事例&例题

最新推荐文章于 2024-10-05 12:07:50 发布

qnmdlzg

最新推荐文章于 2024-10-05 12:07:50 发布

阅读量55

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qnmdlzg/article/details/122316364

版权

这篇博客探讨了Java中的数据类型转换，强调在运算过程中byte, short, char会自动提升为int类型，同时提醒注意变量超出表示范围的问题。文章详细介绍了+号的用法，以及前置和后置++、--的区别。此外，还讨论了s+=1与s=s+1的微妙差异。文章进一步阐述了三目运算符的结果数据类型规则，并深入讲解了位运算符（&、|、^、~）及移位运算符（<<、>>、>>>），解释了它们的运算原理和应用。" 121327477,1005481,QT图片识别实战教程,"['图像处理', 'QT开发', 'OCR技术', 'C++编程', '软件开发']

摘要由CSDN通过智能技术生成

数据类型转换

public class DataTypeDemo3 {
    public static void main(String[] args) {

        byte b = 3;
        int a = 4;

        //自动类型转换
//        a = b;
//        b = a;

//        int i = 10;
//        long l = i;

        //强制类型转换
//        byte b1 = a;
        byte b1 = (byte) a;
        System.out.println(a);



    }
}

注意 byte,short,char在参与运算的时候会自动提升到int类型

/*
        面试题
            byte b1=3,b2=4,b;
            b=b1+b2;
            b=3+4;
            哪句是编译失败的呢？为什么呢？

      变量相加和常量相加不一样：
        1、变量相加首先会提升数据类型，然后再相加赋值，如果接收的数据类型范围小于计算结果后的数据类型范围，报错，不能赋值
        2、常量相加，会先进行计算，计算完后看看在不在接收的数据类型范围内，如果在，直接赋值，如果不在，报错。

 */
public class DataTypeDemo4 {
    public static void main(String[] args) {
//        int a = 3;
//        byte b = 4;
//        int c1 = a + b;
//
//        byte c2 = (byte)(a + b);
//        System.out.println(c2);

        byte b1=3,b2=4,b;
//        b=b1+b2;
        b=(byte)(b1+b2);
        b=3+4;

    }
}

注意变量超出表示范围

/*
        byte b = 130;有没有问题?如果我想让赋值正确，可以怎么做?结果是多少呢?
            有问题的，因为byte数据类型的范围是在-128~127之间，而130超出了范围。


 */
public class DataTypeDemo5 {
    public static void main(String[] args) {
//        byte b = 130;

        byte b = (byte)130;
        System.out.println(b);  // -126
        b = (byte)131;
        System.out.println(b); //-125

        byte b1 = (byte)300;
        System.out.println(b1); // 44
    }
}

/*
        我们知道数据在计算机种运算的时候是采用补码的形式参数运算的，所以要知道130的补码
        而想要知道补码，就得知道反码，原码，所以得求出130的二进制的表示：
        130的二进制：10000010
        由于整数默认是int类型，所以扩大字节
        130的原码为：00000000 00000000 00000000 10000010
        又由于最高位是0，所以它的原码，反码，补码都一样
        130的补码：00000000 00000000 00000000 10000010
        做截取操作：10000010 这是补码

        已知补码，求原码：
               符号位   数值位
        补码：    1     0000010
        反码：    1     0000001
        原码：    1     1111110

        最终结果为：11111110
        将它换算成十进制就是我们看到的结果：-126



 */

+号的用法

package com.shujia.wyh.day03;

/*
        System.out.println(“hello”+’a’+1);
        System.out.println(‘a’+1+”hello”);
        System.out.println(“5+5=”+5+5);
        System.out.println(5+5+”=5+5”);

        +号的用法：
            1、当加号两边都是数字或者是数字和字符的时候，这时候的+号做的是加法运算
            2、当加号两边其中是字符串的时候，做的是字符串拼接，拼接后是一个新的字符串
            3、字符串与任何数值做加法，做的是字符串拼接，拼接后是一个新的字符串

 */
public class DataTypeDemo7 {
    public static void main(String[] args) {
        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

        //System.out.println("5+5="+5+5); // 5+5=55 我就想先计算后面的5+5怎么办？
        //小括号可以改变运算的顺序优先级
        System.out.println("5+5="+(5+5));
    }
}

++--在前在后的区别

/*
        1:基本小题目
	        int a = 10;
	        int b = 10;
	        int c = 10;

	        a = b++;
	        c = --a;
	        b = ++a;
	        a = c--;
	请分别计算出a,b,c的值

 */
public class OptArithmeticDemo2 {
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        int c = 10;

        a = b++; // a=10  ,b=11  ,c=10
        c = --a; // a=9  ,b=11  ,c=9
        b = ++a; // a=10  ,b=10  ,c=9
        a = c--; // a=9  ,b=10  ,c=8

        System.out.println(a); // 9
        System.out.println(b); // 10
        System.out.println(c); // 8
    }
}

/*
                int a = 4;
                int b = (a++)+(++a)+(a*10);

 */
public class OptArithmeticDemo3 {
    public static void main(String[] args) {
        int a = 4;
        int b = (a++)+(++a)+(a*10);
        //        4     6      60
        //       a=5   a=6    a=6

        System.out.println(a);//6
        System.out.println(b);//70
    }
}

s+=1不完全等于s=s+1

/*
    short s=1, s = s+1;
    short s=1, s += 1;
    上面两个代码有没有问题，如果有，那里有问题
    第一个有问题，因为变量参与运算，首先会提升数据类型，然后做运算。所以 s = s+1;s会提升到int类型然后再做加法运算，最终的
    结果是int类型，所以拿short类型接收会报错，所以要想成功赋值，就得强制类型转换。

    第二个代码没有问题，是因为内部自动包含了强制类型转换，s+=1 ===>  s = (s的数据类型)(s+1)


 */
public class OptFuZhiDemo2 {
    public static void main(String[] args) {
//        short s = 1;
//        s = (short)(s + 1);

        short s = 1;
        s+=1;
        System.out.println(s);
    }
}

注意三目运算符表达式的结果数据类型由三目运算符表达式1和表达式2中最大的数据类型决定的

public class OptSanMuDemo1 {
    public static void main(String[] args) {
        //面试题：int a = 20;double b = 30.0;(a>b)?a:b
        int a1 = 20;
        double b1 = 30.0;
        double c1 = (a1>b1)?a1:b1;
        System.out.println(c1);


    }
}

位运算符&,|,^,~ 注意参与运算的都是补码

public class OptWeiDemo1 {
    public static void main(String[] args) {
        byte a = 3;
        byte b = 4;
        System.out.println(a&b);
        System.out.println(a|b);
        System.out.println(a^b);
        System.out.println(~a); //-4
    }
}
/*
        由于数据在计算机中参与运算的都是补码，而想要知道补码，就得知道反码，原码，就得求出二进制
        3的二进制：00000011
        4的二进制：00000100
        又由于3和4都是正数
        3的补码：00000011
        4的补码：00000100

        & 运算：有0则0
            00000011
         &
            00000100
        ---------------
            00000000

        结果是 ： 0

        ====================================

        | 运算：有1则1
            00000011
         |
            00000100
        --------------
            00000111

        结果是：7

        ====================================

        ^ 运算：相同则0，不同则1
            00000011
         ^
            00000100
        --------------
            00000111

        结果是：7

        ====================================

        ~ 运算：1变成0，0变成1
            00000011
        ~
        -------------
        补码：     11111100
        已知补码求原码：
        反码：     11111011
        原码：     10000100

        结果是：-4

 */

位运算符<<,>>,>>>

a左移b相当于a乘2的b次幂

a右移b相当于a除以2的b次幂

/*
        位运算符：
        <<: 左移，二进制左移，右边用0补齐,多出来的丢弃
        >>: 右移，最左边最高位是0用0补齐，最高位是1就用1补齐，多出来的丢弃。
        >>>: 无符号右移，无论左边最高是0还是1，都用0补齐，多出来的丢弃。

 */
public class OptWeiDemo2 {
    public static void main(String[] args) {
        System.out.println(3<<2); //12 = 3*4 = 3*2^2
        System.out.println(24>>2); //6 = 24/(2^2)
        System.out.println(-24>>2);// -6
        System.out.println(-24>>>2);//1073741818

        System.out.println(3<<3); // 3*2^3


        //请用最有效率的方式写出计算2乘以8的结果
//        System.out.println(2*8);
        System.out.println(2<<3);
    }
}

/*
       <<: 左移，二进制左移，右边用0补齐
       3的二进制：00000000 00000000 00000000 00000011
       由于3是正数，所以原码，反码，补码都一样
       3的补码：00000000 00000000 00000000 00000011
       左移：
            00000000 00000000 00000000 00000011
        (00)00000000 00000000 00000000 00001100   （补码）
      由于最高位是0，既是补码也是原码，所以结果是：  12

      ================================================================
      >>: 右移，最左边最高位是0用0补齐，最高位是1就用1补齐，多出来的丢弃。
      24的二进制：00000000 00000000 00000000 00011000
      由于24是正数，所以原码，反码，补码都一样
      24的补码：00000000 00000000 00000000 00011000
      右移：
              00000000 00000000 00000000 00011000
              0000000000 00000000 00000000 000110(00)  (补码)
      由于最高位是0，既是补码也是原码，所以结果是：6

      ================================================================
      >>: 右移，最左边最高位是0用0补齐，最高位是1就用1补齐，多出来的丢弃。
      -24的二进制：10000000 00000000 00000000 00011000
      已知原码求补码：
        原码：10000000 00000000 00000000 00011000
        反码：11111111 11111111 11111111 11100111
        补码：11111111 11111111 11111111 11101000
      右移：
            11111111 11111111 11111111 11101000
            1111111111 11111111 11111111 111010(00)  (补码)
      已知补码求原码：
        补码：11111111 11111111 11111111 11111010
        反码：11111111 11111111 11111111 11111001
        原码：10000000 00000000 00000000 00000110
        最终结果是：-6

        ==============================================================
        >>>: 无符号右移，无论左边最高是0还是1，都用0补齐，多出来的丢弃。
        -24的二进制：10000000 00000000 00000000 00011000
      已知原码求补码：
        原码：10000000 00000000 00000000 00011000
        反码：11111111 11111111 11111111 11100111
        补码：11111111 11111111 11111111 11101000
        无符号右移2位：
             11111111 11111111 11111111 11101000
             0011111111 11111111 11111111 111010(00)   (补码)
        由于最高位是0，所以它的原码，反码，补码都是一样的。
        最终结果位：0011111111 11111111 11111111 111010 = 1073741818


 */

qnmdlzg

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫