对象与对象变量：
要想使用对象，就必须首先构造对象，并指定其初始状态，然后，对对象应用方法。
在Java中，使用构造器构造新实例。构造器是一种特殊的方法，用来构造并初始化对象。
在实际开发中，通常需要将对象存放在一个变量中来达到多次使用的目的。
在这里，birth指向了Date对象的存储的地方的引用。
Date birthday = new Date();
在对象与对象变量直接存在着一个重要的区别，例如：
Date deadline; //deadline dosen't refer to any object;
定义了一个对象变量，它可以引用Date类型的对象，但是，一定要认识到：变量deadline不是一个对象，实际上也没有引用一个对象。并且不能用任何Date方法应用与这个变量上
s = deadline.toString(); // not yet
在这里，将会产生编译错误。
首先，必须初始化变量deadline,可以用新构造的对象初始化，也可以引用一个已存在的变量。
deadline = new Date() //新构造对象 // //或者 Date birthday = new Date(); deadline = birthday; //引用一个已存在对象
当引用一个已存在的变量时，两个变量引用同一个对象：
在Java开发中，一定要认识到，一个对象变量并没i月实际包含一个对象，而仅仅使用一个对象，任何对象变量的值都是对存储在另外一个地方的一个对象的引用。
构造器：
首先来看一个Employee类：
class Employee { // instance fields private String name; private double salary; private LocalDate hireDay; // constructor 构造器 public Employee(String n, double s, int year, int month, int day) { name = n; salary = s; hireDay = LocalDate.of(year, month, day); } // a method public String getName() { return name; } // more methods . . . }
该类的构造器与类同名，在构造Employee类的对象时，构造器会运行，并将实例初始化为所希望的状态。
例如，当使用下面代码实例化时：
new Employee("James Bond", 100000, 1950, 1, 1);
将会把实例域设置为：
name = "James Bond"; salary = 100000; hireDay = LocalDate.of(1950, 1, 1); // January 1, 1950
构造器与其他方法有一个区别，即构造器伴随着new操作符被调用并且没有返回类型，而不能通过一个对象调用构造器，如下将会产生编译错误。
james.Employee("James Bond", 250000, 1950, 1, 1) // ERROR
重载：
一个类可以拥有多个构造器。
如果在一个类中，拥有多个方法，每个方法具有相同的名字，不同的参数，便产生了重载。编译器必须挑选出具体执行那个方法。
通常，多个具有相同名字不同参数的方法，是通过它们的签名来辨识的。
什么是方法的签名？
一个方法的签名即为它的方法名称，以及参数类型。注意，返回类型并不属于一个方法的签名！也就是说，不能具有相同名字，相同参数，而返回类型不同的两个方法。
默认域初始化：
如果在构造器中没有显式的给域赋予初始值，那么域会被自动地赋予默认值，数值为0，布尔值为false，对象引用为null。
这是域与局部变量的主要不同点。局部变量必须明确地初始化。
无参数的构造器：
很多类都包含一个无参数的构造函数，对象由构造函数创建时，状态会被设置为适当的默认值，如下为Employee类的无参数构造函数：
public Employee() { name = ""; salary = 0; hireDay =new Date(); }
如果一个类没有编写构造器的话，那么系统就会提供一个无参数构造器。
调用另一个构造器：
如果构造器的第一个语句形如this(...),这个构造器将会调用同一个类的另一个构造器，下面是一个典型的例子：
public Employee(double s){ this("Employee ",s); }
当调用new Employee(60)时，Employee(double)构造器将调用Employee(String,double)构造器。
初始化块：
通常，初始化数据域有三种方法，一种是在构造器设置，一种是在声明中赋值，还有一种是初始化话块，只要构造类的对象，这些块就会被执行。
class Employee { private static int nextId; private int id; private String name; private double salary; // object initialization block 初始化块 { id = nextId; nextId++; } public Employee(String n, double s) { name = n; salary = s; } public Employee() { name = ""; salary = 0; } . . . }
由于初始化数据域有多种途径，所以可能会有些混乱，下面是调用构造器的具体处理步骤：
1.所有数据域被初始化默认值。
2.按照类声明中出现的次序，依次执行所有域初始化语句和初始化块。
3.如果构造器第一行调用了第二个构造器，则执行第二个构造器的主体。
4.执行这个构造器的主体。
不要编写返回引用可变对象的访问器方法：
例如：
class Employee { private Date hireDay; . . . public Date getHireDay() { return hireDay; // Bad } . . . }
这样会破坏封装性，即可以不通过Hireday的设置器方法就能改变Hireday,具体如下代码：
Employee harry = . . .; Date d = harry.getHireDay(); double tenYearsInMilliSeconds = 10 * 365.25 * 24 * 60 * 60 * 1000; d.setTime(d.getTime() - (long) tenYearsInMilliSeconds); // let's give Harry ten years of added seniority
出错的原因即为d和harry.hireDay引用同一个对象，参见图：
实际上，返回对象应对其进行克隆，并返回该克隆对象。
final实例域：
可以将实例域定义为final,构建对象时必须初始化这样的域，也就是说，确保在每一个构造器执行之后，这个域的值被设置，并且在后面的从早中，不能够在对它进行修改。
通常，不推荐是哦那个final修饰符应用于可变的类，如下：
private final Date hiredate;
这仅仅意味着，存储在hiredate变量的对象引用不可变，也就是说永远指向同一个对象引用，但任何方法都可以对hiredate引用的对象调用setTime更改器来改变该对象。
静态域与静态方法：
如果将域定义为static，每个类中只有一个这样的域。而每一个对象对于所有的实例域却都有一份自己的拷贝。静态域是所有对象共享的，如这里给Employee类添加一个实例域id和一个静态域nextId:
class Employee { private static int nextId = 1; private int id; . . . }
换句话说，如果有1000个Emplyee对象，那么就有1000个id实例域，但却只有一个nextId静态域。即使没有实例对象时，静态域也是存在的，它是属于类，而不是属于对象。
静态方法同理。
方法参数：
Java中的参数是一种值引用。
首先，观察一下基本数据类型（数字、布尔值）。
public static void tripleValue(double x) // doesn't work { x = 3 * x; } double percent = 10; tripleValue(percent);
当我们将percent作为参数给一个方法时，经过执行后，percent本身并没有改变，这个很容易理解。
接下来看一下对象引用：
public static void tripleSalary(Employee x) // works { x.raiseSalary(200); }
当调用如下语句时：
harry = new Employee(. . .); tripleSalary(harry);
具体的操作过程如下：
1.x被初始化harry值的拷贝，这是一个对象的引用。
2.raiseSalary方法应用于这个对象的引用，x和harry同时引用的那个Employee对象的薪金提高了200%。
3.方法结束后，参数变量x不再使用。当然，对象变量harry继续引用那个薪金增3倍的对象。
看到这里，或许会认为Java的对象参数是引用调用，实际上，并不是。
依然是按值调用，传给tripleSalary函数的实际上是harry值的拷贝，而harry值指向了一个对象引用，所以x也指向了该引用，所以才会引起变化。
可以通过下面这个例子得出结果：
public static void swap(Employee x, Employee y) // doesn't work { Employee temp = x; x = y; y = temp; }
如果Java是按引用调用的话，那么执行下面语句后，a与b应该互换。
Employee a = new Employee("Alice", . . .); Employee b = new Employee("Bob", . . .); swap(a, b); // does a now refer to Bob, b to Alice?
但在测试中，并没有互换，所以传入的实际上是a,b的拷贝，也就是一个对象引用，这个方法交换的是这两个拷贝。
最终，函数结束时，变量x，y被丢弃了，原来的ab对象变量依然引用之前的对象。