Swift 10 SwiftのObject Programming Basic

`Swift`は`Object`アフリ開発を幅広く対応します。

# 十・壱　`Object`は何ですか
`Object`≒ Class ≒ Instance はソフトウェアのアフリを構築するブロックにで
簡単に使えて再利用できる独立な`Independent Functional Modules`です。
`Task`を`Run`するための`Object`と`Instance`でアクセスして`Call`される 
`Property`と`Method`で`Object`が構成されます。
`Object`を構成するデータ `var　　`と`func　　`を包括的に｀Class Member`と言います。
# 十・弐　`Class`は何ですか
> method : a particular form of procedure for accomplishing or approaching something, especially a systematic or established one.
origin :  from meta- (expressing development) + hodos ‘way’.

これは`Object`が生成する時の形を定義します。
例え、`Method`が何をすることになるのか、どんな`Property`が存在するかなどを定義します。
## 弐・甲　`Class`宣言する
> property : a thing or things belonging to someone; possessions collectively.
origin : from Latin proprietas, from proprius **‘one's own, particular’**

> Instance: an example or **single occurrence** of something.
origin : The original sense was **‘urgency, urgent entreaty’**, surviving in at the instance of . In the late  hence the meaning ‘single occurrence’.


`Class`を`Instance`化する前に、まず`Object`に対する`bluePrint`を定義する必要があります。
新しく作る`Class`が、どの`Parent Class`から派生したかを指定されて`Class`で含める`Property`と`Method`を定義します。
```swift
class 新しいclassの名前:親class {
//property
//instance Method 
//type method 
}
```

本地的に此れらは特定`Task`を実行する`Class`固有の`Function`である
`Class`の名前を作る時のルールは各単語の最初の文字を大文字で宣言するです。
これに反して、`Property`の名前と`func　　`の名前は lowerCamelCaseで作ります。
## 弐・乙　`Instance` `Property`追加する
`Object Programming`の主な目的はデータカプセル化という概念です
`Class`に保存して`access`できるデータは、その`Class`内で定義された`Method`だけを通していいという事です。
`Class`内のカプセル化されたデータを`Property`または`Instance　var　`だと言います。
# 十・参　`Method`

## 参・甲`Instance Method`と`Type Method`
`Method`は`Class`の性格に合った特定`Task`を実行する為に呼び出されるコードルーチンです。
`Method`は`Type Method`と`Instance Method`で二つの形があります。
`Type Method`は　`Class`レベルに動作(例え、`Class`の新しい`Instance`生成する)します。
反面、`Instance　Method`は`Class`の`Instance`に対する作業(例え、二つの`Property　var... `に対する算術演算をして結果を `Return`することです。

`Instance　Method`は自身が属することになる`Class`の　( 中で)宣言されて、標準のSwift `func`宣言`Syntax`を使って宣言されます。

`Type Method`は　`Instance Method`と同じ方法で宣言されるけど、前で Classキーワードが付ける点が違います。
```swift
class BankAccount {
    var accountBalance: Float = 0
    var accountNumber: Int = 0
    
    func displayBalance()
    {
        print("Number \(accountNumber)")
        print("Current balance is \(accountBalance)")
    }   
}
```
この`Method`は`Instance Method`ので``Class`が前に付けられません。

