Javaのアクセス指定子とパッケージの相互作用を徹底解説

Javaプログラミングにおいて、アクセス指定子とパッケージは、コードのセキュリティと可読性を保つ上で非常に重要な要素です。アクセス指定子は、クラスやメソッド、フィールドの可視性を制御し、どの部分が外部から利用可能であるかを決定します。一方、パッケージは、コードの構造を整理し、再利用性を高めるためのツールです。これら二つの要素の相互作用を理解することで、より堅牢でメンテナンス性の高いコードを作成することが可能になります。本記事では、Javaのアクセス指定子とパッケージがどのように連携して動作するかについて、詳細に解説します。

アクセス指定子の基本概念

Javaのアクセス指定子は、クラス、メソッド、フィールドに対するアクセス範囲を制御するためのキーワードです。主に4種類のアクセス指定子があり、それぞれが異なるレベルの可視性を提供します。

public

public指定子を持つクラス、メソッド、またはフィールドは、すべてのパッケージからアクセス可能です。これにより、広く利用されるユーティリティクラスやメソッドを公開することができます。

private

private指定子は、クラス内部のみでのアクセスを許可します。他のクラスやパッケージからは、private指定子が付与されたメンバーにはアクセスできません。これにより、外部に公開したくない実装の詳細を隠すことができます。

protected

protected指定子は、同じパッケージ内のクラス、またはサブクラスからアクセス可能です。クラスの継承関係で親クラスのメソッドやフィールドを保護しつつ、継承先のクラスからは利用できるようにするために使用されます。

デフォルト（パッケージプライベート）

アクセス指定子を明示しない場合、そのメンバーはデフォルトで「パッケージプライベート」となります。同じパッケージ内の他のクラスからはアクセス可能ですが、異なるパッケージからはアクセスできません。これにより、パッケージ内部でのアクセス制御が可能です。

これらの指定子を理解し、適切に使い分けることで、クラス設計の柔軟性とセキュリティを向上させることができます。

パッケージの役割と構造

Javaのパッケージは、関連するクラスやインターフェースをグループ化し、コードの整理と管理を効率化するための仕組みです。また、名前の衝突を防ぎ、大規模なプロジェクトにおけるコードの可読性と再利用性を高める役割も果たします。

パッケージの構造

パッケージは、ディレクトリ構造としてファイルシステムに表現されます。各クラスファイルは、対応するパッケージのディレクトリに格納され、完全修飾名（例：com.example.project.ClassName）によって一意に識別されます。この構造により、異なる開発者が同じ名前のクラスを作成しても、異なるパッケージに属していれば問題なく共存できます。

パッケージの宣言と使用

Javaのソースファイルでは、packageキーワードを使用してパッケージを宣言します。例えば、package com.example.myapp;と宣言すると、そのファイルに含まれるクラスはcom.example.myappパッケージに属します。パッケージ外のクラスを使用する場合は、import文を使用して明示的にそのクラスをインポートします。

パッケージの役割

パッケージは、コードの論理的な分類とアクセス制御を提供します。同じパッケージに属するクラスは、互いにアクセスしやすく、デフォルトのアクセス指定子を利用してパッケージ内での情報隠蔽を実現できます。また、異なるパッケージに属するクラス間でのアクセスは、publicやprotectedの指定子を使用して制御されます。

パッケージを適切に利用することで、プロジェクト全体の構造が明確になり、コードの保守性と可読性が向上します。

アクセス指定子とパッケージの相互作用

Javaにおいて、アクセス指定子とパッケージの組み合わせは、クラスやメンバーへのアクセス制御に大きな影響を与えます。これにより、コードのセキュリティやモジュール性が強化され、異なるパッケージ間での情報のカプセル化が実現されます。

パッケージ内でのアクセス制御

同じパッケージ内のクラス同士は、publicやprotected、デフォルト（パッケージプライベート）のメンバーにアクセス可能です。特にデフォルトアクセスの場合、同一パッケージ内でのクラスメンバーの共有が容易になりますが、パッケージ外からはアクセスできないため、特定の範囲内でのデータ隠蔽が可能です。

デフォルトアクセスとパッケージの関係

