Scala

目录

 

01. 成员变量

02. 成员方法

03. 成员函数

04. 局部变量

05. 代码块

06. apply方法

07. classOf/isInstanceOf/asInstanceOf

08. 权限修饰符  private    private[this]    private[packageName]

09. 特质    动态混入 new对象是再实现接口

10. 抽象类

11. 样例类

12. 高阶函数

13. 偏函数

14. 匹配模式

---

01. 成员变量

位置：1.主构造器   2. 类的主体位置 

使用val/var修饰

val name:String = "zss"

val 定义的成员变量一定要赋值，在主构造器中除外

var age:Int = _

var 定义的成员变量可以不赋值，用_占位

想要使用get/set方法可以用依赖 @BeanProperty

import scala.beans.BeanProperty

class Demo01 {
  val name:String = "zss"
  @BeanProperty
  var age:Int =_

  def this(id:Int,job:String){
    this()
    println(id+":"+job)
  }

  def apply(): Demo01 = new Demo01()
}

object Demo01 {
  def apply(id: Int, job: String): Demo01 = new Demo01(id, job)

  def main(args: Array[String]): Unit = {
    Demo01(1,"coder")
    val demo0 = new Demo01()
    demo0.setAge(28)
    val age: Int = demo0.getAge
    println(age)
  }
}

02. 成员方法/成员函数

在类的成员位置定义的函数或者方法是类的成员的一部分

class Demo02(private var name:String) {
  // 成员方法
  def show1(): Unit = {
    println("hello")
  }
  // 成员函数
  val f1: (String, String) => Unit = (str1:String, str2:String) => {
    println(str1+str2)
  }
}

object Demo02 {
  def main(args: Array[String]): Unit = {
    // 成员方法
    def show2(): Unit = {
      println("hello")
    }
    // 成员函数
    val f2: (String, String) => Unit = (str1:String, str2:String) => {
      println(str1+str2)
    }
  }
}

03. 代码块

在类或者对象中的代码块在实例化的时候会被调用

在class中的成员代码块每次创建实例都会执行

在object中的成员代码块只在加载的时候执行一次

class Demo3 {
  //每次创建实例都会执行
  {
    println("hello")
  }
}
 
object Demo3 {
  // 只在加载的时候执行一次
  {
    println("hello2")
  }
}

04. 局部变量

定义在函数/方法的参数中 , 定义在代码块中 , 定义在流程控制的条件表达式中

  1 局部变量都需要设置初始值

  2 局部变量的作用范围 ,定义的代码块中

05. 伴生类和伴生对象

条件 1：在同一个源文件中, 条件 2：对象名和类名相同

伴生对象和伴生类之间可以互相访问彼此的私有属性和私有方法

06. apply方法

这是一个特殊的方法

1 不用声明式的调用方法

2 创建对象的时候不用new     

使用此方法时，可以在main函数中不通过new来创建一个对象，即可以不用专门的一次一次地进行实例化，加载创建对象的这个类的时候，会自动调用apply这个方法，类似Java中的static静态块。

建议将这个方法写在半生对象中 , 如果将这个方法写在一个没有半生对象的类中是无法使用的

• apply方法的主要目的是不使用new来获取实例对象, 并且默认是单例的!!!!!
• apply方法建议编写在伴生对象中
• apply方法如果没有参数也不要省略()

class Demo05 {
  var x:Int = _
  var y:Int = _
  def this(x:Int,y:Int) = {
    this()
    this.x = x
    this.y = y
  }

  def show() = {
    println("hello...")
  }
}
object Demo05 {
  def apply(): Demo05 = {
    new Demo05()
  }

  def apply(x: Int, y: Int): Demo05 = new Demo05(x, y)

  def main(args: Array[String]): Unit = {
    // Demo05() 等同于 Demo05.apply()

    val demo0 = new Demo05
    demo0.show()

    val demo1 = Demo05()
    demo1.show()
    Demo05().show()

    val demo2 = Demo05(18,22)
    println(demo2.x)
  }
}

object ApplyTest {
  def main(args: Array[String]): Unit = {
    val demo0 = Demo05(1,2)
    println(demo0.x)

  }
}

apply 调用其他方法

class Demo06 {
  def show() = {
    println("show...")
  }
}

object Demo06 {
  // 空参的apply方法不要省略 ()
  def apply() = new Demo06().show()
  def main(args: Array[String]): Unit = {
    Demo06()
  }
}

07. classOf/isInstanceOf/asInstanceOf

class A {

}
class B extends A {

}

object Demo07 {
  def main(args: Array[String]): Unit = {
    val a = new A
    println(a.isInstanceOf[A])
    val b = new B
    b.isInstanceOf[B]
    // 强制类型转换 有继承关系的强转
    b.asInstanceOf[A]
    // a.asInstanceOf[B]  // ClassCastException: com.yaoz.demo.day05.A cannot be cast to com.yaoz.demo.day05.B 不可以转换
    // 获取类的字节码 类似于全类名
    println(classOf[A])  // class com.yaoz.demo.day05.A
    println(Class.forName("com.yaoz.demo.day05.A"))  // class com.yaoz.demo.day05.A
  }
}

08. class、object的选择

• class object 一般情况下，使用 object + 伴生的 class
• 优先使用object，object本质上拥有了的类的所有特性，object中没有构造器，也没有 参数 ，必须要有程序入口，object，main方法，必不可少
• 如果是单例的，优先选择object，如果是多例的（封装数据，构造器），必须选择类
• 伴生类和伴生对象都会用到。

09. 权限修饰符  private    private[this]    private[packageName]

 

09. 特质    动态混入 new对象是再实现接口

 

10. 抽象类

 

11. 样例类

 

12. 高阶函数

 

13. 偏函数

 

14. 匹配模式