Java基礎まとめ

# Java言語の簡単な出力

Javaでは、`System.out.println()`や`System.out.print()`メソッドを使用して標準出力に文字列や変数の値を表示できます。

```java
public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
        System.out.print("This is on the same line. ");
        System.out.print("This too!");
    }
}
```

`println()`は出力後に改行を行いますが、`print()`は改行を行いません。

# 変数の宣言

Javaでは、変数を使用する前に宣言する必要があります。変数の宣言は、データ型と変数名を指定することで行います。

```java
int age;
double height;
boolean isStudent;
String name;
```

# 変数の代入と初期化

変数の宣言と同時に初期化することもできます。また、複数の変数を一度に宣言したり初期化したりすることも可能です。

```java
int x = 5;
double pi = 3.14159;
boolean isOpen = true;
String greeting = "Hello";

int a = 1, b = 2, c = 3;
int i, j, k = 10;  // kのみ初期化
```

# 演算子

Javaには様々な演算子があります。以下は基本的な算術演算子の例です。

```java
public class OperatorExample {
    public static void main(String[] args) {
        int a = 10, b = 3;
        
        System.out.println("加算: " + (a + b));
        System.out.println("減算: " + (a - b));
        System.out.println("乗算: " + (a * b));
        System.out.println("除算: " + (a / b));
        System.out.println("剰余: " + (a % b));
        
        // インクリメント、デクリメント
        a++;
        b--;
        System.out.println("aをインクリメント: " + a);
        System.out.println("bをデクリメント: " + b);
    }
}
```

この例では、基本的な算術演算子（+, -, *, /, %）とインクリメント（++）、デクリメント（--）演算子を示しています。他にも比較演算子（==, !=, >, <, >=, <=）や論理演算子（&&, ||, !）などがあります。

# 型変換(キャスト)

Javaでは、データ型を別の型に変換することをキャストと呼びます。キャストには暗黙的なものと明示的なものがあります。

## 暗黙的キャスト
小さい型から大きな型への変換は自動的に行われます。

```java
int intValue = 100;
long longValue = intValue; // intからlongへの暗黙的キャスト
```

## 明示的キャスト
大きな型から小さな型への変換は明示的に行う必要があります。

```java
double doubleValue = 100.5;
int intValue = (int) doubleValue; // doubleからintへの明示的キャスト
System.out.println(intValue); // 出力: 100
```

## 文字列と数値の変換

文字列から数値への変換:
```java
String strNumber = "123";
int number = Integer.parseInt(strNumber);
```

数値から文字列への変換:
```java
int number = 123;
String strNumber = String.valueOf(number);
```

# 文字列の結合

Javaでは、文字列を結合するための複数の方法があります。

## +演算子を使用
```java
String str1 = "Hello";
String str2 = "World";
String result = str1 + " " + str2; // "Hello World"
```

## String.format()メソッド
```java
String formatted = String.format("%s %s", "Hello", "World"); // "Hello World"
```

## StringBuilder
```java
StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" ");
sb.append("World");
String result = sb.toString(); // "Hello World"
```

## String.join()メソッド（Java 8以降）
```java
String joined = String.join(" ", "Hello", "World"); // "Hello World"
```

# 条件文と関係演算子

Javaでは、条件分岐を制御するために関係演算子と条件文を使用します。

## 関係演算子
- `==`: 等しい
- `!=`: 等しくない
- `>`: より大きい
- `<`: より小さい
- `>=`: 以上
- `<=`: 以下

# if文

if文は単純な条件分岐を行います。

```java
int age = 18;
if (age >= 18) {
    System.out.println("成人です");
}
```

# if~else文

if~else文は二つの選択肢がある場合に使用します。

```java
int score = 75;
if (score >= 60) {
    System.out.println("合格");
} else {
    System.out.println("不合格");
}
```

# if~else if~else文

複数の条件を順番にチェックする場合に使用します。

```java
int grade = 85;
if (grade >= 90) {
    System.out.println("A");
} else if (grade >= 80) {
    System.out.println("B");
} else if (grade >= 70) {
    System.out.println("C");
} else {
    System.out.println("D");
}
```

これらの制御構造を使用することで、プログラムの流れを効果的に制御できます。

# switch文

switch文は、複数の条件分岐を簡潔に記述できる制御構造です。

```java
int day = 3;
switch (day) {
    case 1:
        System.out.println("月曜日");
        break;
    case 2:
        System.out.println("火曜日");
        break;
    case 3:
        System.out.println("水曜日");
        break;
    default:
        System.out.println("その他の曜日");
}
```

