クラスは、オブジェクト指向プログラミング（OOP）において、データ（フィールド）と操作（メソッド）を組み合わせた抽象データ型を定義するための重要な構造です。
以下に、クラスの特徴をいくつか挙げてみます。
カプセル化（Encapsulation）:
クラスは、データとそれを操作するメソッドを1つの単位にまとめることができます。これにより、データの内部実装を隠蔽し、外部からの直接アクセスを制御することができます。カプセル化により、データの整合性やセキュリティを向上させることができます。
継承（Inheritance）:
クラスは、他のクラスから継承することができます。継承により、既存のクラスの機能を再利用し、新しいクラスを定義することができます。これにより、コードの再利用性が向上し、階層的な関係を持つクラスの構造を簡潔に表現することができます。
ポリモーフィズム（Polymorphism）:
クラスの継承とメソッドのオーバーライドにより、同じメソッド名を持つ異なるクラスのメソッドが異なる動作をすることができます。これにより、同じインタフェースを持つ複数のオブジェクトを同じように扱うことができ、柔軟性と拡張性が向上します。
抽象化（Abstraction）:
クラスは、実世界のエンティティや概念をモデル化するための抽象化を提供します。具体的な実装の詳細を隠蔽し、重要な機能や属性に焦点を当てることができます。これにより、問題をよりシンプルに捉えることができます。
インスタンス化（Instantiation）:
クラスは、オブジェクト（インスタンス）を生成するための設計図として機能します。クラスをインスタンス化することで、実際のデータを持つオブジェクトを生成し、操作することができます。
クラスは、オブジェクト指向プログラミングの基本的な概念であり、コードの構造化、再利用性の向上、保守性の向上などの多くの利点を提供します。
Javaのクラスは、オブジェクト指向プログラミングの基本的な構成要素です。
クラスは、オブジェクトの属性（フィールド）と振る舞い（メソッド）を定義します。
以下は、Javaのクラスの基本的な構造と機能についての概要です：
Javaのクラスは、class キーワードを使用して定義されます。クラスの定義は次のようになります：  
/**
 * MyClass クラスは、クラス定義の例を示すためのサンプルです。
 */
