Android学习笔记

四大组件

1. Activity
2. Service
3. BroadcastReceiver
4. ContentProvider

AndroidMainifest.xml

整个安卓项目的配置文件,程序中定义的所有四大组件都需要在这个文件里面注册,还可以在这个文件中给程序 添加权限声明 路径：项目根目录app/src/main/AndroidMainifest.xml

Kotlin

val, var

声明变量时优先使用 val 在val无法满足需求时才使用 var 声明变量

一行的函数可以简写

fun largerNumber(num1: Int, num2: Int) = max (num1, num2)

if 语句可以存在返回值

val value = if (num1 > num2) {
	num1
} else {
	num2
}

使用when语句替换switch

1. when 也有返回值
2. when 允许进行类型匹配

fun checkNumber(num: Number) {
    when(num) {
        is Int -> println("number is Int")
        is Double -> println("number is Double")
        else -> println("number is not support")
    }
}

3. when的另一种语法

fun getScore2(name: String) = when {
    name.startsWith("Tom") -> 86
    name == "Jim" -> 77
    name == "Jack" -> 95
    name == "Lily" -> 100
    else -> 0
}

区间类型

// 区间[0,10]
val range1 = 0..10

// 左闭右开的区间
val range = 0 until 10

// 实现循环中 i += 2 的效果
for (i in 0 until 10 step 2) {
	println(i)
}

// 实现降序输出[10,1], 注意此处区间两边都是闭合
for (i in 10 downTo 1) {
        println(i)
}

面向对象

kotlin中任何一个非抽象类默认都是不可以被继承的

// 讲类声明为可继承
open class Person {

}

1. 类的继承

class Student: Person() {

}

2. 主构造函数和次构造函数

// 主构造函数没有函数体
/**
* 此处age和name都会被认为类的成员变量
*/
class Student(val age: Int, val name: String): Person() {

}

// 提供init方法来给主构造函数添加逻辑
class Student(val sno: String, val grade: Int): Person() {
    init {
    	// 此处使用字符串模板
        println("sno is $sno")
        println("grade is $grade")
    }
}

// 继承时选择调用父类的哪一个构造函数
// 即继承时通过括号来制定调用父类的哪一个构造函数
// 此处为调用父类的无参构造函数
class Student: Person() {

}

/**
*注意，此处name和age没有使用val来声明，一旦使用val或者var声明的参数，
*该参数会成为该类的成员属性
*/
class Student(val sno: String, val grade: Int, name: String, age: Int): Person(name, age) {
    init {
        println("sno is $sno")
        println("grade is $grade")
    }
}

3. 次构造函数 任何一个类只能有一个主构造函数，但是可以有多个次构造函数.次构造函数也可以 用于构造一个类的实例，只不过它拥有函数体 如果一个类既有主构造函数又有次构造函数时,所有的次构函数都必须调用主构造函数(包括间接调用)

class Student(val sno: String, val grade: Int, name: String, age: Int): 
Person(name, age) {
constructor(name: String, age: Int): this("", 0, name, age){
}
constructor(): this("", 0){ // 此处调用的是上面一个次构造函数
}
}

特殊情况：只有次构造函数没有主构造函数(此时Person后面的括号可以不写) 即有括号代表调用相应的构造函数,没有括号，但是需要在内部使用super调用父类 构造函数

class Student: Person {
constructor(name: String, age: Int): super(name, age) {
}
}

4. 接口(基本与Java中的一致)

// 此处Study为接口
class Student: Person(), Study {
override fun ...
}

接口中的函数允许存在默认实现

interface Study {
fun readBooks() {
	println("read books")
}
}

5. 可见性修饰符

6. 数据类 自动实现equals, hashCode, toString方法

data class CellPhone(val brand: String, val price: Double) {
}

fun main() {
	val c1 = CellPhone("Samsung", 1299.99)
	val c2 = CellPhone("Samsung", 1299.99)
	println(c1)
	println("c1 equals c2 " + (c1 == c2))
}

7. 单例类

object Singleton {
	fun singletonTest() {
		println("singletonTest is called")
	}
}
// 调用
Singleton.singletonTest()

8. 静态方法

// 在写静态方法时，可以使用匿名伴随内部单例类
class Student {
	// 此处添加名字也行，加也行
	// companion object Name{
	companion object {
		fun say() {
		 println("this act like static method")
		}
	}
}

Student.say()

Lambda

1. 集合的创建 可以使用Java的语法创建

val list = ArrayList<String>()

• listOf函数：由此创建的列表为不可变列表(只能读取)

val list = listOf("it1", "it2", "it3")

• mutableListOf函数: 创建可变列表

val list = mutableListOf("it1", "it2", "it3")

• set也是同list一样创建，set中只会存在不同元素
• map也存在mafOf函数以及mutableMapOf

val m1 = mutableMapOf<String, String>()
m["key"] = "value"

// 此处to并不是一个关键字而是一个infix函数
val m2 = mapOf("key1" to 1, "key2" to 3)

// 遍历
for((k, v) in m2) {
	println(k + " " + v)
}

2. Lambda表达式(配合函数式API)

val lst = listOf(1, 2, 3, 4)
// 选出大于5的元素
// 此处这种写法是因为，kotlin中lambda表达式如果为做后一个参数可以将lambda
// 表达式写在外面,如果只有一个参数的话可以省略()
// 由于kotlin的类型推断，可以省略lambda表达式参数的类型
// 只有一个参数时，参数可以用 `it` 来替代
val moreThan5 = lst.maxBy {it > 5}
// 其他api可以自行在ide内查看

空指针检查

kotlin默认所有参数和变量都是非空 要表示可空类型则需要在类型名之后添加问号

// 此处表示num可以为空值但是在编译期就得通过代码逻辑解决空值问题
// 否则编译器会报错
// 如果没有?则一定不为空
fun f(num: Int?)

• 使用 ?. 判空简化

// 原始判空
if (a != null) {
	a.doSomething()
}
// 使用?.简化判空操作
// 如果a为null则整个表达式的值为null
a?.doSomething()

• 非空断言 !!

// 此处告诉编译器，content一定不为空
// 但是这存在风险，程序员自信不会发生空指针异常，但还是有可能会出现
content!!.toUpperCase()

• let函数 let函数会将对象本身作为参数传入函数 使用let函数解决多个 ?. 问题 返回值为let最后一句

// doStudy版本1
// 目前版本仍然比较繁琐
fun doStudy1(study: Study?) {
    study?.readBooks()
    study?.doHomework()
}

//doStudy版本2
fun soStudy2(study: Study?) {
    study?.let {
        it.readBooks()
        it.doHomework()
    }
}

此外let函数可以用来解决全局变量判空问题 if则不行

var study: Study? = null
// 以下代码编译报错
fun doStudy() {
	// 全局可空变量可能在其他线程被修改
	if(study != null) {
		study.readBooks()
		study.doHomework()
	}
}

// 使用let解决全局变量判空问题
var study: Study? = null
fun doStudy() {
	study?.let {
		it.readBooks()
		it.doHomework()
	}
}

小魔术

• 字符串模板

val num = 10
println("the num is ${num}")
// 单个变量时可以省略{}
// 字符串模板内也可以是有值的表达式
val s1 = "name"
val s2 = "name"
println("${s1.toUpperCase()}")
println("${s1 == s2}")

• 函数的默认参数

// 使用默认参数
fun printParams(num: Int, str: String = "Hello") {
    println("num is $num str is $str")
}

可以使用键值对的方式调用函数来解决默认参数不匹配问题

printParams(num = 10, str = "world")

Activity

• 布局xml文件中，引用一个id

"@id/id_name"

• 创建一个id

"@+id/id_name"

• 宽高属性

android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="按钮"

match_parent 表示当前元素和父元素一样 wrap_content 表示当前元素刚好包裹内容就行 text 按钮上显示的文字

Intent

Intent是Android程序中各组件之间进行交互的一种重要方式，它不仅可以指明当前组件想要执 行的动作，还可以在不同组件之间传递数据。Intent一般可用于启动Activity、启动Service以 及发送广播等场景，由于Service、广播等概念你暂时还未涉及，那么本章我们的目光无疑就锁 定在了启动Activity上面。 Intent 一般有两种

1. 显式Intent

// 创建Intent实例
// Intent有多个重载的构造函数,其中一个是
Intent(Context packageContext, Class<?> cls)
// packageContext: 启动Activity的上下文
// 	      cls: 想要启动的目标Activity

2. 隐式Intent 相比于显式Intent，隐式Intent则含蓄了许多，它并不明确指出想要启动哪一个Activity，而是 指定了一系列更为抽象的action和category等信息，然后交由系统去分析这个Intent，并帮 我们找出合适的Activity去启动。 因此，可以通过标签来配置Activity能响应那些Intent

<activity
            android:name=".SecondActivity"
            android:exported="false">
            <intent-filter>
                <action android:name="com.example.activitylearn.ACTION_START"/>
                <category android:name="android.intent.category.DEFAULT"/>
            </intent-filter>
        </activity>

<action> 这个标签指定当前Activity可以响应 com.example.activitylearn.ACTION_START 这个action 而 <category> 标签则包含了 一些附加信息，更精确地指明了当前Activity能够响应的Intent中还可能带有的category。只 有 <action> 和 <category> 中的内容同时匹配Intent中指定的action和category时，这个 Activity才能响应该Intent。 修改button的setOnListener

