跟我一起学“仓颉”编程语言—类的定义和封装

目录

一、类的定义

二、封装

三、小结

---

面向对象编程（OOP）是一种以对象为核心的编程方式，它包含了两个很重要的概念-类和对象。类是某一事物的抽象描述，而对象是类的具体实例。比如：现实生活中，马路上跑的车辆，这些车辆，就是类，而当我们具体到某一辆车上，是问界M9呢，还是尊界S800，这些具体的车，就是对象。在比如：马路上来往的行人，这些行人就是类，而具体到某一个人上，园区门口的赵大爷，赵大爷，就是对象。

一、类的定义

package Study

class Car {
    let carName: String
    let carType: String
    var carPrice: Float64

    // 构造函数
    init(carName: String, carType: String, carPrice:Float64) {
        this.carName = carName
        this.carType = carType
        this.carPrice = carPrice
    }
}

main () {
    let car = Car("问界M9","纯电", 31.99)
    println(car.carName)
    println(car.carType)
    println(car.carPrice)
}

注意：和结构体一样，类也必须定义在仓颉文件的顶层，同时，类里也分为实例成员和静态成员，类的构造函数也分为普通构造函数和主构造函数（主构造函数只能有一个）,因为这些性质与结构体相同，因此这里就不在做过多介绍，不了解结构体友友们，可以参考这篇文章跟我一起学“仓颉”编程语言—结构体。

下面，给大家介绍类与结构体的区别。类与结构体的区别：

• 类是引用类型、结构体是值类型（具体解释参考“结构体”那片文章）；
• 类具有封装、继承、多态的三大特性（后面给大家详细介绍），而结构体不能继承，
• 类及其成员支持所有访问控制，而结构体支持所有访问控制但是结构体成员不支持protected（被保护的）

二、封装

在说封装之前，可以先看看下列代码

package Study

class Car {
    // 主构造函数
    Car(let carName: String, let carType: String, var carPrice: Float64) {}
}

main () {
    let car = Car("byd","纯电", 31.99)
    car.carPrice = 0.0
    println(car.carPrice)
}

这段代码，定义了一个Car类，在初始化时，“byd”的价格为31.99，但是在后续使用的时候，将它的价格修改成了0，这种修改是合法却不太合理的修改，因此，在类外直接使用修改成员变量的操作不是安全的操作。为此，在面向对象编程中，使用封装可以解决此类问题。在使用封装的时候，要结合访问控制一起使用，因此不了解访问控制的友友，可以移步到这篇文章—跟我一起学“仓颉”编程语言—包管理，了解清楚访问控制后，在接着往下看。

package Study

class Car {
    // 主构造函数
    public Car(private var _carName: String, private var _carType: String, private var _carPrice: Float64) {
        if (this._carPrice > 0.0) {
            this._carPrice = _carPrice
        } else {
            println("汽车的价格非法输入")
        }
    }

    /*
    * 被private修饰的成员变量，必须使用getter或setter
    */
    mut prop carName: String {
        get () {
            _carName
        }
        set (_carName) {
            this._carName = _carName
        }
    }

    mut prop carType: String {
        get () {
            _carType
        }
        set (_carType) {
            this._carType = _carType
        }
    }

    mut prop carPrice: Float64 {
        get () {
            _carPrice
        }
        set (_carPrice) {
            if (_carPrice > 0.0) {
                this._carPrice = _carPrice
            } else {
                println("汽车的价格非法输入")
            }
        }
    }
}

main () {
    let car1 = Car("byd","纯电", 0.0)
    println(car1.carName)
    println(car1.carType)
    println(car1.carPrice)

    let car2 = Car("问界","纯电", 1.0)
    println(car2.carName)
    println(car2.carType)
    println(car2.carPrice)
}

注意：prop修饰符，用于定义成员属性，mut修饰符修饰的成员属性，既可以读取，也可以被赋值，且必须包含get和set方法，没有被mut修饰的成员属性，只可以读取，不能被赋值。

package Study

class Car {
    // 主构造函数
    public Car(private var _carName: String, private var _carType: String, private var _carPrice: Float64, private var _carCount: Int64) {
        if (this._carPrice > 0.0) {
            this._carPrice = _carPrice
        } else {
            println("汽车的价格非法输入")
        }
        if (this._carCount > 0) {
            this._carCount = _carCount
        } else {
            println("汽车的销售量非法输入")
        }
    }

    /*
    * 被private修饰的成员变量，必须使用getter或setter
    */
    mut prop carName: String {
        get () {
            _carName
        }
        set (_carName) {
            this._carName = _carName
        }
    }

    mut prop carType: String {
        get () {
            _carType
        }
        set (_carType) {
            this._carType = _carType
        }
    }

    mut prop carPrice: Float64 {
        get () {
            _carPrice
        }
        set (_carPrice) {
            if (_carPrice > 0.0) {
                this._carPrice = _carPrice
            } else {
                println("汽车的价格非法输入")
            }
        }
    }

    mut prop carCount: Int64 {
        get () {
            _carCount
        }
        set (_carCount) {
            if (this._carCount > 0) {
                this._carCount = _carCount
            } else {
                println("汽车的销售量非法输入")
            }
        }
    }

    /*
    * 类里面的函数不用mut修饰符就可以进行修改值
    */
    func getSale() {
        this._carPrice = this._carPrice * Float64(this._carCount)
        return this._carPrice
    }
}

main () {
    let car = Car("byd","纯电", 1.0, 10)
    println(car.carName)
    println(car.carType)
    println(car.carPrice)
    println(car.getSale())
}

三、小结

本章为大家详细的介绍了仓颉编程语言中类的定义和封装的内容，下一章，为大家带来继承的内容。最后，创作不易，如果大家觉得我的文章对学习仓颉服务端开发有帮助的话，就动动小手，点个免费的赞吧！收到的赞越多，我的创作动力也会越大哦，谢谢大家🌹🌹🌹！！！