[移动开发]kotlin类与对象

构造函数

kotlin 类
class MainActivity: AppCompatActivity()
class MainActivity:AppcompatActivity(),OnClickListener

kotlin 的类默认是 public final 的

open class MainActivity:AppCompatActivity()
open class MainActivity:AppCompatActivity(),OnClickListener

//在kotlin 中接口和父类没有先后关系，先写接口在写父类也是可以的
//AppCompatActivity()  显示的调用父类的无参构造方法。
//如果 MainActivity 没有实现构造方法，那么AppCompatActivity() 的"()" 是可以不写的
open class MainActivity : View.OnClickListener,AppCompatActivity(){
	override fun onCreate(savedInstanceState:Bundle?){
		setContent(R.layout.activity_main)
		findViewById<View>(R.id.textview).setOnClickListener(this)
	}

	overrde fun onClick(v:View){
	}
}

//如果我们想在构造函数中添加一个参数的话，直接在类名后添加即可，无需想java一样额外的写一个构造函数
open class MainActivity(var int:Int) : View.OnClickListener,AppCompatActivity(){
	
	//如果我们想在构造函数中执行一些语句的话。在kotlin 类中添加init 代码块，将所需执行的代码写在代码块中即可
	init{
		println("-----")
	}
	
	override fun onCreate(savedInstanceState:Bundle?){
		setContent(R.layout.activity_main)
		findViewById<View>(R.id.textview).setOnClickListener(this)
	}

	overrde fun onClick(v:View){
	}
}

//如果在kotlin 代码块中有多个构造函数的话，需要显示的申明次级构造函数  
class TestView :View {
	//次构造函数必须直接或间接的继承主构造函数或父构造函数
	constructor(content:Context):super(content){
		println("constructor")
	}
	constructor(content:Context,attrs:AttributeSet?):this(content,attrs,0)

	constructor(content:Context,attrs:AttributeSet?,defStyleAttr:Int):super(content,attrs,defStyleAttr)
}

访问修饰符

• private 类私有
• protected 类以及继承类可访问
• public 本类以及其他类都可访问
• internal 表示一个模块（android module）中的类都可以访问到这个对象，跨模块的类无法访问

伴生对象

kotlin 中因为没有静态方法，所以无法通过类名.方法名 调用静态方法。除了使用jvmStatic 注解修饰方法，
还有一种方法便是 companion object (伴生对象)
伴生对象一定要写在类的内部

class StringUtils{
	companion object{
		fun isEmpty(str:String):Boolean{
			return "" == str
		}
	}
}
//kotlin 调用
fun main(args: Array<String>){
	StringUtils.isEmpty("===")
}

//java 调用
public class CompanionTest{
	public void test(){
		StringUtils.Companion.isEmpty("afafba")
	}
}

总结：
实际上伴生对象在编译好以后，会在这个类的内部生成一个静态对象，叫Companion的一个对象。java 在调用的时候，实际上是通过Companion 对象调用内部一些变量或方法；

伴成对象还有一个特性，用于声明一个单例。如下

单例类

class Single private constructor(){
	compation object{
		fun get:String{
			return Holder.instance
		}
	}
	
	private object Holder{
		val instance = Single()
	}
}

fun main(args : Array<String>){
	Single.get()
}

动态代理（by）

interface Animal{
	fun bark()
}

class Dog:Animal{
	override fun bark(){
		println("wang")
	}
}

//将传入的animal 作为代理
class Zoo(animal:Animal):Animal by animal

fun main(args:Array<String>){
	Zoo(Dog()).brak()
}

kotlin 会将动态代理在编译后转为动态代理去调用，所以kotlin 的动态代理一定比java 的动态代理效率高；
java 的动态代理本质上是通过反射调用的，而kotlin 的动态代理本质上是通过静态代理去调用的

kotlin 特有的类

数据类（通常用来替代java 中的JavaBean）

data class User(var id:Int,var name:String)
//可以将类中的成员变量自动的生成 getter 和 setter 方法
//public final  getter()/setter()

//也可以自动生成我们经常用到的一些方法，例如下
toString()
hashCode()
equeals()
copy()

//在kotlin 中使用data 修饰的数据类是 final 类型的，在kotlin 中继承数据类时编译期会提示 “ this type is final”
class VIP(id:Int,name:String):User(id,name)

枚举类

enum class Command{
	A、B、C、D
}

fun exec(command:Command)=when(command){
	Command.A->{}
	Command.B->{}
	Command.C->{}
	Command.D->{}
}

在kotlin 中我们很少会使用枚举类，一般会使用它更强大的一个类–密闭类

密闭类（超级枚举）

//密闭类是可以有子类的，但是密闭类的子类必须和密闭类写在同一个文件中，所以通常会将密闭类的子类写在密闭类中，例如下。如此便可以用它来表示一个枚举类了。密闭类的用法和枚举类的用法一致
sealed class SuperCommand{
	object A:SuperCommand()
	object B:SuperCommand()
	object C:SuperCommand()
	object D:SuperCommand()
}

fun exec(command:SuperCommand)=when(command){
	SuperCommand.A->{}
	SuperCommand.B->{}
	SuperCommand.C->{}
	SuperCommand.D->{}
}

密闭类最大的特性在于，密码类是可以有扩展它的子类的，并且，它的子类也可以成为密码类的一个选项。例如下

sealed class SuperCommand{
	object A:SuperCommand()
	object B:SuperCommand()
	object C:SuperCommand()
	object D:SuperCommand()
	class E:SuperCommand()
	//也可以给密闭类的扩展类声明参数
	class E(var id :Int):SuperCommand()
}

fun exec(command:SuperCommand)=when(command){
	SuperCommand.A->{}
	SuperCommand.B->{}
	SuperCommand.C->{}
	SuperCommand.D->{}
	is SuperCommand.E->{}
}

//真实场景应用。 对一个view 进行属性动画的操作
sealed class SuperCommand{
	object UP : SuperCommand()
	object DOWn : SuperCommand()
	object LEFT : SuperCommand()
	object RIGHT : SuperCommand()
	object PACE(var pace:Int) : SuperCommand()
}

fun exec(command:SuperCommand)=when(command){
	SuperCommand.UP->{}
	...
	is SuperCommand.PACE->{}
}