Scala基础知识笔记2

1 类

1.1 定义一个简单的类

1.2 field的getter 和 setter方法

感觉成员变量定义成  var 属性名=属性值即可，  不需要定义成 val 或者 private就行，

  // ---------------------- 自定义类 和 属性 get  set方法-------------------------------------------------
 /* class HelloWorld {
    var  name="zm" // 自动生成get set方法, 如果属性是private 那么生成的get set方法也是private
    val  age = 32  // val类型的成员变量只提供get方法 不提供set方法 比如调用  对象.age=34会报错
    def sayHello(name:String) {
      println("hi: " + name)
    }
    def getName = name
  }

  val hello = new HelloWorld
  //println(hello.getName) // 如果定义的方法没有括号 那么调用时也不能带括号
  //println(hello.sayHello("ping"))
  //println(hello.name) get方法获取属性值
  //hello.name="ping"  set方法设置属性值
 // println(hello.name)
  println(hello.age)
 // hello.age=34 // 编译报错
  //hello.love
*/
  // 自定义 属性的 get set方法  Scala的getter和setter方法的命名与java是不同的，是field和field_=的方式
  /*class Man{
    private var  myname = "zm"
    def name = "you name is" +  myname  // get方法
    def name_=(value:String) {  // 自定义 private类型的属性的 set方法  其中 _=固定写法并且前后不能有空格
      print("you cannot edit your name!!!")
    }
  }

/*  val man = new Man
  println(man.name) // 调用属性 get方法
  man.name="liang" // 调用属性 set方法 */

  // 属性是private类型的成员变量 自定义 set方法来修改属性值
  class Man{
    private var  myname = "zm"
    def name = "you name is" +  myname  // get方法
    def updateName(value:String) {  // 自定义 private类型的属性的set方法
      myname = value
    }
  }

  val man = new Man
  println(man.name)
  man.updateName("liang")
  println(man.name)*/

  // 生成java风格的 get set方法  感觉没必要
  /*import scala.reflect.BeanProperty
  class Student{
    @BeanProperty var name:String =_
    class Student(@BeanProperty var name: String)
  }
  val s = new Student
  s.setName("leo")
  println(s.getName())*/

1.3 constructor介绍

1.4 内部类介绍

  // 辅助构造函数  类似 java的构造器
/*  class Person{
    var name = ""
    var age = 0
    def this(name:String) {
      this()
      this.name = name
    }

    def this(name:String, age:Int) {
      this(name:String)
      this.age = age
    }
  }

  var person = new Person("zm",34)
  println(person.name)
  println(person.age)*/

  // 主构造函数  就是在类名括号里定义 构造函数需要的形参的写法
/*  class Person(val name: String, val age: Int) {
    println(name + " | " + age)
  }
  var person = new Person("zm",32)*/

 // 内部类
  import scala.collection.mutable.ArrayBuffer
  class Class {
    class Student(val name: String) {}
    val students = new ArrayBuffer[Student]
    def getStudent(name: String) =  { // 理解为新生报到
      new Student(name)
    }
  }

  val c1 = new Class
  val s1 = c1.getStudent("leo")
  c1.students += s1

1.5 object 静态类-继承-枚举-object的apply方法

// object  相当于静态类  存放静态field 和 method 工具方法  不能定义接受参数的constructor
  // object内部不在method内的代码就是 object的constructor  object的constructor只会在其第一次调用时执行一次
/*  object Person{
     private var eyes = 2
     println("this is object Person consutror")
     def getEyes = eyes
   }
  println(Person.getEyes)*/

  // 伴生类和伴生对象  class类和class同名的object对象并定义在同一个 .scala文件中，那么彼此是对方的伴生类好伴生对象
  // 特点是互相可以访问对方的private field属性
 /* object Person {
    private val eyeNum = 2
    def getEyeNum = eyeNum
  }

  class Person(name:String="zm", age:Int=32) {
    def sayHello = println(name + " | " + age + " have " + Person.getEyeNum + " eyes") // 使用伴生类的私有属性
  }

  val person = new Person
  person.sayHello*/

  // objectjic 继承 抽象类