bind.button1.setOnClickListener {
	    // 此处直接传入intent action的标签字符串
            val intent = Intent("com.example.activitylearn.ACTION_START")
            startActivity(intent)
        }
// or
bind.button1.setOnClickListener {
            val intent = Intent("hahahahah")
            startActivity(intent)
        }

由此可以看出，<action> 标签内的 android:name 值可以为自定义字符串只要对应的intent内传入对应的action字符串即可 对于category android.intent.category.DEFAULT 是一种默认的category， 在调用startActivity()方法的时候会自动将这个category添加到Intent中。

• 每一个Intent只能指定一个action, 但是可以指定多个category

bind.button1.setOnClickListener {
            val intent = Intent("hahahahah")
            intent.addCategory("MY_CATEGORY")
            startActivity(intent)
        }

此时修改 AndroidMainifest.xml 文件 注意，此时DEFAULT仍然要保留，因为调用的是 startActivity 方法，DEFAULT category会被自动加入intent

<intent-filter>
                <action android:name="hahahahah"/>
                <category android:name="android.intent.category.DEFAULT"/>
                <category android:name="MY_CATEGORY"/>
            </intent-filter>

• 更多隐式Intent 使用隐式Intent，不仅可以启动自己程序内的Activity，还可以启动其他程序的Activity，这就 使多个应用程序之间的功能共享成为了可能。 浏览器打开网页

val intent = Intent(Intent.VIEW)
intent.data = Uri.Parse("https://www.baidu.com")

• <data> 标签 在 <intent-filter> 标签中再配置一个 <data> 标签，用于更精确地指 定当前Activity能够响应的数据。<data> 标签中主要可以配置以下内容。
• android:shceme 用于定义数据的协议部分，如https
• android:host 用于指定数据的主机名部分，如www.baidu.com
• android:port 用于指定数据的端口
• android:path 用于制定主机名和端口之后的部分
• android:mimeType 用于指定可以处理的数据类型,允许使用通配符的方式指定

3. 使用Intent向下一个Activity传递数据 使用Intent的putExtra方法

val data = "Hello SecondActivity"
val intent = Intent(this, SecondActivity::class.java)
intent.putExtra("extra_data", data)
startActivity(intent)

在第二个Activity中获取Extra数据

class SecondActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val bind = ActivitySecondBinding.inflate(layoutInflater)
        setContentView(bind.root)
        val extraData = intent.getStringExtra("extra_data")
        Log.d("SecondActivity", "Extra data is $extraData")
    }
}

• 返回结果给上一个Activity 并没有一个用于启动的Activity的Intent来传递数据,可以使用 startActivityForResult 方法在Activity在销毁时返回数据给上一个Activity(注意此方法已经被弃用) 可以使用AndroidXActivity 和 Fragment中引入的ActivityResult API

bind.button2.setOnClickListener {
            val intent = Intent()
            intent.putExtra("data_return", "Hello FirstActivity")
	    // 专门用来向上一个Activity传递数据
            setResult(RESULT_OK, intent)
            finish()
        }

在 SecondActivity被销毁之后会回调上一个Activity的onActivityResult()方法，因此我们 需要在FirstActivity中重写这个方法来得到返回的数据

• 保存上一个Activity的数据 使用 onSaveInstanceState 方法保证Activity被回收之前一定会被调用

// 在要被收回的Activity中重写 onSaceInstanceState 方法
override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        val tempData = "Something you just typed"
        outState.putString("data_key", tempData)
    }

在 OnCreate 方法参数的 savedInstanceState 可以获得保存的数据

Activity 生命周期

flowchart TD
A([启动Activity]) --> B(["onCreate()"])
subgraph 完整生存期
direction LR
B --> C(["onStart()"])
subgraph 可见生存期
C --> D(["onResume()"])
subgraph 前台生存期
D --> E([Activity运行中])
E -- 另一个Activity来到前台 --> F(["onPause()"])
end
F -- Activity不再可见 --> G(["onStop()"])
end
G -- Activity被销毁 --> H(["onDestory()"])
end
H --> L([关闭Activity])
G -- 返回上一个Activity ----> I(["onRestart()"])
I ----> C
F -- 返回上一个Activity --> D
G -- 另一个优先级更高的<br/>程序需要内存 ----> K([杀掉进程])
F -- 另一个优先级更高的<br/>程序需要内存 --> K
K -- 返回上一个Activity --> B

4. Activity的启动模式 在实际项目中我们应该根据特定的需求为每个Activity指定恰当的启动模式。启动模式一共有4种， 分别是standard、singleTop、singleTask和singleInstance，可以在AndroidManifest.xml中通过给 <activity> 标签指定 android:launchMode 属性来选择启动模式

• standard standard是Activity默认的启动模式，在不进行显式指定的情况下，所有Activity都会自动使用这种启动模式

使用standard模式的Activity，系统不会在乎这个Activity是否已经在返回栈中存在， 每次启动都会创建一个该Activity的新实例 示例 在自身存在的按钮上再次创建自身Activity实例

// 此Activity为MainActivity
override fun onCreate(savedInstanceState: Bundle?) {
        val bind = ActivityMainBinding.inflate(layoutInflater)
        super.onCreate(savedInstanceState)
        Log.d(tag, "onCreate")
        setContentView(bind.root)
        bind.startNormalActivity.setOnClickListener {
            val intent = Intent(this, MainActivity::class.java)
	    // 再次启动自身实例
            startActivity(intent)
        }
}

standard模式原理图

flowchart TD
s1([MainActivity]) -- 返回 --> s2([MainActivity])
s2 -- 返回 --> s3([MainActivity])
s3 -- 创建 --> s2
s2 -- 创建 --> s1

<activity
            android:name=".FirstActivity"
            android:launchMode="singleTop"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

注意，此处在 <activity> 标签内添加 android:launchMode 属性来设置启动模式 FirstActivity 和 SecondActivity 中按钮的监听事件

// FirstActivity
bind.btn1.setOnClickListener {
            val intent = Intent(this, SecondActivity::class.java)
            startActivity(intent)
        }
// SecondActivity
bind.btn2.setOnClickListener {
            val intent = Intent(this, FirstActivity::class.java)
            startActivity(intent)
        }

singleTop原理图

flowchart
s1([FirstActivity]) -- 返回 --> s2([SecondActivity])
s2 -- 返回 --> s3([FirstActivity])
s3 -- 启动新Activity --> s2
s2 -- 检查栈顶判断<br/>是否需要启动<br/>新的Activity --> s1

<activity
            android:name=".FirstActivity"
            android:launchMode="singleTask"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

FirstActivity 和 SecondActivity 代码和之前相同在FirstActivity的onRestart方法和SecondActivity的onDestory方法中添加日志输出

// FirstActivity
override fun onRestart() {
        super.onRestart()
        Log.d("FirstActivity", "OnRestart")
    }
// SecondActivity
override fun onDestroy() {
        super.onDestroy()
        Log.d("SecondActivity", "onDestroy")
    }

在SecondActivity中启动FirstActivity时，会发现返回栈 中已经存在一个FirstActivity的实例，并且是在SecondActivity的下面，于是SecondActivity 会从返回栈中出栈，而FirstActivity重新成为了栈顶Activity，因此FirstActivity的 onRestart()方法和SecondActivity的onDestroy()方法会得到执行。现在返回栈中只剩下 一个FirstActivity的实例了，按一下Back键就可以退出程序。 singleTask原理图

flowchart BT
s2([SecondActivity]) --> s1([直接出栈重新启动FirstActivity])
subgraph 返回栈
direction BT
s3([FirstActivity]) -- 启动SecondActivity --> s2
end

<activity
            android:name=".FirstActivity"
            android:launchMode="singleInstance"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

按下Back键进行返回，ThirdActivity直接返回到了FirstActivity，再按 下Back键又会返回到SecondActivity，再按下Back键才会退出程序 由于FirstActivity和ThirdActivity是存放在同一个返回栈里的，当在ThirdActivity 的界面按下Back键时，ThirdActivity会从返回栈中出栈，那么FirstActivity就成为了栈顶 Activity显示在界面上，因此也就出现了从ThirdActivity直接返回到FirstActivity的情况。然后 **在FirstActivity界面再次按下Back键，这时当前的返回栈已经空了，于是就显示了另一个返回 栈的栈顶Activity，即SecondActivity。**最后再次按下Back键，这时所有返回栈都已经空了， 也就自然退出了程序 singleInstance原理图

flowchart LR
subgraph 返回栈B
direction BT
s2([SecondActivity])
end
subgraph 返回栈A
direction TB
s3([ThirdActivity])
s1([FirstActivity])
end
s3 -- 返回 --> s1
s1 -- 启动新Activity --> s2
s1 -- 返回 --> s2
s2 -- 重新启动Activity --> s3

Activity的最佳实践

知晓当前是在哪一个Activity

自己写一个Activity继承自AppCompatActivity,在此Activity的OnCreate方法中添加答应当前对象的Class名称的日志输出， 最后让项目中所有Activity都集成自这个Activity

// 自己写的单独的Activity
open class BaseActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
	// 此处javaClass获取的是当前实例对象
        Log.d("BaseActivity", javaClass.simpleName)
    }
}

