3.primitive主数据类型和引用认识变量

3.1 声明变量

Java注重类型。它不会让你做出把长颈鹿类型变量装进兔子类型变量中这种诡异又危险的举动——如果有人对长颈鹿调用“跳跃”这个方法会发生什么样的悲剧？并且它也不会让你将浮点数类型变量放进整数类型的变量中，除非你先跟编译器确认过数字可以损失掉精确度(例如说舍去所有的小数值)。

编译器会指出大部分的问题：
Rabbit hopper = new Giraffe();
这样的程序过不了编译器这关。

为了要让类型安全能够发挥作用，必须声明所有变量的类型，指定它是个int类型或是个Dog类型。变量有两种口味：清凉的primitive主数据类型与香辣的对象引用。primitive主数据类型用来保存基本类型的值，包括整数、布尔和浮点数等。而对象引用保存的是对象的引用。

先记住下面这条声明变量的规则：
variables must have a type
变量必须拥有类型。另一条规则是必须要有名称。
variables must have a name—

int count;
类型名称

注意：当你读到“X 类型的 Y 对象”时，类型（type）此时与类是相通的同义字。

3.2 Primitive主数据类型

变量就像是杯子，是一种容器，承装某些事物。

primitive主数据类型

类型位数值域

boolean与char

boolean (Java虚拟机决定) true或false

char 16 bits 0~65535

数值（带正负号）

integer

byte 8 bits -128 ~ 127

short 16 bits -32768 ~ 32767

int 32 bits -2147483648 ~ 2147483647

long 64 bits -很大 ~ +很大

浮点数

float 32 bits 范围规模可变

double 64 bits 范围规模可变

primitive主数据类型的声明与赋值声明

int x;

x = 234;

byte b = 89;

boolean isFun = true;

double d = 3456.98;

char c = 'f';

int z = x;

boolean isPunkRock;

isPunkRock = false;

boolean powerOn;

powerOn = isFun;

long big = 3456789;

float f = 32.5f;

除非加上f，否则所有带小数点的值都会被Java当作double处理

当心溢出，要确保变量能存下所保存的值

编译器不允许将大变量赋值给小变量，但是反过来可以

3.3 Java关键字

类、方法、变量命名规则：

名称必须以字母、下划线（_）或$符号开头，不能用数字开头
除了第一个字符之外，后面就可以用数字
避开Java的保留字

3.4 引用变量

事实上没有对象变量这样的对象存在
只有引用（reference）到对象的变量
对象引用变量保存的是存取对象的方法
它并不是对象的容器，二十类似指向对象的指针。或者可以说是地址。但在Java中我们不会也不该知道引用变量中实际装载的是什么，它只是用来代表单一的u对象。只有Java虚拟机才会知道如何使用引用来取得该对象。

无法将对象装进变量中

虽然primitive主数据类型变量是以字节来代表实际的变量值，但对象引用变量却是以字节来表示取得对象的方法

使用圆点运算符（.）来对引用变量表示，取得圆点前面的对象，然后求出该对象在圆点后面的事物。

3.5 对象的声明与赋值

对象引用也只是个变量值，还是会有东西放进杯子中，只是引用所放进去的是遥控器

Primitive主数据类型变量

byte x = 7;

代表数值7的字节被放进变量中（00000111）

引用变量

Dog myDog = new Dog();

代表取得Dog对象的方法以字节形式放进变量中，对象本身并没有放进变量中

对primitive主数据类型中的变量来说，变量值就是所代表的值（如5、-26.7或a’）。对引用变量来说，变量值是取得特定对象的位表示法。

1.声明一个引用变量

Dog myDog = new Dog();

要求Java虚拟机分配空间给引用变量，并将此变量命名为myDog。此引用变量将永远被固定为Dog类型。换句话说，它是个控制Dog的遥控器，不会是Cat或皮卡丘的遥控器。

2.创建对象

Dog myDog = new Dog();

要求Java虚拟机分配堆空间给新建立的Dog对象

3.连接对象和引用

Dog myDog = new Dog();

将新的Dog赋值给myDog这个引用变量，换言之就是设定遥控器

3.6 可回收堆空间

1.在垃圾收集堆上的生活

Book b = new Book();

Book c = new Book();

声明两个Book的引用变量并创建两个Book对象，然后将Book对象赋值给引用变量。现在这两个Book对象生活在堆上。

引用数：2

对象数：2

Book d = c;

声明新的Book引用变量，但不创建新的Book变量而将变量c的值赋给值给变量d。这代表“将c的字节组合拷贝给变量d”

c与d引用到同一对象

