基本数据类型

• 整数类型
  • byte short int long
  • 整数默认是int
  • 声明long 要加 l(小写L) 或 L(大写L)
• 浮点数
  • float double
  • 浮点数在机器中存放形式为：浮点数 = 符号位 + 指数位 + 尾数位
  • 尾数部分可能丢失，造成精度损失（小数都是近似值）
  • 浮点数默认是double，声明float要带f或F
  • float f = 11.1; // 编译报错，double转换到float可能会有损失
  • 通常情况下，应该使用double，因为比float更精确
  • 浮点数结算的结果不要相等比较
• 字符类型
  • char 表示单个字符， 用单引号
  • char 本质上是一个整数，因此字符类型可以直接存放一个数字
    • chart c = 97;
    • 输出时是unicode码对应的字符
    • char 类型可以进行运算
  • 允许使用转义字符 \ 将其后的字符转变为特殊字符型常量 ‘\n’
  • public static final char MIN_VALUE = ‘\u0000’;
  • public static final char MAX_VALUE = ‘\uFFFF’;
  • Java中的char是Unicode编码。Unicode编码占两个字节，就是16位，足够存储一个汉字。
• 字符编码
  • ASCII : 标准128个
  • ISO-8859-1：扩展ASCII 256
  • GB2312：简体中文
  • GBK：简体中文
  • BIG5: 繁体中文 台湾 香港
  • Unicode编码：65536个 全球字符
    • UTF-32：每个字符4个字节表示
    • UTF-16：每个字符2个字节表示
    • UTF-8：是一种变长的存储方式，省存储空间。字母1个字节，汉字是3个字节节。

• 存储单位换算

  • 1byte = 8bit
  • 1KB = 1024B(B即byte)
  • 1MB = 1024KB

  • 1GB = 1024MB

    @Test
    public void test_2() {
    System.out.println(Byte.MIN_VALUE); //-128
    System.out.println(Byte.MAX_VALUE); // 127
    System.out.println(Short.MIN_VALUE); //-32768
    System.out.println(Short.MAX_VALUE); // 32767
    System.out.println(Integer.MIN_VALUE); //-2147483648
    System.out.println(Integer.MAX_VALUE); //2147483647
    System.out.println(Long.MIN_VALUE); //-9223372036854775808
    System.out.println(Long.MAX_VALUE); //9223372036854775807
    }

    @Test
    public void test_2() {
    int n = 11; // 默认就是int类型
    byte b = 11; //只要赋值给byte的值没有超过其取值范围，就会按照byte类型处理
    // byte b1 = 128; //编译报错,128超过了byte的取值范围
    short s = 11;  //只要赋值给short的值没有超过其取值范围，就会按照short类型处理
    long l = 11;  // 自动数据类型转换
    long l1 = 11L; //加L表示是一个long类型的数字
    }

    @Test
    public void test_2() {
    int n = 11; // 默认是10进制
    int n1 = 0b101;  //前缀 0b 或者 0B 表示二进制
    int n2 = 017;  // 前缀 0 表示八进制
    int n3 = 0x11;  // 前缀 0x 或 0X 表示十六进制
    int n4 = 0b1111111111_10000000_11100; // 可以用下划线，增强可读性
    }

    @Test
    public void test_2() {
    double d = 11.1; //默认就是double
    double d1 = 11.1d;
    // float f = 11.1; // 编译报错，double转换到float可能会有损失
    float f = 11.1f;
    double d2 = 2.0E3; // 浮点数的科学计数法表示
    System.out.println(d2); // 2000.0  E3表示 10的3次方
    // 不要在数量级相差很大的浮点数之间进行运算
    double d3 = 5.25E20;
    System.out.println(d3 + 1); // 5.25E20   1被丢掉
    //浮点数不要比较（注意：是参与计算就不能比较，如果是声明的两个常量浮点数是相等的）
    double d4 = 0.1;
    double d5 = 0.2;
    double d6 = d4 + d5;
    System.out.println(d6); // 0.30000000000000004
    System.out.println(d6 == 0.3); // false
    // 精确计算
    BigDecimal num1 = new BigDecimal("0.1");
    BigDecimal num2 = new BigDecimal("0.2");
    System.out.println(num1.add(num2)); //0.3
    }

    @Test
    public void test_2() {
       char c = '中';
       System.out.println(c); //中
       System.out.println((int)c); // 20013
       //char是一个字符，一个字符有一个编号，因此char可以直接参与运算
       System.out.println(c + 100); // 20113 
       char cc = 65535;
      // char cc1 = 65536; //编译报错，超过了char的两个字节能表示的最大数
    }
    //https://tool.chinaz.com/tools/unicode.aspx

    基本数据类型的 自动类型转换
    byte->short->int->long->float->double
    char->int->long->float->double
    char没有负数，因此byte和short没法包含在其取值范围内。

• 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算

  • float f = 10 + 1.1; //编译报错
  • float f = 10 + 1.1F; // 正确
• 当我们把精度（容量）大的数据类型赋值给精度（容量）小的数据类型时，就会报错，反之就会进行自动类型转换
  • byte b = 12; // 正确 当把具体数赋值给byte时，先判断该数是否在byte范围内，如果是就可以
  • short s = 12; // 正确
  • char c = 12; //正确
  • int i = 1; byte b = i; //编译报错
• （byte、short）和char之间不会相互转换，这是规定
  • byte b = 12; char c1 = b; //编译报错
• byte、short、char他们三者可以计算，在计算时首先转换为int类型
  • byte b = 12; short s = 12; char c = 12;
    byte b2 = b + s + c; //编译报错
    int i = b + s + c; //正确
  • byte b2 = 1; byte b3 = 2;__ _byte b5 = b2 +b3; //编译报错 ，都是byte也会转为int
• boolean不能参与转换
• 自动提升原则：表达式结果的类型自动提升为操作数中最大的类型

基本数据类型的强制类型转换

• 强转符号只针对与最近的操作数有效，往往会使用小括号提升优先级
• char类型可以保存int的常量值，但不能保存int的变量值，需要强转
• byte 和 short ，char类型进行运算时，当做int类型处理
• int i = (int)1.9;
  System.out.println(i); // 1 精度丢失
• int n = 263;
  byte b = (byte) n;
  System.out.println(b); // 7 数据溢出

• char n = 263;
  byte b = (byte) n; // char 可以和byte强转
  System.out.println(b); // 7 数据损失

  @Test
  public void test_9() {
    byte b2 = 7;
    int  i = b2;
    int n = 263;
    byte b = (byte) n;
    System.out.println(b); // 7  强制类型导致 数据损失
    int n2 = 12;
    byte b1 = (byte)n2;
    System.out.println(b1); //12  如果int在btye范围内不会有数据损失
  }

  

short s = 1; s = s+1; 和 s += 1的区别

public static void main(String[] args) {
    short s1 = 1;
    // s1 = s1 + 1; // 编译报错，自定提升为int
    short s2 = 4;
    //s2 = s2 + s1; // 编译报错，byte 和 short ，char类型进行运算时，当做int类型处理
    byte b = 127;
    b += 1; //正确，隐式的强制类型转换, byte
    System.out.println(b); // -128
}