Kotlin学习(六) --其他特殊的类

Kotlin的特殊的类

把之前学的kotlin知识总结一下哈，区别于java kotlin有很多特殊的类，主要就是根据安卓开发设计的感觉。

数据类

这个数据类就很关键了，可以节约好多开发的时间，尤其是在解析json数据时候，自己创建的类的时候，用数据类就很方便。

格式：data class 类名(var param1 ：数据类型,…){}

关键字：data

举个例子：在java中一个数据类如下

public class Person {

private String name;
private String surname;
private String id;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getSurname() {
return surname;
}

public void setSurname(String surname) {
this.surname = surname;
}

public String getId() {
return id;
}

public void setId(String id) {
this.id = id;
}

@Override public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;

Person person = (Person) o;

if (name != null ? !name.equals(person.name) : person.name != null) return false;
if (surname != null ? !surname.equals(person.surname) : person.surname != null)
return false;
return id != null ? id.equals(person.id) : person.id == null;

}

@Override public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + (surname != null ? surname.hashCode() : 0);
result = 31 * result + (id != null ? id.hashCode() : 0);
return result;
}

@Override public String toString() {
return "Person{" +
"name='" + name + ''' +
", surname='" + surname + ''' +
", id='" + id + ''' +
'}';
}
}

但在kotlin里面我们可能只需要一行。。。。emmmmmm

data class Person(var name: String, var surname: String, var id: String)

其中我们就可以发现省了好多的代码，，查资料我发现kotlin的数据类帮我们做了好多的事

当我们声明一个数据类时，编辑器自动为这个类做了一些事情，不然它怎么又比Java简洁呢。它会根据主构造函数中所定义的所有属性自动生成下列方法：

1生成equals()函数与hasCode()函数

2生成toString()函数，由类名（参数1 = 值1，参数2 = 值2，….）构成

3由所定义的属性自动生成component1()、component2()、…、componentN()函数，其对应于属性的声明顺序。

4copy()函数。

copy函数的用法

在数据类的特殊copy函数就是可以局部修改部分属性，但是保持其他不变

就像下面的例子

val mUser = User("笑笑","16")
println(mUser)
val mNewUser = mUser.copy(name = "小笑笑")
println(mNewUser)

输出结果是：

User(name=笑笑, pwd=16)

User(name=小笑笑, pwd=16)

解构声明

Kotlin中定义一个数据类，则系统会默认自动根据参数的个数生成component1() … componentN()函数。其…,componentN()函数就是用于解构声明的 个人理解就是可以是单独把数据类对象的个别变量的值得出来 看下下面的例子

val mUser = User("笑笑,"17")
val (name,pwd) = mUser
println("name = $name\tpwd = $pwd")

输出结果：

name = 笑笑 pwd = 17

抽象类

这个和java里面的抽象类差不多一样的

关键字：abstract

abstract可以修饰类 也可以修饰抽象类里面的变量和方法

举例子

abstract class Lanauage{
val TAG = this.javaClass.simpleName  // 自身的属性

// 自身的函数
fun test() : Unit{
// exp
}
abstract var name : String           // 抽象属性
abstract fun init()                  // 抽象方法
}

class TestAbstarctA : Lanauage(){

override var name: String
get() = "Kotlin"
set(value) {}

override fun init() {
println("我是$name")
}
}

class TestAbstarctB : Lanauage(){
override var name: String
get() = "Java"
set(value) {}

override fun init() {
println("我是$name")
}
}

fun main(args: Array<String>) {

// val lanauage = Lanauage() 是错误的，因为抽象类不能直接被实例化

val mTestAbstarctA = TestAbstarctA()
val mTestAbstarctB = TestAbstarctB()

println(mTestAbstarctA.name)
mTestAbstarctA.init()

println(mTestAbstarctB.name)
mTestAbstarctB.init()
}

输出结果：

Kotlin

我是Kotlin

Java

我是Java

抽象类本身具有普通类特性，以及组成部分。不过值得注意的是，抽象类不能直接被实例化

其抽象了类的子类必须全部重写带abstract修饰的属性和方法。

抽象成员只有定义，没有实现。都有abstract修饰符修饰。

抽象类是为其子类定义了一个模板。不同是类实现不同的功能

抽象类中可以定义内部抽象类。

只能继承一个抽象类。

若要实现抽象类的实例化，需要依靠子类采用向上转型的方式处理。

抽象类可以继承自一个继承类，即抽象类可以作为子类。

内部类

在安卓开发中内部类和匿名内部类都是很常见的

关键字：inner

格式：inner class 类名(参数){}

class Other{            // 外部类
val numOther = 1

inner class InnerClass{     // 嵌套内部类
val name = "InnerClass"
fun init(){
println("我是内部类")
}
}
}

fun main(args: Array<String>) {
Other().InnerClass().init()
}

输出结果：我是内部类

注意：调用内部类的属性或方法的格式为：外部类().内部类().内部类方法/属性。在调用的时候嵌套类是需要实例化的。

内部类不能使用外部类的属性和成员

在这里注意内部类和嵌套类的区别

1 嵌套类没有关键字/所谓的嵌套类：即指一个类可以嵌套在其他类中。

2嵌套类可以直接创建实例，方式是包装类.嵌套类

val nested : Outter.Nested()

3内部类不能直接创建实例，需要通过外部类调用

val outter = Outter()

outter.Inner().execute()

4 嵌套类的调用方法 外部类.内部类().内部类方法/属性

ps就是没带括号啊啊啊啊啊

匿名内部类

这个安卓开发经常用在开发中，匿名内部类随处可见。比如说Button的OnClickListener，ListView的单击、长按事件等都用到了匿名内部类。 一般的使用方式为定义一个接口，在接口中定义一个方法。

class Other{

lateinit private var listener : OnClickListener

fun setOnClickListener(listener: OnClickListener){
this.listener = listener
}

fun testListener(){
listener.onItemClick("我是匿名内部类的测试方法")
}
}

interface OnClickListener{
fun onItemClick(str : String)
}

fun main(args: Array<String>){
// 测试匿名内部类
val other = Other()
other.setOnClickListener(object : OnClickListener{
override fun onItemClick(str: String) {
// todo
println(str)
}
})
other.testListener()
}

接口中的属性使用

在接口中申明属性。接口中的属性要么是抽象的，要么提供访问器的实现。接口属性不可以有后备字段。而且访问器不可以引用它们。接口里面都是抽象的方法必须靠继承类来实例化它的方法

关键字：interface

格式：interface 接口名{

…

}

fun main(args: Array<String>) {

// 类的初始化
var demo = Demo1()

demo.fun1()
}

/**
* 我定义的接口
*/
interface Demo1Interface{

// 定义的方法
fun fun1()
}

/**
* 接口的实现类
*/
class Demo1 : Demo1Interface{
override fun fun1() {
println("我是接口中的fun1方法")
}
}

总结

这几天就看了几个kotlin类的相关知识，，，还有密封类什么的看不太懂