kotlin-compare-to-java

KO | EN

gitlite — search

#python #react #go #golang #android #machine-learning #docker #nodejs #macos #java #awesome #vue #ios #openai

kotlin-compare-to-java

(★ 19)

No description available.

kotlin-compare-to-java 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Kotlin Compare to Java
> 对比着java学习kotlin，事半功倍

* [Kotlin Compare to Java](#kotlin-compare-to-java)
      * [变量定义](#变量定义)
      * [只读变量](#只读变量)
      * [变量null检查](#变量null检查)
      * [const常量](#const常量)
      * [类型检测及自动类型转换](#类型检测及自动类型转换)
      * [字符串拼接](#字符串拼接)
      * [三元表达式](#三元表达式)
      * [switch/case条件匹配](#switchcase条件匹配)
      * [for循环](#for循环)
      * [方法](#方法)
      * [Util类（工具类）](#util类工具类)
      * [类的构造函数](#类的构造函数)
      * [数据类（Bean）](#数据类bean)
      * [类的初始化块](#类的初始化块)
      * [类的Getter和Setter](#类的getter和setter)
      * [抽象类](#抽象类)
      * [内部类](#内部类)
      * [匿名内部类](#匿名内部类)
      * [类的所有方法和变量均为static（Util类）](#类的所有方法和变量均为staticutil类)
      * [静态内部类](#静态内部类)
      * [单例模式](#单例模式)
      * [继承](#继承)
      * [派生类的方法重写](#派生类的方法重写)
      * [接口](#接口)
      * [扩展（Kotlin特有）](#扩展kotlin特有)
      * [模板类](#模板类)
      * [枚举](#枚举)
      * [委托模式](#委托模式)
      * [let,run,applu,also](#let,run,applu,also)

## 变量定义
- kotlin

```
    var a: Int = 1          //指定了类型并赋初值
    var b = 1               //不指定类型
    var c: Int              //不初始化，报错
    var d: String = null    //赋值为null，报错
    var e: String? = null   //赋值为null，可为空，正确
```

```
    print(e.length)     //直接访问，报错
    print(e?.length)    //正确
    print(e!!.length)   //正确
```

- java

```
    int a = 1;          //整形基本类型
    Integer b = 1;      //整形包装类型
    int c;              //不初始化，自动初始化为0
    Integer d = null;   //赋值为null
```

> kotlin用var定义变量，可以指定类型，也可以不指定类型，但是不同于java，kotlin用var定义的变量需要指定初始值，java可以不指定初始值。

> 变量类型如Int是不能设为null的，如果一个变量有可能设置为null，类型需要设置成“类型+?”，如“String?”。访问有可能为空的变量的成员，直接写.编译器会报错，需要写成?.或者!!.，这个后面再说。

---

## 只读变量
- kotlin

```
    val a:Int = 1           //指定了类型并赋值
    val b = 1               //不指定类型
    val c                   //不赋值，报错
    val d:Int = null        //赋值为null，报错
    val e:Int? = null       //赋值为null，可为空，正确
```

```
    print(a)            //访问，正确
    a = 2               //修改，报错
```

- java

```
    final int a = 1;
```
> kotlin中的val可以理解成java中的final变量
> 也可以理解成java中只有getter没有setter的类成员变量

---

## 变量null检查
- kotlin

```
    val a: String? = "hello world"
```

```
    print(a.length)            //报错，不能直接访问
    print(a?.length)           //正确，若为空不做处理返回null
    print(a!!.length)          //正确，若为空抛出空指针异常
```

- java

```
    String a = "hello world";
```

```
    if (a != null) {
        int length = a.length();
    }
```
or

```
    int length = a != null ? a.length() : 0;
```

> 可控变量必须使用null检查访问成员变量或方法，直接访问会报错，?.若为空不做处理返回null，!!.若为空抛出空指针异常

---

## const常量
- kotlin

```
const val THOUSAND = 1000

object myObject {
    const val constNameObject: String = "constNameObject"
}

class MyClass {

companion object Factory {
        const val constNameCompanionObject: String = "constNameCompanionObject"
    }
}
```

- java

```
class MyClass {
    public static final int THOUSAND = 1000;

public static final String CONST_NAME = "const_name";
}
```
> const 必须修饰val

> const 只允许在top-level级别和object中声明

---

## 类型检测及自动类型转换
- kotlin

```
    var obj: Any = "hello world"
    
    if (obj is String) {
        val length = obj.length     // 做过类型判断以后，obj会被系统自动转换为String类型
    }
```

- java

```
    Object obj = "hello world";
    
    if (obj instanceof String) {
        int length = ((String) obj).length();
    }
```
> kotlin中用is判断是不是某种类型，也可以用!is判断不是某种类型

---

## 字符串拼接
- kotlin

```
    val a: String = "a"
    val b: String = "b"
    val c: String = "$a and $b"
```

- java

```
    String a = "a";
    String b = "b";
    String c = a + " and " + b;
```

---

## 三元表达式
- kotlin

```
    val input: Int = 10
    val ret: Int = if (input > 0) input else 0
```

- java

```
    int input = 10;
    int ret = input > 0 ? input : 0;
```

---

## switch/case条件匹配
- kotlin

```
    val score: Int = 10
    val result = when (score) {
        100 -> "full score"
        in 90..99 -> "excellent"
        in 80..89 -> "good"
        in 60..79 -> "not bad"
        else -> "fail"
    }
```

- java

```
    int score = 10;
    String result;
    switch (score) {
        case 100:
            result = "full score";
            break;
        case 99:
        case 98:
        case 90:
            result = "excellent";
            break;
        case 89:
        case 88:
        case 80:
            result = "good";
            break;
        case 79:
        case 78:
        case 60:
            result = "not bad";
            break;
        default:
            result = "fail";
```
---

## for循环
- kotlin

```
    for (i in 1..10) { }
    
    for (i in 1 until 10) { }
    
    for (i in 10 downTo 0) { }
    
    for (i in 1..10 step 2) { }
    
    for (i in 10 downTo 0 step 2) { }
    
    for (item in collection) { }
    
    for ((key, value) in map) { }
```

- java

```
    for (int i = 1; i <= 10 ; i++) { }
    
    for (int i = 1; i < 10 ; i++) { }
    
    for (int i = 10; i >= 0 ; i--) { }
    
    for (int i = 1; i <= 10 ; i+=2) { }
    
    for (int i = 10; i >= 0 ; i-=2) { }
    
    for (String item : collection) { }
    
    for (Map.Entry<String, String> entry: map.entrySet()) { }
```
---

## 方法
- kotlin

```
    fun doSomething() {

}

fun doSomething(input: Int) {

}

fun doSomething(vararg inputs: Int) {

}

fun doSomething(input: String): Int {
        return 0
    }
```

- java

```
    void doSomething() {

}

void doSomething(int input) {

}

void doSomething(int... inputs) {

}

int doSomething(String input) {
        return 0;
    }
```
---

## Util类（工具类）
- kotlin

```
class Utils private constructor() {

companion object {

fun compute(input: Int): Int {
            return 2 * input
        }
    }
}

// another way

object Utils {

fun compute(input: Int): Int {
        return 2 * input
    }
}
```

- java

```
public class Utils {

private Utils() {
        // This utility class is not publicly instantiable
    }

public static int compute(int input) {
        return 2 * input;
    }
}
```
---
## 类的构造函数
- kotlin

```
class Person constructor(name: String) {
    var name: String = ""
    var age: Int = 0

constructor(name: String, age: Int) : this(name) {
        this.age = age
    }
}
```

- java

```
class Person {
    String name;
    int age;

public Person(String name) {
        this.name = name;
    }

public Person(String name, int age) {
        this(name);
        this.age = age;
    }
}
```
> 在Kotlin中一个类可以有一个主构造函数和一个或多个次构造函数；如果不写构造函数会有一个默认空的构造函数

> 主构造函数是类头的一部分：它跟在类名（和可选的类型参数）后。如果主构造函数没有任何注解或可见性修饰符，constructor关键字可省略，否则是必须的
---

## 数据类（Bean）
- kotlin

```
data class Student(val name: String, val age: Int)
```

- java

```
public class Student {

private String name;
    private int age;

public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

public String getName() {
        return name;
    }

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

public int getAge() {
        return age;
    }

public void setAge(int age) {
        this.age = age;
    }

@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

Student developer = (Student) o;

if (age != developer.age) return false;
        return name != null ? name.equals(developer.name) : developer.name == null;

}

@Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

@Override
    public String toString() {
        return "Developer{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
```
> kotlin的简洁体现得淋漓尽致
---

## 类的初始化块
- kotlin

```
class Person constructor(name: String) {
    var name: String
    var age: Int

init {
        this.name = ""
        this.age = 0
    }

constructor(name: String, age: Int) : this(name) {
        this.age = age
    }
}
```

- java

```
class Person {
    String name;
    int age;

{
        name = "";
        age = 0;
    }

public Person(String name) {
        this.name = name;
    }

public Person(String name, int age) {
        this(name);
        this.age = age;
    }
}
```
---

## 类的Getter和Setter
- kotlin

```
class Person {
    var name: String = ""
    var age: Int = 0
    val no: Long = 0
}
```

- java

```
class Person {
    private String name;
    private int age;
    final private long no = 0;

public String getName() {
        return name;
    }

public int getAge() {
        return age;
    }

public long getNo() {
        return no;
    }

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

public void setAge(int age) {
        this.age = age;
    }
}
```
> 在Kotlin中，getter和setter是可选的，如果你没有在代码中创建它们，它是会默认自动生成

> val不允许设置setter函数，因为它是只读的
---

## 抽象类
- kotlin

```
abstract class Person {
    var name: String = ""
    var age: Int = 0
    val no: Long = 0

abstract fun absFun()
}
```

- java

```
abstract class Person {
    String name;
    int age;
    final long no = 0;

abstract void absFun();
}
```
---

## 内部类
- kotlin

```
class Outer {
    private val bar: Int = 1
    var v = "成员属性"

/**嵌套内部类**/
    inner class Inner {
        fun foo() {
            print(bar)
        }

fun innerTest() {
            print(this@Outer.v)
        }
    }
}
```

- java

```
class Outer {
    private int bar = 1;
    String v = "成员属性";

/**
     * 嵌套内部类
     **/
    class Inner {
        void foo() {
            System.out.print(bar);
        }

void innerTest() {
            System.out.print(Outer.this.v);
        }
    }
}
```
---

## 匿名内部类
- kotlin

```
interface TestInterFace {
    fun test()
}

class Test {

var interFace: TestInterFace = object : TestInterFace {
        override fun test() {
            print("hello world")
        }
    }
}
```

- java

```
interface TestInterFace {
    void test();
}

class Test {

TestInterFace interFace = new TestInterFace() {
        @Override
        public void test() {
            System.out.print("hello world");
        }
    };
}
```
---

## 类的所有方法和变量均为static（Util类）
- kotlin

```
object DemoManager {
    private val TAG = "DemoManager"

fun staticFun() {
        print("hello world")
    }
}
```

- java

```
class DemoManager {
    private static final String TAG = "DemoManager";

public static void staticFun() {
        System.out.print("hello world");
    }
}
```
---

## 静态内部类
- kotlin

```
class OutterClass {
    object InnerClass {
        fun someFun() {
            print("hello world")
        }
    }
}
```

- java

```
class OutterClass {
    static class InnerClass {
        static void someFun() {
            System.out.print("hello world");
        }
    }
}
```
---

## 单例模式
- kotlin

```
class SomeManager private constructor() {

companion object {
        fun getInstance(): SomeManager {
            return Holder.holder
        }
    }

private object Holder {
        val holder = SomeManager()
    }

fun someFun() {

}
}
```
call

```
SomeManager.getInstance().someFun()
```

- java

```
class SomeManager {

private SomeManager() {
    }

private static class SingletonHolder {
        private static final SomeManager INSTANCE = new SomeManager();
    }

public static SomeManager getInstance() {
        return SingletonHolder.INSTANCE;
    }

public void someFun() {

}
}
```
call

```
SomeManager.getInstance().someFun();
```
---

## 继承
- kotlin

```
open class Base(p: Int)

class Derived(p: Int) : Base(p)
```

- java

```
class Base {
    public Base(int p) {
    }
}

class Derived extends Base {
    public Derived(int p) {
        super(p);
    }
}
```
> Kotlin 中所有类都继承该 Any 类，它是所有类的超类，对于没有超类型声明的类是默认超类

> 如果一个类要被继承，需要使用open关键字进行修饰，否则就是final类
---

## 派生类的方法重写
- kotlin

```
open class Person {
    open fun study() {
        println("我毕业了")
    }
}

class Student : Person() {
    override fun study() {
        println("我在读大学")
    }
}
```

- java

```
class Person {
    protected void study() {
        System.out.print("我毕业了");
    }
}

class Student extends Person {
    @Override
    protected void study() {
        System.out.print("我在读大学");
    }
}
```
> 在Kotlin基类中，使用fun声明函数时，此函数默认为final修饰，不能被子类重写。如果允许子类重写该函数，那么就要手动添加open修饰它, 子类重写方法使用override关键词
---

## 接口
- kotlin

```
interface MyInterface {
    var name: String //name 属性, 抽象的
    fun bar()
    fun foo() {
        // 可选的方法体
        println("foo")
    }
}

class MyImpl : MyInterface {
    override var name: String = "runoob" //重写属性
    override fun bar() {
        // 方法体
        println("bar")
    }
}
```

- java

```
interface MyInterface {

String name = "name";

void bar();

void foo();
}

class MyImpl implements MyInterface {
    @Override
    public void bar() {

}

@Override
    public void foo() {

}
}
```
> Kotlin接口允许方法有默认实现，java不允许

> Kotlin接口可以定义属性，并且属性只能是抽象的，不允许初始化值，接口不会保存属性值，实现接口时，必须重写属性；相对的，java的接口中定义的属性实际是个static final变量，不能被重写
---

## 扩展（Kotlin特有）
- kotlin

```
class User(var name: String)

/**扩展函数**/
fun User.print() {
    print("用户名 $name")
}
```
call

```
var user = User("Runoob")
user.print()
```

> Kotlin可以对一个类的属性和方法进行扩展，且不需要继承

> 扩展是一种静态行为，对被扩展的类代码本身不会造成任何影响
---

## 模板类
- kotlin

```
class Box<T>(t: T) {
    var value = t
}
```
call

```
val box: Box<Int> = Box(1)
```
- java

```
class Box<T> {
    T value;

public Box(T value) {
        this.value = value;
    }
}
```
call

```
Box<Integer> box = new Box<>(1);
```

> 定义泛型类型变量，可以完整地写明类型参数，如果编译器可以自动推定类型参数，也可以省略类型参数
---

## 枚举
- kotlin

```
enum class Color {
    RED, BLACK, BLUE, GREEN, WHITE
}
```

- java

```
enum Color {
    RED, BLACK, BLUE, GREEN, WHITE
}
```
---

## 委托模式
- kotlin

```
interface Base {
    fun print()
}

class BaseImpl(val x: Int) : Base {
    override fun print() {
        print(x)
    }
}

class Delegate(b: Base) : Base by b
```
call

```
val b = BaseImpl(10)
val d = Delegate(b)
d.print() // 输出 10
```
- java

```
interface Base {
    void print();
}

class BaseImpl implements Base {
    private int value;

public BaseImpl(int value) {
        this.value = value;
    }

@Override
    public void print() {
        System.out.print(value);
    }
}

class Delegate implements Base {

private Base base;

public Delegate(Base base) {
        this.base = base;
    }

@Override
    public void print() {
        base.print();
    }
}
```
call

```
Base b = new BaseImpl(10);
Base d = new Delegate(b);
d.print();
```
> Kotlin直接支持委托模式。Kotlin通过关键字by实现委托。
---
## let,run,applu,also
### let
- kotlin

```
fun test1(str: String?) {
    val ret = str?.let {
        print(it)
        it
    }
    print(ret)
}
```
- java

```
public static final void test1(@Nullable String str) {
  String var10000;
  if (str != null) {
     System.out.print(str);
     var10000 = str;
  } else {
     var10000 = null;
  }

String ret = var10000;
  System.out.print(ret);
}
```
---
### run
- kotlin

```
fun test2(str: String?) {
    val ret = str?.run {
        print(this)
        this
    }
    print(ret)
}
```
- java

```
public static final void test2(@Nullable String str) {
  String var10000;
  if (str != null) {
     System.out.print(str);
     var10000 = str;
  } else {
     var10000 = null;
  }

String ret = var10000;
  System.out.print(ret);
}
```
---
### apply
- kotlin

```
fun test3(str: String?) {
    val ret = str?.apply {
        print(this)
    }
    print(ret)
}
```
- java

```
public static final void test3(@Nullable String str) {
  String var10000;
  if (str != null) {
     System.out.print(str);
     var10000 = str;
  } else {
     var10000 = null;
  }

String ret = var10000;
  System.out.print(ret);
}
```
---
### also
- kotlin

```
fun test4(str: String?) {
    val ret = str?.also {
        print(it)
    }
    print(ret)
}
```
- java

```
public static final void test4(@Nullable String str) {
  String var10000;
  if (str != null) {
     System.out.print(str);
     var10000 = str;
  } else {
     var10000 = null;
  }

String ret = var10000;
  System.out.print(ret);
}
```
---

kotlin-compare-to-java

kotlin-compare-to-java 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

kotlin-compare-to-java

kotlin-compare-to-java 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README