Kotlin 1.1也适用于Android开发人员
  HomoDjYo9vTw 2023年11月02日 59 0


我们对Kotlin 1.1的发布感到非常兴奋。此版本包含的新功能对Java开发人员非常有用,并将JVM开发引向了一个新的可能性世界。

但是这些新功能,如协同程序或类型别名(放几个例子),就像Android开发人员的科幻小说。

我们仍然停留在古老的Java 6中,几乎没有什么改进,迫使我们以其他平台中大多数开发人员几乎被遗忘的方式开发。

所以一个理所当然的问题是:Kotlin团队能够保持与Java 6的兼容性,同时使所有这些新功能还活着吗?答案是:当然!

所有新的东西仍然可用于Java 6,作为扩展,适用于Android开发人员。而今天,我想向大家介绍一下,并且开发Android应用程序时,如何使自己的生活变得更加简单。


键入别名:您可以使您的监听器更易读

当然,类别别名有很多不同的应用。但是,我想到的第一个就是让听众更加可读,同时保持使用lambdas的能力。

如果您以前没有听说过类型别名,它们基本上是将复杂类型重命名为更可读的类型。

例如,您可以有一个RecyclerViewadapter将收到一个监听器。您可能知道,RecyclerView没有一个标准的方法来处理项目点击,就像ListView一样,所以我们必须自己出来。

让我们想象一下,我们希望有一个可以访问视图的监听器。我们的适配器类可能如下所示:




 class 
           
         MyAdapter 
         ( 
         val  
         items 
         : 
           
         List 
         < 
         Item 
         > 
         , 
           
         val  
         listener 
         : 
           
         ( 
         View 
         ) 
           
         -> 
           
         Unit 
         ) 
           
         : 
           
         RecyclerView 
         . 
         Adapter 
         < 
         MyAdapter 
         . 
         ViewHolder 
         > 
         ( 
         ) 
           
         { 
        
 
        
 
              
         . 
         . 
         . 
        
 
        
 
         } 


而ViewHolder可能需要接收该监听器,才能将其分配给视图的点击监听器:




  class 
           
         ViewHolder 
         ( 
         itemView 
         : 
           
         View 
         ) 
           
         : 
           
         RecyclerView 
         . 
         ViewHolder 
         ( 
         itemView 
         ) 
           
         { 
        
 
        
 
              
         fun  
         bind 
         ( 
         item 
         : 
           
         Item 
         , 
           
         listener 
         : 
           
         ( 
         View 
         ) 
           
         -> 
           
         Unit 
         ) 
           
         { 
        
 
        
 
                  
         itemView 
         . 
         setOnClickListener 
         ( 
         listener 
         ) 
        
 
        
 
              
         } 
        
 
        
 
         } 


这不是一个非常复杂的情况,但是您可以看到,我们需要重复一下lambda定义,这种定义在上下文中可能会导致难度的读取。

但是,我们可以创建一个代表点击监听器的类型别名:

typealias ClickListener = (View) -> Unit

然后在我们需要的每一个地方使用它:

class MyAdapter(val items: List<Item>, val listener: ClickListener)

or

fun bind(item: Item, listener: ClickListener) { ... }

数据类现在更强大了

数据类是伟大的,因为避免了大量的样板。 但是他们缺乏一些权力,这使得它们在某些情况下不可用。

Kotlin 1.1中的新内容之一是继承:数据类现在可以继承其他类。

这允许数据类成为密封类的一部分:




sealed 
           
         class 
           
         UiOp 
           
         { 
        
 
        
 
              
         object 
           
         Show 
           
         : 
           
         UiOp 
         ( 
         ) 
        
 
        
 
              
         object 
           
         Hide 
           
         : 
           
         UiOp 
         ( 
         ) 
        
 
        
 
              
         data  
         class 
           
         Translate 
         ( 
         val  
         axis 
         : 
           
         Axis 
         , 
           
         val  
         amount 
         : 
           
         Int 
         ) 
         : 
           
         UiOp 
         ( 
         ) 
        
 
        
 
         } 


现在,由于可以在父类中定义密封类,这也可以是这样的:




  sealed  
         class 
           
         UiOp 
        
 
        
 
         object 
           
         Show 
           
         : 
           
         UiOp 
         ( 
         ) 
        
 
        
 
         object 
           
         Hide 
           
         : 
           
         UiOp 
         ( 
         ) 
        
 
        
 
         data  
         class 
           
         Translate 
         ( 
         val  
         axis 
         : 
           
         Axis 
         , 
           
         val  
         amount 
         : 
           
         Int 
         ) 