// 其他Activity继承自BaseActivity
class MainActivity : BaseActivity() {
}

此时程序运行分别进入不通道Activity时，就会输出对应的Activity类名信息

随时随地退出程序

使用一个集合对所有Activity进行管理

object ActivityCollector {
    private val activities = ArrayList<Activity>()

    fun addActivity(activity: Activity) {
        activities.add(activity)
    }

    fun removeActivity(activity: Activity) {
        activities.remove(activity)
    }

    fun finishAll() {
        for (activity in activities) if (!activity.isFinishing) activity.finish()
        activities.clear()
    }
}

在其他Activity中的onCreate方法中将自身Activity加入到该集合中 在onDestroy中移除

class MainActivity : BaseActivity() {

    private val tag = "MainActivity"

    override fun onCreate(savedInstanceState: Bundle?) {
    // ...
        ActivityCollector.addActivity(this)
	// ...
	}
	// ...
    override fun onDestroy() {
        super.onDestroy()
        ActivityCollector.removeActivity(this)
    }
}

从此以后，不管你想在什么地方退出程序，只需要调用ActivityCollector.finishAll() 方法就可以了。 但是此时APP还是在后台运行,可以使用killProcess杀掉后台进程

android.os.Process.killProcess(android.os.Process.myPid())

启动Activity的最佳写法

通过添加 compaion object，添加对应的方法，来解决启动参数传递问题

class SecondActivity: BaseActivity {
	companion object {
		fun actionStart(context: Context, data1: String, data2: String) {
			val intent = Intent(context, SecondActivity::class.java)
			intent.putExtra("param1", data1)
			intent.putExtra("param1", data2)
			context.startActivity(intent)
		}
	}
}

标准函数和静态方法

标准函数with, run和apply

• with with函数接收两个参数：第一个参数可以是一个任意类型的对 象，第二个参数是一个Lambda表达式。with函数会在Lambda表达式中提供第一个参数对象 的上下文，并使用Lambda表达式中的最后一行代码作为返回值返回。

val result = with(obj) {
	// obj上下文
	"value" // with函数的返回值
}

作用: 它可以在连续调用同一个对象的多个方法时让代码变得更加精简

// 不使用with的代码
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")
val builder = StringBuilder()
builder.append("Start eating fruits\n")
for (fruit in list) {
	builder.append(fruit).append("\n")
}
builder.append("Ate all fruits")
val result = builder.toString()
println(result)

以上代码多次使用builder对象，可以使用with来简化

val result1 = with(StringBuilder()) {
       append("Start eating fruits\n")
       for (fruit in list) {
           builder.append(fruit).append("\n")
       }
       append("Ate all fruits")
       toString()
   }
    println(result1)

val result = obj.run {
	// obj 上下文
	"value" // run函数的返回值
}

对上面使用with函数的代码进行改写

val result2 = builder.run {
        append("Start eating fruits\n")
       for (fruit in list) {
           builder.append(fruit).append("\n")
       }
       append("Ate all fruits")
       toString()
    }
    println(result2)

• apply apply函数和run函数也是极其类似的，都要在某 个对象上调用，并且只接收一个Lambda参数，也会在Lambda表达式中提供调用对象的上下 文，但是apply函数无法指定返回值，而是会自动返回调用对象本身

val result = obj.apply {
	// obj的上写文
}
// result == obj

使用apply改写上面使用run函数的代码

val result3 = StringBuilder().apply {
        append("Start eating fruits\n")
       for (fruit in list) {
           builder.append(fruit).append("\n")
       }
       append("Ate all fruits")
    }
    println(result3.toString())

定义静态方法

1. 使用 companion object 来给类添加 前文Kotlin部分已经提过，此处就不在赘述
2. 注解 给单例类或companion object中的方 法加上@JvmStatic注解，那么Kotlin编译器就会将这些方法编译成真正的静态方法 注意，@JvmStatic注解只能加在单例类或companion object中的方法上，如果你尝试加在 一个普通方法上，会直接提示语法错误
3. 顶层方法 顶层方法指的是那些没有定义在任何类中的方法, Kotlin编译器会将所有的顶层方法全部编译成静态方法

// 顶层方法，Kotlin自动编译为静态方法
fun doSomething() {
    println("doSomething")
}
所有的顶层方法都可以在任何位置被直接调
用，不用管包名路径，也不用创建实例

在Kotlin中所有的顶层方法都可以在任何位置被直接调，不用管包名路径，也不用创建实例 在Java中Kotlin编译器会创建名称为文件名后跟Kt的java类，可以使用这个类来调用静态方法

UI

几种基础控件

TextView

用 android:layout_width 和 android:layout_height 指定了控件的宽度和高度。

Android中所有的控件都具有这两个属 性，可选值有3种：match_parent、wrap_content和固定值。match_parent表示让当前 控件的大小和父布局的大小一样，也就是由父布局来决定当前控件的大小。wrap_content表 示让当前控件的大小能够刚好包含住里面的内容，也就是由控件内容决定当前控件的大小。固 定值表示表示给控件指定一个固定的尺寸，单位一般用dp，这是一种屏幕密度无关的尺寸单 位，可以保证在不同分辨率的手机上显示效果尽可能地一致，如50 dp就是一个有效的固定值 TextView中的文字默认是居左上角对齐的

使用android:gravity来指定文字的对齐方式

可选值有top、bottom、start、 end、center等，可以用“|”来同时指定多个值，这里我们指定的是"center"，效果等同 于"center_vertical|center_horizontal"，表示文字在垂直和水平方向都居中对齐

<TextView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:text="Hello World!"
        android:gravity="center"
        android:textColor="#00ff00"
        android:textSize="24sp"
    />

Button

Android系统默认会将按钮上的英文字母全部转换成大写

<Button
        android:id="@+id/btn1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Button"
        />

可以在XML中添加 android:textAllCaps="false" 这个属性，这样系统就会保留你指定的原始文字内容了

注册监听事件

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
	// 
	/**
	* 使用viewBinding 需要在app文件夹下的build.gradle内添加如下代码
	* buildFeatures {
	*	viewBinding true
	* }
	*
	*
	*/
        val bind = ActivityMainBinding.inflate(layoutInflater)
        setContentView(bind.root)

        bind.btn1.setOnClickListener {
            // 添加逻辑
        }
    }
}

EditText

<EditText
        android:id="@+id/editText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        />

1. android:hint 给EditText添加提示性文本
2. android:maxLines 指定最大行数

bind.btn1.setOnClickListener {
            // 添加逻辑
            val res = bind.editText.text.toString()
            Toast.makeText(this, res, Toast.LENGTH_SHORT).show()
        }

这里调用的实际是getText方法，这是一个Kotlin语法糖, 同理设置文本内容也可直接赋值, 实际调用的是setText方法 但是得使用实现了Editable接口的类

bind.btn1.setOnClickListener {
            // 添加逻辑
            val res = bind.editText.text.toString()
            Toast.makeText(this, res, Toast.LENGTH_SHORT).show()
            bind.editText.text = SpannableStringBuilder().append("Text")
        }

ImageView

在res文件夹下建立drawable-xxhdpi因为当下很多设备的分辨率大多是xxhdpi,在这个文件夹下添加图片文件(文件名不能以数字开头) android:src 用来制定图片路径

<ImageView
	android:id="@+id/imgid"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:src="@drawable/imag1"
        />

    <ImageView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:src="@drawable/imag2"
        />

使用代码动态修改图片

bind.imgid.setImageResource(R.drawable.imag2)

注意此处imgid是设置的标签id

ProcessBar

<ProgressBar
        android:id="@+id/progressBar"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        />

• 可见性设定

1. 使用xml设定 使用 android:visibility 设定，属性值可以为 visible, invisible, gone 控件默认是 visible invisible 表示控件不可见，但是它仍然占据着原来的位置和大小，可以理解成控件变成透明状态了 gone 则表示控件不仅不可见，而且不再占用任何屏幕空间
2. 使用代码设定

// 方法允许传入View.VISIBLE, View.INVISIBLE, 和 View.GONE 三个值
setVisibility()

// 按钮点击来回切换加载条可见性
if (bind.progressBar.visibility == View.VISIBLE) {
                bind.progressBar.visibility = View.GONE
            } else {
                bind.progressBar.visibility = View.VISIBLE
            }

3. 修改属性

• 修改style属性, 修改样式

<ProgressBar
        android:id="@+id/progressBar"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        style="?android:attr/progressBarStyleHorizontal"
	android:max="100"
        />

注意此处属性写法与之前的会有些不同，此处的progressBarStyleHorizontal 对应的代码位于AndroidSdk目录下IDE内可以查看路径

• 通过代码动态改动进度条

bind.progressBar.progress += 10

AlertDialog

弹出警告框, 在代码内实现

AlertDialog.Builder(this).apply {
                setTitle("This is a Dialog")
                setMessage("Something important")
                setCancelable(false)
                setPositiveButton("OK") {dialog, which -> }
                setNegativeButton("Cancel") {dialog, which -> }
                show()
            }

3种基本布局

LinearLayout (线性布局)

可以使用 android:orientation 属性来设置方向 vertical 表示垂直, horizontal 表示水平

