MENU
  1. ホーム
  2. Java
  3. Javaで複雑な条件式をシンプルに保つテクニック

Javaで複雑な条件式をシンプルに保つテクニック

Java

Javaプログラミングにおいて、複雑な条件式は避けがたい課題の一つです。コードのロジックが複雑になるにつれて、条件式もまた入り組んでしまい、可読性やメンテナンス性が低下します。これにより、バグの発生や修正の困難さが増大し、プロジェクトの進行に悪影響を及ぼすこともあります。本記事では、Javaにおける複雑な条件式をシンプルに保ち、コードをより理解しやすくするためのさまざまなテクニックやベストプラクティスを紹介します。これらのテクニックを活用することで、コードの品質向上と開発効率の改善が期待できます。

目次

複雑な条件式の問題点

Javaプログラミングにおいて、複雑な条件式はコードの可読性と保守性に大きな影響を与える要因となります。複雑な条件式は、一見して理解しづらく、エラーが発生しやすくなるため、デバッグやメンテナンスの際に多くの時間を費やすことになります。

可読性の低下

複雑な条件式は、多くの論理演算子やネストした条件を含むことが多いため、一目で意図を理解するのが難しくなります。これにより、他の開発者がコードをレビューしたり、将来的に修正を加えたりする際に混乱が生じる可能性があります。

エラーのリスク

複雑な条件式は、意図しない動作を引き起こすリスクが高くなります。特に、条件の優先順位や括弧の位置が適切でない場合、期待した動作とは異なる結果が生じることがあります。これにより、バグが発生しやすくなり、特定するのに時間がかかることがあります。

メンテナンスの困難さ

複雑な条件式を含むコードは、修正や機能追加の際に問題を引き起こします。元の意図を理解するのが難しいため、変更が容易にバグを生む可能性があり、結果としてメンテナンスが非常に困難になります。

このような理由から、条件式をできるだけシンプルに保つことが、安定したコードの作成と長期的なメンテナンスの容易さを確保するために重要です。

条件式の分割とメソッド化

複雑な条件式をシンプルに保つための最も基本的なテクニックの一つが、条件式を分割し、それぞれをメソッド化することです。このアプローチにより、個々の条件の役割を明確にし、コードの可読性と再利用性を向上させることができます。

条件式の分割

まず、複雑な条件式を複数の単純な条件に分割することを考えます。たとえば、次のような複雑な条件式があったとします。

if (user.isActive() && user.getRole().equals("ADMIN") && user.getAge() > 18 && user.hasValidSubscription()) {
    // 処理内容
}

このような条件式は、複数の論理条件を一度に評価しており、何を判断しようとしているのかが一目で分かりにくいです。

メソッド化

次に、この条件式を個別のメソッドに分割し、それぞれが何をチェックしているのかを明確にします。たとえば、次のようにコードを改善できます。

if (isUserEligibleForAdminAccess(user)) {
    // 処理内容
}

private boolean isUserEligibleForAdminAccess(User user) {
    return isActiveUser(user) && isAdmin(user) && isAdult(user) && hasValidSubscription(user);
}

private boolean isActiveUser(User user) {
    return user.isActive();
}

private boolean isAdmin(User user) {
    return user.getRole().equals("ADMIN");
}

private boolean isAdult(User user) {
    return user.getAge() > 18;
}

private boolean hasValidSubscription(User user) {
    return user.hasValidSubscription();
}

この方法により、各条件の意図が明確にされ、コード全体の可読性が大幅に向上します。さらに、個々のメソッドは再利用可能であり、他の部分でも同様の条件チェックが必要な場合に便利です。

まとめ

条件式を分割してメソッド化することで、コードをシンプルに保ちながら、可読性とメンテナンス性を向上させることができます。このテクニックは、特に複雑なロジックが含まれる場合に有効であり、バグの発生を防ぎつつ、将来のコード変更にも柔軟に対応できるようにします。

ディシジョンテーブルの活用

ディシジョンテーブル（決定表）は、複雑な条件式をシンプルに整理し、管理するための強力なツールです。特に、複数の条件が絡み合っている場合、ディシジョンテーブルを使用することで、全ての条件とその結果を明確に把握しやすくなります。

ディシジョンテーブルとは

