Overview
本節(jié)主要介紹一下四門語言的數(shù)據(jù)類型
Java 篇
Java 的數(shù)據(jù)類型主要分為基本數(shù)據(jù)類型和引用數(shù)據(jù)類型
基本類型
Java 的基本類型有 int, long, float, double, char, boolean，即以小寫字母開頭的數(shù)據(jù)類型。
例
int x = 2;
float y = 0.1f;
boolean flag = false;
引用數(shù)據(jù)類型
Java 中除基本數(shù)據(jù)類型之外的所有數(shù)據(jù)都屬于引用數(shù)據(jù)類型，并且所有引用數(shù)據(jù)類型都是 Object 類的子類。
BigDecimal
Java 的基本數(shù)值類型及其包裝類在進行浮點操作時，很有可能會損失精度。為此，Java 引進了 BigDecimal 類，可以在不損失精度的情況下進行計算。但是不幸的是 Java 的 BigDeciaml 的構(gòu)造器設(shè)計得比較反人類。
System.out.println(2.0 - 1.8); //0.19999999999999996
System.out.println(new BigDecimal(2.0).subtract(new BigDecimal(1.8))); //0.1999999999999999555910790149937383830547332763671875
System.out.println(new BigDecimal("2.0").subtract(new BigDecimal("1.8"))); //0.2
從上面的例子可以看到，BigDecimal 有字符串和數(shù)值兩種構(gòu)造器，字符串構(gòu)造器構(gòu)造的 BigDecimal 才能滿足我們的需求，而不是直接使用數(shù)值進行構(gòu)造，基本上用過這個類的人都會踩過這個坑。
類型轉(zhuǎn)換
隱式轉(zhuǎn)換
所謂的隱式轉(zhuǎn)換即無需顯示指明需要進行類型轉(zhuǎn)換，由編譯器根據(jù)變量的類型自動推斷。
Java 的隱式轉(zhuǎn)換只發(fā)生在使用字面值給變量賦值或者向上轉(zhuǎn)型時
例：
byte b = 1;
int i = b; // byte 類型向上轉(zhuǎn)型為 int 類型
char c = 1; // 使用 int 型的字面值 1 為 char 變量賦值
在以上的例子，Java 默認數(shù)值字面值為 int 型，只要該數(shù)值在 byte 取值范圍內(nèi)，字面值就可以直接賦值給 byte 類型變量。此外由于 int 類型取值范圍比 byte 大，所以 byte 變量可以直接賦值給 int 變量，即向上轉(zhuǎn)型。
顯式轉(zhuǎn)換
無論是基本類型還是引用類型都是使用 (dataType)value 的語法進行轉(zhuǎn)換。顯示轉(zhuǎn)換又稱作強制轉(zhuǎn)換，且向下轉(zhuǎn)型時很可能會丟失精度。
int i = (int) 99.98
類型推斷
Java 使用關(guān)鍵字 isInstanceof 來判斷變量的類型
例：
private static void bar(Object foo) {
if (foo instanceof String) {
String fooString = (String) foo;
System.out.println(fooString.toUpperCase());
}
}
Object foo = "foo";
bar(foo);
從以上例子可以看到，第二行通過 instanceof 已經(jīng)知道 foo 是 String 類型了，但是還需要聲明一個變量進行強制類型轉(zhuǎn)換，這一做法稍顯多余。稍后可以看到 Groovy 的做法要優(yōu)雅得多。
Groovy 篇
由于 Groovy 就是 Java，所以 Groovy 的數(shù)據(jù)類型也與 Java 完全一樣。但是 Groovy 根據(jù)上下文的不同會對自動數(shù)據(jù)進行包裝。
int i = 1
1.toString()
編譯以上代碼后可以看到，第一行編譯后的結(jié)果與 Java 完全一樣，而第二行由于調(diào)用了方法，所以 Groovy 會將其轉(zhuǎn)換為 Integer 類型。這一自動化操作比 Java 的裝箱，拆箱操作要更加先進。
由于以上的原因，我們可以認為 Groovy 中一切皆對象。通常來說 Groovy 將數(shù)據(jù)類型分為靜態(tài)類型和動態(tài)類型。
靜態(tài)類型
靜態(tài)類型即聲明變量時指定了數(shù)據(jù)類型，該種變量聲明后就不可以再改變數(shù)據(jù)類型。
例
int x = 2
float y = 0.1f
boolean flag = false
動態(tài)類型
動態(tài)類型即使用關(guān)鍵字 def 聲明的變量。與靜態(tài)類型變量不同，動態(tài)類型變量在定義后可以任意改變類型。
例：
定義幾個動態(tài)類型變量
def dx = 2
def dy = 0.1
def dflag = false
改變以上數(shù)據(jù)的類型
Date staticDate = new Date()
// 靜態(tài)類型變量
// 無法改變數(shù)據(jù)類型，會報 'java.lang.Integer' to class 'java.util.Date'
// staticDate = 2
// 動態(tài)類型變量
// 變量可以由 Date 類型轉(zhuǎn)換為 Integer 類型
def dynamicDate = new Date()
dynamicDate = 2
BigDecimal
與 Java 不同，Groovy 中定義一個浮點類型數(shù)據(jù)實際就是使用 BigDecimal 的字符串構(gòu)造器定義一個 BigDecimal，所以 Groovy 中不需要做任何額外操作直接就可以做精確的浮點運算。
println(2.0 - 1.8) //0.2
類型轉(zhuǎn)換
隱式轉(zhuǎn)換
同 Java
顯式轉(zhuǎn)換
Groovy 通常使用 toXXX() 這樣的方法來實現(xiàn)基本類型的顯式轉(zhuǎn)換，語法看起來更加優(yōu)雅
int i = 99.98.toInteger()
double d = "99.12".toDouble()
需要注意的是 Groovy 并沒有提供到 char 類型的轉(zhuǎn)換方法，所以 char 類型還是需要使用 Java 樣式的轉(zhuǎn)換方式或者使用以下方式的類型轉(zhuǎn)換：
char c = 99 as char
而對于引用類型的話則轉(zhuǎn)換方式則類似 Java。
類型推斷
對于引用類型而言，Groovy 也使用關(guān)鍵字 instanceof 做類型推斷，但是 Groovy 也提供了 isXXX() 的語法糖來進行基本類型的推斷。
例：
def static bar(foo) {
if (foo instanceof String) {
println(foo.toUpperCase())
}
if (foo instanceof Double) {
println(foo.intValue())
}
if (foo.isDouble()) {
println(foo.toDouble())
}
}
def foo = "foo"
bar(foo)
從以上例子中可以看到，通過 instanceof 進行類型判斷以后，變量就可以直接調(diào)用其真實類型的方法，無需再聲明另一個變量并進行強制類型轉(zhuǎn)換，這一做法相比 Java 方便很多。但是如果使用的是 isXXX() 的語法糖進行類型判斷的話則不支持此特性。
Scala 篇
Scala 中并不存在基本類型，所有數(shù)據(jù)都是對象，且都繼承自 Any 類。Scala 數(shù)據(jù)類型主要分為 AnyVal 和 AnyRef，兩者都是 Any 的子類。
AnyVal
AnyVal 分為 Int, Long, Float, Double, Boolean, Char, Byte，Unit 幾種類型。除了最后一種，其它都可以看做是 Java 上的基本類型的包裝類。而 Unit 則相對于 Java 平臺上的 Void，即表示沒有返回值。
var x: Int = 2
var y: Float = 0.1f
var flag: Boolean = false
AnyRef
AnyRef 是 Scala 中所有引用類的基類，本質(zhì)上就是 Java 中的 Object 類。
BigDecimal
Scala 中的 BigDecimal 雖然沒有 Groovy 那么方便，但是表現(xiàn)也與預(yù)期一樣
println(BigDecimal(2) - BigDecimal(1.8))
類型轉(zhuǎn)換
隱式轉(zhuǎn)換
類似 Java
顯式轉(zhuǎn)換
對于 AnyVal 類型，Scala 科研使用方法進行類型轉(zhuǎn)換
例：
var i:Int = 99.98.toInt
var d:Double = "99.12".toDouble
對于 AnyRef類型，Scala 則使用方法 asInstanceOf[type] 類進行類型轉(zhuǎn)換
例：
val fooString: String = foo.asInstanceOf[String]
類型推斷
Scala 使用 isInstanceOf 來進行類型推斷，整個過程與 Java 基本一樣，需要額外定義變量并顯式進行類型轉(zhuǎn)換。
def bar(foo: Any): Unit = {
if (foo.isInstanceOf[String]) {
val fooString: String = foo.asInstanceOf[String]
println(fooString.toUpperCase)
}
}
Kotlin 篇
Kotlin 中一切皆對象，Any 為所有類的基類。
數(shù)據(jù)類型
Kotlin 中的所有類型都是引用類型，但是與其它幾門語言不一樣，Kotlin 中的 Char 類型只屬于字符類型，而不屬于數(shù)值類型。
var x: Int = 2
var y: Float = 0.1f
var flag: Boolean = false
val c: Char = 1 // 錯誤，Char 不是數(shù)值類型
BigDecimal
Kotlin 并沒有專門的 BigDecimal 類，需要調(diào)用 Java 代碼來完成計算
println(BigDecimal("2").subtract(BigDecimal("1.8")));
類型轉(zhuǎn)換
隱式轉(zhuǎn)換
Kotlin 只有使用字面值給變量賦值時的支持自動隱式轉(zhuǎn)換，并且 Kotlin 不支持自動向上轉(zhuǎn)型，這點上比其它幾門語言都要嚴格不少。
var b: Byte = 1
// 錯誤，不支持自動向上轉(zhuǎn)型
val i: Int = b
顯式轉(zhuǎn)換
Kotlin 也使用方法進行內(nèi)置類型的轉(zhuǎn)換
val i:Int = 99.98.toInt()
"99.12".toDouble()
對于其它類型的數(shù)據(jù)，Kotlin 使用 as 關(guān)鍵字進行類型轉(zhuǎn)換。
val fooString: String = foo as String
類型推斷
Kotlin 使用關(guān)鍵字 is 來進行類型判斷，在類型判斷后數(shù)據(jù)會被自動隱式轉(zhuǎn)換為真正的類型，所以可以直接調(diào)用該類型的所有方法。在 Kotlin 的文檔中稱這一特性為 "Smart Cast"。
fun bar(foo: Any) {
if (foo is String) {
// 該處發(fā)生了 Smart Cast, Any 類型的 foo 在該處被自動轉(zhuǎn)換成了 String 類型
println(foo.toUpperCase())
}
}
val foo = "foo"
bar(foo)
Summary
- 除了 Java 之外，可以認為其它三門語言中一切都是對象
- 每種語言的數(shù)據(jù)類型的基類的叫法都有差別：Java(Object), Grooy(Object), Scala(Any), Kotlin(Any)
- 除了 Java 之外，其它語言都可以使用更優(yōu)雅的方法調(diào)用來完成內(nèi)置類型的強制類型轉(zhuǎn)換
文章源碼見 https://github.com/SidneyXu/JGSK 倉庫的 _05_datatype 小節(jié)