デフォルトアクセス指定子は、そのクラスが属するパッケージ内でのみアクセス可能となります。これは、特定のクラスやメソッドをパッケージ内で共有したいが、外部には公開したくない場合に非常に有効です。例えば、同じプロジェクト内のクラス間で緊密に連携する必要があるが、外部APIとしては公開したくないメソッドなどに適用されます。

異なるパッケージ間でのアクセス制御

異なるパッケージに属するクラス間では、public指定子が付与されたメンバーのみがアクセス可能です。protectedメンバーは、継承関係にあるサブクラスからアクセス可能ですが、privateやデフォルトのメンバーはアクセスできません。これにより、パッケージを跨いだアクセスが必要な場合でも、意図しない操作やデータの改変を防ぐことができます。

protectedとパッケージの関係

protected指定子は、同じパッケージ内のクラスと、異なるパッケージでも継承関係にあるサブクラスからアクセス可能です。この特性を利用して、ある程度のカプセル化を維持しつつ、拡張性を持たせることができます。

アクセス指定子とパッケージを適切に組み合わせて使用することで、必要な範囲でのみデータやメソッドを公開し、モジュール性を維持しながらコードのセキュリティを確保することができます。

デフォルトアクセスの注意点

デフォルトアクセス（パッケージプライベート）は、アクセス指定子を明示しない場合に適用され、同じパッケージ内のクラスからのみアクセスが可能になります。これは便利な機能ですが、特に大規模なプロジェクトやチームでの開発においては、いくつかの注意点があります。

パッケージ内の意図的なカプセル化

デフォルトアクセスは、特定のクラスやメソッドをパッケージ内でのみ使用させたい場合に有効です。しかし、意図せずにデフォルトアクセスを使用してしまうと、本来公開すべきメンバーが外部からアクセスできない状態になることがあります。このため、デフォルトアクセスを使用する際は、その意図を明確にしておくことが重要です。

例: デフォルトアクセスによる誤ったカプセル化

たとえば、あるクラスAのメソッドを、クラスBやCから使用することを意図しているが、これらが異なるパッケージに属している場合、デフォルトアクセスではメソッドが外部パッケージから見えなくなります。この場合、publicまたはprotectedのアクセス指定子を付与することが必要です。

パッケージの分割と再構成による影響

プロジェクトが進行する中で、パッケージの再構成やクラスの移動が行われることがあります。デフォルトアクセスはパッケージ内に限定されているため、クラスを別のパッケージに移動した際に、アクセス権が失われるリスクがあります。この場合、アクセスエラーが発生し、修正が必要になるため、パッケージの再構成には注意が必要です。

チーム開発での一貫性の維持

チームで開発を行う場合、アクセス指定子の使用方針を明確にしないと、デフォルトアクセスの濫用や誤用による不整合が生じる可能性があります。特に、異なる開発者が同じパッケージで作業する場合、一貫したアクセス制御ポリシーを設定し、それを遵守することが重要です。

デフォルトアクセスは強力なツールですが、その特性を正しく理解し、適切に使用することが求められます。これにより、意図しないアクセス制御の問題を防ぎ、コードの保守性を向上させることができます。

クラス内でのアクセス指定子の使い分け

Javaクラス内では、アクセス指定子を適切に使い分けることで、クラスの設計を柔軟かつ安全に行うことができます。それぞれの指定子は、クラスのメンバー変数やメソッドに対して異なるレベルのアクセス制御を提供し、データのカプセル化を実現します。

privateの使用: 完全なカプセル化

private指定子は、クラス内部でのみアクセス可能であり、最も厳密なアクセス制御を提供します。クラスの実装詳細を隠蔽し、外部からの直接的な操作を防ぐために使用されます。特に、メンバー変数（フィールド）に対してprivateを使用することで、データの不正な操作を防ぎ、クラスの内部状態を保護します。

例: メンバー変数のカプセル化

public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

上記の例では、nameとageフィールドがprivateに設定され、getNameやsetNameなどのパブリックメソッドを通じてのみアクセス可能です。これにより、データの整合性を維持しつつ、クラスの使用者がデータを操作できるようにします。

publicの使用: 外部への公開

public指定子を使用すると、そのメンバーはクラス外部からもアクセス可能になります。これは、クラスの機能を外部に提供するためのメソッドや定数に使用されます。例えば、ユーティリティクラスのメソッドや、クラスの重要な操作を提供するメソッドなどに適しています。

例: 公開メソッドの定義

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

