1. 前言
在《还不清楚怎样面向对象？》和《面向对象再探究》两篇文章中，都介绍了关于面向对象程序设计的概念和特点。其中也涉及到了许多代码，比如：
Dog dog = new Dog();
这篇文章就主要来谈谈创建对象时的具体操作。
2. 引入例子
下面是一个Dog类：
/**
* @author Xing Xiaoguan (xingrenguanxue)
*/
public class Dog {
private String name;
private int age;
private String address;
public void say() {
System.out.println("我叫" + name + "，今年" + age + "岁了，家住" + address + "，汪汪汪...");
}
//getters 和 setters
}
下面是一个Test类，创建了一个Dog对象，然后进行相关操作：
public class Test {
public static void main(String[] args) {
Dog dog = new Dog();
dog.setName("哮天犬");
dog.setAge(1);
dog.setAddress("光明小区")
dog.say();
}
}
输出：
我叫小黑，今年1岁了，家住光明小区，汪汪汪...
3. 对象和对象变量
对象是根据类创造出来的，我们使用的是具体的对象，而不是类。要想使用对象，那对象必须得先被创建出来才行。下面一行代码是创建对象的语句：
Dog dog = new Dog();
我们将其分成三部分来看：
（1）new ：如果你想创建一个对象，那么必须使用new操作符。
（2）Dog()：这是一个构造器，构造器是一个特殊的方法。通过调用该构造器，我们可以创建并初始化一个对象出来。
new Dog()连起来就能正确地创建出一个对象了。但是我们创造出来的对象并不只会使用一次，而会使用许多次，所以我们需要给该对象 “取一个名字”，保证它“随叫随到”。这就需要第三部分了：
（3）Dog dog：声明一个Dog类型的、名为dog的变量。它就类似于int number，声明一个int类型的number变量。
然后我们使用=进行赋值（引用），便给创建出的对象 “取一个名字” 叫dog，以后可以称它为dog对象。
这里可能会出现一个误区，认为：Dog dog部分便能创建出一个dog对象，这是错误的。应当明确：dog从头到尾都只是一个变量而已。这个变量和使用int number、String str等方式声明的变量，除了类型不同之外并无差别。
真正创建出对象的是new Dog()部分。
下面解释一下 “取一个名字” 是什么意思。
在Java中，对象变量中存储的并不是对象，真正的变量在内存的某个地方躺着呢。该变量记录的是对象在内存中的位置，我们有了对象变量，就有了对象的位置，有了位置，就能找到真正的对象。
看下面的代码：
public class Test {
public static void main(String[] args) {
Dog dog = new Dog();//创建出一个dog对象
System.out.println(dog);//打印dog
}
}
打印结果：basic.Dog@1b6d3586
1b6d3586便是dog对象在内存中的地址。
4. 构造器
前面提到，创建一个对象的关键在于使用new操作符和构造器。构造器是一个特殊的方法，通过调用构造器，我们可以创建并初始化一个对象出来。
构造器的特点：
- 有一个访问修饰符
- 构造器的名字和类名相同
- 构造器没有返回值
- 构造器要和
new操作符一起使用 - 构造器可以有0个、1个或多个构造器
- 一个类中可以有多个构造器
4.1. 无参构造器
即没有参数的构造器，如Dog()。无参构造器是Java默认的构造器，如果你在编写类时没有写构造器，那么Java会在类中默认提供一个无参构造器。
在Dog类中并没有写构造器，Dog类默认拥有下面的无参构造器：
public Dog() {
}
4.2. 有参构造器
有参构造器，即有参数的构造器。例如：
public Dog(String n, int a, String addr) {
name = n;
age = a;
address = addr;
}
这个有参构造器非常简单，分别给n、a参数传值，然后给对象的属性赋值。美中不足的是参数的变量名取得不够“见名知意”，所以我们通常这样写：
public Dog(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
参数的名字和对象的成员变量名一样，这样，参数的意义就很清晰了。在赋值的时候，使用this关键字区分二者，因为this代表我们所创建的对象，this.name即对象的成员变量。
有了有参构造器，我们就可以在创建对象时初始化对象的属性，比如：
public static void main(String[] args) {
Dog dog = new Dog("小狗有参", 1, "地球");
dog.say();
}
输出：
我叫小狗有参，今年1岁了，家住地球，汪汪汪...
4.3. 多个构造器的使用
先了解一个概念——重载（overloading）。重载是指在一个类中，有几个方法的方法名字相同，而参数不同。返回值类型可以相同也可以不相同。注意：每个重载的方法的参数列表必须独一无二。
注意：参数列表的独一无二是指参数列表的类型的独一无二。
千万不要以为
func(String name)和func(String address)这两个方法的参数列表是不同的。它俩应该这样看：func(String)和func(String)，所以这俩方法是相同的。
下图是String类中的部分方法的重载情况，可从中体会参数列表的独一无二：
为什么要求参数列表必须独一无二呢？
这就得介绍另一个概念——方法的签名。方法的签名是指要完整地描述一个方法，需要指出方法名和参数类型。注意：方法的返回类型不是签名的一部分。
所以在Java中，方法名和参数列表能确定一个方法。不存在方法名和参数列表相同，而返回类型不同的方法们。
而重载要求的是方法名相同，参数列表不同。从方法的签名角度来看，重载方法之间本就是不同的方法。
由于重载的存在，我们可以在一个类中编写多个参数列表不同的构造器，使该类具有多种创建对象的形式。比如：
public class Dog {
private String name;
private int age;
private String address;
public Dog() {//无参构造器，有其他构造器存在，系统不会默认提供
}
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
public Dog(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
public void say() {
System.out.println("我叫" + name + "，今年" + age + "岁了，家住" + address + "，汪汪汪...");
}
//getters 和 setters
}
写了三种构造器，便有三种创建对象的方式：
Dog dog = new Dog("小狗", 1, "太阳系");
Dog dog1 = new Dog("小狗1", 2);
Dog dog2 = new Dog();
编译器会根据我们提供的参数匹配到合适的构造器。
注意：无参构造器只有在我们没有编写任何构造器时，系统才会默认提供。所以当一个类中有其他构造器时，如果我们需要无参构造器，那么必须手动编写出来，系统不会默认提供。
4.4. 构造器之间的关系
在类中，一个构造器可以调用另一个构造器。如下例：
/**
* @author Xing Xiaoguan (xingrenguanxue)
*/
public class Dog {
private String name;
private int age;
private String address;
public Dog(String name, int age) {
this(name, age, "银河系");//调用另一个构造器
System.out.println("两个参数的构造器");
}
public Dog(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
System.out.println("三个参数的构造器");
}
public void say() {
System.out.println("我叫" + name + "，今年" + age + "岁了，家住" + address + "，汪汪汪...");
}
//getters and setters...
}
使用Dog(String, int)创建对象：
public class Test {
public static void main(String[] args) {
Dog dog = new Dog("小狗有参", 1);
dog.say();
}
}
输出：
三个参数的构造器
两个参数的构造器
我叫小狗有参，今年1岁了，家住银河系，汪汪汪...
我们在构造器的第一行语句中使用this(...)来调用另一个构造器。注意：一定要是第一行语句。
5. 对象属性的初始化
所谓初始化，就是我们在创建对象同时设置对象的属性值。
5.1. 默认的属性值
当我们创建对象时如果不显式地设置属性值，对象的属性值会被初始化为默认值。
数值的默认值为0，布尔值的默认值为false，对象引用的默认值为null。
如下例中的Dog类的属性值：
public class Dog {
private String name;
private int age;
private String address;
public void say() {
System.out.println("我叫" + name + "，今年" + age + "岁了，家住" + address + "，汪汪汪...");
}
}
创建对象：
public static void main(String[] args) {
Dog dog = new Dog();
dog.say();
}
输出：
我叫null，今年0岁了，家住null，汪汪汪...
5.2. 直接设置属性值
我们可以在类中直接设置类的属性值，这样一来，根据该类创建的对象的属性值就确定了。
如下例中Dog类的属性值：
public class Dog {
private String name = "小黑";
private int age = 2;
private String address = "太阳系";
public void say() {
System.out.println("我叫" + name + "，今年" + age + "岁了，家住" + address + "，汪汪汪...");
}
}
这时再创建对象：
public static void main(String[] args) {
Dog dog = new Dog();
dog.say();
}
输出：
我叫小黑，今年2岁了，家住太阳系，汪汪汪...
5.3. 使用构造器初始化
(一) 当构造器中没有显式地设置对象的属性值时，这些属性值会被初始化为默认值。如下面的无参构造器：
public Dog() {
}
创建对象：
public static void main(String[] args) {
Dog dog = new Dog();
dog.say();
}
输出：
我叫null，今年0岁了，家住null，汪汪汪...
（二）可以在无参构造器的方法体中初始化属性值：
public Dog() {
name = "小黑";
age = 2;
address = "宇宙";
}
创建对象：
public static void main(String[] args) {
Dog dog = new Dog();
dog.say();
}
输出：
我叫小黑，今年2岁了，家住宇宙，汪汪汪...
（三）也可以使用有参构造器，对象会按照我们传入的变量初始化属性值：
public Dog(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
创建对象：
public static void main(String[] args) {
Dog dog = new Dog("小黑", 3, "南极");
dog.say();
}
输出：
我叫小黑，今年3岁了，家住南极，汪汪汪...
如有错误，还请指正。