本章章节
> 5.1 面向对象程序设计的基本概念
> 5.2类与对象
> 5.3类的封装性
> 5.4在类内部调用方法
> 5.5引用数据类型的传递
> 5.6构造方法
> 5.7匿名对象
> 5.8对象的比较
> 5.9 this 关键字的使用
> 5.10 static 关键字的使用
> 5.11构造方法的私有
> 5.12对象数组的使用
> 5.13 Java基本数据类型的包装类
> 5.14 String类的常见方法
> 5.15 Java文档注释
.本章摘要:
5.6 构造方法
在前面的Java程序里，我们将属性封装之后，需要提供公共的getXxx和setXxx函数集来初始化变量和获取变量。利用构造方法也可以实现给新创建的对象的各个成员属性赋初值。构造方法可视为一种特殊的方法，它的定义方式与普通方法类似，其语法如下所示：
<修饰符> class 类名称 { 访问权限 类名称(类型1 参数1，类型2 参数2，…) { 程序语句; … // 构造方法没有返回值 } }
在使用构造方法的时候请注意以下几点：
1、构造方法的名称与类的名称相同
2、构造方法没有返回值
3、构造方法可以重载
如上所述，构造方法除了没有返回值，且名称必须与类的名称相同之外，它的调用时机也与一般的方法不同。一般的方法是在需要时才调用，而构造方法则是在创建对象时，便自动调用，并执行构造方法的内容。因此，构造方法无需在程序中直接调用，而是在对象产生时自动执行。
基于上述构造方法的特性，可利用它来对对象的数据成员做初始化的赋值。所谓初始化就是为对象的赋初值。
下面的程序TestConstruct.java说明了构造方法的使用。
范例：TestConstruct.java
class Person { public Person() // Person类的构造方法 { System.out.println("public Person()"); } } public class TestConstruct { public static void main(String[] args) { Person p = new Person(); } }
输出结果：
public Person()
程序说明：
1、程序1~7行声明了一个Person类，此类中只有一个Person的构造方法。
2、程序3~6行声明了一个Person类的构造方法，此方法只含有一个输出语句。
3、程序第12行实例化一个Person类的对象p，此时会自动调用Person中的无参构造方法，即在屏幕上打印信息。
从程序中不难发现，在类中声明的构造方法，会在实例化对象时自动调用。你可能会问，在之前的程序中用同样的方法来产生对象，但是在类中并没有声明任何构造方法，而程序不也一样正常运行了吗？
实际上，在执行javac编译java程序的时候，如果在程序中没有明确声明构造方法的话，系统会自动为类加入一个无参的且什么都不做的构造方法。类似于下面代码：
public Person(){}
所以，之前所使用的程序虽然没有明确的声明构造方法，也是可以正常运行的。但是需要注意的是，一旦用户自己写了构造函数之后，系统就不会再提供默认的构造函数。
5.6.1 构造方法的重载
在Java里，不仅普通方法可以重载，构造方法也可以重载。只要构造方法的参数个数不同，或是类型不同或顺序不同，便可定义多个名称相同的构造方法。这种做法在java中是常见的，请看下面的程序。
范例：TestConstruct1.java
class Person { private String name; private int age;
public Person(String n, int a) { name = n; age = a; System.out.println("public Person(String n, int a)"); } public String talk() { return "我是："+name+"，今年："+age+"岁"; } } public class TestConstruct1 { public static void main(String[] args) { Person p = new Person("张三", 25); System.out.println(p.talk()); //Person p2 = new Person();//加入此行会报错，因为没有无参的构造函数 //System.out.println(p2.talk()); } }
输出结果：
public Person(String n, int a)
我是：张三，今年：25岁
程序说明：
1、程序1~15行声明了一个Person类，里面有name与age两个私有属性，和一个talk()方法。
2、程序第5~10行，在Person类中声明一个含有两个参数的构造方法，此构造方法用于将传入的值赋给Person类的属性。
3、程序第20行调用Person类中有的含有两个参数的构造方法“new Person("张三",25)”。
4、程序第21行调用Person类中的talk()方法，打印信息。
从本程序可以发现，构造方法的基本作用就是为类中的属性初始化的，在程序产生类的实例对象时，将需要的参数由构造方法传入，之后再由构造方法为其内部的属性进行初始化。这是在一般开发中经常使用的技巧。但是如果加入22、23行的代码就会报错。因为在java程序中只要明确的声明了构造方法，则默认的构造方法将不会被自动生成。而要解决这一问题，只需要简单的修改一下Person类就可以了，可以在Person类中明确地声明一个无参的且什么都不做的构造方法。
范例：TestConstruct2.java
class Person { private String name; private int age; public Person() { } public Person(String n, int a) { name = n; age = a; System.out.println("public Person(String n,int a)"); } public String talk() { return "我是：" + name + "，今年：" + age + "岁"; } } public class TestConstruct2 { public static void main(String[] args) { Person p = new Person(); System.out.println(p.talk()); } }
可以看见，在程序的第5、6行声明了一个无参的且什么都不做的构造方法，此时再编译程序的话，就可以正常编译而不会出现错误了。
5.7 匿名对象
“匿名对象”，顾名思义，就是没有名字的对象。也可以简单的理解为只使用一次的对象，即没有任何一个具体的对象名称引用它。请看下面的范例：
范例：TestNoName.java
class Person { private String name = "张三"; private int age = 25; public String talk() { return "我是：" + name + "，今年：" + age + "岁"; } } public class TestNoName { public static void main(String[] args) { System.out.println(new Person().talk()); } }
输出结果：
我是：张三，今年：25岁
程序说明：
1、程序1~9行声明了一个Person类，里面有name与age两个私有属性，并分别赋了初值。
2、在程序第14行，声明了一个Person匿名对象，调用Person类中的talk()方法。可以发现用new Person()声明的对象并没有赋给任何一个Person类对象的引用，所以此对象只使用了一次，之后就会被Java的垃圾收集器回收。
5.8 对象的比较
Java程序中测试两个变量是否相等有两种方式，一种是利用==运算符，另一种是利用equals方法。
当使用==来判断两个变量是否相等时，如果两个变量是基本数据类型的变量，且都是数值类型，只要两个变量的值相等，就会返回布尔值true。但对于两个引用类型的变量，他们必须指向同一个对象时，才会返回布尔值true。否则，返回false。
equals方法是Object类（所有类的父类）提供的一个实例方法，所有引用变量都可以调用该方法判断是否与其他变量相等。Object类提供的equals方法没有太大意义，默认的equals方法，当两个引用变量指向一个对象才会返回true，跟“==”类似。如果希望采用自定义的相等标准，可以采用重写equals方法来实现。
先以String类为例，String类中已经重写了equals方法。“==”操作符用于比较两个String对象的内存地址值是否相等，equals()方法用于比较两个String对象的内容是否一致。
范例：TestEquals.java
public class TestEquals { public static void main(String[] args) { String str1 = new String("java"); String str2 = new String("java"); String str3 = str2; if (str1 == str2) System.out.println("str1 == str2"); else System.out.println("str1 != str2"); if (str2 == str3) System.out.println("str2 == str3"); else System.out.println("str2 != str3"); } }
输出结果：
str1 != str2
str2 == str3
由程序的输出结果可以发现，str1不等于str2，str1与str2的内容完全一样，为什么会不等于呢？在程序的第5和第6行分别实例化了String类的两个对象，此时，这两个对象指向不同的内存空间，所以它们的内存地址是不一样的。这个时候程序中是用的“==”比较，比较的是内存地址值，所以输出str1!=str2。程序第7行，将str2的引用赋给str3，这个时候就相当于str3也指向了str2的引用，此时，这两个对象指向的是同一内存地址，所以比较值的结果是str2==str3。
那该如何去比较里面的内容呢？这就需要采用另外一种方式——“equals”，请看下面的程序，下面的程序TestEquals1.java修改自程序TestEquals.java，如下所示：
范例：TestEquals1.java
public class TestEquals1 { public static void main(String[] args) { String str1 = new String("java"); String str2 = new String("java"); String str3 = str2; if (str1.equals(str2)) System.out.println("str1 equals str2"); else System.out.println("str1 not equals str2"); if (str2.equals(str3)) System.out.println("str2 equals str3"); else System.out.println("str2 note equals str3"); } }
输出结果：
str1 equals str2
str2 equals str3
这个时候可以发现，在程序中将比较的方式换成了equals，而且调用equals()方法的是String类的对象，所以可以知道equals是String类中的方法。在这里一定要记住：“==”是比较内存地址值的，“equals”是比较内容的。
小提示：
你可能会问，下面两种String对象的声明方式到底有什么不同？
String str1 = new String("java");
String str2 = "java";
下面先来看一个范例：
public class StringDemo { public static void main(String[] args) { String str1 = "java"; String str2 = new String("java"); String str3 = "java"; System.out.println("str1 == str2 ? --- > " + (str1 == str2)); System.out.println("str1 == str3 ? --- > " + (str1 == str3)); System.out.println("str3 == str2 ? --- > " + (str3 == str2)); } }
输出结果：
str1 == str2 ? --- > false
str1 == str3 ? --- > true
str3 == str2 ? --- > false
由程序输出结果可以发现，str1与str3相等，这是为什么呢？还记得上面刚提到过“==”是用来比较内存地址值的。现在str1与str3相等，则证明str1与str3是指向同一个内存空间的。可以用图5-11来说明：
图5-11 String对象的声明与使用
由图中可以看出“java”这个字符串在内存中开辟的一个空间，而str1与str3又同时指向同一内存空间，所以即使str1与str3虽然是分两次声明的，但最终却都指向了同一内存空间（可以把它理解为C语言的文字常量区）。而str2是用new关键字来开辟的空间，所以单独占有自己的一个内存空间。
另外，需要注意的是，如果用new关键字开辟String对象的内存空间的话，则实际上就开辟了两个内存空间，如图5-12所示：
图5-12 String对象内容的改变
由图 5-12（A）中不难发现，如果要改变str1的值，则会先断开原有的对象引用，再开辟新的对象，之后再指向新的对象空间。
用图 5-12（B）的方法也可以实现改变String对象的声明的操作，可以发现，用new String("java")方式实例化 String 对象时，实际上是开辟了两个内存空间，所以一般在开发上都采用直接赋值的方式，即：String str1 = "java"。
再来看看普通类的实例：
范例：TestCompare.java
class Person { String name; int age;
Person(String name, int age) { this.name = name; this.age = age; } public boolean equals(Object obj) //可以试着将这个函数注释掉 { if (obj instanceof Person)
{ Person p = (Person) obj; if (this.name.equals(p.name) && this.age == p.age) return true; } return false; } } public class Test { public static void main(String[] args) { Person p1 = new Person("张三", 30); Person p2 = new Person("张三", 30); //直接==，比较的是地址 System.out.println(p1 == p2 ? "相等,是同一人!" : "不相等,不是同一人!"); //调用自己复写的equals方法，比较的是内容 System.out.println(p1.equals(p2) ? "相等,是同一人!" : "不相等,不是同一人!"); } }
输出结果：
相等,是同一人!
实例中我们复写了Object类的equals方法，此时利用p1.equals(p2)调用的是自己本身的equals方法，按照自己定义的比较规则来比较两个对象是否相同。
5.9 this 关键字的使用
在整个java的面向对象程序设计中，this是一个比较难理解的关键字，在前面调用类内部方法时，曾经提到过this。this强调对象本身，那么什么是对象本身呢？其实就是当前对象本身，而所谓的当前对象就是指调用类中方法或属性的那个对象。即“哪个对象调用的，则this就具备谁的身份”。
this 关键字有以下作用：
·通过this操作类中的属性和普通方法；
·使用this调用本类的构造方法；
·this表示当前对象；
先来看一下下面的程序片段：
范例：Person.java
class Person { private String name; private int age;
public Person(String name,int age) { name = name; age = age; } }
看上面的程序可以发现会有些迷惑，程序的本意是通过构造方法为name和age进行初始化的，但是在构造方法中声明的两个参数的名称也同样是name和age，此时执行name=name，没能完成赋值，只是将形参变量自己赋给了自己。没能修改到类中的成员变量。为了避免这种混淆的出现，可以采用this这种方式，请看修改后的代码：
范例：Person.java
class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } }
Person.java这段代码与之前的不同之处在于在第7、8行分别加上了this关键字。还记得之前说过的this表示当前对象吗？那么此时的this.name和this.age就分别代表类中的name与age属性，这个时候再完成赋值操作的话，就可以清楚的知道谁赋值给谁了。完整程序代码如下：
范例：TestJavaThis.java
class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public String talk() { return "我是：" + name + "，今年：" + age + "岁"; } } public class TestJavaThis { public static void main(String[] args) { Person p = new Person("张三", 25); System.out.println(p.talk()); } }
输出结果：
我是：张三，今年：25岁
程序说明：
1、程序第1~14行声明了一个名为Person的类。
2、第5~9行声明Person类的一个构造方法，此构造方法的作用是为类中的属性赋初值。
5.9.1 用 this 调用构造方法
如果在程序中想用某一构造方法调用另一构造方法，可以用this来实现，具体的调用形式如下：
this();
在使用 this 关键字调用其他构造方法的时候，有以下几点限制；
·this()调用构造方法的语句只能放在构造方法的首行(非构造方法不可以使用)。
·至少有一个构造方法是不用 this调用的。
范例：TestJavaThis1.java
class Person { String name; int age;
public Person() { System.out.println("1. public Person()"); } public Person(String name, int age) { // 调用本类中无参构造方法 this(); this.name = name; this.age = age; System.out.println("2. public Person(String name,int age)"); } } public class TestJavaThis1 { public static void main(String[] args) { new Person("张三", 25); } }
输出结果：
1. public Person()
2. public Person(String name,int age)
程序说明：
1、程序1~17行，声明一个名为Person的类，类中声明了一个无参和一个有两个参数的构造方法。
2、程序第12行使用this()调用本类中的无参构造方法。
3、程序第22行声明一个Person类的匿名对象，调用了有参的构造方法。
由程序TestJavaThis1.java可以发现，在第22行虽然调用了Person中有两个参数的构造方法，但是由于程序第12行，使用了this()调用本类中的无参构造方法，所以程序先去执行Person中无参构造方法，之后再去继续执行其他的构造方法。
注意：
如果我把this()调用无参构造方法的位置任意调换，那不就可以在任何时候、任何方法里面都可以调用构造方法了么？实际上这样理解是错误的。构造方法是在实例化一对象时被自动调用的，也就是说在类中的所有方法里，只有构造方法是被优先调用的，所以使用this调用构造方法必须也只能放在构造方法的第一行，下面的程序就是一个错误的程序：
class Person { String name; int age; public Person() { System.out.println("1. public Person()"); } public Person(String name, int age) { this.name = name; this.age = age; // 用this调用构造方法，此时不是放在构造方法的首行，错 this(); System.out.println("2. public Person(String name,int age)"); } public String talk() { // 普通函数调用this，错 this(); System.out.println("我是：" + name + "，今年：" + age + "岁"); } } public class TestJavaThis1 { public static void main(String[] args) { new Person("张三", 25); } }
由此可见，对this()的调用必须是构造函数中的第一个语句。
感谢阅读。如果感觉此章对您有帮助，却又不想白瞟