• android:layout_gravity 在布局内的组件使用 android:layout_gravity 用于指定控件在布局中的 对齐方式。android:layout_gravity 的可选值和 android:gravity 差不多，但是需要注 意，**当LinearLayout的排列方向是horizontal时，只有垂直方向上的对齐方式才会生效。**因 为此时水平方向上的长度是不固定的，每添加一个控件，水平方向上的长度都会改变，因而无 法指定该方向上的对齐方式。同样的道理，当LinearLayout的排列方向是vertical时，只有 水平方向上的对齐方式才会生效

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="horizontal"
    tools:context=".MainActivity">

    <Button
        android:id="@+id/btn1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="top"
        android:text="button1"
        />

    <Button
        android:id="@+id/btn2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="button2"
        android:layout_gravity="center_vertical"
        />

    <Button
        android:id="@+id/btn3"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="button3"
        android:layout_gravity="bottom"
        />
</LinearLayout>

• android:layout_weight (权重) 类似css中的grid布局或者flow布局 这个属性允许我们使用比例的方式来指定控件的大小，它在手机屏幕的适配性方面可以起到非常重要的作用

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="horizontal"
    tools:context=".MainActivity">

    <Button
        android:id="@+id/btn3"
        android:layout_width="0dp"
        android:layout_weight="1"
        android:layout_height="wrap_content"
        android:text="Send"
        android:textAllCaps="false"
        />

    <EditText
        android:id="@+id/input_msg"
        android:layout_width="0dp"
        android:layout_weight="1"
        android:layout_height="wrap_content"
        android:hint="Type Something"
        />

</LinearLayout>

使用了 android:layout_weight 属性，此时控件的宽度就不应该再由 android:layout_width 来决定了，这里指定成0 dp是一种比较规范的写法 在仅指定了EditText的 android:layout_weight 属性，并将Button的宽度改回了 wrap_content 。这表示Button的宽度仍然按照 wrap_content 来计算，而EditText则会占满 屏幕所有的剩余空间。

<Button
        android:id="@+id/btn3"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Send"
        android:textAllCaps="false"
        />

    <EditText
        android:id="@+id/input_msg"
        android:layout_width="0dp"
        android:layout_weight="1"
        android:layout_height="wrap_content"
        android:hint="Type Something"
        />

RelativeLayout (相对布局)

和LinearLayout的排列规则不同，RelativeLayout显得更加随意，它可以通过相对定位的方式让控件出现在布局的任何位置。

相对于父组件进行定位

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="horizontal"
    tools:context=".MainActivity">

    <Button
        android:id="@+id/btn1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Send"
        android:textAllCaps="false"

        android:layout_alignParentLeft="true"
        android:layout_alignParentTop="true"
        />

    <Button
        android:id="@+id/btn2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Send"
        android:textAllCaps="false"

        android:layout_alignParentRight="true"
        android:layout_alignParentTop="true"
        />
    <Button
        android:id="@+id/btn3"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Send"
        android:textAllCaps="false"

        android:layout_centerInParent="true"
        />
    <Button
        android:id="@+id/btn4"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Send"
        android:textAllCaps="false"

        android:layout_alignParentLeft="true"
        android:layout_alignParentBottom="true"
        />
    <Button
        android:id="@+id/btn5"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Send"
        android:textAllCaps="false"

        android:layout_alignParentRight="true"
        android:layout_alignParentBottom="true"
        />

</RelativeLayout>

此处的布局为5个按钮分别想对于父组件处于左上，右上，中间，左下，右下位置

想对于控件进行定位

<Button
        android:id="@+id/btn3"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Send"
        android:textAllCaps="false"

        android:layout_centerInParent="true"
        />


    <Button
        android:id="@+id/btn1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Send"
        android:textAllCaps="false"

        android:layout_above="@id/btn3"
        android:layout_toLeftOf="@id/btn3"
        />


    <Button
        android:id="@+id/btn2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Send"
        android:textAllCaps="false"

        android:layout_above="@id/btn3"
        android:layout_toRightOf="@id/btn3"
        />


    <Button
        android:id="@+id/btn4"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Send"
        android:textAllCaps="false"

        android:layout_below="@id/btn3"
        android:layout_toLeftOf="@id/btn3"
        />


    <Button
        android:id="@+id/btn5"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Send"
        android:textAllCaps="false"

        android:layout_toRightOf="@id/btn3"
        android:layout_below="@id/btn3"
        />

android:layout_alignLeft 表示让一个控件的左边缘和另一个控件的左边缘对齐，android:layout_alignRight 表示 让一个控件的右边缘和另一个控件的右边缘对齐。此外，还有 android:layout_alignTop 和 android:layout_alignBottom ，道理都是一样的

FrameLayout (帧布局)

应用场景少，所有控件默认摆放在左上角

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="horizontal"
    tools:context=".MainActivity">

    <Button
        android:id="@+id/btn3"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Send"
        android:textAllCaps="false"

        android:layout_centerInParent="true"
        />


    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="This is a text"
        />

</FrameLayout

创建自定义控件

引入布局

我们所用的所有控件都是直接或间接继承自View的，所用的所有布局都是直接或间接继承自ViewGroup的 在layout文件夹下创建title.xml文件

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content">

    <Button
        android:id="@+id/titleBack"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:layout_margin="5dp"
        android:text="Back"
        android:textColor="#ff0000"
        />

    <TextView
        android:id="@+id/titleText"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:layout_weight="1"
        android:gravity="center"
        android:text="Title Text"
        android:textColor="#00ff00"
        android:textSize="24sp"
        />

    <Button
        android:id="@+id/titleEdit"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:layout_margin="5dp"
        android:text="Back"
        android:textColor="#0000ff"
        />
</LinearLayout>

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <include layout="@layout/title" />

</LinearLayout>

通过getSupportBar方法获取默认标题栏，通过hide方法隐藏默认标题栏

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val bind = ActivityMainBinding.inflate(layoutInflater)
        setContentView(bind.root)
        supportActionBar?.hide()
    }
}

创建自定义控件

新建TitleLayout继承自LinearLayout，让它成为我们自定义的标题栏控件,最后可以通过包名在xml文件中作为对应标签

class TitleLayout(context: Context, attrs: AttributeSet):
    LinearLayout(context, attrs) {
   init {
       LayoutInflater.from(context).inflate(R.layout.title, this)
   }
}

通过LayoutInflater的from()方法可以构建出一个LayoutInflater对象，然后调用inflate()方法就可以动态加载一个布局文件。 inflate()方法接收两个参数：第一个参数是要加载的布局文件的id，这里我们传入 R.layout.title；第二个参数是给加载好的布局再添加一个父布局，这里我们想要指定为 TitleLayout，于是直接传入this 在activity_main.xml文件中如下

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <com.example.uicustomview.TitleLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"/>

</LinearLayout>

class TitleLayout(context: Context, attrs: AttributeSet):
    LinearLayout(context, attrs) {
   init {
    val b = LayoutInflater.from(context).inflate(R.layout.title, this)
    val bind = TitleBinding.bind(b)
    bind.titleBack.setOnClickListener {
        val activity = context as Activity
        activity.finish()
    }
    bind.titleEdit.setOnClickListener {
        Toast.makeText(context,
            "You clicked Edit Button", Toast.LENGTH_LONG).show()
    }
   }
}

注意，此处context为Activity类型，并且为父Activity，此时即为MainActivity,因为在xml中，activity_main.xml文件包含了TitleLayout标签， Kotlin使用 as 进行强制类型转换

ListView

简单使用

activity_main.xml 文件内容

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <ListView
        android:id="@+id/listView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"/>

</LinearLayout>

对应kotlin代码

private val data = listOf("Apple", "Banana", "Orange", "Watermelon",
        "Pear", "Grape", "Pineapple", "Strawberry", "Cherry", "Mango",
        "Apple", "Banana", "Orange", "Watermelon", "Pear", "Grape",
        "Pineapple", "Strawberry", "Cherry", "Mango")

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val bind = ActivityMainBinding.inflate(layoutInflater)
        setContentView(bind.root)

        val adapter = ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, data)
        bind.listView.adapter = adapter
    }

定制ListView界面

自定义Adapter，通过继承重写getView方法FruitAdapter定义了一个主构造函数，用于将Activity的实例、ListView子项布局的id和数 据源传递进来。另外又重写了getView()方法，这个方法在每个子项被滚动到屏幕内的时候会 被调用。

class Fruit(val name: String, val imageId: Int)

class FruitAdapter(activity: Activity, private val resourceId: Int, data: List<Fruit>):
        ArrayAdapter<Fruit>(activity, resourceId, data) {
    override fun getView(position: Int, convertView: View?, parent: ViewGroup): View {
        val view = LayoutInflater.from(context).inflate(resourceId, parent, false)
        val bind = FruitItemBinding.bind(view)
        val fruit = getItem(position)
        val fruitImage = bind.fruitImage
        val fruitName = bind.fruitName
        if (fruit != null) {
            fruitImage.setImageResource(fruit.imageId)
            fruitName.text = fruit.name
        }
        return view
    }
}

提升ListView的效率

在FruitAdapter的getView()方法中，每次都将布局重新加载了一遍，当ListView快速滚动的时候，这就会成为性能的瓶颈 getView()方法中还有一个convertView参数，这个参数用于将之前加载好的布局进行缓存， 以便之后进行重用，我们可以借助这个参数来进行性能优化。

