Cómo dominar rápidamente Kotlin por programadores de Java que entienden Kotlin en segundos

[Declaración de derechos de autor] La fuente puede reimprimirse libremente con fines no comerciales.
Dirección del blog: https://blog.csdn.net/ShuSheng0007/article/details/108640462
de: shusheng007

Artículo publicado por primera vez en blog personal

Visión de conjunto

Kotlin/JVMPuede verse como un intento activo de mejorar Java, que intenta mejorar las deficiencias y deficiencias conocidas del lenguaje de programación Java que han sido ampliamente discutidas. Porque me dediqué al desarrollo de C # hace muchos años, cuando vi por primera vez Kotlin, sentí que muchas características de C # existían hace muchos años. Muestra cuán tradicional es Java y no está dispuesto a introducir demasiado azúcar sintáctico.

Con respecto al amor y el odio entre Kotlin y Java, haga clic aquí para ver si tiene la oportunidad de escribir un artículo relacionado. Este artículo solo quiere dar algunas diferencias entre Kotlin y Java desde la perspectiva de los idiotas de Java, que a menudo es crucial para que los idiotas de Java dominen rápidamente Kotlin. Debido a que Kotlin es una mejora de Java, es 100% interoperable con Java, por lo que los programadores de Java a menudo pueden comenzar rápidamente después de una breve familiaridad y luego dominar Kotlin.

Una forma muy importante para que los humanos aprendan cosas nuevas es la analogía. Si las cosas nuevas son muy similares a las antiguas, entonces el efecto de aprender por analogía será más obvio. De Java a Kotlin encaja muy bien con esta característica, y la analogía con Java con la que está familiarizado. El familiar Kotlin hará más con menos, comencemos.

Este artículo se basa en la versión Kotlin 1.4.0

Diferencias gramaticales

Hay algunas diferencias gramaticales entre Kotlin y Java, que no son particularmente grandes. Aquí están las pocas que creo que más necesitan adaptar:

Los métodos y propiedades de Kotlin pueden no incluirse en la categoría de

Sabemos que todo en Java se basa en clases y debe estar en clases, pero Kotlin no. En el siguiente código, los métodos, atributos y clases coexisten en el mismo nivel y todos están permitidos en el mismo archivo.

//属性
var name: String = "ShuSheng007"

//方法
fun sum(x: Int, y: Int): Int {
    return x + y
}

//类
class Student{}

Las declaraciones en Kotlin no necesitan ;terminar con

println("hello world")

Los tipos de datos en Kotlin son postfijos

//变量声明时类型后置
var name: String = "ShuSheng007"

//方法参数及返回值类型后置
fun sum(x: Int, y: Int): Int {
        return x + y
}

El método Kotlin utiliza la fundefinición de palabras clave

fun sum(x: Int, y: Int): Int {
        return x + y
}

Las clases y métodos de Kotlin son public finalpor defecto

La clase no se puede heredar de forma predeterminada y los métodos de la clase base no se pueden anular de forma predeterminada. Si desea que se herede o anule, debe openmarcarlo con palabras clave

//Human类可以被继承
open class Human{
	//eat方法可以被overwrite
    open fun eat(){
    }
}

Herencia de clases e implementación de interfaz en Kotlin use :tags

//类继承
class Man : Human(){
    override fun eat() {
        super.eat()
    }
}

//实现接口
interface action{
    fun sleep()
}
class Woman :action{
    override fun sleep() {
        //...
    }
}

Úselo en Kotlin var, valdeclare variables y atributos, y puede realizar inferencias de tipos

En Java, declaramos que una variable primero debe especificar su tipo, por ejemplo

String name= "shusheng007";

Pero en Kotlin, el compilador puede inferir automáticamente su tipo según la asignaciónString

var name = "shusheng007"

Kotlin tiene tipos no nulos y que aceptan valores NULL

Esto también es un punto culminante de su propaganda, que intenta resolver un problema por valor de miles de millones de dólares:NullPointerException

Cada objeto en Kotlin no es nulo de forma predeterminada, a menos que lo declare explícitamente como anulable

//非空类型
var name1:String="shusheng"
//可空类型
var name2:String?=null

El paquete en Kotlin puede ser inconsistente con la ruta del archivo

Qué significa eso? Supongamos que tenemos un archivo de clase en la ruta del archivo src /.../ top / ss007 / learn

Luego, para Java, el nombre del paquete debe ser

package top.ss007.learn

Para Kotlin, no existe tal restricción, puedes llamarlo como quieras, por ejemplo: es tan voluntarioso

