Swiftで継承クラス専用のメソッド動作を実現する方法

Swiftは、オブジェクト指向プログラミングにおける強力な継承機能を持っており、親クラスから子クラスへと機能やメソッドを引き継ぐことができます。この機能を活用することで、コードの再利用性が向上し、効率的な開発が可能になります。しかし、プロジェクトが大規模になるにつれて、特定のクラスに対して特化した動作を実現するためには、継承を適切に使い分けることが必要です。本記事では、Swiftにおけるメソッドのオーバーライドや継承を使った特化した動作の実現方法について、基礎から応用までを詳しく解説します。

継承の基本概念

継承は、Swiftを含むオブジェクト指向プログラミング言語の重要な概念で、あるクラスが別のクラスのプロパティやメソッドを受け継ぐ仕組みです。親クラス（スーパークラス）の機能をそのまま使用できるだけでなく、子クラス（サブクラス）ではそれらを拡張したり、変更したりすることが可能です。これにより、コードの再利用性が高まり、共通の機能を複数のクラスで簡単に管理できるようになります。

Swiftでの継承の書き方

Swiftでは、クラスが他のクラスを継承する場合、classキーワードを使用し、コロン（:）の後に親クラスの名前を指定します。次のような構文で継承を定義します。

class ParentClass {
    // 親クラスのプロパティやメソッド
}

class ChildClass: ParentClass {
    // 子クラスのプロパティやメソッド
}

このようにして、ChildClassはParentClassのすべてのプロパティやメソッドを継承します。

メソッドオーバーライドとは

メソッドオーバーライドとは、親クラスで定義されたメソッドを子クラスで再定義し、独自の実装を与えることです。これにより、子クラスは親クラスのメソッドを上書きして異なる動作を実行できます。Swiftでは、メソッドをオーバーライドする際に、overrideキーワードを使用する必要があります。

メソッドオーバーライドの基本

メソッドオーバーライドを行うには、子クラスで親クラスと同じメソッド名を定義し、overrideキーワードを使って親クラスの実装を上書きします。以下はその例です。

class ParentClass {
    func greet() {
        print("Hello from ParentClass!")
    }
}

class ChildClass: ParentClass {
    override func greet() {
        print("Hello from ChildClass!")
    }
}

この場合、ParentClassのgreetメソッドを子クラスでオーバーライドしています。ChildClassのインスタンスでgreetメソッドを呼び出すと、「Hello from ChildClass!」が出力されます。

オーバーライドの目的

メソッドオーバーライドは、親クラスから継承した機能をそのまま利用するのではなく、子クラスで特化した動作を提供したい場合に非常に有用です。例えば、動物クラスの親クラスが「鳴く」というメソッドを持っている場合、犬や猫といった子クラスでそれぞれ「ワンワン」や「ニャー」といった異なる鳴き方を実装できます。これにより、継承関係を保ちながら柔軟な動作を実現できます。

特定のクラスで異なる動作を行う方法

Swiftでは、親クラスから継承したメソッドをオーバーライドすることで、特定の子クラスに特化した動作を実現できます。オーバーライドされたメソッドは、同じ名前のメソッドであってもクラスごとに異なる振る舞いをします。これにより、クラス階層全体に共通のインターフェースを提供しつつ、各クラスの役割に応じた独自のロジックを持たせることが可能です。

具体例: 動作の特化

例えば、動物を表すクラス階層を考えます。親クラスAnimalにはmakeSoundというメソッドがあり、各子クラスで異なる動作を実装します。

class Animal {
    func makeSound() {
        print("Some generic animal sound")
    }
}

class Dog: Animal {
    override func makeSound() {
        print("Woof!")
    }
}

class Cat: Animal {
    override func makeSound() {
        print("Meow!")
    }
}

この例では、Animalクラスが持つmakeSoundメソッドをDogクラスとCatクラスでオーバーライドし、それぞれ犬と猫の鳴き声を出力するようにしています。これにより、同じmakeSoundというメソッドが異なるクラスごとに特化した動作を行います。

ポリモーフィズムの活用

さらに、このオーバーライドを利用することで、Swiftでのポリモーフィズムを実現できます。例えば、親クラスの型を使って子クラスのインスタンスを扱うことが可能です。以下のように、Animal型の配列に異なる子クラスのインスタンスを格納し、それぞれ特化した動作を行わせることができます。

