java的构造函数
时间：2020-02-23 14:34:46 来源:igfitidea点击:
在Java中，Constructor构造函数是允许我们创建对象实例的代码块，。
它没有返回类型。
它有两个要点
- 构造函数名称应与类相同
- 构造函数不应有任何返回型否则它将与方法相同。
Java中有三种类型的构造函数。
- 默认构造函数
- 没有arg构造函数
- 参数化构造函数
如何调用构造函数？
要调用构造函数，我们需要使用关键字新建，然后使用类的名称，然后是参数。
例如：如果要创建类员工的对象，我们可以调用这样的构造函数： new Employee()
构造函数的类型
默认构造函数：
当我们没有为类提供构造函数时，JVM将创建默认构造函数。
它对我们不可见，JVM将在初始化类对象时自动创建它。
让我们来检查示例的示例：
package org.arpit.theitroad;
public class Employee {
String name;
int age;
public void workOnAssignment()
{
//Working on assignment
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String args[])
{
Employee e1=new Employee();
e1.setName("John");
e1.setAge(20);
System.out.println(e1.getName());
System.out.println(e1.getAge());
}
}
正如我们可以在此处看到的，我们没有为此类提供任何构造函数，但JVM将在这种情况下创建默认构造函数。
运行上面的程序时，我们将得到以下输出：
John 20
无参数的构造函数
无参数的构造函数是我们在类中明确提供的构造函数，它没有任何参数。
package org.arpit.theitroad;
public class Employee {
String name;
int age;
public Employee()
{
System.out.println("Calling no arg constructor");
}
public void workOnAssignment()
{
//Working on assignment
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String args[])
{
Employee e1=new Employee();
e1.setName("John");
e1.setAge(20);
System.out.println(e1.getName());
System.out.println(e1.getAge());
}
}
当我们拨打上面的程序时，我们将得到以下输出：
Calling no arg constructor John 20
参数化构造函数
将参数传递给构造函数时，调用此类构造函数 Parameterized constructor。
package org.arpit.theitroad;
public class Employee {
String name;
int age;
public Employee(String name,int age)
{
System.out.println("Calling Parameterized constructor");
this.name=name;
this.age=age;
}
public void workOnAssignment()
{
//Working on assignment
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String args[])
{
Employee e1=new Employee("John",20);
System.out.println(e1.getName());
System.out.println(e1.getAge());
}
}
运行上面的程序时，我们将得到以下输出：
Calling Parameterized constructor John 20
如果我们提供参数化构造函数，那么我们需要小心。
让我们看看以下计划：
package org.arpit.theitroad;
public class Employee {
String name;
int age;
public Employee(String name,int age)
{
System.out.println("Calling Parameterized constructor");
this.name=name;
this.age=age;
}
public void workOnAssignment()
{
//Working on assignment
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String args[])
{
Employee e1=new Employee();
e1.setName("John");
e1.setAge(20);
System.out.println(e1.getName());
System.out.println(e1.getAge());
}
}
如果注意，我们将在第38行收到编译错误。
为什么这样？
因为如果在类中创建参数化构造函数，则JVM不会向我们提供默认构造函数。
如果我们不编写任何构造函数，那么只有JVM将为我们提供默认构造函数。
构造函数链
Constructor chaining是子类在内部或者明确地调用其父类的构造函数的概念。
每当我们在Java中创建一个对象时，它会调用其超类构造函数。
编译器简单地将Super()在内部置于构造函数中。
让我们随着榜样的帮助：让我们说你有一个具有属性名称的人类，你有一个名字的子类 Employee延伸 Person类。
package org.arpit.theitroad;
public class Person
{
String name;
public Person()
{
System.out.println("Calling Person constructor");
name="John";
}
}
class Employee extends Person{
int age;
public Employee()
{
System.out.println("Calling Employee class constructor");
name="Martin";
}
public void workOnAssignment()
{
//Working on assignment
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String args[])
{
Employee e1=new Employee();
System.out.println(e1.getName());
}
}
运行上面的程序时，我们将得到以下输出：
Calling Person constructor Calling Employee class constructor Martin
正如我们在这里看到的那样，第一个人构造函数被称为并将名称变量设置为 John然后员工构造函数被称为已被覆盖的名称变量 Martin。
这就是为什么我们在最后看到变量名称为"Martin"。
如果要显式调用超级类参数化构造函数，该怎么办
我们可以使用Super关键字轻松进行。
让我们在举例的帮助下看看。
package org.arpit.theitroad;
public class Person
{
String name;
public Person(String name)
{
this.name=name;
System.out.println("Calling Person Parameterized constructor");
}
}
class Employee extends Person{
int age;
public Employee(String name)
{
super(name);
System.out.println("Calling Employee class constructor");
}
public void workOnAssignment()
{
//Working on assignment
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String args[])
{
Employee e1=new Employee("John");
System.out.println("Employee's name:"+e1.getName());
}
}
运行上面的程序时，我们将得到以下输出：
Calling Person Parameterized constructor Calling Employee class constructor Employee's name:John
如果你想调用同一类的另一个构造函数，怎么办？
如果你想调用 overloaded constructor在同一类中，我们可以使用此关键字来执行此操作。
例如：
package org.arpit.theitroad;
public class Employee {
String name;
int age;
public Employee() {
System.out.println("Calling No arg constructor");
}
public Employee(String name,int age)
{
this();
System.out.println("Calling Parameterized constructor");
this.name=name;
this.age=age;
}
public void workOnAssignment()
{
//Working on assignment
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String args[])
{
Employee e1=new Employee("John",20);
System.out.println("Employee's name : "+e1.getName());
System.out.println("Employee's age : "+e1.getAge());
}
}
运行上面的程序时，我们将得到以下输出：
Calling No arg constructor Calling Parameterized constructor Employee's name : John Employee's age : 20
