本章节中，注释中有详细说明(注释是重点)
1、java种的动态绑定机制(多态)
public class Test_java {
public static void main(String[] args) {
//动态绑定机制
//成员方法在执行过程中，jvm会将方法和当前调用对象的实际内存绑定
// (调用方法时：都会先找自己成员方法，找不到在从父类中找)
AAA a = new BBB();
System.out.println(a.getResult()); // 40
// 属性没有动态绑定机制,AAA中(return i+10;) = (return this.i+10;) ,省略this
// 又因为属性没有动态绑定机制，所以this.i 就是AAA中的i
AAA aa = new CCC();
System.out.println(aa.getResult()); // 20
// 成员方法均有动态绑定机制，(return getI()+10;)中的getI(),是DDD中的getI()方法，返回的也是DDD中的i
AAA aaa = new DDD();
System.out.println(aaa.getResult1()); // 30
}
}
class AAA{
public int i = 10;
public int getResult(){
return i+10;
}
public int getResult1(){
return getI()+10;
}
public int getI(){
return i;
}
}
class BBB extends AAA{
public int i = 20;
public int getResult(){
return i+20;
}
}
class CCC extends AAA{
public int i = 20;
}
class DDD extends AAA{
public int i = 20;
public int getI(){
return i;
}
}
2、继承
object ClassDemo7 {
def main(args: Array[String]): Unit = {
val dog = new dog()
dog.test //抽象类中的抽象方法实现了
println(dog.name) // petter
// scala中dog.sex 其实底层是调用sex方法（getSex方法）
// 所以scala的属性也同样遵寻动态绑定机制
println(dog.sex) // women
// scala中的成员方法也要遵循 动态绑定机制
val animal:Animal = new dog() //多态
animal.test1() // 这是dog中的test1
}
}
abstract class Animal{
//抽象属性：方法只有声明，没有实现,不用abstract关键字
//抽象属性在编译的class文件，不产生属性，而是一个抽象的(abstract)getter方法
var name : String
val sex : String = "man"
//抽象方法：方法只有声明，没有实现,不用abstract关键字
def test()
def test1(): Unit ={
print("这是Animal中的test1")
}
}
class dog extends Animal{
// 重写之后父类还是不存在属性，只有一个抽象的(abstract)getter方法
// 子类种有属性，并且重写抽象的(abstract)getter方法
var name: String = "petter"
// 属性可以被重写，但是不能重写父类var修饰的变量
override val sex: String = "woman"
def test: Unit = {
println("抽象类中的抽象方法实现了")
}
override def test1: Unit ={
print("这是dog中的test1")
}
}
子父类构造方法参数
package com.bfd.chap06
object ConstruMethod6_1 {
def main(args: Array[String]): Unit = {
val user:User6 = new User6()
/*结果：
这是父类的主构造方法
这是子类的主构造函数
这是子类辅助构造方法
*/
}
}
class Person6(s6:String){
println("这是父类的主构造方法")
}
//若父类是无参构造，会直接调用；
//若是有参构造，必须显示申明
class User6(s:String) extends Person6("yyyy"){
println("这是子类的主构造函数")
def this()={
// this要放在第一行
this("xxx")
println("这是子类辅助构造方法")
}
}
构造函数参数作用域
object ConstruMethod6_2 {
def main(args: Array[String]): Unit = {
//作用域研究
val person6:Person6_0 = new Person6_0("wangwu")
//println(person6.s6) //报错,没有用var/val修饰，作用域只能在类体/构造方法体内部
val person6_1:Person6_1 = new Person6_1("zhangsan")
println(person6_1.name) // zhangsan 赋值给属性，可以调用
val person6_2:Person6_2 = new Person6_2("lisi")
println(person6_2.s6_2) // lisi 用var/val修饰，作用域扩大为类体/构造方法体外部也可以用
}
}
class Person6_0(s6:String){
}
// scala中构造函数的作用域是整个类体/构造方法体
// java仅是在构造方法体内
class Person6_1(s6_1:String){
val name = s6_1
}
//scala 对构造函数参数赋值给属性的简化
//使用var/val修饰构造函数参数时,构造函数参数作用域扩大至方法外
class Person6_2(val s6_2:String){
}
3、特质
1）基本声明
- 单个特质(extends 特质名)
class TraitDemo8 extends TestTrait1 {
}
trait TestTrait1{
}
- 多个特质(先用extends,之后用with)
class TraitDemo8 extends TestTrait1 with TestTrait2 with TestTrait3 {
}
trait TestTrait1{
}
trait TestTrait2{
}
trait TestTrait3{
}
- 继承加特质(父类必须用extends,之后特质用with（混入特质）)
class TraitDemo8 extends TestFather with TestTrait1 with TestTrait2 {
}
trait TestTrait1{
}
trait TestTrait2{
}
trait TestTrait3{
}
class TestFather{
}
2）基本使用、与java接口的比较
object TraitDmo9 {
def main(args: Array[String]): Unit = {
//java中接口无法直接创建对象
//接口中只能有抽象方法(新版java中可以存在实现好的方法)
//scala中特质也无法直接创建对象
//new TestTrait4() //报错
//特质中可以有抽象方法、实现好的方法
val clazz: TestClass = new TestClass() //TestTrait4的特质体中，test方法外
clazz.test() // 结果:TestTrait4中的test方法
println(clazz.name) //zhangsan 直接获取特质中的变量
println(clazz.sex) //woman 获取TestClass修改后的变量
clazz.test1 // TestClass中test1实现方法
}
}
trait TestTrait4{
println("TestTrait4的特质体中，test方法外")
var name = "zhangsan"
val sex = "man"
def test(): Unit ={
println("TestTrait4中的test方法")
}
//特质中的抽象方法定义，不需要abstract
def test1
}
class TestClass extends TestTrait4 {
//重写特质中的方法、变量，需要override关键字
override val sex :String = "woman"
def test1: Unit = {
println("TestClass中test1实现方法")
}
}
- scala中特质也无法直接创建对象
- 特质中可以有抽象方法、实现好的方法
- 对象. 就可以获取特质中的变量
- 对象. 获取TestClass修改后的变量
- 特质中的抽象方法定义，不需要abstract
3）父类和特质执行顺序
object TraitDemo10 {
def main(args: Array[String]): Unit = {
new User10()
/*
trait code ...
父类 code ...
子类 code ...
*/
}
}
//父类和特质没有关系，只和混入的当前类有关系
//所以，在调用时，父类会先执行(父类也会先执行自己的特质)
//如果父类中混入了与子类相同的特质，那么相同特质中的代码只执行一遍
trait TestTrait5{
println("trait code ...")
}
class Person10 extends TestTrait5{
println("父类 code ...")
}
class User10 extends Person10 with TestTrait5{
println("子类 code ...")
}
- 父类和特质没有关系，只和混入的当前类有关系
- 所以，在调用时，父类会先执行(父类也会先执行自己的特质)
- 如果父类中混入了与子类相同的特质，那么相同特质中的代码只执行一遍
4）多特质执行顺序
object TraitDemo11 {
def main(args: Array[String]): Unit = {
val mysql: Mysql = new Mysql()
mysql.inster()
}
}
trait Operate{
println("Operate ...")
def inster(): Unit ={
println("插入数据")
}
}
trait DB extends Operate {
println("DB ...")
override def inster(): Unit ={
println("向数据库")
super.inster()
}
}
trait File extends Operate {
println("File ...")
override def inster(): Unit ={
println("向文件")
super.inster()
//super[Operate].inster()
}
}
// 多特质混入时，代码执行顺序从左到右，如果有父特质,会优先执行
// 对特质混入时，方法会从右向左执行
// 在特质中的super关键字不是指父特质，而是上一级特质(File的上一级特质时DB)
// 如果希望super指向的父特质，需要：super[父特质名] super[Operate].inster()
// java中的接口可以直接当作特质用with Serializable
class Mysql extends DB with File with Serializable{
/*
结果：
Operate ...
DB ...
File ...
向文件
向数据库
插入数据*/
}
- 多特质混入时，代码执行顺序从左到右，如果有父特质,会优先执行
- 对特质混入时，方法会从右向左执行
- 在特质中的super关键字不是指父特质，而是上一级特质(File的上一级特质时DB)
- 如果希望super指向的父特质，需要：super[父特质名] super[Operate].inster()
- java中的接口可以直接当作特质用 例：with Serializable
5、scala特质的动态混入
(在new对象时,直接with特质)
object TraitDemo12 {
def main(args: Array[String]): Unit = {
val mysql12: Mysql12 with Operate12 = new Mysql12() with Operate12
mysql12.inster() //插入数据
}
}
trait Operate12{
def inster(): Unit ={
println("插入数据")
}
}
class Mysql12 {
}
6、限制特质的作用范围
// 特质可以继承类，并调用类中方法
trait Operate13 extends Exception{
def inster(): Unit ={
println("插入数据")
this.getMessage
}
}
class Mysql13 {
}
// 特质可以继承类，并调用类中方法
trait Operate13_1 {
this:Exception=>
def inster(): Unit ={
println("插入数据")
this.getMessage
}
}
//如果想混入限制了作用范围的特质，必须要满足它需要的环境
class Mysql13_1 extends Exception with Operate13_1{
}
如果想混入限制了作用范围的特质，必须要满足它需要的环境
