数据类型与变量，以及运算符的大篇章详细内容总结和感受（什么居然有一万多字！！！）

JAVASE--NO.3day(为期三个月的成长过程)

  数据类型与变量，以及运算符的大篇章详细内容总结和感受

1. 字面常量

   1.1什么是常量

      System.Out.println("Hello World") ； 语句，不论程序何时运行，输出的都是 Hello

World ，其实 "Hello World" 就是字面常量。

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello world!");  //这个就是字面常量
    }
}

   1.2字面常量的分类

1. 字符串常量：由 "" 括起来的，比如 “12345”、“hello”、“你好” 。
2. 整形常量：程序中直接写的数字 ( 注意没有小数点 ) ，比如： 100、 1000。
3. 字符常量：由 单引号 括起来的当个字符，比如： ‘A’、 ‘1’。
4. 布尔常量：只有两种 true 和 false 。
5. 浮点数常量：程序中直接写的小数，比如： 3.14、 0.49。

2. 数据类型

   2.1基本数据类型和引用数据类型

       2.11基本数据类型分为四类八种

       1. 四类：整型、浮点型、字符型以及布尔型

       2.八种

注意：

• 不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节
• 整形和浮点型都是带有符号的
• 整型默认为int型，浮点型默认为double
• 字符串属于引用类型

详细笔记在Gitee：https://gitee.com/jing-junhao/java-se/tree/master/%E6%9D%BF%E4%B9%A6 

新问题：这里会有一个新的问题字节是什么？

字节是计算机中表示空间大小的基本单位 .

计算机使用二进制表示数据 . 我们认为 8 个二进制位 (bit) 为一个字节 (Byte).

我们平时的计算机为 8GB 内存 , 意思是 8G 个字节 .

其中 1KB = 1024 Byte, 1MB = 1024 KB, 1GB = 1024 MB.

所以 8GB 相当于 80 多亿个字节 .

3.变量

    3.1变量的概念

     * 对 于这些经常改变的内容，在 Java 程序中，称为变量 。 而数据类型就是用来定义不同种类变量的 。

定义变量的语法格式为： 数据类型 变量名 = 初始值 

public class Test {
    public static void main(String[] args) {
        int a = 10; // 定义整形变量a，a是变量名也称为标识符，该变量中放置的值为10
        double d = 3.14;
        char c = 'A';
        boolean b = true;
        System.out.println(a);
        System.out.println(d);
        System.out.println(c);
        System.out.println(b);
        a = 100; // a是变量，a中的值是可以修改的，注意：= 在java中表示赋值，即将100交给a，a中保存的值就是100
        System.out.println(a);
// 注意：在一行可以定义多个相同类型的变量
        int a1 = 10, a2 = 20, a3 = 30;
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);

    }
}

输出结果如图： 

    3.2整型变量

注意事项：

1.  int不论在何种系统下都是4个字节
2.  推荐使用方式一定义，如果没有合适的初始值，可以设置为0
3.  在给变量设置初始值时，值不能超过int的表示范围，否则会导致溢出
4.  变量在使用之前必须要赋初值，否则编译报错
5.  int的包装类型为 Integer（特殊）

代码如下： 

public class Test {
    public static void main(String[] args) {
        // 方式一：在定义时给出初始值
        int a = 10;
        System.out.println(a);
// 方式二：在定义时没有给初始值，但使用前必须设置初值
        int b;
        b = 10;
        System.out.println(b);
// 使用方式二定义后，在使用前如果没有赋值，则编译期间会报错
//        int c;
//        System.out.println(c);
//        c = 100;
// int型变量所能表示的范围：
        System.out.println(Integer.MIN_VALUE);//-2147483648
        System.out.println(Integer.MAX_VALUE);// 2147483647
// 注意：在定义int性变量时，所赋值不能超过int的范围
      //  int d = 12345678901234; // 编译时报错，初值超过了int的范围
    }

方法二报错： 

