ソフトウェアエンジニアの技術ブログ：Software engineer tech blog

### ジェネリクス
型を汎用化する
class使用時にデータ型を指定する

class MyData<T> {
    fun getThree(x: T){
        println(x)
        println(x)
        println(x)
    }
}

fun main(args: Array<String>) {
	val mi = MyData<Int>()
    mi.getThree(55)
}

### data class

data class Point(val x: Int, val y: Int)

fun main(args: Array<String>) {
	val p1 = Point(3, 5)
    val p2 = Point(3, 5)
    
    println(p1)
    println(if (p1 == p2) "same" else "not same")
}

### Collection
List: 順番を持つデータの集合(Immutable/Mutable)、Set: 順番を持たない|重複を許さないデータの集合(Immutable/Mutable)、Mapはkeyと値でデータを管理(Immutable/Mutable)
– Immutableなデータを作る
– listはlistOfで使う。変更する場合は、mutableListOfで使用する

fun main(args: Array<String>) {
	val sales: List<Int> = listOf(20, 30, 40)
    println(sales[1])
}

– setはsetOf
– 変更する場合は、mutableSetOfで使用する

fun main(args: Array<String>) {
	val answers: Set<Int> = setOf(5, 3, 8, 5)
    println(answers)
    println(answers.contains(3))
    
    val set1 = setOf(1, 3, 4, 8)
    val set2 = setOf(3, 5, 7, 9)
    println(set1.intersect(set2))
    println(set1.union(set2))
}

– mapはmapOf
– mutableMap

fun main(args: Array<String>) {
	val users: Map<String, Int> = mapOf("yamada" to 10, "tanaka" to 20, "sato" to 30)
    println(users["yamada"])
    println(users.size)
	println(users.keys)
    println(users.values)
    println(users.entries)
}

### map
コレクションを処理するための命令にmap, filter, forEachなどが使える

fun main(args: Array<String>) {
	val prices = listOf(53.2, 48.2, 32.8)
    prices
    	.map{ n -> n * 1.08} // 引数　->処理
        .filter { n -> n > 50}
        .forEach { println(it)}
}

### 例外処理
try & catch

class MyException(message: String): Throwable(message){
    
}

fun div(a: Int, b: Int){
    try {
        if(b < 0){
            throw MyException("not minus!")
        }
        println(a / b)
    } catch(e: ArithmeticException){
        println(e.message)
    }
}

fun main(args: Array<String>) {
	div(3, 0)
}

### Nullable
nullになりそうな型は、型の後ろに「?」を付ける

fun main(args: Array<String>) {
	val s: String = null
    println(s)
}

Null can not be a value of a non-null type String

fun main(args: Array<String>) {
	val s: String? = null
    println(s)
    
    if(s != null){
        println(s.length)
    } else {
        println(null)
    }
}

### class

class User {
    var name = "Me!"
    fun sayHi(){
        println("hi $name")
    }
}

fun main(args: Array<String>){
	val user = User()
    println(user.name)
    user.sayHi()
    
    user.name = "steve"
    println(user.name)
    user.sayHi()  
}

constructor
->classの引数の渡し方はmethodと同様に型を指定する

class User(var name: String) { // constructor
    var team = "red"
    init {
        println("instance created: name: $name, team: $team")
    }
    fun sayHi(){
        println("hi $name")
    }
}

fun main(args: Array<String>){
	val tom = User("tom")
    println(tom.name)
    tom.sayHi()
}

instance created: name: tom, team: red
tom
hi tom

### getter, setter

    // getter
//     get(){
//         return field.toUpperCase()
//     }
    get() = field.toUpperCase()
    // setter
    set(value) {
        if(value != ""){
            field = value
        }
    }

### override
継承される側はopenを付ける

class AdminUser(name: String): User(name){
    fun sayHello(){
        println("hello $name")
    }
    override fun sayHi(){
        println("[admin] hi $name")
    }
    
}

open class User(var name: String){
    open fun sayHi(){
        println("hi $name")
    }
}

fun main(args: Array<String>) {
    val bob = AdminUser("bob")
    println(bob.name)
    bob.sayHello()
    bob.sayHi()
}

### アクセス修飾子
public:どこからでも、protected: そのクラス+サブクラス、private:そのクラスのみ
-> アクセスをcontrollすることで安全なプログラムを書ける

### 拡張

fun User.sayHi(){
    println("[ext] hello $name")
}

val User.myName: String
 get() = "I am $name"

open class User(var name: String){
    fun sayHi(){
        println("hi $name")
    }
}

fun main(args: Array<String>) {
    val bob = User("bob")
    println(bob.name)
    bob.sayHi()
}

### 抽象クラス・具象クラス
抽象クラスはabstractとする

abstract class User{
    abstract fun sayHi()
}

class Japanese: User() {
    override fun sayHi(){
        println("こんにちは!")
    }
}

class American: User() {
    override fun sayHi(){
        println("Hi!")
    }
}


fun main(args: Array<String>) {
	val tom = American()
    val aki = Japanese()
    tom.sayHi()
    aki.sayHi()
}

### Interface
抽象プロパティ、抽象メソッド、メソッド

interface Sharable {
    val version: Double
    fun share()
    fun getInfo(){
        println("Share I/F ($version)")
    }
}

class User: Sharable {
    override val version = 1.1
    override fun share(){
        println("Sharing ...")
    }
}

fun main(args: Array<String>) {
	val user = User()
    user.share()
    user.getInfo()
}