Java入门--构造方法

1、构造方法的特点：

1. 构造方法的方法名称与类名一致
2. 构造方法的没有返回值

2、构造方法的功能：主要是对类中的实例变量进行初始化
3、构造方法的调用：在主函数新建一个类相应的引用变量时，会调用相应的构造方法对变量进行初始化（注意这里是相应的构造方法，一定不要误解为所有的构造方法都会被调用），当一个类中没有声明构造方法时，编译器会自动生成一个无参的构造方法，但是如果你声明了一个有参的构造方法，那么编译器不会再生成一个无参的构造方法，此时如果你在主函数中声明一个类的引用变量且无参时就会出现编译出错的情况。

下面的代码中类没有声明构造方法，在声明一个Animal类的引用变量 Dog时，在Animal类中编译器会自动生成一个如下的与Animal同名的构造方法

public Animal(){}

class Animal
{
    String name;
    //public Animal(){}
}
class AnimalTest
{
    public static void main(String[] args)
    {
        Animal Dog = new Animal();
    } 
}

下面例子中类有声明带参的构造方法，但是主函数中声明一个类的引用变量且无参时就会出现编译出错的情况

class Animal
{
    String name;
    int age;
    public Animal(int age)
    {
        this.age=age;
    }
    public Animal(String name)
    {
        this.name=name;
    }
    public Animal(String name, int age)
    this(name);
    this.age=age;
}
class AnimalTest
{
    public static void main(String[] args)
    {
        Animal Duck = new Animal("Papi");
        Animal Dog = new Animal("DonaldDuck");
    } 
}

4、构造方法的重载
在上面的例子中，没有定义构造方法，如果我们定义构造方法时，可以定义一个无参的构造方法和一个有参的构造方法，这样一来，无参的构造方法和有参的构造方法就是方法的重载，定义一个无参的构造方法的好处就在于当主函数忘记给对象中的实例变量赋值时，无参的构造函数可以给变量进行初始化

public Animal()
{
    String name="DonaldDuck";//这种方式是主函数未对引用变量初始化时自动给实例变量初始化
}
public Animal(name)
{
    this.name=name;//这种方式是通过主函数在声明一个Animal 类的引用变量时对实例变量初始化
}

5、同类构造方法之间的实现
对与在同一个类中的构造方法之间的调用主要是构造方法中参数列表较多的调用参数列表较少的
如上面的例子中

public Animal(int age)
{
    this.age =age;
}
public Animal(String name)
{
    this.name=name;
}
public Animal(String name ,int age)
{
    this(name);
    this.age=age;
}

利用this()方法调用同一个类中的构造方法实例

public Animal(String name ,int age)
{
    this(name);
    this.age=age;
}

这一行代码就是利用this(name)直接调用第二个构造方法public Animal(String name) 。那这为什么第二个this.age=age没有同样使用this(age)来实现，因为this调用构造函数只能在第一行。因此在一个构造方法内最多就只能有一个this()。
6、子类的构造方法和父类的构造方法
子类继承父类所有的成员方法（这其中包括构造方法和一般方法）和成员变量。当子类方法中没有声明

super(变量类型 参数1、变量类型 参数2、.....变量类型 参数n),

子类的构造方法都会自动声明一个super()。如果子类的构造函数没有调用每一次子类构造方法被调用时，首先都会调用一次父类的构造方法。如下面的例子

class Boo
{
    public Boo(){}
    public Boo(int i){}
    public Boo(String s){}
    public Boo(String s,int i){}
}
class SonOfBoo extends Boo
{
    public SonOfBoo()
    {
        super("boo");
    }
    public SonOfBoo(int i)
    {
        super("Fred");
    }
    public SonOfBoo(String s)
    {
        super(42);
    }
    public SonOfBoo(int i ,String s)
    {
        //super();
    }
    public SonOfBoo(String a,String b,String c)
    {
        super(a,b);
    }
    public SonOfBoo(int i, int j)
    {
        super("man",j);
    }


}

class  SonOfTest
{
    public static void main(String[] args) 
    {
        SonOfBoo s = new SonOfBoo(3,2);
    }
}

对于子类中第一个构造方法

public SonOfBoo()
    {
        super("boo");
    }

这个子类构造方法通过super(“boo”)调用了父类中的

public Boo(String s){}

对于子类的第二个构造方法

public SonOfBoo(String s)
    {
        super(42);
    }

调用了父类的构造方法

public SonOfBoo(int i){}

子类的第三个构造方法

public SonOfBoo(int i ,String s)
    {
        //super();
    }

由于在其内部没有声明super(),因此编译器会自动生成一个super(),但是父类中并没有父类的构造函数，因此会出现编译出错的情况编译后的输出显示如下

对于Boo(),找不到合适的构造器