switch文は式を評価し、一致するcaseラベルの処理を実行します。

# 論理演算子

論理演算子は、複数の条件を組み合わせるために使用されます。

- `&&`: AND（かつ）
- `||`: OR（または）
- `!`: NOT（否定）

```java
int age = 25;
boolean hasLicense = true;

if (age >= 18 && hasLicense) {
    System.out.println("運転可能です");
}
```

# 条件演算子(発展)

条件演算子（三項演算子）は、if-else文を1行で記述できる簡潔な方法です。

```java
int score = 85;
String result = (score >= 60) ? "合格" : "不合格";
System.out.println("試験結果: " + result);
```

# 繰り返し文

## for文

for文は、指定した回数だけ処理を繰り返します。

```java
for (int i = 0; i < 5; i++) {
    System.out.println("カウント: " + i);
}
```

## while文

while文は、条件が真である間、処理を繰り返します。

```java
int count = 0;
while (count < 5) {
    System.out.println("カウント: " + count);
    count++;
}
```

## do~while文

do~while文は、最低1回は処理を実行し、その後条件が真である間繰り返します。

```java
int num = 1;
do {
    System.out.println("数値: " + num);
    num *= 2;
} while (num < 100);
```

# スコープ

変数のスコープは、その変数が有効な範囲を指します。

```java
{
    int x = 10; // xはこのブロック内でのみ有効
}
// ここではxは使用できない
```

# 文のネスト

制御構造は入れ子にすることができます。

```java
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        System.out.println("i: " + i + ", j: " + j);
    }
}
```

# break文

break文は、ループや switch文から即座に抜け出すために使用されます。

```java
for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break;
    }
    System.out.println(i);
}
```

# continue文

continue文は、ループの現在の反復をスキップし、次の反復に進みます。

```java
for (int i = 0; i < 5; i++) {
    if (i == 2) {
        continue;
    }
    System.out.println(i);
}
```

これらの制御構造を適切に組み合わせることで、効率的で読みやすいJavaプログラムを作成することができます。

# 配列

配列は同じデータ型の複数の要素を格納できるデータ構造です。

```java
int[] numbers = new int[5]; // 5つの整数を格納できる配列を作成
numbers[0] = 10; // 最初の要素に10を代入
```

# 多次元配列

多次元配列は、配列の要素として別の配列を持つ構造です。

```java
int[][] matrix = new int[3][3]; // 3x3の2次元配列を作成
matrix[0][0] = 1; // 最初の要素に1を代入
```

# 参照型変数としてみる配列

Javaでは、配列は参照型として扱われます。配列変数は実際の配列データへの参照を保持します。

```java
int[] arr1 = {1, 2, 3};
int[] arr2 = arr1; // arr2はarr1と同じ配列を参照
```

# メソッド

メソッドは特定の機能を持つコードブロックで、再利用可能な形で定義されます。

```java
public static int add(int a, int b) {
    return a + b;
}
```

# 引数と戻り値

引数はメソッドに渡されるデータで、戻り値はメソッドが処理を完了した後に返す結果です。

```java
public static int multiply(int x, int y) { // xとyは引数
    return x * y; // 戻り値
}
```

# メソッド・引数・戻り値のしくみ

メソッドは引数を受け取り、処理を行い、必要に応じて戻り値を返します。引数は値渡しまたは参照渡しで渡されます。

# オーバーロード

同じ名前で異なる引数を持つメソッドを複数定義することをオーバーロードと呼びます。

```java
public static int add(int a, int b) {
    return a + b;
}

public static double add(double a, double b) {
    return a + b;
}
```

# 再帰処理

メソッドが自分自身を呼び出すことを再帰と呼びます。

```java
public static int factorial(int n) {
    if (n == 0) return 1;
    return n * factorial(n - 1);
}
```

# オブジェクト指向の考え方

オブジェクト指向プログラミングは、データと操作をオブジェクトとしてまとめる考え方です。

# オブジェクト指向プログラムの構造

クラス、オブジェクト、継承、カプセル化、ポリモーフィズムなどの概念で構成されます。

# Javaによるオブジェクト指向プログラミングの基本

Javaはクラスベースのオブジェクト指向言語です。クラスを定義し、そのインスタンスを作成してプログラムを構築します。

```java
public class Car {
    private String model;
    
    public Car(String model) {
        this.model = model;
    }
}
```

# アクセス修飾子 private

privateキーワードは、クラス内部からのみアクセス可能な要素を定義します。

