Java数据类型之Java数据类型的划分方式

      程序的本质在于数据的处理上。所以如果想进行程序处理，那么必须要有相应的数据类型。在Java中针对于数据类型一共可以划分为两类：

• 基本数据类型：是进行内容的操作，而不是进行内存的操作；

      |-  数值型：

            |-  整型：byte，short，int，long；            默认值：0

            |-  浮点型：float，double；                        默认值：0.0

      |-  字符型：char；                                              默认值：‘\u0000’

      |-  布尔型：boolean；                                       默认值：false

• 引用数据类型：在数据交互过程之中会占用内存空间指向

      |-  分为：数组、类、接口；                              默认值：null

      对于给出的八种基本数据类型，有其自己特定的使用环境：

• 表示整数首先考虑的就是int，例如：年龄；
• 表示小数一定使用double；
• 表示日期、时间、数字、文件、内存大小使用long（字节）；
• 进行编码转化、数据传输使用byte；
• 处理中文使用char类型；
• 处理逻辑使用boolean类型；

      以后考虑代码的时候，float和short可以暂时不考虑。

      Java的基本数据类型

     double保存的数据范围是最大的。

      1整型

      在程序开发之中，如果想要表示整数就使用整型，同时如果要想定义整型可以使用byte、short、int、long，但是一定要记住，在Java之中有一个特点：默认的一个整数，其对应的类型永远是int。

      范例：定义整形变量

       public class Test {
          public static void main(String args[]){
              //定义变量的语法：数据类型 变量名称 = 默认值；
              //10作为一个常量其类型是int型
              int num = 10;//定义一个num的int型变量，赋值为10
              //代码从等号右边开始执行
              //int型变量 = int型变量 + int型常量
              num = num + 20;//使用num变量的内容（10）+20的常量，将结果赋值给num
              System.out.println(num);//输出num的内容
          }
      }

       变量内容在开发之中允许修改，常量内容不允许修改。

      范例：数据溢出

      public class Test {
          public static void main(String args[]){
              int max = Integer.MAX_VALUE;//int的最大值
              int min = Integer.MIN_VALUE;//int的最小值
              System.out.println(max);//2147483647
              System.out.println(min);//-2147483648
              //max是int型变量 + int型常量 = int型
              System.out.println(max+1);//-2147483648
              System.out.println(max+2);//-2147483647
              //min是int型变量 - int型常量 = int型
              System.out.println(min-1);//2147483647
          }
     }

      之所以会出现数据的溢出操作，那么本质的问题就在于数据类型的操作位数太短了，那么在这种情况下（正常情况下基本出现），所以要想解决此时 int 的问题，那么就必须扩展操作类型，比int大的是long数据类型。

      给出一个常量或者是变量怎么变成long型？

• 将int变量转换为long：（long）int  变量；
• 将int常量转换为long：常量L。
• 如果小范围的数据类型变量或常量与大范围的变量或常量计算时，先转换到大范围数据类型

      范例：解决数据溢出

      public class Hello {
          public static void main(String args[]){
              int max = Integer.MAX_VALUE;//int的最大值
              int min = Integer.MIN_VALUE;//int的最小值
              System.out.println(max);//2147483647
              System.out.println(min);//-2147483648
              //int型变量 + long型常量 = long型
              System.out.println(max+1L);//2147483648
              //强制将int型变为long+int型常量 = long型
              System.out.println((long)min-1);//-2147483649
          }
      }

      public class Hello {
           public static void main(String args[]){
                  System.out.println(11+1l);//12
           }
      }

      这样的转换操作确实是很少出现，但是通过上述代码实际上发现了一种数据类型的自动转换功能。

      不同种数据类型之间是可以进行转换的，转换原则如下（由大到小，强制；由小到大，自动。）：

