fun String.divide(num: Int = 4, ch: Char = '_'): String {
    return if(num > 0) {    // 分割可能->chの挿入
        StringBuilder(this).apply {
            for(_offset in (this.length - num) downTo 1 step num)
                insert(_offset, ch)  // _offset:左端からの距離
        }.toString()
    }
    else                    // 分割不可->処理しない
        this
}

        val _value1 = 0xD2
        Log.i(TAG, "0x${_value1.toString(16)}は10進の${_value1}")
        Log.i(TAG, "0x${_value1.toString(16)}は 2進の${_value1.toString(2).divide()}")

val String.isPNG: Boolean
    get() {
        return this.contains(Regex(".*\\.png$"))
    }
val String.isJpeg
    get() = this.contains(Regex(".*\\.jpg$"))
val String.isGif: Boolean
    get() = this.contains(Regex(".*\\.gif$"))

        val _filename = "sample.jpg"
        // val _filename = "sample.png"
        // val _filename = "sample.gif"
        when {
            _filename.isJpeg -> Log.i(TAG, "File:${_filename} is Jpeg.")
            _filename.isPNG  -> Log.i(TAG, "File:${_filename} is PNG.")
            _filename.isGif  -> Log.i(TAG, "File:${_filename} is Gif.")
            else -> Log.i(TAG, "File:${_filename} is UnKnown.")
        }

var StringBuilder.firstLetter: Char
    get() {             // getter関数
        return get(0)
    }
    set(value) {        // setter関数
        set(0, value)
    }

        val _builder = StringBuilder("this is a pen.")
        Log.i(TAG, "Before Sentence = \"${_builder}\"")
        _builder.firstLetter = _builder.firstLetter.uppercaseChar()
        // _builder.set(0, _builder.first().uppercaseChar())  // 拡張プロパティなしで書くと...
        Log.i(TAG, "After  Sentence = \"${_builder}\"")

package com.example.xxx.module_a

// トップレベル
fun String.extFunc_top_none(){ Log.i(TAG, "top-none") }
public fun String.extFunc_top_public(){ Log.i(TAG, "top-public") }
private fun String.extFunc_top_private(){ Log.i(TAG, "top-private") }
internal fun String.extFunc_top_internal(){ Log.i(TAG, "top-internal") }

class Sample() {

    // クラス
    fun String.extFunc_class_none(){ Log.i(TAG, "class-none") }
    public fun String.extFunc_class_public(){ Log.i(TAG, "class-public") }
    private fun String.extFunc_class_private(){ Log.i(TAG, "class-private") }
    internal fun String.extFunc_class_internal(){ Log.i(TAG, "class-internal") }
    protected fun String.extFunc_class_protected(){ Log.i(TAG, "class-protected") }

    fun localFunc() {
	    // 関数
        fun String.extFunc_func_none(){ Log.i(TAG, "function-none") }
        ...
    }

    ...
}

ackage com.example.xxx.module_a

open class SuperSample() {

    // 拡張関数の定義
    fun String.extFunc_none(){ Log.i(TAG, "class-none") }
    public fun String.extFunc_public(){ Log.i(TAG, "class-public") }
    private fun String.extFunc_private(){ Log.i(TAG, "class-private") }
    internal fun String.extFunc_internal(){ Log.i(TAG, "class-internal") }
    protected fun String.extFunc_protected(){ Log.i(TAG, "class-protected") }
	
	// メンバー関数の実装
    open fun sampleFunc() { ... }
}

package com.example.xxx.module_a

private val STR = "Hello World !!"

class SubSample : SuperSample() {

    private fun test() {
        STR.extFunc_none()			// 継承有
        STR.extFunc_public()		// 継承有
        // STR.extFunc_private() 	// 継承無⇒スーパークラス内でのみ有効
        STR.extFunc_internal()		// 継承有
        STR.extFunc_protected()		// 継承有
    }

    override fun sampleFunc() { ... }
}

open class SuperClass(open val str: String) {
    fun String.extFuncA(){ Log.i(TAG, "${str} (Super-FuncA)") }
    fun String.extFuncB(){ Log.i(TAG, "${str} (Super-FuncB)") }
    open fun String.extFuncC(){ Log.i(TAG, "${str} (Super-FuncC)") }
    open fun String.extFuncD(){ Log.i(TAG, "${str} (Super-fundD)") }

