【Java】見てわかる基本文法

今回は、Javaの基本文法についてまとめてみました！

Javaのコードを書くために必要な基本文法になります。サンプルコードもあるので、ぜひ手を動かしながら確認してみてください。

変数宣言と初期化

変数宣言

変数を使用する前に、その変数を宣言する必要があります。変数の宣言には次のような構文を使用します。

<データ型> <変数名>;

たとえば、整数型の変数を宣言するには次のようにします。

int number;

初期化

変数を宣言した後、その変数に初期値を代入することができます。これを変数の初期化と呼びます。初期化は宣言と同時に行うことも、後で行うこともできます。

<変数名> = <初期値>;

または

<データ型> <変数名> = <初期値>;

たとえば、整数型の変数を宣言して初期化するには次のようにします。

int number = 10;

これにより、変数numberには初期値として10が代入されます。

初期化を後から行う場合は、変数宣言の後に値を設定します。

int number; // 変数の宣言
number = 10; // 初期化

また、複数の変数を同じデータ型で一度に宣言し、初期化することもできます。

<データ型> <変数名1>, <変数名2>, ... = <初期値1>, <初期値2>, ...;

複数の整数型の変数を宣言して初期化する場合は次のようになります。

int x = 5, y = 10, z = 20;

Javaでは変数を宣言するとき、初期値を指定しないと、数値型の場合は0、boolean型の場合はfalse、参照型の場合はnullが自動的に割り当てられます。

演算子

算術演算子

算術演算子は数値演算に使用されます。

+ : 加算
- : 減算
* : 乗算
/ : 除算
% : 剰余（割り算の余り）

int a = 10;
int b = 5;
int sum = a + b; // sumには15が代入される
int difference = a - b; // differenceには5が代入される
int product = a * b; // productには50が代入される
int quotient = a / b; // quotientには2が代入される
int remainder = a % b; // remainderには0が代入される

代入演算子

代入演算子は値を変数に代入するために使用されます。

= : 値を代入
+= : 左辺の変数に右辺の値を加えて代入
-= : 左辺の変数から右辺の値を引いて代入
*= : 左辺の変数に右辺の値を掛けて代入
/= : 左辺の変数を右辺の値で割って代入
%= : 左辺の変数を右辺の値で割った余りを代入

int x = 5; // xに5が代入される

int y = 10;
y += 3; // yにy + 3の結果が代入される（y = y + 3と同じ）

int z = 7;
z -= 2; // zにz - 2の結果が代入される（z = z - 2と同じ）

int a = 4;
a *= 2; // aにa * 2の結果が代入される（a = a * 2と同じ）

int b = 10;
b /= 3; // bにb / 3の結果が代入される（b = b / 3と同じ）

int c = 15;
c %= 4; // cにc % 4の結果が代入される（c = c % 4と同じ）

比較演算子

比較演算子は、値を比較するために使用されます。

== : 等しいかどうか
!= : 等しくないかどうか
> : より大きいかどうか
< : より小さいかどうか
>= : 以上かどうか
<= : 以下かどうか

int x = 5;
int y = 5;
boolean result = (x == y); // trueが代入される

int a = 10;
int b = 5;
boolean result = (a != b); // trueが代入される

int m = 10;
int n = 5;
boolean result = (m > n); // trueが代入される

int p = 3;
int q = 7;
boolean result = (p < q); // trueが代入される

int i = 8;
int j = 5;
boolean result = (i >= j); // trueが代入される

int r = 4;
int s = 4;
boolean result = (r <= s); // trueが代入される

論理演算子

論理演算子は、真偽値を扱うために使用されます。

&& : 論理積（AND）
|| : 論理和（OR）
! : 否定（NOT）

論理積演算子は、2つの条件が両方とも真の場合にtrueを返します。否定の条件が1つでも偽であれば、全体の結果はfalseになります。

boolean condition1 = true;
boolean condition2 = false;
boolean result = (condition1 && condition2); // falseが代入される

論理和演算子は、2つの条件のうち少なくとも1つが真の場合にtrueを返します。両方の条件が偽である場合にのみ、結果はfalseになります。

boolean condition3 = true;
boolean condition4 = false;
boolean result = (condition3 || condition4); // trueが代入される

論理否定演算子は、真偽値を反転させます。trueはfalseに、falseはtrueになります。

