【新人エンジニア向け】JavaとPythonの書き方を完全比較 同じことをどう書くか一覧で整理する

はじめに

JavaもPythonも学んでいると、こんな疑問が出てきます。

• 「同じことをやるのに、なんで書き方がこんなに違うの？」
• 「Javaで書いたこれ、Pythonだとどう書くの？」
• 「型宣言って絶対必要？」

この記事では 「同じことをJavaとPythonでどう書くか」 を
テーマ別に並べて整理します。

---

基本的な違い：一言まとめ

Java
・型を必ず宣言する（静的型付け）
・文末に ; が必要
・{ } でブロックを表現する
・クラスの中にすべてを書く
・コンパイルしてから実行する

Python
・型宣言が不要（動的型付け）
・文末に ; は不要
・インデント（字下げ）でブロックを表現する
・クラスなしで書ける
・そのまま実行できる

---

1. 変数の宣言

// Java：型を必ず宣言する
String name    = "田中花子";
int    age     = 25;
double price   = 1980.5;
boolean isOpen = true;

// 変数を宣言だけして後から代入
String message;
message = "こんにちは";

// 変更できない定数
final int MAX_COUNT = 100;

# Python：型宣言は不要
name    = "田中花子"
age     = 25
price   = 1980.5
is_open = True

# 変更できない定数（慣習として大文字にする）
MAX_COUNT = 100

項目	Java	Python
型宣言	必須	不要
定数	final をつける	大文字の変数名（慣習のみ）
命名規則	キャメルケース（isOpen）	スネークケース（is_open）

---

2. 文字列の扱い

// Java
String name = "たま";
int age = 3;

// 文字列の結合
String msg1 = "名前：" + name + "、年齢：" + age;

// フォーマット
String msg2 = String.format("名前：%s、年齢：%d", name, age);

// 長さ
int len = name.length();

// 含むか確認
boolean contains = name.contains("た");

// 大文字・小文字変換
String upper = name.toUpperCase();

// 分割
String[] parts = "a,b,c".split(",");

// 置換
String replaced = "hello world".replace("world", "Java");

# Python
name = "たま"
age = 3

# 文字列の結合
msg1 = "名前：" + name + "、年齢：" + str(age)

# f文字列（推奨）
msg2 = f"名前：{name}、年齢：{age}"

# 長さ
length = len(name)

# 含むか確認
contains = "た" in name

# 大文字・小文字変換
upper = name.upper()

# 分割
parts = "a,b,c".split(",")

# 置換
replaced = "hello world".replace("world", "Python")

---

3. 配列・リスト

// Java：配列（サイズ固定）
int[] numbers = {1, 2, 3, 4, 5};
String[] names = new String[3];   // サイズ3の空配列
names[0] = "たま";

// 要素数
int size = numbers.length;

// アクセス
int first = numbers[0];

// ループ
for (int n : numbers) {
    System.out.println(n);
}

// ArrayList（サイズ可変）
import java.util.ArrayList;
ArrayList<String> list = new ArrayList<>();
list.add("たま");
list.add("くろ");
list.remove("くろ");
System.out.println(list.size());
System.out.println(list.contains("たま"));

# Python：リスト（サイズ可変）
numbers = [1, 2, 3, 4, 5]
names = []        # 空リスト

# 追加
names.append("たま")
names.append("くろ")

# 削除
names.remove("くろ")

# 要素数
size = len(numbers)

# アクセス
first = numbers[0]
last  = numbers[-1]    # 末尾は -1 で取れる

# スライス
part = numbers[1:3]    # インデックス1〜2を取得

# ループ
for n in numbers:
    print(n)

# 含むか確認
print("たま" in names)

---

4. 辞書（マップ）

// Java：HashMap
import java.util.HashMap;
HashMap<String, Integer> scores = new HashMap<>();

// 追加・更新
scores.put("たま", 90);
scores.put("くろ", 75);

// 取得
int score = scores.get("たま");

// 存在確認
boolean exists = scores.containsKey("たま");

// 削除
scores.remove("くろ");

// ループ
for (Map.Entry<String, Integer> entry : scores.entrySet()) {
    System.out.println(entry.getKey() + "：" + entry.getValue());
}

// サイズ
int size = scores.size();

# Python：dict
scores = {}

# 追加・更新
scores["たま"] = 90
scores["くろ"] = 75

# まとめて定義
scores = {"たま": 90, "くろ": 75}

