【Head First Java 读书笔记】（三）primitive主数据类型和引用

认识变量

变量有两种：primitive数数据类型和引用。

声明变量

Java注重变量。它不会让你将浮点数类型变量放进整数类型的变量中，除非你先跟编译器确认过数字可以损失掉精确度。

为了要让类型安全能过发挥作用，必须声明所有变量的类型。

变量有两种:primitive主数据类型和对象引用。

primitive主数据类型用来保存基本类型的值，包括整数、布尔和浮点数等，而对象引用保存的是对象的引用。

声明变量的规则：

variables must have type

变量必须拥有类型

variables must have a name

变量必须要有名称

变量就像是杯子，是一种容器，承载某些事物，他有大小与类型。

primitive主数据类型就如同咖啡馆的杯子，他们有不同的大小，而每种大学都有个名词，比如，小杯、大杯、中杯等。

每种primitive主数据类型变量有固定的位数(杯子大小)，存放数值的primitive主数据类型有下列6种大小

byte:8、short: 16、int:32、long: 64 、 float : 32 、double ：64

primitive主数据类型的赋值

要确保变量能存下所保存的值。

你无法用小杯子装大值。

举例，你无法把int大小的东西装进byte的容器中

你可以用几种方式来给变量赋值：

• 在等号后面直接打出
• 指派其他变量的值
• 上述两种方式的组合

避开关键字(keyword)

Java的命名规则：

名称必须以字母、下划线、或$符号开头，不能用数字开头

除了第一个字符以外，后面就可以用数字。只要不是用在第一个字符就行

只要符合上述两条规则，你就可以随意地命名，但还的要避开Java的保留字

保留字一览表

对象引用(Object Reference)

我们已经知道如何声明primitive主数据类型变量并赋值给她，但是非primitive主数据类型的变量该如何处理？即如何处理对象

---

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

你无法将对象装进变量中。

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

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

举例：

Dog d = new Dog();

d.bark();

名为d的变量引用对象上的bark(),可以把它想成遥控器和上面的按钮

对象引用也只是个变量值

还是会有东西放到杯子里面，只是引用放进去的是遥控器。

我们来看看primitive主数据类型和对象引用的区别

byte  x = 7;

代表数字7的字节(00000111)被放进变量中

Dog myDog = new Dog();

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

对primitive主数据类型中的变量来说，变量值就是所代表的值。对引用变量来说，变量值是取得特定对象的位表示法。

对象的声明、创建与赋值有3个步骤

1.声明一个引用变量

要求Java虚拟机分配空间给引用变量，并将此变量命名为myDog.此引用变量将永远被固定为Dog类型

2，创建对象

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

3.连接对象和引用

将新的Dog赋值给myDog这个引用变量。可以看作就是设定遥控器

问：引用变量有多大？

答：不知道，这是由Java虚拟机决定的，引用变量内部有指针，但你无法也不需要存取，若你是要讨论内存分配的问题，最需要关系的应该是需要建立多少个对象和引用，以及对象的实际大小。

问：既然这样，那是否意味着所有的对象引用都具有相同的大小，而不管它实际所引用的对象大小？

答：是的，对于任意一个Java虚拟机来说，所有的引用大小都一样，但不同的Java虚拟机可能用不同的方式来表示引用，因此某个Java虚拟机的引用大小可能会大于或小于另一个Java虚拟机的引用。

问：我可以对引用变量进行运算么，就像C语言那样？

答：不行。Java不是C

关于对象引用需要注意的几点：

对象引用可以被看作是一个遥控器，并且可以被设定来控制不同的对象。

但是,对象引用一旦声明，就无法改变，比如说生命为Dog类的对象引用，就不能让它指向别的类。

但可以引用某个Dog,然后又去引用另外一个Dog,只要是Dog类就行，就像重新设定遥控器一样。

但是，如果被标记为final的话，一点被指派给某个Dog,之后就不能赋值给这个特定Dog之外的任何事物，也就是说被固定下来了。

对象引用也可以引用到空指针，不引用任何东西，这样对象引用就是null，null也是个值，这就好像买了一个万能遥控器回家，但是家里没有电视。如果对象引用是某个对象的唯一引用却被设定为null，这意味着以后将没有其他人能够取得该对象。

在垃圾收集堆上的生活

Book b = new Book();

Book c = new Book();

---

Book d = c;

c和d引用到同一对象

相同的两份拷贝。相当于一台电视机有两个遥控器。

---

c = b ;

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

堆空间(堆上的生与死)

b = c

对象1被抛弃且能够做垃圾收集器(gc)

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

---

c = null

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

数组犹如杯架

int [] nums;//数组变量是数组对象的遥控器

nums = new int[7];//创建大小为7的数组，并将它赋值给nums;

赋予int数组每一个元素一个int值

nums[0]  = 6;

nums[1]  = 19;

nums[2]  = 44;

nums[3]  = 42;

nums[4]  = 10;

nums[5]  = 20;

nums[6]  = 1;

数组也是对象

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

数组是个对象，不管里面放的是不是primitive主数据类型。无论被声明来承载的是primitive主数据类型或对象引用，数组永远是对象。

对象的数组

Dog[] pets;

pets = new Dog[7];

我们虽然有了对Dog的引用，但缺少实际的Dog对象

记得Dog数组中只带有Dog的引用变量，我们还是需要Dog对象

pets[0] = new Dog();

pets[1] = new Dog();

Java注重类型

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

现在用一个小例子来使用引用

 package chapter3;

 public class Dog {
     String name;

     public void bark() {
         System.out.println(name + " says Ruff!");

     }

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

         Dog[] myDogs = new Dog[3];
         myDogs[0] = new Dog();
         myDogs[1] = new Dog();
         myDogs[2] = dog1;

         myDogs[0].name = "Fred";
         myDogs[1].name = "Marge";

         System.out.print("last dog's name is ");
         System.out.println(myDogs[2].name);

         int x = 0;
         while (x < myDogs.length) {
             myDogs[x].bark();
             x++;
         }
     }
 }

结果：

null says Ruff!
last dog's name is Bart
Fred says Ruff!
Marge says Ruff!
Bart says Ruff!

本节要点

• 变量有两种：primitive主数据类型和引用
• 变量的声明必须有类型和名称
• primitive主数据类型变量值是该值的字节所表示的
• 引用变量的值代表位于堆之对象的存取方法
• 引用变量如同遥控器，对引用变量使用圆点云算法可以如同按下遥控器按钮般的存取它的方法或实例变量
• 没有引用到任何对象的音乐变量的值为null值
• 数组一定是一个对象，不管所声明的元素是否为primitive主数据类型，并且没有primitive主数据类型的数组，只有装载primitive主数据类型的数组。