Kotlin學習筆記

基本類型

在 Kotlin 中，所有東西都是對象，在這個意義上講我們可以在任何變量上調用成員函數和屬
性。 一些類型可以有特殊的內部表示——例如，數字、字符和布爾值可以在運行時表示爲原
生類型值，但是對於用戶來說，它們看起來就像普通的類。 在本節中，我們會描述 Kotlin 中
使用的基本類型：數字、字符、布爾值、數組與字符串。

數字

kotlin在處理數字時與java類似,但又不完全相同.
例如在數字沒有隱式拓展;
有些情況下的字面值有所不同;
在kotlin中字符不是數字;

Double 64
Float 32
Long 64
Int 32
Short 16
Byte 8

十進制:  123
Long類型:123L
十六進制:0x01
二進制:0b11011000
不支持八進制
Double:123.5
Float:123.5f
可以使用下劃線增加數組的可讀性
val oneMillion=1_000_000

在 Java 平臺數字是物理存儲爲 JVM 的原生類型，除非我們需要一個可空的引用（如
Int?  ）或泛型。 後者情況下會把數字裝箱。

    fun box(v:View){
        val a:Int =10000
        Log.d("meee",""+(a === a));
        val b:Int?=a;
        val c:Int?=a;
        Log.d("meee",""+(b === c));//注意,裝箱後不保證同一性,這裏爲false

        //但會保持數字的相等
        Log.d("meee",""+(b == c));//true

        //假設代碼,實際上不能被編譯
        //Long 和Int即使值相等也不能陪判斷爲==
        val ten:Int? =10;
        val tenL:Long?=ten;
        Log.d("meee",""+(a==b));//false
        //所以同一性還有相等性都會在所有地方悄無聲息地失去
    }

顯式轉換

toByte(): Byte
toShort(): Short
toInt(): Int
toLong(): Long
toFloat(): Float
toDouble(): Double
toChar(): Char

        val byte:Byte=1
/*        //不能通過編譯
        val int:Int=byte*/
        //顯式轉換
        val int:Int=byte.toInt()

運算

Kotlin支持數字運算的標準集，運算被定義爲相應的類成員（但編譯器會將函數調用優化爲相
應的指令）

位運算

對於位運算，沒有特殊字符來表示，而只可用中綴方式調用命名函數
shl(bits)  – 有符號左移 (Java 的  <<  )
shr(bits)  – 有符號右移 (Java 的  >>  )
ushr(bits)  – 無符號右移 (Java 的  >>>  )
and(bits)  – 位與
or(bits)  – 位或
xor(bits)  – 位異或
inv()  – 位非

浮點數比較

相等性檢測： a == b  與  a != b
比較操作符： a < b  、  a > b  、  a <= b  、  a >= b
區間實例以及區間檢測： a..b  、  x in a..b  、  x !in a..b

    fun calculate(v:View){
        val num=0b1101_1000
        Log.d("meee",""+num);//216

        val num2=num shl  1
        Log.d("meee",""+num2);//432

        Log.d("meee",""+(0.9 in 1..10));
    }

字符

字符用  Char  類型表示。它們不能直接當作數字
    fun myChar(v:View){
        val char:Char='a'
        Log.d("meee","char:"+char);//a
/*        //編譯錯誤,類型不同不能判斷
        Log.d("meee",""+(char == 97));*/
        //可以對char進行顯式轉換
        Log.d("meee",""+(char.toInt() == 97));//true
    }

布爾

布爾用  Boolean  類型表示，它有兩個值： true  和  false  。
若需要可空引用布爾會被裝箱。

內置的布爾運算有：
||  – 短路邏輯或
&&  – 短路邏輯與
!  - 邏輯非

數組

數組在 Kotlin 中使用  Array  類來表示，它定義了  get  和  set  函數（按照運算符重載約定
這會轉變爲  []  ）和  size  屬性，以及一些其他有用的成員函數：

