Java的数据类型

Java的数据类型分为基本类型和引用类型，因为涉及到内存的一些问题，这里先简单说一下基本数据类型，后期有时间在具体分析。
在Java中有八种基本的数据类型

这里详细了解一下：

//1。整数字面值是int类型
int a = 75543;
long a = 9999999999;//错误，等号右侧是int类型，但是超出了int范围

/**
*2.byte,short,char,三种比int范围小的整数，
*可以用范围内的值直接赋值。
*/
byte a = 127;//右侧是byte类型
byte a= 128;//错，右侧是int类型

/*
*3浮点数 字面值是double类型
*/
double d = 3.14;
float f = 3.14;//错，右侧是double类型
//4.后缀
//  L long
long a = 9999999999L;
// F float
float f= 3.14f
// D double
double d=3.0;
double d= 3D;
/* 5.前缀
 1. 0x    16进制
 2. 0xff      255
 3. 0     8进制
 4. 0377      255
 5. \u    char类型16进制前缀
 6. '\u0061'    97      a
 7. '\u4e2d'    20013   中
*/

基本类型运算规则

1.计算结果的数据类型，与运算项中范围最大的类型一致。

   3/2     得 1
   3d/2    得 1.5

2.byte,short,char,比int范围小的整数，运算时，会先自动转成 int

    byte a = 2;
    byte b = 3;
    byte c = a + b;//错,右侧是int+int，结果也是int

3.整数运算溢出

    int a = Integer.MAX_VALUE;
    print(a + 1);//最小值
    
    
    01111111111111111111111111111111  +1
    10000000000000000000000000000000
    
    300000000L*60*60*24*365

4.浮点数运算不精确

    2-1.9
    得 0.10000000000000000009
    
    4.35*100
    得 434.9999999999999999994

5.浮点数的特殊值

    Infinity - 无穷大
    --------------------------------
      3.14/0
      Double.MAX_VALUE * 2
    
    
    NaN - Not a Number
    --------------------------------
      负数开平方
      Math.sqrt(-2)

基本类型类型转换

范围小的类型 --> 范围大的类型

    byte a = 127;
    int b = a;
    
    01111111
    00000000 00000000 00000000 01111111 
    
    byte a = -128;
    int b = a;
    
    10000000
    11111111 11111111 11111111 10000000 

范围大的类型 --> 范围小的类型

    int a = 257;
    byte b = (byte) a;
    
    00000000 00000000 00000001 00000001 
    
    00000001

运算符

+ - * /
  
      + 数学运算，字符串连接运算
  
  %   取余
      
      0 % 3    0
      1 % 3    1
      2 % 3    2
      3 % 3    0
      4 % 3    1
      5 % 3    2
      6 % 3    0
      7 % 3    1
      8 % 3    2
      9 % 3    0
      10 % 3   1
      
      判断 x 能否被 4 整除,
      要看余数 x % 4 是否是0

  > >= < <= == !=
      
      a = 2
      b = 3
      
      a>b   false
      a<b   true
      a==b  false
      a!=b  true

      


    &&  逻辑与
        两侧同时是真结果是真,任意一侧是假结果是假
        短路与,左侧是假,右侧被忽略
    
    ||  逻辑或
        两侧同时是假结果是假,任意一侧是真结果是真
        短路或,左侧是真,右侧被忽略
    
    !   非
        真变假，假变真
        可以做相反条件判断
        
        如果“非a”是真，即a是假
        if(!a) {
            
        }
  
    
    
    &   位与
        两位同时是1结果是1,任意一位是0结果是0
        
    |   位或
        两位同时是0结果是0,任意一位是1结果是1
        
    ^   异或
        不同是1，相同是0
        对同一个值异或两次，得到原值
        
    
    ~   求反
    
        a~
        -a-1
    
    >>    带符号向右移位,
          符号位是0左侧补0,符号位是1左侧补1
          
    >>>   不带符号右移位
          不管符号位是0是1，
          左侧都补0
    
    <<    向左移位
    
          *)向右移动一位相当于除2
          *)向左移动一位相当于乘2

    
  ++  - -
  
    自增、自减
    
    a=10
    print(a++)  a自增变成11，使用原值打印
    
    a=10
    print(++a)  a自增变成11，使用新值打印
    
    a=10
    b = a++     a自增变成11，给b赋a的原值10
      
    a=10
    a = a++     a自增变成11，给a赋a的原值10

  ? :
    三项运算
    
    1 ? 2 : 3
        
        1是真，执行2
        1是假，执行3
  
  = 
  赋值运算
  
  +=
  /=
 >>=
  ^=
  ...
    a=10
    a += 3 //a=a+3
    
    会自动转型
        
        byte a = 10;
        a = (byte) (a + 3);
        a += 3;
  
  
  *)运算符优先级
      
      (1+(2-3))*4/5