ゼロから始めるJava
IntelliJで手を動かして学ぶ基礎テキスト

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

public class VariableSample {
    public static void main(String[] args) {
        // 宣言と同時に代入(初期化)
        int age = 20;
        double height = 172.5;
        boolean isStudent = true;
        String name = "佐藤";   // 文字列は " " で囲む

        // 変数は後から値を入れ替えられる
        age = 21;               // 再代入(型は書かない)

        // 文字列と変数は + で連結できる
        System.out.println(name + "さんは" + age + "歳です");
        System.out.println("身長:" + height + "cm 学生:" + isStudent);
    }
}

final double TAX_RATE = 0.10;  // finalを付けると再代入禁止=定数。名前は大文字+_
// TAX_RATE = 0.08;            // → コンパイルエラーになる

var message = "hello";          // varと書くと右辺から型を推論(String型になる)

int a = 10;
double b = a;          // OK:自動変換(10.0になる)

double x = 3.9;
int y = (int) x;       // 明示的キャスト:小数部は切り捨てられ 3 になる

int p = 5, q = 2;
System.out.println(p / q);          // 3 ではなく 2(int同士の割り算は整数)
System.out.println((double) p / q); // 2.5(どちらかをdoubleにする)

int score = 10;
score = score + 5;   // 「今の値に5足して入れ直す」
score += 5;          // 上と同じ意味(複合代入)。-= *= /= %= もある

int count = 0;
count++;             // count = count + 1 と同じ(インクリメント)
count--;             // 1減らす(デクリメント)

public class OperatorSample {
    public static void main(String[] args) {
        int price = 1200;
        int point = price % 100;              // 下2桁をポイントに
        boolean isExpensive = price >= 1000;  // 比較結果はbooleanに入れられる

        System.out.println("ポイント:" + point);
        System.out.println("高額商品?:" + isExpensive);

        int age = 22;
        boolean canDrink = age >= 20 && age <= 120;  // かつ
        System.out.println("飲酒可?:" + canDrink);
    }
}

public class IfSample {
    public static void main(String[] args) {
        int score = 75;

        if (score >= 90) {
            System.out.println("素晴らしい!");
        } else if (score >= 60) {
            System.out.println("合格です");      // 今回はここが実行される
        } else {
            System.out.println("不合格です");
        }
    }
}

public class SwitchSample {
    public static void main(String[] args) {
        int day = 3;

        // 新しいswitch(Java 14以降・推奨):breakが不要で安全
        switch (day) {
            case 1 -> System.out.println("月曜日");
            case 2 -> System.out.println("火曜日");
            case 3 -> System.out.println("水曜日");
            case 6, 7 -> System.out.println("週末!");   // 複数の値をまとめられる
            default -> System.out.println("その他の曜日");
        }

        // 従来のswitch:case毎にbreakが必要(忘れると下に落ちる)
        switch (day) {
            case 3:
                System.out.println("水曜日(従来型)");
                break;   // これを忘れるとcase 6,7…も実行されてしまう
            default:
                System.out.println("その他");
        }
    }
}

public class ForSample {
    public static void main(String[] args) {
        //   ①初期化      ②条件     ③更新
        for (int i = 1; i <= 5; i++) {
            System.out.println(i + "回目のループ");
        }
    }
}

public class WhileSample {
    public static void main(String[] args) {
        int hp = 100;
        int turn = 0;

        while (hp > 0) {          // HPが残っている間、戦い続ける
            hp -= 30;
            turn++;
            System.out.println(turn + "ターン目:残りHP " + hp);
        }
        System.out.println(turn + "ターンで戦闘不能になった");
    }
}

for (int i = 1; i <= 10; i++) {
    if (i == 4) {
        continue;   // この回だけスキップして次の回へ
    }
    if (i == 7) {
        break;      // ループ全体を打ち切る
    }
    System.out.print(i + " ");
}
// 出力:1 2 3 5 6

