Java数据类型划分以及数据类型操作

程序就是一场数字游戏

Java的数据类型划分

Java数据类型一共分为两大类。
基本数据类型：
 数值型：表示整数或小数
 整形：byte、short、int、long     ----  默认值：0；
 浮点型：float、double  
---- 默认值：0.0；
 字符型：char     ----默认值：'\u0000'
 布尔型：boolean   
 ----默认值 ：null
引用数据类型：数组、类、接口
重点在于基本数据类型的操作上，而对于基本数据类型就肯定有其保存的数据范围。

选择原则：

在程序开发中表示整数就使用int，描述小数就用double；
ong数据类型一般描述日期时间、内存或文件大小（字节）；
如果需要进行编码转换或进行二进制数据传输，使用byte；
char一般在描述中文的时候使用到（基本上会忽略）；
boolean在描述程序逻辑的使用。

整形

在Java程序里面任何一个整数的常量类型都是int型，
范例：定义一个整形

public class TestDemo {
public static void main(String[] args) {
//10 是一个整数（不会改变的数据是常量）
//程序之中任何一个整数对应的类型都是int
int num = 10;  //声明一个int变量
// num是int型的变量 * 2 是int的常量 = 结果还是int型
System.out.println(num * 2);
}
}

但是在进行整形数据操作的过程之中也会存在有一个数据的溢出问题，指的是当已经达到了整形的最大或最小，如果进行数学计算而可能产生的错误数据。

关于变量的命名要求：第一个单词的字母小写。

public class TestDemo {
public static void main(String[] args) {
int maxValue = Integer.MAX_VALUE; // 最大值
int minValue = Integer.MIN_VALUE; // 最小值
System.out.println(maxValue); //2147483647
System.out.println(minValue); // -2147483648
// maxValue属于int变量 + int 型常量 = int
System.out.println(maxV
4000
alue + 1); //取得最小值
System.out.println(minValue - 1); //取得最大值

}
}

发现但已经超过了数据类型的局限之后，数据的计算就会出现偏差，所以一定要在操作前预估数据的大小。但是问题是，既然已经知道了int会出现溢出的问题，就需要解决这个溢出问题。解决方案只有一个：更换更大的数据类型，而比int大的是数据类型就是long类型。

范例：使用long来解决int的数据溢出问题

public class TestDemo {
public static void main(String[] args) {
int maxValue = Integer.MAX_VALUE; // 取得最大值
int minValue = Integer.MIN_VALUE; // 取得最小值
long result = maxValue + 1;
System.out.println(result);

}
}

在使用此类方式处理之前请一定要注意一个问题，所以的程序的执行顺序都是由等号的右边到左边，也就是说如果你现在继续使用了int进行计算，那么计算结果依然会有溢出，所以最简化的做法是将其中的一个变量
首先做类型扩充，而扩充有两种实现方式： 

实现方式一：直接将int变量赋值给long类型 

public class TestDemo {
public static void main(String[] args) {
int maxValue = Integer.MAX_VALUE; // 最大值
int minValue = Integer.MIN_VALUE; // 最小值
long result = maxValue;  // 将int数据变量赋值给long类型;
// result是long类型 + 1是int类型 = long类型
System.out.println(result + 1);

}
}

 实现方式二 ： 直接将某个int型的变量变为long型
 

public class TestDemo {
public static void main(String[] args) {
int maxValue = Integer.MAX_VALUE; // 最大值
int minValue = Integer.MIN_VALUE; // 最小值
// 先将int型变为long型 + int型常量 = long类型
long result = (long)maxValue + 1;
System.out.println(result);

}
}

数据类型除了可以由小变大之外，也可以实现由大变小，但就需要强制完成，强制的结果是会丢结果

范例：数据类型强制转换

public class TestDemo {
public static void main(String[] args) {
//任何的整数其默认类型都是int，但是该数据已经超过int可以保存的数据范围
//那么现在就需要将这个数据明确表示是一个long型的常量
long num = 2147483648L; // “L”和“l”都行
//在强制的时候设置其目标类型，这种操作有可能会丢失精度
int result = (int)num; // 大的类型变为小的类型，必须强制
System.out.println(result);  //-2147483648
}
}

在开发中没事干别整这个，懂这个流程就行
范围小的数据类型可以自动转换为范围大的数据类型 
数据范围大的数据类型只有强制转换才可以变为范围小的

