面向对象
Z1h 语言支持面向对象, 并且支持多继承
声明
声明一个类有两种语言风格:
// map风格
class People {
name: 'zwr',
hi: e => print(`Hello, i am ${this.name}, you are ${e}`),
}
// 表达式风格
class Student {
name = 'zwr'
hi = e => print(`Hello, i am ${this.name}, you are ${e}`)
func bye(from) {
print(`Goodbye from ${from} to ${this.name}`)
}
}
请注意, 两种声明风格不能混用
初始化实例
以上文创建的两个类为例
// go风格
p = new(People)
// python风格
s = Student()
类变量
// 风格1
p.name = 'zq'
// 风格2
s['name'] = 'zq'
类函数
p.hi('tester')
构造函数
在声明类变量的时候, 声明init函数即创建构造函数, 并且在继承关系中, 构造函数会从父类开始被调用, 顺序遵循 MRO 链的顺序.
建议通过map作为构造函数的参数
class A {
init = e => print(`通过参数${e}构造了一个A对象`)
}
class B (A) {
init: e => print(`通过参数${e}构造了一个B对象`),
}
A(123)
new(B, 456)
勾子函数
可以通过声明 setter 和 getter 函数来创建写/读的钩子, 在不需要经过勾子的地方, 需要改为调用 Store 和 Load 函数
// setter使用函数示例
class People {
age = 24
setter = (k, v) => {
if (k == 'age') {
this.Store(k, this.age + v)
} else {
panic('No key named ' + k)
}
}
}
p = new(People)
p.age = 100
print(p.age) // 124
p.name = 'zwr' // will panic
// getter使用函数示例
class Student {
age = 24
getter = (k, v) => {
if (k == 'age') {
var [age, has] = this.Load(k)
if (has) {
return age + ' Years'
} else {
return 'No age'
}
} else {
panic('Cannot take ' + k)
}
}
}
s = new(Student)
print(s.age)
del(s, 'age')
print(s.age)
print(s.name) // panic
请注意, Load函数有两个返回值, 一个是获取到的真实的值, 第二个是true/false, 表示是否存在这个key
如果直接在setter或getter内使用this.xxx, 大概率会导致死循环, 请注意用Store和Load替换
继承的情况下, 父类的setter和getter将不生效
继承
单继承
class People {
name = 'zwr'
}
class Student (People) {}
print(Student().name)
多继承
class AAA {
name = 'zwr'
}
class BBB {
age = 26
}
class CCC(AAA, BBB) {
hi = e => print(`My name is ${this.name}, age is ${this.age}`)
}
var c = CCC()
c.hi()
super
使用 this.super() 可以获取父类的引用, 以获取父类函数
class AAA {
hi = e=>print('Hi, i am AAA')
}
class BBB(AAA) {
hi = e=> {
print('Hi, i am BBB')
this.super().hi()
}
}
var b = BBB()
b.hi()
MRO
在多继承时, 免不了会出现优先级的冲突问题
使用 Object.mro(sth) 可以获得对象的MRO链
class D() {}
class E() {}
class F() {}
class B(D, E) {}
class C(D, F) {}
class A(B, C) {}
Object.mro(A).map(e => e.Type())
// 可以看到, A类的MRO链是 [A, B, C, D, E, F, Object]
判断继承关系
class AAA {}
class BBB(AAA) {}
class CCC() {}
class DDD(BBB, CCC) {}
Object.isInstanceOf(BBB(), AAA) // true
Object.isInstanceOf(CCC(), AAA) // false
Object.isInstanceOf(DDD(), AAA) // true
BBB().InstanceOf(AAA) // true
CCC().InstanceOf(AAA) // false
DDD().InstanceOf(AAA) // true
强类型的类或对象
类或对象调用 SetStronglyTyped 函数, 类变量将不可以被修改类型, 或添加类变量
class People {age: 0}
People.SetStronglyTyped()
p1 = new(People)
p1.age = 20 // ok
p1.age = 'zwr' // panic
class Student {name = 'zwr'}
s1 = Student()
s2 = Student()
s1.SetStronglyTyped()
s1.name = 123 // panic
s2.name = 123 // ok
如果一个类是强类型的, 那么其衍生出来的子类和对象, 也都会是强类型的
如果需要取消强类型限制, 可以调用SetStronglyTyped(false)
协程(线程)安全的类或对象
类或对象调用 SetThreadSafe 函数, 类或变量将保证协程(线程)安全
class People {age: 0}
People.SetThreadSafe()
p = new(People)
print('Step 1:', p.age)
p.Lock()
print('Step 2:', p.age) // block
// wait
p.Unlock() // will print
如果一个类是协程安全的, 那么其衍生出来的子类和对象, 也都会是协程安全的
如果需要取消协程安全, 可以调用SetThreadSafe(false)
对象包含Lock、Unlock、RLock、RUnlock方法, 分别用于限制读和写操作, 可以手动调用函数以测试