• <small id='8ZTUR'></small><noframes id='8ZTUR'>

      <legend id='8ZTUR'><style id='8ZTUR'><dir id='8ZTUR'><q id='8ZTUR'></q></dir></style></legend>
      <i id='8ZTUR'><tr id='8ZTUR'><dt id='8ZTUR'><q id='8ZTUR'><span id='8ZTUR'><b id='8ZTUR'><form id='8ZTUR'><ins id='8ZTUR'></ins><ul id='8ZTUR'></ul><sub id='8ZTUR'></sub></form><legend id='8ZTUR'></legend><bdo id='8ZTUR'><pre id='8ZTUR'><center id='8ZTUR'></center></pre></bdo></b><th id='8ZTUR'></th></span></q></dt></tr></i><div id='8ZTUR'><tfoot id='8ZTUR'></tfoot><dl id='8ZTUR'><fieldset id='8ZTUR'></fieldset></dl></div>

        • <bdo id='8ZTUR'></bdo><ul id='8ZTUR'></ul>
        <tfoot id='8ZTUR'></tfoot>

      1. Java构造函数的相互调用代码示例

        时间:2023-12-11
        <legend id='f0CBM'><style id='f0CBM'><dir id='f0CBM'><q id='f0CBM'></q></dir></style></legend>
        1. <i id='f0CBM'><tr id='f0CBM'><dt id='f0CBM'><q id='f0CBM'><span id='f0CBM'><b id='f0CBM'><form id='f0CBM'><ins id='f0CBM'></ins><ul id='f0CBM'></ul><sub id='f0CBM'></sub></form><legend id='f0CBM'></legend><bdo id='f0CBM'><pre id='f0CBM'><center id='f0CBM'></center></pre></bdo></b><th id='f0CBM'></th></span></q></dt></tr></i><div id='f0CBM'><tfoot id='f0CBM'></tfoot><dl id='f0CBM'><fieldset id='f0CBM'></fieldset></dl></div>

          <tfoot id='f0CBM'></tfoot>

                  <tbody id='f0CBM'></tbody>
                  <bdo id='f0CBM'></bdo><ul id='f0CBM'></ul>
                • <small id='f0CBM'></small><noframes id='f0CBM'>

                  Java构造函数的相互调用,是指一个构造函数中调用了另一个构造函数,以达到代码复用和降低代码重复度的目的。在Java中,构造函数相互调用有两种方式:this和super。

                  使用this关键字调用另一个构造函数

                  使用this关键字调用另一个构造函数时,需要满足两个条件:

                  1. this关键字必须位于构造方法中的第一行;
                  2. 被调用的构造方法必须在当前构造方法之前定义。

                  下面是一个使用this调用另一个构造函数的示例代码:

                  public class Person {
                      private String name;
                      private int age;
                  
                      public Person() {
                          this("Unknown", 0);
                      }
                  
                      public Person(String name) {
                          this(name, 0);
                      }
                  
                      public Person(int age) {
                          this("Unknown", age);
                      }
                  
                      public Person(String name, int age) {
                          this.name = name;
                          this.age = age;
                      }
                  
                      public static void main(String[] args) {
                          Person person1 = new Person();
                          Person person2 = new Person("Tom");
                          Person person3 = new Person(18);
                          Person person4 = new Person("Tom", 18);
                      }
                  }
                  

                  解释一下上面的代码:

                  • Person类有四个构造函数,分别是无参、带一个字符串参数name、带一个整数参数age、带一个字符串参数name和一个整数参数age的构造函数;
                  • 无参构造函数调用带两个参数的构造函数,并传入默认值,即"Unknown"和0;
                  • 带一个字符串参数name的构造函数调用带两个参数的构造函数,并把age默认值设置为0;
                  • 带一个整数参数age的构造函数调用带两个参数的构造函数,并把name默认值设置为"Unknown";
                  • 带一个字符串参数name和一个整数参数age的构造函数直接初始化name和age。

                  这个示例代码的输出结果为:

                  Unknown 0
                  Tom 0
                  Unknown 18
                  Tom 18
                  

                  使用super关键字调用父类构造函数

                  使用super关键字调用父类构造函数时,需要满足以下条件:

                  1. super关键字必须位于构造方法的第一行;
                  2. 被调用的父类构造方法必须存在,并且参数列表必须与当前构造方法的参数列表相同或可以隐式转换。

                  下面是一个使用super调用父类构造函数的示例代码:

                  public class Student extends Person {
                      private String school;
                  
                      public Student(String school) {
                          super();
                          this.school = school;
                      }
                  
                      public Student(String name, int age, String school) {
                          super(name, age);
                          this.school = school;
                      }
                  
                      public static void main(String[] args) {
                          Student student1 = new Student("High School");
                          Student student2 = new Student("Tom", 16, "High School");
                      }
                  }
                  

                  解释一下上面的代码:

                  • Student类继承自Person类,具有相同的构造函数;
                  • 无参构造函数调用父类构造函数,并用默认值初始化school;
                  • 带三个参数的构造函数调用父类构造函数,并用相应参数初始化school。

                  这个示例代码的输出结果与前一个示例代码相同,不再赘述。

                  以上就是Java构造函数的相互调用的完整示例攻略。

                  上一篇:Java欧拉函数的计算代码详解 下一篇:Java语言中flush()函数作用及使用方法详解

                  相关文章

                  <legend id='wKH5N'><style id='wKH5N'><dir id='wKH5N'><q id='wKH5N'></q></dir></style></legend>

                    1. <small id='wKH5N'></small><noframes id='wKH5N'>

                    2. <tfoot id='wKH5N'></tfoot>

                    3. <i id='wKH5N'><tr id='wKH5N'><dt id='wKH5N'><q id='wKH5N'><span id='wKH5N'><b id='wKH5N'><form id='wKH5N'><ins id='wKH5N'></ins><ul id='wKH5N'></ul><sub id='wKH5N'></sub></form><legend id='wKH5N'></legend><bdo id='wKH5N'><pre id='wKH5N'><center id='wKH5N'></center></pre></bdo></b><th id='wKH5N'></th></span></q></dt></tr></i><div id='wKH5N'><tfoot id='wKH5N'></tfoot><dl id='wKH5N'><fieldset id='wKH5N'></fieldset></dl></div>
                        <bdo id='wKH5N'></bdo><ul id='wKH5N'></ul>