ディシジョンテーブルは、条件とその組み合わせによって導き出される結果を表形式で整理したものです。これにより、すべての可能な条件の組み合わせと、それぞれのケースに対する適切なアクションを視覚的に確認できます。これをコードに反映させることで、条件式を簡潔にし、ロジックのミスを防ぐことができます。

ディシジョンテーブルの例

例えば、次のような条件を考えてみましょう：

  • ユーザーがアクティブかどうか (isActive)
  • ユーザーのロールが管理者 (isAdmin)
  • サブスクリプションが有効か (hasValidSubscription)

これらの条件に基づいて、ユーザーに異なる権限を与える場合、ディシジョンテーブルを使用して次のように整理できます。

isActiveisAdminhasValidSubscriptionアクション
YesYesYesフルアクセス
YesYesNo管理者アクセスのみ
YesNoYes一般アクセス
YesNoNoアクセス拒否
No––アカウント停止中

この表を使って、コードをよりシンプルで分かりやすいものにできます。

ディシジョンテーブルの実装

上記のディシジョンテーブルを実装するコードは次のようになります：

public String determineUserAccess(User user) {
    if (!user.isActive()) {
        return "アカウント停止中";
    }

    if (user.isAdmin()) {
        return user.hasValidSubscription() ? "フルアクセス" : "管理者アクセスのみ";
    } else {
        return user.hasValidSubscription() ? "一般アクセス" : "アクセス拒否";
    }
}

このコードは、ディシジョンテーブルに従ってユーザーのアクセスレベルを決定しています。条件が視覚的に整理されているため、ロジックを誤る可能性が低く、コードの意図を理解しやすくなります。

まとめ

ディシジョンテーブルを活用することで、複雑な条件を整理し、よりシンプルで分かりやすいコードに変換できます。これにより、コードの可読性とメンテナンス性が向上し、バグの発生を防ぐことができます。ディシジョンテーブルは、特に複数の条件が組み合わさる場面で威力を発揮します。

Enumを使った条件処理の改善

JavaのEnum（列挙型）は、条件処理をシンプルに保つための強力なツールです。複数の状態やオプションを扱う際に、Enumを使うことでコードの可読性と安全性が向上し、条件式を簡潔にすることができます。

Enumの基本的な活用法

まず、Enumは固定された定数の集合を定義するためのクラスです。これにより、特定の状態やオプションを明確にし、間違った値の使用を防ぐことができます。例えば、ユーザーのロールを管理する場合、次のようにEnumを定義できます。

public enum UserRole {
    ADMIN,
    USER,
    GUEST
}

これにより、ユーザーのロールを文字列で扱うよりも安全で、コードが理解しやすくなります。

Enumを使った条件式の改善

複雑な条件式でEnumを使用することで、コードを整理し、条件を明確に表現できます。例えば、ユーザーのロールに応じたアクセス権を管理する場合、以下のようにコードを簡潔にできます。

public String getAccessLevel(UserRole role) {
    switch (role) {
        case ADMIN:
            return "フルアクセス";
        case USER:
            return "一般アクセス";
        case GUEST:
            return "制限付きアクセス";
        default:
            return "アクセス拒否";
    }
}

このコードは、ユーザーのロールに応じて適切なアクセスレベルを返します。Enumを使用することで、条件が明確に定義され、誤ったロールが使用される可能性を排除できます。

Enumの拡張機能

Enumは単なる定数の集まり以上の機能を持っています。例えば、各Enum定数に対して特定の動作を定義することも可能です。以下の例では、各ロールに対応するメッセージを持たせています。

public enum UserRole {
    ADMIN("フルアクセス"),
    USER("一般アクセス"),
    GUEST("制限付きアクセス");

    private final String accessLevel;

    UserRole(String accessLevel) {
        this.accessLevel = accessLevel;
    }

    public String getAccessLevel() {
        return accessLevel;
    }
}

このようにして、Enum自体が関連する情報を持つことで、条件式をさらにシンプルにできます。

まとめ

Enumを使用することで、複雑な条件処理をシンプルかつ安全に管理できます。Enumを適切に活用することで、コードの可読性とメンテナンス性が向上し、誤りを防ぐことができます。特に、状態やオプションが明確に定義できる場合には、Enumを活用することで、より良いコード設計が実現できます。