# 取得
score = scores["たま"]

# 存在確認
exists = "たま" in scores

# 削除
del scores["くろ"]

# ループ
for key, value in scores.items():
    print(f"{key}：{value}")

# サイズ
size = len(scores)

---

5. 条件分岐

// Java：if / else if / else
int age = 20;

if (age >= 20) {
    System.out.println("成人です");
} else if (age >= 13) {
    System.out.println("中高生です");
} else {
    System.out.println("子どもです");
}

// switch文
String day = "月";
switch (day) {
    case "土":
    case "日":
        System.out.println("休日");
        break;
    default:
        System.out.println("平日");
        break;
}

// 三項演算子
String label = (age >= 20) ? "成人" : "未成年";

# Python：if / elif / else
age = 20

if age >= 20:
    print("成人です")
elif age >= 13:
    print("中高生です")
else:
    print("子どもです")

# match文（Python 3.10以降）
day = "月"
match day:
    case "土" | "日":
        print("休日")
    case _:
        print("平日")

# 三項演算子
label = "成人" if age >= 20 else "未成年"

---

6. ループ

// Java

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

// 拡張forループ（foreach）
String[] cats = {"たま", "くろ", "みかん"};
for (String cat : cats) {
    System.out.println(cat);
}

// whileループ
int count = 0;
while (count < 5) {
    System.out.println(count);
    count++;
}

// インデックス付きループ
for (int i = 0; i < cats.length; i++) {
    System.out.println(i + "番目：" + cats[i]);
}

# Python

# forループ（rangeで回数指定）
for i in range(5):
    print(i)

# リストのループ
cats = ["たま", "くろ", "みかん"]
for cat in cats:
    print(cat)

# whileループ
count = 0
while count < 5:
    print(count)
    count += 1

# インデックス付きループ
for i, cat in enumerate(cats):
    print(f"{i}番目：{cat}")

# リスト内包表記（Pythonらしい書き方）
squares = [x**2 for x in range(5)]   # [0, 1, 4, 9, 16]

---

7. 関数・メソッド

// Java：メソッド（必ずクラスの中に書く）

public class Main {

    // 戻り値あり
    public static int add(int a, int b) {
        return a + b;
    }

    // 戻り値なし（void）
    public static void greet(String name) {
        System.out.println("こんにちは、" + name);
    }

    // デフォルト引数は使えない（オーバーロードで代替）
    public static void greet() {
        greet("ゲスト");
    }

    public static void main(String[] args) {
        int result = add(3, 4);     // → 7
        greet("たま");               // → こんにちは、たま
        greet();                    // → こんにちは、ゲスト
    }
}

# Python：関数（クラス外に書ける）

# 戻り値あり
def add(a, b):
    return a + b

# 戻り値なし
def greet(name):
    print(f"こんにちは、{name}")

# デフォルト引数
def greet_with_default(name="ゲスト"):
    print(f"こんにちは、{name}")

# 複数の戻り値
def min_max(numbers):
    return min(numbers), max(numbers)

result = add(3, 4)              # → 7
greet("たま")                   # → こんにちは、たま
greet_with_default()            # → こんにちは、ゲスト

minimum, maximum = min_max([3, 1, 4, 1, 5])

---

8. クラスとオブジェクト

// Java
public class Cat {

    // フィールド
    private String name;
    private String color;

    // コンストラクタ
    public Cat(String name, String color) {
        this.name  = name;
        this.color = color;
    }

    // getter
    public String getName() {
        return name;
    }

    // メソッド
    public void cry() {
        System.out.println(name + "：にゃーにゃー");
    }
}

// 使う
Cat cat1 = new Cat("たま", "白");
cat1.cry();                        // → たま：にゃーにゃー
System.out.println(cat1.getName()); // → たま

# Python
class Cat:

    # コンストラクタ
    def __init__(self, name, color):
        self._name  = name    # _ で「外から直接触わないで」を表現
        self._color = color

    # プロパティ（getter）
    @property
    def name(self):
        return self._name

    # メソッド
    def cry(self):
        print(f"{self._name}：にゃーにゃー")

# 使う
cat1 = Cat("たま", "白")
cat1.cry()         # → たま：にゃーにゃー
print(cat1.name)   # → たま

---

9. 継承

// Java
public class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void cry() {
        System.out.println(name + "が鳴いた");
    }
}

// extends で継承
public class Cat extends Animal {
    private String color;