public class MyClass {
    /**
     * クラスのフィールド
     */
    private int myField;
    /**
     * クラスのメソッド
     */
    public void myMethod() {
        // メソッドの処理
    }
}
フィールド（Fields）: クラス内で定義された変数のことで、そのクラスのインスタンスの状態を表現します。フィールドには、インスタンス変数（インスタンスごとに独立して存在する変数）とクラス変数（すべてのインスタンスで共有される変数）があります。
メソッド（Methods）: クラス内で定義された関数のことで、そのクラスの振る舞いや操作を定義します。メソッドには、インスタンスメソッド（インスタンスごとに異なる振る舞いを提供するメソッド）と静的メソッド（すべてのインスタンスで共通の振る舞いを提供するメソッド）があります。
コンストラクタ（Constructor）: クラスのインスタンスが作成される際に呼び出される特別なメソッドで、インスタンスの初期化を行います。コンストラクタは、クラスと同じ名前を持ち、戻り値を持ちません。
初期化ブロック（Initialization Blocks）: クラスがロードされる際に実行されるコードブロックで、フィールドの初期化やその他の初期化処理を行います。静的初期化ブロック（staticブロック）とインスタンス初期化ブロック（インスタンスイニシャライザ）の2つがあります。
ネストしたクラス（Nested Classes）: 他のクラスの内部に定義されるクラスで、外部クラスのメンバーにアクセスすることができます。ネストしたクラスには、静的なネストしたクラスと非静的なネストしたクラス（内部クラス）の2つがあります。
インターフェース（Interfaces）: クラスが実装することができる抽象的な型で、メソッドのシグネチャのみを定義します。インターフェースは、クラスの振る舞いを定義するために使用されます。
列挙型（Enums）: 一連の定数を表す特殊なクラスで、列挙型の定数はクラスのメンバーとして定義されます。
すべてのフィールド要素を盛り込んだクラス例:
// ネストしたクラスの定義
class Outer {
    // インスタンス変数
    int instanceVariable;
    // クラス変数（静的変数）
    static int classVariable;
    // コンストラクタ
    Outer(int instanceVariable) {
        this.instanceVariable = instanceVariable;
    }
    // インスタンスメソッド
    void instanceMethod() {
        System.out.println("インスタンスメソッドが呼び出されました。インスタンス変数: " + instanceVariable);
    }
    // 静的メソッド
    static void classMethod() {
        System.out.println("クラスメソッドが呼び出されました。クラス変数: " + classVariable);
    }
    // 初期化ブロック（インスタンス初期化ブロック）
    {
        System.out.println("インスタンス初期化ブロックが実行されました。");
    }
    // 静的初期化ブロック（クラス初期化ブロック）
    static {
        classVariable = 100;
        System.out.println("クラス初期化ブロックが実行されました。");
    }
    // 静的ネストしたクラスの定義
    static class StaticNested {
        void nestedMethod() {
            System.out.println("静的ネストしたメソッドが呼び出されました。");
        }
    }
    // ネストしたクラス（内部クラス）の定義
    class Inner {
        void innerMethod() {
            System.out.println("ネストしたメソッドが呼び出されました。");
        }
    }
    // 列挙型（Enum）の定義
    enum MyEnum {
        VALUE1, VALUE2, VALUE3;
    }
}
public class Main {
    public static void main(String[] args) {
        // クラスのインスタンス化
        Outer outer = new Outer(42);
        // インスタンスメソッドの呼び出し
        outer.instanceMethod();
        // 静的メソッドの呼び出し
        Outer.classMethod();
        // ネストしたクラス（静的ネストしたクラス）のインスタンス化とメソッドの呼び出し
        Outer.StaticNested staticNested = new Outer.StaticNested();
        staticNested.nestedMethod();
        // ネストしたクラス（内部クラス）のインスタンス化とメソッドの呼び出し
        Outer.Inner inner = outer.new Inner();
        inner.innerMethod();
        // 列挙型の使用
        Outer.MyEnum enumValue = Outer.MyEnum.VALUE1;
        System.out.println("列挙型の値: " + enumValue);
    }
}
このコードでは、以下の要素が含まれています。
Javaにおける「フィールド」とは、クラス内で定義された変数のことを指します。
つまり、クラスが持つデータや状態を表現するためのメンバー変数です。
具体的には、以下の2つの種類のフィールドがあります。
インスタンス変数は、クラスのインスタンスごとに固有のデータを表します。
インスタンスが生成されると、それぞれのインスタンスに対して別々のメモリ領域が割り当てられ、インスタンス変数の値が保持されます。
インスタンスメソッド内で使用され、thisキーワードを介してアクセスされます。
クラス変数は、クラス全体で共有される静的な変数です。
クラスがロードされると、1つのメモリ領域がクラス変数に割り当てられ、その値はすべてのインスタンス間で共有されます。
staticキーワードで修飾されます。
フィールドは、クラスの属性や状態を表現するために使用され、インスタンスの個々の状態を保持します。例えば、クラス Person には、nameやageなどのインスタンス変数があり、それぞれの Person インスタンスが特定の名前や年齢を持つことができます。また、counterやPIなどの定数を保持するのに適したクラス変数もあります。
Javaにおける「メソッド」とは、クラス内に定義された関数のことを指します。メソッドは、クラスが持つ振る舞いや操作を定義し、実行するための手段です。
以下は、Javaのメソッドの特徴です。
クラス内で定義される: メソッドは、特定のクラス内に定義されます。これにより、そのクラスが持つ振る舞いや機能をカプセル化し、再利用可能なコード単位として組織することができます。
名前を持つ: メソッドは、識別子（メソッド名）で識別されます。メソッド名は、他の部分のコードから呼び出される際に使用されます。
引数を受け取る: メソッドは、ゼロ個以上の引数を受け取ることができます。これらの引数は、メソッドの動作に必要なデータを提供します。
値を返す: メソッドは、値を返すことができます。この返り値は、メソッド呼び出し元に戻され、利用することができます。
アクセス修飾子で修飾される: メソッドは、public、private、protected、あるいはデフォルトのアクセスレベルを持つことができます。これにより、メソッドの可視性やアクセス範囲を制御することができます。
static修飾子で修飾される: メソッドは、static修飾子を使用してクラスメソッドとして定義することができます。クラスメソッドは、クラスのインスタンスを作成せずに呼び出すことができます。
メソッドは、オブジェクト指向プログラミングにおいてクラスの主要な構成要素の一つであり、クラスの振る舞いや操作を定義するために広く使用されます。
メソッド定義の中で、特別な意味を持つキーワードがいくつかあります。
メソッド内で、そのメソッドを呼び出している現在のオブジェクト（インスタンス）を参照するために使用されます。
メソッドの引数やローカル変数と同じ名前のインスタンス変数やフィールドにアクセスする場合に必要です。
class MyClass {
    private int value;
    public MyClass(int value) {
        this.value = value; // インスタンス変数にアクセスするためにthisキーワードを使用
    }
}
サブクラスのメソッド内で、親クラスのメソッドやフィールドにアクセスするために使用されます。
サブクラスが親クラスのメソッドをオーバーライドする場合に、親クラスのメソッドを呼び出すために使用されます。
class SubClass extends MyClass {
    public SubClass(int value) {
        super(value); // 親クラスのコンストラクタを呼び出すためにsuperキーワードを使用
    }
}
メソッドにfinal修飾子が付いている場合、そのメソッドはサブクラスでオーバーライドできません。
サブクラスで同じシグネチャ（メソッド名、引数リスト、戻り値の型）のメソッドを定義しようとすると、コンパイルエラーが発生します。
class Parent {
    final void finalMethod() {
        // メソッドの本体
    }
}
class Child extends Parent {
    // コンパイルエラー: メソッド 'finalMethod()' をオーバーライドできません
    void finalMethod() {
        // メソッドの本体
    }
}
メソッドにabstract修飾子が付いている場合、そのメソッドは実装されていません。抽象メソッドは、抽象クラスまたはインターフェース内で定義されます。
サブクラスで抽象メソッドをオーバーライドすることが要求されます。
abstract class AbstractClass {
    abstract void abstractMethod(); // 抽象メソッド
}
class ConcreteClass extends AbstractClass {
    void abstractMethod() {
        // メソッドの本体
    }
}
 