for (int i = 1; i <= 9; i++) {          // 段(外側)
    for (int j = 1; j <= 9; j++) {      // 各段の中(内側)
        System.out.print(i * j + "\t"); // \t はタブ文字
    }
    System.out.println();               // 1段終わったら改行
}

public class ArraySample {
    public static void main(String[] args) {
        // 作り方1:値を並べて初期化
        int[] scores = {80, 65, 92, 74, 58};

        // 作り方2:サイズだけ決めて後から入れる(初期値は0)
        String[] names = new String[3];
        names[0] = "佐藤";
        names[1] = "鈴木";
        names[2] = "高橋";

        System.out.println(scores[0]);       // 80(最初の要素)
        System.out.println(scores.length);   // 5(要素数)

        // for文と組み合わせるのが定番(iを0からlength未満まで)
        int sum = 0;
        for (int i = 0; i < scores.length; i++) {
            sum += scores[i];
        }
        System.out.println("平均点:" + (double) sum / scores.length);

        // 拡張for文:全要素を順に取り出すだけならこちらが簡潔
        for (String name : names) {
            System.out.println(name + "さん");
        }
    }
}

public class MethodSample {
    public static void main(String[] args) {
        greet();                          // ① 引数なし・戻り値なし
        greet("鈴木");                    // ② 引数あり(オーバーロード)

        int ans = add(3, 5);              // ③ 戻り値を変数で受け取る
        System.out.println("3 + 5 = " + ans);

        double bmi = calcBmi(60.0, 1.7);  // ④ 複数の引数
        System.out.println("BMI: " + bmi);
    }

    // 戻り値なし → 型の場所に void と書く
    static void greet() {
        System.out.println("こんにちは!");
    }

    // 同名でも引数の型・数が違えば定義できる(オーバーロード)
    static void greet(String name) {
        System.out.println("こんにちは、" + name + "さん!");
    }

    // int を返すメソッド:returnで値を返し、そこで処理終了
    static int add(int a, int b) {
        return a + b;
    }

    static double calcBmi(double weightKg, double heightM) {
        return weightKg / (heightM * heightM);
    }
}

static 戻り値の型 メソッド名(引数の型 引数名, ...) {
    処理;
    return 戻り値;   // 戻り値の型がvoidならreturn文は省略可
}

public class Hero {
    // フィールド:このモノが持つデータ(状態)
    String name;
    int hp;

    // メソッド:このモノの振る舞い。フィールドを直接使える
    void attack() {
        System.out.println(name + "は攻撃した!");
    }

    void damage(int point) {
        hp -= point;
        System.out.println(name + "は" + point + "のダメージ!残りHP:" + hp);
    }
}

public class Main {
    public static void main(String[] args) {
        // newでインスタンスを生成し、変数に入れる
        Hero hero1 = new Hero();
        hero1.name = "勇者アレン";     // ドット(.)でフィールドにアクセス
        hero1.hp = 100;

        Hero hero2 = new Hero();
        hero2.name = "戦士ベルタ";
        hero2.hp = 150;

        hero1.attack();      // メソッドもドットで呼ぶ
        hero2.damage(30);    // hero2のhpだけが減る(hero1は無関係)
    }
}

Hero a = new Hero();
a.hp = 100;
Hero b = a;        // 実体のコピーではなく「同じ実体への参照」のコピー
b.hp = 50;
System.out.println(a.hp);   // 50!(aとbは同じHeroを指している)

public class Hero {
    String name;
    int hp;

    // コンストラクタ:new Hero("勇者アレン", 100) のときに実行される
    Hero(String name, int hp) {
        this.name = name;   // this.name=フィールド、name=引数
        this.hp = hp;
    }

    void attack() {
        System.out.println(name + "は攻撃した!");
    }
}

Hero hero1 = new Hero("勇者アレン", 100);   // 生成と初期化が1行で完了
hero1.attack();

