1.构造方法,初始化代码块

java中                                                      
public class User {
  private String name;
  public user(String name) {
  this.name = name;
  }
//初始化代码块
  {
system.out.print("我是初始代码块")
  }
}
kotlin中
class User{
  var name:String
//构造方法
  constructor(name:String) {
  this.name = name
  }
  init {
  println("我是初始化代码块")
  }
} 
在AndroidStudio中创建构造参数,使用上面的写法,被提示"convert to primary constructor",修改为以下写法
class UserData(var age: Int) : UserDataSuper() {

}

1.1主构造函数 primary constructor

• 主构造函数没有方法体,但可以在init{}代码块中使用
• 主构造函数中的参数如果使用了var/val,等于在类中创建了一个同名的属性
• 主构造函数会参与到所有次级构造函数创建对象的初始化过程中,也就是创建次级构造函数,必须要调用主构造函数

class User(var name:String,var age:Int) {
    init {
            .....
    }
    constructor():this() {
    }
}

1.2次级构造参数

class TestClass(var name:String) {
    //直接调用主构造函数
    constructor(name:String,age:Int):this(name) {

    }
    
    //这里调用了上面的次级构造函数,属于间接调用主构造函数
    constructor(name:String,age:Int,id:String):this(name,age) {
        
    }
}

2.kotlin中去除静态变量和静态方法的写法,使用companion object

可以将一个类中的所有静态变量,方法,都统一写到伴生对象中,语义和阅读更舒适些

//1.object  关键字  修饰类,替换掉class,意思:创建一个类,并且创建这个类的对象
//kotlin中的单例, 而里面的方法,变量,都类似于静态变量和静态方法,直接全部用类名就可以调用
object User {
  val name:String = "liangpeng"
  fun userInfo() {

  }
//使用时,直接类名.方法名     User.userInfo()    User.name
}
//1.1 如果我不希望这个类是object,但我想让里面有静态函数或者静态变量怎么办呢?
class User {
    object InnerUser {
      val name:String = "liangpeng"
      fun say() {
      }
  }
}
//外部调用时
User.InnerUser.name
User.InnerUser.say()
//1.2 使用companion的写法,但kotlin不推荐
class User {
//这里直接去掉这个类的名字,调用时就可以直接调用里面的变量和函数
   companion object {
      val name:String = "liangpeng"
      fun say() {
      }
  }
}
//外部调用时
User.name
User.say()
//1.3 kotlin推荐的简便写法   top-level 顶层声明,隶属于package,是全局的
   val name:String = "liangpeng"
      fun say() {
      }
class User {
 
}

//调用时: 直接   
var myName = name
say()

3. object, companion object, 顶层声明,三者的使用场景

• 假如写一个工具类,就可以创建一个.kt文件,不用写类,直接写成顶层函数
• 假如是写一个单例,使用object
• companion object,就是伴生对象,慢慢去发掘更多的使用场景
  总结: 慢慢总结摸索,找到更适合他们的场景

4.const

针对编译期常量 compile-time constant 不太懂--

java中常量
public class MainActivity extends AppCompatActivity {
private static final String TAG = MainActivity.class.getName()
 ......
}
kotlin中
class MainActivity : AppCompatActivity {
companion object {
    const val TAG = MainActivity.class.getName()
  }
.....
}

5.kotlin中得匿名内部类

java中用new kotlin中用object 这两个关键字都修饰的是接口或抽象

首先看java中的:
public class TestClass {
        //匿名内部类
        ITestClass iTestClass = new ITestClass() {
            @Override
            public void method1(String name) {
                
            }
        };
}

kotlin中:
class KotlinTestClass {

   var iKotlinTestClass =  object :IKotlinTestClass {
        override fun method1(name:String):String {
            return "匿名内部类"
        }
    }

}

6.数组

可以看到 Kotlin 中的数组是一个拥有泛型的类，创建函数也是泛型函数，和集合数据类型一样。