Strategyパターンで条件を置き換える

複雑な条件式をシンプルに保つためのもう一つの強力な方法が、Strategyパターンを使用することです。Strategyパターンは、アルゴリズムや動作をカプセル化し、それらを必要に応じて切り替えることで、条件式を減らし、コードを柔軟で拡張可能にします。

Strategyパターンの基本概念

Strategyパターンは、共通のインターフェースを持つ複数のアルゴリズムをクラスとして実装し、それらを動的に切り替えることを可能にするデザインパターンです。これにより、条件式を使用せずに異なる処理を実行できます。

例えば、支払い方法によって異なる計算ロジックを実行する場合を考えてみましょう。条件式を使うと次のようになります。

if (paymentType.equals("CreditCard")) {
    processCreditCardPayment();
} else if (paymentType.equals("PayPal")) {
    processPayPalPayment();
} else if (paymentType.equals("BankTransfer")) {
    processBankTransferPayment();
}

このような条件式は、支払い方法が増えるとともに増大し、管理が難しくなります。

Strategyパターンによる条件式の置き換え

この複雑な条件式をStrategyパターンで置き換えると、コードが次のように整理されます。

まず、共通のインターフェースを定義します。

public interface PaymentStrategy {
    void processPayment();
}

次に、それぞれの支払い方法に対応するクラスを実装します。

public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void processPayment() {
        // クレジットカードでの支払い処理
    }
}

public class PayPalPayment implements PaymentStrategy {
    @Override
    public void processPayment() {
        // PayPalでの支払い処理
    }
}

public class BankTransferPayment implements PaymentStrategy {
    @Override
    public void processPayment() {
        // 銀行振込での支払い処理
    }
}

最後に、支払い方法の選択に応じて適切なStrategyを使用するコードを書きます。

public class PaymentProcessor {
    private PaymentStrategy paymentStrategy;

    public PaymentProcessor(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void executePayment() {
        paymentStrategy.processPayment();
    }
}

このようにすることで、新しい支払い方法が追加されても、条件式を変更する必要がなく、対応するStrategyクラスを追加するだけで済みます。

Strategyパターンの利点

Strategyパターンを使用することで、次のような利点があります。