// Hero hero2 = new Hero();   // ← コンパイルエラー!
// 引数付きコンストラクタを定義すると、引数なしのnewはできなくなる
// (=初期化忘れをコンパイラが防いでくれる)

public class Counter {
    static int total = 0;   // staticフィールド:全インスタンスで共有
    int myCount = 0;        // 通常のフィールド:インスタンスごと

    void countUp() {
        total++;            // 共有カウンタ
        myCount++;          // 自分専用カウンタ
    }
}

Counter a = new Counter();
Counter b = new Counter();
a.countUp();
a.countUp();
b.countUp();

System.out.println(a.myCount);      // 2(aは2回)
System.out.println(b.myCount);      // 1(bは1回)
System.out.println(Counter.total);  // 3(全体で3回。クラス名でアクセス)

// Mathクラスのstaticメソッド:newせずにクラス名.メソッド名で呼ぶ
System.out.println(Math.max(3, 5));      // 5
System.out.println(Math.pow(2, 10));     // 1024.0
System.out.println(Math.random());       // 0.0以上1.0未満の乱数

int n = Integer.parseInt("123");         // 文字列→intの変換(頻出!)

public class Hero {
    private String name;   // 外部から直接触れない
    private int hp;

    public Hero(String name, int hp) {
        this.name = name;
        this.hp = hp;
    }

    // getter:読み出し用の窓口(命名は get + フィールド名)
    public int getHp() {
        return hp;
    }

    // setter:書き込み用の窓口。ここでデータを守る!
    public void setHp(int hp) {
        if (hp < 0) {
            this.hp = 0;      // 不正な値は補正(0未満にはさせない)
        } else {
            this.hp = hp;
        }
    }

    public String getName() {
        return name;
    }
    // nameのsetterをあえて作らない=「名前は生成後に変更不可」という設計
}

Hero hero = new Hero("勇者アレン", 100);
// hero.hp = -9999;          // コンパイルエラー:privateには触れない
hero.setHp(-9999);           // 窓口経由 → チェックが働き0に補正される
System.out.println(hero.getName() + "のHP:" + hero.getHp());   // 0

public class Character {
    String name;
    int hp;

    public Character(String name, int hp) {
        this.name = name;
        this.hp = hp;
    }

    public void attack() {
        System.out.println(name + "は攻撃した!");
    }
}

public class Wizard extends Character {   // extendsで継承

    public Wizard(String name, int hp) {
        super(name, hp);   // super(...) = 親のコンストラクタを呼ぶ(先頭に書く)
    }

    // 追加:子クラス独自のメソッド
    public void castSpell() {
        System.out.println(name + "は魔法を唱えた!");
    }

    // 変更:親のメソッドを上書き(オーバーライド)
    @Override
    public void attack() {
        System.out.println(name + "は杖で殴った!");
    }
}

Wizard wiz = new Wizard("魔法使いメル", 70);
wiz.attack();      // 魔法使いメルは杖で殴った!(オーバーライド版が動く)
wiz.castSpell();   // 魔法使いメルは魔法を唱えた!(独自メソッド)

public class Main {
    public static void main(String[] args) {
        // 親の型の配列に、いろんな子の実体を混ぜて入れられる
        Character[] party = {
            new Hero("勇者アレン", 100),
            new Wizard("魔法使いメル", 70),
            new Wizard("賢者ソラ", 60)
        };

        // 呼び出すコードは1種類なのに、動きはそれぞれ違う!
        for (Character c : party) {
            c.attack();
        }
    }
}

public abstract class Character {
    String name;
    int hp;

    public Character(String name, int hp) {
        this.name = name;
        this.hp = hp;
    }

    // 抽象メソッド:中身なし(セミコロンで終わる)。子に実装を強制する
    public abstract void attack();

    // 普通のメソッドも持てる(共通処理はここに書く)
    public void showStatus() {
        System.out.println(name + " HP:" + hp);
    }
}

