爪哇2博客
关
爪哇2博客

爪哇构造函数

建设者 在Java中是代码块，可让您创建 目的。它没有返回类型。
它有两个要点

  • 构造函数名称应与类相同
  • 构造函数不应具有任何返回类型，否则它将与method相同。

爪哇中有三种构造函数。

  • 默认构造函数
  • 没有arg构造函数
  • 参数化构造函数

如何调用构造函数？

要调用构造函数，您需要使用关键字new，其后是类的名称，然后是参数（如果有）。
例如：如果要创建Employee类的对象，则可以这样调用构造函数： 新 雇员()

建设者的类型

默认构造函数：

当您不为类提供构造函数时，JVM将创建 默认构造函数它对您不可见，JVM将在初始化类的对象时自动创建它。

让’s以示例为例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
包 组织.Arpit.爪哇2blog;
 
上市 类 雇员 {
 
    串 名称;
    整型 年龄;
 
    上市 虚空 workOnAssignment()
    {
        //处理作业
    }
 
    上市 串 getName() {
        返回 名称;
    }
 
    上市 虚空 setName(串 名称) {
        这个.名称 = 名称;
    }
 
    上市 整型 getAge() {
        返回 年龄;
    }
 
    上市 虚空 setAge(整型 年龄) {
        这个.年龄 = 年龄;
    }
 
    上市 静态的 虚空 主要(串 args[])
    {
        雇员 e1=新 雇员();
        e1.setName(“约翰”);
        e1.setAge(20);
        系统.出.打印(e1.getName());
        系统.出.打印(e1.getAge());
    }
}
 

如您所见，我们没有为此类提供任何构造函数，但 虚拟机 在这种情况下将创建默认构造函数。
当您运行上述程序时，将获得以下输出：

约翰20

没有arg建设者

no arg constructor 是您在该类中显式提供的构造函数，它没有任何参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
包 组织.Arpit.爪哇2blog;
 
上市 类 雇员 {
 
    串 名称;
    整型 年龄;
 
    上市 雇员()
    {
        系统.出.打印(“不调用arg构造函数”);
    }
    上市 虚空 workOnAssignment()
    {
        //处理作业
    }
 
    上市 串 getName() {
        返回 名称;
    }
 
    上市 虚空 setName(串 名称) {
        这个.名称 = 名称;
    }
 
    上市 整型 getAge() {
        返回 年龄;
    }
 
    上市 虚空 setAge(整型 年龄) {
        这个.年龄 = 年龄;
    }
 
    上市 静态的 虚空 主要(串 args[])
    {
        雇员 e1=新 雇员();
        e1.setName(“约翰”);
        e1.setAge(20);
        系统.出.打印(e1.getName());
        系统.出.打印(e1.getAge());
    }
}
 

当您调用上述程序时，将获得以下输出：

不调用arg构造函数
约翰
20

参数化构造函数

When you pass arguments to the constructor, 这个 type of constructor is called 参数化构造函数.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
包 组织.Arpit.爪哇2blog;
 
上市 类 雇员 {
 
    串 名称;
    整型 年龄;
 
    上市 雇员(串 名称,整型 年龄)
    {
        系统.出.打印(“调用参数化构造函数”);
        这个.名称=名称;
        这个.年龄=年龄;      
    }
    上市 虚空 workOnAssignment()
    {
        //处理作业
    }
 
    上市 串 getName() {
        返回 名称;
    }
 
    上市 虚空 setName(串 名称) {
        这个.名称 = 名称;
    }
 
    上市 整型 getAge() {
        返回 年龄;
    }
 
    上市 虚空 setAge(整型 年龄) {
        这个.年龄 = 年龄;
    }
 
    上市 静态的 虚空 主要(串 args[])
    {
        雇员 e1=新 雇员(“约翰”,20);
        系统.出.打印(e1.getName());
        系统.出.打印(e1.getAge());
    }
}
 

当您运行上述程序时，将获得以下输出：

调用参数化构造函数
约翰
20