class Array<T> private constructor() {
val size: Int
operator fun get(index: Int): T
operator fun set(index: Int, value: T): Unit
operator fun iterator(): Iterator<T>
// ……
}

    fun myArray(v:View){
        //創建方式一
        val numArray= arrayOf(1,2,3)
        Log.d("meee",""+numArray[0]);//1,[]代表數組的get set
        Log.d("meee",""+numArray[1]);//2
        Log.d("meee",""+numArray[2]);//3
        //創建一個大小爲3空數組
        var nullArray= arrayOfNulls<String>(3)

        //創建方式二
        val asc=Array(5,{i -> (i*i).toString()})//i爲0 1 2 3 4
        Log.d("meee",""+asc[0]);
        Log.d("meee",""+asc[1]);
        Log.d("meee",""+asc[2]);
        Log.d("meee",""+asc[3]);
        Log.d("meee",""+asc[4]);

        /*與 Java 不同的是，Kotlin 中數組是不型變的（invariant）。這意味着 Kotlin 不讓我們把
         *Array<String>  賦值給  Array<Any>  ，以防止可能的運行時失敗*/
    }

Kotlin 也有無裝箱開銷的專門的類來表示原生類型數組:  ByteArray  、
ShortArray  、 IntArray  等等。這些類和  Array  並沒有繼承關係，但是它們有同樣的方法屬
性集。它們也都有相應的工廠方法:
val x: IntArray = intArrayOf(1, 2, 3)
x[0] = x[1] + x[2]

字符串

字符串用  String  類型表示。字符串是不可變的。 字符串的元素——字符可以使用索引運算
符訪問:  s[i]  。 可以用  for  循環迭代字符串:

    fun string(v:View){
        val str:String="a你b好c啊d"
        for(char in str){
            Log.d("meee",""+char);
        }
    }

字符串字面量

//轉義字符
        val helloworld="hello \n world"
        Log.d("meee",""+helloworld);

        //原生字符串,不識別任何轉義字符
        val rawString="""
            |\b \n for in
            |"\"/"
        """
        Log.d("meee",""+rawString);
        //可以通過trimMargin()來去除前導空格
        //默認  |  用作邊界前綴，但你可以選擇其他字符並作爲參數傳入，比如  trimMargin(">")  。
        Log.d("meee",""+rawString.trimMargin());

字符串模版

        val pwd="admin"
        Log.d("meee","電腦的解鎖密碼是$pwd");//電腦的解鎖密碼是admin
        Log.d("meee","電腦的解鎖密碼是${pwd.toString()}");//電腦的解鎖密碼是admin
如果你需要在原生字符串中表示字面值  $  字符
（它不支持反斜槓轉義），你可以用下列語法：
        val rawStr2="""
        |電腦的解鎖密碼是${'$'}
        """
        Log.d("meee",""+rawStr2.trimMargin());//電腦的解鎖密碼是$

包

與 Java 不同，Kotlin 沒有單獨的“import static”語法； 所有這些聲明都用  import  關鍵字導
入。
//引包
package foo.bar
//如果出現名字衝突，可以使用  as  關鍵字在本地重命名衝突項來消歧義：
import foo.Bar // Bar 可訪問
import bar.Bar as bBar // bBar 代表“bar.Bar”

默認導入
有多個包會默認導入到每個 Kotlin 文件中：
kotlin.*
kotlin.annotation.*
kotlin.collections.*
kotlin.comparisons.* （自 1.1 起）
kotlin.io.*
kotlin.ranges.*
kotlin.sequences.*
kotlin.text.*

根據目標平臺還會導入額外的包：
JVM:
java.lang.*
kotlin.jvm.*

JS:
kotlin.js.*

If語句

    fun testIf(v:View){
        val a=1;
        val b=2
        if(a<b){
            Log.d("meee","a<b");
        }
        if (b<a){

        }else{
            Log.d("meee","b>a");
        }
        //在kotlin中 if  是一個表達式，即它會返回一個值
        //如果爲代碼塊,則最後爲該塊的值
        //if  作爲表達該表達式需要有  else  分支。
        var min=if (a<b) {
            Log.d("meee","= =")
            a
        } else {11.1}
        Log.d("meee","min:"+min);//1
    }

When

類似switch,
也可以作爲表達,同樣必須要有else分支
when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    else -> { // 注意這個塊
        print("x is neither 1 nor 2")
    }
}
//如果很多分支需要用相同的方式處理，則可以把多個分支條件放在一起，用逗號分隔：
    fun testWhen2(v:View){
        var x:Int=3
        val str=when(x){
            1,3,5 -> "單數"
            2,4,6 -> "雙數"
            else -> "超出計算能力"
        }
        Log.d("meee",""+str);
    }