   3.3长整型变量

注意事项：

1.  长整型变量的初始值后加L或者l，推荐加L（不然容易将l看成1，所以推荐L）
2.  长整型不论在那个系统下都占8个字节
3.  长整型的表示范围为：-2的63次方 ~ 2的63次方减一
4.  long的包装类型为Long

代码如下： 

public class Test {
    public static void main(String[] args) {
        int a = 10;
        long b = 10; // long定义的长整型变量
        long c = 10L; // 为了区分int和long类型，一般建议：long类型变量的初始值之后加L或者l
        long d = 10l; // 一般更加以加大写L，因为小写l与1不好区分
// long型变量所能表示的范围：这个数据范围远超过 int 的表示范围. 足够绝大部分的工程场景使用.
        System.out.println(Long.MIN_VALUE);//-9223372036854775808
        System.out.println(Long.MAX_VALUE);//9223372036854775807
    }

   3.4短整型变量

注意事项：

1.  short在任何系统下都占2个字节
2.  short的表示范围为：-32768 ~ 32767
3.  使用时注意不要超过范围(一般使用比较少)
4.  short的包装类型为Short

代码如下： 

public class Test {
    public static void main(String[] args) {
        short a = 10;
        System.out.println(a);//输出10
// short型变量所能表示的范围：
        System.out.println(Short.MIN_VALUE);//-32768
        System.out.println(Short.MAX_VALUE);//32767

    }

   3.5字节型变量

注意事项：

1.  byte在任何系统下都占1个字节
2.  byte的范围是：-128 ~ 127
3.  （byte）字节的包装类型为Byte

代码如下： 

public class Test {
    public static void main(String[] args) {
        byte b = 10;
        System.out.println(b);
// byte型变量所能表示的范围：
        System.out.println(Byte.MIN_VALUE);//-128
        System.out.println(Byte.MAX_VALUE);//127

    }

    byte，short，long，int都可以定义整形变量那为什么要给4种不同的类型呢？

因为存在即合理，就如同逛超市，需要什么买什么，不浪费，物尽其用！！！

3.6浮点型变量

   3.61双精度浮点型

注意事项：

1.  double在任何系统下都占8个字节
2.  浮点数与整数在内存中的存储方式不同，不能单纯使用 的形式来计算
3.  double的包装类型为Double
4.  double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势 必会存在一定的精度误差，因此浮点数是个近似值，并不是精确值。

代码如下： 

public class Test {
    public static void main(String[] args) {
        double d = 3.14;
        System.out.println(d);//输出3.14
        int a = 1;
        int b = 2;
        System.out.println(a / b); // 输出 0.5嘛？
        //在 Java 中, int 除以 int 的值仍然是 int(会直接舍弃小数部分)。如果想得到 0.5, 需要使用 double 类型计算.
        double e = 1.0;
        double f = 2.0;
        System.out.println(e / f);//输出0.5
    }

    3.62单精度浮点型

• float 类型在 Java 中占四个字节, 同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数 都优先考虑 double, 不太推荐使用 float.
• float的包装类型为Float。

代码如下：  

public class Test {
    public static void main(String[] args) {
        float num = 1.0f; // 写作 1.0F 也可以
        System.out.println(num);//输出1.0
    }

   3.7字符型变量

1. Java 中使用 单引号 + 单个字母 的形式表示字符字面值.
2.  计算机中的字符本质上是一个整数. 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一个字符占用两个字节, 表示的字符种类更多, 包括中文.
3. char的包装类型为Character

代码如下： 

public class Test {
    public static void main(String[] args) {
        char c1 = 'A'; // 大写字母
        char c2 = '1'; // 数字字符
        System.out.println(c1);
        System.out.println(c2);
// 注意：java中的字符可以存放整形
        char c3 = '张';
        System.out.println(c3);
    }
}

   3.8布尔型变量

1.  boolean 类型的变量只有两种取值, true 表示真, false 表示假.
2.  Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法.
3.  Java虚拟机规范中，并没有明确规定boolean占几个字节，也没有专门用来处理boolean的字节码指令，在 Oracle公司的虚拟机实现中，boolean占1个字节。（当面面试官闻问boolean占几个字节时，可以说没有规定）
4.  boolean的包装类型为Boolean。

public class Test {
    public static void main(String[] args) {
        boolean b = true ;
        System.out.println(b);
        boolean c = false;
        System.out.println(c);
    }

4.类型转换

    在 Java 中，当参与运算数据类型不一致时，就会进行类型转换。 Java 中类型转换主要分为两类：自动类型转换 (隐式) 和 强制类型转换(显式) 。

public class Test {
    public static void main(String[] args) {
        int a = 10;
        long b = 100L;
        b = a; // 可以通过编译
        System.out.println(b);//输出10
        //a = b; // 编译失败 java: 不兼容的类型: 从long转换到int可能会有损失
    }

