Java/문법

1. 개요

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

2. 기본

2.1. C와 차이점

• for-each: 배열과 Iterable을 구현한 객체[2]에 대해 각 데이터를 순환하며 반복한다. 아래 두 for문은 같은 동작을 한다.

#!syntax java
String[] strArray = { "hello", "world", "namuwiki" }

for (int i = 0; i < strArray.length; i++) {
  System.out.println(strArray[i]);
}

for (String s : strArray) {
  System.out.println(s);
}

• boolean 타입이 따로 있다. 따라서 if문에 int를 사용할 수 없다.

3. 메인 메서드

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

4. 제어자

4.1. 접근 제어자

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

4.2. 기타 제어자

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

5. 메서드

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

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

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

받은 문자열이 비어있지 않을 때 출력하는 메서드
public void println(String text) {
    if (text == null || text.equals("")) return; // return은 값 반환 뿐만 아니라 메서드 종료도 하므로 text가 비어있을 경우 아래코드가 실행되기 전에 메서드가 종료된다.
    System.out.println(text);
    // return; 이 생략되었다.
}

#!syntax java
public double getPI() {
    double pi = 3.14
    return pi; // 실제로는 return 3.14; 만으로 쓸 수 있다.
}

6. 클래스

• 유용한 정적 메서드 및 변수를 모아둔 클래스[4]
• 비정적 메서드 및 변수를 활용하여 여러 객체를 만들고 활용하는 클래스.[5][6]

6.1. 유틸리티 클래스

#!syntax java
// Utils.java
public class Utils {
	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)*Math.PI;
    }
}

6.2. 데이터 클래스

• 인스턴스: String 타입의 변수/상수. "String 인스턴스가 필요하다."라고 하면 특정한 String 타입의 변수가 필요하다는 의미가.
• 객체: String 타입의 변수/상수들. 인스턴스를 통틀어서 부르는 말로 "String 객체가 필요하다."는 값에 상관없이 String 타입의 변수가 필요하다는 의미다.
• 생성자: 객체가 만들어 질 때 최초 실행되는 특수한 메서드. 보통 입력 받은 값이나 기본값으로 필드를 초기화 하는 등의 작업을 한다.
• 비정적 변수(필드): 객체 내부의 값. String에서는 문자열[8], ArrayList에서는 배열이다. 보통은 private로 선언하며, 그 이유는 아래 문단에서 후술.
• 비정적 메서드(메서드): 객체에 대하여 동작을 하는 함수. String에서는 필드인 문자열을 전부 대문자로 바꾸는 toUpperCase(), 문자열의 길이을 가져오는 length() 등이 있으며, ArrayList에서는 배열에 값을 추가하는 add(), 값이 포함되어 있는지 확인하는 contains() 등이 있다.

#!syntax java
// Person.java
public class Person {
    // 상술된 유틸리티 클래스처럼 정적 변수를 사용할 수 있다. 모든 객체가 공유하는 필드라고 생각하면 된다.
    // 추가로 final 키워드를 붙여 읽기 전용, 즉 상수로 선언했다. 보통 상수는 대문자로 표기하며 띄어쓰기는 _로 표현한다.
    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
public class Main {
    public static void main(String[] args) {
        // Person 타입의 myPerson 변수를 만들고, new Person("John")이 만드는 인스턴스를 값으로 저장한다.
        Person myPerson = new Person("John"); // 새로운 객체를 생성하려면 new 키워드를 사용한다.
        System.out.println(myPerson.getName()); // John
        System.out.println(Person.getSpecies()); // Homo sapiens
    }
}

6.2.1. Getter와 Setter

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

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

• 암묵적인 규칙
• Getter
  반환 타입이 void가 아니고, 매개 변수가 없으며, 메서드 이름을 'get변수이름'[10]으로 설정한다. 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;
    }
    protected void setLicensePlate(String licensePlate) { // 아무나 번호판을 변경할 수 없다.
        this.licensePlate = licensePlate;
    }
}

6.3. 상속

#!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;
    }
}
// Main.java
public class Main {
    public static void main(String[] args) {
        Student joe = new Student("Joe", 4.0);
        // Student는 Person이기도 하므로 Person의 getName() 메서드를 사용할 수 있다.
        System.out.println(joe.getName()); // Joe.
        System.out.println(joe.getGPA()); // 4.0
    }
}

6.4. Object

• boolean equals(Object obj): 자기 자신과 매개변수를 비교한다. '두 객체가 같다.'는 이 메서드가 true를 반환한다는 뜻이다. 주소를 비교하는 참조 자료형의 특징 때문에 이 메서드를 재정의하여 사용자가 원하는 비교를 가지도록 할 수 있다.
• int hashCode(): 자기 자신의 해시 코드를 반환한다. 동일한 객체는 동일한 해시 코드를 반환하도록 재정의해야 한다.
• String toString(): 자기 자신을 문자열 형태로 반환한다. System.out.println();가 인자로 Object 객체를 받을 경우, 이 메서드로 얻은 문자열을 출력한다. 기본적으로 "클래스이름@해시코드"를 반환하므로 재정의하게 된다. 예시로 Person 클래스의 toString()은 "[species = Homo sapiens, name = (필드 name의 값)]"를 반환하도록 재정의할 수 있다.

