Scala trait 和 Java 的interface 动态混入

Scala trait 和 Java 的interface

1 Java的interface（接口）

• Java接口中的属性都是常量，通过接口名.属性进行调用.

• Java接口中的方法必须全部都是抽象的

• Java接口可以同时继承多个父接口interface A extends B,C,D... 其中BCD都接口,但是接口不能继承类

  • //JAVA中的一个接口可以继承多个父接口
    public interface TestInterface extends Serializable, DeserializationChecker {
    
        //接口中的属性都是常量
        String NAME = "GOOD MAN";
        //Java接口中的抽象方法,定义方法名、参数、返回值类型
        void  say(String name);
    }
    

• Java中的class可以在继承父类的同时实现多个父接口,但是一个class只能有一个父类（超类、基类）

  • class A extends Class implements B,C,D....

  • class Demo extends BBBB implements TestInterface, Serializable{
    
        public void say(String name) {
            System.out.println(TestInterface.NAME + name);
        }
      	
        //必须实现所有的抽象方法
        public static void main(String[] args) {
            new Demo().say("haMan");
        }
    
        public void check(Method method, ObjectStreamClass objectStreamClass, int i, int i1) {
    
        }
    
        public void checkProxyClass(Method method, String[] strings, int i, int i1) {
    
        }
    }
    
    class BBBB {}
    

2 Scala中的trait（特质）

scala中的特质与Java的interface类似

• scala trait中的属性、方法可以是抽象的，但是也可以是普通的
• scala 的trait可以同时继承一个父类，可以继承多个父特质，Java中的所有的接口都可以当作特质使用
• scala的class可以同时继承一个父类，而且可以同时继承多个特质，通过extends with with进行连接
• class继承trait后，必须重写所有的抽象方法、属性，通过override 关键字

package com.shufang.traits

class G1 {}

class G2 {}

trait G4 {
  //
  var name: String
  var id: Int = 1

  def say()

  def say(name: String) {
    print(name)
  }
}

//特质同时继承父类、父特质
trait G5 extends G1 with G4

//类同时继承父类、父特质
class G3 extends G1 with G4 with G5 {
  //重写所有抽象的成员，包括重写属性、方法
  override var name: String = _

  override def say(): Unit = ???
}

3 scala之动态混入（特质）继承特质的方式

3.1 创建类的时候继承trait

class A extends ParentClass with Trait01 with Trait02 ....

3.2 创建对象的时候继承trait(动态混入)

动态混入可以不影响原继承关系的同时对该类的功能进行动态的扩展，与原始继承进行解耦。

object DongtaiHunruTrait {
  def main(args: Array[String]): Unit = {
    
    //动态混入特质的功能、实现特质的方法
    val kk = new KK() with OO {
      //重写抽象方法
      override def say: Unit = {
        println("hello scala")
      }
    }
	 //调用特质继承过来的方法
    kk.say
  }
}

trait OO {
  def say()
}

class KK {}