    4.1自动类型转换(隐式)

1. 自动类型转换即：代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。
2. 特点：数据范围小的转为数 据范围大的时会自动进行。

public class Test {
    public static void main(String[] args) {
        System.out.println(1024); // 整型默认情况下是int
        System.out.println(3.14); // 浮点型默认情况下是double
        int a = 100;
        long b = 10L;
        b = a; // a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值
        System.out.println(b);
        //a = b; // 编译报错，long的范围比int范围大，会有数据丢失，不安全
        float f = 3.14F;
        double d = 5.12;
        d = f; // 编译器会将f转换为double，然后进行赋值
       // f = d; // double表示数据范围大，直接将float交给double会有数据丢失，不安全
        byte b1 = 100; // 编译通过，100没有超过byte的范围，编译器隐式将100转换为byte
       // byte b2 = 257; // 编译失败，257超过了byte的数据范围，有数据丢失
    }

    4.2强制类型转换(显式)  

1. 强制类型转换：当进行操作时，代码需要经过一定的格式处理，不能自动完成。
2. 特点：数据范围大的到数据范围小的。

  public static void main4(String[] args) {
        int a = 10;
        long b = 100L;
        b = a; // int-->long，数据范围由小到大，隐式转换
        a = (int)b; // long-->int, 数据范围由大到小，需要强转，否则编译失败
        float f = 3.14F;
        double d = 5.12;
        d = f; // float-->double，数据范围由小到大，隐式转换
        f = (float)d; // double-->float, 数据范围由大到小，需要强转，否则编译失败
      //  a = d; // 报错，类型不兼容
        a = (int)d; // int没有double表示的数据范围大，需要强转，小数点之后全部丢弃
        byte b1 = 100; // 100默认为int，没有超过byte范围，隐式转换
        byte b2 = (byte)257; // 257默认为int，超过byte范围，需要显示转换，否则报错
        boolean flag = true;
}

注意事项：

1.     不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型
2.     如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失
3.     将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查
4.     强制类型转换不一定能成功，不相干的类型不能互相转换  

类型提升这里提醒一下 ：不同类型的数据之间相互运算时，数据类型小的会被提升到数据类型大的。（int与long之间：int会被提升为long .对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算.  ）

重点如下：

代码演示： 

public class Test {
    public static void main(String[] args) {
        int a = 10;
        long b = 20;
        //int c = a + b; // 编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据
        long d = a + b; // 编译成功：a + b==>int + long--->long + long 赋值给long
        byte e = 10;
        byte f = 20;
        byte g = (byte)(e + f);
        System.out.println(g);//输出30
    }

5.运算符

        作为一门计算机语言， Java 也提供了一套丰富的运算符来操纵变量。 Java 中运算符可分为以下：算术运算符 (+ - * /)、关系运算符 (< > ==) 、逻辑运算符、位运算符、移位运算符以及条件运算符等。

注意：运算符之间是有优先级的. 具体的规则我们不必记忆. 在可能存在歧义的代码中加上括号即可.

   5.1算术运算符

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

public class Test {
    public static void main(String[] args) {
        int a = 3;
        int b = 2;
// 在数学中应该是1.5 但是在Java中输出结果为1 会向下取整，即小数点之后全部舍弃掉了
        System.out.println(a / b);
// 如果要得到数学中的结果，可以使用如下方式
        double d = a*1.0/ b;
        System.out.println(d);//输出1.5
//        int a = 1;
//        int b = 0;
//        System.out.println(a / b)
// 运行结果
   //     Exception in thread "main" java.lang.ArithmeticException: / by zero at Test.main(Test.java:5)
//        int a = 20;
//        int b = 10;
//        double c = 11.5;
//        double d = 2.0;
//        System.out.println(a + b); // 30
//        System.out.println(a - b); // 10
//        System.out.println(a * b); // 200
//        System.out.println(a / b); // 2
//        System.out.println(a % b); // 0 --->模运算相当于数学中除法的余数
//        System.out.println(c % d);//   %  求余数输出  1.5
    }

注意：

1. 都是二元运算符，使用时必须要有左右两个操作数
2. int / int 结果还是int类型，而且会向下取整
3. 做除法和取模时，右操作数不能为0
4. % 不仅可以对整型取模，也可以对double类型取模，但是没有意义，一般都是对整型取模的
5. 两侧操作数类型不一致时，向类型大的提升

