【Oracle試験対策】Java Silver見直しポイント

import java.util.*;
import java.util.regex.*;

public class Main {
 public static void main(String[] args) {
    String str = "abc";
    Pattern p = Pattern.compile("[a-z]");
    Matcher m = p.matcher(str);
    System.out.println(m.find()); //true
    }
}

public static void main(String... args) {
  // エントリーポイントとなる
}

// Java SE 11以前
javac Sample.java
java Sample a b c

// Java SE 11以降
Java Sample.java a b c

// .javaの拡張子でない「Example」というJavaプログラムの場合
java --source 11 Example a b c

// 上記のソースファイルモードは本質的に以下の操作を行なっている
javac -d {メモリ空間} Sample.java
java Sample a b c

import java.util.ArrayList;

public class Test {
  // フィールドでvarを使うとコンパイルエラー
  var sample5 = new ArrayList<Object>();
  // メソッドの引数でvarを使うとコンパイルエラー
  public void test(var value) {
  }
  public void main(String[] args) {
    // 初期化しないとコンパイルエラー
    var sample1;
    // nullで初期化するとコンパイルエラー
    var sample2 = null;
    // ラムダ式で初期化するとコンパイルエラー（右辺でキャストすればエラーにはならない）
    var sample3 = () -> {};
    // 配列の初期化式を使うとコンパイルエラー
    var sample4 = {1, 2, 3};
  }
}

String s = "hello, world";

s.replaceAll("hello", "hoge");
System.out.println(s); // hello, world

s = s.replaceAll("hello", "hoge");
System.out.println(s); // hoge, world

// Heap領域のコンスタントプールを利用
String a = "sample";
// コンスタントプールに同一の値が格納されていても新しいHeap領域を確保
String b = new String("sample");
String c = String.valueOf("sample");

String str = "hello, ";
StringBuilder strBuilder = new StringBuilder("hello, ");

System.out.println(str.concat("world"));        // hello, world
System.out.println(strBuilder.append("world")); // hello, world

String str = null;

System.out.println(str + ", world");     // null, world
System.out.println(str.concat("world")); // NullPointerException

int a = 10;
int b = ++a + a; // int b = (10 + 1) + (10 + 1)

int c = 10;
int d = c++ + c; // int d = 10 + (10 + 1)

// a: 11, b: 22, c: 11, d: 21
System.out.println(String.format("a: %s, b: %s, c: %s, d: %s", a, b, c, d));

public boolean equals(Object obj) {
  return (this == obj); // 同一性の確認
}

// プリミティブ型と参照型のコンパイルエラー
System.out.println(10 == null);
// false
System.out.println("10" == null);
// true
System.out.println(null == null);

// いずれもコンスタントプール外のHeap領域を利用
String str1 = new String("test");
String str2 = new String("test");
System.out.println(str1 == str2); // false

// internは元の文字列を破壊的に変更しない
// もしかしたらこのタイミングでコンスタントプールに値が格納されているかもしれない
str1.intern();
str2.intern();
System.out.println(str1 == str2); // false

// コンスタントプールへの参照を返す (↑でコンスタントプールに値が格納されていようが格納されていまいが関係ない)
str1 = str1.intern();
// ↑で作成されたコンスタントプールへの参照を返す
str2 = str2.intern();
System.out.println(str1 == str2); // true

// 本来こう書きたいが
if (条件A) {
} else if (条件B) {
} else if (条件C) {
} else {
}

// 誤ってこう書いてしまうと
if (条件A) {
} else
if (条件B) {
} else
if (条件C) {
} else {
}

// こう解釈されてしまう
if (条件A) {
} else {
    if (条件B) {
    } else {
        if (条件C) {
        } else {
        }
      }
  }
}

public class Main {
  public static void main(String[] args) {
    final int NUM = 0;
    int num = 10;
    switch (num) {
      // numと異なる型であるためコンパイルエラー
      case "10": break;
      // caseに変数は利用できないためコンパイルエラー
      case num: break;

      // NUMはfinalな定数であるため正常
      case NUM: break;
    }
  }
}

// intとlongが混在しているためコンパイルエラー
for (int i = 0, long j = 0; i < 6; i++)

// for (初期化文; 条件文; 更新文;)
for (int i = 0, j = 1; i < 1 && j < 2; i++, j++)

String[][] array = {{"A", "B", "C"}};

for (型 変数名: 集合) {
  // 繰り返し処理
}

label:
for () {
  for () {
    // 外側のfor文まで併せて抜ける
    break label;
  }
}

int[][] a;
int[] b[];
int c[][];

// 配列型変数 = 配列インスタンス
int[] array = new int[3];

// コンパイルエラー
int[3] array = new int[3];

// コンパイルエラー
int[] a = new int[2][3];