7. 변수 및 자료형

7.1. 변수 선언

#!syntax java
int namu;

#!syntax java
namu = 3;

#!syntax java
int namu = 3;

#!syntax java
var namu = 3;

#!syntax java
System.out.println(namu);

#!syntax java
namu = namuwiki;

7.2. 원시 자료형

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

#!syntax java
public static int sum(int a, int b) {
    return a + b;
}
public static void main(String[] args) {
    int n1 = 10;
    int n2 = 12;
    System.out.println(sum(n1, n2)); // 22
}

7.2.1. 정수

#!syntax java
long namu = 1000000000000L;

7.2.2. 실수

7.2.3. 문자

#!syntax java
char namu = 'A';

7.3. 참조 자료형

7.3.1. 래퍼 클래스

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

7.4. 배열

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

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

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

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

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

7.4.1. 컬렉션

• 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이라고 보면 된다.[17] 키는 중복될 수 없지만, 값은 중복될 수 있다.
• HashTable
• HashMap: 해시 기반으로 데이터를 저장하는 Map.
• LinkedHashMap: HashMap과 동일하나, 순서를 유지한다.
• SortedMap
• TreeMap: 순서를 정렬하여 저장하는 Map.

8. 제네릭

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

8.1. 바운딩

#!syntax java
// 일반 자료형
public static <T extends Number> double sum1(List<T> list) {
  double sum = 0;
  for (T num: list) {
    sum += num.doubleValue();
  }
  return sum;
}
// 와일드카드
public static double sum2(List<? extends Number> list) {
  double sum = 0;
  for (Number num: list) {
    sum += num.doubleValue();
  }
  return sum;
}

8.2. 클래스

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

  public Wrapper(T content) {
    this.content = content;
  }
  
  public T getContent() {
    return this.content;
  }
}
// ... 메인 메서드 안
Wrapper<String> myWrapper1 = new Wrapper<>("Namu Wiki"); // new Wrapper뒤에 <>를 붙여야한다.
Wrapper<Integer> myWrapper2 = new Wrapper<Integer>(44); // java 6 까지는 타입까지 표기해야 한다.
System.out.println(myWrapper1.getContent()); // Namu Wiki
System.out.println(myWrapper2.getContent()); // 44

8.3. 메서드

#!syntax java
public static <T extends Exception> void throwRuntimeException(T e) {
  throw RuntimeException(e);
}
public static void main(String[] args) {
  throwRuntimeException(new IOException()); // IOException은 Exception의 자식 클래스이므로 인자로 사용 가능하다.
}

8.3.1. 와일드카드

#!syntax java
public static <T> int getLength1(List<T> myList) {
  return myList.size();
}
public static int getLength2(List<?> myList) {
  return myList.size();
}

9. 예외

• Throwable: 예외의 최상위 클래스. 이 클래스를 상속하는 클래스는 던질 수 있고, catch 블록에서 받을 수 있다.
• Error: 치명적 오류. JVM에 문제가 발생하거나 메모리가 부족하는 등의 상황에서 발생한다. catch 블록에서 처리할 수 있지만 처리한다고 해결되는 수준이 아니므로 그냥 냅둔다.
• 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();
}

9.1. try

• try: 이 블록의 코드에서 예외가 발생하면 다음 블록으로 넘어간다.
• catch: try에서 던져진 예외를 받는 블록. 받을 예외[20]를 정해야 하며, 대상이 아닌 예외는 다음 catch 블록으로 이동한다.
• finally: 이 문법에서 마지막에 무조건 실행되는 블록. 이 블록은 가장 밑에 있어야 한다. 해당 메서드가 반환되더라도 실행되며, 심지어 System.exit()[21]를 사용해도 실행된다. Closeable을 구현한 객체의 close() 메서드를 호출할 때 사용한다.[22]

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

#!syntax java
String str = "1234a";
try {
  int i = Integer.parseInt(str); // 문자열을 정수로 변환한다. 이 경우, a 때문에 NumberFormatException을 발생시킨다.
} catch(NumberFormatException _) {
  System.err.println("잘못된 문자열"); // 에러 메시지를 출력한다.
} 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) {
    System.out.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) {
    System.out.println(line);
  }
} catch (Exception e) {
  System.err.println("파일 읽기 실패: " + e.getMessage());
} // 이후 자동으로 reader.close(); 를 실행한다.

10. 인터페이스

10.1. 인터페이스 정의하기

#!syntax java
// Incrementable.java
public interface Incrementable {
    String interfaceName = "Incrementable";
    public void increment();
    public default void printMessage() {
        System.out.println("디폴트 메서드");
    }
}

10.2. 인터페이스 구현하기

#!syntax java
public class Person implements Incrementable {
  /* 생략 */
  // Incrementable의 모든 추상 메서드를 정의
  public void increment() {
    age++;
  }
}

#!syntax java
public static void example(Incrementable implementation) {
  implementation.increment();
  implementation.printMessage();
}

#!syntax java
public class SubClass extends SuperClass implements IntOne, IntTwo, IntThree {
// ...
}

10.3. 함수형 인터페이스