   2.增量运算符 += -= *= %= 

• 该种类型运算符操作完成后，会将操纵的结果赋值给左操作数。
• 注意：只有变量才能使用该运算符，常量不能使用。

    public static void main(String[] args) {
        int a = 1;
        a += 2; // 相当于 a = a + 2
        System.out.println(a); // 输出3
        a -= 1; // 相当于 a = a - 1
        System.out.println(a); // 输出2
        a *= 3; // 相当于 a = a * 3
        System.out.println(a); // 输出6
        a /= 3; // 相当于 a = a / 3
        System.out.println(a); // 输出2
        a %= 3; // 相当于 a = a % 2
        System.out.println(a); // 输出2
    }

    3. 自增/自减运算符 ++ --

注意：

1. 如果单独使用，【前置++】和【后置++】没有任何区别
2. 如果混合使用，【前置++】先+1，然后使用变量+1之后的值，【后置++】先使用变量原来的值，表达式 结束时给变量+1
3. 只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改

    public static void main(String[] args) {
        int a = 1;
        a++; // 后置++ 表示给a的值加1，此时a的值为2
        System.out.println(a++); // 注意：后置++是先使用变量原来值，表示式结束时给变量+1，因此输出2
        System.out.println(a); // 输出3
        ++a; // 前置++ 表示给a的值加1
        System.out.println(++a); // 注意：前置++是先给变量+1，然后使用变量中的值，因此输出5
        System.out.println(a); // 输出5
// --操作符给操作-1，与++含义类似
    }

   5.2关系运算符  

   关系运算符主要有六个 : == != < > <= >= ，其计算结果是 true 或者 false 。

   注意：当需要多次判断时，不能连着写，比如：3 < a < 5，Java程序与数学中是有区别的

   

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
// 注意：在Java中 = 表示赋值，要与数学中的含义区分
// 在Java中 == 表示相等
        System.out.println(a == b); // false
        System.out.println(a != b); // true
        System.out.println(a < b); // true
        System.out.println(a > b); // false
        System.out.println(a <= b); // true
        System.out.println(a >= b); // false
    }

   5.3逻辑运算符(重点)  

   逻辑运算符主要有三个 : && || ! ，运算结果都是 boolean 类型。

    5.3.1. 逻辑与 &&

1. 语法规则：表达式1 && 表达式2，左右表达式必须是boolean类型的结果。
2. 相当于现实生活中的且，比如：如果是学生，并且 带有学生证 才可以享受半票。
3. 两个表达式都为真，结果才是真，只要有一个是假，结果就是假

 

  public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a == 1 && b == 2); // 左为真 且 右为真 则结果为真
        System.out.println(a == 1 && b > 100); // 左为真 但 右为假 则结果为假
        System.out.println(a > 100 && b == 2); // 左为假 但 右为真 则结果为假
        System.out.println(a > 100 && b > 100); // 左为假 且 右为假 则结果为假
    }

    5.3.2. 逻辑 ||

1. 语法规则：表达式1 || 表达式2，左右表达式必须是boolean类型的结果。
2. 相当于现实生活中的或，比如：买房子交钱时，全款 或者 按揭都可以，如果全款或者按揭，房子都是你的，
3. 否则站一边去。
4. 注意：左右表达式至少有一个位真，则结果为真

表达式1	表达式2	结果
真	真	真
真	假	真
假	真	真
假	假	假

    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a == 1 && b == 2); // 左为真 且 右为真 则结果为真
        System.out.println(a == 1 && b > 100); // 左为真 但 右为假 则结果为假
        System.out.println(a > 100 && b == 2); // 左为假 但 右为真 则结果为假
        System.out.println(a > 100 && b > 100); // 左为假 且 右为假 则结果为假
    }

   5.3.3. 逻辑非 !

1. 语法规则：! 表达式
2. 真变假，假变真

 

   public static void main(String[] args) {
        int a = 1;
        System.out.println(!(a == 1)); // a == 1 为true，取个非就是false
        System.out.println(!(a != 1)); // a != 1 为false，取个非就是true
    }

