kotlin杂谈系列四

最新推荐文章于 2024-07-23 21:37:49 发布

做技术的Pandaer

最新推荐文章于 2024-07-23 21:37:49 发布

阅读量842

点赞数

分类专栏： java 文章标签： java android kotlin

本文链接：https://blog.csdn.net/weixin_59307830/article/details/123929270

版权

笔记同时被 3 个专栏收录

16 篇文章 0 订阅

订阅专栏

kotlin

13 篇文章 0 订阅

订阅专栏

java

13 篇文章 0 订阅

订阅专栏

Kotlin杂谈系列四

很快我们的杂谈系列都到四了如果你有在看的话这个笔记是看Kotlin编程实战而自己总结的笔记
类的层次结构

在kotlin中不能在可继承和不可继承的二元状态下工作
接口

kotlin中的接口是包含了java的接口的全部功能的

还有几个特别点
- 可以有属性但是没有幕后字段
- 可以有默认实现的方法
- 静态方法要依赖于伴生对象和类一样

interface Remote{
    fun up()
    fun down()
    fun doubleUp(){
        up()
        up()
    }
    
    companion object{
        fun print(){
            println("Remote在工作")
        }
    }
}


public interface Remote {
   @NotNull
   Remote.Companion Companion = Remote.Companion.$$INSTANCE;

   void up();

   void down();

   void doubleUp();

/*----------------------kotlin中默认的实现----------------------------*/
  //默认实现就是利用静态的内部类
   public static final class DefaultImpls {
      public static void doubleUp(@NotNull Remote $this) {
         $this.up();
         $this.up();
      }
   }
/*--------------------------------------------------*/
    
    
    
/*----------------------------kotlin中的伴生对象--------------------------*/

  //伴生对象也是静态的内部类 而且还是单例
   public static final class Companion {
      // $FF: synthetic field
      static final Remote.Companion $$INSTANCE;

      public final void print() {
         String var1 = "Remote在工作";
         System.out.println(var1);
      }

      private Companion() {
      }

      static {
         Remote.Companion var0 = new Remote.Companion();
         $$INSTANCE = var0;
      }
  
/*---------------------------------------------------------------------*/
}

抽象类

抽象类和接口的不同点 :
1. 属性有幕后字段
2. 抽象方法必须是抽象类
注意 : 只有标记为abstract的类才是抽象类标记为abstract的方法才是抽象方法
另外 : 抽象类毕竟还是一个类所以还是可以有构造函数,成员属性成员方法
接口用来指定抽象的行为 : 意思是方法没有具体实现交给他的实现类来灵活实现
抽象类用来重用实现 : 就是有很多类的方法是一样的这时候就可以定义一个抽象类来包括这些方法达到了重用的目的
接口是告诉我们很多可能的事–(声明方法)但是从不去做任何事(方法的具体实现)
嵌套类和内部类

在java中似乎并没有嵌套类和内部类分的这么清楚 : 嵌套类不能访问外部类的私有成员而内部类则没有限制

嵌套类

class Room {
    class Person{

    }
}


public final class Room {
//这个就是嵌套类在java中的实现
   public static final class Person {
   }
}

可以看到嵌套类对应的是Java的静态内部类是无法直接访问Room中的成员属性和成员方法的

内部类

class Room {
    var name = "xixi"
    fun hi(){
        println("hi")
    }

      inner class Person{
        
    }
}


public final class Room {
   @NotNull
   private String name = "xixi";

   @NotNull
   public final String getName() {
      return this.name;
   }

   public final void setName(@NotNull String var1) {
      Intrinsics.checkNotNullParameter(var1, "<set-?>");
      this.name = var1;
   }

   public final void hi() {
      String var1 = "hi";
      System.out.println(var1);
   }

  /*这个就是内部类在java中的实现*/
   public final class Person {
   }
}

由于他不是静态内部类所以可以访问父类的成员和属性
继承

kotlin的继承在无形中给我们加了一层保护就是定义类的时候默认是final不能被继承的这有效的防止了我们继承的滥用所以要想继承某个类就必须显示的声明他可以被继承利用关键字open 同样的方法也要声明为可被重写的关键字还是open 不同于java的 kotlin中的属性也是可以被重写的同样关键字还是open

这还是得归功于kotlin中的字段是和getter 和 setter绑定在一起的 而java的setter 和 getter和字段不是绑定在一起的是所以就没有必要重写属性
- 注意 :
  1. 基类中的val属性可以被var或者val的属性派生类重写但是 var属性不能被派生类的val重写只能被派生类的var重写如果在override前加了一个final就会阻止子类进一步重写
```
open class Animal(protected open val name : String,val age : Int  )


open class Cat( final/*这里*/ override val name: String, age : Int) : Animal(name,age)

class SmallCat(override val name/*这里*/ : String,age : Int) : Cat(name,age)//Error: 'name' in 'Cat' is final and cannot be overridden
```
    这是因为: 派生类只能扩展不能将原本基类所具备的特性给搞没了 因为val原本只有getter方法所以可以扩展一个getter方法如果基类的var属性是既有getter也有setter 不能被扩展类的val来重写的因为违背了扩展类只能扩展这条规则
  2. 可以改变属性的访问权限但是只可以该internal 和 protected修饰的属性不能改private的属性这很好理解 private修饰的属性本来就是私有的不希望被人修改如果还能被重写不就违背了意思吗
还有一点 : 就是如果重写了属性 那么在子类是有另一个幕后字段来储存重写了属性数据的并没有使用父类的而没有重写的则是使用父类的

open class Room {
    open var name = "xixi"
    fun hi() {
        println("hi")
    }

}

class ClassRoom : Room(){
    override var name = "java"
    val isEqual = this.name === super.name
}

fun main() {
    println(ClassRoom().isEqual) //输出 : false
}

Sealed类

Sealed类是final类和open类的一个中间地带就是说可以让一定数量的类来继承而不是全部类的类都可以继承

Sealed类做到了他可以让和他在同一个文件中的类来继承但是其他文件中的类就不行了

注意 : Sealed的类构造器默认是private的所以是不能构造出Sealed的实例的而且Sealed类还具有抽象的属性
枚举类

意思是: 我们只需要有限个实例

用关键字enum来定义枚举类枚举类的实例作为静态的引用来实现的 枚举类也可以有方法和属性但是必须用分号将值列表和定义隔开

enum class Card( val cardName : String) {
    A("a"),
    B("b"),
    C("c"){
        override fun desc() {
            println(this.cardName)
        }
          },
    D("d");
    open fun desc(){
        println(this.name)
    }
}

fun main() {
    for (card in Card.values()){
        card.desc()
        println(card.javaClass)
    }
}

可以看到每个实例其实是枚举类型只是在某些场合会利用匿名内部类
注意一点 enum类默认是有一个name属性的

public abstract class Enum<E extends Enum<E>>
        implements Constable, Comparable<E>, Serializable {
    /**
     * The name of this enum constant, as declared in the enum declaration.
     * Most programmers should use the {@link #toString} method rather than
     * accessing this field.
     */
    private final String name;
}
//所以在我们定义的enum中不能定义name属性