これらのキーワードは、メソッドが継承や実装において特別な振る舞いを持つことを示します。それぞれのキーワードは、メソッドの定義や利用の文脈で異なる意味を持ちます。
Javaでは、クラス、フィールド、メソッドにアクセス修飾子を付けることができます。主なアクセス修飾子には、public、private、protected、default があります。
これらは、クラスやメソッドが他のクラスからどのようにアクセスされるかを制御します。
final修飾子が付いたメンバー（変数やメソッド）は、その値や挙動が変更できないことを示します。これは以下のような意味を持ちます：
インスタンス変数にfinalが付いている場合、その変数はインスタンスが作成された後に一度だけ初期化できます。以降、値を変更することはできません。
クラス変数にfinalが付いている場合、その変数は定数として扱われ、一度値が代入されるとそれ以降変更することはできません。
インスタンスメソッドにfinalが付いている場合、サブクラスでオーバーライドすることができません。つまり、そのメソッドの挙動が不変です。
クラスメソッド（静的メソッド）にfinalが付いている場合、同様にサブクラスでオーバーライドすることができません。
final修飾子は、プログラムの安全性やパフォーマンスの向上に役立ちます。変数やメソッドが不変であることが明示されるため、予期しない変更やオーバーライドによるバグを防ぐことができます。また、コンパイラやランタイムは、final修飾子を利用して最適化を行うことができ、パフォーマンスを向上させることができます。
クラスには、インスタンスが作成される際に自動的に呼び出される特別なメソッドであるコンストラクタがあります。
コンストラクタは、クラス名と同じ名前を持ちます。
オブジェクトが生成される際にフィールドの初期化などの初期化処理を行います。  
public class MyClass {
    private int myField;
    // コンストラクタ
    public MyClass(int initialValue) {
        this.myField = initialValue;
    }
}
Javaにおけるコンストラクタの多態性（ポリモーフィズム）について説明します。
Javaでは、コンストラクタは多態性を持つことができます。これは、異なるクラスや型のオブジェクトを同じコンストラクタを使用して生成することができるという意味です。具体的には、以下のようなケースがあります。
クラス内で複数のコンストラクタを定義し、それぞれが異なる引数リストを持つ場合、オーバーロードされたコンストラクタとして扱われます。
メソッドのオーバーロードと同様に、コンストラクタのオーバーロードでは、同じ名前の異なるシグネチャを持つ複数のコンストラクタが定義されます。
コンストラクタのオーバーロードにより、異なる引数を使用してオブジェクトを生成することができます。
class MyClass {
    private int value;
    // 引数なしのデフォルトコンストラクタ
    MyClass() {
        this.value = 0;
    }
    // int型の引数を受け取るコンストラクタ
    MyClass(int value) {
        this.value = value;
    }
}
public class Main {
    public static void main(String[] args) {
        MyClass obj1 = new MyClass(); // 引数なしのコンストラクタが呼び出される
        MyClass obj2 = new MyClass(42); // int型の引数を受け取るコンストラクタが呼び出される
    }
}
サブクラスのコンストラクタは、親クラスのコンストラクタを呼び出すためにsuperキーワードを使用します。
サブクラスのコンストラクタが親クラスの特定のコンストラクタを呼び出すことで、親クラスのインスタンスの初期化を行うことができます。
class Parent {
    int value;
    // 親クラスのコンストラクタ
    Parent(int value) {
        this.value = value;
    }
}
class Child extends Parent {
    // サブクラスのコンストラクタ
    Child(int value) {
        super(value); // 親クラスのコンストラクタを呼び出す
    }
}
public class Main {
    public static void main(String[] args) {
        Child obj = new Child(42);
    }
}
 