重要说明：关于数据类型默认值问题 

在之前说过所有的数据类型都有其默认值，但是这个默认值在方法声明中（主方法）无效。

范例：观察一个错误程序

public class TestDemo {
public static void main(String[] args) {
int num; //定义一个num变量
System.out.println(num);
}
}

发生的错误：

  TestDemo.java:4: 错误: 可能尚未初始化变量num

               
 System.out.println(num);

                                   ^
 1 个错误

那么这个时候有两种解决方案：一种是在使用前进行赋值，另外一种是再定义变量的时候直接赋值。

范例：在使用前为变量赋值内容

public class TestDemo {
public static void main(String[] args) {
int num; //定义一个num变量
num = 10; //在nun输出之前为变量设置内容
System.out.println(num);
}
}

但是这种方式在老版本的JDK之中也会出错误，所以最保险的做法就是在声明变量的时候设置它的默认值：

public class TestDemo {
public static void main(String[] args) {
int num = 10; //在nun输出之前为变量设置内容
System.out.println(num);
}
}

而对于各个数据类型的默认值的使用，需要结合到类的情况下才可以观察到。

既然说到了整形数据类型，就不得不去考虑byte数据类型，首先byte数据类型可以保存的范围是-128 ~ 127之间。

范例：声明byte变量

public class TestDemo {
public static void main(String[] args) {
//10是int，int的范围要大于byte范围，那么理论上需要进行强制转换
//可是这里面没有转换，因为其数据量符合byte要求
byte data = 10; //10是int类型在byte范围内
System.out.println(data);
}
}

如果说在你为byte赋值的内容大于byte的范围，这个时候就需要强制转换。

public class TestDemo {
public static void main(String[] args) {
byte data = (byte)128;
System.out.println(data);
}
}

同时需要注意的是，如果要将int常量直接赋值给byte，那么只能够是常量，而不能是int变量。

public class TestDemo {
public static void main(String[] args) {
int num = 10;
byte data = (byte)num;
System.out.println(data);
}
}

在以后的开发之中，byte和int经常会一起出现。

浮点数

如果要想描述小数的数据，默认的数据类型使用的是double。

范例：定义小数

public class TestDemo {
public static void main(String[] args) {
System.out.println((double)2);
double num = 10.2;   //这是一个小数，默认类型就是double
// num是double类型 * int型常量 = double类型
// num *  2.0（由int变为的double型）
System.out.println(num * 2);
}
}

而同时最需要注意的是，double可以保存的数据是最大的，也就是double可以保存全宇宙中最大的有意义的数字。而除了double之外也也可以使用float来描述小数，但千万要记住的是float范围要小于double，所以如果要想直接声明float变量，那么就要求在定义的时候进行强制转换，在数字后加一个字母”f“、”F“。

范例：定义float变量

public class TestDemo {
public static void main(String[] args) {
float f1 = 1.1F ;
//float变量 * int常量 = float类型
System.out.println(f1 * 2);
System.out.println(1.1 * 1.1); //输出结果是Java一直有的bug
}
}

但是既然说到了小数问题就必须考虑一下整型的计算问题。

范例：观察如下计算结果

public class TestDemo {
public static void main(String[] args) {
int numA = 10 ;
int numB = 4 ;
// int型 ÷ int型 = int型
System.out.println(numA / numB) ;
// 如果要想准确的进行计算， 那么就必须保证有一个类型至少double型或float型
System.out.println(numA / (double)numB) ;
System.out.println((float)numA / numB) ;
}
}

以后进行出发计算的时候请一定要注意好你的类型。

字符型

虽然在开发之中会使用到字符型的概念，但是真正去操作字符型的情况并不多。
字符型使用char进行表示，而且使用单引号“'”来声明字符变量的内容，同时字符型可以与int互相转换。

范例：观察字符型

public class TestDemo {
public static void main(String[] args) {
char c = 'A' ; // 定义了字符
System.out.println(c) ;
}
}

但在整个字符型的处理之中，最麻烦的部分在于其可以与int互相转换。所有的字符在程序之中都是通过编码描述的，所以char的变量变为int内容的时候，其所包含的就是编码。

范例：观察编码的出现