let animals: [Animal] = [Dog(), Cat()]

for animal in animals {
    animal.makeSound()  // Dogの場合は "Woof!"、Catの場合は "Meow!" を出力
}

このように、クラスごとに異なる動作を行うことができるため、柔軟な設計が可能になります。

`super`を活用した親クラスとの連携

オーバーライドされたメソッドの中で、親クラスのメソッドをそのまま無視するのではなく、一部の動作を継承しつつ追加の処理を行いたい場合があります。このようなケースで便利なのがsuperキーワードです。superは、オーバーライドしたメソッド内から親クラスの同名メソッドを呼び出すために使用されます。

`super`の基本的な使い方

子クラスでオーバーライドしたメソッドの中で、superを使って親クラスのメソッドを呼び出すことができます。これにより、親クラスの実装を利用しつつ、子クラスで新しい動作を追加できます。以下のコード例で、superを使用して親クラスの処理を呼び出す方法を示します。

class Animal {
    func makeSound() {
        print("Some generic animal sound")
    }
}

class Dog: Animal {
    override func makeSound() {
        super.makeSound()  // 親クラスのmakeSound()を呼び出し
        print("Woof!")
    }
}

この例では、DogクラスのmakeSoundメソッドがオーバーライドされ、まずsuper.makeSound()を使って親クラスのmakeSoundメソッドが呼ばれ、その後に犬の特有の鳴き声「Woof!」を出力します。このように、親クラスの動作を継承しつつ新しい振る舞いを追加できます。

親クラスの処理を利用するメリット

superを使うことで、以下のようなメリットがあります。

コードの再利用性向上: 親クラスのロジックを再利用しつつ、子クラスでさらに特化した処理を追加できるため、重複したコードを避けられます。
メンテナンスの容易さ: 親クラスのロジックに変更があった場合、子クラスは再利用している部分だけが影響を受けるため、全体のコードの修正箇所を最小限に抑えることができます。
階層的な拡張: 複数のレベルのクラスで処理を階層的に拡張できるため、クラス階層の構造が整理された形で管理できます。

このようにsuperを適切に活用することで、親クラスと子クラスの間の連携を強化し、柔軟でメンテナンスしやすいコードを作成することができます。

オーバーライド防止の`final`キーワード

Swiftでは、親クラスのメソッドやプロパティが子クラスでオーバーライドされるのを防ぐために、finalキーワードを使うことができます。finalを使うことで、特定のメソッドやプロパティが今後のクラス階層で変更されることを防ぎ、クラス設計の安定性やセキュリティを向上させることが可能です。

`final`キーワードの使い方

finalキーワードは、クラス全体、メソッド、プロパティ、またはサブスクリプトに対して適用することができます。例えば、メソッドをオーバーライドできないようにするには、次のようにfinalを付けます。

class Animal {
    final func makeSound() {
        print("Some generic animal sound")
    }
}

このコードでは、makeSoundメソッドがfinalとして定義されています。これにより、子クラスでこのメソッドをオーバーライドしようとするとコンパイルエラーが発生します。

クラス全体に`final`を適用する

クラス全体をオーバーライド不可能にする場合、クラス宣言にfinalを付けます。これにより、そのクラスは継承されなくなり、完全に固定されたクラスとなります。

final class Dog {
    func makeSound() {
        print("Woof!")
    }
}

この場合、Dogクラス自体が継承できなくなり、すべてのメソッドやプロパティも固定化されます。

`final`を使う利点

finalを使用することで、次のような利点が得られます。

安全性の向上: 重要なメソッドが誤って変更されることを防ぎ、クラス設計の一貫性を維持できます。これにより、予期せぬバグの発生を抑制できます。
パフォーマンスの最適化: Swiftは、finalキーワードが付いたメソッドに対して最適化を行うため、実行時に少し高速になります。
設計の意図が明確になる: 特定のメソッドやクラスが変更されるべきでないことを明示的に示すため、チーム開発での設計意図が共有しやすくなります。

注意点

finalを多用しすぎると、クラスやメソッドの柔軟性が失われ、後でコードを拡張する際に困難になることがあります。そのため、finalを使用する際は、変更の必要がない、またはあってはならない箇所に限定することが推奨されます。

クラス階層の複雑化に伴う注意点

