kotlin 订阅
Kotlin (科特林)是一个用于现代多平台应用的静态编程语言 [1]  ,由 JetBrains 开发。Kotlin可以编译成Java字节码,也可以编译成JavaScript,方便在没有JVM的设备上运行。除此之外Kotlin还可以编译成二进制代码直接运行在机器上(例如嵌入式设备或 iOS)。 [1]  Kotlin已正式成为Android官方支持开发语言。 展开全文
Kotlin (科特林)是一个用于现代多平台应用的静态编程语言 [1]  ,由 JetBrains 开发。Kotlin可以编译成Java字节码,也可以编译成JavaScript,方便在没有JVM的设备上运行。除此之外Kotlin还可以编译成二进制代码直接运行在机器上(例如嵌入式设备或 iOS)。 [1]  Kotlin已正式成为Android官方支持开发语言。
信息
发布时间
2016年2月15日
语言版本
1.3.72
开发公司
JetBrains
推出时间
2011年7月
中文名
科特林
性    质
编程语言
外文名
Kotlin
开源协议
Apache 2
Kotlin简介
2011年7月,JetBrains推出baiKotlin项目,这是一个面向duJVM的新语言 [2]  ,它已被开发一年之久。JetBrains负责人Dmitry Jemerov说,大多数语言没有他们正在寻找的特性,Scala除外。但是,他指出了Scala的编译时间慢这一明显缺陷。Kotlin的既定目标之一是像Java一样快速编译。 [1]  2012年2月,JetBrains以Apache 2许可证开源此项目。 [2]  Jetbrains希望这个新语言能够推动IntelliJ IDEA的销售。 [3]  Kotlin v1.0于2016年2月15日发布。这被认为是第一个官方稳定版本,并且JetBrains已准备从该版本开始的长期向后兼容性。 [2]  在Google I/O 2017中,Google宣布在Android上为Kotlin提供一等支持。 [2] 
收起全文
精华内容
参与话题
问答
  • Kotlin

    千次阅读 2019-09-27 21:28:53
    创建Kotlin项目:首先我们打开File-New-New project创建普通的java项目流程,在进行到平时我们创建java项目流程的java名称时候,有些同学的版本是可以看到一个Language的选项,点开会有java和kotlin两种模式,我们...

    创建Kotlin项目:首先我们打开File-New-New project创建普通的java项目流程,在进行到平时我们创建java项目流程的java名称时候,有些同学的版本是可以看到一个Language的选项,点开会有java和kotlin两种模式,我们创建kotlin项目选择kotlin模式,在下面的Minimum API Level中是我们的API版本号,也是可以选择的,选择完毕我们会在下面看到一行英文,大概意思是你的应用程序可以实行百分之几,我们根据最高的几率选择,我的是百分百,最后点击finish完成,这样一个kotlin项目就创建完毕了。
    与java项目不同的地方:我们点击build.gradle会发现最上方有与平时java不同的2行代码:apply plugin: 'kotlin-android’和apply plugin: ‘kotlin-android-extensions’,这个就是kotlin和java中build.gradle中不同的地方,其次便是代码简洁程度的不同,java代码我们一百行的代码,在使用kotlin我们仅仅只需要三分之一的代码量,这也是java与kotlin不同的地方
    kotlin的好处:Kotlin编译为JVM字节码或JavaScript - 像Java一样,Bytecode也是Kotlin程序的编译格式。 字节码表示编程代码,一旦编译,就通过虚拟机而不是计算机的处理器运行。 通过使用这种方法,一旦编译并运行虚拟机,源代码就可以在任何平台上运行。一旦kotlin程序被转换为字节码,它可以通过网络传输并由JVM(Java虚拟机)执行。
    Kotlin可以轻松学习,平易近人。通过简单的阅读语言参考可以轻松学习。语言干净直观(易于使用和理解)。

    展开全文
  • kotlin

    2017-10-27 21:21:45
    create project--kotlin--src--new kotlin class/file print(“输入你想输入的内容”)—点击运行,在控制台打印注释: 有助于自己理解 便于他人理解 专业优雅 一、kotlin基础 常量 定义:预期范围内不变的量 ...

    这里写图片描述

    工具安装:IntelliJ IDEA安装:首先下载工具,配置jdk环境变量

    第一个工程:
    create project--kotlin--src--new kotlin class/file
    print(“输入你想输入的内容”)—点击运行,在控制台打印

    注释:

    有助于自己理解
    便于他人理解
    专业优雅

    一、kotlin基础

    • 常量
      定义:预期范围内不变的量
      写法:val 常量命(任意文字、长度不限)=值

    • 变量
      定义:预期范围内不变的量
      写法:var 变量命(任意文字、长度不限)=值
      常量和变量的关系:一般不知道写成什么,就写val,这样会报错

    • 整型
      形式:val 名称(任意文字、长度不限):Int=值
      注意:由于Kotlin有类型推断,类型可以省略不写,val 名称 = 值

    • 浮点型(小数)
      注意:Kotlin中默认的是Double(双精度)

    • 类型安全
      定义:变量一旦定义,其类型不可变,即不能给变量一个类型不同的值

    • Boolean
      定义:只有两个值:true和false

    • 元组
      注意:元组(Tuple),给多个变量同事赋值,分为二元(Pair)、三元(Triple)

    var days = Triple(2,true,3.1445926)
    var today = Pair("学费",12)
    //或者
    var (a,b,c) = Triple(2,true,3.1445926)
    var (a,b) = Pair("学费",12)
    • 可空类型
      定义:代表变量可能没有值的情况
      形式:var 变量:类型?,无值则为null
      注意:必须标明类型并加?,否则不能为空
    展开全文
  • Kotlin系列之let、with、run、apply、also函数的使用

    万次阅读 多人点赞 2017-12-12 21:59:53
    标签: Kotlin 常用技巧 目录: 一、回调函数的Kotin的lambda的简化 二、内联扩展函数之let 三、内联函数之with 四、内联扩展函数之run 五、内联扩展函数之apply 六、内联扩展函数之also 七、let,with,run,...

    标签: Kotlin      常用技巧


    目录:

    简述:

    相比Java, Kotlin提供了不少高级语法特性。对于一个Kotlin的初学者来说经常会写出一些不够优雅的代码。在Kotlin中的源码标准库(Standard.kt)中提供了一些Kotlin扩展的内置函数可以优化kotlin的编码。Standard.kt是Kotlin库的一部分,它定义了一些基本函数。 这个源代码文件虽然一共不到50行代码,但是这些函数功能都非常强大。


    一、回调函数的Kotin的lambda的简化

    在Kotlin中对Java中的一些的接口的回调做了一些优化,可以使用一个lambda函数来代替。可以简化写一些不必要的嵌套回调方法。但是需要注意:在lambda表达式,只支持单抽象方法模型,也就是说设计的接口里面只有一个抽象的方法,才符合lambda表达式的规则,多个回调方法不支持。

    • 1、用Java代码实现一个接口的回调。

       mView.setEventListener(new ExamPlanHomeEventListener(){
       
          public void onSuccess(Data data){
            //todo
          }
       
       });
      
      
    • 2、在Kotlin中的实现一个接口的回调,不使用lambda表达式(这种方式非常适用于kotlin中对于一个接口中含有多个回调方法)。

      
      mView.setEventListener(object: ExamPlanHomeEventListener{
           
          public void onSuccess(Data data){
            //todo
          }
           
      });
      
    • 3、如果在Kotlin中的对于接口只有一个回调的方法,就符合使用lambda函数,我们可以把以上代码简化成这样。

      mView.setEventListener({
         data: Data ->
         //todo
      })
      
      //或者可以直接省略Data,借助kotlin的智能类型推导
      
      mView.setEventListener({
         data ->
         //todo
      })
      
    • 4、如果以上代码中的data参数没有使用到的话,可以直接把data去掉

      mView.setEventListener({
        //todo
      
      })
      
    • 5、以上代码还可以做个调整,由于setEventListener函数最后一个参数是一个函数的话,可以直接把括号的实现提到圆括号外面

      mView.setEventListener(){
         //todo
      }
      
    • 6、由于setEventListener这个函数只有一个参数,可以直接省略圆括号

      mView.setEventListener{
        //todo
      }
      

    二、内联扩展函数之let

    let扩展函数的实际上是一个作用域函数,当你需要去定义一个变量在一个特定的作用域范围内,let函数的是一个不错的选择;let函数另一个作用就是可以避免写一些判断null的操作。
    
    • 1、let函数的使用的一般结构
    object.let{
       it.todo()//在函数体内使用it替代object对象去访问其公有的属性和方法
       ...
    }
    
    //另一种用途 判断object为null的操作
    object?.let{//表示object不为null的条件下,才会去执行let函数体
       it.todo()
    }
    
    • 2、let函数底层的inline扩展函数+lambda结构
       @kotlin.internal.InlineOnly
    public inline fun <T, R> T.let(block: (T) -> R): R = block(this)
    
    • 3、let函数inline结构的分析

      从源码let函数的结构来看它是只有一个lambda函数块block作为参数的函数,调用T类型对象的let函数,则该对象为函数的参数。在函数块内可以通过 it 指代该对象。返回值为函数块的最后一行或指定return表达式。

    • 4、let函数的kotlin和Java转化

       //kotlin
       
       fun main(args: Array<String>) {
          val result = "testLet".let {
              println(it.length)
              1000
          }
          println(result)
       }
       
       //java
       
       public final class LetFunctionKt {
         public static final void main(@NotNull String[] args) {
            Intrinsics.checkParameterIsNotNull(args, "args");
            String var2 = "testLet";
            int var4 = var2.length();
            System.out.println(var4);
            int result = 1000;
            System.out.println(result);
         }
      }
      
       
      
    • 5、let函数适用的场景

      场景一: 最常用的场景就是使用let函数处理需要针对一个可null的对象统一做判空处理。

      场景二: 然后就是需要去明确一个变量所处特定的作用域范围内可以使用

    • 6、let函数使用前后的对比

      没有使用let函数的代码是这样的,看起来不够优雅

      mVideoPlayer?.setVideoView(activity.course_video_view)
      	mVideoPlayer?.setControllerView(activity.course_video_controller_view)
      	mVideoPlayer?.setCurtainView(activity.course_video_curtain_view)
      

    使用let函数后的代码是这样的

    ```
    mVideoPlayer?.let {
    	   it.setVideoView(activity.course_video_view)
    	   it.setControllerView(activity.course_video_controller_view)
    	   it.setCurtainView(activity.course_video_curtain_view)
    }
    	
    ```
    

    三、内联函数之with

    • 1、with函数使用的一般结构

       with(object){
         //todo
       }
      
    • 2、with函数底层的inline扩展函数+lambda结构

      @kotlin.internal.InlineOnly
      public inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
      
      
    • 3、with函数inline结构的分析

    with函数和前面的几个函数使用方式略有不同,因为它不是以扩展的形式存在的。它是将某对象作为函数的参数,在函数块内可以通过 this 指代该对象。返回值为函数块的最后一行或指定return表达式。

    可以看出with函数是接收了两个参数,分别为T类型的对象receiver和一个lambda函数块,所以with函数最原始样子如下:

    ```
    
    val result = with(user, {
            println("my name is $name, I am $age years old, my phone number is $phoneNum")
            1000
        })
    ```
    

    但是由于with函数最后一个参数是一个函数,可以把函数提到圆括号的外部,所以最终with函数的调用形式如下:

    ```
    val result = with(user) {
            println("my name is $name, I am $age years old, my phone number is $phoneNum")
            1000
        }
    ```
    
    • 4、with函数的kotlin和Java转化

      //kotlin
      
      fun main(args: Array<String>) {
          val user = User("Kotlin", 1, "1111111")
      
          val result = with(user) {
              println("my name is $name, I am $age years old, my phone number is $phoneNum")
              1000
          }
          println("result: $result")
      }
      
      //java
      
       public static final void main(@NotNull String[] args) {
            Intrinsics.checkParameterIsNotNull(args, "args");
            User user = new User("Kotlin", 1, "1111111");
            String var4 = "my name is " + user.getName() + ", I am " + user.getAge() + " years old, my phone number is " + user.getPhoneNum();
            System.out.println(var4);
            int result = 1000;
            String var3 = "result: " + result;
            System.out.println(var3);
         }
      
      
    • 5、with函数的适用的场景

    适用于调用同一个类的多个方法时,可以省去类名重复,直接调用类的方法即可,经常用于Android中RecyclerView中onBinderViewHolder中,数据model的属性映射到UI上

    • 6、with函数使用前后的对比

    没有使用kotlin中的实现

    ```
    @Override
    public void onBindViewHolder(ViewHolder holder, int position) {
    
       ArticleSnippet item = getItem(position);
    		if (item == null) {
    			return;
    		}
    		holder.tvNewsTitle.setText(StringUtils.trimToEmpty(item.titleEn));
    		holder.tvNewsSummary.setText(StringUtils.trimToEmpty(item.summary));
    		String gradeInfo = "难度:" + item.gradeInfo;
    		String wordCount = "单词数:" + item.length;
    		String reviewNum = "读后感:" + item.numReviews;
    		String extraInfo = gradeInfo + " | " + wordCount + " | " + reviewNum;
    		holder.tvExtraInfo.setText(extraInfo);
    		...
    }
    
    ```
    

    kotlin的实现

    ```
    override fun onBindViewHolder(holder: ViewHolder, position: Int){
       val item = getItem(position)?: return
       
       with(item){
       
          holder.tvNewsTitle.text = StringUtils.trimToEmpty(titleEn)
    	   holder.tvNewsSummary.text = StringUtils.trimToEmpty(summary)
    	   holder.tvExtraInf.text = "难度:$gradeInfo | 单词数:$length | 读后感: $numReviews"
           ...   
       
       }
    
    }
    
    ```
    

    四、内联扩展函数之run

    • 1、run函数使用的一般结构

      object.run{
      //todo
      }
      
    • 2、run函数的inline+lambda结构

      @kotlin.internal.InlineOnly
      public inline fun <T, R> T.run(block: T.() -> R): R = block()
      
    • 3、run函数的inline结构分析

      run函数实际上可以说是let和with两个函数的结合体,run函数只接收一个lambda函数为参数,以闭包形式返回,返回值为最后一行的值或者指定的return的表达式。

    • 4、run函数的kotlin和Java转化

      //kotlin
      
      fun main(args: Array<String>) {
          val user = User("Kotlin", 1, "1111111")
      
          val result = user.run {
              println("my name is $name, I am $age years old, my phone number is $phoneNum")
              1000
          }
          println("result: $result")
      }
      
      //java
      
        public static final void main(@NotNull String[] args) {
            Intrinsics.checkParameterIsNotNull(args, "args");
            User user = new User("Kotlin", 1, "1111111");
            String var5 = "my name is " + user.getName() + ", I am " + user.getAge() + " years old, my phone number is " + user.getPhoneNum();
            System.out.println(var5);
            int result = 1000;
            String var3 = "result: " + result;
            System.out.println(var3);
         }
      
      
    • 5、run函数的适用场景

    适用于let,with函数任何场景。因为run函数是let,with两个函数结合体,准确来说它弥补了let函数在函数体内必须使用it参数替代对象,在run函数中可以像with函数一样可以省略,直接访问实例的公有属性和方法,另一方面它弥补了with函数传入对象判空问题,在run函数中可以像let函数一样做判空处理

    • 6、run函数使用前后的对比

    还是借助上个例子kotlin代码

    ```
    override fun onBindViewHolder(holder: ViewHolder, position: Int){
       val item = getItem(position)?: return
       
       with(item){
       
          holder.tvNewsTitle.text = StringUtils.trimToEmpty(titleEn)
    	   holder.tvNewsSummary.text = StringUtils.trimToEmpty(summary)
    	   holder.tvExtraInf = "难度:$gradeInfo | 单词数:$length | 读后感: $numReviews"
           ...   
       
       }
    
    }
    ```
    

    使用run函数后的优化

    ```
    override fun onBindViewHolder(holder: ViewHolder, position: Int){
       
      getItem(position)?.run{
          holder.tvNewsTitle.text = StringUtils.trimToEmpty(titleEn)
    	   holder.tvNewsSummary.text = StringUtils.trimToEmpty(summary)
    	   holder.tvExtraInf = "难度:$gradeInfo | 单词数:$length | 读后感: $numReviews"
           ...   
       
       }
    
    }
    
    ```
    

    五、内联扩展函数之apply

    • 1、apply函数使用的一般结构

      object.apply{
      //todo
      }
      
    • 2、apply函数的inline+lambda结构

      @kotlin.internal.InlineOnly
      public inline fun <T> T.apply(block: T.() -> Unit): T { block(); return this }
      
    • 3、apply函数的inline结构分析

    从结构上来看apply函数和run函数很像,唯一不同点就是它们各自返回的值不一样,run函数是以闭包形式返回最后一行代码的值,而apply函数的返回的是传入对象的本身。

    • 4、apply函数的kotlin和Java转化

      //kotlin
      
      fun main(args: Array<String>) {
          val user = User("Kotlin", 1, "1111111")
      
          val result = user.apply {
              println("my name is $name, I am $age years old, my phone number is $phoneNum")
              1000
          }
          println("result: $result")
      }
      
      //java
      
      public final class ApplyFunctionKt {
         public static final void main(@NotNull String[] args) {
            Intrinsics.checkParameterIsNotNull(args, "args");
            User user = new User("Kotlin", 1, "1111111");
            String var5 = "my name is " + user.getName() + ", I am " + user.getAge() + " years old, my phone number is " + user.getPhoneNum();
            System.out.println(var5);
            String var3 = "result: " + user;
            System.out.println(var3);
         }
      }
      
      
    • 5、apply函数的适用场景

    整体作用功能和run函数很像,唯一不同点就是它返回的值是对象本身,而run函数是一个闭包形式返回,返回的是最后一行的值。正是基于这一点差异它的适用场景稍微与run函数有点不一样。apply一般用于一个对象实例初始化的时候,需要对对象中的属性进行赋值。或者动态inflate出一个XML的View的时候需要给View绑定数据也会用到,这种情景非常常见。特别是在我们开发中会有一些数据model向View model转化实例化的过程中需要用到。

    • 6、apply函数使用前后的对比

    没有使用apply函数的代码是这样的,看起来不够优雅

    ```
    mSheetDialogView = View.inflate(activity, R.layout.biz_exam_plan_layout_sheet_inner, null)
            mSheetDialogView.course_comment_tv_label.paint.isFakeBoldText = true
            mSheetDialogView.course_comment_tv_score.paint.isFakeBoldText = true
            mSheetDialogView.course_comment_tv_cancel.paint.isFakeBoldText = true
            mSheetDialogView.course_comment_tv_confirm.paint.isFakeBoldText = true
            mSheetDialogView.course_comment_seek_bar.max = 10
            mSheetDialogView.course_comment_seek_bar.progress = 0
    ```
    

    使用apply函数后的代码是这样的

    ```
    mSheetDialogView = View.inflate(activity, R.layout.biz_exam_plan_layout_sheet_inner, null).apply{
       course_comment_tv_label.paint.isFakeBoldText = true
       course_comment_tv_score.paint.isFakeBoldText = true
       course_comment_tv_cancel.paint.isFakeBoldText = true
       course_comment_tv_confirm.paint.isFakeBoldText = true
       course_comment_seek_bar.max = 10
       course_comment_seek_bar.progress = 0
    
    }
    
    ```
    

    多层级判空问题

    ```
    	if (mSectionMetaData == null || mSectionMetaData.questionnaire == null || mSectionMetaData.section == null) {
    			return;
    		}
    		if (mSectionMetaData.questionnaire.userProject != null) {
    			renderAnalysis();
    			return;
    		}
    		if (mSectionMetaData.section != null && !mSectionMetaData.section.sectionArticles.isEmpty()) {
    			fetchQuestionData();
    			return;
    		}
    ```
    

    kotlin的apply函数优化

    ```
    mSectionMetaData?.apply{
    
    //mSectionMetaData不为空的时候操作mSectionMetaData
    
    }?.questionnaire?.apply{
    
    //questionnaire不为空的时候操作questionnaire
    
    }?.section?.apply{
    
    //section不为空的时候操作section
    
    }?.sectionArticle?.apply{
    
    //sectionArticle不为空的时候操作sectionArticle
    
    }
    
    ```
    

    六、内联扩展函数之also

    • 1、also函数使用的一般结构

      object.also{
      //todo
      }
      
    • 2、also函数的inline+lambda结构

      @kotlin.internal.InlineOnly
      

    @SinceKotlin(“1.1”)
    public inline fun T.also(block: (T) -> Unit): T { block(this); return this }
    ```

    • 3、also函数的inline结构分析

    also函数的结构实际上和let很像唯一的区别就是返回值的不一样,let是以闭包的形式返回,返回函数体内最后一行的值,如果最后一行为空就返回一个Unit类型的默认值。而also函数返回的则是传入对象的本身

    • 4、also函数编译后的class文件

      //kotlin
      
      fun main(args: Array<String>) {
          val result = "testLet".also {
              println(it.length)
              1000
          }
          println(result)
      }
      
      //java
      
      public final class AlsoFunctionKt {
         public static final void main(@NotNull String[] args) {
            Intrinsics.checkParameterIsNotNull(args, "args");
            String var2 = "testLet";
            int var4 = var2.length();
            System.out.println(var4);
            System.out.println(var2);
         }
      }
      
    • 5、also函数的适用场景

      适用于let函数的任何场景,also函数和let很像,只是唯一的不同点就是let函数最后的返回值是最后一行的返回值而also函数的返回值是返回当前的这个对象。一般可用于多个扩展函数链式调用

    • 6、also函数使用前后的对比

      和let函数类似

    七、let,with,run,apply,also函数区别

    通过以上几种函数的介绍,可以很方便优化kotlin中代码编写,整体看起来几个函数的作用很相似,但是各自又存在着不同。使用的场景有相同的地方比如run函数就是let和with的结合体。下面一张表格可以清晰对比出他们的不同之处。

    函数名 定义inline的结构 函数体内使用的对象 返回值 是否是扩展函数 适用的场景
    let fun <T, R> T.let(block: (T) -> R): R = block(this) it指代当前对象 闭包形式返回 适用于处理不为null的操作场景
    with fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block() this指代当前对象或者省略 闭包形式返回 适用于调用同一个类的多个方法时,可以省去类名重复,直接调用类的方法即可,经常用于Android中RecyclerView中onBinderViewHolder中,数据model的属性映射到UI上
    run fun <T, R> T.run(block: T.() -> R): R = block() this指代当前对象或者省略 闭包形式返回 适用于let,with函数任何场景。
    apply fun T.apply(block: T.() -> Unit): T { block(); return this } this指代当前对象或者省略 返回this 1、适用于run函数的任何场景,一般用于初始化一个对象实例的时候,操作对象属性,并最终返回这个对象。
    2、动态inflate出一个XML的View的时候需要给View绑定数据也会用到.
    3、一般可用于多个扩展函数链式调用
    4、数据model多层级包裹判空处理的问题
    also fun T.also(block: (T) -> Unit): T { block(this); return this } it指代当前对象 返回this 适用于let函数的任何场景,一般可用于多个扩展函数链式调用
    1

    欢迎关注Kotlin开发者联盟,这里有最新Kotlin技术文章,每周会不定期翻译一篇Kotlin国外技术文章。如果你也喜欢Kotlin,欢迎加入我们~~~

    Kotlin系列文章,欢迎查看:

    Kotlin邂逅设计模式系列:

    数据结构与算法系列:

    翻译系列:

    原创系列:

    Effective Kotlin翻译系列

    实战系列:

    展开全文
  • Android快速转战Kotlin教程

    万次阅读 多人点赞 2019-02-16 09:24:57
    kotlin是啥?这里就不用多说了,想必看这篇文章的童鞋肯定是有所了解的。 那么这篇文章你可以收获什么? 答:本文主要通过本人如何从java转战到kotlin并应用在实际项目中的个人经历,给大家提供一些学习思路、...

    前言

    kotlin是啥?这里就不用多说了,想必看这篇文章的童鞋肯定是有所了解的。

    那么这篇文章你可以收获什么?

    答:本文主要通过本人如何从java转战到kotlin并应用在实际项目中的个人经历,给大家提供一些学习思路、学习方法以及一些学习资料和个人总结。

    前提:你的项目(包含个人项目)即将开始用到kotlin(没有项目作为依托你会缺少十足的动力,而且缺少应用场景乘热打铁那也是白学)
    建议:建议没有切换kotlin的小伙伴快来转战kotlin吧!最近一段时间搞了kotlin之后发现写起来确实比java爽多了,语法非常精简,而且据统计现已有30%安卓项目使用了kotlin,所以小伙伴们行动起来吧,这必定是大势所趋,可千万别被淘汰了啊

    入门

    俗话说万事开头难,不过我们先把Kotlin语法学习一遍,你就会发现so easy,而且语言思想都是相通的

    第一步:学习语法

    当然是去官网学习喽:http://kotlinlang.org/docs/reference/

    如下图:

    不过英文吃力的小伙伴可以去菜鸟教程网站学习

    地址:http://www.runoob.com/kotlin/kotlin-tutorial.html

    如下图:

    内容与官网一致。

    不过不能光看,一定要写,就算照着抄也要多写,尽量在学习时候多和java语法做对比,会印象深刻。
    如下图,本人的练习代码:

    第二步:对比学习

    大家可以参考下面的链接进行学习:

    from-java-to-kotlin : https://github.com/MindorksOpenSource/from-java-to-kotlin

    from-java-to-kotlin中给出了我们常用的语法对比

    如图:

    第三步:Demo练习

    通过上面的学习我们此刻已经熟悉了kotlin的基本语法,可以来尝试写一个万年历的Demo。

    1、新建工程

    我们新建一个工程,点击Include kotlin support
    如图:

    我们看一下Include kotlin support都帮我们做了什么事情

    首先module中gradle文件

    如图:

    比我们之前的工程多了下面两个引用和一个依赖:

    // 使用Kotlin插件
    apply plugin: 'kotlin-android'
    // 使用Kotlin Android扩展插件
    apply plugin: 'kotlin-android-extensions'
    
    dependencies {
        //...
        //添加Kotlin 标准库
        compile "org.jetbrains.kotlin:kotlin-stdlib-jre7:$kotlin_version"
        //...
    }
    

    知识点: kotlin-android-extensions相当于DataBinding,同样的目的为了偷懒不用写findViewByIdAndroid 开发必备。

    我们再看一下project中的gradle文件
    如图:

    比我们之前的工程多了Kotlin编译插件:

    // 添加了Kotlin编译插件
    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    

    2、Demo说明

    该项目使用MVP模式,里面用到了Retrofit2+RxJava2,然后使用了聚合的万年历接口,Demo非常简单便于初学者快速掌握。

    Demo使用展示:

    工程目录结构如图:

    3、Activity

    看下布局文件非常简单,我们可以在activity里面直接将控件的id当成变量来使用

    <?xml version="1.0" encoding="utf-8"?>
    <android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
        ....">
    
        <DatePicker
            android:id="@+id/dataPicker"
            .... />
    
        <Button
            android:id="@+id/selectButton"
            .... />
    
        <TextView
            android:id="@+id/titleTextView"
            .... />
    
        <TextView
            android:id="@+id/contentTextView"
           ....
           />
    
    </android.support.constraint.ConstraintLayout>
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    
        selectButton.setOnClickListener {
            titleTextView.visibility = View.GONE
            selectButton.visibility = View.GONE
            contentTextView.visibility = View.GONE
            dataPicker.visibility = View.VISIBLE
        }
        ....
        ....
    }
    

    注意:直接使用id作为变量的时候,要在Module的gradle里面加入扩展,才能使用,不然会报错

    apply plugin: 'kotlin-android-extensions'
    

    这个上面已经说过,我们创建工程的时候如果选中Include kotlin support怎会自动在gradle中生成。

    4、Retrofit+RxJava

    Retrofit结合RxJava能快捷的使用网络请求。

    创建Service接口,Kotlin的类型是写在后面

    interface RetrofitService {
    
        /**
         *  获取当天详细信息
         *  @param date 日期
         */
        @GET("calendar/day")
        fun calenderDay(
                @Query("date") date: String,
                @Query("key") key: String
        ): Observable<CalentarDayBean>
    
        /**
         *  获取近期假期
         *  @param date 日期
         */
        @GET("calendar/month")
        fun calenderMonth(
                @Query("date") date: String
        ): Observable<CalentarMonthBean>
    
        /**
         *  获取当年假期列表
         *  @param date 日期
         */
        @GET("calendar/year")
        fun calenderYear(
                @Query("date") date: String
        ): Observable<CalentarYearBean>
    }
    
    

    创建Retrofit,Kotlin的class并不支持static变量,所以需要使用companion object来声明static变量,其实这个变量也不是真正的static变量,而是一个伴生对象

    伴生对象可以实现静态调用,通过类名.属性名或者类名.方法名进行调用

    class RetrofitUtil {
        companion object {
            /**
             * 创建Retrofit
             */
            fun create(url: String): Retrofit {
                //日志显示级别
                val level: HttpLoggingInterceptor.Level = HttpLoggingInterceptor.Level.BODY
                //新建log拦截器
                val loggingInterceptor: HttpLoggingInterceptor = HttpLoggingInterceptor(HttpLoggingInterceptor.Logger {
                    message -> Logger.e("OkHttp: " + message)
                })
                loggingInterceptor.level = level
                // okHttpClientBuilder
                val okHttpClientBuilder = OkHttpClient().newBuilder()
    
                okHttpClientBuilder.connectTimeout(60, TimeUnit.SECONDS)
                okHttpClientBuilder.readTimeout(10, TimeUnit.SECONDS)
                //OkHttp进行添加拦截器loggingInterceptor
                //okHttpClientBuilder.addInterceptor(loggingInterceptor)
    
                return Retrofit.Builder()
                        .baseUrl(url)
                        .client(okHttpClientBuilder.build())
                        .addConverterFactory(GsonConverterFactory.create())
                        .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                        .build()
            }
    
            val retrofitService: RetrofitService = RetrofitUtil.getService(Constants.REQUEST_BASE_URL, RetrofitService::class.java)
    
            /**
             * 获取ServiceApi
             */
            fun <T> getService(url: String, service: Class<T>): T {
                return create(url).create(service)
            }
        }
    }
    

    通过伴生对象,结合Retrofit结合RxJava 我们直接就可以调用接口了

    RetrofitUtil
        .retrofitService
        .calenderDay(date,"933dc930886c8c0717607f9f8bae0b48")
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe({ result ->
            view?.showDayCalentarData(result)
            Logger.e(result.toString())
        }, { error ->
            view?.showError(error.message.toString())
            Logger.e(error.message.toString())
        })
    

    5、使用对象声明

    在写项目的时候,一般会将常量统一写到一个类里面,然后设置静态变量,由于在Kotlin中不存在静态变量,所有就有对象声明的存在,对象声明比较常用的地方就是在这里,对象声明用Objcet关键字表示。

    object Constants {
    
        val REQUEST_BASE_URL = "http://v.juhe.cn/"
    
        val KEY = "1be865c0e67e3"
    }
    

    使用的时候直接类名加.加变量名,如Constants.REQUEST_BASE_URL

    6、使用数据类

    Kotlin有专门的数据类,就是用data修饰的类
    首先我们先看一下json数据:

    {
    	"reason":"Success",
    	"result":{
    		"data":{
    			"date":"2018-4-4",
    			"weekday":"星期三",
    			"animalsYear":"狗",
    			"suit":"订盟.纳采.冠笄.拆卸.修造.动土.安床.入殓.除服.成服.移柩.安葬.破土.启攒.造仓.",
    			"avoid":"作灶.开光.嫁娶.开市.入宅.",
    			"year-month":"2018-4",
    			"lunar":"二月十九",
    			"lunarYear":"戊戌年"
    		}
    	},
    	"error_code":0
    }
    

    再来看一下我的数据类:

    data class CalentarDayBean(
        val reason: String,
        val result: CalentarDayResult,
        val error_code: Int
    )
    
    data class CalentarDayResult(
            val data: CalentarDayData
    )
    
    data class CalentarDayData(
            val date: String,
            val weekday: String,
            val animalsYear: String,
            val suit: String,
            val avoid: String,
            val yearMonth: String,
            val holiday: String,
            val lunar: String,
            val lunarYear: String,
            val desc: String
    )
    

    就是如此方便

    7、MVP

    kotlin的MVP和java原理一模一样我先定义了IBaseModelIBaseView

    IBaseModel

    interface IBaseModel<T> {
    
        fun onDestroy()
    
        fun attachView(view: T)
    }
    

    IBaseView

    interface IBaseView {
    
        fun showLoading()
    
    
        fun hideLoading()
    
        fun showMessage(message: String)
    
        fun killMyself()
    }
    

    然后完成ICalentarContract,这个类似合同类的接口把P和V的所有方法全部写在一起,看起来代码格外清楚

    interface ICalentarContract {
        /**
         * 对于经常使用的关于UI的方法可以定义到IBaseView中,如显示隐藏进度条,和显示文字消息
         */
        interface View : IBaseView {
            fun showDayCalentarData(calentarDayBean: CalentarDayBean)
            fun showError(errorMsg: String)
        }
    
        /**
         * Model层定义接口,外部只需关心Model返回的数据,无需关心内部细节,如是否使用缓存
         */
        interface Model : IBaseModel<ICalentarContract.View> {
            fun getDayCalentarData(date: String)
        }
    }
    

    然后activity去实现ICalentarContract.View,presenter去实现ICalentarContract.Model

    class CalentarDatePresenter : ICalentarContract.Model {
    ....
    }
    
    class MainActivity : AppCompatActivity(), ICalentarContract.View {
    ...
    }
    

    so easy~~~ 到这里我们的Demo就完成了,可以尽情玩乐。

    项目地址:待上传。。。。。。。。。。。。。

    好了,到这里我们基本掌握了Kotlin在安卓中的应用,那么接下来就需要去学习一下kotlin设计模式以及一些进阶知识~

    进阶

    一、Kotlin设计模式

    本文只列出几个常用的设计模式

    1、观察者模式( observer pattern )

    Example

    interface TextChangedListener {
        fun onTextChanged(newText: String)
    }
    
    class PrintingTextChangedListener : TextChangedListener {
        override fun onTextChanged(newText: String) = println("Text is changed to: $newText")
    }
    
    class TextView {
    
        var listener: TextChangedListener? = null
    
        var text: String by Delegates.observable("") { prop, old, new ->
            listener?.onTextChanged(new)
        }
    }
    

    Usage

    val textView = TextView()
    textView.listener = PrintingTextChangedListener()
    textView.text = "Lorem ipsum"
    textView.text = "dolor sit amet"
    

    Output

    Text is changed to: Lorem ipsum
    Text is changed to: dolor sit amet
    

    2、策略模式( strategy pattern )

    Example

    class Printer(val stringFormatterStrategy: (String) -> String) {
        fun printString(string: String) = println(stringFormatterStrategy.invoke(string))
    }
    
    val lowerCaseFormatter: (String) -> String = { it.toLowerCase() }
    
    val upperCaseFormatter = { it: String -> it.toUpperCase() }
    

    Usage

    val lowerCasePrinter = Printer(lowerCaseFormatter)
    lowerCasePrinter.printString("LOREM ipsum DOLOR sit amet")
    
    val upperCasePrinter = Printer(upperCaseFormatter)
    upperCasePrinter.printString("LOREM ipsum DOLOR sit amet")
    
    val prefixPrinter = Printer({ "Prefix: " + it })
    prefixPrinter.printString("LOREM ipsum DOLOR sit amet")
    

    Output

    lorem ipsum dolor sit amet
    LOREM IPSUM DOLOR SIT AMET
    Prefix: LOREM ipsum DOLOR sit amet
    

    3、单例模式(singleton pattern)

    Example

    class Singletone private constructor() {
        init {
            println("Initializing with object: $this")
        }
    
        companion object {
            val getInstance =SingletonHolder.holder
        }
    
        private object SingletonHolder {
            val holder = Singletone()
        }
    
        fun print() = println("Printing with object: $this")
    }
    
    

    Usage

    Singletone.getInstance.print()
    Singletone.getInstance.print()
    

    Output

    Initializing with object: advance.Singletone@266474c2
    Printing with object: advance.Singletone@266474c2
    Printing with object: advance.Singletone@266474c2
    

    4、工厂模式(Factory Method)

    Example

    interface Currency {
        val code: String
    }
    
    class Euro(override val code: String = "EUR") : Currency
    class UnitedStatesDollar(override val code: String = "USD") : Currency
    
    enum class Country {
        UnitedStates, Spain, UK, Greece
    }
    
    class CurrencyFactory {
        fun currencyForCountry(country: Country): Currency? {
            when (country) {
                Country.Spain, Country.Greece -> return Euro()
                Country.UnitedStates          -> return UnitedStatesDollar()
                else                          -> return null
            }
        }
    }
    

    Usage

    val noCurrencyCode = "No Currency Code Available"
    
    val greeceCode = CurrencyFactory().currencyForCountry(Country.Greece)?.code() ?: noCurrencyCode
    println("Greece currency: $greeceCode")
    
    val usCode = CurrencyFactory().currencyForCountry(Country.UnitedStates)?.code() ?: noCurrencyCode
    println("US currency: $usCode")
    
    val ukCode = CurrencyFactory().currencyForCountry(Country.UK)?.code() ?: noCurrencyCode
    println("UK currency: $ukCode")
    

    Output

    Greece currency: EUR
    US currency: USD
    UK currency: No Currency Code Available
    

    5、代理模式(Protection Proxy)

    Example

    interface File {
        fun read(name: String)
    }
    
    class NormalFile : File {
        override fun read(name: String) = println("Reading file: $name")
    }
    
    //Proxy:
    class SecuredFile : File {
        val normalFile = NormalFile()
        var password: String = ""
    
        override fun read(name: String) {
            if (password == "secret") {
                println("Password is correct: $password")
                normalFile.read(name)
            } else {
                println("Incorrect password. Access denied!")
            }
        }
    }
    

    Usage

    val securedFile = SecuredFile()
    securedFile.read("readme.md")
    
    securedFile.password = "secret"
    securedFile.read("readme.md")
    

    Output

    Incorrect password. Access denied!
    Password is correct: secret
    Reading file: readme.md
    

    6、建造者模式(builder pattern)

    Example

    // Let's assume that Dialog class is provided by external library.
    // We have only access to Dialog public interface which cannot be changed.
    
    class Dialog() {
    
        fun showTitle() = println("showing title")
    
        fun setTitle(text: String) = println("setting title text $text")
    
        fun setTitleColor(color: String) = println("setting title color $color")
    
        fun showMessage() = println("showing message")
    
        fun setMessage(text: String) = println("setting message $text")
    
        fun setMessageColor(color: String) = println("setting message color $color")
    
        fun showImage(bitmapBytes: ByteArray) = println("showing image with size ${bitmapBytes.size}")
    
        fun show() = println("showing dialog $this")
    }
    
    //Builder:
    class DialogBuilder() {
        constructor(init: DialogBuilder.() -> Unit) : this() {
            init()
        }
    
        private var titleHolder: TextView? = null
        private var messageHolder: TextView? = null
        private var imageHolder: File? = null
    
        fun title(init: TextView.() -> Unit) {
            titleHolder = TextView().apply { init() }
        }
    
        fun message(init: TextView.() -> Unit) {
            messageHolder = TextView().apply { init() }
        }
    
        fun image(init: () -> File) {
            imageHolder = init()
        }
    
        fun build(): Dialog {
            val dialog = Dialog()
    
            titleHolder?.apply {
                dialog.setTitle(text)
                dialog.setTitleColor(color)
                dialog.showTitle()
            }
    
            messageHolder?.apply {
                dialog.setMessage(text)
                dialog.setMessageColor(color)
                dialog.showMessage()
            }
    
            imageHolder?.apply {
                dialog.showImage(readBytes())
            }
    
            return dialog
        }
    
        class TextView {
            var text: String = ""
            var color: String = "#00000"
        }
    }
    

    Usage

    //Function that creates dialog builder and builds Dialog
    fun dialog(init: DialogBuilder.() -> Unit): Dialog {
        return DialogBuilder(init).build()
    }
    
    val dialog: Dialog = dialog {
    	title {
        	text = "Dialog Title"
        }
        message {
            text = "Dialog Message"
            color = "#333333"
        }
        image {
            File.createTempFile("image", "jpg")
        }
    }
    
    dialog.show()
    

    Output

    setting title text Dialog Title
    setting title color #00000
    showing title
    setting message Dialog Message
    setting message color #333333
    showing message
    showing image with size 0
    showing dialog Dialog@5f184fc6
    

    2、相关书籍

    个人认为还是需要找一本书籍好好地阅读一遍,一下提供了相关书籍可以选择适合自己的。

    NO.1

    《Kotlin for Android Developers》

    Kotlin是编写Android应用程序的新官方语言,多亏了这本书,你很快就能写出代码。直奔主题,实用和完整的例子,它将在开发Android应用程序的同时展示你的语言。学习Kotlin并开始使用这个强大而现代的语言再次享受Android开发。

    NO.2

    《Kotlin开发快速入门与实战》

    学习本书之前不需要具备任何的计算机专业背景,任何有志于APP开发的读者都能利用本书从头学起。

    资深软件开发工程师根据Kotlin最新版本撰写,系统讲解Kotlin开发技巧和项目实战。全书共分为7章,内容层次清晰,难度循序渐进。希望通过阅读本书,能够让你成为一个全栈工程师。

    NO.3

    《疯狂Kotlin讲义》

    本书尤其适合从Java转Kotlin的读者,对于没有Java功底的读者,可忽略“对比”部分,直接学习本书也可掌握Kotlin编程。

    本书对Kotlin的解读十分系统、全面,超过Kotlin官方文档本身覆盖的内容。本书很多地方都会结合Java字节码进行深入解读,比如对Kotlin扩展的解读,对Kotlin主、次构造器的解读,这种解读目的不止于教会读者简单地掌握Kotlin的用法,而是力求让读者深入理解Kotlin,且更好地理解Java。

    NO.4

    《Kotlin实战》

    本书主要面向有一定Java 经验的开发者。

    本书将从语言的基本特性开始,逐渐覆盖其更多的高级特性,尤其注重讲解如何将 Koltin 集成到已有 Java 工程实践及其背后的原理。本书分为两个部分。第一部分讲解如何开始使用 Kotlin 现有的库和API,包括基本语法、扩展函数和扩展属性、数据类和伴生对象、lambda 表达式,以及数据类型系统(着重讲解了可空性和集合的概念)。第二部分教你如何使用 Kotlin 构建自己的 API,以及一些深层次特性——约定和委托属性、高阶函数、泛型、注解和反射,以及领域特定语言的构建。

    本书适合广大移动开发者及入门学习者,尤其是紧跟主流趋势的前沿探索者。

    NO.5

    《揭秘Kotlin编程原理》

    本书深入介绍Kotlin面向对象设计的语法特性及其背后的实现方式。

    在本书中,读者不仅能清晰地了解Kotlin的语法、高级特性,还能真正地掌握Kotlin背后的实现机制和设计哲学,形成对Kotlin语言既直观、又深刻的认识——在此基础上,读者能准确、快速地上手实践,大大提升自己的移动开发能力。

    Kotlin的这些特性和实现机制,可以帮助开发者扫清开发道路上的一些障碍,让开发变得更加简单!本书是一本值得拥有,能切实帮助读者加薪提职的好书!

    项目

    学习一门语言最快的方式就是看其如何在实际项目中运用,有了上面的基础和进阶,下面我们看一些开源项目:

    1.Kotlin-for-Android-Developers(★1676)

    介绍:这个项目其实是Kotlin-for-Android-Developers这本书的配套代码,如果你是kotlin的初学者,那么这绝对是你学习kotlin的不二之选。项目通过一个天气的例子很好的展示了kotlin带来的强大功能,比如网络数据的请求,数据的缓存设计,数据库的操作,各种扩展函数的妙用等等。

    地址:https://github.com/antoniolg/Kotlin-for-Android-Developers

    2.Bandhook-Kotlin (★1494)

    介绍:Kotlin版本的音乐播放器,数据来源于LastFm。

    地址:https://github.com/antoniolg/Bandhook-Kotlin

    3.GankClient-Kotlin (★1216)

    介绍:gank.io kotlin实现的干货集中营Android客户端,风格采用了Material Design。

    地址:https://github.com/githubwing/GankClient-Kotlin

    4.PoiShuhui-Kotlin(★897)

    介绍:一个用Kotlin写的简单漫画APP。

    地址:https://github.com/wuapnjie/PoiShuhui-Kotlin

    5.Eyepetizer-in-Kotlin(★1167)

    介绍:Kotlin版本的Eyepetizer客户端

    地址:https://github.com/LRH1993/Eyepetizer-in-Kotlin

    6.Tucao(★792)

    介绍:Kotlin版本的吐槽客户端

    地址:https://github.com/blackbbc/Tucao

    资源

    一、重要资源

    Kotlin 官网

    https://kotlinlang.org/docs/reference/

    Kotlin 官方网站是学习 Kotlin 好去处。在参考部分,你可以找到该语言的所有概念和功能的深入解析文档。在教程部分有关于设置工作环境并使用编译器的实用分步指南。

    这里还有个 Kotlin 编译器,是一个浏览器 APP,你可以在上面尝试使用这门语言。它能加载许多示例,包括 Koans 课程 — 这是目前熟悉 Kotlin 语法的最好方式。

    Kotlin 官博

    https://blog.jetbrains.com/kotlin/

    Kotlin 的官方博客由 JetBrains 的一位作者负责。你可以在这里找到所有与 Kotlin 相关的新闻、更新、教程、使用技巧等的内容。

    在 Android 上开始使用 Kotlin

    https://developer.android.com/kotlin/get-started.html

    一篇很牛叉的文章,向我们展示了如何使用 Kotlin 编写和运行 Android 应用程序的测试

    从 Java 到 Kotlin

    https://github.com/MindorksOpenSource/from-java-to-kotlin

    实用的快速提醒列表工具包含了一些简短的代码块,藉由这个来帮助你快速找到通用 Java 操作符、功能以及声明的 Kotlin 替代方案。

    Kotlin 教学插件

    https://blog.jetbrains.com/kotlin/2016/03/kotlin-educational-plugin/

    用于 IntelliJ IDEa 的插件,可让你在本地离线环境下使用 Koans 课程。

    Kotlin on GitHub

    https://github.com/jetbrains/kotlin

    Kotlin 于 2012 年开源,你可以对该语言进行贡献。

    Kotlin Android 模板

    https://github.com/nekocode/Kotlin-Android-Template

    Android 项目模板,使其非常容易设置稳定的 Kotlin 工作区,并快速引导你开发应用程序。

    不可错过的 Kotlin 资源列表

    https://github.com/KotlinBy/awesome-kotlin

    这是一个比较完整的 Kotlin 资源列表,包括各种实用链接、书籍、库、框架和视频等。该列表的组织结构非常好,kotlin.link 也提供了一个风格化的版本。

    kotlin设计模式

    https://github.com/dbacinski/Design-Patterns-In-Kotlin

    DariuszBaciński 创建了一个 GitHub repo,其中有在 Kotlin 中实现的常见设计模式,也有用其他语言编写的类似项目,包括 Java,Swift,Java 和 PHP,如果你是其中一项语言的使用者,可以用它们作为参考点。

    二、视频资源

    Kotlin 介绍

    https://www.youtube.com/watch?v=X1RVYt2QKQE

    来自 Google I / O 2017 的演讲,大会首次向人们介绍 Kotlin,并提出了改进工作流程的想法。它涵盖了许多基础知识,并展示了一些很酷的 Kotlin 技巧。

    明日胜于今,我用 Kotlin

    https://www.youtube.com/watch?v=fPzxfeDJDzY

    Google I / O 2017 大会关于 Kotlin 的第二个演讲。这个演讲涵盖了更多高级话题,如设计模式,最佳实践和其他常见规则。 演讲也揭示了在生产中使用 Kotlin 的意义,以及在工作中采用新兴语言将面临的挑战。

    Peter Sommerhoff 教你学 Kotlin

    https://www.youtube.com/playlist?list=PLpg00ti3ApRweIhdOI4VCFFStx4uXC__u

    这是一个免费的 Kotlin 课程,适合初学者,前面介绍了从变量到条件循环和函数的所有基础知识,后面会深入到更高级的主题,如 Kotlin 中的面向对象以及像 lambda 表达式的功能编程。

    使用 Kotlin&Gradle 更好地开发 Android

    https://www.youtube.com/watch?v=_DaZQ374Chc

    这个讲座从 2016 年开始,它介绍了现实世界中的编程语言功能,你将了解到 Kotlin 是如何适应 Android 工作流程中存在的工具。

    使用 Kotlin&Gradle 更好地开发 Android

    https://www.youtube.com/watch?v=ZlQhmkp_jyk

    一个 8 分钟的浓缩教程,让你快速了解 Kotlin 的主要功能,如变量声明、Lambdas、扩展功能等等。

    Jake Wharton:用 Kotlin 进行 Android 开发

    https://www.youtube.com/watch?v=A2LukgT2mKc&t

    关于 Kotlin 的介绍,演讲向我们解释了新语言是如何改进 Android 生态系统的,并展示了许多炫酷的方式,我们可以使用智能的 Kotlin 语法来获得优势。

    扫码关注公众号“伟大程序猿的诞生“,更多干货新鲜文章等着你~

    公众号回复“资料获取”,获取更多干货哦~

    有问题添加本人微信号“fenghuokeji996” 或扫描博客导航栏本人二维码

    我的博客即将同步至腾讯云+社区,邀请大家一同入驻:
    https://cloud.tencent.com/developer/support-plan?invite_code=ncnq0hloo5yw

    展开全文
  • kotlin委托

    千次阅读 2019-07-30 23:43:12
    kotlin
  • android:Kotlin Java Kotlin android Kotlin

    千次阅读 2015-10-12 19:02:26
    Kotlin Java Kotlin android Kotlin
  • kotlin密封类

    千次阅读 2019-07-30 23:41:15
    kotlin
  • Kotlin与java混合

    千次阅读 2019-07-30 23:46:39
    kotlin
  • kotlin基础-学习

    千次阅读 2019-07-30 23:37:12
    kotlin
  • 【接下来一段时间会学习Kotlin,接下来的博客也是跟Kotlin相关的。因此,把去年的博客提到最上面吧。】Kotlin出来也有几年时间了,虽然对java的很多地方不满意,但是,总是不想去接触一门新的语言。原因一个是没时间...
  • down votefavorite I solve this problem by 2 steps next: 1- dependencies { ...compile "org.jetbrains.kotlin:kotlin-stdlib:1.2.21" } Change the version ofstdlibfor your versio
  • Kotlin开发者社区 【Kotlin 极简教程】 Kotlin 简介 Kotlin是一门非研究性的语言,它是一门非常务实的工业级编程语言,它的使命就是帮助程序员们解决实际工程实践中的问题。使用Kotlin 让 Java程序员们的生活变得...
  • 这一篇我们开始Kotlin代码之旅,一步步入门Kotlin。 一、Kotlin开发工具 Kotlin语言在开发之初,它的语言和插件工具是同步开发的。 这里推荐IntelliJ IDEA15及以上,IDEA这款开发工具可以说是获得好多程序猿的...
  • Kotlin 学习

    2019-09-08 20:57:02
    Kotlin 中文站 Kotlin 教程 Kotlin从入门到进阶 分享一个 Kotlin 学习方式 Kotlin概述 Kotlin开发环境搭建 10分钟入门Kotlin Kotlin最佳实践 Kotlin基础语法大全 Kotlin PK Java ,如何去提高生产力? ...
  • Kotlin系列之Kotlin简介

    2018-01-01 17:38:43
    从今天开始,我将陆续分享一系列Kotlin相关的文章,希望可以借此来促使自己学习一门新的语言。
  • Kotlin/JVM 可以看做是对改进Java的一种积极的尝试,其试图改进Java的已知的被广泛讨论的缺点。 关于Kotlin与Java的爱恨情仇此处按下不表,等有机会单独写一篇相关文章。此文仅从Java惯用者的角度给出使用Kotlin的...
  • Kotlin:Outdated Kotlin Runtime问题修复

    千次阅读 2018-04-05 20:52:03
    一、今天在kotlin开发的时候,遇见了一个问题,在打开IDEA的时候,Kolin自动弹出来了一个 Outdated Kotlin Runtime框 二、内容是这样的 Your version of Kotlin runtime in 'Gradle: org.jetbrains.kotlin:...
  • Kotlin学习

    2015-09-30 18:01:23
    Kotlin 学习
  • Kotlin学习系列之:Kotlin的构造函数

    万次阅读 多人点赞 2018-03-01 15:09:18
    Kotlin的构造函数分为主构造器(primary constructor)和次级构造器(secondary constructor)。下面我们来看看他们的写法。 一、 Primary Constructor 1. 写法一: class 类名 constructor(形参1, 形参2, 形参3)...
  • Kotlin Unresolved reference: 解决办法

    万次阅读 热门讨论 2018-01-05 16:42:20
    kotlin Unresolved reference:错误的解决办法
  • Kotlin 集合

    千次阅读 2018-06-05 10:30:58
    Kotlin 集合 Kotlin 集合 kotlin 集合-接口架构 Kotlin 集合-抽象实现类 kotlin List工具类 - Collections Kotlin Map 工具类- Maps Kotlin Set 工具类 - Sets _Collections List 相关高阶函数 更多高阶函数 ...
  • Kotlin历史

    千次阅读 2019-08-23 10:22:17
    Kotlin 1.3 1.3.5 Kotlin 1.3.50 发布,新一代安卓开发语言 设计了一个新的持续时间和时间测量 API(预览功能)。 改进 Java-to-Kotlin 转换器。 Gradle Kotlin/JS 项目中生成 npm 依赖项的外部声明(使用 Dukat,...
  • kotlin扩展--学习

    千次阅读 2019-07-30 23:38:58
    kotlin
  • Kotlin反射

    千次阅读 2019-08-02 19:39:19
    Kotlin中我们有两种方式来实现反射的功能。一种是调用Java的反射包 java.lang.reflect 下面的API,另外一种就是直接调用Kotlinkotlin.reflect 包下面的API。不过Kotlin把包的实现放到了单独的kotlin-reflect-...
  • 如何使用Kotlin Scope 方法及takeIf/takeUnless StardardKt类提供以下几个常用的方法 5个scope方法 +2个方法 let run apply also with takeIf/takeUnless ( StardardKt) 什么是 scope functions? The Kotlin ...
  • kotlin面试Kotlin is the latest JVM programming language from the JetBrains. Google has made it the official language for Android Development along with Java. Developers say it addresses the issues ...
  • kotlin泛型--学习

    2019-07-30 23:40:05
    kotlin
  • Kotlin简介

    千次阅读 2017-04-06 17:00:53
    Kotlin 是什么?Kotlin是JetBrains开发的针对JVM、Android 和浏览器的静态编程语言。JetBrains,作为目前广受欢迎的 Java IDE IntelliJ IDEA 的开发商,在 Apache 许可下已经开源其Kotlin 编程语言。JetBrains 作为...

空空如也

1 2 3 4 5 ... 20
收藏数 60,571
精华内容 24,228
关键字:

kotlin