boolean condition5 = true;
boolean result = !condition5; // falseが代入される

インクリメントおよびデクリメント演算子

インクリメント演算子++とデクリメント演算子--は、変数の値を1つ増減させるために使用されます。

++ : 変数の値を1つ増加させる
-- : 変数の値を1つ減少させる

int a = 5;
a++; // aには6が代入される

インクリメント演算子（`++`）とデクリメント演算子（`--`）の評価

インクリメント演算子は、変数の値を1つ増加させる演算子です。

前置インクリメント（++変数）: 変数の値を増加させた後に、その値を評価します。

int x = 5;
int y = ++x;
// xは6になり、yも6になります。

後置インクリメント（変数++）: 変数の値を評価した後に、その値を増加させます。

int x = 5;
int y = x++;
// yは5になり、xは6になります。

デクリメント演算子は、変数の値を1つ減少させる演算子です。

前置デクリメント（–変数）: 変数の値を減少させた後に、その値を評価します。

int x = 5;
int y = --x;
// xは4になり、yも4になります。

後置デクリメント（変数–）: 変数の値を評価した後に、その値を減少させます。

int x = 5;
int y = x--;
// yは5になり、xは4になります。

制御構文

条件分岐

`if`文

条件に基づいてプログラムの一部を実行するための構文です。

if (条件) {
    // 条件が真の場合に実行する処理
} else if (別の条件) {
    // 別の条件が真の場合に実行する処理
} else {
    // 条件が偽で、かつ上記のどの条件も満たさない場合に実行する処理
}

if文の書き方はさまざまです。下記はサンプルコードになります。

単純な`if`文

int x = 10;

if (x > 5) {
    System.out.println("x is greater than 5");
}

実行結果：

is greater than 5

`if-else`文

int age = 20;

if (age >= 18) {
    System.out.println("You are an adult.");
} else {
    System.out.println("You are a minor.");
}

実行結果：

You are an adult.

`if-else if-else`文

int score = 75;

if (score >= 90) {
    System.out.println("Excellent!");
} else if (score >= 70) {
    System.out.println("Good job!");
} else {
    System.out.println("Keep trying!");
}

実行結果：

Good job!

ネストした`if`文

int x = 10;
int y = 20;

if (x == 10) {
    if (y == 20) {
        System.out.println("x is 10 and y is 20");
    }
}

実行結果：

x is 10 and y is 20

論理演算子を使用した`if`文

int a = 10;
int b = 20;

if (a > 5 && b < 30) {
    System.out.println("Both conditions are true.");
}

実行結果：

 Both conditions are true.

`switch`文

複数の条件に基づいてプログラムの一部を実行するための構文です。

switch (式) {
    case 値1:
        // 値1の場合に実行する処理
        break;
    case 値2:
        // 値2の場合に実行する処理
        break;
    // 他の値に対する処理を追加する場合、case文を追加します。
    default:
        // 式がどのcaseにも一致しない場合の処理
}

switch文も書き方はさまざまです。下記はサンプルコードになります。

`break`があるパターン

int number = 2;

switch (number) {
    case 1:
        System.out.println("One");
        break;
    case 2:
        System.out.println("Two");
        break;
    case 3:
        System.out.println("Three");
        break;
    default:
        System.out.println("Other number");
}

実行結果：

Two

breakがないパータン

int dayOfWeek = 3;

switch (dayOfWeek) {
    case 1:
        System.out.println("Monday");
    case 2:
        System.out.println("Tuesday");
    case 3:
        System.out.println("Wednesday");
    default:
        System.out.println("Other day");
}

実行結果：

Wednesday
Other day

default

int option = 4;

switch (option) {
    case 1:
        System.out.println("Option 1 selected");
        break;
    case 2:
        System.out.println("Option 2 selected");
        break;
    default:
        System.out.println("Invalid option");
}

実行結果：

Invalid option

ループ文

`for`ループ

指定した回数だけコードを繰り返し実行するための構文です。

for (初期化式; 条件式; 変化式) {
    // 条件が真の間、実行する処理
}

下記はサンプルコードです。

0から4までの数値を順番に出力

for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

実行結果：

配列の要素を順番に処理

int[] numbers = {1, 2, 3, 4, 5};