如果提供参数化构造函数，则需要小心。
让’s see below program:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
包 组织.Arpit.爪哇2blog;
 
上市 类 雇员 {
 
    串 名称;
    整型 年龄;
 
    上市 雇员(串 名称,整型 年龄)
    {
        系统.出.打印(“调用参数化构造函数”);
        这个.名称=名称;
        这个.年龄=年龄;      
    }
    上市 虚空 workOnAssignment()
    {
        //处理作业
    }
 
    上市 串 getName() {
        返回 名称;
    }
 
    上市 虚空 setName(串 名称) {
        这个.名称 = 名称;
    }
 
    上市 整型 getAge() {
        返回 年龄;
    }
 
    上市 虚空 setAge(整型 年龄) {
        这个.年龄 = 年龄;
    }
 
    上市 静态的 虚空 主要(串 args[])
    {
        雇员 e1=新 雇员();
        e1.setName(“约翰”);
        e1.setAge(20);
        系统.出.打印(e1.getName());
        系统.出.打印(e1.getAge());
    }
}
 

如果您注意到，您将在第38行收到编译错误。为什么这样？
因为如果您在类中创建参数化的构造函数，JVM将会赢得’向您提供默认构造函数。如果您不编写任何构造函数，那么只有JVM将为您提供默认的构造函数。

构造器链

构造器链 是子类在内部或显式调用其父类的构造函数的概念。
每当在Java中创建对象时，都会调用其超类构造函数。编译器只是在内部将super（）放入构造函数中。
让’借助示例查看：
让’s say you have 人 类 with attribute 名称 and you have child 类 名称d 雇员 which 延伸 人 类.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
包 组织.Arpit.爪哇2blog;
 
上市 类 人
{
    串 名称;
    上市 人()
    {
        系统.出.打印(“呼叫人构造函数”);
        名称=“约翰”;
    }
}
类 雇员 延伸 人{
 
    整型 年龄;
 
    上市 雇员()
    {
        系统.出.打印(“调用Employee类的构造函数”);
        名称="马丁";
    }
    上市 虚空 workOnAssignment()
    {
        //处理作业
    }
 
    上市 串 getName() {
        返回 名称;
    }
 
    上市 虚空 setName(串 名称) {
        这个.名称 = 名称;
    }
 
    上市 整型 getAge() {
        返回 年龄;
    }
 
    上市 虚空 setAge(整型 年龄) {
        这个.年龄 = 年龄;
    }
 
    上市 静态的 虚空 主要(串 args[])
    {
        雇员 e1=新 雇员();
 
        系统.出.打印(e1.getName());
    }
}
 

当您运行上述程序时，将获得以下输出：

主叫人构造函数
调用Employee类的构造函数
马丁

如您所见，First 人构造函数被调用，并将name变量设置为 约翰
Then 雇员 constructor got called which have overridden 名称 变量 to 马丁.
那’s why we see a 变量 命名为"Martin" in the end.

如果要显式调用超类参数化构造函数该怎么办

您可以轻松地使用 超级关键字.
让’可以在Example的帮助下进行查看。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
包 组织.Arpit.爪哇2blog;
 
上市 类 人
{
    串 名称;
    上市 人(串 名称)
    {
        这个.名称=名称;
        系统.出.打印(“调用人参数化构造函数”);
    }
}
类 雇员 延伸 人{
 
    整型 年龄;
 
    上市 雇员(串 名称)
    {
        超(名称);
        系统.出.打印(“调用Employee类的构造函数”);
    }
    上市 虚空 workOnAssignment()
    {
        //处理作业
    }
 
    上市 串 getName() {
        返回 名称;
    }
 
    上市 虚空 setName(串 名称) {
        这个.名称 = 名称;
    }
 
    上市 整型 getAge() {
        返回 年龄;
    }
 
    上市 虚空 setAge(整型 年龄) {
        这个.年龄 = 年龄;
    }
 
    上市 静态的 虚空 主要(串 args[])
    {
        雇员 e1=新 雇员(“约翰”);
 
        系统.出.打印("雇员's 名称:"+e1.getName());
    }
}
 