この例では、addメソッドがpublicとして定義されており、クラスの外部から自由に使用することができます。

protectedの使用: 継承関係でのアクセス制御

protected指定子は、クラス内および同じパッケージ内のクラス、さらにそのクラスを継承したサブクラスからアクセス可能です。これは、クラスを継承して機能を拡張する際に、その基本的な動作を保護しつつ、サブクラスからのアクセスを許可するために使用されます。

例: 継承とprotectedの利用

public class Animal {
    protected void eat() {
        System.out.println("This animal is eating.");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println("The dog barks.");
        eat(); // サブクラスからprotectedメソッドにアクセス可能
    }
}

ここでは、Animalクラスのeatメソッドがprotectedで定義され、Dogクラス内で利用されています。

デフォルト（パッケージプライベート）の使用: パッケージ内のアクセスに限定

デフォルトアクセス指定子（アクセス指定子を明示しない場合）は、同じパッケージ内でのみアクセスが可能です。これは、外部パッケージには公開せず、同じパッケージ内でのみ利用したいクラスやメソッドに対して適用されます。

例: パッケージ内限定のクラス設計

class Helper {
    void assist() {
        System.out.println("Assistance provided.");
    }
}

この例では、Helperクラスとそのメソッドassistがデフォルトアクセスで定義され、同じパッケージ内でのみ利用可能です。

クラス内でこれらのアクセス指定子を使い分けることで、適切なカプセル化とアクセス制御を実現し、クラスの設計がより安全かつ管理しやすくなります。

パッケージ間でのアクセス管理

Javaでは、異なるパッケージに属するクラス間のアクセスを適切に管理することが、プログラムのセキュリティと設計の一貫性を保つために重要です。アクセス指定子によって、クラス間でのデータ共有や機能提供を制御できますが、これを誤ると予期しない動作やセキュリティの脆弱性を招く可能性があります。

public指定子によるパッケージ間のアクセス

public指定子を持つクラスやメンバーは、どのパッケージからでもアクセス可能です。これにより、広く利用されるユーティリティクラスやAPIを公開することができます。ただし、過剰にpublicを使用すると、外部からの不要なアクセスが可能になり、クラスの内部状態を誤って操作されるリスクがあります。

例: 公共APIの公開

package com.example.api;

public class UserService {
    public void registerUser(String username, String password) {
        // ユーザー登録ロジック
    }
}

この例では、UserServiceクラスがpublicとして定義されており、com.example.apiパッケージ外からもアクセス可能です。これにより、他のパッケージやプロジェクトからこのクラスのメソッドを利用できます。

protected指定子と継承の活用

protected指定子は、継承関係にあるサブクラスや同一パッケージ内のクラスからアクセス可能です。異なるパッケージ内であっても、親クラスの機能を継承して利用する場合に便利です。これにより、基本的な動作やデータを継承先クラスで再利用できますが、直接的な外部アクセスは防止されます。

例: 継承によるアクセスの制御

package com.example.base;

public class BaseClass {
    protected void performAction() {
        System.out.println("Action performed by BaseClass.");
    }
}

package com.example.derived;

import com.example.base.BaseClass;

public class DerivedClass extends BaseClass {
    public void execute() {
        performAction(); // 継承関係によりprotectedメソッドにアクセス可能
    }
}

この例では、BaseClassのperformActionメソッドがprotectedとして定義されており、異なるパッケージのDerivedClassで利用されています。

デフォルト（パッケージプライベート）アクセスによるパッケージ内の制限

デフォルトアクセス（アクセス指定子なし）のメンバーは、同一パッケージ内のクラスからのみアクセスできます。このアクセス制御により、特定のパッケージ内でのみ使用されるべきクラスやメソッドを他のパッケージから隠蔽できます。これにより、パッケージを超えた不適切な利用を防ぎ、コードの一貫性を保つことが可能です。

例: パッケージ内の限定アクセス

package com.example.utils;

class InternalHelper {
    void internalMethod() {
        System.out.println("Internal method executed.");
    }
}

この例では、InternalHelperクラスとそのメソッドinternalMethodはデフォルトアクセスで定義されており、com.example.utilsパッケージ内からのみ利用可能です。

異なるパッケージ間のアクセス制御におけるベストプラクティス