クラスの継承を使ってプロジェクトを進める中で、階層が複雑になることがあります。クラス階層が深くなると、各クラスがどのメソッドをオーバーライドしているか把握しにくくなり、意図しない動作やバグが発生する可能性が高まります。特に、複数のレベルでメソッドのオーバーライドが行われる場合は注意が必要です。

オーバーライドの衝突と意図しない挙動

多層のクラス階層では、親クラスでオーバーライドされたメソッドが、さらにその子クラスでも再びオーバーライドされる可能性があります。このような状況では、どのクラスのメソッドが最終的に呼び出されるのかが明確でない場合があり、開発者が意図した動作とは異なる結果を招くことがあります。

例えば、以下のような多層階層でのメソッドオーバーライドを見てみます。

class Animal {
    func makeSound() {
        print("Some generic animal sound")
    }
}

class Mammal: Animal {
    override func makeSound() {
        print("Mammal sound")
    }
}

class Dog: Mammal {
    override func makeSound() {
        print("Woof!")
    }
}

DogクラスのインスタンスでmakeSoundメソッドを呼び出すと、Dogクラスの実装が呼び出されますが、MammalクラスやAnimalクラスでも同じメソッドが定義されているため、意図しない動作を防ぐためには、メソッドの管理に注意する必要があります。

複雑なクラス階層でのテストの重要性

クラス階層が深くなるにつれ、メソッドオーバーライドによる挙動をしっかりテストすることが重要です。各クラスで意図したメソッドが正しく呼び出されているかを確認するため、ユニットテストや統合テストを用いて、各クラスの動作を個別に検証しましょう。

テスト例

let genericAnimal = Animal()
genericAnimal.makeSound() // "Some generic animal sound"

let mammal = Mammal()
mammal.makeSound() // "Mammal sound"

let dog = Dog()
dog.makeSound() // "Woof!"

このようなテストを通じて、メソッドが階層のどのレベルで呼び出されているかを確認し、意図しないオーバーライドの挙動がないか検証することが可能です。

クラス階層設計のポイント

複雑なクラス階層を避けるためには、次のような設計上の工夫が役立ちます。

継承は必要な場合にのみ使用: クラスを継承する際には、親クラスの機能を必ずしも引き継ぐ必要があるかを検討しましょう。場合によっては、継承よりもプロトコルやコンポジション（複数の小さな機能を組み合わせること）の方が適しています。
クラス階層を浅く保つ: クラス階層が深くなるほど、管理が困難になります。できる限り浅い階層構造を保つことで、メンテナンスがしやすくなります。
finalやsuperの適切な活用: メソッドのオーバーライドを制限するfinalや、親クラスの処理を明示的に呼び出すsuperを活用することで、階層間の衝突を防ぎます。

これらのポイントを考慮しながらクラスの設計を行うことで、複雑さを抑えつつ、予期せぬ挙動を避けることができます。

実践例: 継承とオーバーライドの応用

ここでは、Swiftの継承とメソッドオーバーライドを活用した具体的なコード例を紹介します。特定のクラスに特化した動作を持たせることで、柔軟かつ効率的な設計を行うことができます。この実践例では、動物のクラス階層を使い、各動物が特有の行動を示すコードを見ていきます。

動物クラス階層の構築

まず、動物の基本クラスAnimalと、これを継承した子クラスDogとCatを定義し、それぞれが異なる音を出すmakeSoundメソッドをオーバーライドします。

class Animal {
    func makeSound() {
        print("Some generic animal sound")
    }
}

class Dog: Animal {
    override func makeSound() {
        print("Woof!")
    }
}

class Cat: Animal {
    override func makeSound() {
        print("Meow!")
    }
}

このコードでは、Animalクラスの基本的な動作をDogとCatクラスでオーバーライドしています。それぞれのクラスが特定の鳴き声を持つように実装されています。

親クラスのメソッドを呼び出す例

オーバーライドされたメソッド内で、親クラスのmakeSoundメソッドも呼び出すことができます。これを利用することで、基本的な動作を継承しつつ、独自の処理を追加することができます。

class Dog: Animal {
    override func makeSound() {
        super.makeSound()  // 親クラスのメソッドも呼び出す
        print("Woof! Woof!")
    }
}