for (int num : numbers) {
    System.out.println(num);
}

実行結果：

文字列の各文字を順番に処理

String word = "Java";

for (int i = 0; i < word.length(); i++) {
    System.out.println(word.charAt(i));
}

実行結果：

J
a
v
a

`while`ループ

条件が真である限り、コードを繰り返し実行するための構文です。

while (条件) {
    // 条件が真の間、実行する処理
}

forループでやったことを、whileループで試してみます。下記はサンプルコードです。

0から4までの数値を順番に出力

int i = 0;
while (i < 5) {
    System.out.println(i);
    i++;
}

実行結果：

配列の要素を順番に処理

int[] numbers = {1, 2, 3, 4, 5};
int index = 0;
while (index < numbers.length) {
    System.out.println(numbers[index]);
    index++;
}

実行結果：

文字列の各文字を順番に処理

String word = "Java";
int index = 0;
while (index < word.length()) {
    System.out.println(word.charAt(index));
    index++;
}

実行結果：

J
a
v
a

`do-while`ループ

条件が真である限り、最低でも1回はコードを実行し、その後条件を確認して繰り返しを行うための構文です。

do {
    // 条件が真の間、実行する処理
} while (条件式);

forループ、whileループでやったことをdo-whileループでも試してみます。下記はサンプルコードです。

0から4までの数値を順番に出力

int i = 0;
do {
    System.out.println(i);
    i++;
} while (i < 5);

実行結果：

配列の要素を順番に処理

int[] numbers = {1, 2, 3, 4, 5};
int index = 0;
do {
    System.out.println(numbers[index]);
    index++;
} while (index < numbers.length);

実行結果：

文字列の各文字を順番に処理

String word = "Java";
int index = 0;
do {
    System.out.println(word.charAt(index));
    index++;
} while (index < word.length());

実行結果：

J
a
v
a

制御構文のネスト

制御構文は、他の制御構文の内部に配置することができます。これにより、より複雑な条件とループの組み合わせが可能になります。

if (条件1) {
    // 条件1が真の場合に実行する処理
    if (条件2) {
        // 条件2が真の場合に実行する処理
    }
} else {
    // 条件1が偽の場合に実行する処理
}

これらの制御構文を組み合わせて使用することで、さまざまな条件や反復処理をプログラムに組み込むことができます。

下記はサンプルコードです。

int x = 10;
int y = 20;

if (x < 20) {
    System.out.println("x is less than 20.");
    if (y > 15) {
        System.out.println("y is greater than 15.");
    }
} else {
    System.out.println("x is greater than or equal to 20.");
}

実行結果：

y is greater than 15.

配列

配列の宣言と初期化

// 配列の宣言
int[] numbers;

// 配列の初期化（要素数を指定して初期化）
numbers = new int[5];

// 配列の初期化と同時に値を設定
int[] numbers = {1, 2, 3, 4, 5};

配列の要素へのアクセス

// 配列の要素にアクセス
int firstElement = numbers[0]; // 最初の要素
int thirdElement = numbers[2]; // 3番目の要素

// 配列の要素に値を代入
numbers[1] = 10; // 2番目の要素に新しい値を代入

配列の長さ

// 配列の要素数を取得
int length = numbers.length;

配列の反復処理

// forループを使用して配列の要素を取得
for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

// 拡張forループ（for-eachループ）を使用して配列の要素を取得
for (int number : numbers) {
    System.out.println(number);
}

多次元配列の宣言と初期化

// 2次元配列の宣言と初期化
int[][] matrix = new int[3][3]; // 3x3の行列

// 初期化と同時に値を設定
int[][] matrix = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };

多次元配列の要素へのアクセス

// 2次元配列の要素にアクセス
int value = matrix[1][2]; // 2行目の3列目の要素にアクセス

配列は、複数の要素を格納するための便利なデータ構造です。上記の構文を使用して、配列を宣言、初期化、アクセスし、反復処理することができます。

メソッド

メソッドの構文

修飾子 戻り値の型 メソッド名(引数) {
    // メソッドの本体（処理）
}

修飾子 : メソッドに対するアクセス権を指定します。例えば、publicやprivateなどがあります。
戻り値の型 : メソッドが返す値のデータ型を指定します。戻り値がない場合はvoidを指定します。
メソッド名 : メソッドの識別子です。他の部分と区別するために使用されます。
パラメータリスト : メソッドに渡される引数のリストです。パラメータがない場合は空にします。

