3.scala快速入门-类、对象、继承、特质（2）

1.类

1.1 类的定义

//在Scala中，类并不用声明为public。
//Scala源文件中可以包含多个类，所有这些类都具有公有可见性。
class Student {
  //用val修饰的变量是只读属性，有getter但没有setter
  //（相当与Java中用final修饰的变量）
  val id = 666

  //用var修饰的变量既有getter又有setter
  var age: Int = 20

  //类私有字段,只能在类的内部使用，除了伴生对象以外，其它的访问不到
  private var name: String = "tom"

  //对象私有字段,访问权限更加严格的，连伴生对象都访问不到
  private[this] val pet = "小强"
}

1.2 构造器

Scala的构造器会分为主构造器和辅助构造器

package lesson06

/**
  * Created by Administrator on 2018/1/5.
  * 构造函数：
  * 1）主构造函数
  *    a 与类名交织在一起的
  *    b 执行的时候，类后面的大括号里面所有的代码都会被执行！！
  * 2）辅助构造函数
  *     方法名必须是 this
  *     每个辅助构造器必须开始首先调用的是主构造器(或者调用其他的辅助构造器)
  */
class Person(var id:Int,var age:Long) {
    var name:String="lisi"
    var address="DaLi"

    def this( id:Int,age:Long,name:String){
      //这个地方其实调用的是就是主构造器
      this(id,age)
      this.name=name
    }

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


  println("我是主构造函数！！")
  def sayHello(): Unit ={
    println("今天星期不错，因为到周五了。还有就是分钟就下班了！！！")
  }
  sayHello()
}

object Test{
  def main(args: Array[String]): Unit = {
    val person = new Person(123,150)
    val person1 = new Person(234,73,"司马懿","魏国")

    println(person1.name)

  }
}

1.3对象

单例对象：

在Scala中没有静态方法和静态字段，但是可以使用object这个语法结构来达到同样的目的

1.存放工具方法和常量

2.高效共享单个不可变的实例=单例模式

import scala.collection.mutable.ArrayBuffer

object SingletonDemo {
  def main(args: Array[String]) {
    //单例对象，不需要new，用【类名.方法】调用对象中的方法
    val session = SessionFactory.getSession()
    println(session)
  }
}

object SessionFactory{
  //该部分相当于java中的静态块
  var counts = 5
  val sessions = new ArrayBuffer[Session]()
  while(counts > 0){
    sessions += new Session
    counts -= 1
  }

  //在object中的方法相当于java中的静态方法
  def getSession(): Session ={
    sessions.remove(0)   
  }
}

class Session{

}

总结

1）object里面的方法都是静态方法

2）Object里面的字段都是静态字段

3）它本身就是一个单例，(因为不需要去new)

伴生对象：

在同一个文件中，在Scala的类中，与类名相同的对象叫做伴生对象，该类为伴生类，伴生类和伴生对象之间可以相互访问私有的方法和属性。

class Dog {
  val id = 1
  private var name = "xiaoqing"

  def printName(): Unit ={
    //在Dog类中可以访问伴生对象Dog的私有属性
    println(Dog.CONSTANT + name )
  }
}

/**
  * 伴生对象
  */
object Dog {

  //伴生对象中的私有属性
  private val CONSTANT = "汪汪汪 : "

  def main(args: Array[String]) {
    val p = new Dog
    //访问私有的字段name
    p.name = "123"
    p.printName()
  }
}

应用程序对象：

Scala程序都必须从一个对象的main方法开始，可以通过扩展App特质，不写main方法。

object AppObjectDemo extends App{
  //不用写main方法
  println("I love you Scala")
}

apply方法

通常我们会在类的伴生对象中定义apply方法，当遇到类名(参数1,...参数n)时apply方法会被调用

object ApplyDemo {
  def main(args: Array[String]) {
    //调用了Array伴生对象的apply方法
    //def apply(x: Int, xs: Int*): Array[Int]
    //arr1中只有一个元素5
    val arr1 = Array(5)
    println(arr1.toBuffer)
  }
}

1.4继承

