类的基本格式

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 ?= null

// Char是一个单独类型 ，不表示数字，需要用‘'括起来，不然那会报错

var char : Char?= '1'

}

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

1.Kotlin中类的定义

类的构成:

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

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

class Empty

2.创建类的对象

fun main(args: Array) {

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) {

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) {

//测试内部类

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) {

// 测试局部类

Local().partMethod()

}

以上这篇Kotlin中实体类的创建方式就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持脚本之家。