異なるパッケージ間でアクセスを制御する際には、以下のポイントに留意することが重要です。

• 必要以上にpublicを使用せず、外部に公開するメンバーを最小限に抑える。
• 継承が必要な場合は、protectedを活用し、必要な範囲だけアクセスを許可する。
• パッケージ内でのみ使用するメンバーはデフォルトアクセスを活用して、カプセル化を徹底する。

これらのベストプラクティスを守ることで、パッケージ間での不正なアクセスを防ぎ、セキュアかつ整然としたコードを維持することができます。

継承とアクセス指定子

Javaにおいて、継承はコードの再利用性を高め、オブジェクト指向設計の基本的な柱の一つです。アクセス指定子は、継承関係におけるクラスメンバーの可視性と利用範囲を制御する重要な要素であり、継承時にどのメンバーがサブクラスから利用できるかを決定します。

public指定子と継承

public指定子を持つクラスメンバーは、どのクラスからもアクセス可能です。継承したサブクラスも例外ではなく、親クラスのpublicメンバーに対して完全なアクセス権を持ちます。これにより、サブクラスは親クラスの公開された機能をそのまま利用したり、オーバーライドしたりできます。

例: publicメンバーの継承

public class ParentClass {
    public void greet() {
        System.out.println("Hello from ParentClass");
    }
}

public class ChildClass extends ParentClass {
    public void displayGreeting() {
        greet(); // 親クラスのpublicメソッドにアクセス
    }
}

この例では、ChildClassがParentClassのgreetメソッドを継承し、そのまま使用しています。

protected指定子と継承

protected指定子を持つメンバーは、同一パッケージ内のクラスおよび異なるパッケージのサブクラスからアクセス可能です。これにより、サブクラスは親クラスの基本的な機能を利用しつつ、外部からのアクセスは制限されます。継承関係におけるprotectedメンバーの使用は、サブクラスに親クラスの内部状態への限定的なアクセスを許可し、カプセル化を保ちながら柔軟性を提供します。

例: protectedメンバーの継承

public class Animal {
    protected void makeSound() {
        System.out.println("Animal sound");
    }
}

public class Dog extends Animal {
    public void bark() {
        makeSound(); // protectedメソッドにアクセス
        System.out.println("Dog barks");
    }
}

この例では、DogクラスがAnimalクラスのmakeSoundメソッドを使用しています。makeSoundはprotectedであり、継承関係にあるDogクラスからのみアクセス可能です。

private指定子と継承

private指定子を持つメンバーは、そのクラス内部からのみアクセス可能であり、サブクラスからもアクセスできません。このため、親クラスのprivateメンバーは継承されるものの、サブクラスからは直接使用できないため、サブクラスで同じ名前のメンバーを定義することも可能です。

例: privateメンバーの非継承

public class Vehicle {
    private void startEngine() {
        System.out.println("Engine started");
    }
}

public class Car extends Vehicle {
    public void drive() {
        // startEngine(); // エラー: privateメソッドにはアクセスできない
        System.out.println("Car is driving");
    }
}

この例では、CarクラスがVehicleクラスのstartEngineメソッドにアクセスしようとしていますが、startEngineがprivateであるため、アクセスできません。

デフォルト（パッケージプライベート）指定子と継承

デフォルトアクセス指定子（アクセス指定子なし）のメンバーは、同一パッケージ内のクラスからのみアクセス可能で、異なるパッケージのサブクラスからはアクセスできません。このため、デフォルトアクセスのメンバーは、同じパッケージ内の継承に対しては利用できますが、パッケージを超えた継承ではアクセスできなくなります。

例: デフォルトメンバーの継承

package com.example.vehicles;

class Vehicle {
    void stop() {
        System.out.println("Vehicle stopped");
    }
}

public class Bike extends Vehicle {
    public void park() {
        stop(); // 同じパッケージ内のデフォルトメソッドにアクセス
    }
}

この例では、BikeクラスがVehicleクラスのstopメソッドを使用しています。stopメソッドはデフォルトアクセスで定義されているため、com.example.vehiclesパッケージ内でのみアクセス可能です。

継承とアクセス指定子の適切な組み合わせは、クラスの再利用性を高めるだけでなく、セキュリティやカプセル化の観点からも非常に重要です。適切なアクセスレベルを設定することで、必要な機能をサブクラスに提供しつつ、不必要な部分を隠蔽することが可能になります。