override fun getView(position: Int, convertView: View?, parent: ViewGroup): View {
        val view: View =
            convertView ?: LayoutInflater.from(context).inflate(resourceId, parent, false)
        val bind = FruitItemBinding.bind(view)
        val fruit = getItem(position)
        val fruitImage = bind.fruitImage
        val fruitName = bind.fruitName
        if (fruit != null) {
            fruitImage.setImageResource(fruit.imageId)
            fruitName.text = fruit.name
        }
        return view
    }

使用ViewHolder进行优化

override fun getView(position: Int, convertView: View?, parent: ViewGroup): View {
        val view: View
        val viewHolder: ViewHolder
        if (convertView == null) {
            view = LayoutInflater.from(context).inflate(resourceId, parent, false)
            val bind = FruitItemBinding.bind(view)
            viewHolder = ViewHolder(bind.fruitImage, bind.fruitName)
            view.tag = viewHolder
        } else {
            view = convertView
            viewHolder = view.tag as ViewHolder
        }
        val fruit = getItem(position)
        if (fruit != null) {
            viewHolder.fruitImage.setImageResource(fruit.imageId)
            viewHolder.fruitName.text = fruit.name
        }
        return view
    }

新增了一个内部类ViewHolder，用于对ImageView和TextView的控件实例进行缓存， Kotlin中使用inner class关键字来定义内部类 ViewHolder 实际是使用view中存在tag属性(此属性是Object类型),用ViewHolder将fruitImage和 fruitName进行封装，再将ViewHolder赋值给tag属性，再利用converView这个参数存储的是之前加载好的布局，由此，第一次调用getView时，convertView为空，则将布局加载出来，并将对应的ViewHolder赋值给tag，之后每次调用getView，如果convertView不为空，及次view已经被加载过，那直接将tag强制类型转换成ViewHolder直接使用即可

ListView的点击事件

给ListView添加能够响应用户的点击事件

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val bind = ActivityMainBinding.inflate(layoutInflater)
        setContentView(bind.root)
        initFruits()
        val adapter = FruitAdapter(this, R.layout.fruit_item, fruitList)
        bind.listView.adapter = adapter
        bind.listView.setOnItemClickListener { parent, view, position, id ->
            val fruit = fruitList[position]
            Toast.makeText(this, fruit.name, Toast.LENGTH_LONG).show()
        }
    }

直接使用setOnItemClickListener方法 当然Kotlin也提供省略参数的写法

bind.listView.setOnItemClickListener { _, _, position, _ ->
            val fruit = fruitList[position]
            Toast.makeText(this, fruit.name, Toast.LENGTH_LONG).show()
        }

RecyclerView (增强版ListView)

基本用法

因为RecyclerView定义在AndroidX当中所以首先需要在app/build.gradle中添加依赖

implementation 'androidx.recyclerview:recyclerview:1.2.1'

在xml布局文件中添加如下代码

<androidx.recyclerview.widget.RecyclerView
        android:id="@+id/recyclerView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        />

class FruitAdapter(private val fruitList: List<Fruit>):
        RecyclerView.Adapter<FruitAdapter.ViewHolder>() {
           inner class ViewHolder(view: View): RecyclerView.ViewHolder(view) {
               val fruitImage: ImageView = view.findViewById(R.id.fruitImage)
               val fruitName: TextView = view.findViewById(R.id.fruitName)
           }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
        val view = LayoutInflater.from(parent.context).inflate(R.layout.fruit_item, parent, false)
        return ViewHolder(view)
    }

    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        val fruit = fruitList[position]
        holder.fruitImage.setImageResource(fruit.imageId)
        holder.fruitName.text = fruit.name
    }

    override fun getItemCount() = fruitList.size
}

总体上重写onCreateViewHolder，onBindViewHolder, getItemCount 方法就行,省区了自己管理view的流程 onCreateViewHolder()方法是用于创建ViewHolder实例的，我们在这个方法中将fruit_item布局加载进来，然后创建一个ViewHolder实例，并把加载出来的布局传入构造 函数当中，最后将ViewHolder的实例返回 onBindViewHolder()方法用于对RecyclerView子项的数据进行赋值，会在每个子项被滚动到屏幕内的时候执行 getItemCount()方法就非常简单了，它用于告诉RecyclerView一共有多少子项，直接返回数据源的长度就可以了。

MainActivity中的onCreate方法

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val bind = ActivityMainBinding.inflate(layoutInflater)
        setContentView(bind.root)
        initFruits()
        val layoutManager = LinearLayoutManager(this)
        bind.recyclerView.layoutManager = layoutManager
        val adapter = FruitAdapter(fruitList)
        bind.recyclerView.adapter = adapter
    }

LayoutManager用于指定RecyclerView的布局方式，这里使用的LinearLayoutManager是线性布局的意思

实现横向滚动和瀑布流布局

ListView的扩展性并不好，它只能实现纵向滚动的效果 在xml中将fruit_item的LinearLayout改成vertical方向

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="80dp"
    android:layout_height="wrap_content"
    >

    <ImageView
        android:id="@+id/fruitImage"
        android:layout_width="40dp"
        android:layout_height="40dp"
        android:layout_gravity="center_horizontal"
        android:layout_marginTop="10dp" />

    <TextView
        android:id="@+id/fruitName"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="left"
        android:layout_marginTop="10dp" />

</LinearLayout>

修改onCreate方法中的layoutManager的方向即可

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val bind = ActivityMainBinding.inflate(layoutInflater)
        setContentView(bind.root)
        initFruits()
        val layoutManager = LinearLayoutManager(this)
	// 此处设置为水平
        layoutManager.orientation = LinearLayoutManager.HORIZONTAL
        bind.recyclerView.layoutManager = layoutManager
        val adapter = FruitAdapter(fruitList)
        bind.recyclerView.adapter = adapter
    }

为什么ListView很难或者根本无法实现的效果在RecyclerView上这么轻松就实现了呢？这主要 得益于RecyclerView出色的设计。**ListView的布局排列是由自身去管理的，而RecyclerView 则将这个工作交给了LayoutManager。**LayoutManager制定了一套可扩展的布局排列接口， 子类只要按照接口的规范来实现，就能定制出各种不同排列方式的布局了。

除了LinearLayoutManager之外，RecyclerView还给我们提供了GridLayoutManager和 StaggeredGridLayoutManager这两种内置的布局排列方式。GridLayoutManager可以用于 实现网格布局，StaggeredGridLayoutManager可以用于实现瀑布流布局。

• 使用StaggeredGridLayoutManager实现瀑布流布局

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    >

    <ImageView
        android:id="@+id/fruitImage"
        android:layout_width="40dp"
        android:layout_height="40dp"
        android:layout_gravity="center_horizontal"
        android:layout_marginTop="10dp" />

    <TextView
        android:id="@+id/fruitName"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="left"
        android:layout_marginTop="10dp" />

</LinearLayout>

Kotlin中只需要修改LayoutManager类型即可

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val bind = ActivityMainBinding.inflate(layoutInflater)
        setContentView(bind.root)
        initFruits()
//        val layoutManager = LinearLayoutManager(this)
        val layoutManager = StaggeredGridLayoutManager(3, StaggeredGridLayoutManager.VERTICAL)
        bind.recyclerView.layoutManager = layoutManager
        val adapter = FruitAdapter(fruitList)
        bind.recyclerView.adapter = adapter
    }

RecyclerView的点击事件

RecyclerView并没有提供类似于setOnItemClickListener()这样的注册监听器方法，而是需要我们自己给子项具体的View 去注册点击事件。这相比于ListView来说，实现起来要复杂一些

修改FruitAdapter中的代码

override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
        val view = LayoutInflater.from(parent.context).inflate(R.layout.fruit_item, parent, false)
        val viewHolder = ViewHolder(view)

	// itemView 表示最外层布局
        viewHolder.itemView.setOnClickListener {
            val position = viewHolder.absoluteAdapterPosition
            val fruit = fruitList[position]
            Toast.makeText(parent.context, "you clicked view ${fruit.name}", Toast.LENGTH_LONG).show()
        }

        viewHolder.fruitImage.setOnClickListener {
            val position = viewHolder.absoluteAdapterPosition
            val fruit = fruitList[position]
            Toast.makeText(parent.context, "you clicked image ${fruit.name}", Toast.LENGTH_LONG).show()
        }

        return viewHolder
    }

编写界面的最佳实践

编写聊天界面

制作9-Patch图片

9-Patch图片:它是一种被特殊处理过的png图片，能够指定哪些区域可以被拉伸、哪些区域不可以

• 设置activity_main.xml的LinearLayout背景图片

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="50dp"
    android:background="@drawable/message_left"
    tools:context=".MainActivity">
</LinearLayout>

注意此处背景图片资源为随书资源的9-Patch图片 在Android Studio中，我们可以将任何png类型的图片制作成9-Patch图片。首先对着 message_left.png图片右击Create 9-Patch file 使用鼠标在需要拉伸的部分拖动绘制褐色标记，可以按住Shift拖动擦除,具体请查阅资料

注意 最后记得要将原来的message_left.png图片删除，只保留制作好的message_left.9.png图片 即可，因为Android项目中不允许同一文件夹下有两张相同名称的图片（即使后缀名不同也不行）

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#d8e0e8"
    >
    <!-- 用于显示聊天消息-->
    <androidx.recyclerview.widget.RecyclerView
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:id="@+id/recyclerView"
        android:layout_weight="1"
        />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content">

       <EditText
           android:id="@+id/inputText"
           android:layout_width="0dp"
           android:layout_height="wrap_content"
           android:layout_weight="1"
           android:hint="输入"
           android:maxLines="2"
           />

        <Button
            android:id="@+id/send"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="发送"
            />

    </LinearLayout>