相同值的两份拷贝，一台电视两个遥控器。

引用数：3

对象数：2

c = b;

把变量b的值赋给变量c。变量b的字节组合被拷贝一份给c

b与c两者都引用相同的对象

引用数：3

对象数：2

2.堆上的生与死

Book b = new Book();

Book c = new Book();

声明两个Book的引用变量并创建两个Book对象，然后将Book对象赋值给引用变量。现在这两个Book对象生活在堆上。

引用数：2

对象数：2

b = c;

把变量c的值赋给变量b，两者带有相同的值。

对象1被抛弃且能够作垃圾收集器（GC）。

引用数：2

对象数：2

被抛弃对象数：1

对象1已经没有引用，变成无法存取的。

c = null;

将null值赋给c。这代表它不再引用任何事物，但还是个可以被指定引用其他Book的引用变量

对象2还引用到，所以不能够作垃圾收集器（GC）

作用中的引用数：1

null引用数：1

可存取对象数：1

被抛弃对象数：1

3.7 数组

数组犹如杯架

1.声明一个int数组变量。数组变量是数组对象的遥控器

int[] nums;

2.创建大小为7的数组，并将它赋值给之前声明为int[]的变量nums

nums = new int[7];

3.赋予int数组的每一个元素一个int值。在int数组中的每个元素皆为int类型的变量

nums[0] = 6;

nums[1] = 19;

nums[2] = 44;

nums[3] = 42;

nums[4] = 10;

nums[5] = 20;

nums[6] = 1;

数组也是对象，不论被声明来承载的是primitive主数据类型或对象引用

Java的标准函数库包含了许多复杂的数据结构，比如map、tree和set（见附录B），但如果需要快速、有序、有效率地排列元素时，数组是不错的选择。数组能够让你使用位置索引来快速、随机地存取其中的元素。

数组中的每个元素都是变量。换言之，会是8种primitive主数据类型变量中的1种，不然就是引用变量。可以放进该类型变量中的值都可以当作此类型数组的元素。所以在int类型的数组中，每个元素可以装载一个int。所以在Dog的数组中(Dogll)每个可以装载一个Dog吗？错，要记得引用变量只会保存引用，而不是对象本身。因此Dog数组的元素持有的是Dog的遥控器。当然啦，我们还得创建Dog对象。

创建Dog数组

1.声明一个Dog数组变量

Dog[] pets;

2.创建大小为7的Dog数组，并赋值给前面所声明出的Dog[]类型变量pets

pets = new Dog[7];

3.创建新的Dog大小并将他们赋值给数组的元素。

pets[0] = new Dog();

pets[1] = new Dog();

控制Dog（通过引用变量）

Dog fido = new Dog();

fido.name = "Fido";

我们创建出Dog对象并使用圆点运算符来操作引用变量fido并存取它的name变量。
我们可以运用fido这个引用来让Dog执行bark()或其他的方法。
fido.bark();

fido.chaseCat();

如何存取Dog数组中的Dog

对数组的操作可以不需要变量名称，只需要数组索引（位置）就可以操作特定对象

Dog[] myDogs = new Dog[3];

myDogs[0] = new Dog();

myDogs[0].name = "Fido";

myDogs[0].bark();

Java注重类型
一旦数组被声明出来，你就只能装入所声明类型的元素。

举例来说，你不能将Cat放到Dog数组中（如果有人尝试要让数组中的每个元素都汪汪叫一次会出现什么状况？）。double也不能放进int数组中。但是你可以将byte放进int的数组中，因为byte可以放进int尺寸的杯子中。这被称为隐含展开（implicit widening，稍后会有更多的说明，现在只需要注意编译器会根据数组所声明的类型来防止错误的类型）。

public class Dog {
    String name;

    public static void main(String[] args) {
        //创建Dog对象
        Dog dog1 = new Dog();
        dog1.bark();
        dog1.name = "Bart";

        //创建Dog数组
        Dog[] myDogs = new Dog[3];
        //关门放狗
        myDogs[0] = new Dog();
        myDogs[1] = new Dog();
        myDogs[2] = dog1;

        //通过数组引用存取Dog
        myDogs[0].name = "Fired";
        myDogs[1].name = "Marge";

        //myDog[2]的名字是
        System.out.print("last dog's name is ");
        System.out.println(myDogs[2].name);

        //逐个对Dog执行bark()
        int x = 0;
        while (x < myDogs.length) {
            myDogs[x].bark();
            x = x + 1;
        }
    }
    public void bark() {
        System.out.println(name + " says Ruff!");
    }
    public void eat() { }
    public void chaseCat() { }
}