如何在Kotlin中创建实体类

班级的基本格式

班级类名{

}

属性的基本格式

var属性名称: 类型

以下是实体类代码

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关键字创建类

空类

2. 创建类对象

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

3. 用于创建类的构造器

当Kotlin不创建构造函数时，它类似于Java，并且与Java相似的是，当没有提供主要功能时c 嵌套类，Kotlin将为其生成无参数构造.

/**
 * 构造器 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中抽象类的定义

抽象类可以理解为定义模板的类. 所有子类都基于此模板填充有自己的代码.

关键字: 抽象

抽象可以分为: 抽象类，抽象函数，抽象属性. 抽象类和普通类的区别在于，除了其自身的属性，构造函数，方法和其他组件外，抽象类还包括抽象函数和抽象属性.

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

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()
}

抽象类的特征

抽象类本身具有通用的类特征和组件. 但是c 嵌套类，值得注意的是，抽象类不能直接实例化.

抽象该类的子类都必须覆盖用抽象修饰的属性和方法.

仅定义而不执行抽象成员. 两者都有抽象修饰符.

抽象类为其子类定义模板. 区别在于该类实现了不同的功能

***抽象类也可以从继承的类继承

//使用open，这个类声明有open属性，可以被其他类继承
open class Base {
 open fun init() {}
}
 
//抽象类还可以继承自一个继承类
abstract class Lanauge2 : Base() {
 override fun init() {
  super.init()
 }
 abstract class Name() {} //抽象类的嵌套
}

5. 嵌套类

/**
 * 嵌套类
 */
class Other {
 val numOuther = 1
 
 class Nested{
  fun init(){
   println("执行了init方法")
  }
 }
}
 
//嵌套类的使用
 
 Other.Nested().init() //调用格式为：外部类.嵌套类().嵌套类 方法/属性

6. 嵌套内部类

//嵌套内部类
class Othert{
 val mumOther=1
 
 inner class InnerClass{
  val name="InnerClass"
  fun init(){
   println("我是内部类")
  }
 }
}
在主函数中调用
Othert().InnerClass().init() // 调用格式为：外部类().内部类().内部类方法/属性

7. 匿名内部类的定义

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. 定义本地课程

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 	 numPart = " + part.numPart + "	 numOther = numOther")
  part.test()
  println("name = $name 	 numPart = " + part.numPart + "	 numOther = numOther")
 }
}
 
fun main(args: Array<String>) {
 // 测试局部类
 Local().partMethod()
}

以上在Kotlin中创建实体类的方法就是小编与您共享的所有内容. 希望能给您参考，也希望您能支持“云海天”教学.

本文来自电脑杂谈，转载请注明本文网址：
http://www.pc-fly.com/a/jisuanjixue/article-148857-1.html