欢迎访问优讯网!
您当前的位置:首页 > 爱编程

Kotlin中实体类的创建方式

时间:2020-03-17 10:27:45  来源:优讯网  作者:小卡司  浏览次数:
这篇文章主要介绍了Kotlin中实体类的创建方式,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
 

类的基本格式

class 类名{

}

属性的基本格式

var 属性名字 : 类型

下面是实体类代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package com.dldw.entity
import java.util.*
class Demo {
  
 //var 声明的属性可以被二次赋值 val声明的是不可变属性,赋值以后不能在赋值,否则编译报错
  
 //长整型 64位 注意后面加大写L
 var height: Long? = 0L
 
 //整型 32 位
 var id : Int?= 0
 
 //短整型 16位
 var short :Short? =0
 
 // 8位
 var name : Byte? = null
 
 //浮点类型 双精度 64位
 var level: Double = 0.0
 
 //单精度 后面加f
 var levelf: Float = 0.0f
 
 //时间类型成员属性 ?表示该属性可以为null
 var createTime: Date?=null
 
 //初始化,kotlin没有new关键字,直接 对象()就是创建一个新对象
 var time: Date?=Date()
 
 //字符串类型
 var introduction: String? = null
 
 //布尔类型作为属性
 var isHide: Boolean? = null
 
 //可变集合作为属性
 var child: MutableList<Demo> ?= null
 
 // Char是一个单独类型 ,不表示数字,需要用‘'括起来,不然那会报错
  var char : Char?= '1'
}

补充知识:Kotlin中类、构造器、对象

1.Kotlin中类的定义

类的构成:

类的构成由构造函数和初始化代码块、属性(字段)、函数(方法)、内部类(嵌套类)、对象声明五部分组成

//Kotlin中也是使用class关键字创建类的

class Empty

2.创建类的对象

1
2
3
fun main(args: Array<String>) {
 val empty=Empty() //Kotlin中创建对象无new关键字
}

3.创建类的构造器

Kotlin当没有创建构造器时,与Java类似的是,与Java类似的就是当没有显示提供主函数时,Kotlin会为其生成一个无参构造。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
/**
 * 构造器 constructor Kotlin中有一个主构造函数和多个二级构造函数
 * 主构造函数是类头的一部分,跟在类名后面
 * 在Java中,构造方法必须和类名相同,而在Kotlin中,是通过constructor关键字来标明的
 */
class Student constructor(name: String, age: Int) {
 private val username: String
 private var age: Int
  
 //在Kotlin中使用init初始化代码块,它的作用是为了主构造函数服务的,
由于主构造函数是放在类首部的,是不能包含任何初始化执行语句的,
这是语法规定的,那么这个时候就有了init的用武之地,

 // 我们可以把初始化执行语句放置在此处,为属性进行赋值
 init {
  this.username = name
  this.age = age
 }
}
  
//写法二 : 可将constructor关键字去掉
class Student2(username: String, age: Int) {
 private val username: String
 private val age: Int
  
 init {
  this.username = username
  this.age = age
 }
}
  
//写法三 初始化语句不是必须放在init代码块中的,也可以定义属性的时候初始化
class Student3(username: String, age: Int) {
 private val username: String = username
 private var age: Int = age
}
//写法四,直接在构造器中定义类的属性
class Student4(private val username: String,private val age: Int){}
  
//次构造函数,与主构造函数的区别就是,次构造函数定义在类中,
可以有多个,但是主构造函数只会有一个

class Users{
 private val username:String
 private val age:Int
  
 constructor(username: String,age: Int){
  this.username=username
  this.age=age
 }
}

4.创建抽象类

用来创建基类,封装常用的方法,以及处理一些共有的逻辑,而这个所谓的基类一般都是抽象类。

Kotlin中抽象类的定义

抽象类,可以理解为类定义了一个模板。所有的子类都是根据这个模板是填充自己的代码。

关键字:abstract

抽象可以分为:抽象类、抽象函数、抽象属性。而一个抽象类和普通类的区别在于抽象类除了可以有其自己的属性、构造函数、方法等组成部分,还包含了抽象函数以及抽象属性。

