Scala编程精要-优快云博客

本文链接：https://blog.youkuaiyun.com/reddy_hu/article/details/107673643

package com.doit.scala.day03

class User {
  val id = 100010
  val name = "tom"
  //如果是var修饰的,就相当于自带了gettersetter方法
  var age = 18
  //被private修饰的 只能在此文件夹中使用
  private var money: Double = 1000
  //被private[this]修饰的只能在此class中使用
  private[this] var password = "123456"
  private def sayHi(): Unit ={
    println(User.ddd + "hi~" + password)
  }
}
//伴生对象: 根类同名,并且在同一个文件夹中的object
object User{
  
  //在object中定义的属性是静态的,定义的方法是静态的
  val www = "wwwww"
  private var ddd = "dddd"
  def say():Unit={
    println(ddd+aaa)
  }
  private[this] var aaa = "aaa"

  def main(args: Array[String]): Unit = {
    val u = new User
    println(u.money)
    u.money = 2000
    //u.password 调用不了
    u.sayHi()
  }
}

构造方法

package com.doit.scala.day03
//跟类名交织在一起的构造器叫主构造器,主构造器中用的var\val修饰的参数,会成为这个列的成员变量
class Person(val id: Long, var age: Int, val name: String) {

}
object Person{
  def main(args: Array[String]): Unit = {
    val p = new Person(100l,18,"kobe")
    println(p.id)
    println(p.age)
    println(p.name)
    p.age = 19
    println(p.age)
  }
}

辅助构造器

package com.doit.scala.day03

class People(val id: Long) {
//定义两个成员变量
  var name: String = _
  var age: Int = _
  var gender: String = _
  //构造器也叫构造方法,def定义,辅助构造是对主构造器的补充和扩展,辅助构造器一定要先调用主构造器
  def this(id: Long,name: String,age: Int){  //参数列表不能用var\val修饰
    this(id)   //辅助构造器必须调用主构造器
    this.name = name   //这个时候需要修饰这些变量的是var  才能用this
    this.age= age
  }
  def this(id: Long,name: String,age: Int,gender: String){
    this(id,name,age)  //也可以调用上一个辅助构造器
    this.gender=gender
  }
  def this(id: Long){//无参构造器
    this(0L)
  }

}
object People{
  def main(args: Array[String]): Unit = {
   // val p = new People(10L)
   val p = new People(10l,"zhaonianhang",34)
    println(p.id)
    println(p.age)
    println(p.name)
  }
}

私有构造器

package com.doit.scala.day03
//私有构造器  只能在伴生对象中new
class Student private(val id: Long,var name: String) {

}
object Student{
  def main(args: Array[String]): Unit = {
    val lili = new Student(11L, "lili")
    println(lili.name)
  }
}

包访问权限

package com.doit.scala.day03
//包访问权限    只能在scala中new
private[scala] class Man (val id: Long){

}

构造器中中的代码只要new处对象来就已经运行了

package com.doit.scala.day03

import scala.util.Random

class  Boy {
  val id = 10L
  println(id)
  private val random = new Random()
  def printid():Unit={
    println(id + "=")
  }
  private val i:Int = random.nextInt(5)
  println(i)
}
object Boy{
  def main(args: Array[String]): Unit = {
    val boy = new Boy
    //这个时候运行就已经打印了两个结果了  相当于构造代码块
    //但是方法是不会被调用的
    // 10
    //0
    println(boy)
    boy.printid()
  }
}

成员变量私有化

package com.doit.scala.day03

class Girl(val name: String,private var age: Int,private[this] var password: String,fv: Double = 100.0) {

}
object Girl{
  def main(args: Array[String]): Unit = {
    val zh = new Girl("zh", 21, "123456", 80)
    //被private修饰  所以只能在这个文件中被调用   
    println(zh.age)
    //这个成员变量是调用不了的  因为被private[this]修饰  只能在class中调用
    //println(zh.password)
  }
}

scala 中的继承和接口

实现类

package com.doit.scala.day03

class Monkey extends Animal with Flvable with Fightable {
  // 必须实现父类的抽象方法  override可加可不加
  override def run(): Unit = println("筋斗云~~~~")

  //实现父类非抽象方法  必须加override
  override def breath(): Unit = println("嗷呜~~~~")

  override def fly(): Unit = println("一个跟头十万八千里")
  override def fight(): Unit = println("吃俺老孙一棒")
}
object Monkey{
  def main(args: Array[String]): Unit = {
    val monkey = new Monkey
    monkey.run()
    monkey.breath()
    monkey.fly()
    monkey.fight()
  }
}

抽象类

package com.doit.scala.day03

abstract class Animal {
  //实现了的方法
  def breath(): Unit = {
    println("呼吸氧气")
  }

  //未实现的方法
  def run(): Unit
}

接口

package com.doit.scala.day03

//相当于java8的接口
trait Flvable {
  def fly():Unit
}

package com.doit.scala.day03

trait Fightable {
  def fight(): Unit={
    println("削你")
  }
}

抽象类用extengds继承,接口用with实现,如果没有抽象类继承,第一个实现的接口需要用entends实现

重写未实现方法的时候可以不带override 重写已经实现了的方法的时候需要带上override

scala中接口中的方法是可以实现的

抽象类和接口的区别是什么呢

抽象类只能继承一个,但是可以实现多个接口抽象类可以比作你爹接口可以比作你老师

多态

 //多态：父类引用指向子类对象或接口指向实现类，必须有方法的重写
    val a: Animal = new Monkey
    a.breath()  //嗷呜~~~~  a的类型是Animal  但是方法却是Monkey中的

单例设计模式

package com.doit.scala.day03

//在scala中,object就是单例
//静态对象还是单例对象
//伴生对象（更类同名，并且在同一个文件中）
object SessionFactory {
  val i = 100
  println(i)
  println("aaaaa")
}



object Test {
  def main(args: Array[String]): Unit = {
    val f1 = SessionFactory
    println(f1)
    val f2 = SessionFactory
    println(f2)
  }
}

//打印结果是
100
aaaaa
com.doit.scala.day03.SessionFactory$@28f67ac7
com.doit.scala.day03.SessionFactory$@28f67ac7

结果打印了两个地址值是相同的

虽然调用了两次方法但是方法中的打印只打印了一次