この場合、DogクラスでmakeSoundメソッドを呼び出すと、親クラスのメソッド「Some generic animal sound」と「Woof! Woof!」の両方が出力されます。

応用例: 動物の行動を追加する

さらに、動物が行う動作を追加してみましょう。例えば、Dogクラスに「走る」という行動を追加し、鳴き声と動作を連携させます。

class Animal {
    func makeSound() {
        print("Some generic animal sound")
    }

    func run() {
        print("The animal is running")
    }
}

class Dog: Animal {
    override func makeSound() {
        print("Woof!")
    }

    override func run() {
        print("The dog is running fast")
    }
}

この例では、Animalクラスにrunというメソッドを定義し、Dogクラスではその動作をオーバーライドして「犬が速く走る」動作を表現しています。これにより、DogクラスはAnimalクラスの基本動作を持ちながら、より具体的な動作を示すようになりました。

実行例

このコードを実行することで、Dogクラスの特化した動作が確認できます。

let genericAnimal = Animal()
genericAnimal.makeSound()  // 出力: Some generic animal sound
genericAnimal.run()        // 出力: The animal is running

let dog = Dog()
dog.makeSound()            // 出力: Woof!
dog.run()                  // 出力: The dog is running fast

このように、親クラスからの継承を活用しつつ、子クラスで異なる動作を実現することで、柔軟なコード設計が可能になります。

演習問題: 子クラスの動作を特化させるコードを書く

ここでは、実践的な演習問題を通じて、Swiftの継承とオーバーライドの理解を深めます。具体的な要件に基づいてクラスを設計し、特定の動作を持つ子クラスを実装してみましょう。

演習課題

基本クラスの作成: 動物を表すAnimalクラスを作成し、makeSoundメソッドを定義します。このメソッドは「Some generic animal sound」と出力します。
子クラスの作成: Animalクラスを継承したBirdクラスとFishクラスを作成します。それぞれのクラスでmakeSoundメソッドをオーバーライドし、以下の出力を行います:

Birdクラス: 「Chirp!」
Fishクラス: 鳴き声は持たないため、makeSoundメソッドは何も出力しないようにします。

特化したメソッドの追加:

Birdクラスにはflyメソッドを追加し、「The bird is flying」と出力するようにします。
Fishクラスにはswimメソッドを追加し、「The fish is swimming」と出力するようにします。

解答例

以下に、上記の演習課題を満たすコードの解答例を示します。

class Animal {
    func makeSound() {
        print("Some generic animal sound")
    }
}

class Bird: Animal {
    override func makeSound() {
        print("Chirp!")
    }

    func fly() {
        print("The bird is flying")
    }
}

class Fish: Animal {
    override func makeSound() {
        // 鳴き声は持たないため、何も出力しない
    }

    func swim() {
        print("The fish is swimming")
    }
}

実行例

このクラスを使って、各動物のメソッドを呼び出してみましょう。

let genericAnimal = Animal()
genericAnimal.makeSound()  // 出力: Some generic animal sound

let bird = Bird()
bird.makeSound()            // 出力: Chirp!
bird.fly()                  // 出力: The bird is flying

let fish = Fish()
fish.makeSound()            // 出力: (何も出力しない)
fish.swim()                // 出力: The fish is swimming

この演習を通じて、Swiftにおけるクラスの継承とオーバーライドの基本を理解し、特定の動作を持つクラスを設計する能力を身につけることができます。また、オーバーライドやメソッドの追加を通じて、コードの柔軟性と拡張性を高める方法を体感できます。

継承とプロトコルの組み合わせ

Swiftでは、継承とプロトコルを組み合わせることで、より柔軟で再利用可能なコードを設計することができます。プロトコルは、特定の機能や動作を定義する契約のようなもので、クラス、構造体、列挙体などに実装させることができます。これにより、複数の異なるクラスが同じプロトコルに準拠しつつ、独自の実装を持つことが可能になります。

プロトコルの基本

プロトコルはprotocolキーワードを使って定義します。以下は、動物が共通して持つメソッドmakeSoundを定義したプロトコルの例です。

protocol AnimalSound {
    func makeSound()
}

このAnimalSoundプロトコルを使用して、各動物クラスがこのメソッドを実装することができます。

プロトコルの適用例

次に、AnimalSoundプロトコルを使って、DogとCatクラスを定義します。これらのクラスは、それぞれ異なる方法でmakeSoundメソッドを実装します。