BankAccount Classを設計する時この`Class`で最多金額を知るために`Class`自身の`Type Method`を呼び出せるなら便利そうだ
これを通してアフリが`Class　Instance`を初めて、生成する過程を経なくても、
BankAccount `Class`を新いお客様の情報を保存するかどうかを別できるようにします。  
```swift
class BankAccount {
    var accountBalance: Float = 0
    var accountNumber: Int = 0
    
    func displayBalance()
    {
        print("Number \(accountNumber)")
        print("Current balance is \(accountBalance)")
    }
    
    class func getMaxBalance() -> Float {
        return 100000.00
    }
}
```
## 参・乙　`Class Instance`宣言する
`Class`を持ってどんな作業をすれば`Instance`を生成必要があります。
`Instance`に対した`Reference`を保存する `var 　`を宣言する事です。
```swift
var account1: BankAccount = BankAccount()
```
account1と言う `var ...`をとしてBankAccount Classにアクセスができます。
## 参・丙　`Initial`すると`Deinitial`する
`Class` `Instance`を生成するときで`initial`必要な`Task`がやるべきことがあるかもしれないです。
この`Task`は`Class`の`init Method`中で実装されます。
新しい`Class`の`Instance`が生成されるとき`value`を`init`します。
```swift

class BankAccount {
    var accountBalance: Float = 0
    var accountNumber: Int = 0
    
    init(number: Int, balance: Float){
        accountNumber = number
        accountBalance = balance
    }
    
    func displayBalance()
    {
        print("Number \(accountNumber)")
        print("Current balance is \(accountBalance)")
    }
}
```
これで、`Class`の`Instance`を生成する時に次の様に口座番号とbalanceで
`init`ができます。
```swift
var account1 = BankAccount(number: 123213123, balance: 400.41)
```
逆に、Swift RuntimeSystemによって`Class` `Instance`が消える前にする`Task`は`Class`中の`Deinit`を実装すればできます。
```swift

class BankAccount {
    var accountBalance: Float = 0
    var accountNumber: Int = 0
    
    init(number: Int, balance: Float){
        accountNumber = number
        accountBalance = balance
    }
    deinit{
 // 必要な`Task`をここで実行します。
}

    func displayBalance()
    {
        print("Number \(accountNumber)")
        print("Current balance is \(accountBalance)")
    }
}
```
## 参・丁　`Method` `Call`と`Property`アクセス
`Class`である`Instance` `Method`をどのように呼び出すか、`Property`にはどのようにアクセスするかを学びます。此れは`dot notation`を使えれば簡単にできます。
```swift
ClassInstance.propertyName
ClassInstance.instanceMethod()
```
例え、accountBalace `Instance`　 `var ...`の現在の`value`を受け取れば
```swift
var balance1 = account1.accountBalance
```
点表記法を使うと`Instance`　`Property`で`value`を設定可能です。
```swift
account1.accountBalance = 6789.98
```
`Class`　`Instance`の`Method`を呼び出す時にも、同じ方法を使います。
```swift
account1.displayBalance() 
```
`Type Method`も点表記法を使って呼び出します。注意することは`Class`　`Instance`がなく、`Class`で呼び出されるべきです。
```swift
ClassName.TypeMethod()
```
例え、前で宣言した、`Type Method` getMaxBalanceを呼び出すると、BankAccountが`Reference`されます。
```swift
var maxAllowed = BankAccount.getMaxBalance()
```
# 十・肆　Property 
## 肆・甲　Stored Property と　Computed Property
### Stored Property
は　`let 　　`と`var    　　`で含まれる`value`です。
```swift
class BankAccount {
    var accountBalance: Float = 0
    var accountNumber: Int = 0
```
### Computed Property
`Property`で`value`を設定すると、持ってくる時点で、どんな計算やロジクで処理される`value`です。
此れは　`getter`を生成して、選択的に`setter` `Method`を生成して、演算を実行するコードが含まれます。
```swift
class BankAccount {
    var accountBalance: Float = 0
    var accountNumber: Int = 0
    let fees: Float = 25.00
    
    var balanceLessFees: Float{
        get{
            return accountBalance - fees
        }
    }
.
.
.
```
上のコードには現在の残高からfeesを済む`Computed Property`を `Return`する`getter`を追加しました。
選択肢の`setter`もやはり同じ方法で宣言できます。
```swift
    var accountBalance: Float = 0
    var accountNumber: Int = 0
    let fees: Float = 25.00
    
    var balanceLessFees: Float{
        get{
            return accountBalance - fees
        }
        set(newBalance){
            accountBalance = newBalance - fees
        }
    }
```
## 肆・乙　遅延保存`Property`
`Property`を一番基本的な`init`する方法は直接に割り当う事です。
```swift
var myProperty = 10
```
### Propertyを`value`を割り当う
他の方法では`init`する作業で`Property`で`value`を割り当てる事です。
```swift
class BankAccount {
    let title: String
    
    init(title: String){
        self.title = title
    }
}
```
### Propertyを`Closure`を割り当う
もう少し複雑な方法では`Closure`を使って`Property`を`init`する事です。

