scala语言入门（二）对象篇

一 、类和对象的使用

      object SimpleObjectApp{
       def main(args: Array[String]): Unit = {
      var person = new People()
       person.name = "Messi"
       println(person.name+".."+person.age)
       println(person.eat())
       person.watchFootball(" 火箭 ")
        }
      }
      /**
       * 定义一个People类
       */
      class People{
       //定义属性，scala中自动生成set get 方法
       var name:String = ""
       //也可以使用一个 下划线占位符
      // var name:String =_
       val age:Int = 10
       //使用private [this] 修饰的属性 只能在本来中使用
       private [this] val gender = "male";
       //方法
       def eat(): String ={
       name +" eat ...."
        }
       def watchFootball(teamName:String): Unit ={
       println(name+" is watching match of"+teamName)
        }
       def printInfo(): Unit ={
       println(gender)
        }
      }
  
 

二、主构造器、附属构造器、继承、重写

      package com.dzx
      /**
       * @author DuanZhaoXu
       * @ClassName:
       * @Description: 主构造器，附属构造器，继承 ，重写
       * @date 2018年12月18日 09:47:11
       */
      object ConstructorApp {
       def main(args: Array[String]): Unit = {
      val zhangSan = new People1("张三",20)
       println(zhangSan.name+","+zhangSan.age+","+zhangSan.school)
      val liSi = new People1("李四",20,"100")
       println(liSi.name+","+liSi.age+","+liSi.gender)
      var student = new Student("王五",10,"英文")
       println(student.name +","+student.age+","+student.major)
       println(student.toString)
        }
      }
      //主构造器
      class People1(var name:String,var age:Int){
         println("enter start。。。。")
        var school = "ustc"
       var gender:String =_
       //附属构造器
       def this(name:String,age:Int,gender:String){
      this(name,age)  //附属构造器的第一行代码必须要调用主构造器或者其他的附属构造器
      this.gender =gender
        }
         println("leave end 。。。。")
       //使用override 重写 toString 方法
       override def toString = s"People1($school, $gender, $name, $age)"
      }
      //子类集成父类，继承的属性，不再需要写var 或者 val，自身特有的属性 才需要加上var 或者 val
      class Student (name: String,age:Int,val major:String) extends People1(name ,age){
        println("student enter start。。。。")
        println("student leave end 。。。。")
       //使用override 重写toString 方法
       override def toString = s"Student($major)"
      }
  
 

 三、抽象类的使用

      package com.dzx
      /**
       * @author DuanZhaoXu
       * @ClassName:
       * @Description: 抽象类的使用
       * @date 2018年12月18日 10:37:27
       */
      object AbstractApp {
       def main(args: Array[String]): Unit = {
      var xiaoming = new Student2
       xiaoming.name = "小明"
       xiaoming.age = 12
       println(xiaoming.name + "," + xiaoming.age)
        }
      }
      /**
       * 类的一个或者多个方法 没有完整的实现（只有定义，没有实现）
       */
      abstract class Person2 {
       def speak(say: String)
       var name: String
       var age: Int
      }
      class Student2 extends Person2 {
       override def speak(say: String): Unit = {
       println(name + " speaking ...")
        }
       override var name: String = ""
       override var age: Int = 0
      }
  
 

 四、伴生类、伴生对象、apply方法的用法

      package com.dzx
      /**
       * @author DuanZhaoXu
       * @ClassName:
       * @Description: 伴生类和伴生对象
       * @date 2018年12月18日 10:50:34
       */
      /**
       * 伴生类和伴生对象
       * 如果有一个class ，还有一个与class 同名的object
       * 那么就称这个object 是 class的伴生对象，
       * class 是object 的伴生类
       */
      object ApplyTest{
       def main(args: Array[String]): Unit = {
      //伴生对象的使用
      ApplyApp.incr
       println(ApplyApp.count)
      for (i<-1 to 10){
      ApplyApp.incr
       }
       println(ApplyApp.count)
      var b =  ApplyApp()   //类名() 调用的是 伴生对象的 apply 方法
      var c = new ApplyApp()
       c()  //对象名() 调用的是伴生类 的 apply方法
        }
      }
      class ApplyApp {
       def apply() = {
       println("走了伴生类的apply 方法")
        }
      }
      object ApplyApp{
        println("start")
        var count = 0
       def incr ={
       count +=1
        }
        println("end")
       //最佳实践，在伴生对象的 apply 方法
       def apply():ApplyApp =  {
       println("走了伴生对象的apply 方法")
      new ApplyApp
        }
      }
  
 

 五、case class 

      package com.dzx
      /**
       * @author DuanZhaoXu
       * @ClassName:
       * @Description:
       * @date 2018年12月18日 14:08:49
       */
      //case class 通常用在 模式匹配里面
      object CaseClassApp {
        def main(args: Array[String]): Unit = {
       println(Dog("小狗").name) //case class 不需要new 就可以声明一个 dog对象
        }
      }
      case class Dog(name: String) {
       var age: Int = _
      }
  
 

六、trait 的用法（类似于java中的interface接口）

      package com.dzx
      /**
       * train 定义一个 接口，类似于java中的interface
       * 当我们需要 实现接口的 时候 ,第一个接口 使用 extends，后面的需要实现的trait 则使用 with 连接
       * extends Atrait with Btrait
       *
       * class SparkConf(loadDefaults : scala.Boolean)
       * extends java.lang.Object
       * with scala.Cloneable with org.apache.spark.internal.Logging
       * with scala.Serializable
       */
      object TraitApp{
       def main(args: Array[String]): Unit = {
      val  traitApp = new TraitApp()
       println(traitApp.add(2,3))
       println(traitApp.decr(10,5))
        }
      }
      class TraitApp extends userDao with personDao {
       override def add(x: Int, y: Int): Int = {
       x + y
        }
       override def decr(x: Double, y: Double): Double ={
       x-y
        }
      }
      trait userDao extends Serializable{
      def add(x:Int,y:Int):Int
      }
      trait personDao extends Serializable{
       def decr(x:Double,y:Double):Double
      }
  
 

文章来源: blog.csdn.net，作者：血煞风雨城2018，版权归原作者所有，如需转载，请联系作者。

原文链接：blog.csdn.net/qq_31905135/article/details/85068834