//可以使用任意表達式作爲分支條件
    fun testWhen2(v:View){
        var x:Int=3
        val str=when(x){
            1,3,5 -> "單數"
            2,4,6 -> "雙數"
            //方法
            getTen() ->  "喲呵你還能輸入個10進來"
            //區間
            in 666..999 -> "666"
            //也可以通過類型判斷,並且會自動轉化,當然這裏是編譯不通過的
            is String -> "string"
            else -> "超出計算能力"
        }
        Log.d("meee",""+str);
    }
    fun getTen():Int=10;
//when  也可以用來取代  if  - else   if  鏈。 如果不提供參數，所有的分支條件都是簡單的布
爾表達式，而當一個分支的條件爲真時則執行該分支：
when {
x.isOdd() -> print("x is odd")
x.isEven() -> print("x is even")
else -> print("x is funny")
}

For

for  循環可以對任何提供迭代器（iterator）的對象進行遍歷，這相當於像 C# 這樣的語言中
的  foreach  循環。語法如下：
for (item in collection) print(item)
循環體可以是一個代碼塊。
for (item: Int in ints) {
// ……
}
如上所述， for  可以循環遍歷任何提供了迭代器的對象。即：
有一個成員函數或者擴展函數  iterator()  ，它的返回類型
有一個成員函數或者擴展函數  next()  ，並且
有一個成員函數或者擴展函數  hasNext()  返回  Boolean  。
這三個函數都需要標記爲  operator  。

//如果你想獲取數組或者集合的索引
//注意這種“在區間上遍歷”會編譯成優化的實現而不會創建額外對象。
        //list
        val list= ArrayList<String>()
        list.add("你")
        list.add("好")
        list.add("啊")
        for (index in 0 until list.size){
            Log.d("meee",""+list.get(index));
        }
        for ((index,value) in list.withIndex()){
            Log.d("meee","index is $index,value is $value");
        }  
        //數組
        val arr= arrayOf("1","2","3")
        for (i in arr.indices){
            Log.d("meee",""+arr[i]);
        }
        for ((index,value)in arr.withIndex()){
            Log.d("meee","index is $index,value is $value");
        }      

While doWhile

同java

返回和跳轉

Kotlin 有三種結構化跳轉表達式：
return  。默認從最直接包圍它的函數或者匿名函數返回。
break  。終止最直接包圍它的循環。
continue  。繼續下一次最直接包圍它的循環。

所有這些表達式都可以用作更大表達式的一部分：
val s = person.name ?: return//返回類型爲Nothing

標籤的使用

    fun testLabel(v:View){
        //labelName@創建標籤
        loop@ for (x in 1..100){
            if (x%10==0){
                //continue@loop跳過這次循環
                continue@loop
            }
            if (x==51){
                //終止這次循環
                break@loop
            }
            Log.d("meee","x:"+x);
        }
    }
    funct@{
    //結束方法
        return@lit
    }
    //隱式標籤,該標籤與接受該lambda 的函數同名。
    fun foo() {
        ints.forEach {
        if (it == 0) return@forEach
        print(it)
    }
}

類與繼承

    //類的聲明由類名 類頭(類型參數,主構造器) 類體組成
    class TestClass1(val height:Double){

    }
    //類頭和類體在不需要時可以省略
    class TestClass2

構造器

    //構造函數:一個主構造函數和多個次構造函數
    class TestClass3 constructor(name:String){

    }
    //如果主構造器沒有任何註解或者可見性修飾符,可以省略constructor這個關鍵字
    class Test4 (name:String){

    }

    //主構造函數不能包含任何的代碼,初始化的代碼可以放到以init關鍵字修飾的代碼塊中
    class TestClass5(var name:String){
        //函數有順序,現在的property是my name is $傳入的參數,但如果放在init之後,則變成了sb
        val property="my name is $name"
        init{
            name="sb";
        }
    }
    //如果構造函數有註解或可見性修飾符，這個  constructor  關鍵字是必需的，並且這些修飾符在它前面：
/*    class Customer public @inject constructor(name: String) {

    }*/

    //次構造器
    class Person2 {
        constructor (name:String) {

        }
        constructor () {

        }
    }

    class Person() {
        //次級構造器必須包含主構造器,或者通過別的次級構造器間接委託
        constructor(name: String) : this() {

        }
        constructor(id:Int,name:String):this(name){

        }
    }

    /*初始化塊中的代碼實際上會成爲主構造函數的一部分。委託給主構造函數會作爲次
    構造函數的第一條語句，因此所有初始化塊中的代碼都會在次構造函數體之前執行。即使該
    類沒有主構造函數，這種委託仍會隱式發生，並且仍會執行初始化塊：*/
    class Constructors {
        init {
            println("Init block")
        }
        constructor(i: Int) {
            println("Constructor")
        }
    }