/**
 * // Scala中，让子类继承父类，与Java一样，也是使用extends关键字
// 继承就代表，子类可以从父类继承父类的field和method；然后子类可以在自己内部放入父类所没有，子类特有的field和method；使用继承可以有效复用代码
// 子类可以覆盖父类的field和method；但是如果父类用final修饰，field和method用final修饰，则该类是无法被继承的，field和method是无法被覆盖的
Java不支持多继承  为什么？   
子类不能继承父类的private属性(事实1)，但可以通过继承的方法(比如，public方法)访问到父类的private属性。
 */


class Person {
  private var name = "leo"
  def getName = name
}
class Student extends Person {
  private var score = "A"
  def getScore = score
}

object  Test{
  def main(args: Array[String]) {
    val s=new Student();
    println(s.getName)
  }
}

override和super

/**
// Scala中，如果子类要覆盖一个父类中的非抽象方法，则必须使用override关键字
// override关键字可以帮助我们尽早地发现代码里的错误，比如：override修饰的父类方法的方法名我们拼写错了；比如要覆盖的父类方法的参数我们写错了；等等
// 此外，在子类覆盖父类方法之后，如果我们在子类中就是要调用父类的被覆盖的方法呢？那就可以使用super关键字，显式地指定要调用父类的方法
 */
class Person {
  private var name = "leo"
  def getName = name
}
class Student extends Person {
  private var score = "A"
  def getScore = score

  override def getName = "Hi, I'm " + super.getName
}

object  Test{
  def main(args: Array[String]) {
    val s=new Student();
    println(s.getName)
  }
}

抽象类

// 如果在父类中，有某些方法无法立即实现，而需要依赖不同的子来来覆盖，重写实现自己不同的方法实现。此时可以将父类中的这些方法不给出具体的实现，只有方法签名，这种方法就是抽象方法。
// 而一个类中如果有一个抽象方法，那么类就必须用abstract来声明为抽象类，此时抽象类是不可以实例化的
// 在子类中覆盖抽象类的抽象方法时，不需要使用override关键字

abstract class Person(val name: String) {
  def sayHello: Unit
}
class Student(name: String) extends Person(name) {
  def sayHello: Unit = println("Hello, " + name)
}

备注：

在Scala中扩展类的方式和Java一样都是使用extends关键字。

在Scala中重写一个非抽象的方法必须使用override修饰符。

2.特质（trait）

特质，有接口的特性。

Jdk7:接口是一个特殊的抽象类。里面所有的方法都是抽象方法。

//特质里面的方法既可以实现，也可以不实现，那么跟抽象类有什么区别

//抽象类，我们用的是extends，我们只能单继承，但是我们可以多实现。

//实现特质，如果没有继承其它类，那么使用第一个特质使用extends

后面的使用with。所以如果有考题说实现特质只能使用with，这是不对的。

2.1将特质作为接口使用：

/**
 * // Scala中的Triat是一种特殊的概念
// 首先我们可以将Trait作为接口来使用，此时的Triat就与Java中的接口非常类似
// 在triat中可以定义抽象方法，就与抽象类中的抽象方法一样，只要不给出方法的具体实现即可
// 类可以使用extends关键字继承trait，注意，这里不是implement，而是extends，在scala中没有implement的概念，无论继承类还是trait，统一都是extends
// 类继承trait后，必须实现其中的抽象方法，实现时不需要使用override关键字
// scala不支持对类进行多继承，但是支持多重继承trait，使用with关键字即可
 */
trait HelloTrait {
  def sayHello(name:String)
}

trait MakeFriendsTrait{
  def makeFriends(w:Worker)
}
class Worker(var name:String) extends HelloTrait with MakeFriendsTrait{
  def sayHello(name:String) = println("hello ,"+name)
  def makeFriends(w:Worker)=println("hello, my name is"+name+" you name is"+w.name)
}

object Test{
  def main(args: Array[String]) {
    val p1=new Worker("xiaoma");
    val p2=new Worker("linghuchong")
    p1.sayHello("lihuchong")
    p1.makeFriends(p2)
  }
}

2.2在特质中可以定义具体方法：