对数组的操作可以像集合一样功能更强大，由于泛型化，Kotlin 可以给数组增加很多有用的工具函数：

• get() / set()
• contains()
• first()
• find()

java中
  protected void arrayTest() {

        String[] strs = {"1", "2", "3"};
        int[] ints = {1, 2, 3};
        String[] strs2 = new String[2];
        for (String str : strs) {

        }

        strs2[0] = "1";

    }
kotlin中:
     val arrayOf = arrayOf("1", "2", "3")
     var arrayof2:Array<String> = arrayOf("a","a")
   

• 不支持协变

Kotlin 的数组编译成字节码时使用的仍然是 Java 的数组，但在语言层面是泛型实现，这样会失去协变 (covariance) 特性，就是子类数组对象不能赋值给父类的数组变量：

kotlin中:
   fun test1() {
      //Error:  Type mismatch: inferred type is Array<Int> but Array<Any> was expected
        var str = arrayOf(1,2,3)
        var strParent:Array<Any> = str
    }
java 中:
   String[] str = {"1","2"};
    Object[] objects = str;

7集合

Kotlin 和 Java 一样有三种集合类型：List、Set 和 Map，它们的含义分别如下：

• List 以固定顺序存储一组元素，元素可以重复。
• Set 存储一组互不相等的元素，通常没有固定顺序。
• Map 存储 键-值 对的数据集合，键互不相等，但不同的键可以对应相同的值。

List

☕️
List<String> strList = new ArrayList<>();
strList.add("a");
strList.add("b");
strList.add("c"); 
🏝️            
val strList = listOf("a", "b", "c")

Kotlin 中的 List 多了一个特性：支持 covariant（协变）。也就是说，可以把子类的 List 赋值给父类的 List 变量：

🏝️
val strs: List<String> = listOf("a", "b", "c")
                👆
val anys: List<Any> = strs // success

☕️
List<String> strList = new ArrayList<>();
       👆
List<Object> objList = strList; // 👈 compile error: incompatible types

Set

☕️
Set<String> strSet = new HashSet<>();
strSet.add("a");
strSet.add("b");
strSet.add("c");
🏝️           
val strSet = setOf("a", "b", "c")

Map

创建,取值,修改

   fun mapTest(){
        var mapData:Map<String,Int> = mapOf("one" to 1,"two" to 2,"three" to 3)
        //取值
        println( mapData.get("one"))
        //取值2
        println(mapData["two"])

        var mapData2 = mutableMapOf("one" to 1,"two" to 2,"three" to 3)
        //修改值
        mapData2.put("one",111)
        //修改值2
        mapData2["two"] = 222
        for (mutableEntry in mapData2) {
            println("---"+mutableEntry.value)
        }
    }

注意:kotlin中得这三种集合都分可变集合和不可变集合的

• listOf() 创建不可变的 List，mutableListOf() 创建可变的 List。
• setOf() 创建不可变的 Set，mutableSetOf() 创建可变的 Set。
• mapOf() 创建不可变的 Map，mutableMapOf() 创建可变的 Map。

Sequence

三种创建方式:

sequenceOf("a", "b", "c")

val list = listOf("a", "b", "c")
list.asSequence()
                  
val sequence = generateSequence(0) { it + 1 }
                              

可见性修饰符

• public ：公开，可见性最大，哪里都可以引用。
• private：私有，可见性最小，根据声明位置不同可分为类中可见和文件中可见。
• protected：保护，相当于 private + 子类可见。
• internal：内部，仅对 module 内可见。

与java对比:

• protected: 包内和子类
• private: java中外部类可以访问private修饰的内部类,
  而kotlin中外部类不可以修改private修饰的内部类
• Java 中一个文件只允许一个外部类，所以 class 和 interface 不允许设置为 private，因为声明 private 后无法被外部使用，这样就没有意义了。
• Kotlin 允许同一个文件声明多个 class 和 top-level 的函数和属性，所以 Kotlin 中允许类和接口声明为 private，因为同个文件中的其它成员可以访问：