学了 JavaSE 面向对象这一部分,也该对构造方法做一个总结了。
在多数情况下,初始化一个对象的终于步骤是去调用这个对象的构造方法。
构造方法负责对象的初始化工作,为
实例变量赋予合适的初始值。构造方法必须满足下面语法规则:
(1) 方法名必须与类名同样。
(2) 不要声明返回类型;(3) 不能被 static、final、synchronized、abstract 和 native 修饰。
构造方法不能被子类继承,所以用 final 和 abstract
修饰没有意义。
构造方法用于初始化一个新建的对象,所以用 static 修饰没有意义。多个线程不会同一时候创建内存地址相
同的同一个对象,因此用 synchronized 修饰没有必要。
此外,Java 语言不支持 native 类型的构造方法。
实例:在下面 Sample 类中,具有 int 返回类型的 Sample(int x) 方法仅仅是个普通的实例方法。不能作为构造方法:
- <span style="font-size:18px;">public class Sample {
- private int x;
- //不带參数的构造方法
- public Sample(){
- this(1);
- }
- //带參数的构造方法
- public Sample(int x) {
- this.x=x;
- }
- //不是构造方法,是一般的实例方法
- public int Sample(int x) {
- return x++;
- }
- }</span>
以上样例虽然能编译通过。可是把实例方法和构造方法同名。不是好的编程习惯,easy 引起混淆。
实例:下面 Mystery 类的 Mystery() 方法有 void 返回类型,因此是普通的实例方法:
- <span style="font-size:18px;">public class Mystery {
- private String s;
- //不是构造方法
- public void Mystery(){
- s = "constructor";
- }
- void go() {
- System.out.println(s);
- }
- public static void main(String[] args) {
- Mystery m = new Mystery();
- m.go();
- }
- }</span>
以上程序的打印结果为 null。由于用 new 语句创建 Mystery 实例时。调用的是 Mystery 类的默认构造方法,而不是以
上有 void 返回类型的 Mystery() 方法。
当通过 new 语句创建一个对象时。在不同的条件下。对象可能会有不同的初始化行为。
可通过重载构造方法来表
达对象的多种初始化行为。下面的 Employee 类的构造方法有三种重载形式。在一个类的多个构造方法中。可能会出现
一些反复操作。为了提高代码的可重用性,Java 语言同意在一个构造方法中,用 this 语句来调用还有一个构造方法。
比如对于公司新进来的一个雇员。在一開始的时候,有可能他的姓名和年龄是未知的,也有可能只他的姓名是
已知的,也有可能姓名和年龄都是已知的。假设姓名是未知的,就暂且把姓名设为 "无名氏"。假设年龄是未知的,就
暂且把年龄设为 - 1。
实例:Employee.java 源文件代码:
- <span style="font-size:18px;">public class Employee {
- private String name;
- private int age;
- //当雇员的姓名和年龄都已知,就调用此构造方法
- public Employee(String name, int age) {
- this.name = name;
- this.age=age;
- }
- //当雇员的姓名已知而年龄未知,就调用此构造方法
- public Employee(String name) {
- this(name, -1);
- }
- //当雇员的姓名和年龄都未知。就调用此构造方法
- public Employee() {
- this( "无名氏" );
- }
- public void setName(String name){
- this.name=name;
- }
- public String getName(){
- return name;
- }
- public void setAge(int age){
- this.age=age;
- }
- public int getAge(){
- return age;
- }
- public static void main(String[] args){
- Employee zhangsan=new Employee("张三",25);
- Employee lisi=new Employee("李四");
- Employee someone=new Employee();
- }
- }</span>
上述程序中 mian() 方法分别通过三个构造方法创建了三个 Employee 对象。在 Employee(String name) 构造方法
中,this(name,-1) 语句用于调用 Employee(String name,int age) 构造方法。在 Employee() 构造方法中。this(" 无名氏 ")
语句用于调用 Employee(String name) 构造方法。
用 this 语句来调用其它构造方法时。必须遵守下面语法规则:
(1) 假如在一个构造方法中使用了 this 语句,那么它必须作为构造方法的第一条语句 (不考虑凝视语句)。
下面构造方
法是非法的:
- <span style="font-size:18px;">public Employee(){
- String name="无名氏";
- this(name);//编译错误。this语句必须作为第一条语句
- }</span>
(2) 仅仅能在一个构造方法中用 this 语句来调用类的其它构造方法。而不能在实例方法中用 this 语句来调用类的其它构
造方法。
(3) 仅仅能用 this 语句来调用其它构造方法。而不能通过方法名来直接调用构造方法。
下面对构造方法的调用方式是
非法的:
- <span style="font-size:18px;">public Employee() {
- String name= "无名氏";
- Employee(name); //编译错误,不能通过方法名来直接调用构造方法
- }</span>
默认构造方法是没有參数的构造方法。可分为两种:
a 隐含的默认构造方法;
b 程序显式定义的默认构造方法。
在 Java 语言中。每一个类至少有一个构造方法。
为了保证这一点。假设用户定义的类中没有提供不论什么构造方法,那
么 Java 语言将自己主动提供一个隐含的默认构造方法。
该构造方法没有參数,用 public 修饰,并且方法体为空。格式为:
- <span style="font-size:18px;">//隐含的默认构造方法
- public ClassName(){
- } </span>
在程序中也能够显式的定义默认构造方法。它能够是随意的訪问级别。比如:
- <span style="font-size:18px;">//程序显式定义的默认构造方法
- protected Employee() {
- this("无名氏");
- }</span>
假设类中显式定义了一个或多个构造方法,而且全部的构造方法都带參数。那么这个类就失去了默认构造方法。
在下面程序中,Sample1 类有一个隐含的默认构造方法,Sample2 类没有默认构造方法。Sample3 类有一个显式定义
的默认构造方法:
- <span style="font-size:18px;">class Sample1{
- }
- class Sample2{
- public Sample2(int a){
- System.out.println("My Constructor");
- }
- }
- class Sample3{
- public Sample3(){
- System.out.println("My Default Constructor");
- }
- }</span>
能够调用 Sample1 类的默认构造方法来创建 Sample1 对象:Sample1 s=new Sample1(); // 合法
Sample2 类没有默认构造方法,因此下面语句会导致编译错误:Sample2 s=new Sample2(); // 编译出错
Sample3 类显式定义了默认构造方法,因此下面语句是合法的。Sample3 s=new Sample3();
父类的构造方法不能被子类继承。
下面 MyException 类继承了 java.lang.Exception 类:
- <span style="font-size:18px;">
- // MyException类仅仅有一个隐含的默认构造方法 public class MyException extends Exception{
- }
- </span>
虽然在 Exception 类中定义了例如以下形式的构造方法:
- <span style="font-size:18px;">
- public Exception(String msg){ }
- </span>
但 MyException 类不会继承以上 Exception 类的构造方法,因此下面代码是不合法的:
- <span style="font-size:18px;">
- Exception e=new MyException("Something is error");//编译出错。MyException类不存在这种构造方法
- </span>
在子类的构造方法中,能够通过 super 语句调用父类的构造方法。比如:
- <span style="font-size:18px;">public class MyException extends Exception{
- public MyException(){
- //调用Exception父类的Exception(String msg)构造方法
- super("Something is error");
- }
- public MyException(String msg){
- //调用Exception父类的Exception(String msg)构造方法
- super(msg);
- }
- }</span>
用 super 语句来调用父类的构造方法时,必须遵守下面语法规则。
(1) 在子类的构造方法中。不能直接通过父类方法名调用父类的构造方法,而是要使用 super 语句。
下面代码是非法的:
- <span style="font-size:18px;">public MyException(String msg){
- Exception(msg); //编译错误
- }</span>
(2) 用 super 语句时,必须放在最前面。
下面代码是非法的:
- <span style="font-size:18px;">public MyException(){
- String msg= "Something wrong";
- super(msg); //编译错误,super语句必须作为构造方法的第一条语句
- }</span>
在创建子类的对象时,Java 虚拟机首先运行父类的构造方法,然后再运行子类的构造方法。在多级继承的情况
下,将从继承树的最上层的父类開始,依次运行各个类的构造方法。这能够保证子类对象从全部直接或间接父类中继
承的实例变量都被正确的初始化。比例如以下面 Base 父类和 Sub 子类分别有一个实例变量 a 和 b,当构造 Sub 实例时,这两
个实例变量都会被初始化。
实例代码:
- <span style="font-size:18px;">class Base{
- private int a;
- public Base(int a){
- this.a=a;
- }
- public int getA(){
- return a;
- }
- }
- public class Sub extends Base{
- private int b;
- public Sub(int a,int b){
- super(a);
- this.b=b;
- }
- public int getB(){
- return b;
- }
- public static void main(String args[]){
- Sub sub=new Sub(1,2);
- System.out.println("a="+sub.getA()+",b="+sub.getB()); //打印a=1 b=2
- }
- }</span>
执行结果:
a=1,b=2
在以以下的实例中。Son 类继承 Father 类。Father 类继承 Grandpa 类。这三个类都显式定义了默认的构造方法。此
外还定义了一个带參数的构造方法。
Son.java 源文件代码:
- <span style="font-size:18px;">class Grandpa{
- protected Grandpa(){
- System.out.println("default Grandpa");
- }
- public Grandpa(String name){
- System.out.println(name);
- }
- }
- class Father extends Grandpa{
- protected Father(){
- System.out.println("default Father");
- }
- public Father(String grandpaName,String fatherName){
- super(grandpaName);
- System.out.println(fatherName);
- }
- }
- public class Son extends Father{
- public Son(){
- System.out.println("default Son");
- }
- public Son(String grandpaName,String fatherName,String sonName){
- super(grandpaName,fatherName);
- System.out.println(sonName);
- }
- public static void main(String args[]){
- Son s1= new Son("My Grandpa", "My Father", "My Son");
- Son s2=new Son();
- }
- }</span>
程序执行结果例如以下:
当子类的构造方法没实用 super 语句显式调用父类的构造方法。那么通过这个构造方法创建子类对象时,Java 虚
拟机会自己主动先调用父类的默认构造方法。
当子类的构造方法没实用 super 语句显式调用父类的构造方法。而父类又没有提供默认构造方法时,将会出现编
译错误。我们凝视掉 Grandpa 类的 protected 级别的构造方法,这样,Grandpa 类就失去了默认构造方法,这时,在编
译 Father 类的默认构造方法时,由于找不到 Grandpa 类的默认构造方法而编译出错。假设把 Grandpa 类的默认构造方
法的 protected 訪问级别改为 private 訪问级别,也会导致编译错误,由于 Father 类的默认构造方法无法訪问 Grandpa 类
的私有默认构造方法。
在下面样例中,子类 Sub 的默认构造方法没有通过 super 语句调用父类的构造方法。而是通过 this 语句调用了自身
的还有一个构造方法 Sub(int i),而在 Sub(int i) 中通过 super 语句调用了父类 Base 的 Base(int i) 构造方法。这样,不管通过
Sub 类的哪个构造方法来创建 Sub 实例,都会先调用父类 Base 的 Base(int i) 构造方法。
Sub.java 源文件代码:
- <span style="font-size:18px;">class Base{
- Base(int i){
- System.out.println("call Base(int i)");
- }
- }
- public class Sub extends Base{
- Sub(){
- this(0);
- System.out.println("call Sub()");
- }
- Sub(int i){
- super(i);
- System.out.println("call Sub(int i)");
- }
- public static void main(String args[]){
- Sub sub=new Sub();
- }
- }</span>
程序运行结果例如以下:
构造方法仅仅能通过下面方式被调用:
(1) 当前类的其它构造方法通过 this 语句调用它。
(2) 当前类的子类的构造方法通过 super 语句调用它。
(3) 在程序中通过 new 语句调用它。
注意以下的构造函数的调用的方式:
Sub.java 源文件代码:
- <span style="font-size:18px;">class Base{
- public Base(int i,int j){
- }
- public Base(int i){
- this(i,0); //合法
- Base(i,0); //编译出错
- }
- }
- class Sub extends Base{
- public Sub(int i,int j){
- super(i,0); //合法
- }
- void method1(int i,int j){
- this(i,j); //编译出错
- Sub(i,j); //编译出错
- }
- void method2(int i,int j){
- super(i,j); //编译出错
- }
- void method3(int i,int j){
- Base s=new Base(0,0); //合法
- s.Base(0,0); //编译出错
- }
- }</span>
构造方法能够处于 public、protected、默认和 private 这四种訪问级别之中的一个。本节着重介绍构造方法处于 private 级
别的意义。当构造方法为 private 级别。意味着仅仅能在当前类中訪问它:在当前类的其它构造方法中能够通过 this 语句
调用它,此外还能够在当前类的成员方法中通过 new 语句调用它。
在下面场合之中的一个,能够把类的全部构造方法都声明为 private 类型:
(1) 在这个类中只包括了一些供其它程序调用的静态方法。没有不论什么实例方法。其它程序无需创建该类的实例,
就能訪问类的静态方法。比如 java.lang.Math 类就符合这样的情况,在 Math 类中提供了一系列用于数学运算的公共静态
方法,为了禁止外部程序创建 Math 类的实例, Math 类的惟一的构造方法是 private 类型的:private Math(){}
假设一个类是抽象类,意味着它是专门用于被继承的类,能够拥有子类,并且能够创建详细子类的实例。
而 JDK
并不希望用户创建 Math 类的子类,在这样的情况下。把类的构造方法定义为 private 类型更合适。
(2) 禁止这个类被继承。当一个类的全部构造方法都是 private 类型。假如定义了它的子类。那么子类的构造方法无
法调用父类的不论什么构造方法,因此会导致编译错误。把一个类声明为 final 类型,也能禁止这个类被继承。这两者的区
别是:
A 假设一个类同意其它程序用 new 语句构造它的实例。但不同意拥有子类。那就把类声明为 final 类型。
B 假设一个类既不同意其它程序用 new 语句构造它的实例,又不同意拥有子类。那就把类的全部构造方法声明为
private 类型。
因为大多数类都同意其它程序用 new 语句构造它的实例,因此用 final 修饰符来禁止类被继承的做法更常
见。
C 这个类须要把构造自身实例的细节封装起来。不同意其它程序通过 new 语句创建这个类的实例。这个类向其它
程序提供了获得自身实例的静态方法,这样的方法称为静态工厂方法。
来源: http://www.bubuko.com/infodetail-2162456.html