</LinearLayout>

主界面中放置了一个RecyclerView用于显示聊天的消息内容，又放置了一个EditText用 于输入消息，还放置了一个Button用于发送消息

消息类

class Msg(val content: String, val type: Int) {
    companion object {
        // 表示收到的消息
        const val TYPE_RECEIVED = 0
        // 表示发送的消息
        const val TYPE_SENT = 1
    }
}

定义常量的关键字是 const 注意只有在单例类、companion object或顶层方法中才可以使用const关键字

新建RecyclerView的子布局(分别为左右消息图形显示建立布局xml文件)

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:padding="10dp">

    <LinearLayout
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="start"
        android:background="@drawable/message_left">

        <TextView
            android:id="@+id/leftMsg"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center"
            android:layout_margin="10dp"
            android:textColor="#fff"/>

    </LinearLayout>


</FrameLayout>

Msg类以及适配器

/**
 * MsgAdapter继承RecyclerView 的Adapter
 * 泛型设置为RecyclerView.ViewHolder
 * 使用两个内部类作为Holder，继承RecyclerView.ViewHolder
  */
class MsgAdapter(val msgList: List<Msg>):
        RecyclerView.Adapter<RecyclerView.ViewHolder>() {
            inner class LeftViewHolder(view: View): RecyclerView.ViewHolder(view) {
                // 初始化leftMsg
        val leftMsg: TextView = view.findViewById(R.id.leftMsg)
            }
            inner class RightViewHolder(view: View): RecyclerView.ViewHolder(view) {
                // 初始化rightMsg
        val rightMsg: TextView = view.findViewById(R.id.rightMsg)
            }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int) = if (viewType == Msg.TYPE_RECEIVED) {
        // 根据不同类型来创建不同的View
        val view = LayoutInflater.from(parent.context).inflate(R.layout.msg_left_item, parent, false)
        LeftViewHolder(view)
    } else {
        val view = LayoutInflater.from(parent.context).inflate(R.layout.msg_right_item, parent, false)
        RightViewHolder(view)
    }

    // 重写getItemViewType方法，支持Kotlin语法糖 obj.viewType
    override fun getItemViewType(position: Int): Int {
        val msg = msgList[position]
        return msg.type
    }

    // 用于设置View的实际内容
    override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
        val msg = msgList[position]
        when(holder) {
            is LeftViewHolder -> holder.leftMsg.text = msg.content
            is RightViewHolder -> holder.rightMsg.text = msg.content
            else -> throw IllegalArgumentException()
        }
    }

    // 返回msg的数量
    override fun getItemCount() = msgList.size
}

MainActivity

class MainActivity : AppCompatActivity() {

    private val msgList = ArrayList<Msg>()

    private var adapter: MsgAdapter? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val bind = ActivityMainBinding.inflate(layoutInflater)
        setContentView(bind.root)
        initMsg()
        val layoutManager = LinearLayoutManager(this)
        bind.recyclerView.layoutManager = layoutManager
        adapter = MsgAdapter(msgList)
        bind.recyclerView.adapter = adapter
        bind.send.setOnClickListener {
            val content = bind.inputText.text.toString()
            if (content.isNotEmpty()) {
                val msg = Msg(content, Msg.TYPE_SENT)
                msgList.add(msg)
                // 当有新消息时刷新RecyclerView中的显示
                adapter?.notifyItemInserted(msgList.size - 1)
                // 将RecyclerView定位到最后一行
                bind.recyclerView.scrollToPosition(msgList.size - 1)
                // 清空输入框
                bind.inputText.setText("")
            }
        }
    }

    private fun initMsg() {
        val msg1 = Msg("Hello guy.", Msg.TYPE_RECEIVED)
        msgList.add(msg1)
        val msg2 = Msg("Hello. Who is that?", Msg.TYPE_SENT)
        msgList.add(msg2)
        val msg3 = Msg("This is Tom. Nice talking to you. ", Msg.TYPE_RECEIVED)
        msgList.add(msg3)
    }
}

Kotlin 延迟初始化和密封类

对变量延迟初始化

使用 lateinit 关键字它可以告诉Kotlin编译器，我会在晚些时候对这个变量进行初始化， 这样就不用在一开始的时候将它赋值为null了。

class MainActivity : AppCompatActivity(), View.OnClickListener {
    private lateinit var adapter: MsgAdapter
    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        adapter = MsgAdapter(msgList)
        ...
    }
    override fun onClick(v: View?) {
        ...
	// 原先此处的判空操作也不需要了
        adapter.notifyItemInserted(msgList.size - 1)
        ...
    }
}

对一个全局变量使用了lateinit关键字时，请一定要确保它在被任何地方调用之前 已经完成了初始化工作，否则Kotlin将无法保证程序的安全性

可以通过代码判断是否已经初始化

if (!::adapter.isInitialized) {
	// ...
}

::adapter.isInitialized可用于判断adapter变量是否已经初始化。 虽然语法看上去有点奇怪，但这是固定的写法。

使用密封类优化代码

实例代码

import java.lang.Exception

interface Result

class Success(val msg: String) : Result

class Failure(val error: Exception) : Result

fun getResultMsg (result: Result) = when(result) {
    is Success -> result.msg
    is Failure -> result.error
    else -> throw IllegalArgumentException()
}

问题： 我们不得不再编写一个else条 件，否则Kotlin编译器会认为这里缺少条件分支，代码将无法编译通过。但实际上Result的执 行结果只可能是Success或者Failure，这个else条件是永远走不到的，所以我们在这里直接 抛出了一个异常，只是为了满足Kotlin编译器的语法检查而已。 另外，编写else条件还有一个潜在的风险。如果我们现在新增了一个Unknown类并实现 Result接口，用于表示未知的执行结果，但是忘记在getResultMsg()方法中添加相应的条 件分支，编译器在这种情况下是不会提醒我们的，而是会在运行的时候进入else条件里面，从 而抛出异常并导致程序崩溃。

使用密封类解决该问题

import java.lang.Exception

sealed class Result

class Success(val msg: String) : Result()

class Failure(val error: Exception) : Result()

fun getResultMsg (result: Result) = when(result) {
    is Success -> result.msg
    is Failure -> result.error
}

import android.view.View
import android.widget.TextView
import androidx.recyclerview.widget.RecyclerView

sealed class MsgViewHolder (view: View): RecyclerView.ViewHolder(view)

class LeftViewHolder(view: View): MsgViewHolder(view) {
    val leftMsg: TextView = view.findViewById(R.id.leftMsg)
}

class RightViewHolder(view: View): MsgViewHolder(view) {
    val rightMsg: TextView = view.findViewById(R.id.rightMsg)
}

修改MsgAdapter中的代码

class MsgAdapter(val msgList: List<Msg>) : RecyclerView.Adapter<MsgViewHolder>() {
    ...
    override fun onBindViewHolder(holder: MsgViewHolder, position: Int) {
        val msg = msgList[position]
        when (holder) {
            is LeftViewHolder -> holder.leftMsg.text = msg.content
            is RightViewHolder -> holder.rightMsg.text = msg.content
        }
    }
    ...
}

Fragment

Fragment是什么

Fragment是一种可以嵌入在Activity当中的UI片段，它能让程序更加合理和充分地利用大屏幕 和Activity非常像 的空间

Fragment的使用方式

新建fragment的view

此处实现左右fragment平分activity

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:orientation="vertical"
    android:background="#00ff00"
    android:layout_height="match_parent">

    <TextView
        android:layout_gravity="center_horizontal"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textSize="24sp"
        android:text="This is right fragment"
        />

</LinearLayout>

activity_main.xml内容

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <fragment
        android:id="@+id/leftFrag"
        android:layout_width="0dp"
        android:name="com.example.fragmenttest.LeftFragment"
        android:layout_height="match_parent"
        android:layout_weight="1"/>

    <fragment
        android:id="@+id/rightFrag"
        android:layout_width="0dp"
        android:name="com.example.fragmenttest.RightFragment"
        android:layout_height="match_parent"
        android:layout_weight="1"/>

</LinearLayout>

新建类，继承子Androidx下的Fragment

系统内置的Fragment在Android9.0已经被弃用

import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment

class LeftFragment: Fragment() {
    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        return inflater.inflate(R.layout.left_fragment, container, false)
    }
}

class RightFragment: Fragment() {
    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        return inflater.inflate(R.layout.right_fragment, container, false)
    }
}

动态添加Fragment

Fragment可以在程序运行时，动态地添加到Activity中 新建another_right_fragment.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:background="#ffff00"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal"
        android:textSize="24sp"
        android:text="This is another right fragment"
        />

</LinearLayout>

kotlin class

class AnotherRightFragment: Fragment() {
    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        return inflater.inflate(R.layout.another_right_fragment, container, false)
    }
}