下記はサンプルコードです。

public class Main {
    // メインメソッド：プログラムのエントリーポイント
    public static void main(String[] args) {
        // メソッドの呼び出し
        greet(); // メソッド呼び出し
        int result = add(5, 3); // メソッド呼び出し
        System.out.println("5 + 3 = " + result);
    }

    // メソッドの定義
    public static void greet() {
        System.out.println("Hello, world!");
    }

    // メソッドの定義（引数を受け取る）
    public static int add(int a, int b) {
        return a + b;
    }
}

このコードではメソッドを２つ定義し、それぞれのメソッドを呼び出しています。

実行結果：

Hello, world!
5 + 3 = 8

メソッドの宣言と呼び出し

public void myMethod(int parameter1, String parameter2) {
    // メソッドの本体（処理）
}

メソッドを呼び出すには、メソッド名と必要な引数を指定します。

myMethod(10, "Hello");

メソッドの特徴

再利用性 : 同じ処理を複数の場所で使用する必要がある場合、メソッドを定義しておくことで、必要なときに簡単に呼び出すことができます。
モジュール性 : メソッドには特定の機能が含まれており、他の部分と分離されています。これにより、プログラムの構造が分かりやすくなります。
デバッグ : メソッドごとに機能を分割することで、プログラム内の問題を特定しやすくなります。

クラスとオブジェクト

クラス(Class)

クラスは、オブジェクトの設計図やテンプレートのようなものです。クラスには、そのオブジェクトが持つ属性（フィールド）や振る舞い（メソッド）が定義されています。例えば、Carというクラスがあれば、その中には車の色や速度などの属性が定義され、走るや停止するなどの振る舞いが定義されます。

クラスの宣言は次のようになります。

public class MyClass {
    // フィールド（属性）の宣言
    int myField;

    // メソッド（振る舞い）の定義
    public void myMethod() {
        // メソッドの本体
    }
}

下記はクラスの定義と実行のサンプルコードです。

Carクラス

public class Car {
    // フィールド（クラス内の変数）
    private String make;
    private String model;
    private int year;

    // コンストラクタ（クラスのインスタンスを初期化するための特別なメソッド）
    public Car(String make, String model, int year) {
        this.make = make;
        this.model = model;
        this.year = year;
    }

    // メソッド（クラス内で実行する操作）
    public void displayInfo() {
        System.out.println("Make: " + make);
        System.out.println("Model: " + model);
        System.out.println("Year: " + year);
    }

    // ゲッターメソッド（フィールドの値を取得するためのメソッド）
    public String getMake() {
        return make;
    }

    public String getModel() {
        return model;
    }

    public int getYear() {
        return year;
    }

    // セッターメソッド（フィールドの値を変更するためのメソッド）
    public void setMake(String make) {
        this.make = make;
    }

    public void setModel(String model) {
        this.model = model;
    }

    public void setYear(int year) {
        this.year = year;
    }
}

Carクラスを実行するためのMainクラス

public class Main {
    public static void main(String[] args) {
        // Carクラスのインスタンス化
        Car myCar = new Car("Toyota", "Corolla", 2020);

        // インスタンスの情報を表示
        System.out.println("My Car Information:");
        myCar.displayInfo();

        // インスタンスの年を更新
        myCar.setYear(2022);

        // 更新後の情報を表示
        System.out.println("\nUpdated Car Information:");
        myCar.displayInfo();
    }
}

実行結果：

My Car Information:
Make: Toyota
Model: Corolla
Year: 2020

Updated Car Information:
Make: Toyota
Model: Corolla
Year: 2022

オブジェクト(Object)

オブジェクトは、クラスを元にして実際に作成されたインスタンスです。クラスから複数のオブジェクトを生成することができます。各オブジェクトは、それぞれ独自の属性を持ち、自身の振る舞いを実行します。例えば、Carクラスから生成されたオブジェクトは、異なる色や速度を持つことができます。

オブジェクトの作成は次のようになります。

MyClass myObject = new MyClass();

このようにして作成されたmyObjectは、MyClassのインスタンスであり、そのクラスが持つ属性やメソッドにアクセスすることができます。