```java
public class Person {
    private String name;
}
```

# Setterメソッドとgetterメソッドによるフィールドの変数へのアクセス

カプセル化を実現するため、privateフィールドへのアクセスはsetterとgetterメソッドを通じて行います。

```java
public class Person {
    private String name;
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return this.name;
    }
}
```

これらの概念を理解し適切に使用することで、効率的で保守性の高いJavaプログラムを作成できます。

# アクセス修飾子

アクセス修飾子は、クラスやそのメンバーの可視性を制御します。Javaには4つの主要なアクセスレベルがあります:

1. public: すべてのクラスからアクセス可能
1. protected: 同一パッケージ内のクラスと、サブクラスからアクセス可能
1. デフォルト(修飾子なし): 同一パッケージ内のクラスからのみアクセス可能
1. private: 同一クラス内からのみアクセス可能


アクセス修飾子の使用例:

```java
public class Example {
    public int publicVar;
    protected int protectedVar;
    int defaultVar;
    private int privateVar;
}
```

# コンストラクタ

コンストラクタは、オブジェクトが生成される際に呼び出される特別なメソッドです。クラス名と同じ名前を持ち、戻り値を指定しません.

```java
public class Student {
    private String name;
    
    public Student(String name) {
        this.name = name;
    }
}
```

# コンストラクタのオーバーロード

コンストラクタもメソッドと同様にオーバーロードできます。引数の数、型、順序を変えることで複数のコンストラクタを定義できます:

```java
public class Student {
    private String name;
    private int age;
    
    public Student() {}
    
    public Student(String name) {
        this.name = name;
    }
    
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
```

# コンストラクタの発展編

コンストラクタ内で他のコンストラクタを呼び出すことができます。これはthis()を使用して行います:

```java
public class Person {
    private String name;
    private int age;
    
    public Person() {
        this("Unknown", 0);
    }
    
    public Person(String name) {
        this(name, 0);
    }
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
```

# オブジェクト指向を用いる場合と用いない場合の比較

オブジェクト指向プログラミング(OOP)の利点:
- カプセル化によるデータの保護
- コードの再利用性の向上
- 拡張性と保守性の向上

非OOPの利点:
- シンプルな問題に対してより直接的なアプローチ
- 小規模なプログラムでは実装が簡単

# インスタンス変数・インスタンスメソッド

インスタンス変数とメソッドは、クラスの各オブジェクトに固有のものです。

```java
public class Car {
    private String model; // インスタンス変数
    
    public void start() { // インスタンスメソッド
        System.out.println(model + " is starting");
    }
}
```

# クラス変数・クラスメソッド

クラス変数とメソッドは、クラスに属し、すべてのインスタンス間で共有されます。staticキーワードを使用して定義します。

```java
public class MathUtils {
    public static final double PI = 3.14159; // クラス変数
    
    public static int add(int a, int b) { // クラスメソッド
        return a + b;
    }
}
```

# 値渡しと参照の値渡し

Javaでは、プリミティブ型は値渡し、オブジェクトは参照渡しで扱われます。

```java
public class Example {
    public static void main(String[] args) {
        int x = 5;
        Integer y = new Integer(10);
        
        changeValues(x, y);
        
        System.out.println(x); // 5 (変更されない)
        System.out.println(y); // 10 (変更されない)
    }
    
    public static void changeValues(int a, Integer b) {
        a = 20;
        b = new Integer(30);
    }
}
```

この例では、xとyの値は変更されません。プリミティブ型のxは値渡しで、Integerオブジェクトのyは参照渡しですが、新しいオブジェクトが割り当てられるため元の参照は変更されません。


# クラス型(オブジェクト型)配列

クラス型の配列は、オブジェクトの参照を格納する配列です。

```java
Computer1[] coms = new Computer1[3];
for (int i = 0; i < coms.length; i++) {
    coms[i] = new Computer1();
}
```

各要素にはオブジェクトの参照を格納する必要があります[1]。

# クラスライブラリ

Javaの標準開発環境JDKには、よく使われる機能をまとめたクラスライブラリが用意されています。例えば、Scanner、System、String、Exceptionなどのクラスが含まれています[2]。

# 継承：基本編

継承は親クラスのメンバ（フィールドやメソッド）を子クラスが引き継ぐ機能です。

```java
public class ChildClass extends ParentClass {
    // 子クラスの追加メンバ
}
```

# 継承：オーバーライド

オーバーライドは、親クラスで定義されたメソッドを子クラスで再定義することです。