/*  abstract  class Hello(var name:String="zm", var age:Int=32) {
    def sayHello(name:String):Unit
  }

  object Person extends Hello("zm",34) {
    override def sayHello(name: String) {
    println("hello " + name )
    }
  }
  Person.sayHello("liang")*/

  // object的重要方法 apply
  // 通常在伴生对象中实现apply方法，并实现构造伴生类的对象的功能,而且创建时通常不使用new Class的方式，使用Class()的方式
  // 隐士调用伴生对象的apply方法， 让代码更简洁 eg:  val a = Array(1,2,3)  Array类的伴生对象的apply方法就实现了接收可变数量的参数，并创建一个Array对象的功能
  // 自定义 伴生类和伴生对象和 apply
/* class Person(var name:String){

  }
  object Person {
    def apply(name:String): Unit = {
      new Person(name)
    }
  }*/
  // 必须定义在 object的main函数写法
/*  object HelloWorld {
    def main (args: Array[String]){
      println("hello world")
    }
  }*/
 // scalac xx.scala   scala xxx 编译和运行

  // 使用object实现枚举
  // Scala没有直接提供类似于Java中的Enum这样的枚举特性,需要用object继承Enumeration类，并且调用Value方法来初始化枚举值
/*  object Season extends Enumeration {
    val SPRING = Value(0, "spring")  // 索引位置 索引值
    val SUMMER = Value(1, "summer")
    val AUTUMN = Value(2, "autumn")
    val WINTER = Value(3, "winter")
  }
  println(Season(0)) // 得到 spring这个value的值
  println(Season.withName("spring"))  // 得到 spring
  //for (ele <- Season.values) println(ele)
  for(c<-Season.values) println(c)*/

继承之  override  super  isInstanceof  asInstanceof  模式匹配判断对象类型

 // 继承中  子类覆盖父类方法 必须使用 override   子类调用父类被覆盖的方法使用 super 关键字
 /* class Person {
    private var name = "leo"
    val age = 32
    def getName = name
  }
  class Student extends Person {
    private var score = "A"
    override val age = 34 // 子类可以覆盖父类 val的变量
    def getScore = score
    override def getName = "Hi, I'm " + super.getName
  }*/

  // 父类对象 指向了子类实例，  然后父类对象又想转换为子类  如果对象是null，则isInstanceOf一定返回false，asInstanceOf一定返回null
 /* c
  var p:Person = new Student
  if(p.isInstanceOf[Student]) { // 如果是子类类型
    //println("p is student")
    var s:Student = p.asInstanceOf[Student] // 那么强转成子类类型

    println( p.getClass ) // class com.beijing.App$Student    得到类实例的真实类信息
    println( classOf[Person] ) // class com.beijing.App$Person*/

  // 使用模式匹配 判断对象类型
/*  class Person
 class Student extends Person
  val p:Person = new Student

  p match {
    case one:Person => println("i am the Person type")
    case _ =>   println("i am unknown type")
  }*/

继承之子类父类构造函数

  // 子类调用父类的constructor 1 每个类可以有一个主constructor 和任意多个辅助constructor, 而每个辅助constructor第一行
  // 都必须是调用主constructor或者其他辅助constructor, 也就是子类的辅助构造函数第一行是一定不可能调用主类的构造函数的
  // 2 只能在子类的主构造函数中调用父类的构造函数， 如果是父类中接收的参数，比如name和age，子类中接收时，就不要用任何val或var来修饰了，否则会认为是子类要覆盖父类的field
/* class Person(name:String, age:Int)
  class Student(name:String, age:Int, var sex:Int) extends Person(name, age) {

    def this(name:String) {// 辅助构造函数调用主构造函数
      this(name,0,0)
    }

    def this(age:Int,name:String) {// 第一行 调用其他辅助构造函数
      this(name)
    }

  }*/

继承之 匿名内部类 抽象类

// 匿名内部类 定义没有名称的子类并直接创建对象，将创建的对象赋予一个变量， 以及可以将该对象传递给其他函数
/*  class Person(val name:String) { // 定义原始类
    def sayHello = "hello, i am " + name
  }

  val p = new Person("zm") { // 匿名内部类需要覆盖主类的方法  因为匿名内部类相当于主类的子类
    override def sayHello = "hello, i am" + name
  }

  def greeting(p:Person) { // 普通传参
    println(p.sayHello)
  }

  def greeting1(p:Person{def sayHello:String}) { // 普通传参
    println(p.sayHello)
  }

  greeting1(p)*/

  // 抽象类 抽象方法 抽象属性  子类在继承过来之后 这些类方法属性都不需要override