lambdas内部破坏

自从第一个版本以来,数据类可能被破坏,这归功于它们生成的componentX()方法。 您可以将数据类的内容分配成若干变量,如下所示:





         data  
         class 
           
         Item 
         ( 
         val  
         text 
         : 
           
         String 
         , 
           
         val  
         url 
         : 
           
         String 
         ) 
        
 
        

            
        
 
        
 
         val 
           
         ( 
         text 
         , 
           
         url 
         ) 
           
         = 
           
         item 


但是,一个非常强大的功能缺失:能够在lambdas上做到这一点。 但是等待结束了! 你现在可以这样做:




  fun  
         bind 
         ( 
         item 
         : 
           
         Item 
         ) 
           
         = 
           
         item 
         . 
         let 
           
         { 
           
         ( 
         text 
         , 
           
         url 
         ) 
           
         -> 
        
 
        
 
              
         textView 
         . 
         text 
           
         = 
           
         text 
        
 
        
 
              
         imageView 
         . 
         loadUrl 
         ( 
         url 
         ) 
        
 
        
 
         } 
        


这对地图中的对或键/值集也是非常有用的。

本地委托属性

已授权的属性已经被证明是非常有用的,为我们的课程中的属性提供额外的能力。

例如,最有用的一个是懒惰的代理,它会延迟作业的执行,直到第一次使用该属性。

但懒惰对变量也是非常有帮助的,而科特林缺乏这个功能。

现在,通过本地委托的属性,我们可以做到:




   fun  
         testLocalDelegation 
         ( 
         ) 
           
         { 
        
 
        
 
              
         val 
           
         database 
           
         by 
           
         lazy 
           
         { 
           
         createDatabase 
         ( 
         ) 
           
         } 
        
 
        
 
              
         val 
           
         cache 
           
         by 
           
         lazy 
           
         { 
           
         createMemoryCache 
         ( 
         ) 
           
         } 
        
 
        

            
        
 
        
 
              
         if 
           
         ( 
         mustUseDatabase 
         ( 
         ) 
         ) 
           
         { 
        
 
        
 
                  
         database 
         . 
         use 
           
         { 
           
         . 
         . 
         . 
           
         } 
        
 
        
 
              
         } 
           
         else 
           
         { 
        
 
        
 
                  
         cache 
         . 
         use 
           
         { 
           
         . 
         . 
         . 
           
         } 
        
 
        
 
              
         } 
        
 
        
 
         } 
        


虽然这个例子可以在没有使用懒惰代表团的情况下解决,但它有助于理解这个概念。

我们有几个重物可能会被使用,也可能不会被使用。 通过使用懒惰,我们可以延迟实例化,直到我们确定我们要使用它。

使用第一次,大括号内的代码被执行,并且它将被缓存,以备稍后再次使用。

忘记在lambdas上声明未使用的变量了

在lambdas中声明变量的参数是非常常见的,最终在任何地方都没有使用。

这是因为在Kotlin 1.0中,我们没有办法丢弃未使用的参数。

例如,在本文中,我介绍了如何使用委托更新RecyclerView适配器,最后我使用了以下代码:




var 
           
         items 
         : 
           
         List 
         < 
         Content 
         > 
           
         by  
         Delegates 
         . 
         observable 
         ( 
         emptyList 
         ( 
         ) 
         ) 
           
         { 
        
 
        
 
              
         prop 
         , 
           
         old 
         , 
           
         new 
           
         -> 
        
 
        
 
              
         autoNotify 
         ( 
         old 
         , 
           
         new 
         ) 
           
         { 
           
         o 
         , 
           
         n 
           
         -> 
           
         o 
         . 
         id 
           
         == 
           
         n 
         . 
         id 
           
         } 
        
 
        
 
         } 


道具从未被使用过,但到现在为止,这是有必要的。 现在可以使用下划线来避免这种情况:




 var 
           
         items 
         : 
           
         List 
         < 
         Content 
         > 
           
         by  
         Delegates 
         . 
         observable 
         ( 
         emptyList 
         ( 
         ) 
         ) 
           
         { 
        
 
        
 
              
         _ 
         , 
           
         old 
         , 
           
         new 
           
         -> 
        
 
        
 
              
         autoNotify 
         ( 
         old 
         , 
           
         new 
         ) 
           
         { 
           
         o 
         , 
           
         n 
           
         -> 
           
         o 
         . 
         id 
           
         == 
           
         n 
         . 
         id 
           
         } 
        
 
        
 
         } 
        


