java回忆录—数据类型的魅力

Java 语言是一种强类型语言。通俗点说就是，在 Java 中存储的数据都是有类型的，而且必须在编译时就确定其类型。 Java 中有两类数据类型：

在 Java 的领域里，基本数据类型变量存的是数据本身，而引用类型变量存的是保存数据的空间地址。

说白了，基本数据类型变量里存储的是直接放在抽屉里的东西，而引用数据类型变量里存储的是这个抽屉的钥匙，钥匙和抽屉一一对应。

Java语言提供了八种基本类型（内置类型）。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

byte：

byte数据类型是8位（1个字节）、有符号的，以二进制补码表示的整数；

最小值是-128（-2^7）；

最大值是127（2^7-1）；

默认值是0；

byte类型用在大型数组中节约空间，主要代替整数，因为byte变量占用的空间只有int类型的四分之一；

例子：byte a = 100，byte b = -50。

short：

short数据类型是16位（2个字节）、有符号的以二进制补码表示的整数

最小值是-32768（-2^15）；

最大值是32767（2^15 - 1）；

Short数据类型也可以像byte那样节省空间。一个short变量是int型变量所占空间的二分之一；

默认值是0；

例子：short s = 1000，short r = -20000。

int：

int数据类型是32位（4个字节）、有符号的以二进制补码表示的整数；

最小值是-2,147,483,648（-2^31）；

最大值是2,147,483,647（2^31 - 1）；

一般地整型变量默认为int类型；

默认值是0；

例子：int a = 100000, int b = -200000。

long：

long数据类型是64位（8个字节）、有符号的以二进制补码表示的整数；

最小值是-9,223,372,036,854,775,808（-2^63）；

最大值是9,223,372,036,854,775,807（2^63 -1）；

这种类型主要使用在需要比较大整数的系统上；

默认值是0L；

例子： long a = 100000L，Long b = -200000L。

float：

float数据类型是单精度、32位（4个字节）、符合IEEE 754标准的浮点数；

float在储存大型浮点数组的时候可节省内存空间；

默认值是0.0f；

浮点数不能用来表示精确的值，如货币；

例子：float f1 = 234.5f。

double：

double数据类型是双精度、64位（8个字节）、符合IEEE 754标准的浮点数；

浮点数的默认类型为double类型；

double类型同样不能表示精确的值，如货币；

默认值是0.0d；

例子：double d1 = 123.4。

boolean：

boolean数据类型是8位（1个字节）；

只有两个取值：true和false；

这种类型只作为一种标志来记录true/false情况；

默认值是false；

例子：boolean one = true。

char：

char类型是一个单一的16位Unicode字符（2个字节）；

最小值是’\u0000’（即为0）；

最大值是’\uffff’（即为65,535）；

char数据类型可以储存任何字符；

例子：char letter = ‘A’。

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)。

包装类均位于java.lang包，包装类和基本数据类型的对应关系如下表所示：

实际上，JAVA中还存在另外一种基本类型void，它也有对应的包装类 java.lang.Void，不过我们无法直接对它们进行操作。

对于包装类来说，这些类的用途主要包含两种：

a、作为和基本数据类型对应的类类型存在，方便涉及到对象的操作。

b、包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法。

对于数值类型的基本类型的取值范围，我们无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了。如：

基本类型byte 二进制位数：Byte.SIZE最小值：Byte.MIN_VALUE最大值：Byte.MAX_VALUE

基本类型short二进制位数：Short.SIZE最小值：Short.MIN_VALUE最大值：Short.MAX_VALUE

基本类型char二进制位数：Character.SIZE最小值：Character.MIN_VALUE最大值：Character.MAX_VALUE

基本类型double 二进制位数：Double.SIZE最小值：Double.MIN_VALUE最大值：Double.MAX_VALUE

其实范围推也可以推出来的，比如byte类型，占一个字节，8位，那么它可以存储2^8=256个数，又知byte是有符号的，所以正数和负数应该各占一半（128个），正数的最大值应该为 0111 1111 = 127 ,所以正数的范围为0~127，则负数的范围应该为-128~-1，其他的数据类型也是同理。

注意：float、double两种类型的最小值与Float.MIN_VALUE、 Double.MIN_VALUE的值并不相同，实际上Float.MIN_VALUE和Double.MIN_VALUE分别指的是 float和double类型所能表示的最小正数。

也就是说存在这样一种情况，0到±Float.MIN_VALUE之间的值float类型无法表示，0 到±Double.MIN_VALUE之间的值double类型无法表示。

这并没有什么好奇怪的，因为这些范围内的数值超出了它们的精度范围。

另外，所有基本类型（包括void）的包装类都使用了final修饰，因此我们无法继承它们扩展新的类，也无法重写它们的任何方法。

Java基本类型存储在栈中，因此它们的存取速度要快于存储在堆中的对应包装类的实例对象。

基本数据类型间的转换

1、boolean类型不能转换成任何其他数据类型。

2、简单类型数据间的转换,有两种方式:自动转换和强制转换,通常发生在表达式中或方法的参数传递时。

