Kotlin properties and fields

Catalog

Declaration of properties

Declare... In the main constructor

Declare in the property initializer

Use of attributes

Behind the scenes fields

Behind the scenes properties

---

Declaration of properties

Declare... In the main constructor

  Use var/val Variable : type Properties can be declared

open class A(var name:String,var node:String){
    override fun toString(): String {
        return "A(name='$name', node='$node')" //name,node The property 
    }
}
fun main(args:Array<String>){
    var a=A("Hellen","1")
    println(a) //A(name='Hellen', node='1')
}

Declare in the property initializer

  The specific format is ：

 var/val Property name [ : Attribute types ] [ = value ]

    [ Access permission symbol set()=/set(){} ] 

    [ Access permission symbol get()=/get(){} ]

  among [ ] The inside is an optional part ,var The variables are get and set Method , and val The variables are only get Method

  When the attribute type can from set and get Infer when , Attribute types can be omitted , but val Only get Method , Must declare type

  Generally, the specified value , You can omit the attribute type

var count=1
open class A{
    var name:String // With default get, The custom set And constructor , Value ellipsis 
        private set(value){
            field=value
            println("set name's value")
        }
    val node:Int
         get() {
             return count++
         }// Only get Default , Value cannot be omitted . Value can be specified , Omit type 
    constructor(name:String){
        this.name=name
    }
    override fun toString(): String {
        return "A(name='$name', node=$node)"
    }
}
fun main(args:Array<String>){
    var a=A("Hellen") //set name's value
    var b=A("Peter") //set name's value
    var c=A("John") //set name's value
    println(a) //A(name='Hellen', node=1)
    println(b) //A(name='Peter', node=2)
    println(c) //A(name='John', node=3)
}

Use of attributes

  General attributes can be Use the attribute name directly visit , Yes When the names conflict, you can use this. Property name ; Outside the class, you can pass through object . Property name visit public attribute   

var count=1
open class A{
    var name:String
        set(value) {
            field=value
            println("name's set")
        }
    val node get() = count++
    var kotlin_score:Int
    val kotlin_level:String get() {
        println("kotlin_level's get")
        return when(kotlin_score/10){
            9,10->{
                "A"
            }
            8->{
                "B"
            }
            6,7->{
                "C"
            }
            else->{
                "D"
            }
        }
    }
    constructor(name:String,kotlin_score:Int){
        this.name=name // Name conflict , use this. Property name access 
        this.kotlin_score=kotlin_score // Name conflict , use this. Property name access 
        //this. Property name = Variable / value , By default, call the set function 
    }

    override fun toString(): String {
        // No name conflicts , Access directly with the attribute name 
        return "A(name='$name', node=$node, kotlin_score=$kotlin_score, kotlin_level='$kotlin_level')"
        //$ Property name , It will call the property name by default get function  print( Property name ) Where the attribute name value is required, the attribute name is called by default get function 
    }

}
fun main(args:Array<String>){
    var a=A("Hellen",85) //name's set
    var b=A("Peter",100) //name's set
    var c=A("John",67) //name's set
    println(a) 
    //kotlin_level's get
    //A(name='Hellen', node=1, kotlin_score=85, kotlin_level='B')
    println(b) 
    //kotlin_level's get
    //A(name='Peter', node=2, kotlin_score=100, kotlin_level='A')
    println(c) 
    //kotlin_level's get 
    //A(name='John', node=3, kotlin_score=67, kotlin_level='C')
    println(c.name+" "+c.kotlin_score)//  Of callable objects outside the class public attribute , object . Property name 
}

Behind the scenes fields

    The field behind the scenes is mainly used to solve attributes set Memory overflow in function call assignment , It is mainly used to make an attribute have different values under different conditions

    Generally according to Java The understanding of the ,set The function will be written as follows

    var name:String
        set(value) {
            this.name=value
        }

  Write it like this IDEA It's yellow , Show unassigned setter

    In this way, errors will also appear after running ： Stack overflow StackOverflowError

    take Kotlin Class to Java as follows , It can be seen that setName Cycle call

public class A {
   @NotNull
   private String name;

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

   public final void setName(@NotNull String value) {
      Intrinsics.checkNotNullParameter(value, "value");
      this.setName(value);// Cycle call 
   }

   @NotNull
   public String toString() {
      return "A(name='" + this.name + "')";
   }

   public A(@NotNull String name) {
      Intrinsics.checkNotNullParameter(name, "name");
      super();
      this.setName(name);
   }
}

    So for Solve this problem , This leads to the field behind the scenes ： stay Kotlin in , If the property has at least one accessor, use the default implementation , that Kotlin Will automatically provide the field behind the scenes . Behind the scenes fields use keywords field Express , Refers to the current attribute , It can only be used for get and set Function , Therefore ,set The function is written as follows ：

    var name:String
        set(value) {
            field=value //field Refers to the attribute name
        }

Be careful ： Not all Kotlin Attributes have fields behind them ： To meet the One of the following two situations ：set and get One of them adopts the default implementation ; Self defined set and get Use in field

Behind the scenes properties

  Behind the scenes properties meet ： Only readable outside the class , But it is both readable and writable within the class

  Implementing the behind the scenes attribute requires the declaration of two variables ：

（ Official requirements , But it should be possible to pass Statement var Attribute but custom public get,private set  Realize the characteristics of behind the scenes properties , Just decompile Java The code is different ）

private var a: Int=0
public val m_a: Int
     get() = a
//a That is, the behind the scenes property 
// The compiled to ：
//public class A {
//   private int a;
//
//   public final int getM_a() {
//      return this.a;
//   }
//}

var a:Int=0
    private set(value){
         field=value
    }//get Default public
// The compiled to 
//public class A {
//   private int a;
//
//   public final int getA() {
//      return this.a;
//   }
//
//   private final void setA(int value) {
//      this.a = value;
//   }
//}
//  More official , Decompile more set function