モジュールシステムとの関係

Java 9で導入されたモジュールシステムは、従来のパッケージに加えて、さらなるカプセル化と制御を提供する仕組みです。モジュールシステムを使用すると、アプリケーションを複数のモジュールに分割し、モジュール間での依存関係を明確に定義できます。この新しいレベルの構造により、アクセス指定子の動作も若干変化し、さらに細かい制御が可能となります。

モジュールの基本構造

モジュールシステムでは、Javaアプリケーションはmodule-info.javaというファイルを使ってモジュール化されます。このファイルにモジュールの名前、依存する他のモジュール、エクスポートするパッケージなどを記述します。これにより、モジュール間でのパッケージの公開範囲を厳密に制御できます。

例: モジュール宣言の基本

module com.example.module {
    requires java.logging;
    exports com.example.module.api;
}

この例では、com.example.moduleモジュールがjava.loggingモジュールに依存しており、自身のcom.example.module.apiパッケージを外部に公開しています。

アクセス指定子とモジュールの相互作用

モジュールシステム導入後も、アクセス指定子は基本的に従来のまま機能しますが、publicとprotectedの動作にモジュールの影響が加わります。具体的には、public指定子を持つクラスやメンバーであっても、モジュールがそのパッケージをエクスポートしていない場合、他のモジュールからはアクセスできません。

例: モジュールによるアクセス制御

// module-info.java
module com.example.module {
    exports com.example.module.api; // このパッケージだけ公開
}

// APIクラス
package com.example.module.api;

public class PublicApi {
    public void performAction() {
        System.out.println("Action performed");
    }
}

// 内部クラス
package com.example.module.internal;

public class InternalClass {
    public void secretAction() {
        System.out.println("Secret action performed");
    }
}

この例では、PublicApiクラスはcom.example.module.apiパッケージに属し、外部モジュールからもアクセス可能です。しかし、InternalClassクラスはcom.example.module.internalパッケージに属し、モジュールがこのパッケージをエクスポートしていないため、外部からはアクセスできません。

モジュールシステムにおけるprotected指定子

protected指定子のメンバーは、継承関係にあるサブクラスからアクセス可能ですが、モジュールシステムの導入により、サブクラスが異なるモジュールに属している場合には、そのパッケージがエクスポートされていなければアクセスできません。これにより、モジュールシステムはさらなるセキュリティとカプセル化を提供します。

例: モジュールとprotectedの制限

// module-info.java
module com.example.module {
    exports com.example.module.api;
    // internalはエクスポートされない
}

// APIクラス
package com.example.module.api;

public class BaseClass {
    protected void protectedMethod() {
        System.out.println("Protected method");
    }
}

// 内部クラス
package com.example.module.internal;

public class DerivedClass extends BaseClass {
    public void useProtectedMethod() {
        protectedMethod(); // エラー: エクスポートされていないためアクセス不可
    }
}

この例では、DerivedClassはBaseClassを継承していますが、BaseClassのprotectedMethodにはアクセスできません。これは、DerivedClassが異なるパッケージ（com.example.module.internal）に属しており、そのパッケージがエクスポートされていないためです。

モジュールシステムの利点と課題

モジュールシステムの導入により、Javaアプリケーションは従来よりも堅牢でセキュアな構造を持つことができます。これにより、複雑なプロジェクトでも依存関係を明確にし、不要なパッケージやクラスの外部公開を防ぐことが可能です。しかし、一方で、モジュールの設計や設定には慎重な計画と理解が必要であり、従来の単一モジュールでの開発に慣れている開発者にとっては新たな学習が必要となります。

モジュールシステムを活用することで、大規模なJavaプロジェクトでも高いセキュリティと整理されたコード構造を維持しながら開発を進めることができます。

よくあるエラーとその対処法

Javaのアクセス指定子とパッケージに関連するエラーは、開発中によく遭遇する問題の一つです。これらのエラーは、コードの構造やモジュールシステムの理解不足に起因することが多く、適切な対処法を知ることで、開発効率を向上させることができます。このセクションでは、アクセス指定子とパッケージに関連する一般的なエラーと、その解決方法を紹介します。

エラー1: 「クラスがパブリックではありません」