package just.so.wayward

Es muy testarudo, por lo que es mejor seguir la especificación de Java.

No hay ninguna excepción marcada en Kotlin

Hay muchas excepciones marcadas en Java, y los programadores se ven obligados a lidiar con ellas, o se las envía al llamador inferior para su procesamiento. Pero Kotlin no tiene esta restricción.

Kotlin enfatiza el concepto de inmutabilidad

Kotlin dará prioridad a los objetos inmutables, como colecciones inmutables y variables inmutables. Una vez generados estos objetos inmutables, solo se pueden leer pero no modificar. En cuanto al uso de objetos inmutables, existen muchos beneficios, como su seguridad de hilo natural, etc.

Las anteriores son las diferencias que personalmente creo que son las más subversivas de nuestra cognición Después de familiarizarse con lo anterior, los programadores de Java básicamente pueden entender el código de Kotlin.

Funciones que no existen en Java

Kotlin ha introducido muchas funciones que no existen en Java. Aquí hay algunas que creo que son más importantes

Tipo de función

En Kotlin, un método es un ciudadano de primera clase, lo que significa que un método es lo mismo que una clase El método puede hacer todo lo que la clase puede hacer. Un método se puede utilizar como tipo como parámetro de otros métodos, como tipo de valor de retorno de otros métodos, como tipo de declaración de una variable ... Esto subvierte las tres visiones de los programadores de Java. No existe un concepto correspondiente en Java. Si tiene que encontrar una contraparte, es una interfaz funcional.

El siguiente es un tipo de método (dos datos int obtienen un int, por ejemplo, 1 + 2 = 3). Podemos considerarlo completamente como una clase en java. Este tipo es aplicable a todos los lugares donde se puede usar la clase. Es decir, en Kotlin, los métodos se pueden pasar como parámetros, lo que equivale a implementar referencias de métodos, lo cual es genial. .

(Int, Int) -> Int

Por ejemplo, en el siguiente método, operationel tipo del tercer parámetro es el tipo de método anterior

fun calculate(x: Int, y: Int, operation: (Int, Int) -> Int): Int {  
    return operation(x, y)                                          
}
//如何调用
fun sum(x: Int, y: Int): Int {
    return x + y
}
//将sum方法当参数传入了calculate方法中
calculate(4, 5, ::sum)

//我们也可以使用Lambda表达式
calculate(4, 5, { a, b -> a + b })
//当Lambda表达式是方法的最后一个参数时，其可以移到()外面
calculate(4, 5) { a, b -> a + b }

Entonces, ¿cómo lograr la misma función en Java?

Paso 1: definir una interfaz de función de acuerdo con los requisitos

La siguiente interfaz tiene solo un método abstracto, que es una interfaz funcional.

@FunctionalInterface
public interface Fun2<P1, P2, R> {
    R invoke(P1 p1, P2 p2);
}

Paso 2: Úselo como un tipo de parámetro de método

 public int javaCalculate(int x, int y, Fun2<Integer, Integer, Integer> operation) {
     return operation.invoke(x, y);
 }

Después de los dos pasos anteriores, está hecho.

Al llamar a un método en Java en Kotlin javaCalculate, el IDE solicitará la siguiente información

El primero es decirle que el tercer parámetro puede usar el tipo de función en Kotlin, el código es el siguiente

javaCalculate(4, 5) { a, b -> a + b }

El segundo es más ortodoxo, diciéndote que necesitas un parámetro de tipo Fun2, el código es el siguiente

javaCalculate(4, 5, object : Fun2<Int, Int, Int> {
        override fun invoke(p1: Int, p2: Int): Int {
            return p1 + p2
        }
    })

En Java usamos newun objeto de una clase anónima, mientras que en Kotlin necesitamos usar objectpalabras clave

Propiedad (Propiedad)

var name:String="ShuSheng007"

Correspondiente al campo privado (Campo) en la clase Java más el método de gettersumasetter

private String name;

public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}

Clase de datos

data class User(val name: String, val age: Int)

Aproximadamente equivalente a JavaBean en Java, pero con diferencias sutiles, esta también es una característica de limpieza que a menudo se muestra cuando Kotlin promueve su simplicidad

Clase sellada ( sellada las clases )

Esto es bastante impresionante, no hay cosas correspondientes en Java y se whenusa principalmente en Kotlin . Cuando lo vi por primera vez, no me gustó mucho, porque se llamaba clase sellada, pero podía heredarse. Más tarde, descubrí la sutileza de su diseño y realmente resolvió el dilema que a menudo se encuentra en el desarrollo.

