kotlin主构造函数代码块和静态代码块
class Person(var name: String, var age: Int) {
fun walk() {
println("Kotlin Person walk...")
}
//有时候我们想在构造函数中做一些操作，可以在init代码块中进行
init {
println("这是init 代码块")
println("构造函数中的name=$name,age=$age")
}
//kotlin代码
companion object { //kotlin的静态代码块
init{
println("这是静态代码块的init")
}
}
}
fun main() {
val person = Person("kotlin",3)
// println(person.name + person.age)
person.walk()
}
//输出
这是静态代码块的init
这是init 代码块
构造函数中的name=kotlin,age=3
Kotlin Person walk...
在安卓自定义View的时候我们有多个构造函数重载
class TestView(private var context: String, private var attributeSet: String?, private var attr: Int) {
constructor(context: String) : this(context, null, 0)
constructor(context: String, attributeSet: String?) : this(context, attributeSet, 0)
init {
println("context是$context,attributeSet=$attributeSet,attr$attr")
println("这里做初始化工作...")
}
}
fun main() {
val view1 = TestView("Context1")
val view2 = TestView("Context2","AttributeSet2")
val view3 = TestView("Context3","AttributeSet3",10086)
}
//输出
context是Context1,attributeSet=null,attr0
这里做初始化工作...
context是Context2,attributeSet=AttributeSet2,attr0
这里做初始化工作...
context是Context3,attributeSet=AttributeSet3,attr10086
这里做初始化工作...
多个init块，执行顺序是代码顺序
class Cat(name: String){
//类体中也可以访问构造函数的参数
val catName:String = "catName:$name"
//初始化代码块
init {
// 在这里面做一些需要在主构造函数中做的初始化操作
println("第一个初始化代码块,name:$name")
}
init {
println("第二个初始化代码块,name:$name")
}
init {
println("第三个初始化代码块,name:$name")
}
}
// 使用如下：
fun main(args: Array<String>) {
var cat: Cat = Cat("喵喵")
println(cat.catName)//打印属性
}
//输出
第一个初始化代码块,name:喵喵
第二个初始化代码块,name:喵喵
第三个初始化代码块,name:喵喵
catName:喵喵
数据类
- java中实现一个数据类
public class UserBean {
private String name;
private int age;
private long height;
public UserBean(String name, int age, long height) {
this.name = name;
this.age = age;
this.height = height;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public long getHeight() {
return height;
}
public void setHeight(long height) {
this.height = height;
}
@Override
public String toString() {
return "UserBean{" +
"name='" + name + '\'' +
", age=" + age +
", height=" + height +
'}';
}
public static void main(String[] args) {
UserBean user = new UserBean("大雄", 12, 150);
System.out.println("用户" + user.getName() +
",年龄" + user.getAge() +
",身高" + user.getHeight());
System.out.println("用户信息" + user.toString());
}
}
//输出
用户大雄,年龄12,身高150
用户信息UserBean{name='大雄', age=12, height=150}
- 实现一个简单的数据类java的代码量很大，而kotlin只需要几行代码就能实现同样的数据类。kotlin数据类只需要加一个data关键字 还有copy功能
data class UserBean(var name: String, var age: Int, var height: Long)
fun main() {
var user = UserBean("小叮当",100,50)
println("用户${user.name},年龄${user.age},身高${user.height}")
println("用户信息${user.toString()}")
user = user.copy(height = 60)
println("用户信息${user.toString()}")
}
//输出
用户小叮当,年龄100,身高50
用户信息UserBean(name=小叮当, age=100, height=50)
用户信息UserBean(name=小叮当, age=100, height=60)
枚举
- kotlin的枚举和java基本一致，只是kotlin中需要在enum后加class关键字
enum class Direction {
WEST,
EAST,
NORTH,
SOUTH
}
fun main() {
val dr = null
when(dr) {
Direction.EAST -> println("东边")
Direction.WEST -> println("西边")
Direction.NORTH -> println("北边")
Direction.SOUTH -> println("南边")
else -> print("未知方向")
}
}
//枚举常量可以有构造函数和自有属性、方法，自定义方法需放在;后
enum class Season(var enumName: String,var range: String){
Spring("春季","1-3"),
Summer("夏季","4-6"),
Fall("秋季","7-9"),
Winter("冬季","10-12");//终于见到kotlin中的；号了
fun printSeason(){
print("name:$enumName,range:$range")
}
}
fun main() {
val season = Season.Spring
season.printSeason()
}
密封类
密闭类用 sealed 修饰符 ，密闭类的字类必须与密闭类在同一文件中（子类也可以嵌套在密闭类的内部）
sealed class Expr
data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()
//定义在类内部
sealed class Expr{
data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()
}
有几点需要注意：
1、一个密闭类是自身抽象的，它不能直接实例化并可以有抽象（abstract）成员
2、密闭类不允许有非-private 构造函数（其构造函数默认为 private）
3、扩展密闭类子类的类（间接继承者）可以放在任何位置，而无需在同一个文件中。
密闭类算是枚举类的扩展，用法和枚举类相似，经常配合when表达式使用，使用例子如下：
fun eval(expr: Expr): Double = when(expr) {
is Expr.Const -> expr.number
is Expr.Sum -> eval(expr.e1) + eval(expr.e2)
Expr.NotANumber -> Double.NaN
// 不再需要 `else` 子句，因为我们已经覆盖了所有的情况
}
fun main(args: Array<String>) {
val const = eval(Expr.Const(12.0))
val sum = eval(Expr.Sum(Expr.Const(10.0),Expr.Const(12.0)))
println("const:$const")
println("sum:$sum")
}
// 执行结果：
const:12.0
sum:22.0
嵌套类(相当于java静态内部类)
class Outer{
val attr = 0
// 嵌套类
class Nested{
fun inMethod(){
// 不能访问外部类的属性
println("内部类")
}
}
}
fun main(args: Array<String>) {
// 调用嵌套类方法
Outer.Nested().inMethod()
}
内部类
- Kotlin中，内部类用inner关键字，声明，跟Java 一样，内部类持有一个外部类的对象引用，可以访问外部类的属性和方法。
class Outer{
private val attr = 10
inner class Inner{
fun method(){
println("内部类可以访问外部类属性：$attr")
}
}
}
fun main(args: Array<String>) {
// 调用内部类方法,看出区别了吗
Outer().Inner().method()
}
匿名内部类
- 来看一下Java的匿名内部类：
mButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// onClick
}
});
- 在kotlin中，匿名内部类用对象表达式创建，给View设置点击事件的kotlin代码如下：
mButton?.setOnClickListener(object: View.OnClickListener{
override fun onClick(v: View?) {
//onClick
}
})