  1. 可読性の向上: 複雑な条件式が消えるため、コードが非常に読みやすくなります。
  2. 拡張性の向上: 新しいアルゴリズムを追加する際、既存のコードを変更する必要がなく、開発とテストが容易になります。
  3. 保守性の向上: 各Strategyクラスが独立しているため、特定の処理に関する変更やバグ修正が他の部分に影響を与えることがありません。

まとめ

Strategyパターンを用いることで、複雑な条件式を削減し、コードをシンプルで管理しやすいものにすることができます。このパターンは、特に処理が動的に変わる場合や、複数の異なる動作を簡単に切り替えたい場合に有効です。結果として、コードの可読性、拡張性、保守性が向上し、長期的な開発効率が大幅に改善されます。

複数の条件式を一つのメソッドに集約

複数の条件式がコード内で散在していると、理解が難しくなるだけでなく、同じ条件チェックが繰り返される可能性があり、バグの温床になります。こうした問題を解決するためには、関連する条件式を一つのメソッドに集約することが有効です。これにより、コードの再利用性が向上し、メンテナンスが容易になります。

条件式の重複を避ける

条件式が複数の場所で重複している場合、それを一つのメソッドにまとめることで、重複を排除し、コードの冗長性を低減できます。例えば、次のように複数のメソッドで同じ条件が使用されている場合を考えてみます。

public void processUser(User user) {
    if (user.isActive() && user.getRole().equals("ADMIN")) {
        // 特定の処理
    }
}

public void notifyUser(User user) {
    if (user.isActive() && user.getRole().equals("ADMIN")) {
        // 通知処理
    }
}

このようなコードは、isActive()とgetRole().equals("ADMIN")という条件が重複しているため、将来的に条件が変わった場合、複数の箇所で修正が必要になります。

条件式の集約によるメソッド化

このような重複を避けるために、条件式を一つのメソッドに集約します。

public boolean isEligibleForAdminActions(User user) {
    return user.isActive() && user.getRole().equals("ADMIN");
}

こうして集約したメソッドを使うことで、コードは次のようにシンプルになります。

public void processUser(User user) {
    if (isEligibleForAdminActions(user)) {
        // 特定の処理
    }
}

public void notifyUser(User user) {
    if (isEligibleForAdminActions(user)) {
        // 通知処理
    }
}

この方法により、条件が変更された場合でも、一箇所のメソッドを修正するだけで済みます。

再利用性と保守性の向上

条件式を一つのメソッドに集約することで、コードの再利用性が高まります。また、条件の変更が必要になった場合でも、集約メソッドを修正するだけで済むため、保守性も大幅に向上します。これにより、コードの品質が向上し、バグの発生を防ぐことができます。

まとめ

複数の条件式を一つのメソッドに集約することで、コードの重複を排除し、可読性と保守性を向上させることができます。このアプローチは、特に条件式が複数の場所で使用される場合に有効であり、コードの一貫性を保つための重要なテクニックとなります。結果として、コードの品質向上と開発効率の改善が期待できます。

NullチェックとOptionalクラスの活用

Javaプログラミングにおいて、NullPointerException（NPE）は非常に一般的なエラーの一つです。複雑な条件式の中でnullチェックが必要な場合、それがコードを冗長にし、エラーの原因となることがあります。これを避けるために、適切なnullチェックとJava 8で導入されたOptionalクラスを活用することで、コードをシンプルで安全に保つことができます。

従来のnullチェックの問題点

nullチェックは、プログラムが予期しない動作をしないようにするために不可欠ですが、過剰なnullチェックはコードの可読性を低下させることがあります。例えば、次のようなコードを考えてみましょう。

if (user != null && user.getProfile() != null && user.getProfile().getAddress() != null) {
    String city = user.getProfile().getAddress().getCity();
    // さらに処理
}

このようなコードは、nullチェックが増えるほど条件式が複雑になり、何を確認しているのかが一目で分かりにくくなります。

Optionalクラスの活用

Optionalクラスを使用すると、nullチェックをより安全かつ明確に行うことができます。Optionalは値が存在するかもしれないし、存在しないかもしれないことを表現するためのラッパーで、null参照の可能性を明示的に扱うことができます。

次に、先ほどのコードをOptionalを使って書き直してみます。

Optional.ofNullable(user)
        .map(User::getProfile)
        .map(Profile::getAddress)
        .map(Address::getCity)
        .ifPresent(city -> {
            // cityが存在する場合の処理
        });

このコードは、ネストされたnullチェックをチェーンメソッドで置き換え、可読性と安全性を高めています。Optionalのmapメソッドは、値が存在する場合にのみ次の処理を実行し、ifPresentは結果が存在する場合に指定されたアクションを実行します。

Optionalクラスによるコードの利点

Optionalを使用することで、次のような利点があります。

