scala类

object是静态的，只能做一次加载，调用时，不需要进行new

class 类需要做new 新的对象，通过对象进行方法和属性调用
trait 类是接口

1、与java类型，class 类里面有变量（类内部声明变量需要声明类型和占位符，或者初始化默认值；在类名后边进行变量定义只需要声明类型）

package com.cslc.day1
/*
* 面向对象
* 类的定义与使用
* 构造器
* 继承与重写
* 抽象类
* 伴生类和伴生对象
* apply
* case class
* trait  (接口)
* */

object FaceClass {

  def main(args: Array[String]): Unit = {
    val people =new People
    people.name="meissi"
    people.age=31
    println(people.eat())
    println(people.watchfoobal("CBA"))
    people.printInfo()
  }
}


class People{
  //属性
  var name:String=_
  var age:Int=_

  private  [this] val gender="male"
  def printInfo():Unit={
  println("gender is  " + gender)
  }
  def eat(): String ={
    name +" is eating"
  }
  def watchfoobal(teamname:String): String ={
    name +" is watching " +teamname+" games"
  }
}

2、构造器与附属构造器

package com.cslc.day1

object ConstructorApp {
  def main(args: Array[String]): Unit = {
    val people=new Person("messi",31)
    println(people.name+" "+people.school)
    val person2=new Person(name = "cluo",age = 33,"M")
    println(person2.name+":",person2.age+":"+person2.gender)
  }

}

//主构造器
class  Person(val name:String,val age:Int){
  println("person Constructor enter...")
  val school ="ustc"
  var gender:String = _

  println("person structor is leaving")
  //附属构造器
  def this(name:String,age:Int,gender:String){
    this(name,age)//附属构造器第一行需要调用主构造器或者其他附属构造器
    this.gender = gender
  }
}

3、类的继承与变量重写

package com.cslc.day1

object jichen {
  def main(args: Array[String]): Unit = {
    val s1=new Student("liu",18,"bioinformation")
    println(s1.major)
    println(s1.school)
  }
}
//继承Person类，重写变量
class  Student(name:String,age:Int,val major:String) extends Person(name,age){
  println("student is entr......")
  override val school= "dlut"
  println("student is leaving")
}

4、抽象类：方法和或者变量只进行了定义没有进行实现，继承抽象类需要完善方法或者变量

 5、case class 通用与模式匹配，使用case class 定义的类不需要进行new

package com.cslc.day1

object CaseClassApp {
  def main(args: Array[String]): Unit = {
    print(Dog("wangcai",13).age)
  }
}
case class Dog(name:String,age:Int)

//通常用于模式匹配

6、伴生类与伴生对象，类名一样，伴生对象直接调用，他是静态的，只能调用一次，默认会调用方法object.apply() ，伴生类需要new 实例，实例()时候，会调用class.apply()

最佳实践：在伴生对象的apply方法中，声明new 伴生类的实例。

package com.cslc.day1

object ApplyApp {
  def main(args: Array[String]): Unit = {
    for (i <- 1.to(10)) {
      ApplyTest.incr
    }
    println(ApplyTest.count)
    val b=ApplyTest()  //使用伴生类或者伴生对象加（） ，默认使用object.apply()
    val c=new ApplyTest()   //进入class
    c()  //调用class。apply
  }
}
/*
*
*
* class 名和object 名称相同，则：伴生对象和伴生类
* object是一个单例，默认调用object
*
* object()  调用object.apply()
*class new 对象t t() 调用class.apply()
*
*
* 最佳实践：object中的apply中new 一个 class对象
* */
class ApplyTest{
  println("class is enter ....")
  println("class is leaving....")

  def apply(): Unit ={
    println("class.apply is entering")
  }
}
object  ApplyTest{
  println("object is enter ......")
  var count=0
  def incr():Unit ={
      count+=1

  }
  println("object is leaving")


  def apply()={
    println("print object.apply is enter ...")

  }
}