    open fun test() {
        str.extFuncA()
        str.extFuncB()
        str.extFuncC()
        str.extFuncD()
        normal()
    }

    open fun normal() { Log.i(TAG, "${str} (Super-Normal)") }
}

class SubClass(override val str: String) : SuperClass(str) {
    override fun String.extFuncC(){ Log.i(TAG, "${str} (Sub-FuncC)") }
    override fun String.extFuncD(){ Log.i(TAG, "${str} (Sub-fundD)") }

    override fun test() {
        str.extFuncA()          // サブクラスの関数
        str.extFuncB()
        str.extFuncC()
        str.extFuncD()
        normal()

        super.str.extFuncA()    // スーパークラスの関数
        super.str.extFuncB()
        super.str.extFuncC()
        super.str.extFuncD()
        super.normal()
    }

    override fun normal() { Log.i(TAG, "${str} (Sub-Normal)") }
}

        SuperClass("Hello World !!").test()
        SubClass("世界の皆さん、こんにちは !!").test()

open class SuperClass(open val str: String) {}
class SubClass(override val str: String) : SuperClass(str) {}

fun SuperClass.extFunc1() { Log.i(TAG, "${str} (Super-Func1)") }
fun SuperClass.extFunc2() { Log.i(TAG, "${str} (Super-Func2)") }
fun SuperClass.extFunc3() { Log.i(TAG, "${str} (Super-Func3)") }
fun SuperClass.extFunc4() { Log.i(TAG, "${str} (Super-Func4)") }

fun SubClass.extFunc3() { Log.i(TAG, "${str} (Sub-Func3)") }
fun SubClass.extFunc4() { Log.i(TAG, "${str} (Sub-Func4)") }

        SuperClass("Hello World !!").extFunc1()
        SuperClass("Hello World !!").extFunc2()
        SuperClass("Hello World !!").extFunc3()
        SuperClass("Hello World !!").extFunc4()
        SubClass("世界の皆さん、こんにちは !!").extFunc1()
        SubClass("世界の皆さん、こんにちは !!").extFunc2()
        SubClass("世界の皆さん、こんにちは !!").extFunc3()
        SubClass("世界の皆さん、こんにちは !!").extFunc4()

class Sample(val str: String) {
    fun func1() { Log.i(TAG, "${str} (Member func1)") }       // メンバーのみ
    fun func2() { Log.i(TAG, "${str} (Member func2)") }
}

fun Sample.func2() { Log.i(TAG, "${str} (Extension func2)") } // メンバーと拡張関数
fun Sample.func3() { Log.i(TAG, "${str} (Extension func3)") } // 拡張関数のみ

        Sample("Hello World !!").func1()
        Sample("Hello World !!").func2()
        Sample("Hello World !!").func3()

class Sample(val str: String) {
    fun func1() { Log.i(TAG, "${str} (Member func1)") }       // メンバーのみ
    fun func2() { Log.i(TAG, "${str} (Member func2)") }
}

fun Sample.func2(value: Int) {								  // メンバーと拡張関数
    Log.i(TAG, "${str} (Extension func2 #${value})") 
}
fun Sample.func3() { Log.i(TAG, "${str} (Extension func3)") } // 拡張関数のみ

        Sample("Hello World !!").func1()
        Sample("Hello World !!").func2(22)
        Sample("Hello World !!").func3()

/*
** 整数値を偶数へ変換
**   up: true  ... 一つ大きい偶数へ
**       false ... 一つ小さい偶数へ
*/
fun Int.toEven1(up: Boolean = true): Int {
    return this + if(up) this%2 else -this%2
}

// 「::関数名」で関数オブジェクト
val toEven2: Int.(Boolean)->Int = Int::toEven1

// 無名関数で生成
val toEven3: Int.(Boolean)->Int =
    fun Int.(up: Boolean): Int {
        return this + if(up) this%2 else -this%2
    }
val toEven4: Int.(Boolean)->Int =
    fun Int.(up: Boolean): Int =
        this + if(up) this%2 else -this%2
		
// ラムダ式で生成
val toEven5: Int.(Boolean)->Int = {
    up: Boolean ->this + if(up) this%2 else -this%2
}
val toEven6: Int.(Boolean)->Int = {
    this + if(it) this%2 else -this%2
}