```swift
class MyClass {
    
    var myProperty: String = {
        var result = resourceIntensiveTask()
        result = processData(data: result)
        return result
    }()
}
```
複雑な`Closure`の場合は`init`作業がリソースと時間を多く使われることになります。`Closure`を使って宣言すると、該当`Property`がコード内で実際使われるのかは関係なく、`Class`の`Instance`が生成される度に`init`作業が実施される。

### Lazy Property
例え、データベースからデータを持ってくる持って来たり使用者から`input`を入手する時、実行フロセスの後半部まで`Property`で`value`が割り当てられたかと、わからない状況が起こる可能性があります。
こんな状況で最も効果的な方法は、`Property`を最初に接近する時のみ`init`作業をすることです。此れは　`lazy Property`で宣言します。
```swift
class MyClass {
    lazy var myProperty: String = {
        var result = resourceIntensiveTask()
        result = processData(data: result)
        return result
    }()
}
```
`Property`を`lazy`で宣言すると、最初に接近される時のみ`init`されます。
ですから、リソース集約的な活動を後回しにすることができます。
`lazy` `Property`は必ず`var  　  `で宣言される。

# 十・伍 Self 
`Object`フログラミーぐ言語で慣れたフログラマーなら、現在の`Class` `Instance`で属する`Method`や`Property`を指すとき、`Property`と`Method`前で`self`を付けす習慣があるはず。`Swift`フログラミーぐもやはり`self` `Property`ターフを提供します。
```swift
class MyClass{
var myNumber = 1 
func addTen(){
    self.myNumber +=10
    }
}
```
前のコードで`self`はMyClass`Class Instance`に属するmyNumberと言う`Property`を`reference`することをCompilerに知らせます。
だが、耐部分の場合Swiftでフログラミーぐする時には`self`を使う必要がありません。`self`は`Property`と`Method`に対した`Reference`をでデフォルトで見なすからです。そして
```swift
func addTen(){
    myNumber += 10
}
```
耐部分の場合はSwiftで`self`は選択的に使用されます。selfを使用する必要がある場合は`Property`な`Method`を`Closure`表現式内で`reference`するときです。
```swift
document?.openWithCompletionHandler({(success: bool) -> Void in
    if success{
        self.ubiquityURL = resultURL
    }
})
```
また、 `func(){   }`の `(Para,meter)` `Class　Property`と同じ名前を持つ場合にコードの曖昧さを解決為に、`self.`を使う必要があります。

# 十・陸　Protocol
他の`Class{}`と一緒に作業する為に最初のルールを`: Protocol`と言います。
此れは必ず含めるべきの`Method()`と`Property = 0`を正義します。
ある`Class{}`が`: Protocol`を採用したが、全てのプロトコルの要件を満たさない場合エラーが発生します。
```swift
protocol MessageBuilder{
    
    var name: String { get }
    func buildMessage() -> String
}

class MyClass: MessageBuilder {
    var name: String
    
    init(name: String) {
        self.name = name
    }
    func buildMessage() -> String {
        "Hello" + name
    }
}
```
# 十・柒　不透明`return ___`ターフ
不透明`return ___`は指定された`: Protocol`が全てのタープをリターンされる様にします。
これは`: Protocol`の前で　`some`キーワードを付けて宣言されます。例え次のコードはdoubleFunc1() `func(){     }`がEquatable `: Protocol`を従う全ての`Type`の結果がリターンされたと宣言する。
```swift
func doubleFunc1 (value: Int)-> some Equatable {
    value * 2 //returnが必要ない
}
```
元々Equatable `: Protocol`を従う為には、
`value`たちが互いに同じかどうか比較できる必要がありますが、
`some (return) ___`は全ての `: Protocol`で使用できます。
IntとStringタイプ全てがEquatable `: Protocol`を従えば、String 結果を` ↑ return`する`func(){     }`も生成できます。
```swift
func doubleFunc2(value: Stinrg) -> some Equatable {
    value + value
}
```
ライブラリやAPIフレームワーク内においてソースコードを見ることができなければ
正確にどんな`Type`が`↑ return`されるか知らないだろう。

# 要約
`Swift`と同じ`ObjectProgramming`言語はコード再利用と`Class Instance(){}`内のデータカプシュル化された`Class{}`は生成を奨励します。