自动转换：容量小的数据类型可以自动转换成容量大的数据类型，如byte-short-int-long-float-double。byte、short、int不会互相转换，他们三者在计算时会转换成int类型。

    ①下面的语句可以在Java中直接通过：

    byte b;int i=b; long l=b; float f=b; double d=b;

    ②如果低级类型为char型，向高级类型（整型）转换时，会转换为对应ASCII码值，例如

    char c='c'; int i=c;

    System.out.println("output:"+i);输出：output:99;

    ③对于byte,short,char三种类型而言，他们是平级的，因此不能相互自动转换，可以使用下述的强制类型转换。

    short i=99 ; char c=(char)i; System.out.println("output:"+c);输出：output:c;

强制转换：容量大的数据类型转换成容量小的数据类型时，要加上强制转换符。可以想象，这种转换肯定可能会导致溢出或精度的下降。

    如： int n=(int)3.14159/2;

3、当一个java算术表达式中包含多个基本类型的值时，整个算术表达式的数据类型将发生自动提升。注意下面的规则。

①所有的byte,short,char型的值将被提升为int型；

②如果有一个操作数是long型，计算结果是long型；

③如果有一个操作数是float型，计算结果是float型；

④如果有一个操作数是double型，计算结果是double型；

例：

byte b=4;    //右边的int值在byte范围之内默认强转
byte b1=3;
byte b2=7;
b=b1+b2; //这样是计算不出b,是错误的
b=b1+7; //这样也是计算不出b
byte b=3+7; //怎么这样又可以计算?
解释：

编译器在编译时（byte类型取值是有限的）他在判断右边的数值的时候发现是int类型（是“常量”）,
但他会判断是不是在byte字节范围之内,如果在的话,会给右边的int类型做默认的强转,他把最后的一个字节（byte八个二进制）赋值到了b这个变量当中

b1和b2是“变量”意味着这两值不确定、可能随时变化,编译器无法检查,也无法确定是否在byte字节范围之内,
他检查不了就会报错（可能丢失精度）,如果是“常量”编译器就能够判断了。

4、包装类过渡类型转换

一般情况下，我们首先声明一个变量，然后生成一个对应的包装类，就可以利用包装类的各种方法进行类型转换了。

例如：

    ①当希望把float型转换为double型时：

    float f1=100.00f;

    Float F1=new Float(f1);

    double d1=F1.doubleValue();//F1.doubleValue()为Float类的返回double值型的方法

    ②当希望把double型转换为int型时：

    double d1=100.00;

    Double D1=new Double(d1);

    int i1=D1.intValue();

简单类型的变量转换为相应的包装类，可以利用包装类的构造函数。

即：Boolean(boolean value)、Character(char value)、Integer(int value)、Long(long value)、Float(float value)、Double(double value)

而在各个包装类中，总有形为××Value()的方法，来得到其对应的简单类型数据。

利用这种方法，也可以实现不同数值型变量间的转换。

例如，对于一个双精度实型类，intValue()可以得到其对应的整型变量，而doubleValue()可以得到其对应的双精度实型变量。

5、字符串与其它类型间的转换

其它类型向字符串的转换

    ①调用类的串转换方法:X.toString();

    ②自动转换:X+"";

    ③使用String的方法:String.volueOf(X);

字符串作为值,向其它类型的转换

    ①先转换成相应的封装器实例,再调用对应的方法转换成其它类型

        例如，字符中"32.1"转换double型的值的格式为:new Float("32.1").doubleValue()。
        也可以用:Double.valueOf("32.1").doubleValue()

    ②静态parseXXX方法

        String s = "1";

        byte b = Byte.parseByte( s );

        short t = Short.parseShort( s );

        int i = Integer.parseInt( s );

        long l = Long.parseLong( s );

        Float f = Float.parseFloat( s );

        Double d = Double.parseDouble( s );

在JDK 5.0之前，没有存在自动拆解箱的操作，即Auto Box操作，所以在这之前是不能使用以下方式的赋值代码的：

Integer a = 0; //这种赋值方式不能够在JDK 1.4以及以下的JDK编译器中通过

但是JDK 5.0出现了自动拆解箱的操作，所以在JDK 5.0以上的编译器中，以上的代码是可以通过的

Java引用类型

Java有 5种引用类型（对象类型）：类 接口 数组 枚举 标注

引用类型：底层结构和基本类型差别较大

所有引用类型的默认值都是null。

JVM的内存空间：

（1）. Heap 堆空间：分配对象 new Student（）

（2）. Stack 栈空间：临时变量 Student stu

（3）.Code 代码区 ：类的定义，静态资源 Student.class

eg：Student stu = new Student（）； //new 在内存的堆空间创建对象

stu.study(); //把对象的地址赋给stu引用变量

上例实现步骤：

 a.JVM加载Student.class 到Code区

 b.new Student()在堆空间分配空间并创建一个Student实例

 c.将此实例的地址赋值给引用stu， 栈空间