/**
 // Scala中的Triat可以不是只定义抽象方法，还可以定义具体方法，此时trait更像是包含了通用工具方法的东西
// 有一个专有的名词来形容这种情况，就是说trait的功能混入了类
// 举例来说，trait中可以包含一些很多类都通用的功能方法，比如打印日志等等，spark中就使用了trait来定义了通用的日志打印方法
 */
trait Logger {
  def log(message:String) = println(message)
}
class Person(val name:String) extends Logger{
  def makeFridends(p:Person): Unit ={
    println("I'm"+name+" i'm glade to make friends with you"+p.name);
    log("makeFridends method invoked!!")
  }
}
object Test{
  def main(args: Array[String]) {
    val p1=new Person("linpingzhi")
    val p2=new Person("yuelingshan");
    p1.makeFridends(p2)
  }
}

2.3在特质中可以定义具体字段

/**
 * // Scala中的Triat可以定义具体field，此时继承trait的类就自动获得了trait中定义的field
// 但是这种获取field的方式与继承class是不同的：如果是继承class获取的field，实际是定义在父类中的；
  而继承trait获取的field，就直接被添加到了类中
 */
trait Person {
  val eyeNum:Int=2
}
class Student(val name:String) extends Person{
  def sayHello()=println("Hi,I'm "+name +"I have "+eyeNum+"eyes !" )
}
object Test{
  def main(args: Array[String]) {
    val s=new Student("zhangsanfeng")
    s.sayHello();
  }
}

2.4在特质中可以定义抽象字段

/**
 * // Scala中的Triat可以定义抽象field，而trait中的具体方法则可以基于抽象field来编写
// 但是继承trait的类，则必须覆盖抽象field，提供具体的值
 */
trait sayHello {
  val msg:String
  def sayHello(name:String)=println(msg +" , "+name)
}
class Person(val name:String) extends sayHello{
  val msg:String = "hello"
  def makeFriends(p:Person): Unit ={
    sayHello(p.name)
    println("I'm"+name +" I want to make frieds with you")
  }
}
object Test{
  def main(args: Array[String]) {
    val p1=new Person("zhangwuji")
    val p2=new Person("zhangsanfeng")
    p1.makeFriends(p2)

  }
}

2.5为示例对象混入特质

/**
 * // 有时我们可以在创建类的对象时，指定该对象混入某个trait，这样，就只有这个对象混入该trait的方法，而类的其他对象则没有
 */
trait Logged {
  def log(msg:String){}

}
trait AMyLogger extends Logged{
  override def log(msg:String): Unit ={
    println("test:"+msg)
  }
}
trait BMyLogger extends Logged{
  override def log(msg:String): Unit ={
    println("log:"+msg)
  }
}
class Person(val name:String) extends AMyLogger{
  def sayHello(): Unit ={
    println("Hi ,i'm name")
    log("sayHello is invoked!")
  }
}
object  Test{
  def main(args: Array[String]) {
    val p1=new Person("liudehua")
    p1.sayHello() 


    val p2=new Person("zhangxueyou") with BMyLogger
    p2.sayHello()
  }
}

2.6trait特质调用链

/**
 * // Scala中支持让类继承多个trait后，依次调用多个trait中的同一个方法，只要让多个trait的同一个方法中，在最后都执行super.方法 即可
// 类中调用多个trait中都有的这个方法时，首先会从最右边的trait的方法开始执行，然后依次往左执行，形成一个调用链条
// 这种特性非常强大，其实就相当于设计模式中的责任链模式的一种具体实现依赖
 */
trait Handler {
  def handler(data:String){}
}
trait DataValidHandler extends Handler{
  override def handler(data:String): Unit ={
    println("check data:"+data)
    super.handler(data)
  }
}
trait SignatureValidHandler extends Handler{
  override def handler(data:String): Unit ={
    println("check signatrue:"+data)
    super.handler(data)
  }
}
class  Person(val name:String) extends SignatureValidHandler with DataValidHandler{
  def sayHello={
    println("Hello "+name)
    handler(name)
  }
}

object Test{
  def main(args: Array[String]) {
    val p=new Person("lixiaolong");
    p.sayHello
  }
}