• 数据范围保存大的数据类型要转换为数据范围保存小的数据类型，使用强制转换；
• 数据范围保存小的数据类型可以自动转换为数据范围保存大的数据类型。

      范例：数据的自动转换

      public class Hello {
          public static void main(String args[]){
              int x = 10;//整型变量
              long num = x;//int自动变为long型
              System.out.println(num);//10
          }
      }

      范例：数据的强制转换

      public class Hello {
          public static void main(String args[]){
              //10是int型常量，将int型自动转换为long
              long x = 10;
              int num = x;//long强制变为int型
              System.out.println(num);
          }
      }

      public class Hello {
                public static void main(String args[]){
                    //10是int型常量，将int型自动转换为long
                    long x = 10;
                    int num = (int)x;//long强制变为int型
                    System.out.println(num);//10
              }
        }

      public class Hello {
                public static void main(String args[]){
                    long x = 3777777777;
                    int num = (int)x;//long强制变为int型
                    System.out.println(num);
              }
        }

       public class Hello{
          public static void main(String args[]){
              long x = 3777777777L;
              int num = (int)x;//long强制变为int型
              System.out.println(num);//-517189519
          }
      }

      在数据类型之中byte表示字节数据，字节数据的范围：-128~127。接下来考虑int与byte之间的转换。

      范例：byte转换为int

      public class Hello{
          public static void main(String args[]){
              byte x = 10;//定义byte变量
              int num = x;//byte转换为int
              System.out.println(num);//10
          }
      }

      public class Hello {
          public static void main(String args[]){
              byte x = 130;//定义byte变量
              int num = x;//byte转换为int
              System.out.println(num);
          }
      }

      在Java中，由于byte类型比较特殊，那么进行赋值处理时，如果设置的整型数据（常量）在byte范围内，那么它会帮助用户自动转型，如果超过了byte的范围，那么就需要进行向下的强制转换。

      public class Hello {
          public static void main(String args[]){
              byte x = (byte)130;//定义byte变量
              int num = x;//byte转换为int
              System.out.println(num);//-126
          }
      }

public class Hello {
    public static void main(String args[]){
        int y = 10;
        byte x = y;//定义byte变量
        int num = x;//byte转换为int
        System.out.println(num);
    }
}

      现阶段表示数字就使用int。

      2浮点型

      如果要表示小数（收入、成绩、身高）使用float、double。但是在Java之中，任何的一个小数常量其对应类型都是double。

      范例：double操作

      public class Hello {
          public static void main(String args[]){
              //10.0是一个小数常量，其类型为double
              double x = 10.0;
              double y = 12.9;
              System.out.println(x*y);//129.0
          }
      }

      但是千万不要忘记，double是整个Java数据类型之中保存范围最大的一个类型。所以任何的数据类型与double类型进行数学计算时都会自动转换为double类型

      范例：double与其他类型操作

      public class Hello {
          public static void main(String args[]){
              //10.0是一个小数常量，其类型为double
              double x = 10.0;
              int y = 10;
              long z = 120;
              //double型变量+int型自动变为double型+long型自动变为long型=double型；
              System.out.println(x+y+z);//140.0
          }
      }
      但是double并不是唯一的小数表示，对于小数还可以使用float表示。但是，如果要想定义float变量，那么必须将double型常量转换为float型。

      public class Hello {
          public static void main(String args[]){
              float x = 10.2F;
              float y = (float)10.2;
              System.out.println(x);//10.2
              System.out.println(y);//10.2
          }
      }
      但是这样的操作有些啰嗦，之所以提出是因为很多时候，Java也许会用在一些内存操作严格的情况下。手机。

      但是除了小数操作中要使用double类型之外，在一些计算中也需要使用到。

      范例：除法计算

      public class Hello {
          public static void main(String args[]){
              int x = 10;
              int y = 4;        
              System.out.println(x/y);//2
          }
      }
      因为整形是不保存小数位的，所以 如果利用整型进行数学计算，那么最终的结果小数位将全部被忽略掉。

     范例：利用float、double进行小数位的保留

      public class Hello {
          public static void main(String args[]){
              int x = 10;
              int y = 4;
              //int型÷double型=double型
              System.out.println(x/(double)y);//2.5
          }
      }

      在大部分情况下，只要与小数点有关的一切操作都使用double完成。

      关于默认值的说明

      默认值现在不起作用

      范例：定义不变量不设置内容

      public class Hello {
          public static void main(String args[]){
              int x ;
              System.out.println(x);
          }
      }