Javaのクラスとオブジェクトの概念を理解することで、より複雑なプログラムの設計や実装が可能になります。

例外処理

例外の種類

チェック例外 (Checked Exception):

メソッドの宣言で明示的に処理が必要とされる例外です。コンパイラがチェックし、処理が必要なことを示します。例えば、IOExceptionなどがあります。

実行時例外 (Runtime Exception):

プログラム実行中に発生し、通常のプログラムの実行フローを中断する可能性がある例外です。通常、明示的な処理が必要ありませんが、適切な処理が必要な場合もあります。例えば、ArithmeticException（ゼロ除算など）やNullPointerExceptionなどがあります。

例外処理の方法

try-catchブロック:

tryブロック内に例外が発生する可能性のあるコードを配置し、catchブロックで例外を捕捉して処理します。

try {
    // 例外が発生する可能性のあるコード
} catch (例外の型 変数名) {
    // 例外の処理
}

finallyブロック:

finallyブロックは、例外の発生の有無に関係なく、必ず実行されるコードを記述します。主に、リソースの解放や後処理などに使用されます。

try {
    // 例外が発生する可能性のあるコード
} catch (例外の型 変数名) {
    // 例外の処理
} finally {
    // 必ず実行される処理
}

throw文:

throw文を使用して、プログラム内で明示的に例外をスローすることができます。これは、特定の条件下でエラーを発生させたり、カスタム例外を作成したりするために使用されます。

if (条件) {
    throw new 例外の型("エラーメッセージ");
}

Javaの例外処理は、プログラムの安全性を向上させ、予期せぬエラーに対処するための重要な機能です。適切に例外処理を実装することで、プログラムの信頼性を高めることができます。

サンプルコード

public class Main {
    public static void main(String[] args) {
        try {
            // 例外が発生する可能性のあるコード
            int result = divideByZero(); // 0で割り算を試みる
            System.out.println("Result: " + result); // この行は実行されない
        } catch (ArithmeticException e) {
            // 例外が発生した場合の処理
            System.out.println("An arithmetic exception occurred: " + e.getMessage());
        } finally {
            // 必ず実行される処理
            System.out.println("Finally block executed.");
        }
    }

    // 0で割り算を行うメソッド
    public static int divideByZero() {
        return 10 / 0;
    }
}

実行結果：

An arithmetic exception occurred: / by zero
Finally block executed.

まとめ

Javaの基本文法ということでざっくりまとめてみましたが、プログラミングの基本文法は言語によって少し書き方は異なりますが考え方は同じです。

変数宣言と初期化

変数宣言

初期化

演算子

算術演算子

代入演算子

比較演算子

論理演算子

インクリメントおよびデクリメント演算子

インクリメント演算子（++）とデクリメント演算子（--）の評価

制御構文

条件分岐

if文

単純なif文

if-else文

if-else if-else文

ネストしたif文

論理演算子を使用したif文

switch文

breakがあるパターン

breakがないパータン

default

ループ文

forループ

0から4までの数値を順番に出力

配列の要素を順番に処理

文字列の各文字を順番に処理

whileループ

0から4までの数値を順番に出力

配列の要素を順番に処理

文字列の各文字を順番に処理

do-whileループ

0から4までの数値を順番に出力

配列の要素を順番に処理

文字列の各文字を順番に処理

制御構文のネスト

配列

配列の宣言と初期化

配列の要素へのアクセス

配列の長さ

配列の反復処理

多次元配列の宣言と初期化

多次元配列の要素へのアクセス

メソッド

メソッドの構文

メソッドの宣言と呼び出し

メソッドの特徴

クラスとオブジェクト

クラス(Class)

Carクラス

Carクラスを実行するためのMainクラス

オブジェクト(Object)

例外処理

例外の種類

チェック例外 (Checked Exception):

実行時例外 (Runtime Exception):

例外処理の方法

try-catchブロック:

finallyブロック:

throw文:

サンプルコード

まとめ

コメント

インクリメント演算子（`++`）とデクリメント演算子（`--`）の評価

`if`文

単純な`if`文

`if-else`文

`if-else if-else`文

ネストした`if`文

論理演算子を使用した`if`文

`switch`文

`break`があるパターン

`for`ループ

`while`ループ

`do-while`ループ