质的动态混入
1.创建对象时混入 trait,而无需使类混入该 trait
2.如果混入的 trait 中有未实现的方法,则需要实现
代码演示:
trait PersonTrait {
//(1)特质可以同时拥有抽象方法和具体方法
// 声明属性
var name: String = _
// 抽象属性
var age: Int
// 声明方法
def eat(): Unit = {
println("eat")
}
// 抽象方法
def say(): Unit
}
trait SexTrait {
var sex: String
}
//(2)一个类可以实现/继承多个特质
//(3)所有的 Java 接口都可以当做 Scala 特质使用
class Teacher extends PersonTrait with java.io.Serializable {
override def say(): Unit = {
println("say")
}
override var age: Int = _
}
object TestTrait {
def main(args: Array[String]): Unit = {
val teacher = new Teacher
teacher.say()
teacher.eat()
//(4)动态混入:可灵活的扩展类的功能
val t2 = new Teacher with SexTrait {
override var sex: String = "男"
}
//调用混入 trait 的属性
println(t2.sex)
}
}
抽象类
在 Scala 中, 使用 abstract 修饰的类称为抽象类. 在抽象类中可以定义属性、未实现的方法(抽象方法)和具体实现的方法。 含有抽象方法的类就是抽象类
- 抽象类中的属性
- 抽象方法
- 具体实现的方法
- 类的单继承
示例:
/*
* abstract 修饰的类是一个抽象类
* */
abstract class Animal {
println("Animal's constructor ....")
// 定义一个 name 属性
val name: String = "animal"
// 没有任何实现的方法
def sleep()
// 带有具体的实现的方法
def eat(f: String): Unit = {
println(s"$f")
}
}
抽象类的继承和重写
- 如果父类为抽象类,那么子类要么也是抽象类,要么就需要重写父类中的所有的抽象方法和抽象的成员变量
- 重写非抽象方法需要用 override 修饰,重写抽象方法则可以不加 override。
- 子类中调用父类的方法使用 super 关键字,在子类重写了父类的方法后,如果不加super,直接写方法名调用的就是子类重写后的,如果加了,调用的还是父类的
- 子类对抽象属性进行实现,父类抽象属性可以用 var 修饰;子类对非抽象属性重写,父类非抽象属性只支持 val 类型,而不支持 var(var修饰具体方法和变量不好重写)
因为 var 修饰的为可变变量,子类继承之后就可以直接使用,没有必要重写
样例类
使用case修饰的类就是样例类(封装数据,模式匹配)
- 构造器中的参数默认是val修饰的[成员,赋值1次]
- 样例类会自动创建伴生对象, 同时在里面实现;的apply和unapply方法 ,创建对象的时候不用new
- 很好的支持匹配模式
- 默认实现了自己的toString , hashCode , copy , equals,序列化方法
定义一个样例类:
case class Person(var name:String , var age:Int){}
//如果类中没有别的需要定义的,可以不写大括号
反编译之后的结果:
//decompiled from Person$.class
package com.doit.day01.day02;
import scala.Option;
import scala.Serializable;
import scala.Some;
import scala.Tuple2;
import scala.None.;
import scala.runtime.AbstractFunction2;
import scala.runtime.BoxesRunTime;
public final class Person$ extends AbstractFunction2 implements Serializable {
public static Person$ MODULE$;
static {
new Person$();
}
public final String toString() {
return "Person";
}
public Person apply(final String name, final int age) {
return new Person(name, age);
}
public Option unapply(final Person x$0) {
return (Option)(x$0 == null ? .MODULE$ : new Some(new Tuple2(x$0.name(), BoxesRunTime.boxToInteger(x$0.age()))));
}
private Object readResolve() {
return MODULE$;
}
// $FF: synthetic method
// $FF: bridge method
public Object apply(final Object v1, final Object v2) {
return this.apply((String)v1, BoxesRunTime.unboxToInt(v2));
}
private Person$() {
MODULE$ = this;
}
}
//decompiled from Person.class
package com.doit.day01.day02;
import scala.Function1;
import scala.Option;
import scala.Product;
import scala.Serializable;
import scala.collection.Iterator;
import scala.reflect.ScalaSignature;
import scala.runtime.BoxesRunTime;
import scala.runtime.Statics;
import scala.runtime.ScalaRunTime.;
@ScalaSignature(
bytes = "\u0006\u0001\u0005Uc\u0001\u0002\u000e\u001c\u0001\u0012B\u0001\"\r\u0001\u0003\u0012\u0004%\tA\r\u0005\t}\u0001\u0011\t\u0019!C\u0001\u007f!AQ\t\u0001B\tB\u0003&1\u0007\u0003\u0005G\u0001\tE\r\u0011\"\u0001H\u0011!