但是,如果您没有使用任何一种,则更糟糕。 如果lambda有多个参数,那么即使不使用lambda,也需要写入所有参数。


现在我们可以忽略它们:




  var 
           
         items 
         : 
           
         List 
         < 
         Item 
         > 
           
         by  
         Delegates 
         . 
         observable 
         ( 
         emptyList 
         ( 
         ) 
         ) 
           
         { 
        
 
        
 
              
         _ 
         , 
           
         _ 
         , 
           
         _ 
           
         -> 
        
 
        
 
              
         notifyDataSetChanged 
         ( 
         ) 
        
 
        
 
         } 
        


不仅您定义较少的变量,而且代码变得更易读。现在你不需要检测这些参数是否被使用。很清楚

协同程序

协同程序 是Kotlin1.1中最令人兴奋的消息。尽管在这个版本中最终还是“实验”,但它们功能完整,您可以在今天开始在项目中使用它们。

协调程序将让您以同步方式编写异步代码,允许在某些时候暂停执行,并等待结果,同时编写顺序代码。

您可能已经知道Kotlin中的协同程序的一件事是,它们不是一个库或一个特定的实现,而是一个可以创建库的语言功能。

因此,尽管结果代码看起来可能相似,但重要的是要知道创建这些辅助线程并返回主线程的“齿轮”是什么,这在Android中非常重要。

幸运的是,Kotlin社区移动速度很快,已经有几个图书馆将协同程序的功能带给了Android。这里有一些例子:

你可能想看看的第一个是Jetbrains提供的官方的:

kotlinx-coroutines-android,它提供了可以在Android上使用的协同程序实现。

Anko,在其最新的beta版中,它包括协调支持许多框架听众。

但是还有许多其他第三方库实现自己的协同版本:

AsyncAwait-Android由Niek Haarman

Async /等待Metalab

如果您只想改装支援,您可以通过Andrey Mischenko来检查kotlin-coctines-改装

我敦促你不仅要使用它们,还要检查它们是如何实现的。这是开源的魔力。

Android Devs的其他一些很酷的东西

这个版本还有更多的改进,但是我想强调一些更侧重于Android开发。

第一个是现在,您可以通过使用:jackOptions {true}启用与Jack编译器的支持。 Google已宣布他们不赞成Jack工具链,但如果您将其用于Java 8,这可能对您有帮助,直到Android Studio 2.4的最终版本被发布。

此外,还有一个新的意图,它将使用@JvmOverloads来实现自定义视图的构造函数,它通过使用一个构造函数和参数的默认值,实际上允许在一行(一个真正的长行)中实现自定义视图构造函数。




 class 
           
         CustomView 
           
         @ 
         JvmOverloads  
         constructor 
         ( 
        
 
        
 
                  
         context 
         : 
           
         Context 
         , 
           
         attrs 
         : 
           
         AttributeSet 
         ? 
           
         = 
           
         null 
         , 
           
         defStyleAttr 
         : 
           
         Int 
           
         = 
           
         0 
        
 
        
 
         ) 
           
         : 
           
         View 
         ( 
         context 
         , 
           
         attrs 
         , 
           
         defStyleAttr 
         ) 
           
         { 
        
 
        
 
              
         . 
         . 
         . 
        
 
        
 
         } 


结论

Kotlin 1.1带来了一大批新的功能,使我们为什么还要使用Java更加不可避免的问题。

Kotlin为Android开发人员带来的强大功能是无关紧要的,您可以从今天开始在Kotlin编写您的Android应用程序。

【版权声明】本文内容来自摩杜云社区用户原创、第三方投稿、转载,内容版权归原作者所有。本网站的目的在于传递更多信息,不拥有版权,亦不承担相应法律责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@moduyun.com

  1. 分享:
最后一次编辑于 2023年11月08日 0

暂无评论

推荐阅读
  YgmmQQ65rPv4   2023年11月19日   30   0   0 Java应用程序
  Y8XIq1u6ceQW   2023年11月19日   43   0   0 Java
  AeUHztwqqxTz   2023年11月02日   44   0   0 Javatomcatapache
  YgmmQQ65rPv4   2023年11月02日   56   0   0 赋值Java运算符
  qdH5JHSHCtBs   2023年11月02日   77   0   0 Javadns cache
HomoDjYo9vTw
最新推荐 更多