一般类形式：
class Person(var name: String){//构造函数放在类头部
var age = 1
var fulName: String
var address = "china"
init {//初始化模块，与第一构造函数同时执行
fulName = name+"_haha"
}
//类内部成员变量访问通过get,set方法访问
//备用字段使用field声明,field只能用于属性的访问器
var lastName: String = "zhang"
get() = field.toUpperCase()
set//禁止修改
//二级构造函数，需要加前缀 constructor:
constructor (name: String, age:Int) : this(name) {
//this.fulName = name
this.age = age
}
var no: Int = 100
get() = field // 备用字段表示当前属性，对当前字段值只能通过此field处理
set(value) { //变量修改方式
if (value < 10) {
field = value
} else {
field = -1
}
}
var heiht: Float = 145.4f
private set
private fun selfMethod(){//私有方法
println("self method ")
}
fun sayHello(){//无修饰符，默认public
print("hello! nice to meet you!")
}
private val bar: Int = 1
inner class MyInner{//内部类 in
fun ff() = bar // 访问外部类成员
fun innerTest() {
var o = [email protected] //获取外部类的成员变量
//内部类引用外部类成员
println("name=${o.name}, age=${o.age}")
}
}
class Nested {// 嵌套类
fun foo() = "nest class content"
fun myHandle(){
println("Nested instance method invoke!")
}
}
}
类访问
val p = Person("haha")
p.address = "beijing"//set
嵌套类访问
var pnest = Person.Nested()
pnest.foo()
内部类访问
var pinner = Person("Tom").MyInner()// 内部类，Outter后边有括号
pinner.innerTest()
匿名内部类：
kotlin object 对象表达式，相当于java匿名类
fab.setOnTouchListener(object :View.OnTouchListener{//匿名类实现监听器
override fun onTouch(v: View?, event: MotionEvent?): Boolean {
return false
}
})//简化为lambda表达式形式fab2.setOnTouchListener { v , event -> if(event.action == MotionEvent.ACTION_UP){ var pnest = Person.Nested() var str = pnest.foo() tvContent?.text = str } false }
静态类，kotlin没有静态类，静态方法，可以使用object修饰符替代 Java static功能
object SampleClass{
var name: String = "jack tom"
var no: Int = 101
fun bar() {}
}
访问方式，
SampleClass.name
SampleClass.bar()
class SingletonSample2 private constructor() {
// 一个类里面只能声明一个内部关联对象，即关键字 companion 只能使用一次
companion object {//通过companion object实现单例模式
val instance = SingletonHolder.holder
val tt:String = "static object"
}
private object SingletonHolder {
val holder = SingletonSample2()
}
fun hello(){}
}
工厂模式实现：
interface Factory<T> {
fun create(): T
}
class MyClass private constructor(){
companion object : Factory<MyClass> {
override fun create(): MyClass = MyClass()
}
}
类属性延迟初始化：
kotlin为确保类型安全，属性在声明和定义时需要指定属性值，但对于想要延迟初始化或者开始无法确定时我们需要特殊处理，实现方式 lateinit关键字，layzy函数
class User(var name:String){
//延迟初始化方式一
lateinit var play:String //lateinit表示延迟初始化，若没有初始化使用则抛出异常
fun setUpValues(){
play = "basketball"//String("football")
}
//延迟初始化方式二
//lazy() 是一个函数, 接受一个 Lambda 表达式作为参数, 返回一个 Lazy <T> 实例的函数，
// 返回的实例可以作为实现延迟属性的委托
val lazyValue: String by lazy {
println("computed!") // 第一次调用输出，第二次调用不执行
"Hello world"
}
// println(lazyValue) // 第一次执行，执行lazy函数
// println(lazyValue) // 第二次执行，只输出返回值 hello
//延迟初始化方式三，Delegates属性代理方式实现
//notNull 适用于那些无法在初始化阶段就确定属性值的场合
var notNullBar: String by Delegates.notNull<String>()
//foo.notNullBar = "bar"
//如果属性在赋值前就被访问的话则会抛出异常
//println(foo.notNullBar)
fun member(){ print("member method") }
}
继承类， 接口
kotlin被继承类必须使用open修饰，否则无法继承
//open 修饰的类才能被继承
open class BaseP(var name:String){
constructor(name:String,age:Int):this(name){
println("-------base class construct init---------")
}
open fun getName(){ // open修饰方法，才允许子类重写
println("I‘m base class")
}
fun getHello(){//普通方法无法重写
//......
}
}
//子类继承重写方法
class Student:BaseP{
constructor(name:String,age:Int,no:String,score:Int):super(name,age){
println("-------construct init---------")
println("name: ${name} age: ${age} num: ${no} score: ${score}")
}
override fun getName() {
println("I‘m student!")
}
}
接口定义及实现：
//接口定义，接口内可以有非抽象方法或属性
interface MyInterface {
val prop: Int // abstract
val name:String
fun foo(){
print("MyInterface foo")
}
}
//接口实现
class MyImpl1:MyInterface{
override val prop: Int
get() = 18
override val name: String
get() = "james bond"
override fun foo() {
// super.foo()
print("MyImpl1 foo method")
}
}
多接口定义相同方法时，子类实现 对父类调用
interface IA {
fun foo() {
print( "A" )
}
fun bar()
}
interface IB {
fun foo() {
print( "B")
}
fun bar() {
print("bar" )
}
}
class D:IA,IB{
override fun foo() {
super<IA>.foo()//调用父类IA方法
super<IB>.foo()//调用父类IB方法
}
override fun bar() {
super<IB>.bar()
}
}
类的扩展：
Kotlin 除了通过继承，组合等还可以通过自身扩展特性对一个类的属性和方法进行扩展，且不需要继承
扩展是一种静态行为，对被扩展的类代码本身不会造成任何影响
class User(var name:String){
fun member(){ print("member: ${name}") }
}
//扩展函数
fun User.printName(){
print("name= $name")
}
//扩展函数和成员函数一致，则使用该函数时，会优先使用成员函数
fun User.member(){
print("add member!")
}
扩展系统类函数
//Extension functions
fun MutableList<Int>.swap(index1: Int, index2: Int) {
val tmp = this[index1] // ‘this‘ 代表当前扩展对象实例
this[index1] = this[index2]
this[index2] = tmp
}
对一个类的扩展提高了灵活性，同时可以替换部分工具类
activity 扩展应用
fun <T : View> Activity.find(@IdRes id: Int): T {
return findViewById(id) as T
}
TextView label = find(R.id.label);
Button btn = find(R.id.btn);
可以看出扩展之后，编写代码更加便捷了
原文地址：https://www.cnblogs.com/happyxiaoyu02/p/10691388.html
时间： 2024-08-30 14:03:46