把java文件轉換成kotlin

code>>convert java file to kt file

javaBean類

//data關鍵字表明是javabean類
data class User(
        var age :Integer,
        var name:String)
/*會爲  User類提供以下功能：
所有屬性的 getters （對於  var  定義的還有 setters）
equals()
hashCode()
toString()
copy()
所有屬性的  component1()  、  component2()  ……等等（參見數據類）*/

擺脫fvbi

在module的gradle中應用
apply plugin: 'kotlin-android-extensions'

//可以直接通過控件的id訪問該控件,順便....不用寫分號,真滴難受
button.text="你好啊"

方法

    //普通方法
    fun add(a: Int, b: Int): Int {
        return a + b
    }

    //將表達式作爲方法的返回值時,會自動判斷返回類型
    fun add2(a: Int, b: Int) = a + b

局部常量

定義
        val a:Int  =1
        //自動推斷
        val b=1
        //沒有初始化則不能自動推斷,且只能被賦值一次,未賦值使用編譯報錯
        val c:Long

局部變量

var x:Int =1;

全局變量和常量

全局常量和變量與局部變量相同,但是必須在定義時初始化或抽象修飾

Lamdba的使用

button.setOnClickListener(object:View.OnClickListener{
            override fun onClick(v: View?) {
                TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
            }
        })
button.setOnClickListener{view->

        }
button.setOnClickListener{

        }

字符串模版

        var a:String="小黃"
        val saying="你是$a"//saying:你是小黃
        //{}內是代碼
        val saying2="你是${a.replace("小黃","老江")}"//saying2:你是老江

使用可空值

    //返回類型可以爲null
    fun getNull():Int?{
        return null
    }
    public fun test(view:View){
        var n=getNull()
        //使用可空值時,必須進行非空判斷
        if (n!=null){
            var x=n+1
            Log.d("meee","x:"+x);
        }
        //或者空檢測
        if (n==null){
            return;
        }
    }

類型檢測

//自動類型轉換
如果一個不可變的局部變量或屬性已經
判斷出爲某類型，那麼檢測後的分支中可以直接當作該類型使用，無需顯式轉換

    //is,類型java中的instance of
    public fun test2(view:View){
        val str:String="你好啊";
        val stringLength = getStringLength(str)
        Log.d("meee","stringLength:"+stringLength)//3
    }
    //Any表示任意類型
    fun getStringLength(obj:Any):Int?{
        if (obj is String){
            //類型判斷後,則默認obj是判斷的類型
            return obj.length
        }else {
            return null;
        }
    }

//反過來用也行
    fun getStringLength2(obj:Any):Int?{
        if (obj !is String){
            //類型判斷後,則默認obj是判斷的類型
            return null
        }else {
            return obj.length;
        }
    }

//會在判斷條件&&右邊自動轉換
    fun getStringLength3(obj:Any):Int?{
        if (obj is String &&obj.length!=0){
            return obj.length
        }
        return null
    }

集合類的創建

var list:ArrayList<String> = ArrayList()//=前要有個空格,否則編譯報錯

For循環

    fun testfor(view:View){
        var list:ArrayList<String> = ArrayList()
        val list2= listOf<String>("你好","你好","你好");
        list.add("你好啊")
        list.add("你好啊")
        list.add("你好啊")
        list(list)

        //不包括100
        for (i in 0 until 100){
            Log.d("meee","哈哈"+i);//輸出至哈哈99
        }
    }
    fun list(list:ArrayList<String>){
        //類似增強型for循環了
        for(item in list){
            Log.d("meee",item);
        }
    }

When表達式

//類似switch
    fun getItemName(index:Int):String{
        when(index){
            0 ->return "Zero"
            1 ->return "One"
            2 ->return "Two"
            else->return "Null"//類似default
        }
    }

分號的作用

分割同一行的不同函數

