scala 基础3

面向对象的基本概念
把数据及对数据的操作方法放在一起，作为一个相互依存的整体——对象
面向对象的三大特征：
封装
继承
多态
简单类和无参方法：
案例：注意没有class前面没有public关键字修饰。
属性的getter和setter方法
当定义属性是private时候，scala会自动为其生成对应的get和set方法
定义属性：private var money:Int = 1000 希望money只有get方法，没有set方法？？
办法：将其定义为常量private val money:Int = 1000
private[this]的用法：该属性只属于该对象私有，就不会生成对应的set和get方法。如果这样，就不能直接调用，例如：

  //private[this] var stuAge:Int = 20

不能通过这个类的对象访问。people.stuAge 是❌

object SimpleObject {
  def main(args: Array[String]): Unit = {
     val people=new People()
    people.name="messi"
      println(people.name+"--"+people.age)
  }
}
class People{
  var name:String =""
  //添加占位符号
  var name:String =_
  val age:Int=10
  //定义方法
  def eat():String={
   name+"eating"
  }
  def watchFootball(teamname:String):Unit={
   println(name+"watchfootball"+teamname);
  }
}

构造器
类的构造器
类的构造器分为：主构造器、辅助构造器
主构造器：和类的声明结合在一起，只能有一个主构造器
Student4(val stuName:String,val stuAge:Int)
(1) 定义类的主构造器：两个参数
(2) 声明了两个属性：stuName和stuAge 和对应的get和set方法

辅助构造器：可以有多个辅助构造器，通过关键字this来实现

object ConstructorApp {
  def main(args: Array[String]): Unit = {
    //主构造器2个参数
     val people=new Person("zhangsan",20)
     println(people.age+"--"+people.name)
    //辅助构造器三个参数
    val people1=new Person("zhangsan",20,"M")
    println(people1.age+"--"+people1.name+"--"+people1.gender)
  }
}
//主构造器
class Person(val name: String,val age:Int){
  var gender:String=_
  //附属构造器
  def this(name:String,age:Int,gender:String){
    this(name,age)//附属构造器的第一行代码必须要调用主构造器或者其他附属构造器

  }
}

继承
Scala和Java一样，使用extends关键字扩展类。
案例一：Employee类继承Person类

子类继承父类的时候，首先是调用父亲的构造方法

object ConstructorApp {
  def main(args: Array[String]): Unit = {
    //主构造器2个参数
   val student=new Student("fk",18,"math")
    println(student.name+"--"+student.major+"--"+student.age)

  }
}
//主构造器
class Person(val name: String,val age:Int){
  var gender:String=_
  //附属构造器
  def this(name:String,age:Int,gender:String){
    this(name,age)//附属构造器的第一行代码必须要调用主构造器或者其他附属构造器
  }
}
//继承子类继承父类
class Student(name:String,age:Int,var major:String) extends Person(name,age){
    print("student")
}

重写
案例二：在子类中重写父类的方法

使用抽象类。抽象类中包含抽象方法，抽象类只能用来继承。
伴生类和伴生对象

object ApplyApp {
  def main(args: Array[String]): Unit = {
//    for(i<- 1 to 10){
//     print(ApplyTest.cur) //说明object本身就是单例对象。
//    }
    val b=ApplyTest() //==>object.apply
    println("----")
     val c=new ApplyTest()
    println(c)
    c()
    //类名()==>object.apply
    //对象()==>class.apply
  }
}
//类 这个class与object同名伴生类与伴生对象
//class是object的伴生类
//object 是class的伴生对象
class ApplyTest{
  def apply(): Unit ={
    print("class apply test ..")
    //在object中的apply方法中new class

  }
}
//
object ApplyTest{
  var count=0
  def cur: Unit ={
    count=count+1
  }

  def apply(){
    print("object apply test ..")
    //在object中的apply方法中new class
    new ApplyTest
  }
}

case class
样本类(CaseClass)
简单的来说，Scala的case class就是在普通的类定义前加case这个关键字，然后你可以对这些类来模式匹配。
case class带来的最大的好处是它们支持模式识别。

//通常在模式匹配
object CaseClassApp {
  def main(args: Array[String]): Unit = {
     println(Dog("wangcai").name)
  }
}
//case class不要new
case class Dog(name:String){
}

trait
trait（特质）
trait就是抽象类。trait跟抽象类最大的区别：trait支持多重继承

package com.dragon.learn02

/**
  * Scala中的trait
  * 1. trait就是抽象类
  * 2. 区别：trait支持多重继承
  */
//第一个trait
trait Human{
  //抽象的字段
  val id:Int
  val name:String

  //方法
  def sayHello():String = "Hello " + name
}
//第二个trait
trait Actions{
  //抽象的方法
  def getActionNames():String
}
//子类,第二个，第三个都是用with
class TOM(val id:Int,val name:String) extends Human with Actions{
  def getActionNames():String = "Action is running"
}

object traitApp {
  //测试程序
  def main(args: Array[String]) {
    //创建一个student的对象
    val s1 = new TOM(1,"Tom")
    println(s1.sayHello())
    println(s1.getActionNames())
  }
}