Kotlin 类可以包含：

构造函数和初始化代码块(init)、

函数、

属性、

嵌套类和内部类、

对象声明

1.使用关键字class声明一个类

class Test{
}

类声明由类名、类头（指定其类型参数、主构造函数等）和由大括号包围的类体构成。类头和类体都是可选的； 如果一个类没有类体，可以省略花括号。class Empty

2. 构造器和初始化

• 关于构造器，kotlin中有一个主构造器，还可以有多个次构造器，主构造器是类头部的一部分，位于类名称之后。

class Person constructor(firstName: String) {
}

• 如果主构造器没有任何注解，也没有任何可见度修饰符，那么constructor关键字可以省略。

class Person(firstName: String) {
}

• 主构造函数不能包含任何的代码。初始化的代码可以放到以 init 关键字作为前缀的初始化块（initializer blocks）中,同时要知道主构造的参数可以在初始化块中使用。它们也可以在类体内声明的属性初始化器中使用：

class Test(id:Int,type:String) {
    //属性 val不可变 var可变
    var id:Int=0
    var name:String="mangguo"
    init {
        //两种方式初始化
        this.id=id
        name=type
    }
    //主构造的参数也可以在类体内声明的属性初始化器中使用
    var typeUpper=type.toUpperCase()
    fun print(){
        println("id:"+id)
        println("name:"+name)
        println("typeUpper:"+typeUpper)
    }

}
------------------------------------------------------
此时在主函数调用这个类的print方法
kotlin中没有new关键字
我们可以像使用普通函数那样使用构造函数创建类实例：
   var test=Test(4,"adcdefGHI")
   test.print()
------------------------------------------------------
输出结果
id:4
name:adcdefGHI
typeUpper:ADCDEFGHI

• 如果构造函数有注解或可见性修饰符，这个 constructor 关键字是必需的，并且这些修饰符在它前面：

class Customer public @Inject constructor(name: String) { …… }

• 如果一个非抽象类没有声明任何（主或次）构造函数，它会有一个生成的不带参数的主构造函数。构造函数的可见性是 public。如果你不希望你的类有一个公有构造函数，你需要声明一个带有非默认可见性的空的主构造函数：

class DontCreateMe private constructor () {
}

3.函数

class Runoob() {
    fun foo() { print("Foo") } // 成员函数
}

4.属性

class Test{
    var name: String = ……
    var url: String = ……
    var city: String = ……
}
对于类中对象的引用，使用 . 号来引用
var test=Test()
test.name
test.url

对于可变属性var默认有getter和setter
对于只读属性val没有setter
我们可以编写自定义的访问器，非常像普通函数，刚好在属性声明内部。

格式：
var <propertyName>[: <PropertyType>] [= <property_initializer>]
    [<getter>]
    [<setter>]
例子：自定义访问器
val isEmpty: Boolean
    get() = this.size == 0
例子：自定义setter
var stringRepresentation: String
    get() = this.toString()
    set(value) {
        setDataFromString(value) // 解析字符串并赋值给其他属性
    }

5.嵌套类和内部类

嵌套类：类可以嵌套在其他类中

class Outer {
    private val bar: Int = 1
    class Nested {
        fun foo() = 2
    }
}
调用：
val demo = Outer.Nested().foo()
输出
2

内部类：类可以标记为 inner 以便能够访问外部类的成员。内部类会带有一个对外部类的对象的引用：

class Outer {
    private val bar: Int = 1
    inner class Inner {
        fun foo() = bar
    }
}
调用
val demo = Outer().Inner().foo()
输出
1

6.对象声明：

它总是在 object 关键字后跟一个名称。 就像变量声明一样，对象声明不是一个表达式，不能用在赋值语句的右边。

object DataProviderManager {
    fun registerDataProvider(provider: DataProvider) {
        // ……
    }

    val allDataProviders: Collection<DataProvider>
        get() = // ……
}
要引用该对象，我们直接使用其名称即可：
DataProviderManager.registerDataProvider(……)