public class TestDemo {
public static void main(String[] args) {
char c = 'A' ; // 定义了字符
int num = c ;	// 将字符变为int型
System.out.println(c) ;
}
}

常用范围：

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

范例：实现大写字母变为小写字母（大写和小写字母之间差了32个长度）

public class TestDemo {
public static void main(String[] args) {
char c = 'A' ; // 定义了字符
// 字符变量 + int常量 = int类型
int num = c + 32;	// 将字符变为int型
System.out.println(c) ;
// 需要将int的内容转换为char类型，强制转换
char x = (char) num ;	// 强制转换
System.out.println(x) ;
}
}

实际上各个语音都有相似的编码，而之前在使用其它语言所使用的编码为ASCⅡ码，但是Java中使用的并不是ASC Ⅱ码，而是UNICODE编码，这种编码包含有ASCⅡ部分内容。但是它所包含的编码范围有多余ASCⅡ。同时UNICODE使用16进制编码，这个编码可以保存任何文字信息。

范例：保存中文字符

public class TestDemo {
public static void main(String[] args) {
char c = '周' ;
int num = c +32 ;
System.out.println((char)num);
}
}

正是因为Java中对于字符的特性支持比较好，所有还有另外一类神奇的用法

范例：神奇的Java

public class 程序类 {
public static void main(String args[]) {
int 变量1 = 10 ;
int 变量2 = 10 ;
int 计算结果 = 变量1 * 变量2 ;
System.out.println(计算结果) ;
}
}

这样一来就打破之前的命名标识符，但是强烈建议，不要用。

布尔型

布尔是一位数学家的名字，发明了两个单词：true，false。一般布尔类型表示逻辑计算结果

范例：观察布尔型的操作

public class TestDemo {
public static void main(String[] args) {
boolean flag = 10 > 2;	//true
System.out.println(flag);
if(flag) {
System.out.println("Hello world!");
}
}
}

但是对于布尔型的内容需要说明：在其他语言之中由于没有提供布尔型，会使用数字来描述布尔型，例如：0表示false，非0表示true，但是Java没有这样的概念。

初见字符串

char可以描述的只是单一字符，但是如果现在要描述出多个字符，就必须利用字符串这一概念来解决，例如：如果要定义表示人姓名的变量，很明显是多个字符，就必须使用String来描述。

但是需要说明的是String并不是一个基本数据类型，String是一个引用数据类型，不过这种类型在使用过程中比较特殊，可以按照基本数据类型的使用模式来进行套用。

范例：观察String型变量
  在String变量上也可以使用“+”，一旦使用了“+”则描述的是两个字符串的连接

public class TestDemo {
public static void main(String[] args) {
String name = "吃鸡" ; //定义一个String
String note = "今晚" ; //
System.out.println(note + name);
}
}

但是“+”在数学计算之中描述的是数学的相加操作，而在String中是字符串连接操作，那么如果两类操作同时出现呢？

范例：观察“+”问题

public class TestDemo {
public static void main(String[] args) {
int numA = 10;
double numB = 20.2;
// 此时不是数学计算，而是连接
String result = "数学计算：" + numA + numB;
System.out.println(result);
}
}

此时计算结果上称为了字符串的连接，发现一旦在使用“+”的操作中出现有字符串，则所有的数据类型都变为String。（所有的类型只要与String发生了“+”操作都变为String类型后再进行连接）。这个时候如果要得到正确的计算结果，那么就必须使用“（）”来解决问题

public class TestDemo {
public static void main(String[] args) {
int numA = 10;
double numB = 20.2;
// 此时不是数学计算，而是连接
String result = "数学计算：" + ( numA + numB ) ;
System.out.println(result);
}
}

在程序里面还会存在有一种转义字符的概念，有如下几个常用转义字符：换行（\n），制表符（tab 、\t）、双引号（\"）、单引号（\'）、\（ \\）

范例：观察转义字符

public class TestDemo {
public static void main(String[] args) {
System.out.println("\t\t\t\t\"大吉\n大利\"，今晚吃鸡");
}
}

利用转义字符可以对字符进行一些小的控制操作，但是这些也只是在基础课程学习阶段上才有那么一点点用途。

总结

现阶段要考虑的数据类型就是int、double、boolean； 
操作的数据请保证有意义，就可以回避掉数据范围问题； 
使用“"”声明的为字符串，字符串使用String来定义类型；