  1. コードの可読性向上: nullチェックが明示的に行われ、何をしているのかが一目で理解しやすくなります。
  2. NullPointerExceptionの防止: Optionalクラスは、null参照を安全に処理するため、予期しないNPEを防ぐことができます。
  3. コードの一貫性: Optionalを使うことで、nullチェックの書き方が統一され、コードの一貫性が保たれます。

Optionalクラスの注意点

Optionalクラスは便利ですが、すべてのケースで使用するべきではありません。例えば、パフォーマンスが重要な場面や、null値が明らかに許容されない場合には、通常のnullチェックが適している場合もあります。また、フィールドやメソッドの引数に対してOptionalを使用することは避けるべきです。

まとめ

Optionalクラスを活用することで、複雑なnullチェックをシンプルにし、コードの可読性と安全性を向上させることができます。特に、複数のメソッドチェーンを使用する場合や、複雑な条件式が存在する場合には、Optionalを導入することで、エラーを減らし、コードのメンテナンス性を高めることができます。

複雑な条件式を解消するリファクタリング手法

複雑な条件式は、コードのメンテナンスを難しくし、バグの温床となる可能性があります。そのため、これらの条件式をシンプルにするリファクタリング手法を適用することで、コードの品質を向上させることが重要です。ここでは、具体的なリファクタリング手法をいくつか紹介し、それぞれの方法がどのように複雑さを軽減するかを説明します。

手法1: 条件式の抽出

複雑な条件式を簡潔にする最も基本的な手法は、条件を意味のあるメソッドに抽出することです。これにより、条件式の意図が明確になり、コードの可読性が向上します。

例えば、次のような条件式があるとします。

if (order.isPaid() && !order.isCancelled() && order.getTotalAmount() > 100) {
    // 特定の処理
}

この条件式をリファクタリングして抽出すると、以下のようになります。

if (isEligibleForProcessing(order)) {
    // 特定の処理
}

private boolean isEligibleForProcessing(Order order) {
    return order.isPaid() && !order.isCancelled() && order.getTotalAmount() > 100;
}

この手法により、条件式の意味が明確になり、他の部分で再利用できるようになります。

手法2: ポリモーフィズムの利用

条件式がクラスのタイプに依存している場合、ポリモーフィズムを活用して条件を解消できます。これにより、条件式をクラスのメソッド内に分散させることで、if-elseやswitch文を削減できます。

例えば、次のようなコードがある場合、

if (employee.getType().equals("Manager")) {
    bonus = calculateManagerBonus(employee);
} else if (employee.getType().equals("Engineer")) {
    bonus = calculateEngineerBonus(employee);
}

ポリモーフィズムを利用して、各Employeeクラスが自分でボーナスを計算するメソッドを持つようにします。

public abstract class Employee {
    public abstract double calculateBonus();
}

public class Manager extends Employee {
    @Override
    public double calculateBonus() {
        // マネージャー向けのボーナス計算
    }
}

public class Engineer extends Employee {
    @Override
    public double calculateBonus() {
        // エンジニア向けのボーナス計算
    }
}

これにより、メインの条件式が不要になり、コードが簡潔になります。

手法3: 条件の否定を避ける

条件式において否定形（例えば、!）を避けることで、条件がより直感的に理解できるようになります。否定形を使うと、頭の中で二重に考えなければならず、ミスを誘発しやすくなります。

例えば、次の条件式を、

if (!isClosed) {
    // 処理
}

以下のように書き換えることで、理解しやすくなります。

if (isOpen) {
    // 処理
}

これは単純な例ですが、複雑な条件式では特に効果的です。

手法4: ガード節の使用

複雑な条件式を解消するもう一つの方法として、ガード節（Guard Clauses）を使用することが挙げられます。これは、早期リターンを行うことで、メインのロジックをシンプルに保つ手法です。

例えば、次のようなネストされた条件式がある場合、

if (user != null) {
    if (user.isActive()) {
        if (user.hasValidSubscription()) {
            // メインの処理
        }
    }
}

これをガード節を使ってリファクタリングすると、

if (user == null) return;
if (!user.isActive()) return;
if (!user.hasValidSubscription()) return;

// メインの処理

これにより、メインの処理部分が明確になり、コードが読みやすくなります。

まとめ

複雑な条件式を解消するためには、条件式の抽出、ポリモーフィズムの利用、否定の避け、ガード節の使用などのリファクタリング手法が有効です。これらの手法を適用することで、コードの可読性、保守性が向上し、エラーの発生を防ぐことができます。リファクタリングを積極的に行い、シンプルで理解しやすいコードを維持することが、長期的なプロジェクト成功の鍵となります。

演習問題と応用例

Javaで複雑な条件式をシンプルに保つためのテクニックを理解するには、実際に手を動かして練習することが重要です。ここでは、いくつかの演習問題と応用例を通して、これまでに学んだ手法を実践し、理解を深めていただきます。

演習問題1: 条件式の分割とメソッド化

次のコードには複雑な条件式が含まれています。これを分割し、メソッド化してリファクタリングしてください。

public void processOrder(Order order) {
    if (order != null && order.isPaid() && order.getTotalAmount() > 500 && order.getCustomer() != null && order.getCustomer().isPremiumMember()) {
        // 特定の処理
    }
}

解答例

public void processOrder(Order order) {
    if (isEligibleForProcessing(order)) {
        // 特定の処理
    }
}

private boolean isEligibleForProcessing(Order order) {
    return order != null && order.isPaid() && order.getTotalAmount() > 500 && isPremiumCustomer(order.getCustomer());
}

private boolean isPremiumCustomer(Customer customer) {
    return customer != null && customer.isPremiumMember();
}

このリファクタリングにより、コードの可読性が向上し、条件式の意図が明確になります。

演習問題2: Optionalクラスの活用

次のコードでは、ネストされたnullチェックを使用しています。これをOptionalクラスを用いてリファクタリングしてください。

public String getCustomerCity(Order order) {
    if (order != null) {
        Customer customer = order.getCustomer();
        if (customer != null) {
            Address address = customer.getAddress();
            if (address != null) {
                return address.getCity();
            }
        }
    }
    return "Unknown";
}

解答例

public String getCustomerCity(Order order) {
    return Optional.ofNullable(order)
            .map(Order::getCustomer)
            .map(Customer::getAddress)
            .map(Address::getCity)
            .orElse("Unknown");
}

この方法により、nullチェックの複雑さが軽減され、コードが簡潔になります。

演習問題3: Strategyパターンの適用

次のコードでは、複数の支払い方法に対する条件分岐が存在します。これをStrategyパターンを使ってリファクタリングしてください。

public void processPayment(String paymentType) {
    if (paymentType.equals("CreditCard")) {
        processCreditCardPayment();
    } else if (paymentType.equals("PayPal")) {
        processPayPalPayment();
    } else if (paymentType.equals("BankTransfer")) {
        processBankTransferPayment();
    }
}

解答例

public interface PaymentStrategy {
    void processPayment();
}

public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void processPayment() {
        // クレジットカードでの支払い処理
    }
}

