本地化吃喝玩乐平台网站可以做吗,品牌建设需打持久战,怎么为网站网页注册免费网址,做的很漂亮的网站一、定义
1、kotlin中使用关键字class 声明类,如果一个类没有类体#xff0c;也可以省略花括号#xff0c; 默认为public 类型的#xff1a;
// 这段代码定义了一个公开的、不可被继承的Test类
class Test{}
// 没有类体#xff0c;可以省略花括号
class Test
底层代码也可以省略花括号 默认为public 类型的
// 这段代码定义了一个公开的、不可被继承的Test类
class Test{}
// 没有类体可以省略花括号
class Test
底层代码class Test{} / class Test 底层编译成java代码 如下
// final: 这个关键字说明Test类是一个最终类意味着它不能被继承。
// 也就是说不允许有其他类继承自Test类以扩展其功能。
public final class Test {
}
2、类中定义的变量必须初始化
class Foo{val x:Int 1
}
二、构造函数
1、主构造函数
1在kotlin中一个类有一个主构造函数并且可以有一个或者多个次构造函数。注所有次构造函数必须调用主构造函数。
// 下边定义类的主构造函数且添加了2个Int类型的参数
class Test constructor(a: Int, b: Int) {
}
// 也可以省略constructor关键字如果主构造函数没有任何注解或可见性修饰符
class Test (a: Int, b: Int) {
}2主构造函数的参数也可以作为类的属性存在下边a 和 b 同时作为构造函数的参数和类的属性存在
// a和 b 都是类的属性
class Test constructor(val a: Int, var b: Int) {
}
// 也可以给参数使用默认值
class Test constructor(val a: Int 1, var b: Int 2) {
}
// 或者在类里边定义属性
class Test01 (a: Int, b: Int) {// 在类定义类属性此时a和b作为参数传进来var c: Int a // 定义类属性cvar d: Int b // 定义类属性dinit {println($c$d${cd})}
}fun main() {Test01(1, 2)
}
作为参数 在构造函数定义中a 和 b 接收从外界传入的具体值允许在创建 Test01 类的实例时初始化这些值。
作为属性val a: Int 表明 a 是一个只读属性final变量一旦在构造函数中初始化后其值就不能再改变。var b: Int 表明 b 是一个可变属性变量在类的实例创建后其值仍然可以被修改。
3类变量初始化时机
1、参数传递初始化类中变量。
2、使用定义的默认值初始化类变量。
3、如果不想第一时间初始化变量可以使用 lateinit 懒加载
class Test () {lateinit var a: Stringlateinit var b: String
}
注意事项
为什么Int类型不能使用lateinit 懒加载
原因如下对于基本数据类型如 Int、Double、Boolean 等它们不能为 null并且在声明时必须赋予一个初始值。由于基本类型不是引用类型它们不存在“未初始化”的状态——它们要么有一个具体的值要么在局部作用域内如果没有初始化就会导致编译错误。因此lateinit 机制不适用于基本数据类型因为基本类型总是有默认值如 Int 的默认值是 0且不能为 null。
4在类里边定义变量kotlin默认会为每个属性添加getter和setter当然你也可以显示的定义getter和setter
class Test (b:Int) {var a: Int b// 为a变量定义getter打印a变量时输出2getter优先级是最高的get() {return 2}set(value) {field value}init {println(a) // 2}
}fun main() {Test(1)
}
类中属性的引用跟方法引用一样
// 方法定义
fun main() {// 引用Foo类中的x属性val r Foo::x// 方式一调用Foo类中的x属性获取其值val r1 r.get(Foo(hello))println(r1 - $r1) // r1 - hello// 方式二通过实例化的对象foo来引用Foo类中的x属性val foo Foo(world)val r2 foo::xprintln(r2 - ${r2.get()}) // r2 - world
}
class Foo(x:String) {val x:String x
}
2、次构造函数
1创建
// 记住一点所有的次构造函数必须要调用主构造函数。
class Test (var name:String) {// 次构造函数的创建如下// 1在类里边添加constructor关键字// 2通过this()来调用主构造函数 Test()// 且this()参数必须和主构造函数的参数一致constructor(name:String,age:Int): this(name){}
}
三、类实例化
1、在kotlin中实例化类后会创建一个新的对象并且返回对象的引用在构造函数执行完毕后会返回一个指向新创建对象的引用这个引用可以被存储在一个变量中以便后续使用。
class Test (var name:String)fun main() {val user:Test Test(小王)// 通过user变量可以访问类中的属性、函数println(user.name) // 小王
}
2、类方法定义及调用
class Test(name: String) {// 定义info方法参数为String类型fun info(name: String) {// 就近原则所以输出 2println(名字为${name}) // 2}
}fun main() {val test Test(1)test.info(2)
}
在方法中如果想调用主构造函数参数需要使用 this. 的方式且主构造函数参数必须是属性。
class Test(var name: String) {fun info(name: String) {// this 就是Test 实例化的对象println(名字为${this.name}) // 1}
}fun main() {val test Test(1)test.info(2)
} 四、接口
1、定义
// Foo类 实现 FooInterface接口
class Foo(val x: String):FooInterface{// 重写接口中foo方法override fun foo() {TODO(Not yet implemented)}
}
// 定义接口
interface FooInterface {// 定义接口中的方法fun foo()
}
2、实现接口
接口的实现需要在实现类后边加上 : 后边写上接口类名即可
// Foo类实现 FooInterface接口
class Foo(val x: String):FooInterface{
}
注意事项
1接口的定义不需要添加关键字 class。 2实现类继承某个接口后边添加 : 然后填写接口名即可 class T( ): AInterface{ } 3重写接口中的方法在实现类中 需要添加 关键字 override
五、抽象类
1、定义
// 定义抽象类
abstract class FooAbstract {// 定义抽象类中的方法abstract fun foo()
}
2、抽象类中如果没定义abstract 关键字 那么该方法默认是不可被重写的如果需要重写必须加上关键字 open
// 定义抽象类
abstract class FooAbstract {// 定义抽象方法,可以被重写abstract fun gar()// 不可被重写的方法fun foo(){}// 可被重写的方法open fun bar(){}
}
3、类实现抽象类重写里边的方法
// Foo类 实现 FooAbstract抽象类
class Foo(val x: String):FooAbstract(){// 重写接口中foo方法override fun bar() {println(Foo:$x)}override fun gar() {println(Foo:$x)}
}
// 定义抽象类
abstract class FooAbstract {// 定义抽象方法,可以被重写abstract fun gar()// 不可被重写的方法fun foo(){}// 可被重写的方法open fun bar(){}
}
注意事项
1定义抽象类前边加上 abstract 关键字。 2抽象类中的方法注意不是抽象方法默认是不可被重写的必须显示的加上关键字 open才可以被重写。 3抽象类中的所有方法有关键字 abstract 和open的方法在实现类里边必须全部被重写否则不会被编译通过。 4继承抽象类写法 class T( ): Aabstract( ) { } ,抽象类后边必须添加括号。 5重写抽象类中的方法跟接口实现一样在实现类中 也需要添加 关键字 override。
六、同时继承接口及抽象类
// Foo类 实现 FooAbstract抽象类、FooInterface接口
class Foo(val x: String):FooAbstract(), FooInterface{// 重写了抽象类中 foo方法override fun foo() {TODO(Not yet implemented)}// 重写了接口中 bar方法override fun bar() {TODO(Not yet implemented)}
}
// 定义抽象类
abstract class FooAbstract {abstract fun foo()
}
// 定义接口
interface FooInterface{fun bar()
}
六、普通类的继承
1、继承普通类普通类前边必须添加 open 关键字才能被别的类继承
// Foo类 实现 FooAbstract抽象类、FooInterface接口
open class Foo(val x: String):FooAbstract(), FooInterface{override fun foo() {TODO(Not yet implemented)}override fun bar() {TODO(Not yet implemented)}
}
// Foo2 继承 Foo 类Foo类前边必须添加关键字 open
class Foo2(val y: String):Foo(y){
}
// 定义抽象类
abstract class FooAbstract {abstract fun foo()
}
// 定义接口
interface FooInterface{fun bar()
}
fun main(){Foo2(hello)
}
2、被继承类中的方法如果不想被别的类复写某个方法可以在方法卡那边加上关键字 final
open class Foo(a:String): FooInterface, FooAbstractClass(){override fun foo() {TODO(Not yet implemented)}// bar 方法不可被别的类重写final override fun bar() {TODO(Not yet implemented)}
}
class Foo2(val a: String):Foo(a){override fun foo() {}// 编译不会通过因为Foo类中的bar方法前边有关键字 finaloverride fun bar() {}
}
abstract class FooAbstractClass {abstract fun foo()
}
interface FooInterface {fun bar()
}
