}
通过上述的代码比较,Kotlin对类的写法与Java之间有以下几点区别:
(1)Kotlin省略了关键字public,因为Kotlin默认类是开放的,所以不需要这个关键字。
(2)Kotlin用冒号“:”代替extends,也就是通过冒号表示继承关系。
(3)Kotlin进行继承时,父类后面多了括号“()”。
然后我们自己新建名为Animal的Kotlin类
步骤:
鼠标右键你的包名→New→Kotlin File/Class→创建的文件类型选择Class→OK(创建完成)
然后你就会看到这样的一个图
现在开始编写代码:
package com.llw.kotlinstart
class Animal {
//类的初始化函数
init {
//Kotlin的println替换Java的System.out.println
println(“Animal:这是个动物类”)
}
}
现在这个类已经创建好了,并且有了初始化函数,我们在MainActivity.kt中来实例化这个类,代码如下:
activity_main.xml代码
<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android=“http://schemas.android.com/apk/res/android”
xmlns:app=“http://schemas.android.com/apk/res-auto”
xmlns:tools=“http://schemas.android.com/tools”
android:orientation=“vertical”
android:gravity=“center_horizontal”
android:layout_width=“match_parent”
android:layout_height=“match_parent”
tools:context=“.MainActivity”>
<TextView
android:textColor=“#000”
android:id=“@+id/tv_title”
android:layout_width=“wrap_content”
android:layout_height=“wrap_content”/>
<TextView
android:textColor=“#000”
android:id=“@+id/tv_result”
android:layout_width=“wrap_content”
android:layout_height=“wrap_content”/>
<LinearLayout
android:gravity=“center”
android:layout_marginTop=“20dp”
android:layout_width=“match_parent”
android:layout_height=“wrap_content”>
<Button
android:id=“@+id/btn_test”
android:text=“Test”
android:layout_width=“wrap_content”
android:layout_height=“wrap_content”/>
MainActivity.kt代码
package com.llw.kotlinstart
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import kotlinx.android.synthetic.main.activity_main.*
import java.lang.Exception
import java.text.SimpleDateFormat
import java.util.*
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
btn_test.setOnClickListener {
//因为根据等号后面的构造函数已经明确知道这是个Animal的实例
//所以声明对象时可以不用指定它的类型
var animal = Animal()
tv_result.text = “简单类的初始化结果见日志”
}
}
}
运行效果图如下:
经过这一番操作,我们再与Java对比一下区别:
(1)Kotlin对类进行初始化的函数名称叫init,不像Java那样把雷鸣作为构造函数的名称。
(2)Kotlin打印日志使用类似C语言的println方法,而非Java的System.out.println
(3)Kotlin创建实例时省略了关键字new。
这里面,初始化函数init看似是Kotlin对类的构造函数,但它只是构造函数的一部分,并不完整,因为没有定义输入参数,那么怎么定义呢?谁来定义呢?
入参的类定义代码如下:
//如果主构造函数没有带@符号的注解说明,类名后面的constructor就可以省略
class AnimalMain constructor(context:Context,name:String){
//class AnimalMain (context:Context,name:String){
init {
context.toast(“这是头$name”)
}
}
一个类可能有多个构造函数,Java可以通过覆写带不同参数的构造函数来实现,那么Kotlin已经在类名后面指明了固定数量的入参,又该如何表示拥有其他参数的构造函数呢?针对这个问题,Kotlin引入了主构造函数与二级构造函数的概念,之前的代码演示的是主构造函数,分为两部分,跟在类名后面的参数是主构造函数的入参,同时init方法是主构造函数的内部代码,至于二级构造函数,则可以在类内部直接书写完整的函数表示式,新建一个名为AnimalMain的类,代码如下:
class AnimalMain constructor(context:Context,name:String){
init {
context.toast(“这是头$name”)
}
constructor(context: Context,name: String,sex:Int) : this(context,name){
var sexName:String = if(sex ==0 ) “公” else “母”
context.toast(“这头 n a m e 是 {name}是 name是{sexName}的”)
}
}
从以上代码可以看出,二级构造函数和普通函数相比有以下两个区别:
(1)二级构造函数没有函数名称,只用关键字constructor表示这是一个构造函数。
(2)二级构造函数需要调用主构造函数。“this(context,name)”这句代码在Java中要以“super(context,name)”的形式写在函数体内部,在Kotlin中则以冒号开头补充到输入参数后面,这意味着二级构造函数实际上是从主构造函数派生出来的,也可以看作二级函数的返回值是主构造函数。
由此看来,二级构造函数从属于主构造函数,如果使用二级构造函数声明该类的实例,系统就会先调用主构造函数的init代码,再调用二级构造函数的自身代码,现在若想声明AnimalMain类的实例,既可通过主构造函数,也可通过二级构造函数,代码如下:
package com.llw.kotlinstart
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import kotlinx.android.synthetic.main.activity_main.*
import java.lang.Exception
import java.text.SimpleDateFormat
import java.util.*
class MainActivity : AppCompatActivity() {
var animalName:String = “”
var animalSex:Int = 0
var count:Int = 0
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
btn_test.setOnClickListener {
setAnimalInfo()
when(count%2){
0 -> { var animal = AnimalMain(this,animalName) }
else -> { var animal = AnimalMain(this,animalName,animalSex) }
}
count++
}
}
fun setAnimalInfo() {
animalName = “牛”
animalSex = 0
}
}
上面代码在运作过程中,通过二级构造函数声明实例有一个问题,就是toast会弹窗两次,因为主构造函数的init方法已经弹窗,然后二级构造函数自身再次弹窗,那能不能不调用主构造函数呢?为了解决该问题,Kotlin设定了主构造函数时不是必需的,也就是说类可以把几个构造函数都放在类内部定义,从而都变成二级构造函数,如此就去掉了主构造函数,为了直观,重新建名为一个AnimalSeparate的类,代码如下
package com.llw.kotlinstart
import android.content.Context
import org.jetbrains.anko.toast
class AnimalSeparate {
constructor(context: Context,name:String){
context.toast(“这是头$name”)
}
constructor(context: Context,name: String,sex:Int){
var sexName:String = if(sex ==0 ) “公” else “母”
context.toast(“这头 n a m e 是 {name}是 name是{sexName}的”)
}
}
这样写就没有主构造函数了,都是二级构造函数,直接使用即可,函数之间没有从属关系,不存在重复调用。
说到默认参数,不知道你有没有想起之前的带默认参数的函数呢?上面的代码中,两个构造函数之间只有一个输入参数的区别,所以完全可以把二者合二为一,变成一个带默认参数的主构造函数,新的主构造函数既能输入两个参数,又能输入三个参数,新创建一个类AnimalDefault,代码如下:
package com.llw.kotlinstart
import android.content.Context
import org.jetbrains.anko.toast
class AnimalDefault (context: Context,name:String,sex:Int = 0){
init {
var sexName:String = if(sex == 0) “公” else “母”
context.toast(“这只 n a m e 是 {name}是 name是{sexName}的”)
}
}
运行效果类似,但是代码更加的简洁了。
===================================================================
创建一个新的类WildAnimal,然后在构造函数中放两个参数,代码如下:
class WildAnimal(name:String,sex:Int = 0) {
}
然后我们再声明对应的属性字段,用于保存入参的数值,加入按照Java的编码思路,下面的代码应该是这样的。
class WildAnimal(name: String, sex: Int = 0) {
var name: String // 表示动物名称可以修改
val sex: Int //表示动物性别不能修改
init {
this.name = name
this.sex = sex
}
}
这上面的写法从Java的角度来看倒是没有问题,但如果时Kotlin呢,代码冗余了,
(1)属性字段跟构造函数的入参,二者名称一样,变量类型也一样。
(2)初始化函数中的属性字段赋值,为了区别同名的属性和入参,特意给属性字段添加了this。
那么Kotlin如何精简这个类的代码呢?代码如下:
class WildAnimal(var name: String,val sex: Int = 0) {
}
你没有看错,就是这样,接下来使用一下吧。
package com.llw.kotlinstart
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import kotlinx.android.synthetic.main.activity_main.*
import java.lang.Exception
import java.text.SimpleDateFormat
import java.util.*
class MainActivity : AppCompatActivity() {
var animalName: String = “”
var animalSex: Int = 0
var count: Int = 0
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
btn_test.setOnClickListener {
setAnimalInfo()
var animal = when (count % 2) {
0 -> {
WildAnimal(animalName)
}
else -> {
WildAnimal(animalName, animalSex)
}
}
count++
tv_result.text = “这头 a n i m a l . n a m e 是 {animal.name}是 animal.name是{if (animal.sex == 0) “公” else “母”}的”
}
}
fun setAnimalInfo() {
animalName = “牛”
animalSex = 1
}
}
再看看Java代码中怎么做的
package com.llw.kotlinstart;
public class WildAnimal {
private String name;
private String sex;
public WildAnimal(String name, String sex) {
this.name = name;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
很熟悉吧,因为基本上每一个实体都离不开这一步,
对比一下:
(1)冗余的同名属性声明语句。
(2)冗余的同名属性赋值语句。
(3)冗余的属性获取方法与设置方法。
Kotlin的代码真的精简了很多,鸟枪换炮,
如果某个字段并非入参的同名属性,就需要在类内部显示声明该属性字段,例如,前面WildAnimal类的性别只是一个整型的类型字段,而界面上展示的是性别的中文名称,所以应当给该类补充一个性别名称的属性字段,这样每次访问sexName字段即可获得该动物的性别名称,新建一个名为WildAnimalMember的类,代码如下:
package com.llw.kotlinstart
class WildAnimalMember (val name:String,val sex:Int = 0) {
//非空的成员属性必须在声明时赋值或者在构造函数中赋值,否则编译器会报错
var sexName:String
init {
sexName = if(sex == 0) “公” else “母”
}
}
然后再看一下怎么调用这个类:
package com.llw.kotlinstart
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import kotlinx.android.synthetic.main.activity_main.*
import java.lang.Exception
import java.text.SimpleDateFormat
import java.util.*
class MainActivity : AppCompatActivity() {
var animalName: String = “”
var animalSex: Int = 0
var count: Int = 0
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
btn_test.setOnClickListener {
setAnimalInfo()
var animal = when (count % 2) {
0 -> {
WildAnimalMember(animalName)
}
else -> {
WildAnimalMember(animalName, animalSex)
}
}
count++
tv_result.text = “这头 a n i m a l . n a m e 是 {animal.name}是 animal.name是{animal.sexName}的”
}
}
fun setAnimalInfo() {
animalName = “牛”
animalSex = 1
}
}
类的成员除了成员属性还有成员方法,在类内部定义成员方法的过程和普通函数定义比较类似。下面增加一个获取动物描述信息的成员方法getDesc(),新创建一个名为WildAnimalFunction的类
package com.llw.kotlinstart
class WildAnimalFunction(var name: String, val sex: Int = 0) {
var sexName: String
init {
sexName = if (sex == 0) “公” else “母”
}
fun getDesc(tag: String): String {
return “欢迎来到 t a g :这头 tag:这头 tag:这头{name}是${sexName}的”
}
}
然后我们在MainActivity.kt中调用这个类的方法
package com.llw.kotlinstart
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import com.llw.kotlinstart.custom_class.WildAnimalFunction
import kotlinx.android.synthetic.main.activity_main.*
class MainActivity : AppCompatActivity() {
var animalName: String = “”
var animalSex: Int = 0
var count: Int = 0
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
btn_test.setOnClickListener {
setAnimalInfo()
var animal = when(count%2){
0 -> WildAnimalFunction(
animalName
)
else -> WildAnimalFunction(
animalName,
animalSex
)
}
tv_result.text = animal.getDesc(“动物园”)
count++
}
}
fun setAnimalInfo() {
animalName = “牛”
animalSex = 1
}
}
伴生对象这个是在Kotlin中有的,Java中没有,什么是伴生对象呢,你可以把它理解为“影子”,把类当做一个人,这个人可以有很多房子,但是人只有一个,影子也只有一个。你也可以把伴生对象替换掉静态成员的作用,但它比静态成员的功能要强大。我们之前通过性别类型来获得性别名称,那么反推呢,我们使用伴生对象来实现这一功能,新创建一个名为WildAnimalCompanion的类
package com.llw.kotlinstart.custom_class
class WildAnimalCompanion (var name: String,val sex:Int = 0) {
var sexName:String
init {
sexName = if(sex == 0) “公” else “母”
}
fun getDesc(tag: String): String {
return “欢迎来到 t a g :这头 tag:这头 tag:这头{name}是${sexName}的”
}
//关键字companion表示伴随,object表示对象,WildAnimal表示伴生对象的名称
companion object WildAnimal{
fun judgeSex(sexName:String):Int{
var sex:Int = when (sexName){
“公”,“雄” -> 0
“母”,“雌” -> 1
else -> -1
}
return sex
}
}
}
代码应该没有什么好说的,一目了然,关键定义这个伴生对象和使用它,接下来看怎么使用
代码如下:
package com.llw.kotlinstart
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import com.llw.kotlinstart.custom_class.WildAnimalCompanion
import com.llw.kotlinstart.custom_class.WildAnimalFunction
import kotlinx.android.synthetic.main.activity_main.*
class MainActivity : AppCompatActivity() {
var count: Int = 0
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val sexArray:Array = arrayOf(“公”,“母”,“雄”,“雌”)
btn_test.setOnClickListener {
var sexName:String = sexArray[count++%4]
//伴生对象的WildAnimal名称可以省略掉
//tv_result.text = "“ s e x N a m e 对 ¨ 应的类型是 sexName\"对应的类型是 sexName对¨应的类型是{WildAnimalCompanion.WildAnimal.judgeSex(sexName)}”
tv_result.text = "“ s e x N a m e 对 ¨ 应的类型是 sexName\"对应的类型是 sexName对¨应的类型是{WildAnimalCompanion.judgeSex(sexName)}”//双引号 要加反斜杠 如同这样 “”
}
}
}
这个是灰色的,我们省略掉也是可以的
有四种结果,我只放两个图
之前我们的伴生对象可以实现静态函数,同样也能实现静态属性,只要在伴生对象内部增加几个字段定义就行了,之前是用0和1表示动物的雄雌,接下来用整型常量MALE表示雄性的0,整型常量FEMALE表示雌性的1,创建一个名为WildAnimalConstant的类,代码如下,
package com.llw.kotlinstart.custom_class
class WildAnimalConstant(var name: String, val sex: Int = MALE) {
var sexName: String
init {
sexName = if (sex == MALE) “公” else “母”
}
fun getDesc(tag: String): String {
return “欢迎来到 t a g : 这只 tag: 这只 tag:这只{name}是${sexName}的。”
}
companion object WildAnimal {
//静态常量的值是不可变得,所以要使用关键字val修饰
val MALE = 0
val FEMALE = 1
val UNKOWN = -1
fun judgeSex(sexName:String):Int{
var sex:Int = when(sexName){
“公”,“雄” -> MALE
“母”,“雌” -> FEMALE
else -> UNKOWN
}
return sex
}
}
}
然后再进行调用
val sexArray:Array = arrayOf(“公”,“母”,“雄”,“雌”)
btn_test.setOnClickListener {
var sexName:String = sexArray[count++%4]
//伴生对象的WildAnimal名称可以省略掉
//tv_result.text = "“ s e x N a m e 对 ¨ 应的类型是 sexName\"对应的类型是 sexName对¨应的类型是{WildAnimalCompanion.WildAnimal.judgeSex(sexName)}”
tv_result.text = "“ s e x N a m e 对 ¨ 应的类型是 sexName\"对应的类型是 sexName对¨应的类型是{WildAnimalConstant.judgeSex(sexName)}”//双引号 要加反斜杠 如同这样 “”
}
改一下类名就可以了,运行效果和之前的是一样的,只不过程序里面就可以通过WildAnimalConstant.MALE和WildAnimalConstant.FEMALE来判断公母了,不像之前通过0和1这种毫无意义的值来判断。
Kotlin的类成员分为实例成员与静态成员,实例成员包括成员属性和成员方法,其中与入参同名的成员属性可以在构造函数中直接声明,外部必须通过类的实例才能访问类的成员属性和成员方法,类的静态成员包括静态属性与静态方法,它们都在类的伴生对象中定义,外部可以通过类名直接访问该类的静态成员。
===================================================================
我们一开始就提到了类的继承,如class MainActivity : AppCompatActivity(),这和Java是不一样的,那么Kotlin怎么定义基类并由基类派生出子类呢?
之前我们写了好多个WildAnimal类,Java和Kotlin关于类的继承还有区别,比如Java中默认每个类都能被继承,除非加了final关键字,而Kotlin刚好相反,它默认每个类都不能被继承(PS:这不是搞我心态吗!!!),这个时候要想让一个类成为基类,就要把该类开放出来,于是就用到了开放性修饰符open(PS:敲黑板,重点来了,哪个),演示代码如下:
open class Animal(var name:String,val sex:Int = 0){
}
在Java中有几个熟悉的关键字,public、protected、private,分别表示公开、只对子类开放、私有。那么在Kotlin中也给出了4个开放性修饰符。
| 开放性修饰符 | 说明 |
| — | — |
| public | 对所有人开放。Kotlin的类、函数、变量不加开放性修饰符的话,默认就是public类型 |
| internal | 只对本模块内部开放,这是Kotlin新增的关键字。 |
| protected | 只对自己和子类开放 |
| private | 只对自己开放、即私有 |
注意到这几个修饰符与open一样都加在类和函数前面,并且都包含“开放”的意思,乍看起来还真有点迷,到底open跟这4个开放性修饰符是什么关系呢?其实很简单,open不控制某个对象的访问权限,只决定该对象能否繁衍开来,说白了,就是公告这个叼毛有没有资格繁衍下一代,只有头戴open帽子的类,才允许作为基类派生出子类来,而头戴open帽子的函数,表示它允许在子类中进行重写,如果没戴open帽子,该类就只好打光棍了,函数没戴open帽子的话,类的孩子就没有办法修改它。
至于那4个开放性修饰符,则是用来限定允许访问某对象的外部范围,通俗地说,就是哪里的帅哥可以跟这个美女搞对象,头戴public的,表示全世界的帅哥都能跟她处对象,头戴internal的,表示只有本国的帅哥可以,头戴protected的,表示自由本单位以及下属单位的可以,头戴private,表示自己本单位可以。
创建一个Poultry类,代码如下:
package com.llw.kotlinstart.custom_class
//Kotlin的类型默认是不能继承的(即 final类型),如果需要继承某类,该父类就应当声明open类型
open class Poultry (var name:String,val sex:Int = MALE){
//变量、方法、类默认都是public,所以一般都把public省略掉了
var sexName:String
init {
sexName = getSexName(sex)
}
//私有的方法既不能被外部访问,也不能被子类继承,因此open与private不能共存,否则编译器会报错
open protected fun getSexName(sex:Int):String{
return if(sex == MALE) “公” else “母”
}
fun getDesc(tag:String):String{
return “欢迎来到 t a g : 这只 tag: 这只 tag:这只{name}是${sexName}的。”
}
companion object BirdStatic{
val MALE = 0
val FEMALE = 1
val UNKOWN = -1
fun judgeSex(sexName:String):Int {
var sex:Int = when (sexName){
“公”,“雄” -> MALE
“母”,“雌” -> FEMALE
else -> UNKOWN
}
return sex
}
}
}
然后我们再创建一个名为Pig的子类,继承Poultry,代码如下:
package com.llw.kotlinstart.custom_class
//注意父类Bird已经在构造函数声明了属性,故而子类Pig无须重复声明属性
//也就是说,子类的构造函数在输入参数前面不需要再加val和var
class Pig(name:String=“猪”,sex: Int= MALE) : Poultry(name, sex){
}
然后在Activity中调用:
package com.llw.kotlinstart
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import com.llw.kotlinstart.custom_class.*
import kotlinx.android.synthetic.main.activity_main.*
class MainActivity : AppCompatActivity() {
var count: Int = 0
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
var sex:Int
btn_test.setOnClickListener {
var sexPoultry = if(count++%3==0) Poultry.MALE else Poultry.FEMALE
var pig = Pig(sex = sexPoultry)
tv_result.text = pig.getDesc(“高老庄”)
}
}
}
运行效果图如下:
然后再来定义一个小狗类 Dog的代码
package com.llw.kotlinstart.custom_class
class Dog (name:String = “哈士奇”,sex:Int = MALE):Poultry(name, sex){
override public fun getSexName(sex: Int): String {
return if(sex == MALE) “雄” else “雌”
}
}
然后在Activity中调用
package com.llw.kotlinstart
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import com.llw.kotlinstart.custom_class.*
import kotlinx.android.synthetic.main.activity_main.*
class MainActivity : AppCompatActivity() {
var count: Int = 0
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
var sex:Int
btn_test.setOnClickListener {
var sexPoultry = if(count++%3==0) Poultry.MALE else Poultry.FEMALE
var dog = Dog(sex = sexPoultry)
tv_result.text = dog.getDesc(“狗狗流浪记”)
}
}
}
运行效果图如下:
Kotlin中也存在与Java类似的抽象类,抽象类之所以存在,是因为其内部拥有被关键字abstract修饰的抽象方法。抽象方法没有具体的函数体,故而外部无法直接声明抽象类的实例,只有在子类继承时重写方法,方可使用该子类正常声明对象实例。
For Example ,鸡属于鸟类,可是公鸡和母鸡的叫声是不一样的,所以鸡这个类的叫唤方法“callOut”发出什么声音并不确定,只能先声明为抽象方法,连带着鸡类“Chicken”也变成抽象类了。
现在定义一个抽象的Chicken类,代码如下:
package com.llw.kotlinstart.custom_class
//子类的构造函数,原来的输入参数不用加var和val,新增的输入参数必须加var或者val
//因为抽象类不能直接使用,所以构造函数不必默认参数赋值
abstract class Chicken (name:String,sex:Int,var voice:String):Poultry(name, sex){
val numberArray:Array = arrayOf(“一”,“二”,“三”,“四”,“五”,“六”,“七”)
//抽象方法必须在子类进行重写,所以可以省略关键字open,因为abstract方法默认就是open类型
//open abstract fun callOut(times:Int):String
abstract fun callOut(times:Int):String
}
然后我们从Chicken类派生出公鸡类Cock,指定攻击的叫声为“喔喔喔”,同时还要重写callOut方法,明确公鸡的叫唤行为。具体代码如下:
package com.llw.kotlinstart.custom_class
class Cock(name:String=“鸡”,sex:Int = Poultry.MALE,voice:String=“喔喔喔”): Chicken(name, sex, voice) {
override fun callOut(times: Int): String {
var count = when {
//when语句判断大于和小于时,要把完整的判断条件写到每个分支中
times <=0 ->0
times >=7 -> 6
else -> times
}
return “ s e x N a m e sexName sexNamename v o i c e 叫了 {voice}叫了 voice叫了{numberArray[count]}声,这是在报晓”
}
}
再派生出公鸡类Hen,指定攻击的叫声为“咯咯咯”,再重写callOut方法
package com.llw.kotlinstart.custom_class
class Hen(name:String=“鸡”,sex:Int = Poultry.FEMALE,voice:String=“咯咯咯”): Chicken(name, sex, voice) {
override fun callOut(times: Int): String {
var count = when {
//when语句判断大于和小于时,要把完整的判断条件写到每个分支中
times <=0 ->0
times >=7 -> 6
else -> times
}
return “ s e x N a m e sexName sexNamename v o i c e 叫了 {voice}叫了 voice叫了{numberArray[count]}声,这是在下蛋”
}
}
然后在Activity中调用不同的类
package com.llw.kotlinstart
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import com.llw.kotlinstart.custom_class.*
import kotlinx.android.synthetic.main.activity_main.*
class MainActivity : AppCompatActivity() {
var count: Int = 0
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
btn_test.setOnClickListener {
//调用公鸡类
tv_result.text = Cock().callOut(count++ % 7)
}
}
}
package com.llw.kotlinstart
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import com.llw.kotlinstart.custom_class.*
import kotlinx.android.synthetic.main.activity_main.*
class MainActivity : AppCompatActivity() {
var count: Int = 0
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
btn_test.setOnClickListener {
//调用母鸡类
tv_result.text = Hen().callOut(count++%7)
}
}
}
运行结果
Kotlin的接口与Java一样是为了间接实现多重继承,由于直接继承多个类可能存在方法冲突等问题,因此Kotlin在编译阶段就不允许某个类同
时继承多个基类,否则会报错,于是,只能通过接口定义几个抽象方法,然后在实现该接口的具体类中重写这几个方法,从而间接实现类似C++多重继承的功能。
在Kotlin中定义接口需要注意以下几点:
(1)接口不能定义构造函数,否则编译器会报错"An interface may not have a constructor"。
(2)接口的内部方法通常要被实现它的类进行重写,所以这些方法默认为抽象类型。
(3)与Java不同的是,Kotlin允许在接口内部实现某个方法,而Java接口的所有内部方法都必须是抽象方法。
Android开发中最常见的接口是控件的点击监听器View.OnClickListener,它内部的点击动作onClick,类似的还有长按监听器、选中监听器等等,它们无一例外都定义了某种行为的事件处理过程。我们可以用一个列子来表达这些,比如鸟儿的飞翔、游泳、奔跑等,下面定义一个行为接口 Behavior。
package com.llw.kotlinstart.custom_class
//Kotlin与Java一样不允许多重继承,即不能同时继承两个及两个以上类
//否则编译器报错"Only one class may appear in a supertype list"
//所以仍然需要接口interface 来间接实现多重继承的功能
//接口不能带构造函数(那样就变成一个类了),否则编译器报错"An interface may not have a constructor"
interface Behavior {
//接口内部的方法默认就是抽象的,所以不加abstract 也可以,当然open也可以不加
open abstract fun fly():String
//比如下面这个swim方法就没有加关键字abstract ,也无须在此实现方法
fun swim():String
//Kotlin的接口与Java的区别在于,Kotlin接口内部允许实现方法
//此时该方法不是抽象方法,就不能加上abstract
//不过该方法依然是open类型,接口内部的所有方法都默认是open类型
fun run():String{
return “大多数鸟儿跑得并不像样,只有鸵鸟、鸸鹋等少数鸟类才擅长奔跑。”
}
//Kotlin的接口允许声明抽象属性,实现该接口的类必须重载该属性
//与接口内部方法一样,抽象属性前面的open和abstract 也可以省略掉
//open abstract var skiledSporte:String
var skiledSporte:String
}
在其他类实现这个接口时,跟类继承一样把接口名称放在冒号后面,也就是说,Java的extends和implement这两个关键字在Kotlin中都被冒号取代了。然后就想重写抽象类的抽象方法一样重写接口的抽象方法,创建一个名为Goose的类,代码如下:
package com.llw.kotlinstart.custom_class
class Goose(name: String = “鹅”, sex: Int = Poultry.MALE) : Poultry(name, sex), Behavior {
override fun fly(): String {
return “鹅能飞一点点,但是飞不高,也飞不远”
}
override fun swim(): String {
return “鹅是会游泳的”
}
//因为接口已经实现了run方法,所以此处可以不用实现该方法,当你也可以实现它
override fun run(): String {
//super用来调用父类的属性或方法,由于Kotlin的接口允许实现方法,因此super所指的对象也可以是interface
return super.run()
}
//重载了来自接口的抽象属性
override var skiledSporte: String = “游泳”
}
然后在Activity中使用
package com.llw.kotlinstart
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import com.llw.kotlinstart.custom_class.*
import kotlinx.android.synthetic.main.activity_main.*
class MainActivity : AppCompatActivity() {
var count: Int = 0
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
btn_test.setOnClickListener {
tv_result.text = when(count++%3){
0 -> Goose().fly()
1 -> Goose().swim()
else -> Goose().run()
}
}
}
}
运行效果如下图:
调用fly方法
调用swim方法
调用run方法
通过接口固然完成了相应行为,但是鸟类这个家族非常庞大,如果每种鸟都实现Behavior接口,工作量是非常大的,其实鸟类的行为并不多,可以分类为飞禽、水禽、走禽三个行为类
下面是飞禽的行为类代码示例:
package com.llw.kotlinstart.custom_class
class BehaviorFly : Behavior {
override fun fly(): String {
return “翱翔天空”
}
override fun swim(): String {
return “落水凤凰不如鸡”
}
override fun run(): String {
return “能飞干嘛还要走”
}
override var skiledSporte: String = “飞翔”
}
下面是水禽
package com.llw.kotlinstart.custom_class
class BehaviorSwim : Behavior {
override fun fly(): String {
return “看情况,大雁能展翅高飞,企鹅却欲飞还休”
}
override fun swim(): String {
return “怡然戏水”
}
override fun run(): String {
return “赶鸭子上树”
}
override var skiledSporte: String = “游泳”
}
下面是走禽
package com.llw.kotlinstart.custom_class
class BehaviorRun : Behavior {
override fun fly(): String {
return “飞不起来”
}
override fun swim(): String {
return “望洋兴叹”
}
override fun run(): String {
return super.run()
}
override var skiledSporte: String = “奔跑”
}
最后说一下我的学习路线
其实很简单就下面这张图,含概了Android所有需要学的知识点,一共8大板块:
- 架构师筑基必备技能
- Android框架体系架构(高级UI+FrameWork源码)
- 360°Androidapp全方位性能调优
- 设计思想解读开源框架
- NDK模块开发
- 移动架构师专题项目实战环节
- 移动架构师不可不学习微信小程序
- 混合开发的flutter
Android学习的资料
我呢,把上面八大板块的分支都系统的做了一份学习系统的资料和视频,大概就下面这些,我就不全部写出来了,不然太长了影响大家的阅读。
330页PDF Android学习核心笔记(内含上面8大板块)
Android学习的系统对应视频
总结
我希望通过我自己的学习方法来帮助大家去提升技术:
-
1、多看书、看源码和做项目,平时多种总结
-
2、不能停留在一些基本api的使用上,应该往更深层次的方向去研究,比如activity、view的内部运行机制,比如Android内存优化,比如aidl,比如JNI等,并不仅仅停留在会用,而要通过阅读源码,理解其实现原理
-
3、同时对架构是有一定要求的,架构是抽象的,但是设计模式是具体的,所以一定要加强下设计模式的学习
-
4、android的方向也很多,高级UI,移动架构师,数据结构与算法和音视频FFMpeg解码,如果你对其中一项比较感兴趣,就大胆的进阶吧!
希望大家多多点赞,转发,评论加关注,你们的支持就是我继续下去的动力!加油!
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》,点击传送门,即可获取!
方法
通过接口固然完成了相应行为,但是鸟类这个家族非常庞大,如果每种鸟都实现Behavior接口,工作量是非常大的,其实鸟类的行为并不多,可以分类为飞禽、水禽、走禽三个行为类
下面是飞禽的行为类代码示例:
package com.llw.kotlinstart.custom_class
class BehaviorFly : Behavior {
override fun fly(): String {
return “翱翔天空”
}
override fun swim(): String {
return “落水凤凰不如鸡”
}
override fun run(): String {
return “能飞干嘛还要走”
}
override var skiledSporte: String = “飞翔”
}
下面是水禽
package com.llw.kotlinstart.custom_class
class BehaviorSwim : Behavior {
override fun fly(): String {
return “看情况,大雁能展翅高飞,企鹅却欲飞还休”
}
override fun swim(): String {
return “怡然戏水”
}
override fun run(): String {
return “赶鸭子上树”
}
override var skiledSporte: String = “游泳”
}
下面是走禽
package com.llw.kotlinstart.custom_class
class BehaviorRun : Behavior {
override fun fly(): String {
return “飞不起来”
}
override fun swim(): String {
return “望洋兴叹”
}
override fun run(): String {
return super.run()
}
override var skiledSporte: String = “奔跑”
}
最后说一下我的学习路线
其实很简单就下面这张图,含概了Android所有需要学的知识点,一共8大板块:
- 架构师筑基必备技能
- Android框架体系架构(高级UI+FrameWork源码)
- 360°Androidapp全方位性能调优
- 设计思想解读开源框架
- NDK模块开发
- 移动架构师专题项目实战环节
- 移动架构师不可不学习微信小程序
- 混合开发的flutter
[外链图片转存中…(img-Nb5HhTOC-1715847565044)]
Android学习的资料
我呢,把上面八大板块的分支都系统的做了一份学习系统的资料和视频,大概就下面这些,我就不全部写出来了,不然太长了影响大家的阅读。
330页PDF Android学习核心笔记(内含上面8大板块)
[外链图片转存中…(img-GTbGLRN9-1715847565047)]
Android学习的系统对应视频
总结
我希望通过我自己的学习方法来帮助大家去提升技术:
-
1、多看书、看源码和做项目,平时多种总结
-
2、不能停留在一些基本api的使用上,应该往更深层次的方向去研究,比如activity、view的内部运行机制,比如Android内存优化,比如aidl,比如JNI等,并不仅仅停留在会用,而要通过阅读源码,理解其实现原理
-
3、同时对架构是有一定要求的,架构是抽象的,但是设计模式是具体的,所以一定要加强下设计模式的学习
-
4、android的方向也很多,高级UI,移动架构师,数据结构与算法和音视频FFMpeg解码,如果你对其中一项比较感兴趣,就大胆的进阶吧!
希望大家多多点赞,转发,评论加关注,你们的支持就是我继续下去的动力!加油!
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》,点击传送门,即可获取!