このエラーは、クラスが同一パッケージ内でない場合に発生します。アクセス指定子がデフォルトのまま（パッケージプライベート）であるため、他のパッケージからそのクラスにアクセスできないことが原因です。

解決方法

クラスにpublic指定子を追加することで、他のパッケージからアクセス可能にします。例：

// エラーが発生するコード
package com.example.app;

class MyClass {
    public void doSomething() {
        // 実装
    }
}

// 修正後のコード
package com.example.app;

public class MyClass {
    public void doSomething() {
        // 実装
    }
}

エラー2: 「アクセスが許可されていません」

このエラーは、privateまたはデフォルトアクセスのメンバーに対して、クラス外部からアクセスしようとした場合に発生します。

解決方法

• privateメンバーにアクセスする必要がある場合、publicまたはprotectedのゲッターメソッドを追加します。
• クラス全体の設計を見直し、アクセスが必要なメンバーを公開する適切な手段を検討します。

// エラーが発生するコード
package com.example.app;

public class MyClass {
    private int value;

    public void printValue() {
        System.out.println(value);
    }
}

// 修正後のコード
package com.example.app;

public class MyClass {
    private int value;

    public int getValue() { // ゲッターメソッドを追加
        return value;
    }

    public void printValue() {
        System.out.println(getValue());
    }
}

エラー3: 「モジュール ‘XXX’ にモジュール ‘YYY’ がありません」

Javaモジュールシステムを使用している場合、このエラーは、あるモジュールが別のモジュールを参照しているにもかかわらず、そのモジュールがmodule-info.javaでrequiresされていない場合に発生します。

解決方法

module-info.javaファイルに依存するモジュールを追加し、明示的にrequires宣言を行います。

// エラーが発生するmodule-info.java
module com.example.app {
    // 依存モジュールが記載されていない
}

// 修正後のmodule-info.java
module com.example.app {
    requires com.example.utils; // 依存モジュールを追加
}

エラー4: 「パッケージがエクスポートされていません」

このエラーは、Javaモジュールシステムで、あるパッケージがエクスポートされていないために他のモジュールからアクセスできない場合に発生します。

解決方法

module-info.javaファイルで、該当するパッケージをエクスポートします。

// エラーが発生するmodule-info.java
module com.example.module {
    // パッケージがエクスポートされていない
}

// 修正後のmodule-info.java
module com.example.module {
    exports com.example.module.api; // パッケージをエクスポート
}

エラー5: 「オーバーライド不可能なメソッド」

privateまたはfinalで定義されたメソッドをサブクラスでオーバーライドしようとすると、このエラーが発生します。

解決方法

• privateメソッドはサブクラスでオーバーライドできないため、アクセスレベルをprotectedまたはpublicに変更するか、オーバーライドを諦めます。
• finalメソッドはオーバーライドできないため、オーバーライドが必要な場合は、final修飾子を削除します。

// エラーが発生するコード
public class ParentClass {
    private void method() {
        // 実装
    }
}

public class ChildClass extends ParentClass {
    @Override
    public void method() { // エラー: privateメソッドはオーバーライド不可
        // 実装
    }
}

// 修正後のコード
public class ParentClass {
    protected void method() { // protectedに変更
        // 実装
    }
}

public class ChildClass extends ParentClass {
    @Override
    public void method() {
        // 実装
    }
}

これらのエラーと対処法を理解し、実践することで、Javaのアクセス指定子やパッケージに関する問題を迅速に解決し、より堅牢でメンテナンス性の高いコードを書くことができるようになります。

練習問題と解説

Javaのアクセス指定子とパッケージに関する理解を深めるために、いくつかの練習問題を解いてみましょう。これらの問題は、理論を実際のコードに適用する能力を養うことを目的としています。解答例も含めていますので、挑戦してみてください。

練習問題1: アクセス指定子の影響

以下のコードを見て、どのクラスがどのメソッドにアクセスできるかを考えてみてください。

package com.example.package1;

public class ClassA {
    private void methodPrivate() {
        System.out.println("Private method in ClassA");
    }

    void methodDefault() {
        System.out.println("Default method in ClassA");
    }

    protected void methodProtected() {
        System.out.println("Protected method in ClassA");
    }

    public void methodPublic() {
        System.out.println("Public method in ClassA");
    }
}

package com.example.package2;

import com.example.package1.ClassA;

