本文章已授权鸿洋微信公众号转载
目开源阅读录
-
空安全
-
方法支持添加默认参数
-
方法上面的参数不可变
-
类方法扩展
-
函数变量
-
内联函数
-
委托机制
-
类委托
-
属性委托
-
懒委托
-
-
扩展函数
-
let 函数
-
with 函数
-
run 函数
-
apply 函数
-
also 函数
-
-
运算符重载
空安全Kotlin
-
在 Java 不用强制我们处理空对象,所以常常会导致 NullPoint变量的指针其含义是指该变量的erException 空指针出现,现在 Kotlin 对空对象进行了限定,必须在编译时处理对象是否为空的情况,不然会导致编译不通过开源众包
-
在对象不可空的情况下,可以直接使用这个对象
fun getText() : String {
return "text"
}
val text = getText()
print(text.length)
- 在对象可空的情况下,必须要判断对象是否为空
fun getText() : String? {
return null
}
val text = getText()
if (text != null) {
print(text.length)
}
// 如果不想判断是否为空,可以直接这样,如果 text 对象为空,则会报空指针异常,一般情况下不推荐这样使用
val text = getText()
print(text!!.length)
// 还有一种更好的处理方式,如果 text 对象为空则不会报错,但是 text.length 的结果会等于 null
val text = getText()
print(text?.length)
方法支持添加默认参数
- 在 Java 方法上,我们可能会为了扩展某个方法而进行多次重载
public void toast(String text) {
toast(this, text, Toast.LENGTH_SHORT);
}
public void toast(Context context, String text) {
toast(context, text, Toast.LENGTH_SHORT);
}
public void toast(Context context, String text, int time) {
Toast.makeText(context, text, time).show();
}
toast("弹个吐司");
toast(this, "弹个吐司");
toast(this, "弹个吐司", Toast.LENGTH_LONG);
- 但是在 Kotlin 上面,我们无需进行重载,可以直接在方法上面直接定义参数的默apple认值
fun toast(context : Context = this, text : String, time : Int = Toast.LENGTH_SHORT) {
Toast.makeText(context, text, time).show()
}
toast(text = "弹个吐司")
toast(this, "弹个吐司")
toast(this, "弹个吐司", Toast.LENGTH_LONG)
方法上面的参数不可变
-
在 Java 方法上面,我们可以随意修改方法上面参数的赋值,appstore但是到了 Kotlin 这里是不行的,Kotlin 方法参数上面的变量是 val (对应 Java 的 final)类型的,那么这个时候我们有两种解决方案:
-
第一种,在方法appearance里面定义一个一模一样的变量,具体写法如下:
class XxxView : View {
override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
var widthMeasureSpec: Int = widthMeasureSpec
var heightMeasureSpec: Int = heightMeasureSpec
if (MeasureSpec.getMode(widthMeasureSpec) == MeasureSpec.AT_MOST) {
widthMeasureSpec = MeasureSpec.makeMeasureSpec(30, MeasureSpec.EXACTLY)
}
if (MeasureSpec.getMode(heightMeasureSpec) == MeasureSpec.AT_MOST) {
heightMeasureSpec = MeasureSpec.makeMeasureSpec(30, MeasureSpec.EXACTLY)
}
setMeasuredDimension(widthMeasureSpec, heightMeasureSpec)
}
}
-
但是编译器会报警告,提示我们出java语言现了重复变量,但是仍可正常编译和运行,所以不推荐这种写法
-
第二种,在方法里面定义一个不同开源中国名称的变量,具体写法如下:
class XxxView : View {
override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
var finalWidthMeasureSpec: Int = widthMeasureSpec
var finalHeightMeasureSpec: Int = heightMeasureSpec
if (MeasureSpec.getMode(finalWidthMeasureSpec) == MeasureSpec.AT_MOST) {
finalWidthMeasureSpec = MeasureSpec.makeMeasureSpec(30, MeasureSpec.EXACTLY)
}
if (MeasureSpec.getMode(finalHeightMeasureSpec) == MeasureSpec.AT_MOST) {
finalHeightMeasureSpec = MeasureSpec.makeMeasureSpec(30, MeasureSpec.EXACTLY)
}
setMeasuredDimension(widthMeasureSpec, heightMeasureSpec)
}
}
-
其实就在原来的基础上加一个 final 前缀,这样不仅解决了编译器警告的问题,还解决了我们还要重新想一个名称来给变量命名的烦恼。
-
那么肯定有人变量名会问了,有没有办法像 Java 一样改呢?关于这个问题我也纠APP结了一阵子,但是查阅了很多文档和资料,最终发现并没有办法,所以只能妥协了,毕竟这个世界上没有什么事物是完美的。
类方application法扩展
- 可以在不用继承的情况下对扩展原有类的方法,例如对 StrAPPing 类进行扩展方法
fun String.handle() : String {
return this + "Android轮子哥"
}
// 需要注意,handle 方法在哪个类中被定义,这种扩展只能在那个类里面才能使用
print("HJQ = ".handle())
HJQ = Android轮子哥
函数变量
- 在 Kotlin 语法中函数Java是可以作为变量进行传递的
var result = fun(number1 : Int, number2 : Int) : Int {
return number1 + number2
}
- 使用这个函数变量
println(result(1, 2))
内联函数
- 有人可能会问了,内联函数是虾米开源节流什么意思?我举个栗子,用 Kotlin 编写以下代码
class Demo {
fun test() {
showToast("666666")
}
/**
* 这个就是我们今天的主角:内联函数了,用 inline 关键字来修饰
*/
private inline fun showToast(message: String) {
ToastUtils.show(message)
}
}
- 经过反编译之后,会变成以下代码:
/* compiled from: Demo.kt */
public final class Demo {
public final void test() {
ToastUtils.show("666666");
}
}
-
看到这里相信大家应该知道内联函数的用法和作用了,内联函数就是在编译的时候将所有调用 inline 函数的代码直接替换成方法里面的代码,那么大家可能有疑问了,这样做有什么实际好处呢?它其实提升了代码的性能,这跟基本数据类型的常量会在编译的过程中被优化一样,但是如果 inline 函数被许多处地方调用,并且 inline 函数的实现代码比较多的情况变量下,也会相应导致代码量增加。
-
另外上面的代码示例中,编java语言译器在 inline 关键字上面有一个代码警告,原话是开源阅读app下载安装这样的java编译器:
Expected performance impact from inlining is insignificant. Inlining works best for functkotlin为什么流行不起来ions with papplea开源代码网站githubrameters of functional types
内联对性能的预期影响是微不足道的。内联最适用于参数为函数类型的函数
- 大致的意思是,上面的代码示例中,内联函数能起到开源阅读app下载安装的性变量类型有哪些能优化是微不足道的,它比较适合带有 lambda 参数的函数,根据这个提示,将上面的代码示例修改成下面这样就不会报代码警告了:
class Demo {
fun test() {
showToast({
println("测试输出了")
}, "7777777")
}
private inline fun showToast(function: () -> Unit, message: String) {
function.invoke()
ToastUtils.show(message)
}
}
- 有人可能会好奇了,这样就能有很大的性能提升?有什么判断依据呢?接下来让我们做变量的定义一组实验,加 inline 和不加 inline 反编变量的指针其含义是指该变量的译出来的代码有什么区别,先来看加 inline 之后反编译出来的代码长啥样
/* compiled from: Demo.kt */
public final class Demo {
public final void test() {
System.out.println("\u6d4b\u8bd5\u8f93\u51fa\u4e86");
ToastUtils.show("7777777");
}
}
- 一切都在java模拟器预料之中,那么不加 inline 反编译出来又是什么效果呢?
/* compiled from: Demo.kt */
public final class Demo {
public final void test() {
showToast(1.INSTANCE, "7777777");
}
private final void showToast(Function0<Unit> function, String message) {
function.invoke();
ToastUtils.show(message);
}
}
/* compiled from: Demo.kt */
final class Demo$test$1 extends Lambda implements Function0<Unit> {
public static final Demo$test$1 INSTANCE = new Demo$test$1();
Demo$test$1() {
super(0);
}
public final void invoke() {
System.out.println("\u6d4b\u8bd5\u8f93\u51fa\u4e86");
}
}
-
很明显,不加 inline 会导致多生成一个内部类,这个是 lambda 函数多出来的类,并且里面的示例还是静态,这无开源节流什么意思疑会增加内存消耗,另外这样还有另外一个好处,就是能少一层方法栈的调用。
-
除了 inline (内联)这个关键字,还开源中国有另外一个关键字:noinline(禁止内联),大家可能到这app小胖子里就摸不着头脑了,这个有啥用?我不在方法上面写 inline 不就是不会内联了么?那java培训么这个关键字是有什么作用呢?其实这个关键字不是修饰在方法上面的,开源矿工而是修饰 在 lappointmentambda 参数上面的,假设一个 inline 函数上面有多个 lambda 参数,那么我只想对某个java模拟器 lambda 参数内联,其他 lambda 参数不内联的情况下,就可以使用这个关键字来对不需要进行内联的 lambda 参数进行修饰,大体用法如下:
private inline fun showToast(function1: () -> Unit, noinline function2: () -> Unit, message: String) {
function1.invoke()
function2.invoke()
ToastUtils.show(message)
}
委托机制
类委托
- 先让我们来看一段代码
// 定义日志策略接口
interface ILogStrategy {
fun log(message: String)
}
// 实现一个默认的日志策略类
class LogStrategyImpl : ILogStrategy {
override fun log(message: String) {
Log.i("测试输出", message)
}
}
// 创建一个日志代理类
class LogStrategyProxy(strategy: ILogStrategy) : ILogStrategy by strategy
-
看到这里大家可能有一些疑惑
-
ILogjava面试题Strategyappointment by strategyjava培训
是虾米操作? -
LogStrategyProxy
这个类不去实现接口方法难道不会导致编译不通过么?
-
-
关于这两个问题,我觉得都可以APP用同一个解释,LogStrategyProxy 之所以不用实现 ILogStrategy 的 lappointmentog 方法,是因为在
ILogStrategy
接口后面加了by strategy
,而strategy
对象就是 LogStrategyProxy 构造函数中的变量,意思是让这个接口的具体实现由变量的指针其含义是指该变量的strategy
对象帮我实现就可以了APP,我(LogStrategyProxy
类)不需要再实现一遍了,这样是不是跟 Jajava怎么读va 中的静态代理很像?只不过在 Kotlin 类委托特性上面编译器帮我们自动生成接口方法的代码,你可以把它想象下面这样的代码java模拟器:
class LogStrategyProxy(val strategy: ILogStrategy) : ILogStrategy {
override fun log(message: String) {
strategy.log(message)
}
}
-
有人肯定会问了:口说无凭,我凭什么相信你就是这样的代码?
-
这是个好问题,我提供一下反编译之后的代码,大家看一下就能明白了:
public final class LogStrategyProxy implements ILogStrategy {
private final /* synthetic */ ILogStrategy $$delegate_0;
public LogStrategyProxy(@NotNull ILogStrategy strategy) {
Intrinsics.checkNotNullParameter(strategy, "strategy");
this.$$delegate_0 = strategy;
}
public void log(@NotNull String message) {
Intrinsics.checkNotNullParameter(message, "message");
this.$$delegate_0.log(message);
}
}
- 是不是就立马顿悟了?调用变量的定义的话也很简单,代码如下:
val logStrategyImpl = LogStrategyImpl()
LogStrategyProxy(logStrategyImpl).log("666666")
- 最后让我们看看输出的日志:
测试输出: 666666
- 这java环境变量配置个我突然有一个kotlin语言大胆的想法,在使用类委托appointment的情况下,再去重写它的接口方法呢?例如下面的:
class LogStrategyProxy(strategy: ILogStrategy) : ILogStrategy by strategy {
override fun log(message: String) {
println("测试输出 " + message)
}
}
- 关于这个问题我已经做过实践了,是开源矿工木有问题的,大家放心大胆搞。
属性委托
- 看过了上面的类委托,想必大家对委托有一定的了解了,那么属性委托是什么呢?简单来讲,类委托是为了帮我们减少一些实现代码,而属性委托是为了帮我们控制变量的 Get、Set 的操作了,废话不多说,下面演示一下用法,下面先创建一个委托类
class XxxDelegate {
// 先给它一个默认值
private var currentValue: String = "666666"
operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
println("测试字段名为 ${property.name} 的变量被访问了,当前值为 $currentValue")
return currentValue
}
operator fun setValue(thisRef: Any?, property: KProperty<*>, newValue: String) {
currentValue = newValue
println("测试字段名为 ${property.name} 的变量被赋值了,当前值为 $currentValue" + ",新的值 $newValue")
}
}
- 使用代码示例如下:
var temp: String by XxxDelegate()
println("测试输出 " + temp)
temp = "55555"
println("测试输出 " + temp)
- 具体日志输出如下:
System.out: 测试字段名为 temp 的变量被访问了,当前值为 666666
System.out: 测试输出 666666
System.out: 测试字段名为 temp 的变量被赋值了,当前值为 55555,新的值 55555
System.out: 测试字段名为 temp 的变量被访问了,当前值为 55555
System.out: 测试输出 55555
- 看到这里你是否明白了,这个
XxxDelegate
类里面只有两个方法,一个是getValue
,另外一个是setValue
,从方法命名上我们已经能大致得出它的作用了,这里就不再多讲解了,var temp: String by XxxDelegate(开源节流)
表示这个temp
对象的创建会全权委托app小胖子给XxxDelegate
这个类来做。
懒委托
- 什么是懒委托呢?大家开源阅读app下载安装知道单例模式中的懒汉式吧?这个跟它差不多,只不过我们不需要写静态方法和锁机制了,只需要像下面这样写:
val temp: String by lazy {
println("测试变量初始化了")
return@lazy "666666"
}
- 调用代码如下:
println("测试开始")
println("测试第一次输出 " + temp)
println("测试第二次输出 " + temp)
println("测试结束")
- 输出日志如下:
System.out: 测试开始
System.out: 测试变量初始化了
System.out: 测试第一次输出 666666
System.out: 测试第二次输出 666666
System.out: 测试结束
- 是不变量4是真的跟懒汉式差不多?只不过这种写法简化了很多,另外在日常开发中我们可以用它来做
findViewById
是最适合不过的。
private val viewPager: ViewPager? by lazy { findViewById(R.id.vp_home_pager) }
-
另外懒委托还提供了几种懒加载模式供我们选择,
-
LazyTh开源软件readSafetyMode.SYNCHRONIZED:同步模式,确保只有单个线程可以初始化实例,这种模式下初始化时线程安全的,当
by lazy
没有指定模式的时候,就是默认用的这种模式。 -
LazyThreadSafetyMode.PUBLICATkotlin和javaION:并发模式,在多线程下允许并发初始化,但是只有第一个返回的值作为实例,这种模式下是线程安全的,和
LazyThreadSafetyMode.SYNCHRONIZED
最大区Java别是,这种模式在多线程并发访问下初始化效率是最高的,本质上面是用空间换时间,哪个的线程执行快就让哪个先返回结果,其他线程执行的结果抛弃掉。 -
LazyThreadSafetyMode.NONE:普通模式,这种模式不会使用锁来限制多线程访问java模拟器,所以是线程不安全的,所以请勿在多线程并发的情况下使用。
-
-
具体使用的方式也很简单,如下:
val temp: String by lazy(LazyThreadSafetyMode.NONE) {
println("测试变量初始化了")
return@lazy "666666"
}
- 另外有一点需要注意,使用懒委托的变量必须声明为kotlin下载 val(不可变的),因为它只能被赋值一次。
扩展函数
- 扩展函数是 KoKotlintlin 用于简化一些代码的书写产生的,其中有 let、with、rkotlin语言un、apply、also 五个函数
let 函数
-
在函数块内可以变量名的命名规则通过 it 指代该对象。返回值为函数块的最后一行或指定 return 表达式
-
一般写法
fun main() {
val text = "Android轮子哥"
println(text.length)
val result = 1000
println(result)
}
- let 写法
fun main() {
val result = "Android轮子哥".let {
println(it.length)
1000
}
println(result)
}
- 最常用的场景就是使用let函数处理需要针对一个可 null 的对象统一做判空处理
videoPlayer?.setVideoView(activity.course_video_view)
videoPlayer?.setControllerView(activity.course_video_controller_view)
videoPlayer?.setCurtainView(activity.course_video_curtain_view)
videoPlayer?.let {
it.setVideoView(activity.course_video_view)
it.setControllerView(activity.course_video_controller_view)
it.setCurtainView(activity.course_video_curtain_view)
}
- 又或者是需要去明确一个变量所处特定的作用域范围内可以使用
with 函数
-
前面的几个函数使用方式略有不同,因变量4为它开源节流什么意思不是以扩展java环境变量配置的形式存在的。它是将某对象作为函数的参数,在函数块变量与函数内可以通过 this 指代该对象,返回值为函数块的最后一行或指定 return 表达式
-
定义 Person 类
class Person(var name : String, var age : Int)
- 一般写法
fun main() {
var person = Person("Android轮子哥", 100)
println(person.name + person.age)
var result = 1000
println(result)
}
- with 写法
fun main() {
var result = with(Person("Android轮子哥", 100)) {
println(name + age)
1000
}
println(result)
}
- 适用于调用同一个类的多kotlin为什么流行不起来个方appointment法时,可以省去类名重复,直接调用类的方法即可,经常用于 Android 中
RecyclAPPerVijava面试题ew.onBinderViewHolder
中,数据 model 的属性映射到 UI 上
override fun onBindViewHolder(holder: ViewHolder, position: Int){
val item = getItem(position)?: return
holder.nameView.text = "姓名:${item.name}"
holder.ageView.text = "年龄:${item.age}"
}
override fun onBindViewHolder(holder: ViewHolder, position: Int){
val item = getItem(position)?: return
with(item){
holder.nameView.text = "姓名:$name"
holder.ageView.text = "年龄:$age"
}
}
run 函数
-
实际上可以说是 let 和 with 两个变量英文函数的结合体,run 函数只接收一个 lambda 函数为参数,以闭包开源形式返回,返回值为最后一行的值或者指定的 return 的表达式
-
一般写法
var person = Person("Android轮子哥", 100)
println(person.name + "+" + person.age)
var result = 1000
println(result)
- run 写法
var person = Person("Android轮子哥", 100)
var result = person.run {
println("$name + $age")
1000
}
println(result)
- 适用于 let,with 函数任何场景。因为 run 函数是let,with两个函数结合体kotlin现在不火了,准确来说它弥补了 let 函数在函数体javascript百炼成仙内必须使用 it 参数替代对象,在 run 函数中可以像 with 函数一样可以省略,直接访问实例的公有属性和方法,另一方面它弥补了 with开源阅读app下载安装 函数传入对象判空问题,在 run 函数中可以像l et 函数一样做判空处理,这里变量4还是借助 onBindViewHolder 案例进行简化
override fun onBindViewHolder(holder: ViewHolder, position: Int){
val item = getItem(position)?: return
holder.nameView.text = "姓名:${item.name}"
holder.ageView.text = "年龄:${item.age}"
}
override fun onBindViewHolder(holder: ViewHolder, position: Int){
val item = getItem(position)?: return
item?.run {
holder.nameView.text = "姓名:$name"
holder.ageView.text = "年龄:$age"
}
}
apply 函数
-
从结构上来看 apply 函数和 run 函数很像,唯一不同点就是它们各自返回的值不一样,run 函数变量的定义是以闭包形式返回最后一行代码的值,而 apply 函数的返回的是传入对象的本身
-
一app小胖子般写法
val person = Person("Android轮子哥", 100)
person.name = "HJQ"
person.age = 50
- apply 写法Java
val person = Person("Android轮子哥", 100).apply {
name = "HJQ"
age = 50
}
- 整体作用功能和 run 函数很像,唯开源节流什么意思一不同点就是它返回的值是对象本身,而 ru开源软件n 函数是一个闭包形式返回,返回的是最后一行的值。正是基于这一点差异它的适用场景稍微与 run 函数有点不一样。apply 一般用于一个变量的定义对象实例初始化的时候,需要对对象中的属性进行赋值。或者动javaee态 inflat变量的定义e 出一个 XMappearL 的 View 的时候需要给 View 绑定数据也会用到,这种javascript情景非常常见。特别是在我变量的定义们开发中会有一application些数据 model 向 V变量4iew model 转化实例化的过程中需要用到
mRootView = View.inflate(activity, R.layout.example_view, null)
mRootView.tv_cancel.paint.isFakeBoldText = true
mRootView.tv_confirm.paint.isFakeBoldText = true
mRootView.seek_bar.max = 10
mRootView.seek_bar.progress = 0
- 使用 apply 函数后java面试题的代码是这样的
mRootView = View.inflate(activity, R.layout.example_view, null).apply {
tv_cancel.paint.isFakeBoldText = true
tv_confirm.paint.isFakeBoldText = true
seek_bar.max = 10
seek_bar.progress = 0
}
- 多层级判空问题
if (sectionMetaData == null || sectionMetaData.questionnaire == null || sectionMetaData.section == null) {
return;
}
if (sectionMetaData.questionnaire.userProject != null) {
renderAnalysis();
return;
}
if (sectionMetaData.section != null && !sectionMetaData.section.sectionArticles.isEmpty()) {
fetchQuestionData();
return;
}
- kotjavascriptlin 的 apply 函数优化
sectionMetaData?.apply {
// sectionMetaData 对象不为空的时候操作sectionMetaData
}?.questionnaire?.apply {
// questionnaire 对象不为空的时候操作questionnaire
}?.section?.apply {
// section 对象不为空的时候操作section
}?.sectionArticle?.apply {
// sectionArticle 对象不为空的时候操作sectionArticle
}
also 函数
- also 函数的结构实际上和 lappearet 很像唯一的区别就是返回值的不一样,let 是以闭包的形式返回,返回函数体内最后一行的值,如果最后一行为空就返回一个 Unit 类型的默认值。而 als开源众包o 函数返回的则是传入对象的本身
fun main() {
val result = "Android轮子哥".let {
println(it.length)
1000
}
println(result) // 打印:1000
}
fun main() {
val result = "Android轮子哥".also {
println(it.length)
}
println(result) // 打印:Android轮子哥
}
- 适用于 let 函数的任何场景,also 函数和 let 很像,只是唯一的不同点就是 let 函数最开源是什么意思后的返回值是最后一行的返回值而 also 函数的返回值是返回java环境变量配置当前的这个对象。一般可用于多个扩展函数链式调用
运算符重载
- 在 Kotlin 中使用运算符最终也会调用对appear象对应的方法,我们可以通过重写这些方法使得这个对象支持运算符,这开源阅读app下载安装里不再演示代码
运算符 | 调用方法 |
---|---|
+a | a.unaryPlus() |
-aAPP | a.unaryMinus() |
!a | a.not() |
运算符 | 调用方法 |
---|---|
a++ | a.inc() |
a– | a.dec() |
运算符 | 调用方法 |
---|---|
a + b | a.plus(b) |
a – b | a.minapple苹果官网us(b) |
a * b | a.变量值times(b) |
a / b | a.div(b) |
a % b | a.rem(b), a开源中国.mod(b) (depr开源众包ecated) |
a..b | a.rangeTo(b) |
运算符 | 调用方APP法 |
---|---|
a in b | b.contains(a) |
a !in b | !b.contains(a) |
运算符 | 调用方法 |
---|---|
a[i] | a.getJava(i) |
a[i, j] | a.get(i, j) |
a[i_1, …, i_n] | a.get(i_1, …, i_njava模拟器) |
a[i] = b | a.set(i, b) |
a[i, j] = b | a.set(i, j, b) |
a[i_1, …, i_n] = b | a.set(i_1, …, i_n, b) |
运算符 | 调用方法 |
---|---|
a() | a.invoke开源中国() |
a(i) | a.inv开源阅读oke(i) |
a(i, j) | a.invoke(i, j) |
a(i_1, …, i_n) | a.invoke(i_1java编译器, .javascript百炼成仙.., i_n) |
运算符 | 调用方法 |
---|---|
a +=javascript b | a.pluskotlin现在不火了Assign(b) |
a -= b | a.minusAssign(b) |
a *= b | a.timesAssign(b) |
a /= b | a.divAssign(b) |
a %= b | a.remAssign(b), a.modAssign(b) (deprecated) |
运算符 | 调用方法 |
---|---|
a == b | a?.equalsjava模拟器(b) ?: (b === null) |
a != b | !(a?.equals(b) ?: (b === null)) |
运算符 | 调用方法 |
---|---|
a > b | a.compareTo(b) > 0 |
a < b | a.compareTo(b) < 0 |
a >= b | a.compareTo(b) >= 0 |
a <= b | a.compareTo(b) &lkotlin下载t;= 0 |