修改activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <fragment
        android:id="@+id/leftFrag"
        android:layout_width="0dp"
        android:name="com.example.fragmenttest.LeftFragment"
        android:layout_height="match_parent"
        android:layout_weight="1"/>

    <FrameLayout
        android:id="@+id/rightLayout"
        android:layout_width="0dp"
        android:layout_height="match_parent"
        android:layout_weight="1"
        />


</LinearLayout>

修改MainActivity中的代码

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.fragment.app.Fragment
import com.example.fragmenttest.databinding.ActivityMainBinding
import com.example.fragmenttest.databinding.LeftFragmentBinding

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val bind = ActivityMainBinding.inflate(layoutInflater)
        setContentView(bind.root)

	// 此处注意，这样写，btn将无法注册监听事件
        // val b1 = LeftFragmentBinding.inflate(layoutInflater)
	// 获取btn并且设置监听事件应该在其父View设置，即使用viewBinding 绑定父View
	// 或者目前使用findViewById
	val btn = findViewById<Button>(R.id.btn)
        btn.setOnClickListener {
            replaceFragment(AnotherRightFragment())
        }
        replaceFragment(RightFragment())
    }

    private fun replaceFragment(fragment: Fragment) {
        val fragmentManager = supportFragmentManager
        val transaction = fragmentManager.beginTransaction()
        transaction.replace(R.id.rightLayout, fragment)
        transaction.commit()
    }
}

此时Fragment并没有加入返回栈中，直接返回会退出程序

动态添加Fragment的步骤

(1) 创建待添加Fragment的实例。 (2) 获取FragmentManager，在Activity中可以直接调用getSupportFragmentManager() 方法获取。 (3) 开启一个事务，通过调用beginTransaction()方法开启。 (4) 向容器内添加或替换Fragment，一般使用replace()方法实现，需要传入容器的id和待添 加的Fragment实例。 (5) 提交事务，调用commit()方法来完成。

在Fragment中实现返回栈

调用addToBackStack方法即可

private fun replaceFragment(fragment: Fragment) {
        val fragmentManager = supportFragmentManager
        val transaction = fragmentManager.beginTransaction()
        transaction.replace(R.id.rightLayout, fragment)
        transaction.addToBackStack(null)
        transaction.commit()
    }

addToBackStack 接受一个名字描述返回栈的状态

Fragment和Activity之间的交互

为了方便Fragment和Activity之间进行交互，FragmentManager提供了一个类似于 findViewById()的方法，专门用于从布局文件中获取Fragment的实例

val fragment = supportFragmentManager.findFragmentById(R.id.leftFrag) as LeftFragment

调用FragmentManager的findFragmentById()方法，可以在Activity中得到相应 Fragment的实例，然后就能轻松地调用Fragment里的方法了。 同样 在每个Fragment中都可以通过调用getActivity()方法来得到和当前Fragment相关联的Activity实例

if (activity != null) {
	val mainActivity = activity as MainActivity
}

另外当Fragment中需要使用Context对象时，也可以使用getActivity()方法，因为获取到的Activity本身就是一个Context对象。

不同的Fragment之间通信，可以让其中一个Fragment获取Activity，在通过Activity获取其他的Fragment

Fragment的生命周期

1. 运行状态 当一个Fragment所关联的Activity正处于运行状态时，该Fragment也处于运行状态。
2. 暂停状态 当一个Activity进入暂停状态时（由于另一个未占满屏幕的Activity被添加到了栈顶），与 它相关联的Fragment就会进入暂停状态。
3. 停止状态 当一个Activity进入停止状态时，与它相关联的Fragment就会进入停止状态，或者通过调 用FragmentTransaction的remove()、replace()方法将Fragment从Activity中移 除，但在事务提交之前调用了addToBackStack()方法，这时的Fragment也会进入停止 状态。总的来说，进入停止状态的Fragment对用户来说是完全不可见的，有可能会被系统 回收。
4. 销毁状态 Fragment总是依附于Activity而存在，因此当Activity被销毁时，与它相关联的 Fragment就会进入销毁状态。或者通过调用FragmentTransaction的remove()、 replace()方法将Fragment从Activity中移除，但在事务提交之前并没有调用 addToBackStack()方法，这时的Fragment也会进入销毁状态。

Fragment的回调方法

同样地，Fragment类中也提供了一系列的回调方法，以覆盖它生命周期的每个环节。其中，Activity中有的回调方法， Fragment中基本上也有，不过Fragment还提供了一些附加的回调方法

• onAttach()：当Fragment和Activity建立关联时调用。
• onCreateView()：为Fragment创建视图（加载布局）时调用。
• onActivityCreated()：确保与Fragment相关联的Activity已经创建完毕时调用。
• onDestroyView()：当与Fragment关联的视图被移除时调用。
• onDetach()：当Fragment和Activity解除关联时调用。

Fragment完整生命周期

flowchart
s1([添加一个Fragment]) --> s2["onAttach()"]
s2 --> s3["onCreate()"]
s3 --> s4["onCreateView()"]
s4 --> s5["onActivityCreated()"]
s5 --> s6["onStart()"]
s6 --> s7["onResume()"]
s7 --> s8[Fragment已激活]
s8 -- 用户点击返回键或Fragment被移除/替换 ----> s9["onPause()"]
s8 -- 当Fragment被添加到返回栈,然后被移除/替换 ----> s9
s9 --> s10["onStop()"]
s9 --> s10
s10 --> s11["onDestroyView()"]
s10 --> s11
s11 --> s12["onDestroy()"]
s11 -- 从返回栈中返回上一个Fragment ----> s4
s12 --> s13["onDetach()"]
s13 --> s14([Fragment被销毁])

体验Fragment的生命周期

class RightFragment: Fragment() {

    companion object {
        const val TAG = "RightFragment"
    }

    override fun onAttach(context: Context) {
        super.onAttach(context)
        Log.d(TAG, "onAttach")
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        Log.d(TAG, "onCreate")
    }

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        Log.d(TAG, "onCreateView")
        return inflater.inflate(R.layout.right_fragment, container, false)
    }

    // 此处该方法已经被弃用
    override fun onActivityCreated(savedInstanceState: Bundle?) {
        Log.d(TAG, "onActivityCreated")
        super.onActivityCreated(savedInstanceState)
    }

    override fun onStart() {
        Log.d(TAG, "onStart")
        super.onStart()
    }

    override fun onResume() {
        Log.d(TAG, "onResume")
        super.onResume()
    }

    override fun onPause() {
        Log.d(TAG, "onPause")
        super.onPause()
    }

    override fun onStop() {
        Log.d(TAG, "onStop")
        super.onStop()
    }

    override fun onDestroyView() {
        Log.d(TAG, "onDestroyView")
        super.onDestroyView()
    }

    override fun onDestroy() {
        Log.d(TAG, "onDestroy")
        super.onDestroy()
    }

    override fun onDetach() {
        Log.d(TAG, "onDetach")
        super.onDetach()
    }
}

在Fragment中也可以通过 onSaveInstanceState() 方法来保存数据

动态加载布局的技巧

使用限定符

在res文件夹下的layout文件夹下创建layout-large文件夹，里面创建一个activity_main.xml文件， 该文件与layout文件夹下的文件同名,layout与layout-large对应了不同屏幕尺寸的设备的布局文件 此处两个文件内容为

layout文件夹下的activity_main.xml文件内容

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="horizontal"
    tools:context=".MainActivity">

    <fragment
        android:id="@+id/leftFrag"
        android:layout_width="0dp"
        android:name="com.example.fragmenttest.LeftFragment"
        android:layout_height="match_parent"
        android:layout_weight="1"/>


</LinearLayout>

layout-large文件夹下的activity_main.xml文件内容

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="horizontal"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <fragment
        android:id="@+id/leftFrag"
        android:layout_width="0dp"
        android:name="com.example.fragmenttest.LeftFragment"
        android:layout_height="match_parent"
        android:layout_weight="1"
        />


    <fragment
        android:id="@+id/rightFrag"
        android:layout_width="0dp"
        android:name="com.example.fragmenttest.RightFragment"
        android:layout_height="match_parent"
        android:layout_weight="3"
        />

</LinearLayout>

对应MainActivity代码依然如之前，只是注释掉了replaceFragment内容, 分别启动平板虚拟和手机虚拟机，程序会分别加载layout-large和layout下的activity_main.xml文件 由此实现了同一个程序，动态加载布局的效果

Android中常见的限定符

使用最小宽度限定符

最小宽度限定符允许我们对屏幕的宽度指定一个最小值（以dp为单位），然后以这个最小值为 临界点，屏幕宽度大于这个值的设备就加载一个布局，屏幕宽度小于这个值的设备就加载另一 个布局。 在res目录下新建layout-sw600dp文件夹，然后在这个文件夹下新建activity_main.xml布 局

<!--activity_main.xml 文件-->
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <fragment
        android:id="@+id/leftFrag"
        android:name="com.example.fragmenttest.LeftFragment"
        android:layout_width="0dp"
        android:layout_height="match_parent"
        android:layout_weight="1" />
    <fragment
        android:id="@+id/rightFrag"
        android:name="com.example.fragmenttest.RightFragment"
        android:layout_width="0dp"
        android:layout_height="match_parent"
        android:layout_weight="3" />

</LinearLayout>

这就意味着，当程序运行在** 屏幕宽度 大于等于600 dp的设备上时，会加载layout- sw600dp/activity_main布局，当程序运行在 屏幕宽度 小于600 dp的设备**上时，则仍然加载 默认的layout/activity_main布局。

