精华内容
下载资源
问答
  • 实际上,通过本项目精心设计的场景和精简的代码,你可以Swift了解到在约会了Jetpack的项目中“到底写了什么” ,以及Kotlin相较Java写法的差异之所在, 在简单感受一下项目源码后,如你开始对“具体该怎么写”,“为...
  • JavaKotlinJavaKotlin-JavaKotlin的备忘单 打印到控制台 Java System . out . print( " Amit Shekhar " ); System . out . println( " Amit Shekhar " ); Kotlin print ( " Amit Shekhar " ) println ...
  • JavaKotlinJavaKotlin-JavaKotlin的备忘单 打印到控制台 Java System . out . print( " Amit Shekhar " ); System . out . println( " Amit Shekhar " ); Kotlin print ( " Amit Shekhar " ) println ...
  • java-kotlin-spring-demo 该项目用于展示JavaKotlin如何在同一个项目中相遇的旅程。 该项目不仅包括最终解决方案,还包括如何逐步解决每个步骤/提交中的中间问题。 要查看有关该项目如何进行的完整说明以及每次...
  • Kotlin 的设计过程中就...在 Kotlin 中可以直接调用既有的 Java 代码, 反过来在 Java 中也可以很流畅地使用 Kotlin 代码,下面这篇文章主要给大家介绍了关于kotlinJava的相互调用的相关资料,需要的朋友可以参考下。
  • 1、java转成kotlin 方法1:快捷键:Ctrl+Shift+Alt+K 方法2:Code – Convert Java File To Kotlin File 2、kotlin转成java 1.Tools>Kotlin>Show Kotlin Bytecode 2.点击 Decompile 补充知识:Android Studio ...
  • 主要给大家介绍了关于在JavaKotlin之间如何进行互操作的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • JavaKotlin备忘单 页面: : 灵感来自于“ 编程灵感,视觉灵感来自“ 执照 麻省理工学院 开发 npm i # install dependencies to build tools ./make.coffee dev # build html HTML是从cirru/index.cirru , ...
  • java调用kotlin

    千次阅读 2021-02-04 16:24:49
    java调用kotlinJava代码中,可以轻松的调用Kotlin,无缝对接,然而两者之间有一些不同的地方需要注意。 属性 一个kotlin属性会编译成下面java元素: getter setter private field 例如var firstName: String会...

    java调用kotlin

    在Java代码中,可以轻松的调用Kotlin,无缝对接,然而两者之间有一些不同的地方需要注意。

    属性

    一个kotlin属性会编译成下面java元素:

    • getter
    • setter
    • private field

    例如var firstName: String会被编译成下面这样:

    private String firstName;
    
    public String getFirstName() {
        return firstName;
    }
    
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
    

    如果属性名以is开头,setter方法名会将属性中的is替换为set,getter方法名与属性名相同,例如var isOpen: Boolean被会编译成下面这样:

    private boolean isOpen;
    
    public final boolean isOpen() {
      return this.isOpen;
    }
    
    public final void setOpen(boolean isOpen) {
      this.isOpen = isOpen;
    }
    

    注意这个规则与属性名有关,而不仅仅是与boolean类型有关。

    包级别的函数

    kotlin中的函数和属性可以直接定义在最外层,不必包含在一个Class中,那么编译后kotlin会自动生成Class类。

    // Demo2.kt
    package com.morris.kotlin.interop.javacallkotlin
    
    fun method() {}
    
    var name: String = "name"
    

    最后生成的class文件如下:

    // Demo2Kt.class
    package com.morris.kotlin.interop.javacallkotlin;
    
    import kotlin.Metadata;
    import kotlin.jvm.internal.Intrinsics;
    import org.jetbrains.annotations.NotNull;
    
    @Metadata(mv = {1, 4, 0}, bv = {1, 0, 3}, k = 2, d1 = {"\000\020\n\000\n\002\020\016\n\002\b\005\n\002\020\002\n\000\032\006\020\006\032\0020\007\"\032\020\000\032\0020\001X\016\006\016\n\000\032\004\b\002\020\003\"\004\b\004\020\005\006\b"}, d2 = {"name", "", "getName", "()Ljava/lang/String;", "setName", "(Ljava/lang/String;)V", "method", "", "untitled"})
    public final class Demo2Kt {
      public static final void method() {}
      
      @NotNull
      private static String name = "name";
      
      @NotNull
      public static final String getName() {
        return name;
      }
      
      public static final void setName(@NotNull String <set-?>) {
        Intrinsics.checkNotNullParameter(<set-?>, "<set-?>");
        name = <set-?>;
      }
    }
    

    顶层的属性和方法在生成的类中都是static的。

    可以使用@JvmName来指定生成的class文件的名称,需要放在文件的第一行。

    @file: JvmName("Demo2")
    package com.morris.kotlin.interop.javacallkotlin
    
    fun method() {}
    
    var name: String = "name"
    

    一般来说,JvmName()中指定的名字+包名必须是唯一的,但是kotlin支持将多个kotlin文件中的属性和方法打包放到一个class中:

    // Util1.kt
    @file: JvmName("Util")
    @file: JvmMultifileClass
    package com.morris.kotlin.interop.javacallkotlin
    
    fun getTime() {}
    
    // Util2.kt
    @file: JvmName("Util")
    @file: JvmMultifileClass
    package com.morris.kotlin.interop.javacallkotlin
    
    fun getDate() {}
    

    最后生成的class文件如下:

    package com.morris.kotlin.interop.javacallkotlin;
    
    import kotlin.Metadata;
    
    @Metadata(mv = {1, 4, 0}, bv = {1, 0, 3}, k = 4, d1 = {"com/morris/kotlin/interop/javacallkotlin/Util__Util1Kt", "com/morris/kotlin/interop/javacallkotlin/Util__Util2Kt"})
    public final class Util {
      public static final void getDate() {
        Util__Util2Kt.getDate();
      }
      
      public static final void getTime() {
        Util__Util1Kt.getTime();
      }
    }
    

    实例字段

    可以使用@JvmField将属性作为一个public的字段暴露给java,而不是通过setter和getter访问。

    class User(id: String) {
        @JvmField val ID = id
    }
    

    这样生成的class会有个public的字段,而没有setter和getter方法。

    public final class User {
      @JvmField
      @NotNull
      public final String ID;
      
      public User(@NotNull String id) {
        this.ID = id;
      }
    }
    

    静态字段

    使用@JvmField注解一个伴生对象的属性,那么这个属性就会成为外部类的一个静态属性:

    class Key(val value: Int) {
        companion object {
            @JvmField
            val COMPARATOR: Comparator<Key> = compareBy<Key> { it.value }
        }
    }
    

    在java中如下使用:

    // Java
    Key.COMPARATOR.compare(key1, key2);
    // public static final field in Key class
    

    对象声明或者伴生对象中的lateinit修饰的属性会成为类的静态属性:

    object Singleton {
        lateinit var provider: Provider
    }
    

    在java中如下使用:

    // Java
    Singleton.provider = new Provider();
    // public static non-final field in Singleton class
    

    const修饰的属性也会成为静态属性:

    // file example.kt
    
    object Obj {
        const val CONST = 1
    }
    
    class C {
        companion object {
            const val VERSION = 9
        }
    }
    
    const val MAX = 239
    

    在java中如下使用:

    int const = Obj.CONST;
    int max = ExampleKt.MAX;
    int version = C.VERSION;
    

    静态方法

    跟属性一样,顶级的函数是静态的方法。

    kotlin也支持使用@JvmStatic注解为定义在命名对象或派生对象中的方法生成静态方法:

    class C {
        companion object {
            @JvmStatic fun callStatic() {}
            fun callNonStatic() {}
        }
    }
    

    在java中如下使用:

    C.callStatic(); // works fine
    C.callNonStatic(); // error: not a static method
    C.Companion.callStatic(); // instance method remains
    C.Companion.callNonStatic(); // the only way it works
    

    重载方法的生成

    kotlin支持默认参数,而java中没有这个特性,可以使用@JvmOverloads注解暴露多个方法供java调用:

    class Circle @JvmOverloads constructor(centerX: Int, centerY: Int, radius: Double = 1.0) {
        @JvmOverloads fun draw(label: String, lineWidth: Int = 1, color: String = "red") { /*...*/ }
    }
    

    在java中如下使用:

    // Constructors:
    Circle(int centerX, int centerY, double radius)
    Circle(int centerX, int centerY)
    
    // Methods
    void draw(String label, int lineWidth, String color) { }
    void draw(String label, int lineWidth) { }
    void draw(String label) { }
    
    展开全文
  • KotlinJava Java是一种通用的,面向对象的编程语言。 Java程序或应用程序将在JVM( Java虚拟机 )中执行。 它是一种独立的编程语言,可让您在所有支持Java的平台上运行相同的代码。 Kotlin是一种开放源代码,...

    Kotlin与Java

    Java是一种通用的,面向对象的编程语言。 Java程序或应用程序将在JVM( Java虚拟机 )中执行。 它是一种独立的编程语言,可让您在所有支持Java的平台上运行相同的代码。 Kotlin是一种开放源代码,通用,静态类型的编程语言。 它结合了面向JVM和Android的面向对象和功能性编程功能。 它对开发服务器端应用程序更有用,并且允许用户编写简短而有意义的代码。

    什么是Java?

    Java是基于对象的编程语言,于1995年首次引入。它是在sun microsystems上开发的,后来由Oracle Corporation生产。 需要使用Java applet在浏览器上执行程序,并且它通常用于独立应用程序或后端开发。 它是James Gosling发明的,其主要实现是OpenJDK。 Java是Android应用程序开发的主要选择,因为Android也是用Java编写的。

    什么是Kotlin?

    Kotlin是由JetBrains开发的一种开源新编程语言。 它针对JavaScript,JVM,Native和Android。 该项目于2010年开始,于2011年首次出现,并于2016年2月正式宣布。它也是一种基于Java虚拟机(JVM)的静态类型语言,如C ++和Java 。 从Java切换到Kotlin非常容易,因为我们只需要安装插件即可。 Kotlin正式宣布支持Android应用程序开发。

    Java和Kotlin之间的区别:

    编号 Java和Kotlin的比较基础 Java Kotlin
    1个 扩展功能 为了增强Java中当前类的功能,需要创建一个新类并派生父类。 这就是Java中不存在扩展功能的原因。 Kotlin允许开发人员使用新功能增强现有的类。 它通过在类名之前添加新函数的名称来提供创建增强功能的功能。
    2 空安全 NullPointerException是运行时异常,它使Java开发人员感到沮丧。 它允许用户为对象引用分配空值,并且在程序尝试使用具有空值的对象引用时将引发该空值。 默认情况下,各种变量在Kotlin中都不为null,这意味着我们不能为任何类型的变量定义null值。 如果有人试图给Kotlin中的变量赋值或返回空值,则代码将在编译时失败。 在Kotlin中,将空值分配给任何变量的正确方法是:
    值个数:整数? =空
    3 协程支持 协程在Java中通常称为轻量级线程。 如果我们启动了长时间运行的网络或CPU紧凑型操作,则相关线程将被阻塞。 Java提供了在后台创建和运行多个线程的功能,但是要管理它是一项艰巨的任务。 Kotlin允许您创建多个线程来运行这些长时间运行的紧凑操作。 但是您有协程支持,它将在特定点终止执行而不会阻塞其他线程。
    4 资料类别 在Java中,如果我们需要一个类,该类要求仅保存数据而没有其他内容。 因此,我们需要声明变量以存储数据, 构造函数 ,hashcode(),toString(),getter和setter方法以及equals()函数。 在Kotlin中,假设我们需要一个只需要保存数据的类,因此我们必须在类定义中声明一个带有关键字“ data”的类。 编译器将自动处理所有事情,例如创建构造函数,hashcode(),getter和setter方法等。
    5 检查异常 Java具有支持检查的异常的能力,这可以帮助开发人员尝试捕获异常,从而通过良好的错误处理最终生成强大的代码。 Kotlin不支持检查的异常。 这就是为什么无需捕获任何异常的原因。
    6 类型推断 在Java中声明时,需要定义每个变量的类型。 在Kotlin中,不需要定义每个变量的类型,它将处理基于的分配。 但是,如果您想定义变量的类型,则可以使用它来完成。
    7 静态成员 静态成员定义为属于一个类,并且可以在不启动该类的情况下进行访问。 Java允许使用static关键字创建静态方法。 您可以通过类名称访问它。 Kotlin不允许您为类创建静态成员。 但是,如果您在类中声明一个friend对象,则Kotlin对象可以处理此问题,还可以使用Java之类的类名称来访问其成员。
    8 智能班 在Java中,必须检查变量的类型并相应地强制转换对象。 Kotlin具有智能转换功能,该功能可通过“ is-check”关键字处理这些转换检查。
    9 功能编程 Java不支持功能性编程语言。 但是在开发Android应用程序时,它仅支持带有lambda表达式的功能编程。 Kotlin是过程语言和函数式编程语言的结合,它涉及不同类型的方法,例如运算符重载,lambda,惰性求值和高阶函数等。
    10 非私人领域 Java支持非私有字段功能。 在对象的调用者想要更改其表示形式的脚本中,此功能很有用。 Kotlin不提供非私有字段的功能。
    11 内联功能 Java不提供内联函数; 它通常是在执行时由Java虚拟机完成的。 Kotlin支持内联功能。 所有功能都是Kotlin中的一个对象,它捕获一个闭包。

    From: https://dev.to/javatpoint/kotlin-vs-java-10-difference-between-java-and-kotlin-30ld

    展开全文
  • Java 调用 Kotlin

    千次阅读 2018-07-12 18:12:29
    KotlinJava 的互操作性是 Kotlin 的一大优点,Kotlin 调用 Java 已经基本不需要特别去注意什么了,但是 Java 调用 Kotlin 代码就不那么好看了。项目切换到 Kotlin 的过程中总会有两种语言交错的时候,最近切换 ...

    Kotlin 和 Java 的互操作性是 Kotlin 的一大优点,Kotlin 调用 Java 已经基本不需要特别去注意什么了,但是 Java 调用 Kotlin 代码就不那么好看了。项目切换到 Kotlin 的过程中总会有两种语言交错的时候,最近切换 Kotlin 的第一版就要上线了,就先总结一下已经遇到的 Java 调用 Kotlin 的特殊姿势。

    不一样的protected

    • Kotlin 继承 Java 时,可以直接拿到 protected 属性
    • Kotlin 继承 Kotlin 时也一样
    • 但是 Java 继承 Kotlin 时,需要用 getter 和 setter 操作 protected 属性
    • 举个例子

    [基类定义]

     

     

    [Java 中使用]

     

     

    • 如果在 Kotlin 父类中是用 lazy 声明的 protected 属性,在 Java 中获取还要加上getValue()(在 Kotlin 中对应 .value)

    ps:使用@JvmField注解可以获得和Kotlin一样的体验

    取代static的Companion

    • Kotlin 中没有了 static 关键字,常量可以使用 伴生对象(companion object) 处理
    • 对于绝对的常量,可以使用 const 关键字,此时在 Java 中和在 Kotlin 中的调用方式是一样的。const 只适用于直接初始化为一个 value 的情况。
    • 没有 const 修饰的话,Java 中需要使用 getter 来获取

    [常量定义]

     

     

    [Kotlin 使用]

     

     

    [Java 使用]

     

    ps:可以使用@JvmStatic获得一样的体验

    扩展函数和顶层函数(Any的扩展函数)

    这两个都是 Kotlin 的特性,在 Kotlin 中调用就是如丝般顺滑,但是在 Java 中调用还是普通的静态方法,类名是所在文件名加Kt:

    [函数定义]

     

     

    [Kotlin 使用]

     

     

    [Java 使用]

     

     

    还原lambda

    Kotlin 支持函数对象,可以将 lambda 作为函数的参数和返回值,这也是 Java 中没有的特性,于是在 Java 中调用这类方法,就会变成匿名内部类(类名就叫 FunctionX, X是数字,表示参数数量):

    [定义一个接收 lambda 的函数]

     

     

    [Kotlin 使用]

     

    [Java 使用]

     

     

    invoke 方法就是 lambda 的内容函数了,这也证明了 Kotlin 中 lambda 的实现方式还是定义了一个接口(我记得方法也是一个对象,应该不是一个接口)。使用 lambda 时需要考虑额外的性能开销,尽量使用 inline 优化性能。

    ps:我测试了一下,函数的最后一个泛型是返回值的类型

    总结

    Java 调用 Kotlin 并不是特别常用,毕竟我相信用过 Kotlin 之后,就不会想要使用 Java 了。这次情况特殊,在 Kotlin 的新项目中引入了一些过去的 Java Activity,真是没有对比就没有伤害啊。


    原文链接:https://juejin.im/post/5adda4b35188256712782274

    展开全文
  • 适用于JavaKotlin的AppGameKit 现在,您可以利用JavaKotlin的灵活性来利用App Game Kit的功能。 Java / Kotlin由于简单但非常强大且用途广泛的语法而提供了Tier 1的完美替代方案。 这里,只有少数一些面向对象...
  • 比较javakotlin

    千次阅读 2018-07-19 13:47:23
    在2018年的冬天,每天与Kotlin相伴的几个月后,我们总结出了正反两面。这有几个原因: 名称遮蔽 类型推断 编译时空指针安全 类文字 反向类型声明 伴侣对象 集合文字 也许? ...

    在2018年的冬天,每天与Kotlin相伴的几个月后,我们总结出了正反两面。这有几个原因:

     

    名称遮掩

    这是Kotlin让我感到最大惊喜的地方。看看这个函数:

    fun inc(num : Int) {
        val num = 2
        if (num > 0) {
            val num = 3
        }
        println ("num: " + num)
    }

    当你调用inc(1)的时候会输出什么呢?在Kotlin中方法参数是一个值,所以你不能改变num参数。这是好的语言设计,因为你不应该改变方法的参数。但是你可以用相同的名称定义另一个变量,并按照你想要的方式初始化。现在,在这个方法级别的范围中你拥有两个叫做num的变量。当然,同一时间你只能访问其中一个num,所以num的值会改变。将军,无解了。

    在if主体中,你可以添加另一个num,这并不令人震惊(新的块级别作用域)。

    好的,在Kotlin中,inc(1)输出2。但是在Java中,等效代码将无法通过编译。

    void inc(int num) {
        int num = 2; //error: variable 'num' is already defined in the scope
        if (num > 0) {
            int num = 3; //error: variable 'num' is already defined in the scope
        }
        System.out.println ("num: " + num);
    }

    名称遮蔽不是Kotlin发明的。这在编程语言中着很常见。在Java中,我们习惯用方法参数来遮蔽类中的字段。

    public class Shadow {
        int val;
    
        public Shadow(int val) {
            this.val = val;
        }
    }

    在Kotlin中,遮蔽有点过分了。当然,这是Kotlin团队的一个设计缺陷。IDEA团队试图把每一个遮蔽变量都通过简洁的警告来向你展示,以此修复这个问题:Name shadowed。两个团队都在同一家公司工作,所以或许他们可以相互交流并在遮蔽问题上达成一致共识?我感觉——IDEA是对的。我无法想象存在这种遮蔽了方法参数的有效用例。

     

    类型推断

    在Kotlin中,当你申明一个var或者val时,你通常让编译器从右边的表达式类型中猜测变量类型。我们将其称做局部变量类型推断,这对程序员来说是一个很大的改进。它允许我们在不影响静态类型检查的情况下简化代码。

    例如,这段Kotlin代码:

    var a = "10"

    将由Kotlin编译器翻译成:

    var a : String = "10"

    它曾经是胜过Java的真正优点。我故意说曾经是,因为——有个好消息——Java10 已经有这个功能了,并且Java10现在已经可以使用了。

    Java10 中的类型涂端:

    var a = "10";

    公平的说,我需要补充一点,Kotlin在这个领域仍然略胜一筹。你也可以在其他上下文中使用类型推断,例如,单行方法。

    更多关于Java10 中的局部变量类型推断

    编译时空值安全

    Null-safe类型是Kotlin的杀手级特征。这个想法很好。在Kotlin,类型是默认的非空值。如果您需要一个可空类型,您需要添加?符号,例如:

    val a: String? = null      // ok
    
    val b: String = null       // 编译错误

     

    如果您在没有空检查的情况下使用可空变量,那么Kotlin将无法编译,例如:

    println (a.length)          // compilation error
    println (a?.length)         // fine, prints null
    println (a?.length ?: 0)    // fine, prints 0

     

    一旦你有了这两种类型,non-nullable T 和nullable T?,您可以忘记Java中最常见的异常——NullPointerException。真的吗?不幸的是,事情并不是那么简单。

    当您的Kotlin代码必须与Java代码一起使用时,事情就变得很糟糕了(库是用Java编写的,所以我猜它经常发生)。然后,第三种类型就跳出来了——T!它被称为平台类型,它的意思是T或T?,或者如果我们想要精确,T!意味着具有未定义空值的T类型。这种奇怪的类型不能用Kotlin来表示,它只能从Java类型推断出来。T!会误导你,因为它放松了对空的限制,并禁用了Kotlin的空值安全限制。

    看看下面的Java方法:

    public class Utils {
        static String format(String text) {
            return text.isEmpty() ? null : text;
        }
    }

     

    现在,您想要从Kotlin调用format(string)。您应该使用哪种类型来使用这个Java方法的结果?好吧,你有三个选择。

    第一种方法。你可以使用字符串,代码看起来很安全,但是会抛出空指针异常。

    fun doSth(text: String) {
        val f: String = Utils.format(text)       // compiles but assignment can throw NPE at runtime
        println ("f.len : " + f.length)
    }

     

    你需要用增加判断来解决这个问题:

    fun doSth(text: String) {
        val f: String = Utils.format(text) ?: ""  // 
        println ("f.len : " + f.length)
    }

     

    第二种方法。您可以使用String?,然后你的程序就是空值安全的了。

    fun doSth(text: String) {
        val f: String? = Utils.format(text)   // safe
        println ("f.len : " + f.length)       // compilation error, fine
        println ("f.len : " + f?.length)      // null-safe with ? operator
    }

     

    第三种方法。如果你让Kotlin做了令人难以置信的局部变量类型推断呢?

    fun doSth(text: String) {
        val f = Utils.format(text)            // f type inferred as String!
        println ("f.len : " + f.length)       // compiles but can throw NPE at runtime
    }

     

    坏主意。这个Kotlin的代码看起来很安全,也可以编译通过,但是允许空值在你的代码中不受约束的游走,就像在Java中一样。

    还有一个窍门,!!操作符。使用它来强制推断f类型为String类型:

    fun doSth(text: String) {
        val f = Utils.format(text)!!          // throws NPE when format() returns null
        println ("f.len : " + f.length)
    }

     

    在我看来,Kotlin的类型系统中所有这些类似scala的东西!,?和!!,实在是太复杂了。为什么Kotlin从Java的T类型推断到T!而不是T?呢?似乎Java互操作性破坏了Kotlin的杀手特性——类型推断。看起来您应该显式地声明类型(如T?),以满足由Java方法填充的所有Kotlin变量。

     

    类字面量

    在使用Log4j或Gson之类的Java库时,类字面量是很常见的。

    Java中,我们用.class后缀来写类名:

    Gson gson = new GsonBuilder().registerTypeAdapter(LocalDate.class, new LocalDateAdapter()).create();

     

    Groovy中,类字面量被简化为本质。你可以省略.class,不管它是Groovy还是Java类都没关系。

    def gson = new GsonBuilder().registerTypeAdapter(LocalDate, new LocalDateAdapter()).create()

     

    Kotlin区分了Kotlin和Java类,并为其准备了不同的语法形式:

    val kotlinClass : KClass<LocalDate> = LocalDate::class
    val javaClass : Class<LocalDate> = LocalDate::class.java

     

    所以在Kotlin,你不得不写:

    val gson = GsonBuilder().registerTypeAdapter(LocalDate::class.java, LocalDateAdapter()).create()

     

    这真是丑爆了。

     

    相反顺序的类型声明

    在C系列编程语言中,有一个标准的声明类型的方式。即先写出类型,再写出声明为该类型的东西(变量、字段、方法等)。

    Java中如下表示:

    int inc(int i) {
        return i + 1;
    }

     

    Kotlin中则是相反顺序的表示:

    fun inc(i: Int): Int {
        return i + 1
    }

     

    这让人觉得恼火,因为:

    首先,你得书写或者阅读介于名称和类型之间那个讨厌的冒号。这个多余的字母到底起什么作用?为什么要把名称和类型分隔开?我不知道。不过我知道这会加大使用Kotlin的难度。

    第二个问题。在阅读一个方法声明的时候,你最先想知道的应该是方法的名称和返回类型,然后才会去了解参数。

    在 Kotlin 中,方法的返回类型远在行末,所以可能需要滚动屏幕来阅读:

    private fun getMetricValue(kafkaTemplate : KafkaTemplate<String, ByteArray>, metricName : String) : Double {
        ...
    }

     

    另一种情况,如果参数是按分行的格式写出来的,你还得去寻找返回类型。要在下面这个方法定义中找到返回类型,你需要花多少时间?

    @Bean
    fun kafkaTemplate(
            @Value("\${interactions.kafka.bootstrap-servers-dc1}") bootstrapServersDc1: String,
            @Value("\${interactions.kafka.bootstrap-servers-dc2}") bootstrapServersDc2: String,
            cloudMetadata: CloudMetadata,
            @Value("\${interactions.kafka.batch-size}") batchSize: Int,
            @Value("\${interactions.kafka.linger-ms}") lingerMs: Int,
            metricRegistry : MetricRegistry
    ): KafkaTemplate<String, ByteArray> {
    
        val bootstrapServer = if (cloudMetadata.datacenter == "dc1") {
            bootstrapServersDc1
        }
        ...
    }

     

    关于相反顺序的第三个问题是限制了IDE的自动完成功能。在标准顺序中,因为是从类型开始,所以很容易找到类型。一旦确定了类型,IDE 就可以根据类型给出一些与之相关的变量名称作为建议。这样就可以快速输入变量名,不像这样:

    MongoExperimentsRepository repository

     

    即时在 Intellij 这么优秀的 IDE 中为 Kotlin 输入这样的变量名也十分不易。如果代码中存在很多 Repository,就很难在自动完成列表中找到匹配的那一个。换句话说,你得手工输入完整的变量名。

    repository : MongoExperimentsRepository

    伴生对象

    一个 Java 程序员来到 Kotlin 阵营。

    “嗨,Kotlin。我是新来的,有静态成员可用吗?”他问。
    “没有。我是面向对象的,而静态成员不是面向对象的,” Kotlin回答。
    “好吧,但我需要用于 MyClass 日志记录器,该怎么办?”
    “没问题,可以使用伴生对象。” 
    “伴生对象是什么鬼?”
    “它是与类绑定的一个单例对象。你可以把日志记录器放在伴生对象中,” Kotlin 如此解释。
    “明白了。是这样吗?”

    class MyClass {
        companion object {
            val logger = LoggerFactory.getLogger(MyClass::class.java)
        }
    }

     

    “对!“
    “好麻烦的语法,”这个程序看起来有些疑惑,“不过还好,现在我可以像这样——MyClass.logger——调用日志记录了吗?就像在 Java 中使用静态成员那样?”
    “嗯……是的,但是它不是静态成员!它只是一个对象。可以想像那是一个匿名内部类的单例实现。而实际上,这个类并不是匿名的,它的名字是 Companion,你可以省略这个名称。明白吗?这很简单。”

    我很喜欢对象声明的概念——单例是种很有用的模式。从从语言中去掉静态成员就不太现实了。我们在Java中已经使用了若干年的静态日志记录器,这是非常经典的模式。因为它只是一个日志记录器,所以我们并不关心它是否是纯粹的面向对象。只要它起作用,而且不会造成损害就好。

    有时候,我们必须使用静态成员。古老而友好的 public static void main() 仍然是启动 Java 应用的唯一方式。在没有Google的帮助下尝试着写出这个伴生对象。

    class AppRunner {
        companion object {
            @JvmStatic fun main(args: Array<String>) {
                SpringApplication.run(AppRunner::class.java, *args)
            }
        }
    }

    集合字面量

    在 Java 中初始化列表需要大量的模板代码:

    import java.util.Arrays;
    ...
    
    List<String> strings = Arrays.asList("Saab", "Volvo");

     

    初始化 Map 更加繁琐,所以不少人使用 Guava

    import com.google.common.collect.ImmutableMap;
    ...
    
    Map<String, String> string = ImmutableMap.of("firstName", "John", "lastName", "Doe");

     

    我们仍然在等待 Java 产生新语法来简化集合和映射表的字面表达。这样的语法在很多语言中都自然而便捷。

    JavaScript:

    const list = ['Saab', 'Volvo']
    const map = {'firstName': 'John', 'lastName' : 'Doe'}

     

    Python:

    list = ['Saab', 'Volvo']
    map = {'firstName': 'John', 'lastName': 'Doe'}

     

    Groovy:

    def list = ['Saab', 'Volvo']
    def map = ['firstName': 'John', 'lastName': 'Doe']

     

    简单来说,简洁的集合字面量语法在现代编程语言中倍受期待,尤其是初始化集合的时候。Kotlin 提供了一系列的内建函数来代替集合字面量:listOf()、mutableListOf()、mapOf()、hashMapOf(),等等。

    Kotlin:

    val list = listOf("Saab", "Volvo")
    val map = mapOf("firstName" to "John", "lastName" to "Doe")

     

    映射表中的键和值通过 to 运算符关联在一起,这很好,但是为什么不使用大家都熟悉的冒号(:)?真是令人失望!

     

     

    Maybe?不

    函数式编程语言(比如 Haskell)没有空(null)。它们提供 Maybe Monad(如果你不清楚 Monad,请阅读这篇由 Tomasz Nurkiewicz 撰写文章)。

    在很久以前,Scala 就将 Maybe 作为 Option 引入 JVM 世界,然后在 Java 8 中被采用,成为 Optional。现在 Optional 广泛应用于 API 边界,用于处理可能含空值的返回类型。

    Kotlin 中并没有与 Optional 等价的东西。看起来你应该使用 Kotlin 的可空类型封装。我们来研究一下这个问题。

    通常,在使用 Optional 时,你会先进行一系列空安全的转换,最后来处理空值。

    比如在 Java 中:

    public int parseAndInc(String number) {
        return Optional.ofNullable(number)
                       .map(Integer::parseInt)
                       .map(it -> it + 1)
                       .orElse(0);
    }

     

    在 Kotlin 中也没问题,使用 let 功能:

    fun parseAndInc(number: String?): Int {
        return number.let { Integer.parseInt(it) }
                     .let { it -> it + 1 } ?: 0
    }

     

    可以吗?是的,但并不是这么简单。上面的代码可能会出错,从 parseInt() 中抛出 NPE。只有值存在的时候才能执行 Monad 风格的 map(),否则,null 只会简单的传递下去。这就是 map() 方便的原因。然后不幸的是,Kotlin 的 let 并不是这样工作的。它只是从左往右简单地执行调用,不在乎是否是空。

    因此,要让这段代码对空安全,你必须在 let 前添加 ?:

    fun parseAndInc(number: String?): Int {
        return number?.let { Integer.parseInt(it) }
                     ?.let { it -> it + 1 } ?: 0
    }

     

    现在,比如 Java 和 Kotlin 两个版本的可读性,你更喜欢哪一个?

    展开全文
  • 一个Java / Kotlin反编译工具和AST库。 该库的主要目的是为Java类文件构造一个完整的抽象源树(AST),其中包括所有指令的节点。 它是在的顶部构建的,该具有用于方法的AST元素,但是在此停止并提供了一个简单的...
  • KotlinJava 网页: : 基于: 开发 安装npm 安装coffeescript npm install -g coffeescript 安装node-gyp npm install -g node-gyp 安装依赖项 npm install 产生HTML ./make.coffee dev HTML生成 首先,...
  • 如何使用JavaKotlin:今天开始使用Kotlin Kotlin 一个极好的点就是完全和Java融为一体。这个意味着,即使你的应用代码是使用Java写的,你能用Kotlin创建一个类,然后使用Java调用它不产生任何问题。 这至少给你...
  • Android:KotlinJava比较

    千次阅读 2020-10-10 11:11:25
    Android:KotlinJava比较一、Kotlin优势1.1 优雅的解决Java空指针问题1.1.1 编译期进行空指针检查1.1.2 精简防空判断代码1.2 代码精简1.2.1 精简Set/Get方法1.2.2 精简属性调用1.2.3 精简单例模式二、从Java到...
  • javakotlin

    千次阅读 2018-11-22 17:21:19
    毫无疑问,Kotlin 目前很受欢迎,业界甚至有人认为其将取代 Java 的霸主地位。它提供了 Null 安全性,从这一点来说它确实比 Java 更好。那么是不是这就意味着开发者应该毫不犹豫地拥抱 Kotlin,否则就落伍了? ...
  • kotlin 还是java你喜欢哪个? 翻译自: https://dev.to/fultonbrowne/java-or-kotlin-171gkotlin 还是java
  • 目前kotlin是谷歌首推的开发Android的语言,但由于历史原因,我们绝大部分项目依旧还是以Java为主的,也就是说存在JavaKotlin两种语言同时开发的情况。 有人会说把老项目全部翻译成Kotlin,的确可以怎么做,但是...
  • 官方文档: http://kotlinlang.org/docs/reference/java-to-kotlin-interop.html4.静态字段(Static Fields)在对象(object)或伴生对象(companion object)中声明的Kotlin属性,有静态的幕后字段(backing fields)!...
  • JavaKotlin之间互相转换

    万次阅读 2018-04-02 18:08:06
    javakotlin: 打开要转的java文件 快捷键 Ctrl+Shift+Alt+K 直接转换 快捷键 Ctrl+Shift+A在搜索框输入Convert Java File to Kotlin或者 Code -&gt;Convert Java File to Kotlin Kotlikn 转 Java ...
  • Kotlin(和 Java)中的拼写检查器示例 在和 Java 中实现的非常简单的拼写检查器示例。 建造 在 IntelliJ IDEA 11 中安装 克隆这个 repo,并在 IntelliJ 中导入 运行KotlinSpellChecker程序。 注意:代码假定您正在...
  • kotlin的扩展方法,其实是以java的静态方法形式存在的,也就是说如果要用java调用kotlin的扩展方法,和调用静态函数一样 调用扩展属性也是相同的道理 举个例子,我们在某个kotlin文件(文件名为Utils.kt)里为...
  • 简单的入门(上传的资源如果因版权、使用、内容完整度 等原因被举报并通过官方审核,将扣除通过该资源获得的全部积分)
  • 该项目旨在逐步展示如何通过Spring Boot从Java迁移到Kotlin: :初始Java项目 :JavaKotlin :Spring Boot 2 :Spring WebFlux :Kotlin路由DSL 有关更多详细信息,请参见。 步骤0:初始Java项目 带有JSON ...
  • 我的项目是个Java版本的项目,然后再Java项目里面新建的Kotlin的文件,代码写完后再次运行就报错了,无论如何找不到原因。因为以前的项目JavaKotlin互相跳转没有问题的。看我的kotlin跳转Java的Activity方法如下:...
  • Android开发Java调用Kotlin 提示包不存在 加上 apply plugin: ‘kotlin-android’
  • Java调用Kotlin函数的坑

    千次阅读 2019-07-20 17:46:21
    看下这段代码执行main函数结果如何, 会打印"执行了method函数"么? class DemoClass { fun method(str: String) { System.out.println("执行了method函数") System.out.println...public class HelloJava { p...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 70,770
精华内容 28,308
关键字:

java比較kotlin

java 订阅