目录
六:案例:为Activity扩展findViewById方法
一、认识
Koltin的扩展函数,能够使你扩展一个类的新功能而无需继承的方式,例如,你可以为一个你不
能修改的来自第三方库中的某个类编写扩展,这个新增的函数就像那个原始类里本来有的函数一
样,可以用普通方法调用,除此,还有属性扩展,常见的扩展函数。
二、扩展方法
对一个类进行方法扩展,只需要在方法声明时,在函数名前加上类名.
如:表示对String类进行求取最后一个字符的方法扩展,类的方法扩展应在类本体之外
fun String.lastChar(str:String):Char{
}
1、普通类的扩展
fun main() {
val a :Char= OpenString().lastChar("abc")
println(a)
}
fun OpenString.lastChar(str:String):Char{
if(str.isEmpty()){
throw Exception("this String an illegal")
}
return str[str.length-1]
}
open class OpenString{
fun test(){
println("test")
}
}
在Java中使用Kotlin扩展,通过
文件名+Kt.函数名(扩展类的对象,完整的其他参数)
来在 Java 中调用扩展函数(相当于调用工具类的静态方法),比如在test.java中:public class test { public static void main(String[] args) { char lastChar = BaseDataTypeKt.lastChar(new OpenString(),"hello world"); System.out.printf(String.valueOf(lastChar)); } }
2、泛型类的扩展
fun main() {
val list = mutableListOf<String>("android","kotlin","java")
list.swap(0,1)
list.forEach {
println(it)
}
}
fun <T> MutableList<T>.swap(index: Int,index1: Int){
val temp:T = this[index1]
this[index1] = this[index]
this[index] = temp
}
kotlin
android
java
三、扩展属性
1、kotlin里的属性扩展
比如,对String类进行求取首个字符
fun main() {
val str = "android"
println(str.firstChar)
val array :ArrayList<Int> = arrayListOf(1,2,3,4,5)
println(array.lastItem)
}
val String.firstChar:Char get() = this[0]
val <T> List<T>.lastItem:T get() = this[size-1]
2、在Java中使用Koltin的扩展属性
在Java中,获取Kotlin的扩展属性,使用类名KT.get扩展属性(参数)
public static void main(String[] args) {
char lastChar = BaseDataTypeKt.getFirstChar("hello world");
System.out.printf(String.valueOf(lastChar));
}
四、伴生对象的扩展
如果一个类定义了伴生对象,也可以对伴生对象进行属性和方法扩展
fun main() {
val studentA = Student.search("lisi")
println(studentA)
val height = Student.height
println(height)
}
class Student{
companion object{
}
}
fun Student.Companion.search(name:String):String{
return name
}
val Student.Companion.height:Int get() = 100
lisi
100
五、常见的扩展函数
1、run
run函数是对一个类的实例,进行扩展,在run方法里,可以直接访问一个类的公有实例或方法,
什么是公有的属性或方法,就是非private/protected修饰的。第二,run方法是有返回值的,以最后
一条语句结束,或者以return结束。
fun main() {
val result = test(Tree())
println("this tree have $result leaf.")
method(Tree())
}
fun test(tree: Tree):Int{
tree.run {
return leaf
}
}
fun method(tree: Tree):Unit{
tree.run {
grow()
}
}
class Tree{
val leaf = 2
fun grow():Unit{
println("this tree growing")
}
}
2、apply
apple扩展函数是一个作用域函数,调用某对象的apply函数,可以在作用域内,调用该对象的任意方法,并且返回该对象。apply和run函数很相像,区别就是run返回的是值,而apply返回的是对象
fun main() {
ArrayList<Int>().apply {
this.add(1)
this.add(2)
this.add(3)
}.run {
for (i in this) {
println(i)
}
}
}
3、let
let扩展函数是一个作用域函数,当你需要去定义一个变量在一个特定的作用域范围内时,就可以用
let,除此,let还有一个作用就是属性判null。
fun main() {
val a = 3
//作用域
a.let {
val b = a+2
println(b)
}
//判null
val c:String? = null
c?.let {
println(c.length)
}
}
六:案例:为Activity扩展findViewById方法
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
R.id.btn_test.onClick(this){
println("click btn_test")
}
}
}
private fun Int.onClick(activity: Activity, function: () -> Unit) {
activity.findViewById<View>(this).setOnClickListener {
function()
}
}
七:案例:四则运算
//四则运算
fun main() {
while (true) {
println("=============请输入你的表达式=============")
val input = readLine()
try {
input?.let {
val ret = calculate(input)
println("{$input}={$ret}")
println("=============是否继续使用(y/n)=============")
val cmd = readLine()
cmd?.let {
if (cmd == "n")
exitProcess(0)
}
}
} catch (e: Exception) {
e.printStackTrace()
}
}
}
fun calculate(input: String): String {
val add = "+"
val sub = "-"
val mul = "*"
val eli = "/"
if (input.contains(add)) {
val nums = input.trim().split(add)
return operate(nums[0].toDouble(), nums[1].toDouble(), add).toString()
} else if (input.contains(sub)) {
val nums = input.trim().split(sub)
return operate(nums[0].toDouble(), nums[1].toDouble(), sub).toString()
} else if (input.contains(eli)) {
val nums = input.trim().split(eli)
return operate(nums[0].toDouble(), nums[1].toDouble(), eli).toString()
} else if (input.contains(mul)) {
val nums = input.trim().split(mul)
return operate(nums[0].toDouble(), nums[1].toDouble(), mul).toString()
}
return "计算有误"
}
fun operate(s: Double, s1: Double, s2: String): Double {
return when (s2) {
"+" -> s + s1
"-" -> s - s1
"/" -> s / s1
"*" -> s * s1
else -> {0.0}
}
}