Scala学习——类，继承，接口（中）

基本类的使用：（初）

package com.dtspark.scala.basics
/**
 * trait是一个接口
 * 接口的第一次继承用extends，多继承时用with
 * 多继承时，如果这些接口中都有同样的方法时，则是从右往左的顺序执行
 * 抽象类不能实例化
 * 类继承的时候不继承伴生对象object，只能看见类的接口，而其父类可以使用自己伴生对象中的方法
 * isInstanceOf 和 asInstanceOf的使用
 * 前者是判断是不是其子类，后者是进行类型转换，但必须是父子之间的转换，不能是完全不同的类
 */
trait Logger{
  def log(message:String){
    println("logger "+message)
  }
  
}
/**
 * override 是表示重写原有方法，（必须要写）
 */
trait RichLogger extends Logger{
  override def log(message:String){
    println("RichLogger:"+message)
  }
}

class Loggin( name:String)extends Logger{
  def loggin{
    println("Hi,welcome! "+name)
    log(name)
  }

}



trait Information{
  
  val information:String //抽象属性
  //def getId:String
  def getInformation:String //抽象方法(不存在方法体)
  def checkIn:Boolean = {
    getInformation.equals("Spark")
  }
}

class Passenger( name:String)extends Information{
  //不可以定义为val 原因是因为_的值不明确
  var id:String=_ //这种方法申明的不是抽象属性，而是可变属性，其值为String的默认值null
  override val information = name //重写抽象属性
  override def getInformation = information //不执行任何操作，直接给返回值，相当于实现了
  /**
   * this关键字为构造方法，重写构造方法
   * 副构造函数的第一行必须是构造函数
   */
  def this(name:String,iid:String){
    this(name)
    id=iid;
    println("hello!!")
  }
  def out:String={
    name+" : "+id
  }
  
}

object HelloTrait {
  def main(args: Array[String]): Unit = {
    /**
     * 对象实例化之后又继承了新的接口，可以使用新的方法
     * 新的接口必须继承至原有的接口，并重写新的方法
     */
    val Log = new Loggin("Spark")with RichLogger
    Log.loggin
    
    val person = new Passenger("zcb")
    println(person.out)
    person.id="123"  //不具有封装性
    println(person.out)
    val person1 = new Passenger("zcb1","1234")
    println(person1.out)
    val a:Boolean=person.isInstanceOf[Information]//看它是不是其子类
    println(a)
  }
}

 

类的继承和判断对象是否相等（中）

package com.dtspark.scala.basics
/**
 *class Creature {
 *   val range: Int = 10
 *   val env: Array[Int] = new Array[Int](range)
 *}
  
 *class Ant extends Creature {
 *   override val range = 2
 *}
 * 在构造时，发生的过程如下：
 * Ant构造器在构造自己之前，调用超类构造器；
 * Creature的构造器将range字段设为10；
 * Creature的构造器初始化env数组，调用range字段的getter；
 * range的getter被Ant类重写了，返回的Ant类中的range，但是Ant类还未初始化，所以返回了0；
 * env被设置成长度为0的数组
 * Ant构造器继续执行，将range字段设为2
 * -------------------------------------------------------------
 * 第二种写法是先初始化sporter的成员，然后在初始化父类的成员，这样可保证将数据传给父类，with后面接要继承的类
 * class Person10{
 *  val counter=3
 *  val counterArray =new Array[Int](counter)
 * }
　
 * class Sporter extends {
 *   override val counter = 5
 * }with Person10
      
**/这样初始化后sporter的counterArray的长度为5
class Person10{
  val counter=3
  val counterArray =new Array[Int](counter)
}

class Sporter extends {
  override val counter = 5
}with Person10

//判断两个对象是否相同的方法
class Programmer(val name:String,val salary:Double){
  final override def equals(other:Any)={
    val that = other.asInstanceOf[Programmer]
    if(that==null)false
    else name == that.name&&salary==that.salary
  }
  /**
   * 1.hashCode()方法存在的主要目的就是提高效率。
     * 2.在集合中判断两个对象相等的条件，其实无论是往集合中存数据，
     * 还是从集合中取数据，包括如果控制唯一性等，都是用这个条件判断的，条件如下：
   * 首先判断两个对象的hashCode是否相等，如果不相等，就认为这两个对象不相等，就完成了。
   * 如果相等，才会判断两个对象的equals()是否相等，如果不相等，就认为这两个对象不相等，
   * 如果相等，那就认为这两个对象相等。
               
   * 所以说重写equals时必须重写hashcode，这是良好的习惯
   */
  final override def hashCode=name.hashCode()*5+salary.hashCode()*9
  
}

