Scala主构造器和辅助构造器详解

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 类的构造器包括:主构造器和辅助构造器

基本语法

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) {}
}

  • 1
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值