Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/ucodeustory/kotlinnote
Kotlin 学习笔记
https://github.com/ucodeustory/kotlinnote
android kotlin mvp
Last synced: 5 days ago
JSON representation
Kotlin 学习笔记
- Host: GitHub
- URL: https://github.com/ucodeustory/kotlinnote
- Owner: UCodeUStory
- Created: 2018-03-13T01:34:53.000Z (over 6 years ago)
- Default Branch: master
- Last Pushed: 2018-09-13T15:28:22.000Z (about 6 years ago)
- Last Synced: 2023-08-25T03:28:46.952Z (about 1 year ago)
- Topics: android, kotlin, mvp
- Language: Kotlin
- Homepage:
- Size: 1.79 MB
- Stars: 6
- Watchers: 2
- Forks: 2
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Kotlin 学习笔记
### Kotlin
- 1. Kotlin 特性
- - 1. 简洁，在Kotlin中，努力地保证你写的代码都具有实际的意义，而不是仅仅满足代码结构，许多Java样中，如get，set方法，和构造方法参数赋值
给字段的逻辑，在Kotlin都将是隐式的，并不会是你的代码变得混乱；同时Kotlin支持lambda，让小代码块可以轻松传递给函数库
。这让你可以办公共部分封装到函数库中，而在用户代码中仅保留特定的针对任务的实现；
越简洁的代码写起来花的时间更少，更重要读起来耗费的时间也短。这会提高生产力。
- - 2. 安全
- - 3. 互操作性
- 2. 基础
- - 1. 函数
- - 2. 语句和表达式
- - - 1. 在kotlin if 是一个表达式，并不是声明，两者区别，在于，表达式有值他可以作为另一个表达式的一般不分，
声明没有值，在Java中所有控制结构都是声明，在Kotlin中除了for do while都是表达式
- - 3. 表达式体的函数更多代替代码块体函数
//一般写法
fun max(a:Int,b:Int):Int{
return if(a>b) a else b;
}
// 将代码块主体替换表达式主体
fun max(a:Int,b:Int):Int = if(a>b) a else b;
// 省略返回值
fun max(a:Int,b:Int) = if(a>b) a else b;
- - 4. 变量与常量
- - - 1. 常量
val name1 = "John"
//可以省略类型
val name2:String = "Bob"
- - - 2. 变量
var age1:Int = 23
var age2 = 12
- - 3. 类
//java
public Person{
private final name;
public Person(String name){
this.name = name;
}
}
//kotlin
class Person(var name:String,val age:Int)
//var定义的是可读写属性，val定义的是只读属性，也就相当于没有get方法
//kotlin 中将get 和set方法进行隐藏了，赋值和访问我们只需要通过对象.属性就可以访问
自定义获取器,判断是否是成年人，person.isAdult
val isAdult:Boolean
get() {
return age>18
}
//定义枚举
enum class Color(val r:Int,val g:Int,val b:Int ) {
RED(255,0,0),ORANGE(255,265,0),YELLOW(255,255,0);
fun rgb()=(r*256+g)*256 + b;
}
//when 代替Javaswitch ；else 里面相当于default,因为必须有个返回值
fun test_when(age:Int)= when(age){
1->"zhangsan"
2->"lisi"
3->"wangwu"
else -> {
"no find"
}
}
// 强化java中instance of ，kotlin用is
- - 4. 迭代
while 和java用法一样
@Test
fun test_for_up(){
for(i in 1..100){
System.out.println("index="+i);
}
}
@Test
fun test_for_down(){
for(i in 100 downTo 1 ){
System.out.println("index="+i);
}
}
@Test
fun test_for_step(){
for(i in 1..100 step 2){
System.out.println("index="+i);
}
}
@Test
fun test_iterator_map(){
val binaryReps = TreeMap()
for (c in 'A'..'F'){//创建字符区间
val binary = Integer.toBinaryString(c.toInt()) //将 ASCII 码转化成二进制
binaryReps[c] = binary //根据 key 为c 把 binary 存到 map 中
}
for ((letter, binary) in binaryReps){//迭代 map，把 key 和 value 赋值给变量
println("$letter = $binary")
}
}
- - 5. 异常
@Test
fun test_try_catch(){
try{
var sum = 1/0;
}catch (e:Exception){
System.out.println("异常"+e.localizedMessage);
}finally {
System.out.println("finally");
}
}
@Test
fun test_try_catch_expression(){
var num = try {
// Integer.valueOf(11)
// 22
// 1/0
}catch (e:Exception){
System.out.println("异常"+e.localizedMessage);
0//表达式最后一行作为值
}finally {
System.out.println("finally");
}
System.out.println("num="+num);
}
- - 6. 集合
@Test
fun test_set(){
var setTest = hashSetOf()
setTest.add("set0")
setTest.add("set1")
setTest.add("set2")
println(setTest)
println("set-size="+setTest.size)
println(setTest.contains("set0"));
println(setTest.javaClass);
}
@Test
fun test_list(){
var listTest = listOf("23","345","wer")//只读list
println(listTest.size)
println(listTest)
println(listTest.javaClass)
var mutableList: MutableList = arrayListOf();//读写list
mutableList.add("list0")
mutableList.add("list1")
mutableList.add("list2")
println(mutableList)
println(mutableList.javaClass)
mutableList.forEach {
println(it)
}
for (s in mutableList) {
println(s)
}
for (i in 0..mutableList.size-1){
println("index="+i +"data="+mutableList[i])
}
}
@Test
fun test_map(){
var map = mapOf("one" to 1,"two" to 2,"three" to 3)//只读map
println(map["two"])
for ((key,value) in map){
println("key="+key+" value="+value)
}
}
- - 7. 指定参数名
joinToString(collection = mutableList,separator = ",",prefix = "(",postfix = ")");
- - 8. 指定默认值实现重载
fun joinToString(collection:Collection,separator:String = ",",prefix:String = "(",postfix:String=")"):String{
var result = StringBuilder(prefix)
for((index,element) in collection.withIndex()){
if (index>0)result.append(separator)
result.append(element)
}
result.append(postfix)
return result.toString()
}
var str3 :String = joinToString(collection = mutableList)
var str4 :String = joinToString(collection = mutableList,separator = "^")
- - 9. 静态方法
package util
fun getProductName():String{
return "KotlinSMVP"
}
import util.getProductName
- - 10. 扩展方法
扩展方法只是静态方法的高效语法，可以指定具体的类型接收器
/**
* 全部的集合扩展joinString方法
*/
fun Collection.joinString(
separator:String = ",",prefix:String = "(",postfix:String=")"
):String{
var result = StringBuilder(prefix)
for((index,element) in this.withIndex()){
if (index>0)result.append(separator)
result.append(element)
}
result.append(postfix)
return result.toString()
}
不可以覆盖的扩展方法，因为扩展函数并不是类一部分，而是属于类的外部，被调函数依赖于已声明的静态类型
- - 11. 创建接收任意数量的参数方法
/**
* 创建接收任意参数数量的方法
*/
fun createList(vararg params:T):List{
var list = ArrayList()
params.forEach {
list.add(it)
}
return list
}
- - 12. 接口(有默认实现方法和无默认实现方法)
- - 13. 类(默认作用域是final不可继承)
- - - 1. 允许创建子类需要open修饰
open class Person (var name:String,val age:Int){
val isAdult:Boolean
get() {
return age>23
}
}
- - - 2. 修饰方法(open可以被重写覆盖 final不可被重写覆盖 abstract必须被重写)
- - - 3. 可见性(public所有地方可见,internal模块内可见,protect 子类可见，private类内部可见)
- - 14. 内部类和类嵌套
- - - 1. inner修饰的类持有外部类引用，同时创建也依赖外部类对象，其他类不持有外部类引用
@Test
fun test_innerClass(){
var outTest:OutTest = OutTest();
println(outTest.getName());
var innerTest:OutTest.InnerTest = outTest.InnerTest()
println(innerTest.getName()+"--"+innerTest.getOurReference().getName())
var test:OutTest.Test = OutTest.Test();
println(test.getName())
}
- - 15. 密封类（超强的枚举）
/**
* sealed 密封类 这一好处是，现在when表达式要求我们为所有可能的类型提供分支：
*/
fun calculate (x:Int,operation: Operation)=when(operation){
is Operation.Add -> x + operation.value
is Operation.Substract -> x - operation.value
is Operation.Multiply -> x * operation.value
is Operation.Divide -> x/operation.value
}
- - 16. 主构造器和初始化器
- - 17. 委托
- - - 1. 类委托
/**
* 委托，类似装饰器模式，相比Java实现一个装饰器模式，需要实现注入对象，并且把每个方法都写出来，
* 而这里的委托，比较好是有一种继承的效果，只有需要实现的方法写出来就可以，其他的自动委托
*/
@Test
fun test_delegate(){
val b = BaseImpl(10)
Derived(b).print() // 输出 10
}
// 创建接口
interface Base {
fun print()
}
// 实现此接口的被委托的类
class BaseImpl(val x: Int) : Base {
override fun print() { print(x) }
}
// 通过关键字 by 建立委托类
class Derived(b: Base) : Base by b
- - - 2. 属性委托
/**
* 委托属性可以达到延迟加载的效果
*/
@Test
fun test_delegate_var(){
val e = Example()
println(e.p) // 访问该属性，调用 getValue() 函数
e.p = "Runoob" // 调用 setValue() 函数
println(e.p)
}
// 定义包含属性委托的类
class Example {
var p: String by Delegate()
}
// 委托的类
class Delegate {
operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
println("getValue")
return "$thisRef, 这里委托了 ${property.name} 属性"
}
operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
println("setValue")
println("$thisRef 的 ${property.name} 属性赋值为 $value")
}
}
//可以实现的单例模式
class Example1{
//lazy 方法只会被调用一次，而且只能作为常量才可以使用，因此适合做单例模式
val lazyValue: String by lazy {
println("computed!") // 第一次调用输出，第二次调用不执行
"Hello"
}
}
//可以观察前后值得变化
class User {
var name: String by Delegates.observable("初始值") {
prop, old, new ->
println("旧值：$old -> 新值：$new")
}
}
- - 18. 静态属性和方法
class Utils {
companion object {
val isDebug:Boolean = false;
fun test():String{
return "Hello"
}
}
}
- - 19. 匿名内部类
view.setOnClickListener(object:OnClickListener{
override fun onclick() {
println("onclick!")
}
})
- - 20. Lambda
@Test
fun test_lambda(){
var sum = {a:Int,b:Int ->
println("a="+a)
a+b}
println(sum(10,10))
var index = 1;
var list = listOf("aaa","bbb");
list.forEach {
println(index)
println(it)
}
}
- - 21. 集合通过 filter,map 筛选和修改
@Test
fun test_list_filter(){
var list = listOf("aaa","bbb","ccc");
list.filter { it.equals("aaa") }
println(list)
}
class Tester(val name:String)
@Test
fun test_list_map(){
var list = listOf( Tester("AAA"),Tester("BBB"),Tester("CCC"));
var targetList = list.map { it.name }// 相当于每一项变成it.name
println(list)
println(targetList)
var numList = listOf(1,2,3,4,5);
var targetNums = numList.map { it*2 }// 相当于每一项变成it*2
println(targetNums)
}
@Test
fun test_map_filter(){
var maps = mapOf(1 to "one",2 to "two")
var targetMap = maps.filterKeys { it>1 }
println(targetMap)
var targetMap2 = maps.filterValues { it.equals("one") }
println(targetMap2)
}
@Test
fun test_map_map(){
var maps = mapOf(1 to "one", 2 to "two", 3 to "three")
var targetmap = maps.mapKeys { it.key *2 }
println(targetmap)
var targetMap2 = maps.mapValues { it.value+"_qy" }
println(targetMap2)
}
- - 22. 集合 all,any,count, find
@Test
fun test_collection_all_any_count_find_groupby(){
var list = listOf(1 ,2 ,3 ,4 ,5)
println(list.all { it> 2 })
println(list.any { it> 2 })
println(list.find { it > 2 })
println(list.count { it> 2 })
}
- - 23. with使用
/**
* 使用with 省去变量使用
*/
@Test
fun test_with(){
// var result = StringBuilder()
// result.append('[')
// for (letter in 'A'..'Z'){
// result.append(letter)
// }
// result.append(']')
//
// println(result.toString())
var result = with(StringBuilder()){
append('[')
for(letter in 'A'..'Z'){
append(letter)
}
append(']')
this.toString();
}
println(result)
}