抽象类的定义及具体的实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class TestAbstractA :Lanauge(){
 override var name: String="Kotlin"
 override fun init() {
//  TODO("not implemented") //To change body of created functions
use File | Settings | File Templates.

  println("我是${name}")
 }
}
  
class TestAbstractB :Lanauge(){
 override var name: String
 get() = "Java"
 set(value) {}
 override fun init() {
  // TODO("not implemented") //To change body of created functions
use File | Settings | File Templates.

  println("我是${name}")
 }
}
  
fun main(args: Array<String>) {
 val ta=TestAbstractA()
 val tb=TestAbstractB()
 println(ta.name)
 println(tb.name)
   ta.init()
 tb.init()
}

抽象类的特点:

抽象类本身具有普通类特性,以及组成部分。不过值得注意的是,抽象类不能直接被实例化

其抽象了类的子类必须全部重写带abstract修饰的属性和方法。

抽象成员只有定义,没有实现。都有abstract修饰符修饰。

抽象类是为其子类定义了一个模板。不同是类实现不同的功能

***抽象类还可以继承自一个继承类

1
2
3
4
5
6
7
8
9
10
11
12
//使用open,这个类声明有open属性,可以被其他类继承
open class Base {
 open fun init() {}
}
  
//抽象类还可以继承自一个继承类
abstract class Lanauge2 : Base() {
 override fun init() {
  super.init()
 }
 abstract class Name() {} //抽象类的嵌套
}

5.嵌套类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
 * 嵌套类
 */
class Other {
 val numOuther = 1
  
 class Nested{
  fun init(){
   println("执行了init方法")
  }
 }
}
  
//嵌套类的使用
  
 Other.Nested().init() //调用格式为:外部类.嵌套类().嵌套类 方法/属性

6.嵌套内部类

1
2
3
4
5
6
7
8
9
10
11
12
//嵌套内部类
class Othert{
 val mumOther=1
  
 inner class InnerClass{
  val name="InnerClass"
  fun init(){
   println("我是内部类")
  }
 }
}
在主函数中调用<br>Othert().InnerClass().init() // 调用格式为:外部类().内部类().内部类方法/属性<br>

7.匿名内部类的定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
fun main(args: Array<String>) {
 //测试内部类
 val inner=Inner()
 inner.setOnClickListener(object : OnClickListener{
  override fun onItemClick(str: String) {
   println(str)
  }
 })
 inner.testListener()
}
class Inner{
 //lateini(延迟加载) 只能修饰, 非kotlin基本类型
 //因为Kotlin会使用null来对每一个用lateinit修饰的属性做初始化,
而基础类型是没有null类型,所以无法使用lateinit。

 lateinit private var listener:OnClickListener
 fun setOnClickListener(listener: OnClickListener){
  this.listener=listener
 }
  
 fun testListener(){
  listener.onItemClick("我是匿名内部类的测试方法")
 }
}
  
interface OnClickListener{
 fun onItemClick(str:String)
}

8.定义局部类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class Local{ // 外部类
 val numOther = 1
  
 fun partMethod(){
  var name : String = "partMethod"
  
  class Part{
   var numPart : Int = 2
  
   fun test(){
    name = "test"
    numPart = 5
    println("我是局部类中的方法")
   }
  }
  
  val part = Part()
  println("name = $name \t numPart = " + part.numPart + "\t numOther = numOther")
  part.test()
  println("name = $name \t numPart = " + part.numPart + "\t numOther = numOther")
 }
}
  
fun main(args: Array<String>) {
 // 测试局部类
 Local().partMethod()
}

以上这篇Kotlin中实体类的创建方式就是小编分享给大家的全部内容了

来顶一下
返回首页
返回首页

原文链接:https://www.jb51.net/article/182818.htm


推荐资讯
如何下载旧版centos iso镜像 如何下载迷你mini版的centos镜像
如何下载旧版centos i
计算机的正确使用姿势 电脑痴如何正确的使用电脑
计算机的正确使用姿势
好用的后台管理的前端框架模版H-ui H-ui框架模版分享
好用的后台管理的前端
微信电脑多开方法 无需辅助电脑版微信双开方法分享
微信电脑多开方法 无
相关文章
栏目更新
栏目热门