これらの例は、Javaにおけるコンストラクタの多態性を示しています。コンストラクタのオーバーロードやサブクラスのコンストラクタが、異なる型やクラスのオブジェクトを初期化するために使用される方法を示しています。
クラスからオブジェクト（インスタンス）を作成することをインスタンス化と言います。
new キーワードを使用してインスタンスを生成します。
MyClass obj = new MyClass(10);
このようにして、MyClass クラスから obj という名前のインスタンスを作成しました。
型推論は、コンパイラが変数の型を自動的に推測する機能です。
Java 10からは、varキーワードを使用してローカル変数の型を推論することができるようになりました。
以下は、型推論を使用したインスタンス化の例です。
var obj = new MyClass(10);
この場合、コンパイラはobjの型をMyClassと推論します。
明示的に型を宣言する必要がなくなり、コードの冗長性を減らすことができます。
Javaでは、既存のクラスを拡張して新しいクラスを作成することができます。
これを継承と呼びます。
継承を使用することで、既存のクラスのフィールドやメソッドを再利用し、新しいクラスで追加や修正を加えることができます。  
public class ChildClass extends ParentClass {
    // ChildClass のフィールドとメソッドを定義
}
Javaでは、クラスは単一の直接スーパークラスしか持つことができません（単一継承）。
しかし、インタフェースは複数実装できるため、多重継承の代替手段として使用されます。
シールドクラス (Sealed class) は、Java 17から導入された新機能の1つです。
シールドクラスは、そのサブクラスがどのクラスになるかを制限するために使用されます。
シールドクラスは以下のように定義されます：
sealed class Shape permits Circle, Rectangle {
    // クラスの定義
}
上記の例では、Shapeというシールドクラスを定義し、CircleとRectangleというサブクラスを許可しています。つまり、CircleとRectangle以外のクラスはShapeのサブクラスになることができません。
シールドクラスを使用することで、クラスの階層構造を制御し、より安全な設計を実現することができます。
これにより、クラスの派生元や使用方法をより明確に定義することができます。
ポリモーフィズム（Polymorphism）とは、オブジェクト指向プログラミングの重要な概念の一つであり、同じメッセージ（操作やメソッド呼び出し）を異なるオブジェクトに送ることができる能力を指します。つまり、同じ名前のメソッドや操作が複数のクラスで異なる動作をすることができるという概念です。
ポリモーフィズムには主に2つのタイプがあります：
コンパイル時のポリモーフィズム（Compile-time Polymorphism）:
コンパイル時のポリモーフィズムは、メソッドのオーバーロードや演算子のオーバーロードなど、コンパイル時に静的に解決されるポリモーフィズムの形態です。
オーバーロードされたメソッドや演算子は、同じ名前で異なる引数の型や数を受け入れることができます。コンパイラは、呼び出し元のコンテキストから適切なバージョンのメソッドや演算子を解決します。
実行時のポリモーフィズム（Runtime Polymorphism）:
実行時のポリモーフィズムは、継承とメソッドのオーバーライドを利用して、実行時にオブジェクトの型に基づいてメソッドが動的に選択される機能です。
この形態では、オーバーライドされたメソッドが異なるサブクラスで定義され、同じメソッド名を持ちますが、それぞれのクラスのインスタンスに対して異なる振る舞いを示します。
Javaでは、実行時のポリモーフィズムが主に使用されます。これは、スーパークラスの参照変数がサブクラスのオブジェクトを参照し、その参照変数を通じてメソッドを呼び出すことで実現されます。実際の実行時に、どのクラスのメソッドが呼び出されるかは、オブジェクトの実際の型に基づいて動的に決定されます。
オーバーライド（Override）とは、Javaのオブジェクト指向プログラミングにおいて、サブクラスが親クラスのメソッドを再定義することを指します。つまり、親クラスで定義されたメソッドと同じ名前、引数リスト、戻り値の型を持つメソッドをサブクラスで再度定義することです。
オーバーライドには以下の特徴があります：
オーバーライドするメソッドは、親クラスのメソッドと同じ名前、引数リスト、戻り値の型を持たなければなりません。
オーバーライドされたメソッドは、実行時にオブジェクトの型に基づいて動的に呼び出されます。つまり、実際に実行されるメソッドは、オブジェクトの実際の型によって決定されます。
Javaでは、@Overrideアノテーションを使用して、明示的にメソッドがオーバーライドされていることを示すことができます。コンパイラは、このアノテーションを使用してオーバーライドの誤りを検出するのに役立ちます。
public class SubClass extends SuperClass {
    @Override
    public void methodName() {
        // オーバーライドされたメソッドの実装
    }
}
抽象クラスは、インスタンス化できないクラスであり、抽象メソッド（本体を持たないメソッド）を含むことができます。抽象クラスは、他のクラスによって拡張されることを意図しています。  
public abstract class AbstractClass {
    // 抽象メソッド
    public abstract void abstractMethod();
}
インタフェースは、抽象メソッドのみを含む抽象型です。
クラスは複数のインタフェースを実装でき、これにより複数の振る舞いを持つことができます。  
public interface InterfaceName {
    // 抽象メソッド
    void methodName();
}
ジェネリックなクラスは、異なる型のデータを扱えるように設計されたクラスです。
ジェネリックなクラスは、その定義中に1つ以上の型パラメータを持ち、そのパラメータを使用してフィールドの型やメソッドの引数・戻り値の型を指定します。
これにより、特定の型に依存せず、汎用的なクラスを定義することができます。
以下は、ジェネリックなクラスの例です。
public class Box {
    private T data;
    