    5.3.4. 短路求值

• && 和 || 遵守短路求值的规则.
• 我们都知道, 计算 10 / 0 会导致程序抛出异常. 但是上面的代码却能正常运行, 说明 10 / 0 并没有真正被求值.

注意 :

1. 对于 && , 如果左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式.
2. 对于 ||, 如果左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式.
3. & 和 | 如果表达式结果为 boolean 时, 也表示逻辑运算. 但与 && || 相比, 它们不支持短路求值.

   public static void main(String[] args) {
        System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false
        System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true
        System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
        System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常
       //输出： Exception in thread "main" java.lang.ArithmeticException: / by zero at Test.main(Test.java:5)
    }

    5.3.5. 位运算符

• 位运算符主要有四个: & | ~ ^ ，除 ~ 是一元运算符外，其余都是二元运算符。
• 位操作表示 按二进制位运算. 计算机中都是使用二进制来表示数据的(01构成的序列), 按位运算就是在按照二进制位的每一位依次进行计算

• Java 中数据存储的最小单位是字节，而数据操作的最小单位是比特位. 字节是最小的存储单位，每个字节是由8个二进制比特位组成的，多个字节组合在一起可以表示各种不同的数据

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

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a & b);//输出0
    }

进行按位运算, 需要先把 10 和 20 转成二进制, 分别为 1010 和 10100 

 

这个怎么看呢？？怎么将变量转化为二进制？   

2. 按位或 |: 如果两个二进制位都是 0, 则结果为 0, 否则结果为 1

  public static void main(String[] args) {
      int c = 10;
        int d = 20;
        System.out.println(c | d);//输出30
  }

注意 : 当 & 和 | 的操作数为整数 (int, short, long, byte) 的时候 , 表示按位运算 , 当操作数为 boolean 的时候 , 表示逻辑运算

3. 按位取反 ~: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0 

    public static void main(String[] args) {
        int a = 0xf;
        System.out.printf("%x\n", ~a);//输出fffffff0
    }

注意 :

• 0x 前缀的数字为 十六进制 数字. 十六进制可以看成是二进制的简化表示方式. 一个十六进制数字对应 4 个二进制位.
• 0xf 表示 10 进制的 15, 也就是二进制的 1111
• printf 能够格式化输出内容, %x 表示按照十六进制输出.
• \n 表示换行符

4. 按位异或 ^: 如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.（注意：如果两个数相同，则异或的结果为0 ）

    public static void main(String[] args) {
        int a = 0x1;
        int b = 0x2;
        System.out.printf("%x\n", a ^ b);//输出3
    }

5. 移位运算

移位运算符有三个 : << >> >>> ，都是二元运算符，且都是按照二进制比特位来运算的。

1. 左移 <<: 最左侧位不要了, 最右侧补 0.

int a = 0x10 ;

System . out . printf ( "%x\n" , a << 1 );

// 运行结果 ( 注意 , 是按十六进制打印的 ) 20

注意：向左移位时，丢弃的是符号位，因此正数左移可能会编程负数 

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

int a = 0x10 ;

System . out . printf ( "%x\n" , a >> 1 );

// 运行结果 ( 注意 , 是按十六进制打印的 )

8

int b = 0xffff0000 ;

System . out . printf ( "%x\n" , b >> 1 );

// 运行结果 ( 注意 , 是按十六进制打印的 )

ffff8000

3. 无符号右移 >>>: 最右侧位不要了, 最左侧补 0. 

int a = 0xffffffff ;

System . out . printf ( "%x\n" , a >>> 1 );

// 运行结果 ( 注意 , 是按十六进制打印的 )

7f ffffff

注意 :

• 左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.
• 右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.
• 由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.
• 移动负数位或者移位位数过大都没有意义.

6. 条件运算符  

• 表达式1 ? 表达式2 : 表达式3
• 当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值;
• 当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值.
• 也是 Java 中唯一的一个 三目运算符, 是条件判断语句的简化写法

    public static void main(String[] args) {
        // 求两个整数的最大值
        int a = 10;
        int b = 20;
        int max = a > b ? a : b;
        System.out.println(max);//输出20
    }

好啦，看到这里是不是该点赞关注啦，谢谢啦！！！