图灵日记之java奇妙历险记--数据类型与变量&&运算符

03-10 1292阅读

目录

  • 数据类型与变量
    • 字面常量
    • 数据类型
    • 变量
      • 语法格式
      • 整型变量
      • 浮点型变量
      • 字符型变量
      • 希尔型变量
      • 类型转换
        • 自动类型转换(隐式)
        • 强制类型转换(显式)
        • 类型提升
          • 不同数据类型的运算
          • 小于4字节数据类型的运算
          • 字符串类型
          • 运算符
            • 算术运算符
            • 关系运算符
            • 逻辑运算符
              • 逻辑与&&
              • 逻辑或||
              • 逻辑非!
              • 短路求值
              • 位运算符
                • 按位与&
                • 按位或 |
                • 按位取反 ~
                • 按位异或^
                • 移位运算
                • 条件运算符

                  数据类型与变量

                  字面常量

                  看下面这个栗子,宝子们

                  System.out.println("cheer up!!!");
                  

                  输出的"cheer up!!!"就是字面变量

                  字面常量的值在程序的整个生命周期中是不变的

                  字面常量的分类:

                  字符串常量

                  整形常量

                  浮点数常量

                  字符常量

                  布尔常量:只有两种true和false

                  空常量

                  注意:字符串,整形,浮点型,字符型以及布尔型,在java中都被叫作数据类型

                  数据类型

                  java中数据类型主要分为两类:基本数据类型和引用数据类型

                  基本数据类型有四类八种:

                  1. 四类:整型、浮点型、字符型以及布尔型
                  2. 八种:

                    字节型 byte 1字节

                    短整型 short 2字节

                    整型 int 4字节

                    长整型 long 8字节

                    单精度浮点数 float 4字节

                    双精度浮点数 double 8字节

                    字符型 char 2字节

                    布尔型 boolean

                    整型和浮点数都是带符号的

                    整型默认为int型,浮点型默认为double

                  变量

                  语法格式

                  数据类型 变量名 = 初始值

                  整型变量

                  分类:整型变量,长整型变量,短整型变量,字节型变量

                  注意:长整型初始值后面加L或者l,建议L,避免l长得太像1混淆

                  浮点型变量

                  包括单精度浮点型和双精度浮点型

                  和c语言一样,浮点数使用有限空间表示必然存在误差,浮点数是近似值不是精确值

                  字符型变量

                  宝子们目光向这里看

                  public class test
                  {
                      public static void main(String[] args) {
                          System.out.println("启动");
                          System.out.println("시동");
                          System.out.println("Ініціювати");
                      }
                  }
                  

                  计算机里的字符本质是一个整数,c语言使用的ASCII码表示字符,为了扩充更多的字符,采用unicode表示字符,一个字符占用2字节

                  有兴趣可以查询Java char 型了解一下

                  希尔型变量

                  布尔类型用来判断真假

                  public class test
                  {
                      public static void main(String[] args)
                      {
                          boolean a = true;
                          System.out.println(a);
                      }
                  }
                  

                  与c语言不一样,java的布尔类型就是true表示真,false表示假,而并非像c语言当中的非0表示真,0表示假,boolean与int类型不存在转换关系

                  在java虚拟机规范中并未明确规定boolean占几个字节

                  类型转换

                  public class test
                  {
                      public static void main(String[] args)
                      {
                          int a = 10;
                          long b = 2;
                          b = a;
                      }
                  }
                  
                  自动类型转换(隐式)

                  如上图,数据范围小(int类型)的a赋值给b时,要转化为数据范围更大的long类型,这个过程会自动进行,比如int是个小盆子,long是个水缸(容量比小盆子大),int里的水倒入水缸里肯定不会溢出,但是倒过来就不行了,因为变量的值在编译过程是未知的,可能很大,你把水缸的水倒入盆子里就溢出,造成数据丢失了,但如果你非要把水缸里的水倒进盆子里,就要进行强制类型转换了

                  强制类型转换(显式)
                  public class test
                  {
                      public static void main(String[] args)
                      {
                          int a = 10;
                          long b = 2;
                          b = a;
                          a = (int)b;
                      }
                  }
                  

                  依旧是上图,非要把水缸里的水倒进盆子里的强硬做法,确实霸道(强制类型转换,可能会造成数据丢失)

                  注意:进行强制类型转换不一定会成功,毫不相干的类型是不能相互转换,比如Boolean与int类型转换

                  类型提升

                  不同数据类型的运算
                      public static void main(String[] args) {
                          long a = 10;
                          int b = 10;
                          int c = a+b;//报错
                      }
                  

                  如图,数据类型小的和数据类型大的运算时,a是long类型属于数据类型大的,b是int类型属于数据类型小的,两者在进行运算时,会把小类型(数据类型小的类型,往后不说了)提升为与大类型,也就是把b的int类型提升为long类型,然后与b进行运算,所以结果就是long类型,但是你用int类型来接收就达咩,所以要这样

                      public static void main(String[] args) {
                          long a = 10;
                          int b = 10;
                          long c = a+b;
                      }
                  

                  这样接收值就不会造成数据的丢失,但是你要是非常执着于int类型,对数据不管不顾,就是纯爱int,也可以,要这样

                      public static void main(String[] args) {
                          long a = 10;
                          int b = 10;
                          int c = (int)(a+b);
                      }
                  
                      public static void main(String[] args) {
                          long a = 10;
                          int b = 10;
                          int c = (int)a+b;
                      }
                  

                  玩的就是任性

                  小于4字节数据类型的运算
                      public static void main(String[] args) {
                          byte a = 1;
                          byte b = 1;
                          byte c = a+b;//报错
                      }
                  

                  有宝子就要说呀,为啥么相同类型直接的运算也会报错,这就要提到计算机的读取数据了,通常计算机CPU读取数据会按照4字节为单位来读取,也就是提升为int类型来参与计算

                  就图而言,a和b因为自己小于4个字节,非常卑微,经过思想教育提升到了4字节来计算,但是你还用个小盆子c来接收int(4字节)这个水缸就不道德了,就会直接报错,但是你非要用水盆子接收也可以,那就强转呗

                      public static void main(String[] args) {
                          byte a = 1;
                          byte b = 1;
                          byte c = (byte)(a+b);
                      }
                  

                  累了,写着一个强转吧

                  异或这样:

                      public static void main(String[] args) {
                          byte a = 1;
                          byte b = 1;
                          int c = a+b;
                      }
                  

                  小结:

                  1. 不同类型的数据混合运算, 范围小的会提升成范围大的.

                  2. 对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算.

                  字符串类型

                  使用String类定义字符串类型

                      public static void main(String[] args) {
                          String a = "hello";
                          String b = "java";
                          System.out.println(a+b);
                      }
                  

                  有些情况需要字符串和整型数字直接进行转换,后续会补,这里不展开了捏

                  运算符

                  算术运算符

                  1. 基本四则运算符:加减乘除模(+ - * / %)

                  %可以对整型取模.还可以对double类型取模,但是没有意义,一般是对整型取模

                  1. 增量运算符 += -= *= %=
                  		int a = 4;
                          double b = 5.0;
                          a += b;
                          System.out.println(a);
                  

                  在这里,a和b的类型分别是int和double。在这个过程中,与a相加,得到的结果强转为int类型是9。由于a的类型是int,所以结果也是int类型。如果你想要得到9.0,你需要将a的类型改为double

                  1. 自增/自减运算符 ++ –
                      public static void main(String[] args) {
                          int a = 10;
                          a = a++;
                          System.out.println(a);
                      }
                  

                  与c语言不同,此处java的结果是10,而非11,因为c语言中,a=a++的步骤可以分成a = a;a++;

                  两步,这样a的值应该是11,但是java结果是10,此处涉及操作表和局部变量表,但是宝子们可以大致这样理解,int temp = a;(保存原始值)

                  a = a + 1;(执行递增)然后temp的值再赋值给a,所以还是10,

                  关系运算符

                  在C语言中,表达式 5

                  在C语言中,关系运算符的结果是一个整数,要么是1(真),要么是0(假)

                  然而,在Java中,情况是不同的。Java中的比较运算符是不能被链式使用的,因此 5

                  注意:想表达数学表达式5

                  逻辑运算符

                  逻辑与&&

                  语法规则:表达式1 && 表达式2,左右表达式必须是boolean类型的结果。

                  图灵日记之java奇妙历险记--数据类型与变量&&运算符

                  逻辑或||

                  语法规则:表达式1 || 表达式2,左右表达式必须是boolean类型的结果。

                  注意:左右表达式至少有一个为真,则结果为真

                  逻辑非!

                  语法规则: !表达式

                  真变假,假变真

                  短路求值

                      public static void main(String[] args) {
                          System.out.println(21||1/0==0);
                      }
                  

                  &&运算在第一个错误时,将直接判断错误,不会判断第二个条件,因为不会报错,||则是第一个条件正确后,就直接跳出,不判断第二个条件

                      public static void main(String[] args) {
                          System.out.println(21|1/0==0);
                      }
                  

                  如果是&和|就不一样了,他们都会对两个条件进行判断,所以此处会报错

                  位运算符

                  按位与&

                  如果两个二进制位都是 1, 则结果为 1, 否则结果为 0.

                  按位或 |

                  如果两个二进制位都是 0, 则结果为 0, 否则结果为 1.

                  按位取反 ~

                  如果该位为 0 则转为 1, 如果该位为 1 则转为 0

                  按位异或^

                  如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.

                  移位运算

                  1. 左移 : 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)
                  2. 无符号右移 >>>: 最右侧位不要了, 最左侧补 0.

                  条件运算符

                  条件运算符只有一个:

                  表达式1 ? 表达式2 : 表达式3

                  当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值;

                  当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值.

                  也是 Java 中唯一的一个 三目运算符, 是条件判断语句的简化写法

VPS购买请点击我

文章版权声明:除非注明,否则均为主机测评原创文章,转载或复制请以超链接形式并注明出处。

目录[+]