class Dog: AnimalSound {
    func makeSound() {
        print("Woof!")
    }
}

class Cat: AnimalSound {
    func makeSound() {
        print("Meow!")
    }
}

この場合、DogとCatのクラスはAnimalSoundプロトコルに準拠しており、それぞれのクラスで異なる鳴き声を出すように実装されています。

継承との組み合わせ

継承とプロトコルを組み合わせることで、共通の基盤を持つクラスがさらに特化した動作を持つことができます。例えば、基本的な動物クラスAnimalを作成し、その中でAnimalSoundプロトコルを実装することができます。

class Animal: AnimalSound {
    func makeSound() {
        print("Some generic animal sound")
    }
}

このように、Animalクラスはプロトコルを実装しつつ、継承によって他のクラスに共通の機能を提供します。

実践例: プロトコルを使った動物の動作

以下に、継承とプロトコルを組み合わせた具体的なコード例を示します。

protocol AnimalSound {
    func makeSound()
}

class Animal: AnimalSound {
    func makeSound() {
        print("Some generic animal sound")
    }
}

class Dog: Animal {
    override func makeSound() {
        print("Woof!")
    }
}

class Cat: Animal {
    override func makeSound() {
        print("Meow!")
    }
}

このように設計することで、Animalクラスは共通の機能を提供し、DogやCatはそれぞれの特有の動作を実装することができます。

ポリモーフィズムの活用

プロトコルを使用することで、ポリモーフィズムを活かしたコードを書くことが可能です。以下のように、AnimalSound型の配列を作成し、異なる動物のインスタンスを格納することができます。

let animals: [AnimalSound] = [Dog(), Cat()]

for animal in animals {
    animal.makeSound()  // 各動物の鳴き声を出力
}

このコードでは、DogとCatのインスタンスを配列に格納し、makeSoundメソッドを呼び出すことで、それぞれの動物の鳴き声を出力します。これにより、動的に異なる型のオブジェクトを扱うことができるようになります。

まとめ

継承とプロトコルを組み合わせることで、Swiftでのクラス設計の柔軟性が大幅に向上します。共通の機能を持つ基盤を作りつつ、各クラスに特有の振る舞いを実装することで、コードの再利用性と可読性を高めることができます。

トラブルシューティング: よくあるエラーと解決策

Swiftにおける継承とメソッドオーバーライドを使っている際には、さまざまなエラーや問題が発生することがあります。以下に、よくあるエラーの例とその解決策を示します。

1. オーバーライドエラー

エラー内容: 「Method cannot override a 'final' method」
このエラーは、親クラスのメソッドがfinalとして定義されている場合に、子クラスでオーバーライドしようとすると発生します。

解決策:
親クラスのfinal修飾子を取り除くか、子クラスでオーバーライドを行わないようにします。必要に応じて、finalを使わない設計に変更することも検討しましょう。

class Animal {
    final func makeSound() {
        print("Some generic animal sound")
    }
}

// 子クラスでオーバーライドはできません
class Dog: Animal {
    // この部分がエラーになります
}

2. 親メソッドの未実装エラー

エラー内容: 「Type 'Dog' does not conform to protocol 'AnimalSound'」
プロトコルに準拠するクラスが、そのプロトコルで定義されたすべてのメソッドを実装していない場合に発生します。

解決策:
プロトコルで要求されているメソッドをすべて実装することを確認します。

protocol AnimalSound {
    func makeSound()
}

class Dog: AnimalSound {
    // makeSound() メソッドが実装されていないためエラーが発生
}

解決策は、makeSound()を追加することです。

class Dog: AnimalSound {
    func makeSound() {
        print("Woof!")
    }
}

3. メソッドの呼び出しエラー

エラー内容: 「Value of type 'Animal' has no member 'fly'」
親クラスには存在しないメソッドを子クラスのインスタンスで呼び出そうとした場合に発生します。

解決策:
メソッドを呼び出す際は、そのメソッドがどのクラスに定義されているかを確認します。必要に応じて、適切な型でキャストするか、親クラスにそのメソッドを追加することを検討します。

class Animal {
    func makeSound() {
        print("Some generic animal sound")
    }
}

class Bird: Animal {
    func fly() {
        print("The bird is flying")
    }
}