//object OverrideField {
//  def main(args: Array[String]): Unit = {
//    val s = new Sporter
//    println(s.counterArray.length)
//  }
//}
//第二种写法，不用写main函数
object OverrideField extends App{
    val s = new Sporter
    println(s.counterArray.length)
}

 

 注：对于无序表寻找是否有相同的对象时，使用hashcode可以大大提高速度。equal的比较通常比较耗资源，可以先比较hashcode后，确认hashcode相同时再用equal比较。

hashcode相同，equal不一定相同；equal相同的hashcode一定相同。

 

类的提取器：（中）

package com.dtspark.scala.basics
/**
 * 类的提取器
 * 注解要搞懂下面两个
 * @transient 注解将字段标记为瞬态的
 * @volatile 注解标记为易失的
 *
 * 自己编写的注解要继承annotation.Annotation
 */
case class Person1(name:String ,age:Int)
 
class DTCoder(val name:String ,val salary:Int)
object DTCoder{
  //复写了其apply和unapply方法
  def apply(name:String,salary:Int)={
    println("DTCoder apply method invoked!!!")
    new DTCoder(name,salary)
  }
//  方法1 (可使一个字符串转换成一个对象)
//  def unapply(information:String)={
//    //根据空格区分参数
//    println("DTCoder unapply method invoked!!!")
//    Some((information.substring(0 , information.indexOf(" ")),information.substring(information.indexOf(" ")+1)))
//  }
//方法二
  def unapply(information:DTCoder)={
    //根据空格区分参数
    println("DTCoder unapply method invoked!!!")
    Some((information.name,information.salary))
  }
}
 
object HelloExtractor {
  def main(args: Array[String]): Unit = {
    val person=Person1("Spark",12)//调用apply的工厂构造方法，构造出类的实例
    //= val person =Person1.apply("Spark",12)
    val Person1(name,age)=person//调用Person1的unapply的方法把person实例中的name和age提取出来
    println(person.name+" : "+person.age)//实现了name和age的赋值。
     
    person match{ //val Person1(name,age)=person=match这个过程
      case Person1(name,age)=>println(name+" : "+age)
    }
    //针对unapply方法一
    //val DTCoder(dtname,salary) = "Spark 16000000"
     
    //针对unapply方法二
    val coder = DTCoder("Spark",2999999)
    val DTCoder(dtname,salary)=coder
  }
}

 

 

 类的伴生对象:（高）

添加类的内容：

class Marker ( color:String)
class Marker (val color:String)
class Marker (var color:String)

 

 

这两种申明是有差的，第二种和第三种申明都可以通过Marker的对象+"."直接调用（相当于这个属性是静态的），而第一种申明不行

class Marker private (val color:String) {

  println("创建" + this)
  
  override def toString(): String = "颜色标记："+ color
  
}

 

private写在类名和参数中间表示对主构造函数的私有化，这时是不能new出对象的（除非有伴生对象object或者有重构this构造函数）

def main(args: Array[String]) { 
       new Marker("black")//报错
}

 

 

第一种解决方案：

添加object后，同时要有apply方法，否则还是报错（伴生对象是不带参数的，但是apply方法需要与原类相同的参数）

由于有apply方法的存在，创建新对象时，不需要用new关键字，

用object初始化时，他会直接初始化object中存在的所有变量。

object zcb01 {
    def main(args: Array[String]) { 
         Marker("white") //直接对象名进行初始化
    }

}
 class Marker (val color:String) {

  println("创建" + this)
  
  override def toString(): String = "颜色标记："+ color
  
}


object Marker{
  
    private val markers: Map[String, Marker] = Map(
      "red" -> new Marker("red"),
      "blue" -> new Marker("blue"),
      "green" -> new Marker("green")
    )
    private val m = Set(new Marker("black"))
    def apply(color:String) = {
      if(markers.contains(color)) markers(color) else null
      println("我输入的颜色："+color)
    }

}

 

 

结果：(先将object中的元素初始化，然后再调用apply方法初始化当前对象)

创建颜色标记：red
创建颜色标记：blue
创建颜色标记：green
创建颜色标记：black
我输入的颜色：white

 

第二种解决方案：

重构构造器（创建对象时必须用new，因为object（apply方法）不支持除主构造以外的任何重载构造方式）

object zcb01 {
    def main(args: Array[String]) { 
          new Marker("white",4)
    }

}
 class Marker private (val color:String) {//主构造的形式与类名后面的形式相同

  println("创建" + this)
  var a=1;

  def this(color:String,a:Int){
    this(color)//必须先调用主构造器
    this.a=a;
  }
  
  override def toString(): String = "颜色标记："+ color
  
}