// Character c = new Character("?", 10);  // エラー:抽象クラスはnewできない

interface Attackable {
    void attack();   // インターフェース内は自動的に public abstract
}

interface Healable {
    void heal();
}

// 複数のインターフェースを同時に実装できる(カンマ区切り)
class Priest implements Attackable, Healable {
    @Override
    public void attack() {
        System.out.println("僧侶はメイスで攻撃!");
    }

    @Override
    public void heal() {
        System.out.println("僧侶は回復魔法を唱えた!");
    }
}

public class InterfaceSample {
    public static void main(String[] args) {
        Attackable a = new Priest();   // インターフェース型で受ける
        a.attack();
    }
}

public class StringSample {
    public static void main(String[] args) {
        String s = "Hello, Java World";

        System.out.println(s.length());              // 17:文字数
        System.out.println(s.toUpperCase());         // HELLO, JAVA WORLD
        System.out.println(s.toLowerCase());         // hello, java world
        System.out.println(s.contains("Java"));      // true:含むか
        System.out.println(s.startsWith("Hello"));   // true
        System.out.println(s.indexOf("Java"));       // 7:最初に現れる位置
        System.out.println(s.substring(7, 11));      // Java:7文字目から11文字目の手前まで
        System.out.println(s.replace("World", "入門")); // Hello, Java 入門
        System.out.println("  空白あり  ".trim());     // 前後の空白を除去

        // 分割:カンマ区切り文字列を配列に(CSV処理の基本)
        String csv = "りんご,みかん,ぶどう";
        String[] fruits = csv.split(",");
        for (String f : fruits) {
            System.out.println(f);
        }
    }
}

String input = new String("yes");

System.out.println(input == "yes");        // false になり得る(別インスタンス)
System.out.println(input.equals("yes"));   // true:内容の比較はこちら
System.out.println(input.equalsIgnoreCase("YES"));  // true:大文字小文字無視

StringBuilder sb = new StringBuilder();
for (int i = 1; i <= 5; i++) {
    sb.append(i).append(",");   // 連結してもインスタンスは1つのまま
}
String result = sb.toString();  // 最後にStringへ変換
System.out.println(result);     // 1,2,3,4,5,

double price = 1234.5;
// %s:文字列 %d:整数 %f:小数 %n:改行
System.out.printf("価格は%.1f円です%n", price);          // 価格は1234.5円です
String msg = String.format("%sさん(%d歳)", "佐藤", 20); // 変数に整形結果を入れる

import java.util.ArrayList;
import java.util.List;    // java.util パッケージの読み込み(6.1節)

public class ListSample {
    public static void main(String[] args) {
        // 変数はインターフェース型(List)で受けるのが定石(4.4の実践!)
        List<String> fruits = new ArrayList<>();

        fruits.add("りんご");            // 追加(サイズは自動で伸びる)
        fruits.add("みかん");
        fruits.add("ぶどう");

        System.out.println(fruits.get(0));        // りんご:取得
        System.out.println(fruits.size());        // 3:要素数(lengthではない)
        System.out.println(fruits.contains("みかん")); // true

        fruits.remove("ぶどう");                   // 削除
        fruits.set(1, "メロン");                   // 置き換え

        for (String f : fruits) {                 // 拡張forが使える
            System.out.println(f);
        }
    }
}

import java.util.HashMap;
import java.util.Map;

public class MapSample {
    public static void main(String[] args) {
        Map<String, Integer> prices = new HashMap<>();  // キーの型, 値の型

        prices.put("apple", 150);     // 登録
        prices.put("banana", 100);
        prices.put("apple", 180);     // 同じキーは上書きされる

        System.out.println(prices.get("apple"));      // 180
        System.out.println(prices.get("melon"));      // null(存在しないキー)
        System.out.println(prices.containsKey("banana")); // true

        // 全ペアを回す
        for (Map.Entry<String, Integer> e : prices.entrySet()) {
            System.out.println(e.getKey() + " = " + e.getValue() + "円");
        }
    }
}