let animal = Animal()
// animal.fly()  // エラーが発生します

この場合、animalをBird型にキャストするか、Birdのインスタンスを作成してflyメソッドを呼び出します。

4. コンパイルエラー: タイプミスマッチ

エラー内容: 「Cannot assign value of type 'Dog' to type 'Animal'」
異なる型のオブジェクトを無理に代入しようとした際に発生します。

解決策:
型の互換性を確認し、適切な型のオブジェクトを使用するようにします。

class Animal {}
class Dog: Animal {}

let myAnimal: Animal = Dog()  // 正しい代入

5. トラブルシューティングのためのデバッグ

これらのエラーに遭遇した場合は、次のデバッグ手法を活用してください。

エラーメッセージをよく読む: Swiftのコンパイラが提供するエラーメッセージは、問題の発生箇所や原因を指摘しています。これを手がかりに問題を特定します。
コメントアウトを活用する: 問題のあるコードを一時的にコメントアウトし、どの部分が問題を引き起こしているかを切り分けて確認します。
小さな単位でテスト: 各クラスやメソッドを小さな単位でテストし、正常に動作するか確認します。

これらのポイントを押さえながら、トラブルシューティングを行うことで、Swiftの継承とオーバーライドに関連する問題を迅速に解決できるようになります。

まとめ

本記事では、Swiftにおける継承クラス専用のメソッド動作を実現する方法について詳しく解説しました。以下のポイントを振り返ります。

継承の基本概念: Swiftでは、クラスを使って親クラスの機能を子クラスに引き継ぐことで、コードの再利用性を高めることができます。
メソッドオーバーライド: 親クラスで定義されたメソッドを子クラスでオーバーライドすることで、特化した動作を実現できます。このプロセスを通じて、ポリモーフィズムを活用した柔軟なコード設計が可能になります。
superの活用: オーバーライドしたメソッド内で親クラスのメソッドを呼び出すことで、共通の機能を再利用しながら独自の処理を追加できます。
finalキーワードの利用: オーバーライドを防ぐためのfinalキーワードを使うことで、クラス設計の安全性を向上させることができます。
クラス階層の注意点: クラス階層が複雑になると、メソッドの呼び出しやオーバーライドに関するエラーが発生しやすくなるため、慎重な設計が求められます。
プロトコルとの組み合わせ: 継承とプロトコルを併用することで、さらに柔軟で再利用可能な設計が可能になります。
トラブルシューティング: よくあるエラーとその解決策を理解することで、問題を迅速に解決し、スムーズな開発が行えます。

これらの知識を活用することで、Swiftにおけるオブジェクト指向プログラミングの理解が深まり、より効果的にクラスを設計・実装することができるでしょう。今後の開発に役立ててください。

Swiftで継承クラス専用のメソッド動作を実現する方法

継承の基本概念

Swiftでの継承の書き方

メソッドオーバーライドとは

メソッドオーバーライドの基本

オーバーライドの目的

特定のクラスで異なる動作を行う方法

具体例: 動作の特化

ポリモーフィズムの活用

`super`を活用した親クラスとの連携

`super`の基本的な使い方

親クラスの処理を利用するメリット

オーバーライド防止の`final`キーワード

`final`キーワードの使い方

クラス全体に`final`を適用する

`final`を使う利点

注意点

クラス階層の複雑化に伴う注意点

オーバーライドの衝突と意図しない挙動

複雑なクラス階層でのテストの重要性

テスト例

クラス階層設計のポイント

実践例: 継承とオーバーライドの応用

動物クラス階層の構築

親クラスのメソッドを呼び出す例

応用例: 動物の行動を追加する

実行例

演習問題: 子クラスの動作を特化させるコードを書く

演習課題

解答例

実行例

継承とプロトコルの組み合わせ

プロトコルの基本

プロトコルの適用例

継承との組み合わせ

実践例: プロトコルを使った動物の動作

ポリモーフィズムの活用

まとめ

トラブルシューティング: よくあるエラーと解決策

1. オーバーライドエラー

2. 親メソッドの未実装エラー

3. メソッドの呼び出しエラー

4. コンパイルエラー: タイプミスマッチ

5. トラブルシューティングのためのデバッグ

まとめ

コメント

コメントする コメントをキャンセル

コメントするコメントをキャンセル