Scala主构造器和辅助构造器

忘是亡心i 2023-01-13 14:59 228阅读 0赞

类比下 Java构造器

Java构造器 基本语法

[修饰符] 方法名(参数列表) {
        构造方法体
    }

细节说明

1）在 Java 中一个类可以定义多个不同的构造方法（构造器），构造方法重载

2）如果程序员没有定义构造方法，系统会自动给类生成一个默认无参构造方法(也叫默认构造器)

3）一旦定义了自己的构造方法（构造器），默认的构造方法就覆盖了，就不能再使用默认的无参构造方法，除非显示的定义一下

4）子类的构造器默认会调用父类的空参构造器

5）如果子类显式的使用super()调用父类的有参构造器则不会再去调用父类的空参构造器

案例

public class JavaDemo {
    
        public static void main(String[] args) {
            //细节说明4
            new Student();    //调用了父类的空参构造器
            new Student("zhangsan", 170.0);    //调用了父类的空参构造器
    
            //细节说明5
            new Student("lisi", 18, 175.0);    //调用了父类的带参构造器
        }
    }
    
    class Person {
        String name;
        int age;
    
        public Person() {
            System.out.println("调用了父类的空参构造器");
        }
    
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
            System.out.println("调用了父类的带参构造器");
        }
    }
    
    class Student extends Person {
        double height;
    
        public Student() {
        }
    
        public Student(String name, int age, double height) {
            super(name, age);
            this.height = height;
        }
    
        public Student(String name, double height) {
            this.name = name;
            this.height = height;
        }
    }

Scala构造器

介绍

1）和 Java 一样，Scala构造对象也需要调用构造方法，并且可以有任意多个构造方法（即 scala 中构造器也支持重载）

2）Scala 类的构造器包括：主构造器和辅助构造器

3）Scala中辅助构造器 必须使用this， 调用 主构造器 或者上个 辅助构造器，即 第一个 辅助构造器 用this 调用主构造器， 第二个辅助构造器 使用this 调用第一个辅助构造器。

eg:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6cDY2Ng_size_16_color_FFFFFF_t_70][]

所以，第二个 辅助构造器 会先调用第一个辅助构造器，第一个辅助构造器又调用 主构造器， 所以会先执行  主构造器 然后 第一个辅助构造器 依次往后执行

Scala构造器基本语法

class 类名(形参列表) {    //主构造器
        // 类体
        def this(形参列表) {    //辅助构造器
        }
        
        def this(形参列表) {    //辅助构造器可以有多个，编译器通过不同参数来区分
        }
    }

细节说明

1）Scala 构造器作用是完成对新对象的初始化，构造器没有返回值

2）主构造器的声明直接放置于类名之后

3）主构造器会执行类定义中的所有语句，这里可以体会到 Scala 的函数式编程和面向对象编程融合在一起，即：构造器也是方法（函数），传递参数和使用方法和前面的函数部分内容没有区别

4）如果主构造器无参数，小括号可省略，构建对象时调用的构造方法的小括号也可以省略

5）辅助构造器名称为 this（这个和 Java是不一样的），多个辅助构造器通过不同参数列表进行区分，在底层就是构造器重载。辅助构造器，必须在第一行显式调用主构造器(可以是直接，也可以是间接)

6）如果想让主构造器变成私有的，可以在 () 之前加上 private，这样用户只能通过辅助构造器来构造对象了，示例：class Person private() \{\}

7）辅助构造器的声明不能和主构造器的声明一致，会发生错误（即构造器名重复）

8）子类的主构造器默认会调用父类的空参构造器，这就会直接或间接的调用父类的主构造器

案例

