当前位置: 首页>移动开发>正文

android kotlin创建一个指定宽高和背景色的空白bitmap kotlin by

概述

Kotlin 中的 by 关键字在 Java 中是没有的,这使我对它感到非常陌生。

Kotlin 中为什么要新增 by 关键字呢?by 关键字在 Kotlin 中是如何使用的?

本文会介绍 by 关键字的使用分类,具体的示例,Kotlin 内置的 by 使用,希望能够帮助到大家。

by 关键字的使用分为两种:类委托委托属性

类委托

现在有一个需求,统计向一个 HashSet 尝试添加元素的尝试次数,该怎么实现?

使用继承方式实现

简单,继承一个 HashSet,创建一个变量,负责统计尝试添加元素的个数,代码如下:

class CountingSet1<T>: HashSet<T>() {

    var objectAdded = 0

    override fun add(element: T): Boolean {
        objectAdded++
        return super.add(element)
    }

    override fun addAll(elements: Collection<T>): Boolean {
        // 因为 super.addAll 内部调用了 add 方法,所以这里不必统计添加个数了。
        return super.addAll(elements)
    }
}

fun main() {
    val cset = CountingSet1<Int>()
    cset.add(1)
    cset.addAll(listOf(2, 2, 3))
    println("${cset.objectAdded} objects were added, ${cset.size} remain")
}
/*
打印如下:
4 objects were added, 3 remain
*/

需求是满足了。

但是这样的实现,CountingSet1 和 HashSet 的具体实现是高度耦合的,也就是说,CountingSet1 严重依赖于 HashSet 类的实现细节。

这有什么问题吗?

当基类的实现被修改或者新的方法被添加进去时,可能改变之前进行继承时的类行为,从而导致子类的行为不符合预期。

当某个类是 final 类时,它是不可以被继承的,这时就不能采用继承的方式来复用它的代码了。

那我们该怎么办呢?

想一下,我们新建的类无非是想复用 HashSet的功能,前面我们是采用继承的方式,除了采用继承的方式之外,我们还可以采用组合的方式。

实际上,在 《Java编程思想》中有写道:

由于继承在面向对象程序设计中如此重要,所以它经常被高度强调,于是程序员新手就会有这样的印象:处处都应该使用继承。这会导致难以使用并过分复杂的设计。实际上,在建立新类时,应该优先考虑组合,因为它更加简单灵活。如果采用这种方式,设计会变得更加清晰。

使用组合方式实现

使用组合方式实现如下:

class CountingSet2<T> : MutableSet<T> {
    private val innerSet = HashSet<T>()
    var objectAdded = 0
    override fun add(element: T): Boolean {
        objectAdded++
        return innerSet.add(element)
    }

    override fun addAll(elements: Collection<T>): Boolean {
        objectAdded += elements.size
        return innerSet.addAll(elements)
    }

    override fun clear() {
        innerSet.clear()
    }

    override fun iterator(): MutableIterator<T> {
        return innerSet.iterator()
    }

    override fun remove(element: T): Boolean {
        return innerSet.remove(element)
    }

    override fun removeAll(elements: Collection<T>): Boolean {
        return innerSet.removeAll(elements)
    }

    override fun retainAll(elements: Collection<T>): Boolean {
        return innerSet.retainAll(elements)
    }

    override val size: Int
        get() = innerSet.size

    override fun contains(element: T): Boolean {
        return innerSet.contains(element)
    }

    override fun containsAll(elements: Collection<T>): Boolean {
        return innerSet.containsAll(elements)
    }

    override fun isEmpty(): Boolean {
        return innerSet.isEmpty()
    }
}

fun main() {
    val cset = CountingSet2<Int>()
    cset.add(1)
    cset.addAll(listOf(2, 2, 3))
    println("${cset.objectAdded} objects were added, ${cset.size} remain")
}
/*
打印如下:
4 objects were added, 3 remain
*/

同样实现了需求。