Fragment最佳实践: 一个简易版的新闻应用

news_content_frag.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <LinearLayout
        android:id="@+id/contentLayout"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        android:visibility="invisible"
        >
        <TextView
            android:id="@+id/newsTitle"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:gravity="center"
            android:padding="10dp"
            android:textSize="20sp"
            />
        <!--    水平细线用于分割标题和内容    -->
        <View
            android:layout_width="match_parent"
            android:layout_height="1dp"
            android:background="#000"/>
       <TextView
           android:id="@+id/newsContent"
           android:layout_width="match_parent"
           android:layout_height="0dp"
           android:layout_weight="1"
           android:padding="15dp"
           android:textSize="18sp"
           />
    </LinearLayout>
    <!--    竖直细线用于分割列表和内容    -->
    <View
        android:layout_width="match_parent"
        android:layout_height="1dp"
        android:layout_alignParentLeft="true"
        android:background="#000"
        />

</RelativeLayout>

要将新闻内容的布局设置成不可见。因为在双页模式下，如果还没有选中新闻列 表中的任何一条新闻，是不应该显示新闻内容布局的。 其他代码请参考仓库

fun ClassName.methodName(param1: Int, param2: Int): Int {
	return 0
}

eg: 给String添加扩展函数

fun String.letterCount(): Int {
    var count = 0
    for(char in this) {
        if (char.isLetter()) {
            count++
        }
    }
    return count
}

扩展函数也是可以定义在任何一个现有类当中的，并不一定非要创建新文件。 不过通常来说，最好将它定义成顶层方法，这样可以让扩展函数拥有全局的访问域。

fun String.letterCount(): Int {
    var count = 0
    for(char in this) {
        if (char.isLetter()) {
            count++
        }
    }
    return count
}

fun main() {
    println("awefawefweafe".letterCount())
}

函数运算符重载

重载运算符使用 operator 关键字 要重载对应的运算符，需要使用 operator 关键字加上对应操作的函数名 eg: 重载+，operator fun plus eg: 重载字符串 * ，使字符串能像Python一样复制 另外，必须说明的是，其实Kotlin的String类中已经提供了一个用于将字符串重复 n 遍的 repeat()函数，

operator fun String.times(n: Int) = repeat(n)

fun main() {
    println("ss" * 3)
}

广播机制

广播简介

广播类型

• 标准广播(normal broadcasts) 是一种完全异步执行的广播，在广播发出之后，所有的 BroadcastReceiver几乎会在同一时刻收到这条广播消息，因此它们之间没有任何先后顺 序可言。这种广播的效率会比较高，但同时也意味着它是无法被截断的。

flowchart LR
s1([发出第一条广播]) --> s2([BroadcastReceiver1])
s1 --> s3([BroadcastReceiver2])
s1 --> s4([BroadcastReceiver3])

• 有序广播(ordered broadcasts) 则是一种同步执行的广播，在广播发出之后，同一时刻 只会有一个BroadcastReceiver能够收到这条广播消息，当这个BroadcastReceiver中的 逻辑执行完毕后，广播才会继续传递。所以此时的BroadcastReceiver是有先后顺序的， 优先级高的BroadcastReceiver就可以先收到广播消息，并且前面的BroadcastReceiver 还可以截断正在传递的广播，这样后面的BroadcastReceiver就无法收到广播消息了。

flowchart LR
s1([发出第一条广播]) --> s2([BroadcastReceiver1])
s2 -- 可将广播截断 --> s3([BroadcastReceiver2])
s3 -- 可将广播截断 --> s4([BroadcastReceiver3])

接收系统广播

动态监听时间变化

BroadcastReceiver的方式一般有两种：在代码中注册和在**AndroidManifest.xml中注册。**其 中前者也被称为动态注册，后者也被称为静态注册。

那么如何创建一个BroadcastReceiver呢？其实只需新建一个类，让它继承自 BroadcastReceiver，并重写父类的onReceive()方法就行了。这样当有广播到来时， onReceive()方法就会得到执行，具体的逻辑就可以在这个方法中处理。

class MainActivity : AppCompatActivity() {

    private lateinit var timeChangeReceiver: TimeChangeReceiver

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val intentFilter = IntentFilter()
        intentFilter.addAction("android.intent.action.TIME_TICK")
        timeChangeReceiver = TimeChangeReceiver()
        registerReceiver(timeChangeReceiver, intentFilter)
    }

    override fun onDestroy() {
        super.onDestroy()
        unregisterReceiver(timeChangeReceiver)
    }

    inner class TimeChangeReceiver: BroadcastReceiver() {
        override fun onReceive(context: Context?, intent: Intent?) {
            Toast.makeText(context, "Time has changed", Toast.LENGTH_SHORT).show()
        }
    }
}

因为当系统时间发生变化时，系统发出的正是一条值为android.intent.action.TIME_TICK的广播， 也就是说我们的BroadcastReceiver想要监听什么广播，就在这里添加相应的action。接下 来创建了一个TimeChangeReceiver的实例，然后调用registerReceiver()方法进行注 册，将TimeChangeReceiver的实例和IntentFilter的实例都传了进去，这样 TimeChangeReceiver就会收到所有值为android.intent.action.TIME_TICK的广播， 也就实现了监听系统时间变化的功能。

系统每隔一分钟发送一条 android.intent.action.TIME_TICK 的广播

静态注册实现开机启动

动态注册的BroadcastReceiver可以自由地控制注册与注销，在灵活性方面有很大的优势。但 是它存在着一个缺点，即必须在程序启动之后才能接收广播，因为注册的逻辑是写在 onCreate()方法中的。 静态注册可以在程序未启动的状态下也能接收广播

使用android.intent.action.BOOT_COMPLETED

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.widget.Toast

class BootCompleteReceiver : BroadcastReceiver() {

    override fun onReceive(context: Context, intent: Intent) {
        Toast.makeText(context, "Boot Complete", Toast.LENGTH_LONG).show()
    }
}

静态的BroadcastReceiver一定要在AndroidManifest.xml文件中注册才可以使用

<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>

    <!-- <application.... -->
    <!-- ... -->
<receiver
            android:name=".BootCompleteReceiver"
            android:enabled="true"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.BOOT_COMPLETED"/>
            </intent-filter>
        </receiver>

另外，这里有非常重要的一点需要说明。Android 系统为了保护用户设备的安全和隐私，做了 严格的规定：**如果程序需要进行一些对用户来说比较敏感的操作，必须在 AndroidManifest.xml文件中进行权限声明，否则程序将会直接崩溃。**比如这里接收系统的开 机广播就是需要进行权限声明的，所以我们在上述代码中使用 <uses-permission> 标签声明 了android.permission.RECEIVE_BOOT_COMPLETED权限

需要注意的是，不要在onReceive()方法中添加过多的逻辑或者进行任何的耗时操作，因为 BroadcastReceiver中是不允许开启线程的，当onReceive()方法运行了较长时间而没有结 束时，程序就会出现错误。

发送自定义广播

发送标准广播

继承BroadCastReceiver并重写onReceive方法

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.widget.Toast

class MyBroadcastReceiver: BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent?) {
        Toast.makeText(context, "received in MyBroadcastReceiver", Toast.LENGTH_SHORT).show()
    }
}

修改AndroidMainifest.xml

<receiver
            android:name=".MyBroadcastReceiver"
            android:enabled="true"
            android:exported="true">
            <intent-filter>
                <action android:name="my_broadcast"/>
            </intent-filter>
        </receiver>

修改onCreate方法

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val bind = ActivityMainBinding.inflate(layoutInflater)
        setContentView(bind.root)
        bind.button.setOnClickListener {
            val intent = Intent("com.example.broadcasttest.MY_BROADCAST")
            intent.setPackage(packageName)
            sendBroadcast(intent)
        }
}

调用Intent的setPackage()方法，并传入当前应用程序的包名。packageName是getPackageName()的语法糖写法，用 于获取当前应用程序的包名。最后调用sendBroadcast()方法将广播发送出去，这样所有监 听com.example.broadcasttest.MY_BROADCAST这条广播的BroadcastReceiver就会收 到消息了。此时发出去的广播就是一条标准广播。

这里我还得对第2步调用的setPackage()方法进行更详细的说明。前面已经说过，在Android 8.0系统之后，静态注册的BroadcastReceiver是无法接收隐式广播(隐式广播指的 是那些没有具体指定发送给哪个应用程序的广播，大多数系统广播属于隐式广播)的，而默认情况下我们发出 的自定义广播恰恰都是隐式广播。因此这里一定要调用setPackage()方法，指定这条广播是 发送给哪个应用程序的，从而让它变成一条显式广播，否则静态注册的BroadcastReceiver将 无法接收到这条广播。

发送有序广播

新建AnotherBroadcastReceiver

class AnotherBroadcastReceiver: BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent?) {
        Toast.makeText(context, "received in AnotherBroadcastReceiver", Toast.LENGTH_SHORT).show()
    }
}

在AndroidMainifest.xml文件中配置

<receiver
            android:name=".AnotherBroadcastReceiver"
            android:enabled="true"
            android:exported="true">
            <intent-filter>
                <action android:name="com.example.broadcasttest.MY_BROADCAST"/>
            </intent-filter>
        </receiver>

kotlin代码