    public void setData(T data) {
        this.data = data;
    }
    
    public T getData() {
        return data;
    }
}
 
この Box クラスは、T という型パラメータを持っています。
このパラメータは、クラスのインスタンス化時に実際の型に置き換えられます。
例えば、Box をインスタンス化すると、T は Integer 型になります。
同様に、Box をインスタンス化すると、T は String 型になります。ジェネリックなクラスを使用することで、型安全性を向上させ、コードの再利用性を高めることができます。
アクセサ (Accessor) は、オブジェクトのフィールドにアクセスするためのメソッドのことを指します。一般的に、オブジェクトのフィールドには直接アクセスせず、フィールドの値を取得するための「ゲッター」メソッドと、フィールドの値を設定するための「セッター」メソッドを使用します。
ゲッターは、フィールドの値を取得するためのメソッドです。
一般的に、フィールドの名前に "get" を接頭辞として付けます。
以下は、ゲッターの例です。
public class MyClass {
    private int number;
    
    public int getNumber() {
        return number;
    }
}
この例では、getNumber メソッドが number フィールドの値を返します。
セッターは、フィールドの値を設定するためのメソッドです。
一般的に、フィールドの名前に "set" を接頭辞として付けます。
以下は、セッターの例です。
public class MyClass {
    private int number;
    