可以看到,CountingSet2 实现了 MutableSet 接口,具体的实现是委托给了 innerSet 来完成的。

这有什么好处呢?

CountingSet2 与 HashSet 不再耦合了,它们都实现了 MutableSet 接口。

这种方式从代码设计上看确实好,但是却需要非常多的模板代码,这点很烦人啊。

使用类委托实现

现在就该 Kotlin 的类委托出场了,它可以解决需要写非常多的模板代码的问题。

class CountingSet3<T>(
    val innerSet: MutableSet<T> = HashSet<T>()
) : MutableSet<T> by innerSet {
    var objectAdded = 0
    override fun add(element: T): Boolean {
        objectAdded++
        return innerSet.add(element)
    }

    override fun addAll(elements: Collection<T>): Boolean {
        objectAdded += elements.size
        return innerSet.addAll(elements)
    }
}

fun main() {
    val cset = CountingSet3<Int>()
    cset.add(1)
    cset.addAll(listOf(2, 2, 3))
    println("${cset.objectAdded} objects were added, ${cset.size} remain")
}
/*
打印如下:
4 objects were added, 3 remain
*/

完美实现了需求。

Kotlin 是如何帮我们减少了模板代码了呢?

使用 Android Studio 的 Tools -> Kotlin -> Show Kotlin Bytecode,再点击 Decompile 按钮,查看对应的 Java 代码:

public final class CountingSet3 implements Set, KMutableSet {
   private int objectAdded;
   @NotNull
   private final Set innerSet;

   public final int getObjectAdded() {
      return this.objectAdded;
   }

   public final void setObjectAdded(int var1) {
      this.objectAdded = var1;
   }

   public boolean add(Object element) {
      int var10001 = this.objectAdded++;
      return this.innerSet.add(element);
   }

   public boolean addAll(@NotNull Collection elements) {
      Intrinsics.checkNotNullParameter(elements, "elements");
      this.objectAdded += elements.size();
      return this.innerSet.addAll(elements);
   }

   @NotNull
   public final Set getInnerSet() {
      return this.innerSet;
   }

   public CountingSet3(@NotNull Set innerSet) {
      Intrinsics.checkNotNullParameter(innerSet, "innerSet");
      super();
      this.innerSet = innerSet;
   }

   // $FF: synthetic method
   public CountingSet3(Set var1, int var2, DefaultConstructorMarker var3) {
      if ((var2 & 1) != 0) {
         var1 = (Set)(new HashSet());
      }

      this(var1);
   }

   public CountingSet3() {
      this((Set)null, 1, (DefaultConstructorMarker)null);
   }

   public int getSize() {
      return this.innerSet.size();
   }

   // $FF: bridge method
   public final int size() {
      return this.getSize();
   }

   public void clear() {
      this.innerSet.clear();
   }

   public boolean contains(Object element) {
      return this.innerSet.contains(element);
   }

   public boolean containsAll(@NotNull Collection elements) {
      Intrinsics.checkNotNullParameter(elements, "elements");
      return this.innerSet.containsAll(elements);
   }

   public boolean isEmpty() {
      return this.innerSet.isEmpty();
   }

   @NotNull
   public Iterator iterator() {
      return this.innerSet.iterator();
   }

   public boolean remove(Object element) {
      return this.innerSet.remove(element);
   }

   public boolean removeAll(@NotNull Collection elements) {
      Intrinsics.checkNotNullParameter(elements, "elements");
      return this.innerSet.removeAll(elements);
   }

   public boolean retainAll(@NotNull Collection elements) {
      Intrinsics.checkNotNullParameter(elements, "elements");
      return this.innerSet.retainAll(elements);
   }

   public Object[] toArray() {
      return CollectionToArray.toArray(this);
   }

   public Object[] toArray(Object[] var1) {
      return CollectionToArray.toArray(this, var1);
   }
}

这不就是 CountingSet2 的代码吗?

原来 Kotlin 的编译器默默地帮我们生成了这些模板代码,而仅仅要求我们通过声明并初始化一个 HashSet 类型的成员变量,并在类声明后添加 by innerSet:

class CountingSet3<T>(
    val innerSet: MutableSet<T> = HashSet<T>()
) : MutableSet<T> by innerSet {

需要注意的是:

  • CountingSet3 必须实现一个接口,而不能继承于一个类;
  • innerSet 的类型必须是 CountingSet3 所实现接口的子类型;
  • 可以直接在 by 创建委托对象,如下所示:
class CountingSet4<T>(
) : MutableSet<T> by HashSet<T>() {
}

但是,这样的话,在 CountingSet4 类中无法获取到委托对象的引用了。

Kotlin 的类委托虽然看起来很简洁,但是它自身又有一些限制:类必须实现一个接口,委托类必须是类所实现接口的子类型。这是需要注意的。

同时,我们在实际开发中,要尽力去使用这种委托的思想,来使代码解耦,使代码更加清晰。这一点,比掌握 Kotlin 的类委托更加重要。

委托属性

委托属性是一个依赖于约定的功能,也是Kotlin 中最独特和最强大的功能之一。

本部分我们仍然是从一个小例子开始,展示一下委托属性的使用,作用;然后,会说明委托属性的一些特点以及其他使用。

需求:现在有一个简单的 Person 类:

class Person2 {
    var name: String = ""
    var lastname: String = ""  
}

需要对 name 和 lastname 赋值时,做一些格式化工作:首字母大写其余字母小写,并统计格式化操作的次数,再获取 name 和 lastname 值的时候,把它们的值的长度拼接在值得后面返回。

仅仅完成需求的代码

这不难,代码实现如下:

class Person2 {
    var name: String = ""
        set(value) {
            field = value.lowercase().replaceFirstChar { it.uppercase() }
            updateCount++
        }
        get() {
            return field + "-" + field.length
        }

    var lastname: String = ""
        set(value) {
            field = value.lowercase().replaceFirstChar { it.uppercase() }
            updateCount++
        }
        get() {
            return field + "-" + field.length
        }
    var updateCount = 0
}

fun main() {
    val person2 = Person2()
    person2.name = "peter"
    person2.lastname = "wang"
    println("name=${person2.name}")
    println("lastname=${person2.lastname}")
    println("updateCount=${person2.updateCount}")
}
/*
打印日志:
name=Peter-5
lastname=Wang-4
updateCount=2
*/

ps:这里面使用 Kotlin 中的支持字段 field ,需要学习可以查看笔者的这篇文章:Kotlin 的 Backing Fields 和 Backing Properties(/article/details/100184784)。

OK,查看日志,可以看到需求实现了。

抽取重复代码为方法

但是,这里面有着重复的代码,并且如果其他类也需要这样的格式化操作,这些代码也不可以复用。

为了提供代码复用性,我们可以把代码抽取出来,放在一个方法里面。代码实现如下:

class Person3 {
    var name: String = ""
        set(value) {
            field = format(value)
        }
        get() {
            return getter(field)
        }

    var lastname: String = ""
        set(value) {
            field = format(value)
        }
        get() {
            return getter(field)
        }
    var updateCount = 0

    fun format(value: String): String {
        updateCount++
        return value.lowercase().replaceFirstChar { it.uppercase() }
    }
    fun getter(value: String): String {
        return value + "-" + value.length
    }
}

fun main() {
    val person = Person3()
    person.name = "peter"
    person.lastname = "wang"
    println("name=${person.name}")
    println("lastname=${person.lastname}")
    println("updateCount=${person.updateCount}")
}
/*
name=Peter-5
lastname=Wang-4
updateCount=2
*/

查看日志打印,这样做可以实现需求。

使用类来封装重复代码

现在需求又来了,有一个 Student 类:

class Student {
    var name: String = ""

    var address: String = ""
}

也需要对属性做同样的格式化操作并统计进行格式化操作的次数,在获取值的时候把长度拼接在后面。

这时,我们可以使用面向对象的思想来解决,把 format 方法和 getter 方法封装在一个类里面:

class Delegate {
    fun format(thisRef: Any, value: String): String {
        if (thisRef is Person4) {
            thisRef.updateCount++
        } else if (thisRef is Student2) {
            thisRef.updateCount++
        }
        return value.lowercase().replaceFirstChar { it.uppercase() }
    }

    fun getter(value: String): String {
        return value + "-" + value.length
    }
}

Person 类修改如下:

class Person4 {

    private val delegate = Delegate()

    var name: String = ""
        set(value) {
            field = delegate.format(this, value)
        }
        get() {
            return delegate.getter(field)
        }

    var lastname: String = ""
        set(value) {
            field = delegate.format(this, value)
        }
        get() {
            return delegate.getter(field)
        }

    var updateCount = 0
}

Student 类修改如下:

class Student2 {
    private val delegate = Delegate()

    var name: String = ""
        set(value) {
            field = delegate.format(this, value)
        }
        get() {
            return delegate.getter(field)
        }
    var address: String = ""
        set(value) {
            field = delegate.format(this, value)
        }
        get() {
            return delegate.getter(field)
        }
    var updateCount = 0
}

把值的存储委托给委托类处理

既然 getter 和 setter 方法都委托给 Delegate 类来实现,我们何不把值也交给 Delegate 类来存储呢?

如果把 name 和 lastname 的值存在 Delegate 里面的话,它们就不可以共用一个 Delegate 对象了。

然后,Delegate 类两个方法的作用就是设置和获取值,所以方法也需要改一下。对吧?

修改 Delegate 类为:

class Delegate2 {
    var formattedString: String = ""
    fun setValue(thisRef: Any, value: String) {
        if (thisRef is Person5) {
            thisRef.updateCount++
        } else if (thisRef is Student2) {
            thisRef.updateCount++
        }
        formattedString = value.lowercase().replaceFirstChar { it.uppercase() }
    }

    fun getValue(): String {
        return formattedString + "-" + formattedString.length
    }
}

修改 Person 类为:

class Person5 {

    private val nameDelegate = Delegate2()
    private val lastnameDelegate = Delegate2()
    var name: String
        set(value) {
            nameDelegate.setValue(this, value)
        }
        get() {
            return nameDelegate.getValue()
        }

    var lastname: String
        set(value) {
            lastnameDelegate.setValue(this, value)
        }
        get() {
            return lastnameDelegate.getValue()
        }
    var updateCount = 0
}
/*
打印日志:
name=Peter-5
lastname=Wang-4
updateCount=2
*/

到这里,需要强调的是,Person5 里的 name 和 lastname 不具有存储值的功能了,它们是自定义了 setter 和 getter 的属性。

使用 Kotlin 的委托属性来简化代码

对于上面的代码实现,我们仍然感到有些累赘,不简洁。

Kotlin 的委托属性可以帮我们解决这些烦恼。

委托属性的基本语法是这样的:

class Foo {
    var p: Type by Delegate()
}

等价于

class Foo {
    private val delegate = Delegate()
    var p: Type
        set(value: Type) = delegate.setValue(this, ..., value)
        get() = delegate.getValue(this, ...)
}

属性 p 将它的访问器逻辑委托给 Delegate 这个辅助对象来处理。

by 关键字的作用是对它后面的表达式求值来获取这个对象,在这里就是获取到了 Delegate 对象。

编译器会创建一个隐藏的辅助属性,并使用委托对象的实例对它进行初始化,在这里就是把 Delegate 对象赋值给了 delegate 属性。

那么,Kotlin 是如何知道把属性 p 的 setter 逻辑委托给辅助对象 delegate 的哪个方法,把属性 p 的 getter 逻辑委托给辅助对象 delegate 的哪个方法呢?

这里就要说到约定的概念了,委托类必须具有 getValue 和 setValue 方法(如果是可变属性的话),定义在 ReadWriteProperty 接口里:

public fun interface ReadOnlyProperty<in T, out V> {
    public operator fun getValue(thisRef: T, property: KProperty<*>): V
}
public interface ReadWriteProperty<in T, V> : ReadOnlyProperty<T, V> {
    public override operator fun getValue(thisRef: T, property: KProperty<*>): V
    public operator fun setValue(thisRef: T, property: KProperty<*>, value: V)
}

当对 Foo 对象的 p 属性赋值时,会调用 Delegate 对象的 setValue 方法,设置对应的值;

当获取 Foo 对象的 p 的值时,会调用 Delegate 对象的 getValue 方法,获取对应的值。

修改委托类为:

class Delegate3 : ReadWriteProperty<Any, String> {
    var formattedString = ""
    override fun getValue(thisRef: Any, property: KProperty<*>): String {
        return formattedString + "-" + formattedString.length
    }

    override fun setValue(thisRef: Any, property: KProperty<*>, value: String) {
        if (thisRef is Person6) {
            thisRef.updateCount++
        }
        formattedString = value.lowercase().replaceFirstChar { it.uppercase() }
    }
}

修改 Person 类为:

class Person6 {
    var name: String by Delegate3()
    var lastname: String by Delegate3()
    var updateCount = 0
}

fun main() {
    val person = Person6()
    person.name = "peter"
    person.lastname = "wang"
    println("name=${person.name}")
    println("lastname=${person.lastname}")
    println("updateCount=${person.updateCount}")
}
/*
打印如下:
name=Peter-5
lastname=Wang-4
updateCount=2
*/

OK,完美符合需求。

使用 Android Studio 的 Tools -> Kotlin -> Show Kotlin Bytecode,再点击 Decompile 按钮,查看 Delegate3 和 Person6 对应的 Java 代码:

public final class Delegate3 implements ReadWriteProperty {
   @NotNull
   private String formattedString = "";

   @NotNull
   public final String getFormattedString() {
      return this.formattedString;
   }

   public final void setFormattedString(@NotNull String var1) {
      this.formattedString = var1;
   }

   @NotNull
   public String getValue(@NotNull Object thisRef, @NotNull KProperty property) {
      return this.formattedString + "-" + this.formattedString.length();
   }

   // $FF: synthetic method
   // $FF: bridge method
   public Object getValue(Object var1, KProperty var2) {
      return this.getValue(var1, var2);
   }

   public void setValue(@NotNull Object thisRef, @NotNull KProperty property, @NotNull String value) {
      if (thisRef instanceof Person6) {
         ((Person6)thisRef).setUpdateCount(((Person6)thisRef).getUpdateCount() + 1);
      }

      Delegate3 var10000 = this;
      boolean var5 = false;
      String var10001 = value.toLowerCase(Locale.ROOT);
      Intrinsics.checkNotNullExpressionValue(var10001, "(this as java.lang.Strin….toLowerCase(Locale.ROOT)");
      String var4 = var10001;
      var5 = false;
      CharSequence var6 = (CharSequence)var4;
      boolean var7 = false;
      if (var6.length() > 0) {
         StringBuilder var20 = new StringBuilder();
         char it = var4.charAt(0);
         StringBuilder var15 = var20;
         int var9 = false;
         boolean var11 = false;
         String var12 = String.valueOf(it);
         boolean var13 = false;
         if (var12 == null) {
            throw new NullPointerException("null cannot be cast to non-null type java.lang.String");
         }

         String var19 = var12.toUpperCase(Locale.ROOT);
         Intrinsics.checkNotNullExpressionValue(var19, "(this as java.lang.Strin….toUpperCase(Locale.ROOT)");
         String var16 = var19;
         var10000 = this;
         var20 = var15.append(var16.toString());
         byte var17 = 1;
         boolean var18 = false;
         if (var4 == null) {
            throw new NullPointerException("null cannot be cast to non-null type java.lang.String");
         }

         String var10002 = var4.substring(var17);
         Intrinsics.checkNotNullExpressionValue(var10002, "(this as java.lang.String).substring(startIndex)");
         var10001 = var20.append(var10002).toString();
      } else {
         var10001 = var4;
      }

      var10000.formattedString = var10001;
   }

   // $FF: synthetic method
   // $FF: bridge method
   public void setValue(Object var1, KProperty var2, Object var3) {
      this.setValue(var1, var2, (String)var3);
   }
}
public final class Person6 {
   // $FF: synthetic field
   static final KProperty[] $$delegatedProperties = new KProperty[]{
   (KProperty)Reflection.mutableProperty1(new MutablePropertyReference1Impl(Person6.class, "name", "getName()Ljava/lang/String;", 0)), 
   (KProperty)Reflection.mutableProperty1(new MutablePropertyReference1Impl(Person6.class, "lastname", "getLastname()Ljava/lang/String;", 0))};
   @NotNull
   private final Delegate3 name$delegate = new Delegate3();
   @NotNull
   private final Delegate3 lastname$delegate = new Delegate3();
   private int updateCount;

   @NotNull
   public final String getName() {
      return this.name$delegate.getValue(this, $$delegatedProperties[0]);
   }

   public final void setName(@NotNull String var1) {
      this.name$delegate.setValue(this, $$delegatedProperties[0], var1);
   }

   @NotNull
   public final String getLastname() {
      return this.lastname$delegate.getValue(this, $$delegatedProperties[1]);
   }

   public final void setLastname(@NotNull String var1) {
      this.lastname$delegate.setValue(this, $$delegatedProperties[1], var1);
   }

   public final int getUpdateCount() {
      return this.updateCount;
   }

   public final void setUpdateCount(int var1) {
      this.updateCount = var1;
   }
}

可以看到,这和我们在上一节中写的大致是一样的。

thisRef 就是发起委托的对象。

值得注意的是,在 Person6.java 中创建了一个 $$delegatedProperties 对象,它是一个 KProperty 类型的数组,它的元素封装了类,属性名,getter 方法签名等信息,也会传递给委托类,这是用来做什么的?

本例子中我们确实用不到这些信息。KProperty 主要是用来封装属性的元信息,提供给委托类使用,比如在委托类的 setValue 方法中通知属性发生变化时,就会用到 KProperty 里的属性名信息了。

对委托属性约定的再认识

虽然 Kotlin 提供了 ReadWriteProperty 和 ReadOnlyProperty 封装了约定的方法给我们使用,但是当我们定义委托类时并不是一定要实现 Kotlin 提供的接口。

实际上,只要保持委托类里的 setValue 和 getValue 方法与约定的 setValue 方法和 getValue 方法一致就可以了。

修改委托类为:

class Delegate4  {
    var formattedString = ""
    // 注意这里的 operator 不可以省略
    operator fun getValue(thisRef: Any, property: KProperty<*>): String {
        return formattedString + "-" + formattedString.length
    }
    // 注意这里的 operator 不可以省略
    operator fun setValue(thisRef: Any, property: KProperty<*>, value: String) {
        if (thisRef is Person7) {
            thisRef.updateCount++
        }
        formattedString = value.lowercase().replaceFirstChar { it.uppercase() }
    }
}

修改 Person 类为:

class Person7 {
    var name: String by Delegate4()
    var lastname: String by Delegate4()
    var updateCount = 0
}


fun main() {
    val person = Person7()
    person.name = "peter"
    person.lastname = "wang"
    println("name=${person.name}")
    println("lastname=${person.lastname}")
    println("updateCount=${person.updateCount}")
}

约定方法可以使用扩展函数来实现:

比如,Delegate 类不符合委托属性的约定方法,代码如下:

class Delegate5  {
    var formattedString = ""
    fun get(): String {
        return formattedString + "-" + formattedString.length
    }

    fun set(thisRef: Any, value: String) {
        if (thisRef is Person8) {
            thisRef.updateCount++
        }
        formattedString = value.lowercase().replaceFirstChar { it.uppercase() }
    }
}

这时可以使用扩展函数来实现约定方法,新建 Delegate5Extension.kt:

operator fun Delegate5.setValue(thisRef: Any, property: KProperty<*>, value: String) =
    set(thisRef, value)

operator fun Delegate5.getValue(thisRef: Any, property: KProperty<*>) = get()

修改 Person 类为:

class Person8 {
    var name: String by Delegate5()
    var lastname: String by Delegate5()
    var updateCount = 0
}


fun main() {
    val person = Person8()
    person.name = "peter"
    person.lastname = "wang"
    println("name=${person.name}")
    println("lastname=${person.lastname}")
    println("updateCount=${person.updateCount}")
}
/*
打印日志:
name=Peter-5
lastname=Wang-4
updateCount=2
*/

Kotlin内置委托

lazy() 函数

lazy() 函数用于实现属性的惰性初始化,即只有在第一次访问属性时,才对它进行初始化。

class Person(name: String) {
    val emails: List<String> by lazy { loadEmailsByName(name) }

    private fun loadEmailsByName(name: String): List<String> {
        println("loadEmailsByName called")
        return listOf("Email1", "Email2", "Email3")
    }
}

fun main() {
    val p = Person("Peter")
    println(p.emails)
    println(p.emails)
}
/*
打印日志:
loadEmailsByName called
[Email1, Email2, Email3]
[Email1, Email2, Email3]
*/

可以看到,两次访问 emails 属性,只有第一次调用了 loadEmailsByName 方法。

如果把访问 emails 属性的代码注释掉,会看到没有任何打印,说明 emails 属性确实是惰性初始化的。

为什么 lazy() 函数可以放在 by 后面用于获取委托对象呢?

这是因为 Lazy.kt 中定义了符合约定的扩展函数:

public inline operator fun <T> Lazy<T>.getValue(thisRef: Any?, property: KProperty<*>): T = value

Delegates.notNull()

Delegates.notNull() 用于实现属性的延迟初始化,和 lateinit 类似。

它们的区别是:

  • notNull 会给每个属性额外创建一个对象,而 lateinit 不会;
  • notNull 可以用于基本数据类型的延迟初始化,而 lateinit 不可以。
class Person4 {
    val fullname: String by Delegates.notNull<String>()
    lateinit var fullname2: String
    // lateinit var age: Int

    companion object {
        lateinit var list: MutableList<String>
        val l : List<String> by Delegates.notNull<List<String>>()
    }
}

最后

本文比较详细地介绍了 Kotlin 为什么要出现 by 关键字,以及它的两种用法。通过小的例子一步一步引出 by 关键字的使用。

需要说明的是,本文对于 by 关键字的委托属性的用法的实际应用并没有一一说明,这部分需要查看 Delegated properties-Kotlin官方文档(https://kotlinlang.org/docs/delegated-properties.html)。

另外,本文没有把委托属性在属性值变化监听的应用例子写在文章里,主要考虑到大家对 PropertyChangeSupport 这个接口比较陌生,不太适合做基本实例说明。不过,这个例子在本文提供的代码中是包含的。需要说明的是,Kotlin 的内置的 Delegates.observable 和 Delegates.vetoable 就是对属性值变化监听或者否决的代码封装。

代码在这里(https://github.com/jhwsx/BlogCodes/tree/master/KotlinByStudy)。

文章的参考部分是不可多得的学习资料。大家也可以看看。

资源复用小技巧

svg矢量图

android5.0之后android就开始支持svg矢量图了,是drawable的vector标签。

使用矢量图的好处是不用在为不同的分辨率提供不同的切图了,而且能保证显示清晰度。

在android studio中,右击drawable目录,选择new - Vector Asset,可以创建一个系统自带svg矢量图,或者通过svg、psd文件导入。

下面是一个示例额:

<vector android:height="24dp" android:tint="#FFFFFF"
    android:viewportHeight="24" android:viewportWidth="24"
    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
    <path android:fillColor="@android:color/white" android:pathData="M20.5,3l-0.16,0.03L15,5.1 9,3 3.36,4.9c-0.21,0.07 -0.36,0.25 -0.36,0.48V20.5c0,0.28 0.22,0.5 0.5,0.5l0.16,-0.03L9,18.9l6,2.1 5.64,-1.9c0.21,-0.07 0.36,-0.25 0.36,-0.48V3.5c0,-0.28 -0.22,-0.5 -0.5,-0.5zM15,19l-6,-2.11V5l6,2.11V19z"/>
</vector>

包括图片的宽高和颜色,最重要的就是path,这里面就是svg图片绘制的路径,如果懂相关语法的甚至可以自己手写一个出来。

变色

变色就是着色,在android5.0版本google出了着色器tint,可以非常方便的对图片进行着色。

(android5.0还对应的加入了取色器Palette,可以动态的在bitmap上取色并设置给其他组件,达到页面随着图片变色的效果)

比如

<ImageView
    ...
    android:src="@mipmap/ic_launcher"
    android:tint="#FFF" />

这样可以将图片变成白色的。

但是有时候我们需要在其他xml resource中使用,比如style中使用drawable,比如想使用一个黑色的箭头,但是我们只有白色的箭头,这时候就没有tint这个属性了,那么怎么办?

我们可以使用bitmap标签,在drawable下新建一个资源xml,如下:

<?xml version="1.0" encoding="utf-8"?>


<bitmap xmlns:android="http://schemas.android.com/apk/res/android"


     android:src="@drawable/white_arrow"


     android:tint="#000000">


</bitmap>\

然后使用这个drawable即可,但是注意这里无法使用svg矢量图,即VectorDrawable。

旋转

比如有一个左箭头,我们还需要右箭头。

一个方法是在view中设置android:rotation属性

<ImageView
    ...
    android:src="@mipmap/ic_launcher"
    android:rotation="90" />

同样我们需要在其他xml resource中使用,可以使用rotate标签,在drawable下新建一个资源xml,如下:

<rotate xmlns:android="http://schemas.android.com/apk/res/android"
    android:fromDegrees="90"
    android:toDegrees="90"
    android:drawable="@drawable/fit">
</rotate>

这里可以使用svg矢量图

阴影

有时候我们有一张图片,但在不同场景使用的时候可能需要阴影,也可能不需要,甚至阴影的大小可能也不一样。

在android5.0以上我们可以直接为view设置elevation即可,如:

<ImageView
    ...
    android:elevation="3dp"
    android:src="@drawable/fit"/>

这是google新增的层的概念,即z轴,设置elevation可以提升组件的高度,就会自动添加阴影。

组合

有时候我们有的资源是几个其他资源组合而成的,其实这时候我们没必要再重新切一个组合后的图。

使用layer-list即可,通过设置位置,并且通过上面所说的旋转等方法可以实现各种组合情况。

比如示例中:

<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
    <item
        android:width="12dp"
        android:height="12dp">
        <shape android:shape="oval">
            <solid android:color="#009bfa" />
        </shape>
    </item>
    <item
        android:width="6dp"
        android:height="6dp"
        android:gravity="center">
        <shape android:shape="oval">
            <solid android:color="#ffffff" />
        </shape>
    </item>
</layer-list>

我们通过两个shape来实现一个类似靶子的效果。

透明度

也是使用bitmap标签即可,通过android:alpha熟悉设置透明度。

裁剪

通过drawable的clip标签即可,注意这里裁剪后还保持原图片大小,只不过裁剪后的内容占据其中一部分

留白

通过drawable的inset标签,可以对资源的各个方向添加留白,达到类似padding的效果。示例如下:

<inset xmlns:android="http://schemas.android.com/apk/res/android"
    android:drawable="@drawable/voice_icon_32x30"
    android:inset="4dp">
</inset>

https://www.xamrdz.com/mobile/45y1964542.html

相关文章: