Java/문법

#!if top = 문서명1 != null ? 문서명1 : calleeTitle != null ? (i = calleeTitle.lastIndexOf("/")) != -1 ? calleeTitle.substr(0, i) : '상위 문서' : '상위 문서'
[[파일:상위 문서 아이콘.svg|align=left&width=21.6px]] {{{#!html  }}} 상위 문서: [[]]

#!style
.table > div {
    margin: 5px 0;
}
.table td {
    border-style: solid none;
}
.sub-title {
    margin: 5px;
    padding: 3px;
    border-radius: 5px;
    background: #154c79;
    color: #fff;
    font-weight: bold;
}

#!wiki class="sub-title"
프로그래밍 언어 문법

#!wiki class="sub-title"
마크업 언어 문법

#!wiki class="sub-title"
개념과 용어

#!wiki class="sub-title"
기타

1. 개요

2. 파일 구조

3. 패키지

#!syntax java
package com.example;

public class Main {
    void main() {
        IO.println(this.getClass()); // class com.example.Main
    }
}

#!syntax java
public class Main {
    void main() {
        IO.println(this.getClass()); // class Main
    }
}

4. import

#!syntax java
package com.example;

import java.util.List;
import java.util.ArrayList;
import java.io.*; // java.io 패키지의 모든 클래스를 import 한다. 하위 패키지의 클래스는 import되지 않는다.
//import java.lang.String; // java.lang 패키지는 import 없이 접근할 수 있다.
import static java.lang.Math.IP; // Math.PI가 아닌 PI만올 접근할 수 있다.

public class Main {
    void main() {
        List<String> list = new ArrayList<>();
        IO.println(PI); // 파이값 출력
        java.util.Set set = new java.util.HashSet<>(); // import 없이 사용.
        var file = new File("file.txt"); // com.example.File 객체가 만들어진다.
        var file2 = new java.io.File("file.txt"); // java.io.File 객체가 만들어진다.
    }
}

// File.java
package com.example;

class File {
    public File(String str) {
    }
}

5. 타입

5.1. 원시 타입

• 정수
• byte: -128~127
• short: -32768~32767
• int: -2147483648~2147483647
• long: -9223372036854775808~9223372036854775807
• 실수
• float: 약 -340간~340간 (절댓값이 1/14재 보다 작을 수 없다.)
• double: 약 -(1구골)³~(1구골)³ (절댓값이 약 1/(1구골)³ 보다 작을 수 없다.)[3]
• 논리
• boolean: true 또는 false
• 문자
• char: 0~65535

5.1.1. 정수

#!syntax java
long namu = 1000000000000L;

5.1.2. 실수

5.1.3. 문자

#!syntax java
char namu = 'A';

5.2. 객체 타입

5.2.1. 래퍼 클래스

#!syntax java
int a = 2;
Integer b = new Integer(a);
int c = b.intValue();

5.3. String

#!syntax java
String a = new String("abc");
String b = "abc";

#!syntax java
String a = "abc";
String b = a;
a += "def"; // a의 값이 "abcdef"가 됨.
IO.println(b) // abc 출력

#!syntax java
String a = "abc";
String b = "abc";
String c = new String("abc");

IO.println(a == b); // true
IO.println(a == c); // false
IO.println(a.equals(c)); // true

5.4. void

5.5. 배열

#!syntax java
int[] intArray;
String strArray[];

#!syntax java
int[] intArray = new int[3];
String[] strArray = {"hello", "world", "example"};

#!syntax java
IO.println(strArray[0]); // 'hello'를 출력
IO.println(strArray[1]); // 'world'를 출력
IO.println(strArray[2]); // 'example'을 출력

#!syntax java
intArray[0] = 1;
intArray[1] = 3;
intArray[2] = -10;

#!syntax java
IO.println(intArray[3]);
strArray[-1] = "text";

5.6. 컬렉션

• Collection: 컬렉션의 최상위 타입. 추가, 제거, 포함 여부 등 공통적인 메서드를 가지고 있다.
• List: 순서를 유지하며 값의 중복 허용하는 컬렉션.
• ArrayList: 배열의 형태로 값을 저장하는 List. 배열의 특징상 임의 접근이 빠르지만, 중간에 값을 추가/제거하는 경우 그 뒤의 모든 인덱스를 바꿔야 해서 느리다.
• LinkedList: 각 값이 이전 값과 다음 값을 지정하는 방식. 중간에 값 삽입/제거가 빠르지만 임의 접근은 처음 값 또는 마지막 값에서 순차적으로 탐색해야 해서 느리다.
• Vector: 하위호환을 위해 남겨진 컬렉션으로 ArrayList와 동일하나 멀티 스레드에서 안전하도록 동기화되어 있다.
• Stack: 하위호환을 위해 남겨진 컬렉션으로 먼저 추가된 데이터가 가장 마지막에 나온다.
• Queue
• PriorityQueue: 우선순위에 따라 저장된 원소를 순차자적으로 꺼낼 수 있다.
• Deque
• ArrayDeque: 양방향으로 추가하고 꺼낼 수 있다. 스택 + 큐.
• LinkedList: List와 Queue를 모두 구현하므로 위의 것과 동일하다.
• Set: 순서를 유지하지 않고, 값의 중복을 허용하지 않는다. 즉, 집합.
• HashSet: 해시 기반으로 데이터를 저장하는 Set.
• LinkedHashSet: HashSet과 동일하나, 순서를 유지한다.
• SortedSet
• TreeSet: 순서를 정렬하여 저장하는 Set.
• Map: Iterable을 구현하지 않는다. 키-값이 쌍으로 저장되는 Set이라고 보면 된다.[13] 키는 중복될 수 없지만, 값은 중복될 수 있다.
• HashTable: 하위호환을 위해 남겨진 컬렉션으로 멀티 스레드에서 안전한 Map이다.
• HashMap: 해시 기반으로 데이터를 저장하는 Map.
• LinkedHashMap: HashMap과 동일하나, 순서를 유지한다.
• SortedMap
• TreeMap: 순서를 정렬하여 저장하는 Map.

6. 변수 선언

#!syntax java
int namu;

#!syntax java
namu = 3;

#!syntax java
int namu = 3;

#!syntax java
final int namu = 3;

#!syntax java
var namu = 3;

#!syntax java
IO.println(namu);

#!syntax java
namu = namuwiki;

6.1. 전역/지역 변수

6.2. 가변/불변 변수와 상수

#!syntax java
public class A {
    public final int someIntValue;
    public static final int SOME_INT_VALUE = 2;

    public A(int i) {
        someIntValue = i;
    }
}

7. 출력

#!syntax java
System.out.println("Hello, World!");

#!syntax java
System.err.println("Error message");

#!syntax java
System.out.print("Hello, World!\n");

#!syntax java
String str = "World!"
System.out.printf("Hello, %s\n", str);

#!syntax java
IO.println("Hello, World!");
IO.print("Hello, World!\n");

8. 입력

#!syntax java
int i = System.in.read();

#!syntax java
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = br.readLine();

#!syntax java
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();

#!syntax java
String str = IO.readln();

9. 연산자

9.1. 산술

#!syntax java
a + b;
a - b;
a * b;
a / b;
a % b;

9.2. 증감

#!syntax java
++a;
--a;
a++;
a--;

9.3. 부호

#!syntax java
+a;
-a;

9.4. 비교

#!syntax java
a == b;
a != b;
a > b;
a < b;
a >= b;
a <= b;

9.5. 논리

#!syntax java
a && b;
a || b;
!a;

9.6. 비트

#!syntax java
a & b;
a | b;
a ^ b;
~a;

9.7. 시프트

#!syntax java
a << b;
a >> b;
a >>> b;

9.8. 대입

#!syntax java
x = a;
x += a;
x -= a;
x *= a;
x /= a;
x %= a;
x &= a;
x |= a;
x ^= a;
x <<= a;
x >>= a;
x >>>= a;

9.9. 조건

#!syntax java
a ? b : c;

9.10. 형변환

#!syntax java
(T) a;

9.11. instanceof

#!syntax java
obj instanceof T

#!syntax java
obj instanceof T t

9.12. 기타 특수 연산자

#!syntax java
arr[i];
method();
new Class();
obj.field;
(a, b) -> a + b;
obj::method;

9.13. 우선순위

10. 조건문

10.1. if

#!syntax java
if (expression) {
    //statement
}

#!syntax java
if (expression) {
    //statement1
else {
    //statement2
}

#!syntax java
if (exp1) {
    //stmt1
} else if (exp2) {
    //stmt2
} else if (exp3) {
    //stmt3
}
...
} else {
    //stmtN
}

#!syntax java
if (exp1) stmt1;
else if (exp2) stmt2;
else stmt3;

10.2. switch

#!syntax java
switch (exp) {
    case value1:
        stmt1;
        break;
    case value2:
        stmt2;
        break;
...
    default:
        stmtN;
}

#!syntax java
switch (exp) {
    case value1:
        stmt1;
    case value2:
    case value3:
        stmt2;
        break;
    case value4:
        stmt3;

#!syntax java
switch (exp) {
    case value1 -> stmt1;
    case value2 -> {
        stmt2;
        stmt3;
    }
    case value3, value4 -> stmt4
    default -> stmt5;
}

#!syntax java
var a = switch (exp1) {
    case value1:
        yield exp2;
    case value2:
        stmt1;
        yield exp3;
    default:
        yield exp4;
}

#!syntax java
switch (exp) {
    case "hello" -> stmt1;
    case String s -> stmt2;
    case Integer i when i > 0 -> stmt3;
    case Integer i -> stmt4;
    case null -> stmt5;
    default -> stmt5;
}

11. 반복문

11.1. while

#!syntax java
while (exp) {
    stmt;
}

#!syntax java
while (true) stmt;

11.1.1. do-while

#!syntax java
do {
    stmt;
} while (exp)

11.2. for

#!syntax java
for (exp1; exp2; exp3) {
    stmt;
}

#!syntax java
exp1;
while (exp2) {
    stmt;
    exp3;
}

#!syntax java
for (int i = 0; i < n; i++) {
    stmt;
}

11.2.1. for-each

#!syntax java
Collection<E> collection = ...

for (E e : collection) {
  stmt;
}

#!syntax java
E[] arr = ...
E[] temp = arr;

for (int i = 0; i < temp.length; i++) {
    E e = temp[i];
    stmt;
}

#!syntax java
Collection<E> collection = ...
Iterator<E> iterator = collection.iterator();

while (iterator.hasNext()) {
    E e = (E) iterator.next();
    stmt;
}

11.3. 분기

#!syntax java
for (var e : arr) {
    if (e == null) continue;
    IO.println(e.toString())
}

#!syntax java
while (true) {
    var str = IO.readln("비밀번호:");
    if (str.equals("pass")) break;
}

12. 라벨

#!syntax java
outer: for (var arr : arr2d) for (var e : arr) {
    if (...) continue outer;
}

#!syntax java
loop: do {
    stmt;
} while (exp)

ifLabel: if (exp) {
    stmt;
}

sw: switch (exp) {
    case value1 -> stmt1;
    case value2 -> stmt2;
}

t: try {
    stmt1;
} catch (...) {
    stmt2;
}

syncBlock: synchronized (...) {
    stmt;
}

stmtBlock: {
    stmt;
}

13. 메인 메서드

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

#!syntax java
public class Main {
    void main() {
        IO.println("Hello, World!");
    }
}

#!syntax java
void main() {
    IO.println("Hello World!");
}

14. 제어자

14.1. 접근 제어자

• public: 공개. 어디에서나 접근 가능하다.
• protected: 보호. 동일 패키지에서만 접근 가능하지만, 상속관계라면 다른 패키지에서도 접근 가능하다. 클래스는 사용 불가.
• default: package-private, 패키지 비공개. 동일 패키지에서만 접근 가능하다.
• private: 비공개. 해당 클래스에서만 접근 가능하다. 클래스는 사용 불가.

14.2. 기타 제어자

• static: 이 제어자가 붙은 요소는 정적 요소가 되어 인스턴스 없이 접근 가능하다. 자세한 차이는 클래스 문단에 후술. 클래스는 사용할 수 없지만 중첩 클래스는 사용할 수 있다.
• final: 수정 불가. 클래스는 상속 불가, 메서드는 재정의 불가, 변수는 불변 변수 또는 상수가 된다.[33]
• abstract: 추상. 메서드와 클래스에 사용 가능하며, 추상 메서드가 존재하는 클래스는 이 제어자를 붙여 추상 클래스로 선언해야 한다. 추상 메서드의 내부를 구현하지 않고, 자식 클래스가 재정의하여 사용하도록 한다.
• synchronized: 동기화. 메서드에 사용 가능하며, 여러 스레드가 동시에 접근할 수 없도록 한다.
• native: 메서드에서 사용 가능하며, 해당 메서드를 다른 언어(C, C++ 등)로 작성된 함수로 선언한다.
• strictfp: 클래스와 메서드에서 사용 가능하며, 부동소수점 연산이 항상 일정하게 된다. java 17에서는 기본값이 되어 제거되었다.
• transient: 변수에 사용 가능하며, 직렬화에서 제외된다.
• volatile: 변수에 사용 가능하며, 멀티 스레드 환경에서 변수의 가시성을 보장한다.

15. 메서드

#!syntax java
// 반환 타입과 메서드이름을 쓰고 뒤에 소괄호를 붙인다.
void name() {
    // 메서드 내용
}

#!syntax java
public void myMethod(int i) {
    // 메서드 내용
}

#!syntax java
// 두 정수를 받고 더한 결과를 반환하는 메서드
public int sum(int a, int b) {
    return a + b;
}

#!syntax java
// 문자열들을 받아 하나의 문자열로 결합 후 출력하는 메서드
public void printJoinedText(String... args) {// 가변 매개변수이다. 배열로 취급된다.
    if (args.length == 0) return; // return은 값 반환 뿐만 아니라 메서드 종료도 하므로 args가 비어있을 경우 아래코드가 실행되기 전에 메서드가 종료된다.
    IO.println(String.join(", ", args)); // 문자열 배열을 하나의 문자열로 합친다. ", "로 원소가 이어진다.
    // return;이 생략되었다.
}

15.1. 오버로딩

#!syntax java
public void println() {
    IO.println();
}
public void println(int i) {
    IO.println(i);
}
public void println(String s) {
    IO.println(s);
}
public void println(int i, String s) {
    IO.println(i + s);
}
public void println(String s, int i) {
    IO.println(s + i);
}

#!syntax java
public void print(Object o, boolean newLine) {
    IO.print(o);
    if (newLine) println();
}
public void print(Object o) {
    print(o, false);
}

#!syntax java
public void print(int i) {
    IO.println(i);
}
public void print(int... args) {
    for (var i : args) IO.print(i);
    println();
}
public void print(String... args) {
    for (var i in args) IO.print(i);
    println();
}

16. 클래스

• 유용한 정적 메서드 및 변수를 모아둔 클래스.[34]
• 비정적 메서드 및 변수를 활용하여 여러 객체를 만들고 활용하는 클래스.[35][36]
• 객체로 다루지 않지만, 비정적 메서드 및 변수를 활용하는 싱글톤 패턴.

16.1. 유틸리티 클래스

#!syntax java
// Utils.java
public class Utils
    public static final int PI = 3.14159;

    public static int getAreaOfSquare(int width, int height) {
        return width * height;
    }

    public static double getAreaOfTriangle(int base, int height) {
        return base * height / 2.0;
    }

    public static double getAreaOfCycle(int radius) {
        return Math.pow(radius, 2) * PI;
    }
}

16.2. 데이터 클래스

• 클래스: 객체의 형태를 결정하는 구조. 즉, 데이터 타입이다.
• 객체: 클래스에서 생성된 실체. 즉, 그 타입의 값이다.
• 인스턴스: 객체와 거의 동일하며, 객체와 클래스의 관계를 더 중시할 때 사용된다. 즉, 모든 인스턴스는 객체지만, 모든 객체가 특정 클래스의 인스턴스는 아닐 수 있다.
• 생성자: 객체가 만들어 질 때 최초 실행되는 특수한 메서드. 보통 입력 받은 값이나 기본값으로 필드를 초기화하는 등의 작업을 한다. 메서드이기에 오버로딩이 가능하다. 단, 재정의는 불가능.
• 속성: 필드, Getter, Setter를 하나로 부르는 용어.
• 비정적 변수(필드): 객체 내부의 값. ArrayList의 경우 배열, 배열의 크기 등을 가진다.
• 비정적 메서드(메서드): 객체에 대하여 동작을 하는 함수. String에서는 문자열을 전부 대문자로 바꾸는 toUpperCase(), 문자열의 길이을 가져오는 length() 등이 있으며, ArrayList에서는 배열에 값을 추가하는 add(), 값이 포함되어 있는지 확인하는 contains() 등이 있다.

#!syntax java
// Person.java
public class Person {
    // 정적 변수를 사용할 수 있다. 모든 객체가 공유하는 필드라고 생각하면 된다.
    private static final String SPECIES = "Homo sapiens";

    // 사람의 이름. 각 객체별로 다른 필드를 가져 공유되지 않는다.
    // 이 경우 final을 붙여도 되며, 생성자에서 한번 초기화하고 읽기 전용이 된다. 객체마다 값이 다를 수 있으므로 상수가 아닌 불변 변수라고 부른다.
    private String name;

    // 생성자. 객체를 생성할때 new 키워드와 함께 사용된다.
    public Person(String name) {
        // this는 객체 자기 자신을 가리킨다.
        this.name = name;
    }

    // 비정적 메서드. name 필드의 값을 리턴한다.
    public String getName() {
        return name; // this.name과 동일
    }

    // 마찬가지로 정적 메서드를 사용할 수 있다. 객체에 대하여 호출하는게 아니기에 비정적 변수 및 메서드를 직접 활용할 수 없다.(어떤 인스턴스의 필드를 가리키는지 모르기 때문.)
    public static String getSpecies() {
        return SPECIES;
    }
}

// Main.java
void main() {
    // Person 타입의 myPerson 변수를 만들고, new Person("John")이 만드는 인스턴스를 값으로 저장한다.
    Person myPerson = new Person("John"); // 새로운 객체를 생성하려면 new 키워드를 사용한다.
    IO.println(myPerson.getName()); // John
    IO.println(Person.getSpecies()); // Homo sapiens
}

16.2.1. Getter와 Setter

• 왜 사용하는가?
  캡슐화라던가 정보 은닉 같은 개념이 있지만 그래서 결론은, 개발자가 의도하지 않은 값이 들어가는 것을 방지하는 용도다.
  예를 들어 자동차 클래스에서 속력을 저장하는 int 필드는 음수가 될 수 없을 것이다. 하지만 필드가 public이라면 음수가 대입될 수 있으므로 필드를 private으로 설정하고 Setter메서드에서 대입할 값이 음수인지를 확인하여 예외를 던지거나 0을 대입하는 방식을 사용할 수 있다.
  Getter의 경우, 컬렉션 같은 가변 객체의 경우, 그대로 넘기면 add(), clear() 메서드 등으로 수정될 수 있으므로 객체를 복사해서 넘기거나 불변으로 넘기는 등으로 바꾸거나, 여러개로 나뉜 필드를 종합하여 값을 넘길 수 있다.
  그 외에도 읽기 전용이나, 접근 범위를 다르게 하는 용도로 쓸 수 있다.

• 사용하지 않아도 되는 경우
  개인이 사용할 프로그램의 경우, 주석으로 충분하기에 편리한 접근과 코드를 줄이기 위해 필드를 public으로 쓸 수 있다. 하지만, 나중을 위해 getter와 setter를 처음부터 사용하는 것을 추천한다.[37]

• 암묵적인 규칙
• Getter
  반환 타입이 void가 아니고, 매개 변수가 없으며, 메서드 이름을 'get변수이름'[38]으로 설정한다. boolean을 반환하는 메서드는 'is변수이름'으로 쓸 수 있다.
• Setter
  반환 타입이 void고, 매개 변수를 받으며, 메서드 이름을 'set변수이름'으로 설정한다.

• 예시

#!syntax java
// 자동차 클래스
public class Car {
    private int speed = 0; // 속도
    private int gear = 0; // 기어. 0부터 차례대로 P, R, N, D를 뜻한다.
    private final List<Object> trunk = new ArrayList<>(); // 트렁크
    private String licensePlate = "12가 3456"; // 번호판

    public int getSpeed() {
        return speed;
    }
    public void setSpeed(int speed) {
        if (speed < 0) throw new IllegalArgumentException("속력은 음수가 될 수 없음"); // 잘못된 대입 방지
        this.speed = speed;
    }

    public String getGear() { // 알아보기 힘든 int를 문자열로 바꿔서 반환
        return switch (gear) {
            case 0 -> "P";
            case 1 -> "R";
            case 2 -> "N";
            case 3 -> "D";
            default -> throw new RuntimeException("도달할 수 없는 코드");
        };
    }
    public void setGear(String gear) {
        this.gear = switch (gear) {
            case "P" -> 0;
            case "R" -> 1;
            case "N" -> 2;
            case "D" -> 3;
            default -> throw new IllegalArgumentException("잘못된 변속");
        };
    }

    public List<Object> getTrunk() {
        return Collections.unmodifiableList(trunk); // List를 수정 불가로 바꿔서 반환
    }
    public void addObjectInTrunk(Object object) {
        if (object instanceof Person) throw new IllegalArgumentException("잘못된 물건"); // 사람을 트렁크에 넣을 수 없다.
        trunk.add(object);
    }
    public void removeObjectInTrunk(Object object) {
        if (!trunk.contains(object)) throw new IllegalArgumentException("존재하지 않는 물건"); // 없는 물건을 꺼낼 수 없다.
        trunk.remove(object);
    }

    public String getLicensePlate() {
        return licensePlate;
    }
    void setLicensePlate(String licensePlate) { // 아무나 번호판을 변경할 수 없다.
        this.licensePlate = licensePlate;
    }
}

16.3. 싱글톤 패턴

#!syntax java
// Config.java
public class Config {
    private static Config instance = new Config();

    public static Config getConfig() {
        return instance;
    }

    private int intOption;
    private boolean boolOption;

    private Config() {
        loadConfig();
    }

    private loadConfig() {
        intOption = ...
        boolOption = ...
    }

    //Getter, Setter 생략
}

// Main.java
void main() {
    var i = Config.getConfig().intValue;
    var b = Config.getConfig().boolValue;
}

#!syntax java
public class Config {
    private static Config instance; // 자동으로 null로 초기화된다.

    public static Config getConfig() {
        if (instance == null) instance = new Config();
        return instanace;
    }
}

16.4. 상속

#!syntax java
// Student.java
public class Student extends Person {
    private double gpa;

    public Student(String name, double gpa) {
        super(name); // 부모 클래스 Person의 생성자를 호출. 반드시 호출해야 하며, 생성자 호출 전에 코드를 쓸 수 있지만, 현재 객체에 접근하는 코드는 쓸 수 없다.
        this.gpa = gpa;
    }
    public double getGPA() {
        return gpa;
    }

    public String getNameWithGPA() {
        return getName() + "_" + gpa; // 부모 클래스의 메서드를 호출할 수 있다.
    }
}
// Main.java
void main() {
    Student joe = new Student("Joe", 4.0);
    // Student는 Person이기도 하므로 Person의 getName() 메서드를 사용할 수 있다.
    IO.println(joe.getName()); // Joe
    IO.println(joe.getGPA()); // 4.0
    IO.println(joe instanceof Person); // true
    Person p = new Student("p", 2.0); // 타입을 부모 클래스로 지정할 수 있다. 단, 부모 클래스에 존재하는 필드와 메서드만 접근 가능하다.
    IO.println(p.getName()); // p
    if (p instanceof Student s) IO.println(s.getNameWithGPA()); // p_2.0
    else IO.println("p is not student"); // 호출되지 않는다.
    printName(joe); // Student 타입은 Person의 하위 타입이므로 자동으로 항변환된다.
}

void printName(Person p) {
    IO.println(p.getName());
}

#!syntax java
// Parent.java
public class Parent {
    public int i = 1;

    public void printHello() {
        IO.println("Hello");
    }
}

// Child.java
public class Child extends Parent {
    public int i = 3;

    @Override // 생략할 수 있지만 쓰는걸 추천한다.
    public void printHello() {
        IO.println("Hello, World!");
    }

    public void print() {
        IO.println(i);
        IO.println(super.i);
        printHello();
        super.printHello();
    }
}

// Main.java
void main() {
    Child c = new Child();
    c.printHello(); // Hello, World!
    IO.println(c.i); // 3
    Parent p = c;
    p.printHello(); // Hello, World!
    IO.println(p.i); // 1
    c.print(); // 순서대로 1, 3, "Hello, World!", "Hello" 출력
}

16.5. 추상 클래스

#!syntax Java
// Animal.java
public abstract class Animal {
    public abstract void sound();
    public void eat(String food) {
        IO.println(food + "을/를 먹습니다.");
    }

    public Animal() {
        IO.println("객체 생성")
    }
}

// Dog.java
public class Dog {
    @Override
    public void sound() {
        IO.println("멍멍");
    }
}

16.6. Object

• boolean equals(Object obj): 자기 자신과 매개변수를 비교한다. '두 객체가 같다.'는 이 메서드가 true를 반환한다는 뜻이다. 객체 타입간 == 연산자는 주소를 비교하므로 이 메서드를 재정의하여 사용자가 원하는 비교를 가지도록 해야 한다. 기본값은 ==과 동일한 비교를 한다.
• int hashCode(): 자기 자신의 해시 코드를 반환한다. 대표적으로 HashSet 등에서 사용되는데, equals만으로 객체를 찾기에는 속도가 느리므로 hashCode로 1차 비교 후 그 중 equals로 동일한 객체를 찾는다. 때문에 동일한 객체는 반드시 동일한 해시 코드를 반환하도록 재정의해야 한다. 반대로 해시 코드가 같아도 equals가 false일 수 있다.
• String toString(): 자기 자신을 문자열 형태로 반환한다. IO.println();이 인자로 null이 아닌 Object 객체를 받을 경우, 이 메서드로 얻은 문자열을 출력한다. 기본적으로 "클래스이름@해시코드"를 반환하므로 재정의하게 된다. 예시로 ArrayList는 [ 원소1, 원소2, 원소3 ] 이런 식의 문자열을 반환한다.
• String getClass(): 자기 자신의 클래스를 반환한다. 변수의 타입과 무관하게 실제 객체의 타입을 반환하며 예를 들어 String 객체는 "class java.lang.String"을 반환한다. 재정의 불가능하다.

17. 인터페이스

#!syntax java
// Incrementable.java
public interface Incrementable {
    String NAME = "Incrementable";
    void increment();
    default void printMessage() {
        IO.print("디폴트 메서드 | ");
        helper();
    }
    private void helper() {
        IO.println("private 메서드");
    }
    static void printMe() {
        IO.println("Incrementable interface");
    }
}

// Person.java
public class Person implements Incrementable {
    public int age;

    public Person(int age) {
        this.age = age;
    }

    @Override
    public void increment() {
        age++;
    }

// Main.java
void main() {
    Person p = new Person(1);
    p.increment();
    IO.println(p.age); // 2
    IO.println(p instanceof Incrementable); // true
    p.printMessage(); // 디폴트 메서드 | private 메서드
    Incrementable.printMe(); // Incrementable interface
    IO.println(Incrementable.NAME); // Incrementable
}
}

#!syntax java
public class Child extends Parent implements IntOne, IntTwo, IntThree {
}

#!syntax java
public interface Collection extends Iterable {
}

#!syntax java
public void printAll(Iterable iterable) {
    for (Object e : iterable) IO.println(e);
}

17.1. 함수형 인터페이스

#!syntax java
@FunctionalInterface // 없어도 된다.
public interface Runnable {
    void run();
}

18. Enum

#!syntax java
// Day.java
enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

// Main.java
void main() {
    Day day = Day.MONDAY;

    if (day == Day.SATURDAY || day == Day.SUNDAY) IO.println("주말 입니다.");


    var text = switch (day) {
        case Day.MONDAY -> "월요일";
        case Day.TUESDAY -> "화요일";
        case Day.WEDNESDAY -> "수요일";
        default -> {
            return;
        }
    }

    IO.println(text);
}

#!syntax java
enum Constant {
    PI(3.14), E(2.71), ROOT2(1.41);

    private final double value;

    Constant(double value) {
        this.value = value;
    }

    public double getValue() {
        return value;
    }
}

19. 예외

• Throwable: 예외의 최상위 클래스. 이 클래스를 상속하는 클래스는 던질 수 있고, catch 블록에서 받을 수 있다.
• Error: 치명적 오류. JVM에 문제가 발생하거나 메모리가 부족하는 등의 상황에서 발생한다. catch 블록에서 처리할 수 있지만 보통 처리한다고 해결되는 수준이 아니므로 그냥 냅둔다.[48]
• Exception: 사실상 예외의 최상위 클래스.
• RuntimeException: checked 예외와 unchecked 예외를 구분하는 클래스. 이 클래스와 그 하위 클래스는 unchecked 예외이고, 나머지는 checked 예외다. Error는 그 특징 때문에 unchecked 예외로 구분된다.

#!syntax java
public void method() {
  RuntimeException e = new RuntimeException();
  throw e;
} 

#!syntax java
public void method() thorws Exception {
  throw new Exception();
}

#!syntax java
void main() {
    method1();
    IO.println("main method"); // 실행되기 전에 메인 메서드가 끝나 프로그램이 종료된다.
}

public void method1() {
    method2();
    IO.println("method1") // 실행되기 전에 윗줄에서 메서드가 끝난다.
}
public void method2() {
    throw new RuntimeException();
    IO.println("method2"); // 실행되기 전에 윗줄에서 메서드가 끝난다.
}

#!syntax java
// StopSignal.java
public class StopSignal extends Throwable {
}

// Main.java
void main() {
    try {
        ...
    catch (StopSignal _) {
        IO.println("프로그램 중지됨.");
    }
}

19.1. try

• try: 이 블록의 코드에서 예외가 발생하면 다음 블록으로 넘어간다.
• catch: try에서 던져진 예외를 받는 블록. 받을 예외[51]를 정해야 하며, 대상이 아닌 예외는 다음 catch 블록으로 이동한다. 한 catch 블록에서 여러 예외를 잡으려면 | 로 구분한다. 매개변수는 동일해야 한다.
• finally: 이 문법에서 마지막에 무조건 실행되는 블록. 이 블록은 가장 밑에 있어야 한다. 해당 메서드가 반환되더라도 실행되며 이 블록에서 반환이나 예외를 던지면 이전의 반환이나 던져진 예외는 무시된다. Closeable을 구현한 객체의 close() 메서드를 호출할 때 사용한다.[52]

#!syntax java
try {
    IO.println("Hello, World!");
} finally {
    IO.println("이 문자열은 반드시 출력된다.");
}

#!syntax java
String str = "1234a";
try {
    int i = Integer.parseInt(str); // 문자열을 정수로 변환한다. 이 경우, a 때문에 NumberFormatException을 발생시킨다.
} catch(NumberFormatException _) {
    System.err.println("잘못된 문자열"); // 에러 메시지를 출력한다.
} catch (IOExceptoin | RuntimeException e) { // IOException 또는 RuntimeException을 잡는다.
    e.printStackTrace(); // printStackTrace()는 현재 예외의 정보(종류, 메시지, 원인 등)와 함수 호출 트리를 보여준다.
} catch (Throwable e) {
    e.printStackTrace(); // 오류 포함 모든 예외를 잡는다. 상술했듯 오류는 처리를 안하기에 잘 사용되지 않는다.
} catch (Error e) {
    e.printStackTrace(); // 이 catch 블록은 모든 오류를 잡지만, 위의 Throwable을 잡는 catch 블록 때문에 실제로는 작동하지 않는다.
}

#!syntax java
BufferedReader reader = null;
try {
    reader = new BufferedReader(new FileReader("example.txt")); // example.txt 파일을 가져온다.
    String line;
    while ((line = reader.readLine()) != null) IO.println(line); // 파일의 내용을 한줄 씩 출력한다.
} catch (Exception e) {
    System.err.println("파일 읽기 실패: " + e.getMessage()); // 모든 예외를 잡는 catch 블록이다. 예외를 잡은 후, 예외 메시지를 출력한다.
} finally {
    if (reader != null) {
        try {
            reader.close(); // 무조건 실행되는 finally 블록의 특징을 활용하여 자원을 닫는다.
        } catch (IOException e) {
            System.err.println("파일 닫기 실패: " + e.getMessage());
        }
    }
}

#!syntax java
try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) { // 여러 객체를 선언하려면, 세미콜론(;)을 사용하여 구분한다.
    String line;
    while ((line = reader.readLine()) != null) IO.println(line);
} catch (Exception e) {
    System.err.println("파일 읽기 실패: " + e.getMessage());
} // 이후 자동으로 reader.close(); 를 실행한다.

#!syntax java
try {
    BufferedReader reader = new BufferedReader(new FileReader("example.txt"));
    Throwable primaryException = null;
    try {
        String line;
        while ((line = reader.readLine()) != null) IO.println(line);
    } catch (Throwable t) {
        primaryException = t;
        throw t;
    } finally {
        if (reader != null) {
            if (primaryException != null) {
                try {
                    reader.close();
                } catch (Throwable closeEx) {
                    primaryException.addSuppressed(closeEx);
                }
            } else reader.close();
        }
    }
} catch (Exception e) {
    System.err.println("파일 읽기 실패: " + e.getMessage());
}

20. 제네릭

• T: Type. 가장 많이 쓰이며, 두 번째는 U로 표현한다.
• R: Result. 결과를 의미한다.
• E: Element. 컬렉션에서 주로 쓰인다.
• K: Key. 아래 V와 함께 주로 Map에서 쓰인다.
• V: Value.
• N: Number.

20.1. 클래스/인터페이스

#!syntax java
// Wrapper.java
public class Wrapper<T> {
  private final T content;

  public Wrapper(T content) {
    this.content = content;
  }
  
  public T getContent() {
    return this.content;
  }
}

// Main.java
void main() {
    Wrapper<String> myWrapper1 = new Wrapper<>("Namu Wiki"); // new Wrapper뒤에 <>를 붙여야한다.
    Wrapper<Integer> myWrapper2 = new Wrapper<Integer>(44); // java 6 까지는 타입까지 표기해야 한다.
    IO.println(myWrapper1.getContent()); // Namu Wiki
    IO.println(myWrapper2.getContent()); // 44
}

#!syntax java
void main() {
    List list1 = new ArrayList();
    list1.add("abc");
    list1.add(2); // 작동한다.
    String s1 = (String) list1.get(0);

    List<String> list2 = new ArrayList<>();
    list2.add("abc");
    //list2.add(2); // 불가능하다.
    String s2 = list2.get(0);
}

20.2. 메서드

#!syntax java
public Object firstObj(Object a, Object b) {
    return a;
}
public <T> T firstT(T a, T b) {
    return a;
}

void main() {
    String a = (String) firstObj("a", "b"); // Object를 반환하므로 항변환이 필요하다.
    String b = firstT("a", "b");
}

20.3. 와일드카드

#!syntax java
public static void printAll1(Iterable<?> iterable) {
    for (Object e : iterable) IO.println(e);
}
public static <T> void printAll2(Iterable<T> iterable) {
    for (T e : iterable) IO.println(e);
}

#!syntax java
public static void addList(List<?> list1, List<?> list2) {
    // list1.addAll(list2); // 불가능
}
public static <T> void addList(List<T> list1, List<T> list2) {
    list1.addAll(list2);
}

20.4. 바운딩

#!syntax java
public static <N extends Number> double sum1(List<N> list) {
    var sum = 0.0;
    for (N n : list) sum += n.doubleValue();
    return sum;
}
public static double sum2(List<? extends Number> list) {
    var sum = 0.0;
    for (Number n : list) sum += n.doubleValue();
    return sum;
}

#!syntax java
public static void addInteger(List<? super Integer> list) {
    list.add(12);
}

#!syntax java
public static <N extends Number & Comparable<T>> void printBiggerNumber(N a, N b) {
    IO.println(a.compareTo(b) > 0 ? a : b); // a가 b보다 크다면 a를 아니면 b를 출력한다.
}

21. 익명 클래스

#!syntax java
// RunnableImpl.java
public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        IO.pritnln("Delayed");
        IO.println("Hello, World!");
    }
}

// Main.java
void main() {
    Runnable run = new Runnable();

    runWithDelay(run);
}

public void runWithDelay(Runnable run) {
    try {
        Thread.sleep(1000); // 1000ms(1초) 동안 대기한다.
    } catch (InterruptedException _) {} // 체크 예외 처리. 보통은 무시해도 된다.
    run.run();
}

#!syntax java
void main() {
    Runnable run = new Runnable() {
        @Override
        public void run() {
            IO.println("Delayed");
            IO.println("Hello, World!");
        }
    };

    runWithDelay(run);
}

public void runWithDelay(Runnable run) {
    try {
        Thread.sleep(1000); // 1000ms(1초) 동안 대기한다.
    } catch (InterruptedException _) {} // 체크 예외 처리. 보통은 무시해도 된다.
    run.run();
}

21.1. 람다식

#!syntax java
void main() {
    Runnable run = () -> {
        IO.println("Delayed");
        IO.println("Hello, World!");
    };

    runWithDelay(run);
}

public void runWithDelay(Runnable run) {
    try {
        Thread.sleep(1000); // 1000ms(1초) 동안 대기한다.
    } catch (InterruptedException _) {} // 체크 예외 처리. 보통은 무시해도 된다.
    run.run();
}

#!syntax java
void main() {
    runWithDelay(() -> IO.println("Hello, World"));
}

public void runWithDelay(Runnable run) {
    try {
        Thread.sleep(1000); // 1000ms(1초) 동안 대기한다.
    } catch (InterruptedException _) {} // 체크 예외 처리. 보통은 무시해도 된다.
    run.run();
}

#!syntax java
IntPredicate isEven = (int n) -> {
    return n % 2 == 0;
};

IO.println(isEven.test(4)); // true

#!syntax java
IntPredicate isEven = n -> n % 2 == 0;

IO.println(isEvent.test(4)); // true

21.1.1. 메서드 참조

#!syntax java
Supplier<Double> a = () -> Math.random();
IO.println(a.get()); // 0.0 이상 1.0 미만의 실수 출력

ToIntFunction<String> b = str -> str.length();
IO.println(b.applyAsInt("Hello")); // 5

List<String> list = ...
IntFunction<String> c = i -> list.get(i);
IO.println(c.applyAsInt(0)); // list의 0번 인덱스 원소 출력

Supplier<Object> d = () -> new Object();
IO.println(d.get()); // Object 객체 출력

#!syntax java
Supplier<Double> a = Math::random;

ToIntFunction<String> b = String::length;

IntFunction<String> c = list::get;

Supplier<Object> d = Object::new;

22. 스레드

#!syntax java
void main() {
    new Thread(() -> {
        while (true) {
            IO.println("1");
            sleep(500);
        }
    };).start();

    while (true) {
        IO.println("2");
        sleep(500);
    }
}

public void sleep(long ms) {
    try {
        Thread.sleep(ms);
    catch (InterruptedException _) {}
}

#!syntax java
void main() {
    new Thread(() -> {
        while (true) IO.println(IO.readln());
    };).start();

    while (true) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException _) {}
        IO.println("Hello, World!");
    }
}