scala中Trait简单使用

trait Log {

  def log(message:String) = println("log:" + message)

}

/**
  * 为实例混入trait
  *
  */

trait Logs{
  def log(message:String){}
}

trait MyLog extends Logs {
  override def log(message: String): Unit = {
    println("log:" + message)
  }
}

class MixTraitUse(val name:String) extends Logs {

  def sayHello{
    println("hello " + name)
    log("sayHello method invoked!!")
  }

}

object MixTraitUseTest{

  def main(args: Array[String]): Unit = {
    val mix1 = new MixTraitUse("yxj")
    mix1.sayHello

    val mix2 = new MixTraitUse("yyy") with MyLog
    mix2.sayHello
  }

  

trait Handler {

  def handler(data: String) {}

}

trait DataValidTrait extends Handler {

  override def handler(data: String): Unit = {
    println("this is DataValidTrait handler invoked.")
    super.handler(data)
  }

}

trait SignatureTrait extends Handler {

  override def handler(data: String): Unit = {
    println("this is SignatureTrait handler invoked.")
    super.handler(data)
  }

}

class ChainPerson(name: String) extends SignatureTrait with DataValidTrait {

  def sayHello(data: String) {
    println("sayHello from " + name)
    handler(data)
  }
}

object TraitChainUse {

  def main(args: Array[String]): Unit = {
    val p1 = new ChainPerson("yxj")
    p1.sayHello("chanin data")

  }

}

  

trait Loger {
  println("loger constructor ..")
}

trait MyLoger extends Loger{
  println("MyLoger constructor...")
}

trait TimeLoger extends Loger{
  println("TimeLogers constructor...")
}

class TraitConstructor {
    println("trait constructor")
}

class SubTrait extends TraitConstructor with MyLog with TimeLoger {

  println("subtrait contructor...")

}

object tcT{

  def main(args: Array[String]): Unit = {
    val sub = new SubTrait

  }
}

  

class People(val name:String) extends Log {

  def makeFriends(p:People) ={
    println("hello, " + p.name + " i‘m " + name + ",i want to make friends with you ")
    log("makeFriends method invoked with parameter " + p.name)
  }

}

object TraitLoggerUse{

  def main(args: Array[String]): Unit = {
    val s1 = new People("yxj")
    val s2 = new People("wulanlan")

    s1.makeFriends(s2)

  }

}

  

trait HelloTrait{
  def sayHello(name:String)
}

/**
  * trait 中定义的field,继承的类,可以直接获取到使用
  *
  */
trait MakeTrait{
  val eyeNum:Int = 2
  def makeFriends(p:Person)
}

class Person(val name:String) extends HelloTrait with MakeTrait {

  def sayHello(otherName:String) = {
      println("hello " +otherName + ", im " + name + ", i have " + eyeNum + " eyes.")
  }

  def makeFriends(p: Person): Unit = {
    println("hello " + p.name + ",i‘m " + name + ",i want to make friends with you.")
  }

}

object useTrait{

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

    val p1 = new Person("yxj")
    val p2 = new Person("wulanlan")

    p1.sayHello("yy")

    p2.sayHello("zz")

    p1.makeFriends(p2)

  }

}

  

原文地址:https://www.cnblogs.com/yxj0728/p/9281820.html

时间: 2024-08-01 19:37:08

scala中Trait简单使用的相关文章

scala中trait学习笔记

scala中提供的trait(特质)和Java中的Interface有很多相似之处.都可以持有方法的声明和属性,但是trait还有比interface强大的多的其他用法. 1. trait可以带有方法实现: 2. trait与interface一样,可以互相继承.但是trait可以继承自某个类,但是这种特质只能够混入父类的子类中,不能随意混入: 3. trait中可以在运行时动态调用方法. 下面举一个trait使用的例子. 首先定义一个虚类IntQueue和特质Logger abstract c

【Scala篇】--Scala中Trait、模式匹配、样例类、Actor模型

一.前述 Scala Trait(特征) 相当于 Java 的接口,实际上它比接口还功能强大. 模式匹配机制相当于java中的switch-case. 使用了case关键字的类定义就是样例类(case classes),样例类是种特殊的类. Actor相当于Java中的多线程. 二.具体阐述 trait特性 1.概念理解 Scala Trait(特征) 相当于 Java 的接口,实际上它比接口还功能强大. 与接口不同的是,它还可以定义属性和方法的实现. 一般情况下Scala的类可以继承多个Tra

scala中函数简单使用记录

object funcHighLevel { def main(args: Array[String]): Unit = { // 创建一个匿名函数 val sayFunc = (name: String) => println("hello ," + name) // 定义一个方法传入一个函数 def greeting(func: (String) => Unit, names: String) { func(names) } // 在定义一个 name,age是参数 v

scala中的trait

这里的trait字面意思是特质或者特征,这个词翻译成特征比较合适.它的意义和java,c#中接口很类似.但是trait支持部分实现,也就是说可以在scala的trait中可以实现部分方法. 下面我们以一个具体的例子来介绍下trait的使用. 我们的例子中定义了一个抽象类Aminal表示所有的动物,然后定义了两个trait Flyable和Swimable分别表示会飞和会游泳两种特征. 我们先看下Aminmal的实现: abstract class Animal { def walk(speed:

(转)Scala中协变(+)、逆变(-)、上界(<:)、下界(>:)简单介绍

看源码的时候看到: trait ExtensionId[T <: Extension] { 没见过这个符号啊<: Scala上界(<:)和下界(>:) 1) U >: T 这是类型下界的定义,也就是U必须是类型T的父类(或本身,自己也可以认为是自己的父类). 2) S <: T 这是类型上界的定义,也就是S必须是类型T的子类(或本身,自己也可以认为是自己的子类). 然后scala中的泛型符号是[T],而不是Java中的<T>. 对于一个带类型参数的类型,比如

scala 中List的简单使用

/** * scala 中List的使用 * */ object ListUse { def main(args: Array[String]): Unit = { def decorator(l:List[Int] , prefix:String){ if(l != Nil) { println(prefix + l.head) decorator(l.tail , prefix) } } // List 是不可变的列表 val list = List(1,2,3,4,5,6,7) decor

scala中的闭包简单使用

object Closure { /** * scala中的闭包 * 函数在变量不处于其有效作用域内,还能够对变量进行访问 * * @param args */ def main(args: Array[String]): Unit = { def getHelloFunc(msg:String) = (name:String) => println(msg + "," + name) val sayHello = getHelloFunc("hello")

scala中java并发编程

Runnable/Callable 线程(Thread) Executors/ExecutorService Future 线程安全问题 示例:搜索引擎 解决方案 Runnable/Callable Runnable只有一个没有返回值的方法 1 2 3 trait Runnable {   def run(): Unit } Callable的方法和run类似,只不过它有一个返回值 1 2 3 trait Callable[V] {   def call(): V } 线程 Scala的并发是建

Scala中 object 和 class的区别

object 在scala中没有静态方法和静态字段,所以在scala中可以用object来实现这些功能,直接用对象名调用的方法都是采用这种实现方式,例如Array.toString.对象的构造器在第一次使用的时候会被调用,如果一个对象从未被使用,那么他的构造器也不会被执行:对象本质上拥有类(scala中)的所有特性,除此之外,object还可以一扩展类以及一个或者多个特质:例如, abstract class ClassName(val parameter){} object Test exte