Kotlin中怎么創建實體類

這篇文章將為大家詳細講解有關Kotlin中怎么創建實體類，小編覺得挺實用的，因此分享給大家做個參考，希望大家閱讀完這篇文章后可以有所收獲。

類的基本格式

class 類名{

}

屬性的基本格式

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關鍵字創建類的

class Empty

2.創建類的對象

fun main(args: Array<String>) {
 val empty=Empty() //Kotlin中創建對象無new關鍵字
}

3.創建類的構造器

Kotlin當沒有創建構造器時，與Java類似的是，與Java類似的就是當沒有顯示提供主函數時，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中抽象類的定義

抽象類，可以理解為類定義了一個模板。所有的子類都是根據這個模板是填充自己的代碼。

關鍵字：abstract

抽象可以分為:抽象類、抽象函數、抽象屬性。而一個抽象類和普通類的區別在于抽象類除了可以有其自己的屬性、構造函數、方法等組成部分，還包含了抽象函數以及抽象屬性。

抽象類的定義及具體的實現類

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修飾符修飾。

抽象類是為其子類定義了一個模板。不同是類實現不同的功能

***抽象類還可以繼承自一個繼承類

//使用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 \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中怎么創建實體類”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，使各位可以學到更多知識，如果覺得文章不錯，請把它分享出去讓更多的人看到。