Scala基础之抽象

2024-02-13 18:07:34

抽象类，方法，属性（不完整）

Scala将一个不完整的类称之为抽象类

abstract class Person {
}

Scala中一个方法只有声明而没有实现，那么是抽象方法

// 子类重写父类的抽象方法，直接补充完整即可
// 子类重写父类的完整方法，必须添加override关键字
// 开发时，推荐，只要重写，都添加override

abstract class User {
    def test(): Unit = {

    }
    def fun():Unit
}
class Child extends User {
    override def test(): Unit = {

    }
    override def fun():Unit = {

    }
}

Scala中如果一个属性只有声明没有初始化，那么是抽象属性

    abstract class User {
        // 抽象属性：只有声明，没有初始化
        // 编译时，不会在类中声明属性，而是会声明属性的set，get方法，并且是抽象的。
        var name:String
    }
    class Child extends User {
        // 属性：编译时，会在类中声明私有属性，同时提供属性的set，get方法，并且为公共的。
        var name:String = "zhangsan"
    }
}

        // 子类可以重写父类的抽象属性，补充完整即可
        // 子类可以重写父类的完整属性，那么必须要添加override关键字

    abstract class User {
        var name : String
        val age : Int = 10

        def test(): Unit = {
            //age = 30 // 对属性的赋值其实等同于调用属性的set方法
            println(age) // 对属性的方法其实等同于调用属性的get方法
        }
    }
    class Child extends User {
        var name : String = "zhangsan" // 重写
        override val age : Int = 20
    }


new Child().test //打印20，实例非静态变量在heap中，类加载后覆盖了所以20

子类如果继承抽象类，必须实现抽象方法或补全抽象属性，否则也必须声明为抽象的

abstract class Person {
    var name:String
}
class User extends Person {
    var name : String = "AsianHarden"
}

抽象类没有办法直接实例化，需要由子类继承后完成实例化操作

trait:由于scala消除了interface，引入了特征(trait)

// 将多个对象中相同的特征，从对象中剥离出来，形成独立的一个结构，称之为trait（特征）
// 如果一个对象符合这个特征，那么可以将这个特征加入到这个对象，这个加入的过程，称之为混入(extends)

// 如果一个类只有一个特征时，采用extends关键字进行混入
// 但是一个类如果有多个特征，这个时候，第一个特征采用extends，后续采用with

// 如果类存在父类的场合，并同时具备了某个特征，
// 需要使用extends关键字继承父类，使用with关键字来混入特征
    trait eat {
        def eat():Unit
    }
    trait Runnable {
        def run():Unit
    }
    class Person extends Object with Runnable {
        override def run(): Unit = {
            println("run...")
        }
    }
    class Dog extends Runnable {
        override def run(): Unit = {
            println("run...")
        }
    }

动态混入

// 动态混入，解耦合
        val user = new User() with Updateuser
        user.insertUser()
        user.updateUser()

    }
    trait Updateuser {
        def updateUser(): Unit = {
            println("update user...")
        }
    }
    class User {
        def insertUser(): Unit = {
            println("insert user...")

trait执行顺序问题

//    父类的特质 > 父类 > 特质1, 特质2 > 当前类
//　　特质1，特质2，由位置顺序决定
 new User()

    trait Test extends Test1{
        println("aaaa")
    }
    trait Test1 {
        println("dddd")
    }
    class Person{
        println("bbbb")
    }
    class User extends Person with Test with Test1 {
        println("cccc")
    }
//b-d-a-c

```
scala钻石问题
```

// scala采用了一种功能叠加的方式解决砖石问题
// super不是父特质的意思，是上一级（上一个）的意思
        new MySQL().operData()

    }
    trait Operator {
        def operData(): Unit = {
            println("操作数据")
        }
    }
    trait DB extends Operator{
        override def operData(): Unit = {
            print("向数据库中")
            super.operData()
        }
    }
    trait Log extends Operator {
        override def operData(): Unit = {
            print("向日志文件中")
            super[Operator].operData()
        }
    }
    class MySQL extends DB with Log {

    }

向日志文件中操作数据
operator与mysql是无关的，所以先显示向日志文件中

码农公寓

相关文章