当您运行上述程序时，将获得以下输出：

调用人参数化构造函数
调用Employee类的构造函数
雇员’s 名称:John

如果要调用同一类的另一个构造函数怎么办

If you want to call overloaded constructor of same 类, you can use 这个关键字 to do 那.
例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
包 组织.Arpit.爪哇2blog;
 
上市 类 雇员 {
 
    串 名称;
    整型 年龄;
 
    上市 雇员() {
        系统.出.打印(“调用无参数构造函数”);
    }
 
    上市 雇员(串 名称,整型 年龄)
    {
        这个();
        系统.出.打印(“调用参数化构造函数”);    
        这个.名称=名称;
        这个.年龄=年龄;      
    }
 
    上市 虚空 workOnAssignment()
    {
        //处理作业
    }
 
    上市 串 getName() {
        返回 名称;
    }
 
    上市 虚空 setName(串 名称) {
        这个.名称 = 名称;
    }
 
    上市 整型 getAge() {
        返回 年龄;
    }
 
    上市 虚空 setAge(整型 年龄) {
        这个.年龄 = 年龄;
    }
 
    上市 静态的 虚空 主要(串 args[])
    {
        雇员 e1=新 雇员(“约翰”,20);
        系统.出.打印("雇员's 名称 : "+e1.getName());
        系统.出.打印("雇员's 年龄 : "+e1.getAge());
    }
}
 

当您运行上述程序时，将获得以下输出：

调用No arg构造函数
调用参数化构造函数
雇员’s 名称 : 约翰
雇员’s 年龄 : 20

请注意，用于调用重载构造函数的此关键字应是该构造函数中的第一条语句。

那’关于Java构造函数的所有内容。


相关文章

分享这个

作者

关注作者

相关文章

  • 9月25日

    爪哇中的参考变量

    在这篇文章中，我们将看到有关Java中的Reference变量的信息。参考变量持有对象参考的变量称为参考变量。变量是一个名称，用于在程序执行期间保存任何类型的值。如果类型是对象，则该变量称为引用[…]

  • 3月26日

    爪哇中的全局变量

    在这篇文章中，我们将看到如何在java中定义全局变量。与C / C ++不同，java中没有标准的全局变量，但是您仍然可以定义可在所有类中使用的全局变量。全局变量是可以在所有类中访问的那些变量。 爪哇不支持全局[…]

  • 3月26日

    爪哇中的静态块

    在本文中，我们将介绍如何在Java中实现静态块。以下是有关Java中静态块的一些重要信息。静态块用于类的静态初始化当您创建类的对象或访问[的静态成员时，静态块仅执行一次。…]

  • 8月26日

    爪哇默认构造函数

    在这篇文章中，我们将看到有关Java默认构造函数的信息。除非您显式提供任何其他构造函数，否则默认构造函数是由编译器插入的no arg构造函数。你赢了’无法看到它，因为它存在于类文件而不是源文件中。没有参数构造函数和[…]

  • 6月17日

    如何学习Java编程

    爪哇是开发桌面应用程序和Web应用程序的世界上使用最广泛的编程语言之一，在编程领域已经完成了22年的时间。在这篇文章中，我们将看到如何以最有效的方式深入学习Java编程。 爪哇的学习曲线很大，这是[…]

  • 28 May

    爪哇编程简介

    爪哇是世界上用于开发桌面应用程序和Web应用程序的最常用的编程语言之一。它在编程世界中已经完成了22年。 爪哇的历史：Java编程语言是1991年由Sun Microsystems Inc.的James Ghosling，Patrick Naughton和Mike Sheridan开发的。最初的名称是Oak，但是[…]

发表评论

您的电子邮件地址不会被公开。 必需的地方已做标记 *

订阅我们的新闻

获取质量教程到您的收件箱。现在订阅。


让’s be Friends

©2020 爪哇2博客