安卓的语法 import android.app.activity,Kotlin的Android开篇探究Activity（一）
赞
踩
上一篇文章对Kotlin常用的语法进行了学习，
当前系列文章，将针对Android开发在Kotlin下的代码风格进行学习
目录
1.1 findviewById
1.2 点击、吐司、菜单
1.3 Intent跳转(显示、隐式、Action)
1.4 Intent传递数据与返回
1.5 companion object
1.6 标准函数with、run、apply
1.7 定义静态方法
1.8 BaseActivity的简单封装
1.1 findviewById
布局有大量控件的时候，之前开发需要大量的findviewById。所以在java中为了规避可以使用黄油刀等系列的控件。在Kotlin中就不需要了，在布局设置的id，在页面可以直接使用，使用之前自动导入以下包
import kotlinx.android.synthetic.main.activity_main.*
1.2 点击、吐司、菜单
1.2.1 随便声明一个控件
android:id="@+id/tvBtn"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello World!"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintLeft_toLeftOf="parent"
app:layout_constraintRight_toRightOf="parent"
app:layout_constraintTop_toTopOf="parent" />
1.2.2单例一个吐司
object ToastUtils {
fun toast(content: Context, text: String) {
Toast.makeText(content, text, Toast.LENGTH_SHORT).show()
}
}
1.2.3菜单布局
android:id="@+id/add_item"
android:title="add" />
android:id="@+id/delete_item"
android:title="delete" />
1.2.4整合到一起的Activity页面
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
//点击
tvBtn.setOnClickListener {
//吐司
ToastUtils.toast(this,"this is a toast")
//跳转 xx::class.java
val intent = Intent(this, SecondActivity::class.java)
startActivity(intent)
}
}
//菜单方法
override fun onCreateOptionsMenu(menu: Menu?): Boolean {
menuInflater.inflate(R.menu.menu_main_text, menu)
return true
}
//菜单方法
override fun onOptionsItemSelected(item: MenuItem): Boolean {
when (item.itemId) {
R.id.add_item -> ToastUtils.toast(this, "this is add item")
R.id.delete_item -> ToastUtils.toast(this, "this is delete item")
}
return true
}
}
1.3 Intent跳转(显示、隐式、Action)
val intent = Intent(this, SecondActivity::class.java)
startActivity(intent)
val intent2 = Intent("com.hdsx.helloworld.ui.activity.second")
intent2.addCategory("thisziyiding")
startActivity(intent2)
val intent3 = Intent(Intent.ACTION_VIEW)
intent3.data = Uri.parse("https://www.baidu.com")
startActivity(intent3)
Activity ::class.java标记跳转class
** 第二个Activity的filter
关于Intent.xxx不在多说，跟java以前一样，有兴趣的可自行扩展
1.4 Intent传递数据与返回
触发
val intent = Intent(this, SecondActivity::class.java)
intent.putExtra("value", "value")
startActivityForResult(intent, 11)
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
super.onActivityResult(requestCode, resultCode, data)
when (requestCode) {
11 -> if (resultCode == Activity.RESULT_OK) {
val stringExtra = data?.getStringExtra("resultvalue")
tvBtn.setText(stringExtra)
}
}
}
接收返回
class SecondActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_second)
val stringExtra = intent.getStringExtra("value")
tv_second.setText(stringExtra)
}
override fun onBackPressed() {
val intent = Intent()
intent.putExtra("resultvalue", "resultvalue")
setResult(Activity.RESULT_OK, intent)
finish()
}
}
1.5 companion object
在实际开发中，假设A页面和B页面分别是不同的同事开发，那A页面同事想要跳转到B页面的时候，会问B同事都要什么参数，或者说去看B页面同事的逻辑来确定参数。不管是哪种方法都会觉得很麻烦，在Kotlin中新加新的语法结构。companion object中的方法都可以使用类似于Java静态方法的形式调用，如下：
B同事写法
class SecondActivity : AppCompatActivity() {
companion object {
fun appStartSecondActivity(context: Context, resultvalue: String) {
val intent = Intent(context, SecondActivity::class.java)
intent.putExtra("value", resultvalue)
context.startActivity(intent)
}
}
}
A同事调用
SecondActivity.appStartSecondActivity(this, "resultvalue")
不但简写了代码，还对B同事需要的参数一目了然。如果所有的Activity从最开始书写时都规定好，那良好的习惯能减少很多不必要的麻烦。
1.6 标准函数with、run、apply
1.6.1 with
with(对象){ 对象的上下文环境}
举例这个公式的含义，如下：
先定义一个举例环境，
val listOf = listOf("orange", "apple", "pear")
val stringBuilder = StringBuilder()
stringBuilder.append("this start \n")
for (value in listOf) {
stringBuilder.append(value).append("\n")
}
stringBuilder.append("this end")
val toString = stringBuilder.toString()
println(toString)
>log:
this start
orange
apple
pear
this end
可见上述stringBuilder这个对象被多次调用。这种情况下可以考虑用with来精简代码
val listOf = listOf("orange", "apple", "pear")
val with = with(StringBuilder()) {
append("this start \n")
for (value in listOf) {
append(value).append("\n")
}
append("this end")
toString()
}
println(with)
>log:
this start
orange
apple
pear
this end
可见上述with在花括号里 直接表示包裹对象的上下文环境，这就是with的作用
1.6.2 run
run跟with的函数意义差不多，但是不能像with直接使用，需要有提供对象，具体如下
val listOf = listOf("orange", "apple", "pear")
val run = StringBuilder().run {
append("this start \n")
for (value in listOf) {
append(value).append("\n")
}
append("this end")
toString()
}
println(run)
>log,
this start
orange
apple
pear
this end
1.6.3 apply
apply在功能跟上述都差不多，有区别的是，apply返回的是对象本身，而不是像run返回指定的类型。
image.png
val listOf = listOf("orange", "apple", "pear")
val apply = StringBuilder().apply {
append("this start \n")
for (value in listOf) {
append(value).append("\n")
}
append("this end \n")
toString()
}
println(apply.toString())
>log
this start
orange
apple
pear
this end
this apply
可以看图片，虽然在上下文环境中toString了，但实际apply的类型还是StringBuilder
针对这个函数，我们可以对intent跳转进行优化，如下：
companion object {
fun appStartSecondActivity(context: Context, resultvalue: String) {
val intent = Intent(context, SecondActivity::class.java).apply {
putExtra("value", resultvalue)
putExtra("value2", resultvalue)
}
context.startActivity(intent)
}
}
1.7 定义静态方法
之前上一章《Kotlin的语法学习之旅》知道了单例，通过单例我们也可以实现在Kotlin中全局调用，但加了object关键字会使得整个类的所有方法都是开放式的。 如果只是想其中某一个方法静态呢？可以使用本章( 1.5 companion object )如下：
class Test {
companion object {
fun addStaticMethod() {
println("this is jia de static")
}
}
}
这样就可以在全局调用，但实际这个关键词并不是真正的静态。如果工程是有java又有Kotlin的，在java代码中就调用不了。这种时候Kotlin也提供了方法
class Test {
companion object {
@JvmStatic
fun addStaticMethod() {
println("this is jia de static")
}
}
}
@JvmStatic只能加在单例，或者被companion object修饰过得方法上，别的加了会报错。
1.7.1 顶层方法
除上述外，想全局使用还有一种就是顶层方法。顶层方法指的是 建立个xxx.kt文件，在kt文件里面书写的方法全都是全局可随意调用的。
image.png
image.png
当然在Java中并没有什么顶层方法。但是Kotlin会自动根据这些创建一个一样的java类。在java中调用的话，就需要使用对象名 。 方法
public class Test2 {
public void Test2() {
LettestKt.testString2();
}
}
LettestKt是自动生成的。
1.8 BaseActivity的简单封装
没写别的，就写了添加activity和移除activity，用目前所学为基准
1.8.1封装添加删除
import android.app.Activity
object ActivityCollector {
private val arrayList = ArrayList()
fun addActivity(activity: Activity) {
arrayList.add(activity)
}
fun removeActivity(activity: Activity) {
arrayList.remove(activity)
}
fun cleadAllActivity() {
for (activity in arrayList) {
if (!activity.isFinishing) {
activity.finish()
}
}
arrayList.clear()
}
}
1.8.2创建BaseActivity
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import com.hdsx.helloworld.ui.utils.ActivityCollector
open class BaseActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
ActivityCollector.addActivity(this)
}
override fun onDestroy() {
super.onDestroy()
ActivityCollector.removeActivity(this)
}
}
加open关键字，表示当前类可被继承
1.8.3 别的类继承
class MainActivity : BaseActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
}
}
: 可以表示继承，也可以表示接口
总结：
别的都不说，省略findviewById还是挺爽的，
在代码上确实很精简，目前学到的Activity相关的跟Java在一些特性上还是大同小异的。