int[][] a = new int[3][];
a[0] = new int[1];
a[1] = new int[2];
a[2] = new int[3];

// コンパイルエラー
int[] array = new int[];

// コンパイルエラー
int[][] a = new int[][];
int[][] a = new int[][3];

// OK
int[][] a = new int[2][];
int[][] a = new int[2][3];

// OK
int[] a = new int[]{1,2};

// コンパイルエラー
int[] a = new int[2]{1,2};

int[] a;
// コンパイルエラー
a = {2,3};

class A {
  void hello() {
    System.out.println("A")
  }
}

class B extends A {
  void hello() {
    System.out.println("B")
  }  
}

public class Main {
  public static void main(String[] args) {
    // aの型はA
    A a = new A();
    // 明示的にキャストしているためコンパイルエラーは回避できる
    B b = (B) a;
    // aの型はBであるがaにはBの差分が含まれていない
    // Bのhelloメソッドを呼び出そうとしてもaにはBのhelloメソッドが含まれていない
    a.hello(); // コンパイルエラー
  }
}

public class Main {
  public static void main(String[] args) {
    // bの型はB
    B b = new B();
    // 型安全のため型変換できる
    A a = b;
    // aにはBの差分が含まれている
    // Aのhelloメソッドを呼び出すとオーバーライドされたBの差分が呼び出される
    a.hello(); // "B"
  }
}

// プリミティブ型の配列には値そのものが格納されているためDeepコピーとなる
int[] a = { 10, 20, 30 };
int[] b = a.clone();
b[0] = 100;
// a: [10, 20, 30], b: [100, 20, 30]
System.out.println(String.format("a: %s, b: %s", Arrays.toString(a), Arrays.toString(b)));

// String型はObject型であるためShallowコピーとなる
// String型はimmutableであるため書き換えようとすると新しい文字列への参照を作成して格納してしまう
// 結果としてDeepコピーのような振る舞いをする
String[] c = { "10", "20", "30" };
String[] d = c.clone();
d[0] = "100";
// c: [10, 20, 30], d: [100, 20, 30]
System.out.println(String.format("c: %s, d: %s", Arrays.toString(c), Arrays.toString(d)));

// 配列はObject型であるためShallowコピーとなる
// String型とは異なりmutableであるため参照先の値を書き換える
Object[][] e = { {"10", "20", "30"}, {"40", "50", "60"} };
Object[][] f = e.clone();
f[0][0] = "100";
// e: [[100, 20, 30], [40, 50, 60]], f: [[100, 20, 30], [40, 50, 60]]
System.out.println(String.format("e: %s, f: %s", Arrays.deepToString(e), Arrays.deepToString(f)));

// 可変長引数は最後に配置する
// 「...」はデータ型の直後に書く
void method(String name, int... a)

public class Sample {
  {
    // ここにコンストラクタ共通の処理を記述
  }
  // コンストラクタ1
  Sample() {
  }
  // コンストラクタ2
  Sample(int a) {
  }
}

public class Sample {
  static int num1 = 10;
  static int num2;
  static {
    num2 = 20;
  }
}

public class Sample {
  static int num;
  {
    num = 10;
  }
}

public class Main() {
  public static void main(String[] args) {
    // 初期化子はインスタンス化しないと実行されないためnumはintのデフォルト値である0のまま
    System.out.println(Sample.num);
    Sample s = new Sample();
    System.out.println(Sample.num);
  }
}

public class Sample {
  public Sample() {
    // コンストラクタ内から別のコンストラクタを呼び出す場合
    this("hello");
  }
  public Sample(String name) {
    // 同一クラスのメソッドを呼び出す場合
    this.Sample(name);
  }
  public void Sample(String name) {
    System.out.println(name);
  }
}

public class Sample {
  public Sample() {
    // コンパイルエラー
    System.out.println("sample")
    this("hello");
  }
  public Sample(String name) {
    System.out.println(name);
  }
}

package other;

public class Book {
  protected void sample() {
    System.out.println("sample")
  }
}

package sample;

public class StoryBook extends Book {
  // この中ではsample()にアクセスできる
}

public class Main {
  public static void main(String[] args) {
    StoryBook story = new StoryBook();
    // MainはStoryBookを継承している訳ではないためコンパイルエラー
    story.sample()
  }
}

public interface A {
  default void common() {
    System.out.println("common")
  }
}

public interface A {
  // OK
  void hello()

  // OK
  default void hello() {}

  // コンパイルエラー (何もしないという処理を記述しているため)
  void hello() {}
}

// コンパイルエラー
public class AbstractClass extends abstractA, abstractB {}

// OK
public class ConcreteClass implements interfaceA, interfaceB {}

public interface extends interfaceA {}

// sampleというデフォルトメソッド
A.super.sample();