• 

      正常情况下，变量值只有设置内容后才能正常使用。而事实上，默认值没有用处。

      public class Hello {
          static int x ;
          public static void main(String args[]){
              System.out.println(x);//0
          }
      }

      public class Hello {
          public static void main(String args[]){
              int x ;
              x=10;//使用前先赋值
              System.out.println(x);//10
          }
      }

      这个代码在JDK1.5之后才可以使用，而JDK1.5之前此代码是错误的。
      范例：绝对正确

      public class Hello {
          public static void main(String args[]){
              int x=10;//使用前先赋值
              System.out.println(x);//10
          }
      }

      以后一定要养成习惯，方法中定义变量一定要设置默认值。

      3字符型

      char主要是保存单个字符，并且单个字符要使用“ '' ”声明。

      范例：char类型

      public class Hello {
          public static void main(String args[]){
              char c = 'A';//字符变量
              System.out.println(c);//A
          }
      }

      以后只要是使用单引号声明的内容都表示单个字符。在Java里，由于使用的是UNICODE这种16进制编码，所以char可以保存中文。

      范例:保存中文

      public class Hello {
          public static void main(String args[]){
              char c = '好';//字符变量
              System.out.println(c);//好
          }
      }

      首先明确的是，计算机的世界里面能保存的数据只是01这样的二进制机器语言，所以如果要保存字符，那么也需要有其对应的编码出现。而Java使用的是UNICODE编码，这个编码特点：包含ASCII码。那么在这样的情况下，char和int可以互相转换，而char转换为int之后就是具体的编码数据。

      范例：观察转换

      public class Hello {
          public static void main(String args[]){
              char c = 'A';//字符变量
              int num = c;//将字符转换为数字（保存的是编码）
              System.out.println(num);//65
          }
      }

      常用字符范围：

• 大写字母：'A'（65）~'Z'（90）;
• 小写字母：'a'（97）~'z'（122）;
• 数字字母：'0'（48）~'9'（57）

      可以发现大写字母和小写字母之间相差32.

      范例：大写与小写字母间的转换。

      public class Hello {
          public static void main(String args[]){
              char c = 'A';//字符变量
              int num = c;//将字符转换为数字（保存的是编码）
              num = num + 32;//大写字母和小写字母之间差了32
              c = (char)num;//将数字强制变为char
              System.out.println(c);//a
          }
      }   

      综合所述，char最大的优势就是可以保存中文，而byte是保存字节的。

      4布尔型

      boolean表示的是布尔型的数据类型，布尔是一个数学家的名字，他发明了布尔类型。所谓的布尔类型指的就是两方面的概念：ture（真），false（假）。

      一般情况下boolean类型往往都要结合判断语句完成处理。

      范例：使用布尔型

      public class Hello {
          public static void main(String args[]){
              boolean flag = true;
              //if语句判断的是boolean型数据
              if(flag){//如果flag内容是true，那么就执行
                  System.out.println("好好学习，天天向上");//好好学习，天天向上
              }
          } 
     }

      很多的编程语言实际上本身并没有直接提供布尔型数据，例如：C语言之中，将0表示为false，将非0表示为true。但是Java并没有这样的0,1描述，只有true、false。

      但是可以借助此概念在数据库设计中使用，做一个超级管理员的标志位：1（是超级管理员）、0（普通管理员）。

      1.5字符串：String型

      利用char只能够保存单个字符，这在很大程度上是有限制的，所以如果想要表示多个字符，就可以利用String完成。但是String本身是一个类，但是这个类的使用有些特殊，可以像基本数据类型那样完成。在程序中使用双引号声明的数据就是字符串。

      范例：定义字符串

      public class Hello {
          public static void main(String args[]){
              String str = "Hello world!";//字符串
              //在字符串中可以使用“+”进行字符串的连接操作
              str = str + "Hello LDN!";
              str += "I'm good.";
              System.out.println(str);//Hello world!Hello LDN!I'm good.
          }
      }

      现在发现String进行连接操作的过程中使用了“+”进行了连接操作，可是“+”也属于数学运算符。

      范例：观察如下代码

      public class Hello {
          public static void main(String args[]){
              int x = 10;
              double y = 20.3;
              //所有的数据类型与String进行“+”操作中都会自动变为String型
              //字符串+double变为字符串+int变为字符串
              String str1 = "计算结果："+y+x;
              String str2 = "计算结果："+(y+x);//改变运算顺序
              System.out.println(str1);//计算结果：20.310
              System.out.println(str2);//计算结果：计算结果：30.3
          }
      }

      另外一点，在程序中还存在有转义字符，包括：“\n”、“\\”、“\"”、“\'”、“\t”。

      范例：观察转义字符

      public class Hello {
          public static void main(String args[]){
              String str = "Hello \"world\",\\hello\n\thaha";
              System.out.println(str);
          }
      }

      运行结果：

      Hello "world",\hello
                   haha

      记忆点：

      1.数据类型划分以及默认值；

      2.表示年龄用int，表示成绩用double，表示姓名用String，表示逻辑用boolean。