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

目录

• 数据类型与变量
• • 字面常量
  • 数据类型
  • 变量
  • • 语法格式
    • 整型变量
    • 浮点型变量
    • 字符型变量
    • 希尔型变量
    • 类型转换
    • • 自动类型转换(隐式)
      • 强制类型转换(显式)
      • 类型提升
      • • 不同数据类型的运算
        • 小于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类型的结果。

                

                逻辑或||

                语法规则：表达式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 中唯一的一个 三目运算符, 是条件判断语句的简化写法