public class Main implements A, B {
  // インタフェースA,Bに共通したデフォルトメソッドtestをOverrideしてA側を採用
  @Override
  public void test() {
    A.super.test();
  }
}

public abstract class AbstractClass {
  // インタフェースの性質
  public abstract void methodA() {}
  // クラスの性質
  public void methodB() {}
}

class A {
    String val = "A";
    void print() {
        System.out.println(val);
    }
}

class B extends A {
    String val = "B";
    void print() {
        System.out.println(val);
    }
}

public class Main {
    public static void main(String[] args) {
        // いずれも継承前のAを指定
        A a = new A();
        A b = new B();
        // いずれも型はAが指定されているので"A"が出力される
        System.out.println(a.val);
        System.out.println(b.val);
        // Aのフィールドである"A"が出力される
        a.print();
        // Bでprintをオーバーライドしているため"B"が出力される
        b.print();
    }
}

public class A {
}
public class B extends A {
  public void sample() {
  }
}

public class Main {
  public static void main(String[] args) {
    // アップキャスト
    // Bで差分として定義されたメソッドは消えるイメージ
    A a = new B();
    // コンパイルエラー
    a.sample();
  }
}

public class A {
  public A() {
  }
}
public class B extends A {
  public B(){
    // コンパイラが自動で挿入する
    super();
  }
}

// Stringを継承することはできない
public final class String extends Object {
}

// OK
() -> "hello";
() -> { return "hello"; };

// コンパイルエラー
() -> return "hello";
() -> { "hello"; };

public class Main{
  public static void main(String[] args) {
    String val = "A";
    // ラムダ式を宣言するブロック内に同名のvalが存在するためコンパイルエラー
    Function f = (val) -> {};
  }
  interface Function{
    void test(String val);
  }
}

import java.util.function.Supplier;

public class Sample{
  void Sample1() {
    int i = 0;
    // iが実質的にfinalでないためコンパイルエラー
    Supplier<Integer> foo = () -> i;
  }
  void Sample2() {
    final int i = 0;
    // iがfinalのためエラーは起きない
    Supplier<Integer> foo = () -> i;
    // iがfinalのためコンパイルエラー
    i++;
  }
}

import java.util.Comparator;

public class SampleComparator implements Comparator<Sample> {
  @Override
  public int compare(Sample s1, Sample s2) {
    // 第一引数のIdが小さい場合は第一引数の方が大きい
    if (s1.getId() < s2.getId()) return 1;
    // 第一引数のIdが大きい場合は第一引数の方が小さい
    if (s2.getId() < s1.getId()) return -1;
    // 第一引数と第二引数のIdが等しい場合は第一引数と第二引数は等しい
    return 0;
  }
}

import java.util.ArrayList;

public class Main {
  public static void main(String[] args){
    ArrayList<String> list = new ArrayList<>();
    list.add("A");
    list.add("B");
    list.add("C");
    list.add("D");
    for (String str : list) {
      // カーソルをインデックス1から2に進めるメソッド内部でmodCountが不一致となる
      // ConcurrentModificationExceptionがスローされる
      if ("B".equals(str)) {
        list.remove(str);
      }
      System.out.println(str); // A, B
    }
  }
}

import java.util.ArrayList;

public class Main {
  public static void main(String[] args){
    ArrayList<String> list = new ArrayList<>();
    list.add("A");
    list.add("B");
    list.add("C");
    list.add("D");
    for (String str : list) {
      // "C"を削除するとカーソルはインデックス3にいる
      // リストのサイズとカーソルのインデックスが比較される
      // カーソルが最後まで到達したとみなされて正常終了
      if ("C".equals(str)) {
        list.remove(str);
      }
      System.out.println(str); // A, B, C
    }
  }
}

import java.util.ArrayList;
import java.util.List; // インタフェース
import java.util.Arrays;

// 配列 (固定長)
var list = new Integer[] {1,2,3}
// Arrays$ArrayList (固定長)
var list = Arrays.asList(new Integer[] {1,2,3});
var list = List.of(1,2,3);
// ArrayList (可変長)
var list = new ArrayList<Integer>(3);

import java.util.List;

public class Main {
  public static void main(String[] args) {
    List<String> list = List.of("A", "B", "C");
    // メソッド参照
    list.forEach(System.out::println);
    // ラムダ式
    list.forEach(str -> System.out.println(str));
  }
}

public class Main {
  // mutableな参照型
  public static StringBuilder returnStringBuilder() {
    StringBuilder a = new StringBuilder("sample");
    try {
      throw new RuntimeException();
    } catch (Exception e) {
      return a;
    } finally {
      a.append("Added");
    }
  }
  // immutableな参照型
  public static String returnString() {
    String a = "sample";
    try {
      throw new RuntimeException();
    } catch (Exception e) {
      return a;
    } finally {
      a += "Added";
    }
  }
  // プリミティブ
  public static int returnInt() {
    int a = 0;
    try {
      throw new RuntimeException();
    } catch (Exception e) {
      return a;
    } finally {
      a += 10;
    }
  }
  public static void main(String[] args) {
    System.out.println(returnStringBuilder()); // 書き換え後のsampleAdded
    System.out.println(returnString()); // 書き換え前のsample
    System.out.println(returnInt()); // 書き換え前の0
  }
}

