Kotlin 基础

/*
jetpack:ViewModol、Lifecycle、Livedata（观察者模式）、Room、WorkManager
*/
class MyThread : Thread(){
    override fun run(){
        println("Thread()")
        count()
    }
}

class MyThread1 : Runnable{
    override fun run() {
        println("Runnable")
        count()
    }
}

@Synchronized
fun count(){
    for (i in 10 downTo 1 step 3) println(i)
}

fun main(){

    val list = mutableListOf("af","we")
    val map = HashMap<String,Int>()

    val s = Student()
    val e = sExtend(20)

    list.add("werwd")
    map["apple"] = 1

    MyThread().start()
    val myThread = MyThread1()
    Thread(myThread).start()

    Thread{
        println("Lambda_Thread")
        println("fajn38".lettersCount())
        count()
    }.start()

    thread {
        println("Lambda_Kotlin")
    }
    s.name = "张三"
    s.age = 10
    s.eat()
    var a = 0
    var b = 1


  //  for (i in 1 until 10 step 1)  println(i)



    println(score("Tom"))
}

fun score(name : String): Int = when(name){
    "Tom" -> 60
    "Jeans" -> 70
    else -> 0
}

fun count1(num : Int, num1: Int) : Int = if(num > num1) num else num1

socket

class FirstActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.first_layout)

        supportActionBar?.hide()

        val updateText = 1

        //泛型
        class fanxing<T>{

            fun mothod(i:T) : T{
                return i
            }
        }

        class fan{

            fun <T> mothod2(j : T) : T{
                return j
            }
        }
        
        //单例类
        /*
         object Util{
         fun doAction(){
                println("单例类")
            }
        }
        
        //静态实现：加注解或顶层方法（新建一个.kt file 文件中的方法）
        class Util{
            companion object{
                
                @JvmStatic  //只能加在单例类或companion object中的方法上
                fun doAction(){
                    println("单例方法")
                }
            }
        }
        */

        //Handler
        val handler = object : Handler(Looper.getMainLooper()){
            override fun handleMessage(msg: Message) {
                when(msg.what){
                    updateText -> textView.text = "Nice !!!"
                }
            }
        }

        button1.setOnClickListener {
            val data = "abc"
            val intent = Intent(this,SecondActivity::class.java)
            intent.putExtra("extra_data",data)
            //val intent = Intent("com.example.android_ktest.ACTION_START")
            //val intent = Intent(Intent.ACTION_VIEW)
            //intent.data = Uri.parse("https://www.baidu.com")
            startActivity(intent)
          //  finish()
        }

        button_change.setOnClickListener {
            val msg = Message()
            msg.what = updateText
            handler.sendMessage(msg)
        }


    }

    override fun onCreateOptionsMenu(menu: Menu?) : Boolean{
        menuInflater.inflate(R.menu.main,menu)
        return true
    }

    override fun onOptionsItemSelected(item: MenuItem) : Boolean{
        when(item.itemId){
            R.id.add_id -> Toast.makeText(this,"Add",Toast.LENGTH_SHORT).show()
            R.id.remove_id -> Toast.makeText(this,"Remove",Toast.LENGTH_SHORT).show()
        }
        return true
    }
}

class SecondActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_second)

        val extraData = intent.getStringExtra("extra_data")

        button2.setOnClickListener {
            Toast.makeText(this,extraData,Toast.LENGTH_SHORT).show()
            val intent = Intent(this,WebActivity::class.java)
            startActivity(intent)
        }

        send_button.setOnClickListener {
            //sendRequestWithHttpURLConnection()
            sendRequestWithOkHttp()
        }
    }

    private fun sendRequestWithOkHttp(){
        thread {
            try {
                var client = OkHttpClient()
                val request = Request.Builder()
                    .url("https://www.baidu.com")
                    .build()
                val response = client.newCall(request).execute()
                val responseData = response.body?.toString()
                if (responseData != null) {
                    showResponse(responseData)
                }
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
    }


    private fun sendRequestWithHttpURLConnection(){
        thread {
            var connection : HttpURLConnection? = null
            try {
                val response = StringBuffer()
                val url = URL("https://www.baidu.com")
                connection = url.openConnection() as HttpURLConnection
                connection.connectTimeout = 8000
                connection.readTimeout = 8000

                val input = connection.inputStream

                val reader = BufferedReader(InputStreamReader(input))
                reader.use {
                    reader.forEachLine {
                        response.append(it)
                    }
                }
                showResponse(response.toString())

            }catch (e : Exception){
                e.printStackTrace()
            }finally {
                connection?.disconnect()
            }
        }
    }

    private fun showResponse(response : String){
        runOnUiThread{
            responseText.text  = response
        }
    }

class WebActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.web_layout)
        webView.settings.javaScriptEnabled = true
        webView.webViewClient = WebViewClient()
        webView.loadUrl("https://www.baidu.com")
    }
}

class TitleLayout(context : Context, attrs: AttributeSet) : LinearLayout(context,attrs){

    init {
        LayoutInflater.from(context).inflate(R.layout.title,this)

        titleBack.setOnClickListener {
            val activity = context as Activity
            activity.finish()
        }
        titleEdit.setOnClickListener {
            Toast.makeText(context,"Edit!!",Toast.LENGTH_SHORT).show()
        }
    }
}

协程库
implementation “org.jetbrains.kotlin:kotlinx-coroutines-core:1.1.1”
implementation “org.jetbrains.kotlin:kotlinx-coroutines-android:1.1.1”

fun main(){
    runBlocking{ //会创建一个协程作用域，里面的代码没执行完就一直阻塞当前线程、
        launch{  //必须在协程作用域中调用，创建子协程，主协程结束，子都会结束
            println("coroutine1")
            delay(1500)  //挂起当前线程 不会影响其他线程 Thread.sleep会阻塞当前线程
            println("coroutine2")
        }
        repeat(100000) {  //循环创建10w个协程
            launch {
                println("coroutine1")
                delay(1500)  //挂起当前线程 不会影响其他线程
                println("coroutine2")
            }
        }

        //suspend 关建字可以声明任意函数为挂起函数，挂起函数间可以相互调用，但无法提供协程作用域
        //coroutineScope 可以继承外部的协程作用域并创建一个子线程,只会阻塞当前协程
        suspend fun printDot(){
            launch {
                println("..")
                delay(1500)
            }
        }

        /*
        //获取返回值
        val result = async {
            5+5
        }.await()  //会阻塞协程，要用再调用result.await()
        println(result)

        */

        //Dispatchers.Default 低并发  Dispatchers.IO 高并发  Dispatchers.Main 主线程
        val result = withContext(Dispatchers.Default){  //必须指定线程参数，如执行网络请求必须在子线程中
            5+5
        }
        println(result)
    }

    //suspendCoroutine  简化回调

    /*  项目中比较常用的，返回值是job对象
    val job = Job()
    val scope = CoroutineScope(job)
    scope.launch {
        //处理集体逻辑
    }
    job.cancel()  //将作用域中的协程全部取消
    */
}