public class ClassB extends ClassA {
    public void testMethods() {
        // methodPrivate(); // アクセス不可
        // methodDefault(); // アクセス不可
        methodProtected(); // アクセス可能
        methodPublic(); // アクセス可能
    }
}

public class ClassC {
    public void testMethods() {
        ClassA obj = new ClassA();
        // obj.methodPrivate(); // アクセス不可
        // obj.methodDefault(); // アクセス不可
        // obj.methodProtected(); // アクセス不可
        obj.methodPublic(); // アクセス可能
    }
}

解答例と解説:

• methodPrivate() は ClassA の中でのみアクセス可能です。
• methodDefault() は com.example.package1 パッケージ内でのみアクセス可能で、ClassB や ClassC からはアクセスできません。
• methodProtected() は ClassB からアクセス可能ですが、ClassC からはアクセスできません。
• methodPublic() はすべてのクラスからアクセス可能です。

練習問題2: パッケージとアクセス制御

以下のコードで、どの部分がエラーとなるかを見つけてください。

package com.example.package1;

class PackagePrivateClass {
    void display() {
        System.out.println("Package-private class in package1");
    }
}

public class ClassD {
    public void show() {
        PackagePrivateClass obj = new PackagePrivateClass();
        obj.display();
    }
}

package com.example.package2;

import com.example.package1.PackagePrivateClass;

public class ClassE {
    public void display() {
        PackagePrivateClass obj = new PackagePrivateClass();
        obj.display(); // ここでエラーが発生します
    }
}

解答例と解説:

• PackagePrivateClass はデフォルトアクセス（パッケージプライベート）のため、com.example.package2 パッケージ内の ClassE からはアクセスできません。このクラスは com.example.package1 パッケージ内でのみ使用可能です。

練習問題3: モジュールのエクスポート

次のコードを見て、モジュールmodule1が他のモジュールからUtilityClassを使用できるようにするためには、どうすればよいか考えてください。

// module-info.java in module1
module com.example.module1 {
    requires com.example.module2;
}

// module-info.java in module2
module com.example.module2 {
    // エクスポート設定なし
}

// UtilityClass in module2
package com.example.module2.utils;

public class UtilityClass {
    public void utilityMethod() {
        System.out.println("Utility method");
    }
}

// ClassF in module1
package com.example.module1.app;

import com.example.module2.utils.UtilityClass;

public class ClassF {
    public void useUtility() {
        UtilityClass util = new UtilityClass();
        util.utilityMethod(); // エラーが発生します
    }
}

解答例と解説:

• UtilityClass が module1 で使用されるためには、module2 の module-info.java にexports文を追加して、com.example.module2.utilsパッケージを公開する必要があります。

// 修正後のmodule-info.java in module2
module com.example.module2 {
    exports com.example.module2.utils;
}

練習問題4: アクセス制御の再設計

次のシナリオでは、現在の設計にはセキュリティ上の懸念があります。どのように改善できるか考えてみましょう。

シナリオ:
Account クラスは balance というフィールドを持っていますが、現在は public で宣言されており、どのクラスからでもアクセス可能です。これにより、balance が意図せず変更される可能性があります。セキュリティを改善するために、どのように設計を変更しますか？

public class Account {
    public double balance;
}

解答例と解説:

• balance フィールドを private にして、外部からの直接アクセスを防ぎ、getBalance() と setBalance() メソッドを通じてアクセスさせるようにします。これにより、データの整合性を保ちながらセキュリティを向上させることができます。

public class Account {
    private double balance;

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        if (balance >= 0) {
            this.balance = balance;
        }
    }
}

これらの練習問題を通じて、Javaのアクセス指定子とパッケージの使用方法に関する理解を深め、より安全で効果的なコードを書くスキルを向上させましょう。

まとめ

本記事では、Javaにおけるアクセス指定子とパッケージの相互作用について詳細に解説しました。アクセス指定子（public, private, protected, デフォルト）の役割や、パッケージ内外でのクラスやメンバーの可視性の制御について学び、モジュールシステムとの関係も理解しました。これにより、より堅牢でセキュアなJavaアプリケーションの開発が可能になります。アクセス制御を適切に行うことで、コードの再利用性を高め、セキュリティを強化することができます。今後の開発において、これらの知識を活かして、保守性と信頼性の高いコードを構築してください。