public class Main {
  // mutableな参照型
  public static StringBuilder returnStringBuilder() {
    StringBuilder a = new StringBuilder("sample");
    try {
      throw new RuntimeException();
    } catch (Exception e) {
      return a;
    } finally {
      return a.append("Added");
    }
  }
  // immutableな参照型
  public static String returnString() {
    String a = "sample";
    try {
      throw new RuntimeException();
    } catch (Exception e) {
      return a;
    } finally {
      return a += "Added";
    }
  }
  // プリミティブ
  public static int returnInt() {
    int a = 0;
    try {
      throw new RuntimeException();
    } catch (Exception e) {
      return a;
    } finally {
      return a += 10;
    }
  }
  public static void main(String[] args) {
    System.out.println(returnStringBuilder()); // 書き換え後のsampleAdded
    System.out.println(returnString()); // 書き換え後のsampleAdded
    System.out.println(returnInt()); // 書き換え後の10
  }
}

javac -d mods/hello src/hello/module-info.java src/hello/com/sample/Main.java

# java --module-path {ルートディレクトリ} -m {モジュール名}/{完全修飾クラス名}
java --module-path mods -m hello/com.sample.Main

# jarファイルの作成
jar --create --file=mlib/hello.jar --main-class=com.sample.Main -C mods/hello .
# jarファイルの実行
java --module-path mlib -m hello

module {
  exports com.sample; // 公開するパッケージ
  requires test;      // 利用するモジュール
}

module {
  requires transitive test; // このパッケージを使うものもtestモジュールを利用できるようになる
}

# 方法1: javaコマンドのオプションを利用
java --describe-module (他の引数は割愛)
# 方法2: jmodコマンドのdescribeを利用
jmod describe (他の引数は割愛)

# 何もrequiresしていなければjava.baseのみが出力される
jdeps --list-deps hello.jar

# {対象のモジュール}/{公開するパッケージ}={利用するモジュール} (他の引数は割愛)
# hogeモジュールにあるcom.testパッケージをhelloモジュールで一時的に利用できるようにする
javac --add-exports hoge/com.test=hello

# javacコマンドはpath名
javac com/sample/Main.java
# javaコマンドは完全修飾クラス名 (ただし.javaは不要)
java com.sample.Main

public class Main {
  public static void main(Str[] args) {
    int data = 1;
    // default010と表示される
    switch(data) {
      default: System.out.print("default")
      case 0:  System.out.print("0")
      case 10: System.out.print("10")
               break;
      case 20: System.out.print("20")
    }
  }
}

# -dでクラスファイルの出力先を指定
javac -d build sample/Main.java
# -cpでクラスパスを指定
java -cp build sample.Main

public class Sample {
  String name;
  public Sample(String name) {
    this.name = name
  }
}

public class SubSample extends Sample {
  String name;
  public SubSample() {}
  public SubSample1(String name) {
    // ここにsuper()が自動追加される
    // Sampleに引数なしコンストラクタが存在しないためコンパイルエラー
  }
  public SubSample1(String name) {
    // superとthisは同時に記述できないためコンパイルエラー
    super(name);
    this(name);
}

import java.util.*;

public class A {
  public List<Number> test(Set<CharSequence> s) {
    return null;
  }
}

// Setの時点でオーバーライドとなるが，その要素がCharSequenceでないため定義できない
public List<Number> test(Set<String> s)

// 引数が完全一致し，ArrayListはListの実装クラス，Numberも完全一致するためオーバーライド
public ArrayList<Number> test(Set<CharSequence> s)

// いずれも配列の要素がNumberでないためオーバーライドとみなされない
public List<Integer> test(Set<CharSequence> s)
public ArrayList<Integer> test(Set<CharSequence> s)
public ArrayList<Object> test(Set<CharSequence> s)

// オーバーロードとみなされる
public List<Integer> test(TreeSet<CharSequence> s)

// コンパイルエラー
@Override
public List<Integer> test(TreeSet<CharSequence> s)

public class Item {
  public int number;
  // 本来フィールドと同名の引数を定義しない方がよい
  public void setNumber(int number) {
    // 正しいsetter
    this.number = number
    // この場合は左辺のnumberも右辺のnumberも引数のnumberを指す
    number = number;
  }
  // フィールドと別名の引数を与えた場合
  public void setNumber(int num) {
    this.number = num
  }
}