JavaSE入门学习23：Java面向对象之构造方法

Posted 2020-06-17 life is wonderful

       学了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>

       以上例子尽管能编译通过，但是把实例方法和构造方法同名，不是好的编程习惯，容易引起混淆。

       实例：以下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语句创建这个类的实例，这个类向其他

程序提供了获得自身实例的静态方法，这种方法称为静态工厂方法。