Range

    //使用in運算符來檢測某個數字是否在指定區間內
    fun testRange(view:View){
        Log.d("meee","38:"+isIn39to50(38));//false
        Log.d("meee","39:"+isIn39to50(39));//true
        Log.d("meee","49:"+isIn39to50(49));//true
        Log.d("meee","50:"+isIn39to50(50));//true

        Log.d("meee","38:"+isNotIn39to50(38));//true
        Log.d("meee","39:"+isNotIn39to50(39));//false
        Log.d("meee","49:"+isNotIn39to50(49));//false
        Log.d("meee","50:"+isNotIn39to50(50));//false


    }
    fun isIn39to50(num:Int):Boolean{
        if (num in 39..50){
            return true;
        }
        return false;
    }
    fun isNotIn39to50(num:Int):Boolean{
        if (num !in 39..50){
            return true;
        }
        return false;
    }

區間迭代

    //區間迭代--------------------------------------------------------------------------------------
    fun testRangeIterator(view:View){
        //包括100,step表示間隔
        for (x in 3 .. 100 step 1){
            Log.d("meee","x:"+x);
        }
        //包括100,step表示間隔
        for (x in 99 downTo  0 step 3){
            Log.d("meee","y:"+x);
        }
    }

集合迭代

    //集合迭代--------------------------------------------------------------------------------------
    fun CollectionIterator(view:View){
        val datas= setOf("apple","banana","pineApple")
        for(data in datas){
            Log.d("meee",""+data);
        }
    }

使用in判斷集合中是否包含某元素

        //使用  in  運算符來判斷集合內是否包含某實例
        when{
            "apple" in datas -> Log.d("meee","已經買蘋果啦");
            "xxx" in datas -> Log.d("meee","並沒有xxx");//沒有打印
        }

用Lambda對集合進行篩選

    fun LambdaFilter(view:View){
        val fruits = listOf("banana", "avocado", "apple", "kiwi")
        fruits.filter { it.startsWith("a") }//篩選出以a開頭的
                .sortedBy { it }//排序
                .map { it.toUpperCase() }//映射
                .forEach{
                    Log.d("meee",it);//遍歷
                }

        //過濾
               val datas=fruits.filter { x-> x.startsWith("a") }
        Log.d("meee","datas:"+datas);
        //等價於
        val datas2=fruits.filter { it.startsWith("a") }
        Log.d("meee","datas2:"+datas2);
    }

類 抽象類 接口

//普通類
   class Circle(val radius:Double){
        fun getArea():Double=radius*radius*Math.PI
    }

    //抽象類
    abstract class Shape(val sides:List<Double>){
        abstract fun getArea():Double
        val sideNum:Double get()=sides.sum()
    }

    //接口
    interface IsColored{
        val isColored:Boolean
    }

    //繼承和實現
    class Rectangle(
            var height:Double,
            var width:Double
    ):Shape(listOf(11.2,1.0)) ,IsColored{
        override val isColored: Boolean=true
        override fun getArea(): Double =height*width
    }
    class Triangle(var Height:Double
                   ,var Width:Double
    ):Shape(listOf(11.1)),IsColored {
        override val isColored: Boolean=true
        override fun getArea(): Double=Height*Width
        override fun toString(): String ="Triangle(Height=$Height, Width=$Width, isColored=$isColored,Sidenum=$sideNum)"
    }

    //測試
    fun newClass(view:View){
        //創建對象
        var circle=Circle(10.0)
        Log.d("meee","circle:"+circle);//Circle(radius=10.0)
        Log.d("meee","circle:"+circle.getArea());//314.1592653589793

        val tri= Triangle(11.1,11.1)
        Log.d("meee","tri:"+tri);//Triangle(Height=11.1, Width=11.1, isColored=true,Sidenum=11.1)
        Log.d("meee","tri:"+tri.sideNum);//tri:11.1
        Log.d("meee","tri:"+tri.getArea());//tri:123.21
    }

函數的默認參數

fun noParamFunction(a:Int=0,b:Int=1)=a+b

用when關鍵字進行類型判斷

    fun testJudgeByWhen(obj:Any){
        when(obj){
            is String -> Log.d("meee","類型爲string"+obj.length);
            is Int -> Log.d("meee","類型爲Int");
            else  -> Log.d("meee","unkonw");
        }
    }