    public Cat(String name, String color) {
        super(name);     // 親のコンストラクタを呼ぶ
        this.color = color;
    }

    @Override           // オーバーライド
    public void cry() {
        System.out.println(name + "：にゃーにゃー");
    }
}

# Python
class Animal:
    def __init__(self, name):
        self.name = name

    def cry(self):
        print(f"{self.name}が鳴いた")

# () の中に親クラスを書く
class Cat(Animal):
    def __init__(self, name, color):
        super().__init__(name)   # 親のコンストラクタを呼ぶ
        self.color = color

    def cry(self):               # オーバーライド
        print(f"{self.name}：にゃーにゃー")

---

10. 例外処理

// Java
try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("エラー：" + e.getMessage());
} catch (Exception e) {
    System.out.println("その他のエラー：" + e.getMessage());
} finally {
    System.out.println("必ず実行される");
}

// 例外を投げる
public void setAge(int age) {
    if (age < 0) {
        throw new IllegalArgumentException("年齢は0以上を指定してください");
    }
    this.age = age;
}

# Python
try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"エラー：{e}")
except Exception as e:
    print(f"その他のエラー：{e}")
finally:
    print("必ず実行される")

# 例外を投げる
def set_age(age):
    if age < 0:
        raise ValueError("年齢は0以上を指定してください")
    self.age = age

---

11. ファイル操作

// Java：ファイル読み込み
import java.io.*;
import java.nio.file.*;

// 読み込み
try {
    String content = Files.readString(Path.of("data.txt"));
    System.out.println(content);
} catch (IOException e) {
    e.printStackTrace();
}

// 書き込み
try {
    Files.writeString(Path.of("output.txt"), "書き込み内容");
} catch (IOException e) {
    e.printStackTrace();
}

// 1行ずつ読む
try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
}

# Python：ファイル読み込み

# 全文読み込み
with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()

# 1行ずつ読む
with open("data.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line.strip())

# 書き込み
with open("output.txt", "w", encoding="utf-8") as f:
    f.write("書き込み内容")

# 追記
with open("output.txt", "a", encoding="utf-8") as f:
    f.write("追記内容")

---

12. null / None チェック

// Java
String name = null;

// nullチェック
if (name != null) {
    System.out.println(name.length());
}

// null の場合にデフォルト値を使う
String display = (name != null) ? name : "名無し";

// Optional（Java 8以降）
import java.util.Optional;
Optional<String> optName = Optional.ofNullable(name);
String result = optName.orElse("名無し");

# Python
name = None

# None チェック
if name is not None:
    print(len(name))

# None の場合にデフォルト値を使う
display = name if name is not None else "名無し"

# or を使った短い書き方
display = name or "名無し"

---

書き方の違い　早見表

                    Java                        Python
────────────────────────────────────────────────────────────────
型宣言              必要（int x = 1;）           不要（x = 1）
文末                セミコロン（;）が必要         不要
ブロック            { } で囲む                   インデントで表現
クラス              必須（すべてクラスの中）       任意
コンスト名          クラス名と同じ                __init__
self                不要（thisで代替）            必ず第一引数に書く
継承                extends                      class 子(親)
オーバーライド      @Override アノテーション       同名メソッドを書くだけ
null チェック       != null                      is not None
定数                final                        大文字の慣習のみ
配列                固定長（int[]）               可変長リスト（list）
マップ              HashMap                      dict
例外を投げる        throw new XXXException()     raise XXXError()
ファイル読み込み    try-catch + BufferedReader    with open() as f
デフォルト引数      使えない（オーバーロード）     使える（def f(x=0)）
複数戻り値          使えない（配列やクラスで代替）  使える（return a, b）

---

まとめ

概念は同じ。書き方が違うだけ。

  クラスを作る     → Java: public class  Python: class
  継承する         → Java: extends       Python: class 子(親)
  ループする       → Java: for(;;)       Python: for x in
  条件分岐する     → Java: if(){}        Python: if :
  例外を扱う       → Java: try-catch     Python: try-except

「Javaで理解した概念をPythonで書き直す」
「Pythonで書いたものをJavaに翻訳する」

この練習が2つの言語を同時に定着させる一番の近道です。

---

2つの言語を並べて見ることで、
「言語が違っても考え方は同じ」が実感できるようになります。

Javaを学びながらPythonも書く。
Pythonを学びながらJavaも確認する。

その積み重ねが、どちらの言語でも書けるエンジニアへの道です。