Kotlin中的类
class Main{
}
class Main1 : AppCompatActivity(){
}
class Main2:AppCompatActivity(),View.OnClickListener{
override fun onClick(v: View?) {
TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
}
}
open class Main3{
}
open class Main4:AppCompatActivity(){
}
open class Main5:AppCompatActivity(),View.OnClickListener{
override fun onClick(v: View?) {
TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
}
}
上面代码中我们声明了五种类的写法。
在Kotlin中定义一个类，必须使用class关键字来修饰(例如Main)；
如果这个类有父类则使用 " : " 来代表继承（例如Main1）；
如果有多重继承或者有接口来实例化则可以直接在后面用逗号来隔开处理，而无需写implements来实现接口（例如Main2），接口和父类可以没有先后关系，先写接口然后再写父类也没有任何的问题；
在kotlin中有一个关键字open，其代表这个类不为final。在kotlin中如果类没有用open进行修饰，那么kotlin会默认这个类是一个被public final修饰的类。
构造函数
在kotlin中，如果想在类中写入构造函数，并且在构造函数中传递参数，那么我们可以只写在类的后面跟一个括号，在括号内填写相应的参数。
class Person (name:String,age:Int){
private var name:String;
private var age:Int;
init {
this.name = name;
this.age = age;
}
}
我们看到，在Person这个类后面我们用括号括起来了两个参数。于是这便是向Person类写入了一个构造函数，,而当我们想要在构造函数中执行一些语句的话，我们便可以使用init这个关键字，这个关键字中的语句会在我们执行构造函数的时候同时执行。在这里我们在init语句中将两个参数进行赋值操作。
次级构造函数
当我们在写一个类的时候可能有时候因为功能的不同，会写很多个构造函数。在kotlin中次级构造函数需要使用constructor来修饰，并且次级构造函数必须直接或间接的继承主构造函数。
class Student constructor(username: String, age: Int) {
private val username: String = username
private var age: Int = age
private var address: String
private var isMarried: Boolean
init {
this.address = "Beijing"
this.isMarried = false
}
constructor(username: String, age: Int, address: String) :this(username, age) {
this.address = address
}
constructor(username: String, age: Int, address: String, isMarried: Boolean) : this(username, age, address) {
this.isMarried = isMarried
}
}
可以看到在代码中，我们写了两个次级构造函数，并且每个函数后面都直接或间接的继承了主构造函数。
访问修饰符
在kotlin中总共有四种访问修饰符
private： 代表这个类中的成员是这个类私有的别的类不能进行访问。
public： 代表这个类或者其他所有的类都能够访问的到。
protected： 代表这个类或者这个类的继承类都可以访问这个成员
internal： 此为kotlin中特有的修饰符，其表示在这个模块内都能访问到这个对象，但是对于跨模块却不能访问到。那么什么叫做模块呢？在Android常用编辑器Android Studio中我们有时候会通过文件File去新建一个叫做module的，而这个module就是一个模块。而被internal修饰的对象，只能在这个module中访问，不能在其他module中访问。
伴生对象
在Java中我们常常会去使用一些工具类，对于工具类的编写，一般都是直接在一个类中用static去修饰这个方法，然后通过类名.方法名直接调用。
public class Utils {
public static boolean isEmpty(String str){
return str.equals("");
}
}
但是在kotlin中是没有static这个关键字的，那么在kotlin中该如何处理这种工具类的编写呢？方法有两种，
一种是之前讲的，可以使用 @JvmStatic 来修饰工具类的方法然后直接调用。
object Utils{
@JvmStatic
fun isEmpty(str:String):Boolean {
return str.equals("");
}
}
fun test1(){
Utils.isEmpty("test");
}
另外一种是使用伴生对象来进行修饰。
class Utils1{
companion object {
fun isEmpty(str:String):Boolean{
return str.equals("");
}
}
}
fun test1(){
Utils1.isEmpty("test");
}
伴生对象必须要在类中进行使用。用companion object两个关键字进行声明，后面用一个大括号括起来需要使用的函数，使用的时候直接通过类名.函数名称即可。
那么在Java中该如何调用这个kotlin中的伴生对象呢？其实也非常简单，可以使用类名 + Companion + 函数名即可。
//java代码
public class Utils {
public void test(){
Utils1.Companion.isEmpty("test");
}
}
实际上，在kotlin中程序会通过Companion这个关键字在编译的时候生成一个静态的对象，然后java通过这个静态对象去调用Companion对象内部的一些函数。
编写单例
在kotlin中编写单例的方式有两种，一种是通过object + @JvmStatic的方式来编写单例。而另外一种单例的编写我们可以使用伴生对象来实现。
fun test1(){
var get = SingletonDemo.get()
}
class SingletonDemo private constructor() {
companion object {
private var instance: SingletonDemo? = null
get() {
if (field == null) {
field = SingletonDemo()
}
return field
}
@Synchronized
fun get(): SingletonDemo{
return instance!!
}
}
}
看到，我们通过伴生对象来编写了一个懒汉式的单例模式。然后直接通过伴生对象的函数来获取到SingletonDemo这个对象。
数据类——data
data可以说是在kotlin中常用的关键字。这个关键字一般是用来修饰一个类的，被修饰的这个类自动会生成get()/set()方法、toString()方法、hashCode()方法、equals()方法以及copy()方法，而不需要我们再特意去书写这些常用的方法，大大节约了我们的书写成本。
data class Person1(var name:String){
}
这里需要注意，被data修饰的类必须至少需要一个构造方法，且里面需要有至少一个参数。如果没有构造方法的类不能被data修饰或者被修饰了会报错。 这个其实也很好理解，因为被data修饰之后会有se()/get()方法，所以如果没有构造方法来传递参数，那么set()/get()方法根本没有用。另外，数据类是一个public final类型，被data修饰的类不能再被open去修饰也不能等被继承，不然程序会报错。
如果觉得我的文章能够帮助到你，也欢迎关注我的微信公众号「晨雨细曲」，有新技术和知识会推送在这上面。