scala 类及抽象类入门

普通类剖析

1 class 默认public

属性

1 class属性必须初始化
2 var声明的变量默认提供公有的get,set方法. val声明的变量默认提供公有的get方法.
3 private var声明的变量提供私有get和set方法,仅在类内部使用
4 初始值可以用占位符 _
5初始值为null时,最好指定类型,否则类型是NULL

构造器cons

1 可以分为主构造器与辅助构造器
2 主构造器的参数直接放置在类名之后
3 一个类如果没有显式的定义主构造器则自动用有一个无参的主构造器
4辅助构造器的名称为this
5每一个辅助构造器都必须在第一行调用一个先前已经定义好的其他辅助构造器火砖

无参构造器

不写的话会自动提供一个无参的构造器. 该构造器即为主构造器

object _04ConstructorDemo {
  def main(args: Array[String]): Unit = {
    val d1=new Dog() //调用无参主构造器
  }
}

class Dog{
  println("------1--------")
  val name="taidi"
  val age=8
  def showInfo=println(s"$name+$age")
  showInfo
  println("-----------last------")
}

主构造器

主构造器的位置和java不一样,注意区别

object _04ConstructorDemo {
  def main(args: Array[String]): Unit = {
    val d1 = new Dog("xiaobai", 'm', 23, false)
    d1.showInfo
    //相当于java的get方法
    println(d1.name)
    println(d1.age)
    //相当于java的set方法
    d1.name = "xiaohei"
    println(d1.name)
    //报错,gender私有
    println(d1.gender)
  }
}

//类后()中的就是主构造器. private的表示私有,否则默认私有.
//val修饰的无默认set方法,var修饰的有默认set get方法
//无var val修饰时,则属性为私有
class Dog(var name: String, private var gender: Char, var age: Int, private val isMarried: Boolean) {
  def showInfo = println(name + "," + gender + " " + age + " " + isMarried)
}

辅助构造器

辅助构造器必须定义到类体中,名字必须叫this
每一个辅助构造器都必须在第一行调用一个先前已经定义的其它辅助构造器或主构造器
辅助构造器参数列表不可以和主构造器相同
主构造器无参

//无参主构造器里的辅助构造器
class Person() {
  println("---------------")
  var name = "libai"
  var age = 23

  //aux constructor
  //aux constructor para doesn't need var or val
  def this(name: String, age: Int) = {
    //aux constructor must call another constructor in first line
    this()
    this.name = name
    this.age = age
  }

  //another aux constructor
  def this(name: String) {
    //调用上面的辅助构造器
    this(name, 40)
    this.name = name
  }

  //another aux constructor
  def this(age: Int, name: String) {
    //调用的是一个参数的辅助构造器
    this(name)
    this.age = age
  }

  def showInfo = println(name + " " + age)
}

object _05ConstructorDemo {
  def main(args: Array[String]): Unit = {
    //调用主构造器创建对象
    val p1 = new Person()
    p1.showInfo //libai 23
    //call aux constructor
    val p2 = new Person("libai")
    p2.showInfo //libai 40

    val p3 = new Person("john", 54)
    p3.showInfo //john 54

  }
}

主构造器有参

//主构造器有参
class Person2(val name: String, val age: Int) {
  println("start")
  var isMarry: Boolean = _

  //定义无参辅助构造器
  def this() {
    //call main constructor
    this("zhangsan", 23)
  }

  def this(name: String) {
    //call main constructor
    this(name, 20)
    this.isMarry = true
  }

  def this(age: Int, name: String) {
    //call main constructor
    this(name, age)
  }

  def this(name: String, age: Int, isMarry: Boolean) {
    this()
  }

  def showInfo = println(name + " " + age + isMarry)

  println("end")
}


object _05ConstructorDemo {
  def main(args: Array[String]): Unit = {

    val p1 = new Person2()
    p1.showInfo //zhangsan 23false
    //call main cons
    val p2 = new Person2("luyao", 34)
    p2.showInfo //luyao 34false
    val p3 = new Person2("libai", 34, true)
    p3.showInfo //zhangsan 23false
    
  }
}

主构造器提供默认值

object _05ConstructorDemo {
  def main(args: Array[String]): Unit = {

    val p1 = new Person3("小明", 23, false)
    p1.showInfo //小明 23false
    val p2 = new Person3()
    p2.showInfo //小红 0false
    val p3 = new Person3("张三")
    p3.showInfo //张三 0false
    val p4 = new Person3("李四", 89)
    p4.showInfo //李四 89false
    //调用构造器顺序不一致需要如下调用
    val p5 = new Person3(age = 100)
    p5.showInfo //小红 100false
  }
}

//主构造器中提供默认值
class Person3(var name: String = "小红", val age: Int = 0, val isMarry: Boolean = false) {
  def showInfo = println(name + " " + age + isMarry)
}

构造方法中参数的特点

var name:String 私有字段,公有的get和set方法

抽象类

1 通过abstract 声明抽象类
2 方法不需要标记为abstract, 没有{}即可
3 可以有抽象字段,就是不赋予初始值
4 抽象类不能被实例化,是需要被子类继承的,重写类里的抽象方法或者抽象字段
5子类继承父类时,必须重写抽象字段,进行赋值. 必须重写抽象方法,进行实现
6继承时,重写的方法建议添加override,可以判断是否重写(ide提示)
7抽象类可以没有抽象字段和抽象方法

abstract class _07Animal {
  //定义抽象字段
  val name: String
  val age = 0 //普通字段
  def running() //抽象方法
  def climb: String = "I can" //普通方法
}

class Dog extends _07Animal {
  override val name: String = "taidi"
  override def running(): Unit = println("狗可以跑")
}

总结

1. scala类主要是构造方法写法与java不同,相比java进行了简化. 另外,有主构造器和辅助构造器. 一般用含默认值的主构造器即可满足需求
2. 抽象类与java类似,单更为简化,比如里面的抽象方法可以无需abstract关键字