Es una clase con herencia limitada, como la siguiente clase humana, que tiene las siguientes características

1. Es una clase abstracta
2. No se puede instanciar directamente
3. Su subclase debe estar en el mismo archivo que

sealed class Human {
    abstract fun eat(): Unit
    open fun program(){
        println("I use koltin")
    }
}
class Man : Human() {
    override fun eat() {
    }

    override fun equals(other: Any?): Boolean {
        return this === other
    }

    override fun hashCode(): Int {
        return System.identityHashCode(this)
    }
}

class Woman :Human(){
    override fun eat() {
    }

    override fun program() {
        super.program()
    }
}

Cuales son sus beneficios? Se utiliza principalmente en whenexpresiones. Tiene la misma función que la enumeración, pero puede proteger el estado. La enumeración es singleton.

Funciones de extensión y propiedades de extensión

Esta característica también es una característica muy importante de Kotlin y tiene una amplia gama de aplicaciones. A través de métodos de extensión, Kotlin tiene la capacidad de agregar nuevos métodos y propiedades a una clase sin herencia.

Por ejemplo, queremos implementar uno wrapWithSymbol, usado para agregar antes y después de la cadena <>, ¿cómo lograrlo? Si es Java, solo puede escribir un método Utils y Kotlin puede usar métodos de extensión para Stringagregar un nuevo método a la clase.

El método de implementación es el siguiente, preste atención al tipo que se extenderá frente al método, el nombre científico es receptor

fun String.wrapWithSymbol() :String{
	return "<$this>"
}

//使用
println("my name is ${"shusheng007".wrapWithSymbol()}")

Salida:

my name is <shusheng007>

Se puede ver que se ha agregado antes y después de la cadena de destino <>. Desde el método de llamada, el wrapWithSymbolmétodo es Stringcomo el método de la clase.

Los atributos de extensión son similares a los métodos de extensión:

val <T> List<T>.lastIndex: Int
    get() = size - 1
    
//调用
println(listOf(1,2,3,4).lastIndex)

Sobrecarga del operador

En realidad, esto es bastante complicado y fácil de abusar. Creo que debería pertenecer al conocimiento avanzado. Aquí hay solo una breve introducción.

Java no admite la sobrecarga del operador, de hecho, no afecta la situación general.

Entonces, ¿qué es la sobrecarga del operador? Para comprender este problema, primero debe comprender qué es un operador.

Por ejemplo, a menudo usamos el tiempo de programación a++, a--, a+b, a==b ,a in by así sucesivamente, cuál de ellos ++，--，+,== ,ines el operador.

Entonces, ¿qué es la sobrecarga? Estos operadores en sí tienen su propio significado, pero podemos cambiar el significado de estos operadores mediante la sobrecarga. Este proceso se denomina sobrecarga de operadores.

En Kotlin, el conjunto de operadores que se pueden sobrecargar y sus métodos correspondientes están predefinidos y no se pueden sobrecargar casualmente. Uno de ellos se enumera a continuación:

Expresión	Traducido a
a + b	a.plus (b)
a - b	menos (b)
a * b	a.veces (b)
a / b	a.div (b)
a% b	a.rem (b), a.mod (b) (obsoleto)
a ... b	a.rangeTo (b)

Los métodos sobrecargados del operador pueden ser métodos de instancia o métodos de extensión .

Intentemos volver a cargar los +operadores en la tabla anterior usando métodos de instancia . Hay dos puntos a tener en cuenta:

1. Los métodos sobrecargados deben estar operatormarcados con
2. Kotlin debe predefinir el nombre y los parámetros del método sobrecargado, por ejemplo aquí plus

data class Point(val x: Int, val y: Int){
	operator fun plus(p: Point): Point {
        return Point(p.x + x,p.y + y)
    }
}

//调用
 val p1 = Point(1, 2)
 val p2 = Point(3, 4)
 println(p1 + p2)

Salida:

Point(x=4, y=6)

Se puede ver que al sobrecargar el +operador, hemos cambiado su significado interno para que +también se pueda usar para objetos.

Coroutine

Más complicado, necesita una descripción del artículo por separado

para resumir

Como dice el refrán, buscar puntos en común reservando diferencias, aprender por analogía, todo en el mundo es igual. Es hora de dar me gusta y coleccionar de nuevo. Me gusta es apoyar al autor, y la colección es responsable de ti.

Deja ir un pensamiento y siéntete a gusto.