```java
@Override
public void parentMethod() {
    // 親クラスのメソッドを上書き
}
```

# 多態性(ポリモーフィズム)

多態性は、同じインターフェースで異なる実装を提供する能力です。継承とオーバーライドを組み合わせて実現されます。

# final修飾子

final修飾子は、クラス、メソッド、変数に使用でき、それぞれ継承、オーバーライド、再代入を禁止します。

```java
public final class FinalClass { }
public final void finalMethod() { }
final int finalVariable = 10;
```

# 抽象クラス

抽象クラスは、直接インスタンス化できないクラスで、抽象メソッドを含むことができます。

```java
public abstract class AbstractClass {
    public abstract void abstractMethod();
}
```

# instanceof演算子

instanceof演算子は、オブジェクトが特定のクラスのインスタンスであるかを確認します。

```java
if (obj instanceof ClassName) {
    // objはClassNameのインスタンス
}
```

# インターフェース

インターフェースは、メソッドの仕様を定義するもので、実装を持ちません。

```java
public interface InterfaceName {
    void methodName();
}
```

# 多重継承

Javaはクラスの多重継承をサポートしていませんが、インターフェースを通じて多重継承の概念を実現できます。

```java
public class ClassName implements Interface1, Interface2 {
    // 実装
}
```

# objectクラス

Objectクラスは、すべてのクラスの親クラスです。equals()、hashCode()、toString()などの基本的なメソッドを提供します。

# パッケージ

パッケージは、関連するクラスをグループ化する仕組みです。

```java
package com.example.mypackage;
```

# 例外処理

例外処理は、プログラム実行中に発生する異常を扱う仕組みです。

```java
try {
    // 例外が発生する可能性のあるコード
} catch (Exception e) {
    // 例外処理
} finally {
    // 必ず実行されるコード
}
```

# 独自の例外クラスの作成

独自の例外クラスを作成することで、アプリケーション固有の例外を定義できます。

```java
public class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}
```

これらの概念を理解し適切に使用することで、より堅牢で柔軟なJavaプログラムを作成できます。

# まとめ

Javaは強力なオブジェクト指向プログラミング言語であり、以下の特徴を持っています:

1. 基本構文: 変数、データ型、条件分岐、繰り返し処理などの基本的な構文を提供し、プログラムの制御を可能
1. オブジェクト指向: クラスとオブジェクト、カプセル化、継承、ポリモーフィズムという概念を中心に、再利用性、保守性、拡張性の高いプログラムの設計を可能
1. 例外処理: プログラムの異常終了を防ぎ、エラーを適切に処理する機能を提供
1. 豊富なクラスライブラリ: JDKに含まれる標準ライブラリにより、多様な機能を容易に利用
1. プラットフォーム独立性: "Write Once, Run Anywhere"の理念のもと、異なるプラットフォームで動作可能

Javaの習得には、基本構文の理解からオブジェクト指向の概念の習得まで段階的な学習が効果的です。実践的なコーディングと併せて、これらの概念を深く理解することで、効率的で保守性の高いプログラムの開発が可能になります。
最後まで読んでくださり、ありがとうございました。もし改善点や質問があれば、ぜひコメントしてください！

# 参考文献

ネットアテスト. (2024). "Javaとは? 10分でわかりやすく解説". 

https://www.netattest.com/java-2024_mkt_tst


HWdream. (n.d.). "【プログラミング入門編】Javaとは?どんな言語なの?【保存版】". 

https://hwdream.com/about-java/

侍エンジニア塾. (n.d.). "Javaの基本文法をわかりやすく解説!初心者が用語もクラスも丸わかり". 

https://www.sejuku.net/blog/107955

忍者CODEマガジン. (n.d.). "【Java入門】オブジェクト指向の基本概念". 

https://ninjacode.work/magazine/programming/%E3%80%90java%E5%85%A5%E9%96%80%E3%80%91%E3%82%AA%E3%83%96%E3%82%B8%E3%82%A7%E3%82%AF%E3%83%88%E6%8C%87%E5%90%91%E3%81%AE%E5%9F%BA%E6%9C%AC%E6%A6%82%E5%BF%B5/

インターネットアカデミー. (n.d.). "Java入門:プログラミングの必須知識!まず押さえたい基本用語集". 

https://www.internetacademy.jp/it/programming/java/basic-glossary-of-java.html

侍エンジニア塾. (2024). "Javaの基礎・基本を知識ゼロから学べる実践記事まとめ". 

https://www.sejuku.net/blog/148098