遍歷map(key-value)集合

    fun listMap(v:View){
        val map=HashMap<Int,String>()
        map.put(1,"小黃")
        map.put(2,"老江")
        map.put(3,"竈傑")
        Log.d("meee","map:"+map);
        for((k,v) in map){
            Log.d("meee","$k 映射 $v");
        }
    }

創建只讀list map

    //創建只讀list map
    fun readOnlyListAndMap(v:View){
        val list= listOf<String>("1","2","3")
        val map= mapOf<Int,Int>(1 to 100,2 to 300,3 to 1000)
    }

ByLaze

    fun ByLazy(v:View){
        //第一次被調用時就被初始化，想要被改變只能重新定義,只能在val上使用
        val str:String by lazy { "你好啊" }
        Log.d("meee","str:"+str);
    }

拓展函數

    fun String.addFun(){
        Log.d("meee","= =");
    }
    fun String.toLowerCase(){
        Log.d("meee","= =");
    }
    fun extendFunction(view:View){
        "你好啊".addFun()
        //如果存在同名的方法,則默認以覆蓋爲準
        "s".toLowerCase()//Log.d("meee","= =");
    }

單例

object SingleInstance{
    val name="小黃"
}

    fun singleInstance(v:View){
        Log.d("meee","SingleInstance.name:"+SingleInstance.name);
        Log.d("meee","SingleInstance:"+SingleInstance);
    }

非空判斷的縮寫

    //非空判斷的縮寫
    fun notNull(v:View){
        var str:String?=null
        //非空判斷執行對象的方法
        str?.addFun()//不會執行addFun();

        //if not null
        val str2="12"
        str2?.let {
            Log.d("meee","str2不爲空");
        }
        //if null
        val str3:String?=null
        str3?:Log.d("meee","str3爲空");

        //if not null and else
        val obj=str?.length?:"空的"
        Log.d("meee",""+obj);//"空的"
    }

以When表達式爲返回值

    fun returnWhen(v:View){
        Log.d("meee",""+returnWhen("red"));
        Log.d("meee",""+returnWhen("blue"));
        Log.d("meee",""+returnWhen("unkonw"));
    }
    fun returnWhen(color:String):String{
        return when(color){
            "red" -> "紅色"
            "green" -> "綠色"
            "blue" -> "藍色"
            else -> "找不到該顏色"
        }
    }

try-cache表達式

    fun tryCache(v:View){
        var str=try {
            throw RuntimeException("呵呵")
            "你好啊"
        }catch (e: RuntimeException){
        }
        Log.d("meee",""+(str==null));
    }

對同一個對象調用多個方法>>With 關鍵字的使用

    fun MutilMethodCall(v:View){
        val tri=Tri()
        with(tri){
            //在with關鍵字內可以直接調用該對象的方法
            for(x in 1..5){
                add1()
                add2()
                add3()
            }
        }
    }
    class Tri(){
        fun add1(){
            Log.d("meee","side1");
        }
        fun add2(){
            Log.d("meee","side2");
        }
        fun add3(){
            Log.d("meee","side3");
        }
    }

FileIo流的使用方法(親測不行,找不到Files類)

val stream = Files.newInputStream(Paths.get("/some/file.txt"))
stream.buffered().reader().use { reader ->
println(reader.readText())
}

泛型返回值的使用

inline fun <reified T: Any> Gson.fromJson(json: JsonElement): T = this.fromJson(json,
T::class.java)

可空布爾值的使用

    fun notBoolean(v:View){
        val flag:Boolean?=null
        if(flag==true){
            Log.d("meee","true");
        }else{
            Log.d("meee","false or null");
        }
    }

同步方法

        @Synchronized
        fun getInstance():APP {
            if(app==null){
                app=APP()
            }
            return app as APP
        }

靜態方法

    //companion object表示伴隨object,也就是java的靜態方法的意思
    companion object{
        var app: APP? = null

        @Synchronized
        fun getInstance():APP {
            if(app==null){
                app=APP()
            }
            return app as APP
        }
    }

Kotlin獲取class方法

//親測報錯,ActivityNotFoundException
intent.setClass(context,NotepadActivity.javaClass)
//  ::  操作符來獲取指向特定對象實例的方法或屬性的成員引用
intent.setClass(context,NotepadActivity::class.java)

抽象類的實現

        val mAdapter = object : HolderAdapter<String, CommonViewHolder>(context, list, id) {
            override fun bindDatas(holder: CommonViewHolder, data: String, position: Int) {

            }
        }