.scala代码：
    
    object ScalaConstructor {
    
      def main(args: Array[String]): Unit = {
        //1. 使用主构造器
        val person1 = new Person1("Tom", 18)
        println(person1.toString)
        //执行了主构造器的其他语句：age=28
        //输出：name=Tom, age=28
    
        println("**************************")
    
        //2. 使用辅助构造器
        val person2 = new Person1("Tom")
        println(person2.toString)
        //执行了主构造器的其他语句：age=20
        //输出：name=Tom, age=20
      }
    }
    
    //主构造器：初始化对象的age属性和name属性
    class Person1(inName: String, inAge: Int) {
      var name: String = inName
      var age: Int = inAge
    
      age += 10
      println("执行了主构造器的其他语句：" + "age=" + age)
    
      //重写toString，便于输出对象的信息
      override def toString: String = {
        "name=" + this.name + ", age=" + this.age
      }
    
      //辅助构造器：初始化对象的name属性
      def this(name: String) {
        //辅助构造器，必须在第一行显式调用主构造器(可以是直接，也可以是间接)
        this("jack", 10)
        //如果主构造器是空参构造器，则可以写成this或this()
        this.name = name //对name重新赋值
      }
    
      def this() {
        this("jack", 10)
      }
    }
    
    Person1的反编译代码：
    
    //可以看出scala主构造器和辅助构造器在底层都是java中的构造器，并没有主次之分
    public class Person1 {
      private String name;
      
      private int age;
      
      public String name() {
        return this.name;
      }
      
      public void name_$eq(String x$1) {
        this.name = x$1;
      }
      
      public int age() {
        return this.age;
      }
      
      public void age_$eq(int x$1) {
        this.age = x$1;
      }
      
      public String toString() {
        return (new StringBuilder()).append("name=").append(name()).append(", age=").append(BoxesRunTime.boxToInteger(age())).toString();
      }
      
      public Person1(String name) {
        this("jack", 10);
        name_$eq(name);
      }
      
      public Person1() {
        this("jack", 10);
      }
      
      public Person1(String inName, int inAge) {
        this.name = inName;
        this.age = inAge;
        age_$eq(age() + 10);
        Predef$.MODULE$.println((new StringBuilder()).append(").append(BoxesRunTime.boxToInteger(age())).toString());
      }
    }

Scala构造器参数的修饰符

说明

1）Scala 类的主构造器的形参未用任何修饰符修饰，那么这个参数是局部变量

2）如果参数使用 val 关键字声明，那么 Scala 会将参数作为类的私有的只读属性使用

3）如果参数使用 var 关键字声明，那么 Scala 会将参数作为类的成员属性使用，并会提供属性对应的 xxx()\[类似 getter\] / xxx\_$eq()\[类似 setter\]方法，即这时的成员属性是私有的，但是可读写

案例

.scala代码：
    
    object ScalaConstructor1 {
    
      def main(args: Array[String]): Unit = {
        val worker1 = new Worker1("zhangsan")
        //println(worker1.inName)  //不能访问inName, 会报错
    
        val worker2 = new Worker2("lisi")
        println(worker2.inName) //可以访问inName, lisi
    
        val worker3 = new Worker3("wangwu")
        println(worker3.inName) //可以访问inName, wangwu
        worker3.inName = "zhaoliu" //可以修改inName,
        println(worker3.inName) //zhaoliu
        println(worker3.name) //wangwu
      }
    }
    
    //1. 如果主构造器是Worker(inName: String)，那么inName就是一个局部变量
    class Worker1(inName: String) {
      var name = inName
    }
    
    //2. 如果主构造器是Worker2(val inName: String) ，那么inName就是Worker2的一个private的只读属性
    class Worker2(val inName: String) {
      var name = inName
    }
    
    // 如果主构造器是Worker3(var inName: String)，那么inName就是Worker3的一个private的可读写的属性
    class Worker3(var inName: String) {
      var name = inName
    }
    
    Worker1的反编译代码：
    
    //inName变成Worker1构造器的局部变量，不能访问
    public class Worker1 {
      private String name;
      
      public String name() {
        return this.name;
      }
      
      public void name_$eq(String x$1) {
        this.name = x$1;
      }
      
      public Worker1(String inName) {
        this.name = inName;
      }
    }
    Worker2的反编译代码：
    
    //inName变成Worker2的私有不可变的属性，提供了 public String inName() {} 方法来访问
    public class Worker2 {
      private final String inName;
      
      private String name;
      
      public String inName() {
        return this.inName;
      }
      
      public Worker2(String inName) {
        this.name = inName;
      }
      
      public String name() {
        return this.name;
      }
      
      public void name_$eq(String x$1) {
        this.name = x$1;
      }
    }
    
    Worker3的反编译代码：
    
    //inName变成Worker2的私有属性，提供了 public String inName() {} 方法来访问和 public void inName_$eq(String x$1) {} 来修改
    public class Worker3 {
      private String inName;
      
      public String inName() {
        return this.inName;
      }
      
      public void inName_$eq(String x$1) {
        this.inName = x$1;
      }
      
      private String name = inName();
      
      public String name() {
        return this.name;
      }
      
      public void name_$eq(String x$1) {
        this.name = x$1;
      }
      
      public Worker3(String inName) {}
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6cDY2Ng_size_16_color_FFFFFF_t_70]: /images/20221022/989784c3cb824fe8b7eec8fac21029b8.png