    public void setNumber(int number) {
        this.number = number;
    }
}
この例では、setNumber メソッドが number フィールドの値を設定します。
アクセサを使用することで、フィールドにアクセスする際の制御を強化し、フィールドの値の読み取りおよび変更を制御することができます。
また、フィールドのカプセル化を実現し、オブジェクトのデータの整合性を保つのに役立ちます。
これらは、Javaのクラスの基本的な構造と機能の概要です。
クラスは、オブジェクト指向プログラミングの中核であり、プログラムの構造を構築するための重要な要素です。
クラスの設計に関するベストプラクティスは、ソフトウェアの品質、保守性、拡張性を向上させるために重要です。以下に、クラスの設計に関するいくつかの一般的なベストプラクティスを示します。
クラスは、1つの責任や役割を持つべきです。複数の異なる責任を持つクラスは、分割して単一の責任に集中させることで、可読性や保守性を向上させることができます。
クラスのフィールドをprivateで宣言し、アクセッサメソッド（getterやsetter）を使用して外部からのアクセスを制御します。これにより、クラスの内部状態を隠蔽し、データの整合性を維持することができます。
継承は強力なツールですが、適切に使用することが重要です。親クラスとサブクラスの間に論理的な関係がある場合にのみ継承を使用し、コードの再利用性を向上させることができます。また、インタフェースを使用することで、継承の代替手段として柔軟性を持たせることができます。
クラスの不変性を維持することは、バグの発生を減らし、並行性の問題を回避するのに役立ちます。可能な限り不変性を推奨し、フィールドをfinalで宣言することを検討してください。
クラス、メソッド、フィールドなどの要素に適切な名前を付けることは、コードの可読性を向上させるために重要です。意味のある名前を選択し、一貫した命名規則を使用することが重要です。
クラスのコンストラクタは、オブジェクトの初期化を行うための重要な手段です。コンストラクタのパラメータを最小限に保ち、必要な初期化を適切に行うように設計することが重要です。
クラスやメソッドの目的、機能、使用方法についてのドキュメントとコメントを追加することは、コードの理解を助けるのに役立ちます。特に他の開発者がコードを読む場合に重要です。
これらのベストプラクティスを遵守することで、より保守性の高い、柔軟性のある、品質の高いクラスを設計することができます。
{{コラム|SOLID原則|2=SOLID原則は、オブジェクト指向プログラミングにおける設計原則の集合であり、ソフトウェアの保守性、拡張性、再利用性を向上させるためのガイドラインを提供します。
SOLIDは以下の5つの原則からなります。
1つのクラスは1つの責務（役割）を持つべきであり、変更する理由は1つであるべきです。この原則により、クラスはシンプルで理解しやすくなり、変更に強い設計になります。
ソフトウェアのエンティティ（クラス、モジュール、関数など）は、拡張に対して開いており、修正に対して閉じているべきです。すなわち、新しい機能を追加するときは既存のコードを変更せずに拡張できるようにするべきです。
サブタイプ（派生クラス、実装クラス）は、その親タイプ（基底クラス、インターフェース）と置換可能でなければなりません。つまり、基底クラス型の変数に対して派生クラスのインスタンスを代入しても動作が変わらないことを保証する必要があります。
クライアント（利用者）が利用しないメソッドに依存しないようにするために、クライアントにとって不要なインターフェースを実装しないように分割します。クライアントは必要な機能にのみ依存するべきです。
上位のモジュールは下位のモジュールに依存すべきではなく、両方が抽象に依存すべきです。また、具象クラスにではなく抽象クラスやインターフェースに依存すべきです。これにより、コードの柔軟性が向上し、依存関係の注入（DI）などのパターンが可能になります。
SOLID原則は、ソフトウェアの品質を向上させるための強力なガイドラインであり、設計のバランスを保ちながら柔軟性と保守性を確保するのに役立ちます。これらの原則を遵守することで、より清潔で拡張可能なコードを作成することができます。
[https://paiza.io/projects/vGiAv_xXPraYJ93-dksSGw?language=java 配列]:
/**
 * Javaクラスと配列の操作例
 */
import java.util.*;
/**
 * 人物を表すクラス
 */
class Person {
    // フィールド
    private String name;
    private int age;
    
    /**
     * コンストラクタ
     * @param name 名前
     * @param age 年齢
     */
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    /**
     * 名前のゲッター
     * @return 名前
     */
    public String getName() {
        return name;
    }
    
    /**
     * 名前のセッター
     * @param name 名前
     */
    public void setName(String name) {
        this.name = name;
    }
    
    /**
     * 年齢のゲッター
     * @return 年齢
     */
    public int getAge() {
        return age;
    }
    
    /**
     * 年齢のセッター
     * @param age 年齢
     */
    public void setAge(int age) {
        this.age = age;
    }
}
/**
 * メインクラス
 */
public class Main {
    /**
     * メインメソッド
     * @param args コマンドライン引数
     */
    public static void main(String[] args) {
        // ArrayListを使用してPersonオブジェクトのリストを作成
        List peopleList = new ArrayList<>();
        
        // Personオブジェクトをリストに追加
        peopleList.add(new Person("Alice", 30));
        peopleList.add(new Person("Bob", 25));
        peopleList.add(new Person("Charlie", 35));
        
        // 配列の要素を出力
        for (Person person : peopleList) {
            System.out.println("Name: " + person.getName() + ", Age: " + person.getAge());
        }
    }
}
[https://paiza.io/projects/9iy_6ZXmiOJxrTrHlha11w?language=java 行列]:
import java.util.*;
/**
 * 行列演算を行うMatrixクラスの定義
 */
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.function.BinaryOperator;
/**
 * 行列を表すMatrixクラス
 */
class Matrix {
    /** 行数 */
    private final int rows;
    /** 列数 */
    private final int cols;
    /** 行列データ */
    private final double[] data;
    /**
     * 行列のコンストラクタ
     * @param rows 行数
     * @param cols 列数
     */
    public Matrix(int rows, int cols) {
        this.rows = rows;
        this.cols = cols;
        this.data = new double[rows * cols];
    }
    /**
     * 行列のコンストラクタ
     * @param data 行列データ
     */
    public Matrix(double[][] data) {
        this.rows = data.length;
        this.cols = data[0].length;
        this.data = new double[rows * cols];
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                this.data[cols * i + j] = data[i][j];
            }
        }
    }
    /**
     * 行数を取得するメソッド
     * @return 行数
     */
    public int getRows() {
        return rows;
    }
    /**
     * 列数を取得するメソッド
     * @return 列数
     */
    public int getCols() {
        return cols;
    }
    /**
     * 指定された位置の要素を取得するメソッド
     * @param i 行インデックス
     * @param j 列インデックス
     * @return 指定された位置の要素
     */
    public double get(int i, int j) {
        return data[cols * i + j];
    }
    /**
     * 指定された位置に要素を設定するメソッド
     * @param i 行インデックス
     * @param j 列インデックス
     * @param value 設定する値
     */
    public void set(int i, int j, double value) {
        data[cols * i + j] = value;
    }
    /**
     * 他の行列との加算を行うメソッド
     * @param other 加算する行列
     * @return 加算結果の行列
     */
    public Matrix add(Matrix other) {
        return operate(other, Double::sum);
    }
    /**
     * 他の行列との減算を行うメソッド
     * @param other 減算する行列
     * @return 減算結果の行列
     */
    public Matrix subtract(Matrix other) {
        return operate(other, (x, y) -> x - y);
    }
    /**
     * 行列とスカラーの乗算を行うメソッド
     * @param scalar 乗算するスカラー値
     * @return 乗算結果の行列
     */
    public Matrix scalarMultiply(double scalar) {
        Matrix result = new Matrix(rows, cols);
        for (int i = 0; i < data.length; i++) {
            result.data[i] = this.data[i] * scalar;
        }
        return result;
    }
    /**
     * 行列の比較を行うメソッド
     * @param other 比較する行列
     * @return 行列が等しい場合はtrue、そうでない場合はfalse
     */
    public boolean equals(Matrix other) {
        if (this.rows != other.rows || this.cols != other.cols) {
            return false;
        }
        for (int i = 0; i < data.length; i++) {
            if (this.data[i] != other.data[i]) {
                return false;
            }
        }
        return true;
    }
    /**
     * 行列の文字列表現を返すメソッド
     * @return 行列の文字列表現
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < data.length; i++) {
            sb.append(data[i]);
            if ((i + 1) % cols == 0) {
                sb.append("\n");
            } else {
                sb.append(", ");
            }
        }
        return sb.toString();
    }
    /**
     * 行列演算を行うメソッド
     * @param other 演算対象の行列
     * @param operator 演算子
     * @return 演算結果の行列
     */
    private Matrix operate(Matrix other, BinaryOperator operator) {
        if (rows != other.rows || cols != other.cols) {
            throw new IllegalArgumentException("Matrices must have the same dimensions");
        }
        Matrix result = new Matrix(rows, cols);
        Iterator thisIterator = iterator();
        Iterator otherIterator = other.iterator();
        for (int i = 0; i < data.length; i++) {
            result.data[i] = operator.apply(thisIterator.next(), otherIterator.next());
        }
        return result;
    }
    /**
     * 行列の要素にアクセスするイテレータを返すメソッド
     * @return 行列の要素にアクセスするイテレータ
     */
    private Iterator iterator() {
        return new Iterator() {
            private int index = 0;
            @Override
            public boolean hasNext() {
                return index < data.length;
            }
            @Override
            public Double next() {
                if (!hasNext()) {
                    throw new NoSuchElementException();
                }
                return data[index++];
            }
        };
    }
}
/**
 * メインクラス
 */
public class Main {
    /**
     * メインメソッド
     * @param args コマンドライン引数
     */
    public static void main(String[] args) {
);
);
        // 加算
        Matrix sum = a.add(b);
        System.out.println("Sum:");
        System.out.println(sum);
        // 減算
        Matrix difference = a.subtract(b);
        System.out.println("Difference:");
        System.out.println(difference);
        // スカラー倍
        Matrix scaled = a.scalarMultiply(2);
        System.out.println("Scaled:");
        System.out.println(scaled);
        // 比較
        System.out.println("Are matrices equal? " + a.equals(b));
    }
}
実行結果:
Sum:
8.0, 10.0, 12.0
14.0, 16.0, 18.0
Difference:
-6.0, -6.0, -6.0
-6.0, -6.0, -6.0
Scaled:
2.0, 4.0, 6.0
8.0, 10.0, 12.0
Are matrices equal? false