scala 碎片内容

标签：set   日志   font   pre   super   length   ice   gen   构造   

object CaseClassDemo{
  def main(args: Array[String]): Unit = {

    //定义样例类
    //默认带有apply方法
    //构造函数的参数默认是public val修饰的
    case class Message(var sender: String, recipient:String, body:String)

    //创建一个样例类的对象
    val message1=Message("jerry","tom","hello")
    //    message1.sender="kate"
    println(message1.sender+" ,"+message1.recipient+" ,"+message1.body)

    //样例类的比较，基于值或者结构比较，而不是基于引用比较
    val message2=Message("jerry","tom","hello")
    println(message1==message2)

    //样例类的拷贝
    val message3=message1.copy()

    println(message1==message3)

    println(message3.sender+" ,"+message3.recipient+" ,"+message3.body)

    //不完全拷贝，对部分参数赋值
    val message4=message1.copy(sender = "hanmeimei")
    println(message4.sender+" ,"+message4.recipient+" ,"+message4.body)

  }

package com.utilcopy

class ConstructorDemo private (var b:Int) {

  var a:Int=0
  println("Constructor Study")

  //定义辅助构造函数
  //这个是public
  def this(a1:Int,b1:Int)={
    //首先需要调用主构造函数或者其他的辅助函数
    this(b1);
    this.a=a1;
  }

}
//定义一个带有参数的主构造函数


//类自带有无参的构造函数
//主构造函数执行类中定义的所有的语句
//主构造函数和辅助构造函数

object ConstructorDemoTest{
  def main(args: Array[String]): Unit = {

    //    val obj:ConstructorDemo=new ConstructorDemo()
    val obj:ConstructorDemo=new ConstructorDemo(10000,10000)
    println(obj.a)

  }
}

package com.utilcopy

class Methods {

  //def 方法名（参数列表）:返回类型=方法体
  //返回类型可以省，返回类型是递归方法的时候，一定要指明，其他情况，可以省

  def add1(x:Int,y:Int)=x+y;

  def add2(x:Int,y:Int):Int=x+y;

  add1(1,2);

  add2(x=1,y=2);

  add2(y=2,x=1);

  def add3(x:Int,y:Int)={
    x+y;
    println(x+y);
  }

  //带有参数类表的方法
  def addAndMultiply1(x:Int,y:Int,z:Int)=(x+y)*z
  def addAndMultiply2(x:Int,y:Int)(z:Int)=(x+y)*z
  def addAndMultiply3(x:Int)(y:Int)(z:Int)=(x+y)*z

  addAndMultiply3(3)(4)(5);

  //无参方法,没带小括号，调用的时候不能带小括号，如果带了小括号，调用的时候可以不带小括号
  def printInfo=println("I love scala");
  printInfo
  def printInfo1()=printInfo
  printInfo1

  //带有默认值参数的方法
  def printInfo2(str:String="Hello Scala")=println(str)
  printInfo2()
  def add(a:Int=1,b:Int,c:Int=3)=println("a="+a+", b="+b+", c="+c);
  add(1,2)
  add(b=2)
  add(1,2,3)

  //可变长参数的方法
  def add(a:Int*)={
    for(i <- a){
      println(i)
    }
  }

}

package com.utilcopy

class PersonS {

  //val修饰的属性，系统自动生成get方法
  //private final
  val id:String="1234"

  def getId():String={
    println("hahaha")
    this.id
  }


  //var修饰的属性，系统生成get和set方法
  //private
  var name:String=""
  //private var修饰的属性，系统生成private修饰的get和set方法
  //相当与类的私有字段
  private var gender:Int=0
  //private[this]系统不会生成get和set方法
  //只有当前对象可以访问该属性
  private[this] var age:Int=0

  //  def compare(obj:PersonS):Int={
  //    this.age-obj.age
  //  }

}

object  test{
  def main(args: Array[String]): Unit = {
    var per:PersonS=new PersonS()

    println(per.getId())

    per.name="张三"
    println(per.name)

  }
}

package com.utilcopy

//定义一个特质，带有抽象方法的特质
trait Iterator[A]{
  def hasNext:Boolean
  def next():A
}

//定义一个带有实现的特质
trait ConsoleLogger{

  def log(msg:String):Unit={
    println(msg)
  }

}

//定义一个类，实现特质
class IntIterator(to:Int) extends Iterator[Int] with ConsoleLogger {
  private var current=0;

  override def hasNext: Boolean =current < to;

  override def next(): Int = {
    if(hasNext){

      log("has next")

      val t=current;
      current+=1;
      t
    }else{
      0
    }
  }
}



object TraitTest {

  def main(args: Array[String]): Unit = {
    val iterator=new IntIterator(to=10)
    println(iterator.next())
    println(iterator.next())
    println(iterator.next())
    println(iterator.next())
    println(iterator.next())
  }
}

package com.utilcopy

trait Logger{
  def log(msg:String)
}

//子特质实现父特质里的抽象方法
trait ConsoleLogger extends Logger{

  override def log(msg: String): Unit = println(msg)

}

//给日志加上时间戳
trait TimestampLogger extends ConsoleLogger{
  override def log(msg: String): Unit = super.log(msg+s"${java.time.Instant.now()}$msg")
}

//如果日志过长，对日志进行阶段显示
trait ShortterLoger extends ConsoleLogger{
  val maxLength=15
  override def log(msg: String): Unit = super.log(
    if(msg.length<=maxLength) msg
    else s"${msg.substring(0,maxLength-3)}..."
  )
}

class Account{
  protected var balance:Double=0.0
}

class SavingAccount extends Account with ConsoleLogger {

  def withdraw(amount:Double):Unit={
    if(amount>balance){
      log(msg="Insufficient funds")
    }else{
      balance=balance-amount
    }
  }

}


//特质可以为类提供可以堆叠的改变
object TraitTest2  extends App {

  //  var acc1=new SavingAccount with ConsoleLogger with TimestampLogger with ShortterLoger
  //  var acc2=new SavingAccount with ConsoleLogger with ShortterLoger with TimestampLogger
  var acc1=new SavingAccount with ConsoleLogger
  acc1.withdraw(amount=100.0)

  var acc2=new SavingAccount with ConsoleLogger with TimestampLogger
  acc2.withdraw(100.0)

  var acc3=new SavingAccount with ConsoleLogger with ShortterLoger
  acc3.withdraw(100.0)

  //  acc1.withdraw(100.0)
  //  acc2.withdraw(100.0)
}

package com.utilcopy

trait Logger{

  def log(msg:String)

  def info(msg:String){
    log(msg="Info:"+msg)
  }

  def service(msg:String): Unit ={
    log(msg="service:"+msg)
  }

  def warn(msg:String): Unit ={
    log(msg="warn:"+msg)
  }

}

class Account{
  protected var balance:Double=0.0
}

class SavingAccount extends Account with Logger {
  override def log(msg: String): Unit = println(msg)
  def withdraw(amount:Double): Unit ={
    if(amount>balance) service(msg="Insufficent funds") else{
      balance=balance-amount
      info(s"you withdraw $amount")
    }
  }
}

object TraitTest3 extends App {

  val acc=new SavingAccount
  acc.withdraw(100.0)

}

scala 碎片内容

标签：set   日志   font   pre   super   length   ice   gen   构造   

原文地址：https://www.cnblogs.com/hotMemo/p/9975131.html