public class PayPalPayment implements PaymentStrategy {
    @Override
    public void processPayment() {
        // PayPalでの支払い処理
    }
}

public class BankTransferPayment implements PaymentStrategy {
    @Override
    public void processPayment() {
        // 銀行振込での支払い処理
    }
}

public class PaymentProcessor {
    private PaymentStrategy paymentStrategy;

    public PaymentProcessor(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void executePayment() {
        paymentStrategy.processPayment();
    }
}

これにより、支払い方法の追加が容易になり、条件分岐の複雑さが解消されます。

応用例: Enumとディシジョンテーブルの組み合わせ

以下のシナリオで、Enumとディシジョンテーブルを組み合わせたコードを作成してください。

シナリオ: ユーザーの状態（アクティブ、非アクティブ、バン済み）とサブスクリプション状態（有効、無効）に応じて、異なるメッセージを表示するシステムを作成します。

解答例

public enum UserStatus {
    ACTIVE,
    INACTIVE,
    BANNED
}

public enum SubscriptionStatus {
    VALID,
    INVALID
}

public class User {
    private UserStatus status;
    private SubscriptionStatus subscriptionStatus;

    // コンストラクタ、ゲッター、セッター
}

public class MessageService {
    public String getMessage(User user) {
        if (user.getStatus() == UserStatus.BANNED) {
            return "アカウントがバンされています";
        }
        if (user.getStatus() == UserStatus.INACTIVE) {
            return "アカウントが非アクティブです";
        }
        if (user.getSubscriptionStatus() == SubscriptionStatus.INVALID) {
            return "サブスクリプションが無効です";
        }
        return "ようこそ！";
    }
}

この例では、Enumを使用してユーザーの状態とサブスクリプションの状態を管理し、複雑な条件式をシンプルにしています。

まとめ

演習問題と応用例を通じて、複雑な条件式をシンプルに保つためのテクニックを実践的に理解できました。これらのテクニックを活用することで、コードの可読性が向上し、メンテナンス性が高まり、バグの発生を防ぐことができます。これらの方法を実際のプロジェクトで積極的に取り入れることが、良質なコードを書くための鍵となります。

まとめ

本記事では、Javaで複雑な条件式をシンプルに保つためのさまざまなテクニックを紹介しました。条件式の分割とメソッド化、ディシジョンテーブルの活用、EnumやStrategyパターンの適用、Optionalクラスによるnullチェックの改善、そしてリファクタリング手法を通じて、コードの可読性、保守性を向上させる具体的な方法を学びました。これらのテクニックを実践することで、バグの発生を防ぎ、効率的かつ効果的なコードを書くことが可能になります。複雑さを排除し、シンプルで明確なコードを維持することが、良質なソフトウェア開発の鍵です。

Java
java 条件式 プログラミングベストプラクティス

コメント

コメントする

目次