public class ExceptionSample {
    public static void main(String[] args) {
        String input = "abc";   // 本来は数字が来るはずの入力

        try {
            // 例外が起きる可能性のある処理をtryで囲む
            int n = Integer.parseInt(input);   // "abc"は数値化できない!
            System.out.println("2倍は" + n * 2);
        } catch (NumberFormatException e) {
            // 例外が起きたらここへジャンプしてくる
            System.out.println("数値を入力してください:" + e.getMessage());
        } finally {
            // 例外の有無にかかわらず必ず実行される(後片付け用)
            System.out.println("処理を終了します");
        }

        System.out.println("プログラムは止まらず続行できる");
    }
}

public void setHp(int hp) {
    if (hp < 0) {
        // 例外を生成して投げる。メッセージで理由を伝える
        throw new IllegalArgumentException("HPは0以上を指定してください: " + hp);
    }
    this.hp = hp;
}

// 検査例外を自分で処理せず、呼び出し元に委ねる場合は throws 宣言
public String readFile(String path) throws IOException {
    // ファイル読み込み処理...
}

import java.util.List;

public class LambdaSample {
    public static void main(String[] args) {
        List<String> names = List.of("佐藤", "鈴木", "高橋");  // 変更不可の簡易List

        // forEach:各要素に対して「渡された処理」を実行する
        names.forEach(name -> System.out.println(name + "さん"));

        // ラムダの中身が複数行なら { } で囲む
        names.forEach(name -> {
            String msg = "こんにちは、" + name + "さん";
            System.out.println(msg);
        });
    }
}

import java.util.List;

public class StreamSample {
    public static void main(String[] args) {
        List<Integer> scores = List.of(85, 42, 91, 58, 73);

        // 60点以上を絞り込み、"◯点"に変換して、新しいListに集める
        List<String> passed = scores.stream()
                .filter(n -> n >= 60)       // 条件に合う要素だけ通す
                .map(n -> n + "点")          // 各要素を変換する
                .toList();                   // 結果をListにする

        System.out.println(passed);          // [85点, 91点, 73点]

        // 集計系:count / sum / average なども一撃
        long count = scores.stream().filter(n -> n >= 60).count();
        int sum = scores.stream().mapToInt(n -> n).sum();
        System.out.println("合格者:" + count + "人 / 合計:" + sum + "点");

        // 同じ処理をfor文で書くと…(比較してみよう)
        int total = 0;
        for (int n : scores) {
            total += n;
        }
        System.out.println("for文の合計:" + total);
    }
}

package com.example.shop;   // 先頭で所属パッケージを宣言(フォルダと一致させる)

public class Item {
    public String name;
}

package com.example.app;

import com.example.shop.Item;   // 別パッケージのクラスはimportして使う
import java.util.ArrayList;     // 標準ライブラリも同じ仕組み(5章で使ったもの)

public class Main {
    public static void main(String[] args) {
        Item item = new Item();
        item.name = "Java入門書";
        System.out.println(item.name);
    }
}

<project>
    <groupId>com.example</groupId>
    <artifactId>my-app</artifactId>
    <version>1.0.0</version>

    <dependencies>
        <!-- JSON変換ライブラリJacksonを使いたい、と宣言するだけ -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.17.0</version>
        </dependency>
    </dependencies>
</project>

package com.example.demo;                          // 6.1 パッケージ

import org.springframework.web.bind.annotation.GetMapping;   // 6.2 Mavenで入れた
import org.springframework.web.bind.annotation.RestController; // ライブラリのimport

@RestController                    // 6.3 「Web受付係」の目印
public class HelloController {     // 3.2 ただのpublicクラス

    @GetMapping("/hello")          // 「/hello へのアクセスはここ」の目印
    public String hello() {        // 3.1 Stringを返すただのメソッド
        return "Hello, Spring Boot!";
    }
}