オブジェクト指向プログラミングの基礎となるクラスについて、基本的な使用方法を解説する。
目次
クラスの定義方法とアクセス修飾子
クラスはJavaプログラミングの基本単位であり、以下のように定義する。
// publicクラスの場合、ファイル名は必ずクラス名と一致させる必要がある
public class Calculator {
// クラスの内容をここに記述
}アクセス修飾子には以下の4種類が存在する。
// 同一パッケージ内からのみアクセス可能
class InternalCalculator {
// クラスの内容
}
// すべてのクラスからアクセス可能
public class PublicCalculator {
// クラスの内容
}
// finalキーワードを使用すると継承不可となる
final class FinalCalculator {
// クラスの内容
}
// abstractキーワードで抽象クラスを定義
abstract class AbstractCalculator {
// クラスの内容
}フィールドとメソッドの宣言
クラス内部では、フィールドとメソッドを宣言することができる。
public class Employee {
// フィールド（インスタンス変数）の宣言
private String name; // 名前を格納
private int age; // 年齢を格納
// メソッドの宣言
public void setName(String name) {
// thisキーワードを使用してフィールドとパラメータを区別
this.name = name;
}
public String getName() {
return name;
}
// 複数のパラメータを受け取るメソッド
public void updateProfile(String name, int age) {
this.name = name;
this.age = age;
}
}アクセス修飾子をフィールドに適用する場合、以下の可視性制御が可能である。
- private -> クラス内からのみアクセス可能
- protected -> 同一パッケージ及び継承したクラスからアクセス可能
- public -> すべてのクラスからアクセス可能
- 修飾子なし -> 同一パッケージからのみアクセス可能（これはデフォルトアクセス、またはパッケージプライベートと呼ばれる）
// 例：デフォルトアクセスの例
class Example {
String defaultField; // アクセス修飾子を指定しない
private String privateField; // privateを指定
protected String protectedField; // protectedを指定
public String publicField; // publicを指定
}コンストラクタの実装方法
コンストラクタはクラスのインスタンス化時に呼び出される特殊なメソッドである。
public class Product {
private String name;
private int price;
// デフォルトコンストラクタ
public Product() {
// 初期化処理
this.name = "未設定";
this.price = 0;
}
// パラメータ付きコンストラクタ
public Product(String name, int price) {
// 引数を用いた初期化
this.name = name;
this.price = price;
}
// コンストラクタのオーバーロード
public Product(String name) {
// 他のコンストラクタを呼び出す
this(name, 0);
}
}なお、コンストラクタにおいて以下の点に注意が必要である。
- コンストラクタ名はクラス名と完全に一致させる
- 戻り値の型は記述しない
- this()を用いて他のコンストラクタを呼び出す場合、そのコンストラクタ内の最初の文として記述する必要がある。他のステートメントをthis()の前に配置するとコンパイルエラーとなる
クラスの継承と実装
クラスの基本的な使い方を踏まえ、より高度な概念である継承と実装について解説する。これら機能により、コードの再利用性と保守性が向上する。
継承の基本と super キーワードの活用
継承は既存のクラスの機能を引き継ぎ、新しい機能を追加するための仕組みである。
// 基底クラス（親クラス）の定義
public class Animal {
private String name; // プライベートフィールドとして定義
// 親クラスのコンストラクタ
public Animal(String name) {
this.name = name;
}
// 名前の取得用アクセサメソッド
protected String getName() {
return name;
}
// 名前の設定用アクセサメソッド
protected void setName(String name) {
this.name = name;
}
public void makeSound() {
System.out.println("何らかの鳴き声");
}
}
// 派生クラス（子クラス）の定義
public class Dog extends Animal {
private String breed; // 犬種を追加
// superキーワードで親クラスのコンストラクタを呼び出す
public Dog(String name, String breed) {
super(name); // 必ず最初に呼び出す
this.breed = breed;
}
// メソッドのオーバーライド
@Override // アノテーションを付けることで意図的な上書きであることを明示
public void makeSound() {
super.makeSound(); // 親クラスのメソッドも実行可能
System.out.println(getName() + "がワン！と鳴きました"); // アクセサメソッド経由でnameにアクセス
}
}インターフェースの実装方法
インターフェースは、クラスが持つべきメソッドを定義する契約のような役割を果たす。
// インターフェースの定義
public interface Flyable {
// 暗黙的にpublic abstractとなる
void fly();
// Java 8以降はdefaultメソッドも定義可能
default void glide() {
System.out.println("滑空中");
}
}
// インターフェースの実装
public class Bird extends Animal implements Flyable {
public Bird(String name) {
super(name);
}
// インターフェースで定義されたメソッドは必ず実装
@Override
public void fly() {
System.out.println(name + "が飛んでいる");
}
}抽象クラスの活用方法
抽象クラスは、共通の機能を持ちながら、一部の実装を派生クラスに委ねるための仕組みである。
// 抽象クラスの定義
public abstract class Vehicle {
protected String model;
protected int year;
// 通常のメソッド
public void displayInfo() {
System.out.println("型式: " + model + ", 年式: " + year);
}
// 抽象メソッド（実装は派生クラスに強制）
public abstract void start();
}
// 抽象クラスの実装
public class Car extends Vehicle {
public Car(String model, int year) {
this.model = model;
this.year = year;
}
// 抽象メソッドの実装は必須
@Override
public void start() {
System.out.println("エンジンを始動");
}
}これら継承と実装の機能を適切に組み合わせることで、保守性の高い柔軟なプログラムを設計することが可能となる。
クラスのインスタンス化と操作
前章で学んだ継承と実装の概念を踏まえ、実際のクラスの利用方法について解説する。
オブジェクトの生成と初期化
クラスからインスタンス（オブジェクト）を生成する方法について説明する。
public class UserAccount {
private String userId;
private String email;
// コンストラクタによる初期化
public UserAccount(String userId, String email) {
this.userId = userId;
this.email = email;
}
}
public class AccountManager {
public static void main(String[] args) {
// newキーワードによるインスタンス生成
UserAccount account1 = new UserAccount("user123", "user@example.com");
// 変数宣言と初期化の分離も可能
UserAccount account2;
account2 = new UserAccount("user456", "another@example.com");
}
}メソッドの呼び出しとパラメータの受け渡し
インスタンスメソッドの呼び出し方とパラメータの受け渡しについて解説する。
public class Calculator {
// 計算結果を保持するフィールド
private double result;
// パラメータを受け取るメソッド
public void add(double value) {
result += value; // 現在の結果に値を加算
}
// 複数のパラメータを受け取るメソッド
public void divide(double numerator, double denominator) {
if (denominator == 0) {
throw new IllegalArgumentException("除数は0以外を指定してください");
}
result = numerator / denominator;
}
// 戻り値のあるメソッド
public double getResult() {
return result;
}
}
// メソッドの使用例
public class CalculatorTest {
public static void main(String[] args) {
Calculator calc = new Calculator();
// メソッドの連続呼び出し
calc.add(5.0);
calc.add(3.0);
System.out.println("結果: " + calc.getResult()); // 8.0が出力される
// 複数パラメータの渡し方
calc.divide(10.0, 2.0);
System.out.println("結果: " + calc.getResult()); // 5.0が出力される
}
}staticメンバーの活用方法
インスタンス生成を必要としないstaticメンバーについて説明する。
public class MathUtils {
// 定数の定義
public static final double PI = 3.14159;
// インスタンス化防止のための private コンストラクタ
private MathUtils() {
throw new AssertionError("インスタンス化は禁止されています");
}
// staticメソッドの定義
public static int factorial(int n) {
if (n < 0) {
throw new IllegalArgumentException("負の数は計算できません");
}
int result = 1;
for (int i = 2; i <= n; i++) {
result *= i;
}
return result;
}
// staticブロックによる初期化
private static Map<String, Double> constants;
static {
constants = new HashMap<>();
constants.put("e", 2.71828);
constants.put("phi", 1.61803);
}
public static double getConstant(String name) {
return constants.getOrDefault(name, 0.0);
}
}staticメンバーはクラスに紐づくため、インスタンス生成なしでMathUtils.PIやMathUtils.factorial(5)のように直接呼び出すことが可能である。
クラスの応用的な使い方
基本的な実装方法を理解したところで、より実践的なクラスの活用方法について解説する。手法を習得することにより、より柔軟で保守性の高いコードを実現することが可能となる。
内部クラスとその活用シーン
内部クラスとは、クラス内部に定義される別のクラスである。外部クラスのメンバーに密接にアクセスする必要がある場合に特に有用である。
public class FileProcessor {
private String filePath;
// 非staticな内部クラス
private class FileReader {
// 外部クラスのメンバーに直接アクセス可能
public String readContent() {
System.out.println("ファイル読み込み: " + filePath);
return "ファイル内容";
}
}
// static内部クラス
public static class FileValidator {
public static boolean isValidPath(String path) {
return path != null && path.endsWith(".txt");
}
}
// 内部クラスの使用例
public void processFile() {
FileReader reader = new FileReader();
reader.readContent();
}
}ジェネリクスを使用したクラス設計
ジェネリクスを活用することで、型安全性を保ちながら汎用的なクラスを実装することが可能となる。
// 汎用的なデータコンテナの実装
public class DataContainer<T> {
private T data; // 任意の型のデータを格納
public DataContainer(T data) {
this.data = data;
}
// 型パラメータに制約を設ける例
public <U extends Number> double calculateSum(U additional) {
if (data instanceof Number) {
return ((Number) data).doubleValue() + additional.doubleValue();
}
throw new IllegalStateException("数値データ以外では計算できません");
}
// ワイルドカードの使用例
public boolean compareWith(DataContainer<?> other) {
return data.equals(other.data);
}
}シングルトンパターンの実装
シングルトンパターンは、クラスのインスタンスが1つのみ存在することを保証する設計パターンである。
public class DatabaseConnection {
// volatile修飾子でマルチスレッド環境での可視性を保証
private static volatile DatabaseConnection instance;
// finalフィールドは一度初期化されると変更不可
private final String connectionString;
// privateコンストラクタでインスタンス化を制御
private DatabaseConnection() {
// finalフィールドはコンストラクタで一度だけ初期化される
// 以降、この接続文字列は変更できない
this.connectionString = "jdbc:database://localhost:5432/mydb";
}
// Double-Checked Lockingによる効率的なインスタンス取得
public static DatabaseConnection getInstance() {
if (instance == null) {
synchronized (DatabaseConnection.class) {
if (instance == null) {
instance = new DatabaseConnection();
}
}
}
return instance;
}
public void connect() {
// connectionStringはfinalなので、このメソッド内でも変更不可
System.out.println("データベースに接続: " + connectionString);
}
}
// 使用例
DatabaseConnection.getInstance().connect();これら応用的な実装パターンを理解することで、より効率的で保守性の高いコードを作成することが可能となる。
クラス設計のベストプラクティス
これまでの基本的な実装方法と応用的な使用方法を踏まえ、実務で活用できる効果的なクラス設計の手法について解説する。
カプセル化の実現方法
カプセル化とは、データと操作を1つのユニットにまとめ、外部からの不適切なアクセスを防ぐ設計手法である。
public class BankAccount {
// privateフィールドによるデータの隠蔽
private String accountNumber;
private double balance;
private static final double MINIMUM_BALANCE = 1000.0;
// コンストラクタでの初期化
public BankAccount(String accountNumber) {
this.accountNumber = accountNumber;
this.balance = MINIMUM_BALANCE;
}
// バリデーションを含むセッター
public void deposit(double amount) {
if (amount <= 0) {
throw new IllegalArgumentException("入金額は正の値である必要があります");
}
this.balance += amount;
}
// ビジネスロジックを含むメソッド
public boolean withdraw(double amount) {
double newBalance = balance - amount;
if (newBalance < MINIMUM_BALANCE) {
return false; // 最低残高を下回る場合は引き出し不可
}
this.balance = newBalance;
return true;
}
// 読み取り専用のゲッター
public double getBalance() {
return this.balance;
}
// 口座番号の読み取り専用のゲッター
public String getAccountNumber() {
return this.accountNumber;
}
}メソッドのオーバーライドとオーバーロード
メソッドの再定義と多重定義を適切に使用することで、柔軟な機能拡張が可能となる。
public class PaymentProcessor {
// 基本的な支払い処理
public boolean processPayment(double amount) {
System.out.println("標準的な支払い処理: " + amount);
return true;
}
// パラメータの型が異なるオーバーロード
public boolean processPayment(String currency, double amount) {
// 通貨変換処理を追加
double convertedAmount = convertCurrency(currency, amount);
return processPayment(convertedAmount);
}
// 複数パラメータによるオーバーロード
public boolean processPayment(double amount, String paymentMethod) {
System.out.println("支払方法: " + paymentMethod);
return processPayment(amount);
}
private double convertCurrency(String currency, double amount) {
// 通貨変換ロジック
return amount * getExchangeRate(currency);
}
private double getExchangeRate(String currency) {
// 為替レート取得ロジック
return 1.0;
}
}クラス間の依存関係の管理
適切な依存関係の管理により、保守性と拡張性の高いシステムを実現することが可能となる。
// インターフェースによる依存性の抽象化
public interface NotificationService {
void sendNotification(String message);
}
// 具体的な実装
public class EmailNotification implements NotificationService {
@Override
public void sendNotification(String message) {
// メール送信の実装
System.out.println("メール送信: " + message);
}
}
// 依存性注入を使用したクラス設計
public class OrderProcessor {
private final NotificationService notificationService;
// コンストラクタインジェクション
public OrderProcessor(NotificationService notificationService) {
this.notificationService = notificationService;
}
public void processOrder(String orderId) {
// 注文処理ロジック
notificationService.sendNotification("注文 " + orderId + " が処理されました");
}
}ベストプラクティスを適切に組み合わせることで、保守性が高く、拡張性のあるシステムを構築することが可能となる。本ガイドラインに従うことで、効率的かつ堅牢なJavaアプリケーションの開発を実現できる。
以上。