개발옹

데이터베이스에서 필수로 쓰이는 날짜형 데이터에 대해 정리해두고자 합니다.

4가지 유형의 데이터 타입에 대한 정리와 일자와 시간을 모두 표현하는 DATETIME과 TIMESTAMP의 차이를 알아보겠습니다.

1. DATE, DATETIME, TIMESTAMP, TIME

MySQL에서는 일자와 시간을 표현하기위해 DATE, DATETIME, TIMESTAMP, TIME 타입을 사용할 수 있습니다.

일자와 시간을 모두 표현하는 DATETIME과 TIMESTAMP는 얼핏봐서는 비슷한데, 차이점이 있습니다. 

이 둘의 차이를 알고 있어야 예상치 못한 에러사항을 대비할 수 있기 때문에, 차이점을 한 번 알아보겠습니다.

2. DATETIME vs TIMESTAMP

1) 범위

일자와 시간을 모두 표현하는 두 타입은 일단 표에서 볼 수 있듯 범위에서 차이가 있습니다.

DATETIME의 범위는 '1000-01-01 00:00:00' 부터 '9999-12-31 23:59:59' 로, 시간대에 관계없이 절대적인 일자와 시간을 저장합니다.

TIMESTAMP의 범위는 '1970-01-01 00:00:01' UTC 부터 '2038-01-19 03:14:07' UTC 로, 데이터가 UTC로 변환되어 저장되며 검색시 현재 시간대로 변환이 됩니다. TIMESTAMP의 범위는 Unix 시간과 관련이 있어, 2038년 문제로 인해 최대 범위가 2038년까지로 제한됩니다.

2) Timezone의 적용 여부

두 타입은 Timezone의 적용 여부에 차이가 있습니다.

Timezone은 동일한 시간을 따르는 지역을 의미하고, 해당 국가에 의해 법적으로 지정되는 값입니다.

UTC, Asia/Seoul 등의 표기가 해당 시간이 어떤 로컬을 기준으로 작성한 것인지를 명시하는 것입니다.

MySQL은 TIMESTAMP 값을 현재 시간대에서 *UTC로 변화하여 저장하고, 다시 UTC에서 현재 시간대로 변환하여 검색합니다.

*UTC: 국제 표준시

기본적으로 설정되는 시간대는 서버 시간으로, 시간대 설정이 일정하게 유지된다면 저장한 값과 동일한 값을 반환받습니다.

만약 TIMESTAMP 값을 저장한 후, 시간대를 변경하고 값을 조회하면, 조회 결과는 저장한 값과 다르게 됩니다. 시간대 변환시 동일한 시간대를 사용하지 않았기 때문에 이러한 결과가 발생하는 것입니다.

*현 시간대는 시스템 변수인 time_zone 에 설정된 값으로 확인할 수 있습니다.

예시

실제로 데이터가 어떻게 저장되는지 확인해봅시다.

create table date_example
(
  test_date date,
  test_datetime datetime,
  test_timestamp timestamp,
  test_time time
);

insert into date_example values (now(), now(), now(), now());

테스트 테이블을 만들고 현재 시간으로 데이터를 저장했습니다.

mysql> select * from date_example;
+------------+---------------------+---------------------+-----------+
| test_date  | test_datetime       | test_timestamp      | test_time |
+------------+---------------------+---------------------+-----------+
| 2024-07-09 | 2024-07-09 10:36:17 | 2024-07-09 10:36:17 | 10:36:17  |
+------------+---------------------+---------------------+-----------+
1 row in set (0.00 sec)

왼쪽부터 DATE, DATETIME, TIMESTAMP, TIME 형식의 데이터가 저장된 것을 확인할 수 있습니다.

여기서 time_zone을 수정해보고 다시 같은 데이터를 확인해보겠습니다.

mysql> SET time_zone = '+01:00';
Query OK, 0 rows affected (0.00 sec)

mysql> select * from date_example;
+------------+---------------------+---------------------+-----------+
| test_date  | test_datetime       | test_timestamp      | test_time |
+------------+---------------------+---------------------+-----------+
| 2024-07-09 | 2024-07-09 10:36:17 | 2024-07-09 02:36:17 | 10:36:17  |
+------------+---------------------+---------------------+-----------+
1 row in set (0.00 sec)

time_zone에 변화를 주고 조회해보니 TIMESTAMP 형식의 test_timstamp 값만 변한 것을 알 수 있습니다.

• SET time_zone = '+01:00' : UTC+09:00 보다 8시간 이전으로 설정

이는 위에서 기재했듯 TIMESTAMP 는 시스템 변수인 time_zone을 기준으로 결과를 반환하기 때문입니다.

그렇기때문에 TIMESTAMP를 사용하고, 로컬 시간이 다른 글로벌 서비스를 운영할 때에는 이를 유의해서 관리해야합니다.

TIMESTAMP를 사용하면 로컬 시간에 따라 혼란이 있을 수는 있으나, 글로벌 서비스를 운영할때에는 유용하게 쓰일 수 있습니다.

만약 DATETIME을 사용한다면 로컬 시간이 제대로 반영되지 않아서, 서울에서 오전 11시에 작성한 글을 미국에서 조회하는 경우, 동일하게 오전 11시로 반영되는 등의 문제가 발생합니다. 이렇게 시간이 다른 지역이 있는 경우, TIMESTAMP가 더 적합할 수도 있습니다.

이러한 특징들로 DATETIME은 절대적인 시간 기록에 적합하고 TIMESTAMP는 시간대에 따라 변환이 필요한 경우 유용하게 쓰입니다.

3) DATETIME 과 TIMESTAMP의 자동 초기화

DATETIME와 TIMESTAMP는 현재 일자와 시간을 기본값, 자동 업데이트 값으로 설정할 수 있습니다.

• 자동 초기화: 데이터 삽입시 명시적으로 지정하지 않아도 현재 타임스탬프로 설정
• 자동 업데이트: 데이터 갱신시 자동으로 현재 타임 스탬프로 갱신

설정 방법

자동 초기화와 업데이트를 설정하려면 DATETIME과 TIMESTAMP 열 정의에서 지정해주면 됩니다.

• 자동 초기화를 위한 초기값 설정: DEFAULT ~~
• 자동 업데이트를 위한 설정: ON UPDATE ~~

DATETIME과 TIMESTAMP를 각각 형식으로 가지는 column이 있는 테이블을 아래와 같이 정의하면 자동으로 값이 들어갑니다.

CREATE TABLE t1 (
  ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  dt DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);

위 테이블에 아무 값도 지정하지 않고 INSERT를 하고 조회를 하면, 

insert into t1 values();

아무 값도 넣지 않았는데도 현재 시간이 저장된 것을 확인할 수 있습니다.

mysql> select * from t1;
+---------------------+---------------------+
| ts                  | dt                  |
+---------------------+---------------------+
| 2024-07-09 12:13:49 | 2024-07-09 12:13:49 |
+---------------------+---------------------+
1 row in set (0.00 sec)

이번엔 아래와 같은 테이블을 생성해봅시다.

CREATE TABLE t1 (
  ts TIMESTAMP DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP,
  dt DATETIME DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP
);

위에서 정의한 것과 다른점은 DEFAULT NULL 부분입니다.

이는 기본값을 NULL로 두겠다는 것을 의미합니다.

mysql> INSERT INTO t1 VALUES();
Query OK, 1 row affected (0.00 sec)

mysql> SELECT * FROM T1;
+------+------+
| ts   | dt   |
+------+------+
| NULL | NULL |
+------+------+
1 row in set (0.00 sec)

위와 동일하게 아무 값도 넣지 않고 INSERT를 하면, 이번에는 NULL 값이 저장된 것을 확인할 수 있습니다.

마치며,

서비스를 운영하면 필수적으로 포함되는 날짜와 시간 데이터형에 대한 내용을 정리했습니다.

특히 DATETIME과 TIMESTAMP의 차이에서 헷갈리는 부분이 많았는데, 이번에 정리하고 찾아보면서 한번 더 확인할 수 있었던 시간이었습니다. 날짜 데이터와 관련해서는 다음에 문자열로 변환하는 등 실제로 값을 조회하고 처리하는 부분에 대해서 알아보겠습니다.

Reference

📌요약

윈도우 함수 중 하나인 순위 함수를 사용하면 결과 집합의 각 행에 순위를 할당할 수 있습니다.

1. RANK() 함수

[MySQL Tutorial]
RANK() 함수는 결과 집합의 파티션 내 각 행에 순위를 할당합니다.
행의 순위는 1에 그 앞에 오는 순위 수를 더한 값으로 지정됩니다.

[Oracle Tutorial]
RANK() 함수는 각 집합에서 값의 순위를 계산하는 분석 함수입니다.
RANK() 함수는 동일한 값을 가진 행에 대해 동일한 순위를 반환합니다. 동률 순위에 동률 행 수를 더해 다음 순위를 계산합니다. 따라서 순위는 연속된 숫자가 아닐 수도 있습니다.
RANK() 함수는 상위 N 및 하위 N 쿼리에 유용합니다.

RANK() 함수는 윈도우 함수 중 그룹 내 순위 함수로, 특정 윈도우(부분)내에서 순위를 할당하는 데 사용합니다.

동일한 값을 가진 행에 대해 동일한 순위를 부여하고 그 다음 순위는 동일 순위를 가진 행 수만큼의 시퀀스 간격이 생깁니다.

예를 들어 3위가 3명이라면, 1,2,3,3,3,6,7,8, ... 이렇게 순위가 매겨집니다.

RANK() 문법

MySQL과 Oracle의 RANK() 함수 문법은 각각 아래와 같습니다.

MySQL 

RANK() OVER (
	PARTITION BY <expression>[{,<expression>...}]
	ORDER BY <expression> [ASC|DESC], [{,<expression>...}]
)

Oracle

RANK() OVER ([query_partition_clause] order_by_clause)

• PARTITION BY | query_partition_clause : 결과 집합을 파티션으로 나눕니다.
  • 옵션 값이며, 생략할 경우 조회 결과의 모든 행을 하나의 파티션으로 취급합니다.
• ORDER BY | order_by_clause : 하나 이상의 열이나 표현식을 기준으로 파티션 내의 행을 정렬합니다.
  • 필수 값이며, 함수가 적용되는 각 파티션의 행의 논리적인 정렬 순서를 결정합니다.

2. DENSE_RANK() 함수

[MySQL Tutorial]
DENSE_RANK() 함수는 순위 값에 차이 없이 파티션 또는 결과 집합 내의 각 행에 순위를 할당하는 윈도우 함수입니다.
행의 순위는 행 앞에 오는 고유한 순위 값에서 1씩 증가합니다.

[Oracle Tutorial]
DENSE_RANK() 함수는 정렬된 행 집합에서 행의 순위를 계산하는 분석 함수입니다.
RANK() 함수와 달리 DENSE_RANK() 함수는 순위 값을 연속된 정수로 할당합니다. 동률인 경우에는 순위를 건너뛰지 않습니다.
순위 기준 값이 동일한 행에는 동일한 순위 값이 적용됩니다. 

DENSE_RANK() 함수는 RANK() 함수와 동일하게 동일한 값을 가진 행에 대해 동일한 순위를 부여하지만 그 다음에 나오는 행에는 순위를 건너뛰지 않고 이어서 순위를 부여합니다.

예를 들어 3위가 3명이라면, 1,2,3,3,3,4,5,6, ... 이렇게 순위가 매겨집니다.

DENSE_RANK() 문법

MySQL과 Oracle의 DENSE_RANK() 함수 문법은 각각 아래와 같습니다.

MySQL 

DENSE_RANK() OVER (
    PARTITION BY partition_expression
    ORDER BY sort_expression [ASC|DESC]
)

Oracle

DENSE_RANK( ) OVER([ query_partition_clause ] order_by_clause)

PARTITION BY | query_partition_clause 과 ORDER BY | order_by_clause는 RANK() 함수에서의 설명과 같습니다.

DENSE_RANK()는 파티션에 동일한 순위 값을 가진 두 개 이상의 행이 있는 경우, 각 행에 동일 순위가 부여되고, RANK()함수와는 달리 항상 연속된 순위 값을 할당 합니다. (동일 순위가 있다하더라도)

3. ROW_NUMBER() 함수

[MySQL Tutorial]
ROW_NUMBER() 함수는 결과 집합의 각 행에 일련 번호를 할당하는 윈도우 함수 혹은 분석 함수입니다.
첫번째 숫자는 1로 시작합니다.

[Oracle Tutorial]
ROW_NUMBER() 함수는 적용되는 각 행(파티션의 각 행 또는 결과 집합의 각 행)에 순차적으로 고유한 정수를 할당하는 분석 함수입니다.

ROW_NUMBER() 함수는 결과 집합 내의 각 행에 고유 번호를 할당합니다.

RANK()나 DENSE_RANK() 함수보다 매우 간단합니다.

ROW_NUMBER() 함수는 각 행에 순위를 부여할 때 동일한 값이 있어도 이를 무시하고 연속적인 순위를 부여합니다.

예를 들어 3위가 3명이라해도, 1,2,3,4,5,6, ... 이렇게 순위가 매겨집니다.

ROW_NUMBER() 문법

MySQL과 Oracle의 RANK() 함수 문법은 각각 아래와 같습니다.

MySQL 

ROW_NUMBER() OVER (
    PARTITION BY <expression>,[{,<expression>}...]
    ORDER BY <expression> [ASC|DESC],[{,<expression>}...]
)

Oracle

ROW_NUMBER() OVER (
   [query_partition_clause] 
   order_by_clause
)

PARTITION BY | query_partition_clause 과 ORDER BY | order_by_clause는 RANK() 함수에서의 설명과 같습니다.

4. RANK() vs DENSE_RANK() vs ROW_NUMBER()

지금까지 알아본 3가지 윈도우 함수인 RANK(), DENSE_RANK(), ROW_NUMBER()의 실제 결과값의 차이를 확인해보겠습니다.

학생 정보가 담긴 테이블을 간단하게 만들고, 학생별 평점으로 각 순위 함수의 차이를 확인해보겠습니다.

CREATE TABLE `students` (
  `student_id` int NOT NULL,
  `first_name` varchar(50) DEFAULT NULL,
  `last_name` varchar(50) DEFAULT NULL,
  `major` varchar(100) DEFAULT NULL,
  `gpa` decimal(3,2) DEFAULT NULL, // 평점
  PRIMARY KEY (`student_id`)
)

적당한 데이터를 여러개 INSERT 한 후 아래 쿼리를 실행시켜 보겠습니다.

SELECT student_id , first_name , gpa 
		, RANK() OVER (ORDER BY gpa DESC) AS 'RANK'
		, DENSE_RANK () OVER (ORDER BY gpa DESC) AS 'DENSE_RANK'
		, ROW_NUMBER() OVER (ORDER BY gpa DESC, first_name ASC) AS 'ROW_NUM'
FROM students;

실행시킨 결과는 아래와 같습니다.

3,4번 행을 보면, 3번 행의 지우와 4번 행의 소민이의 순위 값이 각 함수별로 다른 것을 확인할 수 있습니다.

그리고 각 함수별로 순위도 다르게 매겨지는 것을 알 수 있습니다.

• RANK: 1 ⭢ 2 ⭢ 4 ⭢ 6 ⭢ 8 ⭢ 10
• DENSE_RANK: 1 ⭢ 2 ⭢ 3 ⭢ 4 ⭢ 5 ⭢ 6
• ROW_NUM: 1 ⭢ 2 ⭢ 3 ⭢ 4 ⭢ 5 ⭢ 6 ⭢ 7 ⭢ 8 ⭢ 9 ⭢ 10

5. PARTITION BY  문법

추가로 세가지 함수에서 모두 옵션 값으로 사용되는 파티션 구문에 대한 사용법을 알아보겠습니다.

PARTITION BY는 그룹 내 순위 및 그룹별 집계를 구할 때 사용합니다.

SELECT student_id , major , gpa 
	,RANK() OVER (PARTITION BY major ORDER BY gpa DESC) AS 'PARTITION'
FROM STUDENTS;

이 쿼리는 학생들의 전공(major)별로 학생들의 평점(gpa)순위를 매깁니다.

• PARTITION BY major ORDER BY gpa DESC: major 컬럼이 같은 행을 그룹으로 묶어서, 그룹 내 gpa 컬럼의 순위를 내림차순(DESC)으로 정렬

위 쿼리를 실행한 결과는 아래와 같습니다.

마치며,

윈도우 함수 중 하나인 순위 함수에 대해 알아보았습니다.

코딩테스트를 하면서 RANK() 함수를 활용해야하는 쿼리를 제대로 작성하지 못해 다시 공부하면서 정리하니 전에 공부했던 내용이 다시 생각나기도 하고 새롭게 다시 배우기도 했습니다.

관련한 다른 함수들도 많이 있으니, 다음에는 이외 함수들도 정리하는 시간을 가져보아야겠습니다 :)

참고 링크

📌인터페이스와 추상클래스의 차이

자바에는 비슷한 듯 다른 인터페이스와 추상 클래스가 있다. 이 둘의 차이점을 정리해보려 한다. 

먼저, 인터페이스와 추상 클래스가 무엇인지 먼저 알아보자.

인터페이스(Interface)

인터페이스는 모든 메서드가 추상 메서드로 구성되어있고, 클래스가 구현해야할 메서드의 집합을 정의한다.

간단하게 무언가 구현해야할 내용을 정의해놓은 것이라고 생각하면 된다.

'구현해야할' 것들을 정의해놓은 것이므로 일반 클래스와 달리 메서드에 코드 블럭이 없다. 즉, 어떤 메서드의 기능을 구현해놓은 내용인 코드 블럭이 없다.

interface 인터페이스명() {
    public static final 상수명 = 값;
    public abstract void 메서드명();
}

인터페이스를 선언할 때는 접근 제어자와 함께 ① interface 키워드를 사용한다.

그리고 ② 인터페이스의 모든 메서드는 암묵적으로 public 이며, 필드(변수)는 public static final 이다.

*인터페이스 필드에 int COUNT = 3;은 public static final을 생략해도 자동으로 public static final이 적용된다.

메서드에 기능을 구현해놓지 않기 때문에, 인터페이스는 혼자서 무언갈 할 수는 없다. 인터페이스를 상속한 클래스(구현체)에서 메서드를 Override 해서 구현해야한다.

interface Computer { }
Computer C = new Computer(); // Error: Cannot instantiate the type Computer

위처럼 인터페이스가 있다고 할때, Computer 객체를 생성하려하면 에러가 발생한다. 

그리고 인터페이스는 ③ 다중 상속이 가능해서, 아래와 같이 한 클래스가 여러 인터페이스를 상속받아 구현할 수 있다.

class 클래스명 implements 인터페이스1, 인터페이스2

④ Java8 부터 인터페이스는 default 메서드와 static 메서드를 사용할 수 있다.

인터페이스의 메서드는 구현체를 가질 수 없지만, default 메서드를 사용하면 실제 구현된 형태의 메서드를 가질 수 있다. 

그리고 인터페이스에 static 메서드를 구현하면 인터페이스명.스태틱메서드명과 같이 사용하여 일반 클래스의 static 메서드를 사용하는 것과 동일하게 사용할 수 있다.

interface TestInterface {
    // default 메서드
    default void printSomething() {
    	System.out.println("default method in interface");
    }
    // static 메서드
    static int getNum() {
    	return 10;
    }
}

아래와 같이 인터페이스명.스태틱메서드명으로 사용할 수 있다.

TestInterface.printSomething();

인터페이스(Interface)를 사용하는 이유?

그렇다면 인터페이스를 왜 사용해야 하는걸까?

보통 중요 클래스를 작성하는 시점에서 클래스의 구현체가 몇 개가 될지 알 수 없으므로 인터페이스를 정의해서 인터페이스를 기준으로 메서드를 만드는 것이 효율적이기 때문이다.

당장 이 문장을 읽었을때는 무슨 소린가 싶다.

예시로 한번 다시 정리해보자.

Animal 클래스를 상속하는 Tiger, Bear 클래스가 있고, 이들을 관리하고 먹이를 주는 ZooKeeper 클래스가 있다고 해보자.

class Animal {
	String name;
	void setName(String name) {
		this.name = name;
	}
}

class Tiger extends Animal { }
class Bear extends Animal { }
class ZooKeeper {
	void feed(Tiger tiger) {
		System.out.println("feed apple to Tiger");
	}
	void feed(Bear bear) {
		System.out.println("feed banana to Bear");
	}
}

ZooKeeper는 feed() 메서드 호출시 인자의 타입에 따라 Tiger나 Bear에게 먹이를 준다.

public static void main(String[] args) {
    ZooKeeper zooKeeper = new ZooKeeper();
    Tiger tiger = new Tiger();
    Bear bear = new Bear();

    zooKeeper.feed(tiger); // feed apple to Tiger
    zooKeeper.feed(bear); // feed banana to Bear
}

근데 이때 동물들이 계속해서 늘어난다면, ZooKeeper에 해당 동물들의 타입을 매개변수로 한 feed() 메서드를 계속 계속 추가해주어야한다. 이렇게 계속 추가하게 되면 ZooKeeper 가 굉장히 복잡해질 것이다.

이럴때 인터페이스를 구현하면 훨씬 효율적으로 코드를 구성할 수 있다.

먹이를 주는 메서드 기능을 가진 인터페이스 Work를 생성해보자.

interface Work {	} // 인터페이스
class Animal { // 부모(상위) 클래스
    String name;
    void setName(String name) {
    	this.name = name;
    }
}
class Tiger extends Animal implements Work { }
class Bear extends Animal implements Work { }

그리고 Tiger, Bear 클래스에서  인터페이스 Work를 상속한다. 

*인터페이스 상속시 키워드는 implements

이렇게하면 ZooKeeper 클래스에 인터페이스 Work 타입을 매개변수로 받아서 먹이를 주는 기능인 feed() 메서드를 구현할 수 있다. 

class ZooKeeper {
    void feed(Work work) {
        System.out.println("feed apple to Animal");
    }
}

원래는 Tiger, Bear 타입에 대해 각각 feed() 메서드를 구현해야했지만, 인터페이스인 Work 타입의하나의 메서드만으로도 feed() 메서드 구현이 가능하다.

실제로 Tiger, Bear 인스턴스를 feed(Work work) 메서드의 인자로 넣어서 호출하면 아래와 같은 결과가 나온다.

public static void main(String[] args) {
    ZooKeeper zooKeeper = new ZooKeeper();
    Tiger tiger = new Tiger();
    Bear bear = new Bear();

    zooKeeper.feed(tiger); // feed apple to Animal
    zooKeeper.feed(bear); // feed apple to Animal
}

이제 어떤 동물 클래스를 추가하든 ZooKeeper 클래스에 feed() 메서드를 추가할 필요가 없다.

다시 위에서 얘기했던 이유를 가져오면,

"중요 클래스를 작성하는 시점에서 클래스의 구현체가 몇 개가 될지 알 수 없으므로 인터페이스를 정의해서 인터페이스를 기준으로 메서드를 만드는 것이 효율적"

이라는 말이 조금은 이해가 될 것이다.

다만, 위 예시는 인터페이스가 왜 필요한가에 대한 부분에 대한 설명을 위한 예시로, Work 인터페이스를 상속하는 모든 클래스에서 같은 출력이 나온다. 이건 Work 인터페이스를 상속받는 하위 클래스, 즉 자식 클래스에서 별도로 메서드를 구현해서 각 동물 클래스마다 다른 결과를 나오게 할 수 있다.

*어떻게 하는건지는 이 포스팅에서는 다루지 않겠다. 추상 클래스랑 비교가 목적이므로..

추상 클래스(Abstract Class)

추상 클래스는 ① 하나 이상의 추상 메서드를 포함하며, 인터페이스의 역할도 하면서 클래스의 기능도 가지고 있는 클래스이다. 

하나 이상의 추상 메서드를 포함한다는 것은, 일반 메서드를 가질 수 있다는 의미도 내포한다.

인터페이스의 경우, 모든 메서드가 추상 메서드인 반면 추상 클래스는 미리 구현된 메서드를 가질 수 있다는 차이가 있다.

abstract class 클래스명() { // 추상 클래스
    abstract 반환타입 메서드명(); // 추상 메서드
}

추상 메서드는 인터페이스의 메서드와 마찬가지로 구현체가 없다.

즉, 추상 클래스를 상속하는 자식 클래스에서 반드시 해당 추상 메서드를 오바라이딩을해야 사용할 수 있다.

추상 메서드는 코드 블럭이 있는 구현체로 작성되지 않고, 선언부만 존재한다. 이 메서드를 자식 클래스에서 오버라이딩하여 구현해서 사용하는 것이다.

다시말해, 추상 클래스는 "내가 이 기능을 정해두지 않을테니, 나를 상속한 자식 클래스들아, 내가 정의한 기능을 구현해봐!" 라고 이야기 하는 것이다. 여기에 추가로, "단 일부는 만들어주고, 일부는 안만들어줄게" 라고 한다고 생각하면 기억하기 쉽다.

추상 클래스는 인터페이스와 마찬가지로 구현부가 없는 추상 메서드가 있기 때문에 일반 클래스와 달리  ② 단독으로 객체, 즉 인스턴스를 생성할 수 없다.

반드시 추상 클래스를 상속한 실제 클래스를 통해서만 객체를 생성할 수 있다.

(추상 클래스를 상속한 자식 클래스에서 해당 추상 클래스의 추상 메서드를 오버라이딩 해야, 자식 클래스의 인스턴스 생성 가능)

abstract class Teacher { }
Teacher t = new Teacher();  // Error: Cannot instantiate the type Teacher

그리고 추상 클래스는 인터페이스와 달리 일반 클래스처럼 ③ 인스턴스 변수, 생성자, private 메서드 등을 가질 수 있다.

즉, 추상 메서드와 일반 메서드, 객체 변수, 생성자까지 가질 수 있는 것이다.

abstract class Teacher {
	private String name; // 멤버 변수
	Teacher() {} // 생성자
    
	abstract void hello(); // 추상 메서드
	void hi() { System.out.println("안녕!"); } // 일반 메서드
}

그리고 Java에서는 클래스의 다중 상속을 막기 때문에 ④ 추상 클래스는 다중 상속을 할 수 없다.

class 클래스명 extends 추상클래스

추상 클래스(Abstract Class)를 사용하는 이유?

추상 메서드도 인터페이스와 비슷하게, 중복되거나 공통되는 부분에 대해 미리 만들어진 것을 사용하고, 이를 사용하는 쪽에서 자신에게 필요한 부분만 재정의해서 사용함으로써 생산성과 효율성이 향상되기 때문에 사용한다.

또한 추상 메서드가 포함된 클래스를 상속받는 하위(자식)클래스가 반드시 그 추상 메서드를 구현하게끔 하기 위함이다.

일반 메서드는 해당 메서드를 구현하지 않을수도 있지만, 추상 메서드가 포함된 추상 클래스를 상속받은 모든 하위(자식)클래스는 추상 메서드를 구현해야만 인스턴스를 생성할 수 있기 때문에 반드시 구현하게 된다.

인터페이스(Interface) vs 추상 클래스(Abstract Class)

그럼 이 둘의 차이가 어디에 있는지 정리해보자.

1. 사용 목적

• 인터페이스는 모든 메서드가 추상 메서드로, 인터페이스를 상속받는 클래스가 구현해야 할 메서드의 집합을 정의한다. 
• 추상 클래스는 1개 이상의 추상 메서드가 있고, 일반 메서드도 포함할 수 있기 때문에, 추상 메서드의 기능을 구현하게 하기 위해서도 있지만, 상속을 통한 공통 기능 공유하도록 하는 것에도 목적이 있다.

2. 구현

• 인터페이스는 모든 메서드가 추상 메서드이다.
• 추상 클래스는 추상 메서드와 일반 메서드를 모두 가질 수 있다.

3. 멤버 변수

• 인터페이스의 멤버 변수는 public static final이다. 즉, 인스턴스 변수를 가질 수 없다.
• 추상 클래스는 인스턴스 변수를 가질 수 있다.

4. 생성자 가능 여부

• 인터페이스는 생성자를 가질 수 없다.
• 추상 클래스는 생성자를 가질 수 있다.

5. 다중 상속 여부

• 인터페이스(키워드: implements)는 다중 상속이 가능하다.
• 추상 클래스(키워드: extends) 는 다중 상속이 불가능하다. 

마치며,

Java의 인터페이스와 추상 클래스에 대해 알아보았다.

알아보면서도 더 알아봐야할 개념들이 많아서, 이후에 하나씩 차근히 정리해보아야겠다. 

참고 포스팅 및 서적

• Do it! 점프 투 자바
• TCP School

단축 평가(Short-circuit Evaluation)란?

단축 평가는 표현식의 결과를 결정하는데에 필요한 최소한의 연산만 수행하는 것을 의미한다.

다르게 말하면, 표현식의 결과를 결정하는 도중에 결과가 확정된 경우, 나머지 연산을 수행하지 않고 생략하는 것을 말한다.

그리고 단축 평가는 논리 연산에서 효율성을 높이는 중요한 개념이다.

💡 표현식(Expression)

표현식은 값을 계산하기 위해 사용하는 코드의 한 조각으로, 결과적으로 하나의 값을 만들어낸다.

예를 들어 10 + 3 은 13이라는 값을 만들어내는 표현식이다.

단축 평가의 적용

논리 연산자인 AND(&&)와 OR(||) 연산은 단축 평가를 수행한다.

논리곱(&&) 연산

논리곱(&&) 연산자는 두 피연산자가 모두 true 일 때, true를 반환한다.

그리고 좌항에서 우항으로 평가가 진행된다. 

(피연산자 1) && (피연산자 2) 가 있으면 피연산자 1이 먼저 평가되고, 피연산자 2가 평가되는 것이다.

피연산자 1이 true라고 해서 표현식 전체를 true로 평가할 수는 없고, 피연산자 2까지 평가를 해보아야한다.

즉, 두번째 피연산자인 피연산자 2가 논리곱 연산의 결과를 결정한다고 볼 수 있다. 

그런데 이때 피연산자 1이 false 라면, 피연산자 2의 결과와는 관계없이 논리곱 연산의 결과가 false가 된다.

논리곱(&&) 연산은 두 피연산자가 모두 true이여야하기 때문이다.

논리합(||) 연산

논리합(||) 연산자는 두 피연산자 중 하나라도 true 일 때, true를 반환한다.

논리곱 연산자와 마찬가지로 좌항에서 우항으로 평가된다.

(피연산자 1) || (피연산자 2) 가 있다고 할 때, 피연산자 1이 true라면 두번째 피연산자인 피연산자 2를 평가하지 않아도 이 표현식이 true라고 평가할 수 있다.

그런데 이때 피연산자 1이 false 라면, 피연산자 2를 평가해야지만 이 표현식의 결과를 확정할 수 있다. 

논리합 연산자는 둘 중 하나라도 true면 true를 반환하기 때문이다.

논리곱(&&) 연산자와 논리합(||) 연산자의 단축 평가

그럼 논리곱, 논리합 연산자의 단축 평가가 어떻게 이뤄지는지 알아보자.

결론을 말하자면,

논리곱(&&) 연산자는 첫번째 피연산자가 false 면, 이후 피연산자에 대해서는 평가를 하지 않고,

논리합(||) 연산자는 첫번째 피연산자가 true 면, 이후 피연산자에 대해서는 평가를 하지 않는다.

다음 예제로 자세히 알아보자.

1 == 0 : false
1 / 0 == 0 : Error

조건이 위와 같이 있다할때, 각 결과는 1 == 0 은 false, 1 / 0 == 0 은 에러가 발생한다.

그럼 두개의 피연산자로 표현식을 구성해서 논리곱 연산을 하면 어떻게 될까?

1 == 0 && 1 / 0 == 0

위 표현식에서 두번째 피연산자에 1 / 0 은 에러가 발생하므로, 에러가 발생하지 않을까하지만, 결과는 false 이다!

논리곱(&&) 연산자는 좌항부터 연산을 하고, 단축 평가를 하기 때문에 첫번째 피연산자가 false 라면, 두번째 피연산자에 대해서는 평가를 하지 않고 (결과가 확정되었기 때문) false 를 반환한다. 

두번째 피연산자에 관련된 코드는 실행하지 않으므로 Dead Code가 된다.

*Dead Code: 실행되지 않는 코드

논리합(||) 연산자도 마찬가지로 다음 예제로 살펴보자.

1 == 0 || 1 / 0 == 0

이때는 첫번째 피연산자가 false 이고, 결과가 확정되지 않았으므로 1 / 0 == 0 까지 연산을 수행하게 되어서 에러가 발생한다.

1 == 1 || 1 / 0 == 0

만약 첫번째 피연산자가 1 == 1로, 결과가 true 라면, 두번째 피연산자를 평가하지 않으므로 결과로 true가 반환된다.

논리합(||) 연산자도 좌항부터 연산을 수행하고 단축 평가를 하기 때문에 앞선 연산이 true 라면 결과가 확정되어 이후 연산을 수행하지 않는다.

마찬가지로 두번째 피연산자에 관련된 코드는 실행하지 않으므로 Dead Code가 된다.

단축 평가 규칙

단축 평가의 규칙은 아래 표와 같다.

단축 평가의 이점

단축 평가의 이점은 효율성 향상에 따른 성능 향상에 있다.

논리 연산 수행시 결과가 이미 결정된 경우 나머지 부분을 수행하지 않기 때문에 불필요한 계산을 생략하여 효율성을 높인다. 이는 특히 연산을 많이 수행하는 메서드나 I/O 작업이 포함된 경우에 이점이 커진다.

boolean result = (condition1 && condition2); // condition1이 false라면 condition2는 평가되지 않음

그리고 단축 평가는 특정 조건에서만 메서드를 호출하거나 연산을 수행하고자 할 때 유용하게 쓰인다.

if (obj != null && obj.someMethod()) {
	// obj가 null이 아닌 경우에만 obj.someMethod()가 호출	
}

또한 특정 연산을 실제로 필요한 경우에만 수행하게끔 한다.

if (condition && someMethod()) {
	// someMethod()는 condition이 true인 경우에만 호출
}

이는 배열이나 리스트 같은 자료 구조를 접근할 때 범위 체크시에도 유용하다.

if (idx < array.length && array[idx] == target) {
	// array[idx]에 안전한 접근 가능
}

마치며,

단축 평가를 모른다면 코드 구현시 의도한대로 결과가 나오지 않거나, 런타임 에러가 발생하는 등의 문제가 발생할 수 있겠다.

이번 기회를 통해 단축 평가를 잘 정리한 것 같다.

그리고 Java 카테고리로 분류하긴 했지만, 단축 평가는 대부분의 주요 프로그래밍 언어에서 지원한다고 한다.

참고 포스팅

📌요약

main 메서드는 자바 프로그램의 진입점(entry point), 즉 시작점이다.

JVM은 자바 프로그램 실행시 main 메서드를 찾아서 시작하므로 main 메서드는 필수적인 메서드이다.

• public: 접근제어자로, JVM이 main 메서드를 접근할 수, 찾을 수 있다.
• static: 인스턴스 생성 없이 클래스가 로드되면 바로 실행되어야하고 프로그램 실행시 main 메서드는 메모리에 할당되어 있어야하기 때문에 가비지 컬렉터의 정리 대상이 아니여야 한다. 
• void: main 메서드가 종료되었다는 것은 프로그램이 종료되었다는 것을 의미하므로 반환할 리턴값도 없다.
• String[] args: 프로그램 실행시 main 메서드에 넘기는 파라미터이다.

main 메서드란?

먼저 이 main 메서드가 무엇인지 알아보자.

main 메서드는 Java 프로그램의 진입점(entry point)로, 프로그램이 실행될 때 가장 먼저 호출된다.

그리고 모든 자바 어플리케이션은 main 메서드를 필수로 포함해야한다.

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

💡 진입점(entry point)

진입점이란 프로그램이 시작되는 시작점으로, main 메서드가 이에 해당한다.

컴퓨터가 프로그램을 실행할 때 가장 먼저 main 메서드를 찾아서 그 안에 있는 코드를 실행한다.

즉, 프로그램을 시작할 때 컴퓨터가 어디서부터 실행해야할지를 알려주는 역할을 하는 것이다.

모든 자바 프로그램은 main 메서드를 포함해야하는 이유가 이에 있다. main 메서드가 없으면 프로그램이 어디서 시작해야할지를 몰라서 실행되지 않는다.

*관례적으로 프로그램의 시작점을 main으로 한다고 한다!

main 메서드가 자바 프로그램을 실행하려면 필수적으로 있어야하고, 가장 먼저 실행된다는 것을 알아보았으니 이제 하나씩 뜯어보자!

public

public은 접근 제어자(access modifier)중 하나로, 어디서든 해당 객체를 참조할 수 있는 접근 제어자이다.

main 메서드는 진입점(entry point)이기 때문에 JVM에서 이 main 메서드를 어느곳에서든 접근하기 위해 public 이여야한다.

JVM이 자바 프로그램을 시작하고 main 메서드를 실행하려는 시점은 아직 아무런 클래스도 로드되어있지 않은 상태이다.

가장 먼저 main 메서드가 어떤 클래스에 있는지를 찾고, 그 클래스에서 불러오는 과정이 필요하다.

그래서 이 main 메서드에 접근 제약이 생긴다면 JVM은 main 메서드를 찾지 못해서 프로그램을 실행시킬 수 없는 것이다.

이렇게 되면 자바 프로그램 실행이 안되므로, main 메서드에는 아무런 제약이 없도록 public을 써주어야 한다.

접근제어자로 public 이 아니라 private로 실행하면 아래와 같은 에러가 발생한다.  

오류: javafx.application.Application 클래스에서 기본 메소드가 Main3이(가) 아닙니다. 다음 형식으로 기본 메소드를 정의하십시오.
   public static void main(String[] args)

static

static 은 인스턴스 생성없이 메서드를 호출할 수 있게하는 키워드로, 정적 함수임을 의미한다.

static으로 선언한 속성과 메서드는 인스턴스와 관계없이 항상 일정한 값을 가지므로 굳이 인스턴스를 생성하지 않아도 사용할 수 있게끔 만들어진 것이다.

JVM이 main 메서드를 발견하면 main 메서드가 들어있는 클래스를 로드한다.

그 후 별도로 인스턴스를 생성하는 과정을 거치지 않고 클래스가 로드되면 바로 main 메서드를 사용할 수 있도록 해야하기 때문에 static 키워드를 붙여주어야 한다.

그리고 static으로 선언한 속성과 메서드는 프로그램이 실행되는 순간 메모리가 할당되고, 가비지 컬렉터의 메모리 정리대상이 아니다.

즉, static으로 선언한 속성과 메서드는 메모리에 항상 할당되어 있다는 것이다. 

main 메서드는 가비지 컬렉터에 의해 정리되어서는 안되는 기본 함수이므로 static을 붙여야한다.

void

void 는 메서드의 리턴 값이 없음을 의미한다. 자바는 메서드의 실행이 종료되면 리턴 타입을 명시해야하는 언어이기 때문에 main 메서드에도 명시되어있어야 한다.

main 메서드가 종료되었다는 것은 프로그램이 종료되었다는 것을 의미하므로 반환할 리턴값도 없다.

그렇기 때문에 void를 붙여준다.

String[] args

String[] args는 커맨드 라인의 argument들로, 커맨드 라인을 통해 main 메서드 내부에서 사용할 수 있는 String 타입의 데이터를 전달할 수 있다.

*String[]는 String 타입의 여러 값을 저장할 수 있는 저장구조이다.

JVM이 main 메서드의 변수명은 강제하지 않기에 변수명은 임의로 변경해도 잘 동작한다.

하지만 String[]  args 구문 자체를 빼면 안된다. 일반 메서드는 main 메서드 내부에서 호출하기 때문에 입력값을 main 메서드에서 정할 수 있지만, main 메서드는 프로그램 실행시 처음으로 수행되기 때문에 외부로부터 값을 받을 수 있어야하기 때문이다.

즉, main 메서드는 프로그램 내부에서 값을 호출할 수 없기 때문에 문자열 인자를 받을 수 있도록 해야한다는 것이다.

하지만 IntelliJ나 Eclipse 같은 IDE로 Java 프로그램을 구현하고 실행하는 요즘에는 main 메서드에 문자열을 전달할 일이 거의 없다. 위에 기재했듯이 커맨드라인의 인자값으로, Java가 DOS 환경에서 실행되던 때에 사용하던 것이다. 

명령 프롬프트(cmd)등의 터미널을 통해서 자바를 실행할 때 인자값이라고 생각하면 된다. 

예를들어 아래와 같은 자바 파일을 컴파일하고 실행시 인자값을 넣어서 확인해보겠다.

package project01;

import java.util.Arrays;

public class Solution01 {
	public static void main(String[] args) {
		System.out.println(Arrays.toString(args));
	}
}

윈도우의 경우 명령 프롬프트(cmd)에서 실행해보면 아래와 같이 인자값을 잘 받아서 출력해준다는 것을 알 수 있다.

해당 자바 파일이 있는 디렉토리에서 명령어를 입력해서 수행한다.

• java Solution01.java : java 파일 컴파일
• java project01.Solution01 test string HelloWorld : 컴파일한 자바 파일을 실행
  • projext01.Solution01: 패키지명.클래스명
  • test string HelloWorld 가 main 메서드의 인자값으로 들어가는 String[] args에 해당하는 부분이다.

*중간에 cd .. 를 하는 이유는 상위 폴더로 이동하기 위해서!

물론 IDE 에서도 설정을 하면 main 메서드에 String 배열 인자를 전달할 수 있다고 한다.

참고 포스팅

✏️ 코딩테스트를 풀면서 int[] 를 List로 변환하다가 마주한 문제와 알게된 문법에 대한 포스팅

int[ ] to List<Integer>

int 배열을 List로 변환하는 방법, 즉 int 배열에 담긴 요소를 그대로 List<Integer> (=ArrayList<Integer>)타입으로 변환하는 방법을 아래와 같이 시도했었다.

❌ Fail : Arrays.asList()로 변환

Arrays.asList()에 int 배열(int[])을 매개변수로 그대로 담으면 List<int[]>형으로 변환된다.

// int 배열
int[] arr = {1,2,3,4};

// 리스트로 변환
List<int[]> list = Arrays.asList(arr);

// 결과
System.out.println(list.size());                    // 1
System.out.println(list.get(0));                    // [I@36baf30c
System.out.println(Arrays.toString(list.get(0)));   // [1, 2, 3, 4]

int 배열인 arr을 asList로 변환했을때 기대한 건 arr의 요소(1,2,3,4)를 가진 List<Integer> 타입이지만, List<int[]>로 반환된다.

내가 원하는 List<Integer> 타입이 아니다!

결론부터 말하자면,

Arrays.asList()는 primitive 타입을 Wrapper 클래스로 형변환해주지 않는다.

즉, int 타입을 Integer로 형변환해주지 않기때문에,
primitive 타입의 배열은 Arrays.asList()를 사용해서 List로 변환할 수 없다.

따라서 int 타입의 배열은 다른 방식으로 배열에서 List로 변환해야한다.

1) 반복문을 사용하거나 2) Stream을 사용해서 변환하는 방식이 있다.

✅ Success : 반복문 or Stream 사용해서 변환

1. 반복문

// int 배열
int[] arr = {1,2,3,4};

// 리스트로 변환
List<Integer> list = new ArrayList<>();
for (int el: arr) {
    list.add(el);
}

// 결과
System.out.println(list.size());    // 4
System.out.println(list);           // [1, 2, 3, 4]

위처럼 반복문을 통해 int 배열을 순회하면서 list에 값을 하나씩 추가해주면 된다.

결과를 확인해보면 List에 Integer 요소 4개가 그대로 들어가 있는것을 확인할 수 있다.

2. Stream 

Stream은 람다와 함께 사용되어 간결하게 표현 가능한 기능으로, Java 8부터 지원된다.

// int 배열
int[] arr = {1,2,3,4};

// 리스트로 변환
List<Integer> list = Arrays.stream(arr).boxed().collect(Collectors.toList());

// 결과
System.out.println(list.size());    // 4
System.out.println(list);           // [1, 2, 3, 4]

• Arrays.stream(arr) : int[] → IntStream
• boxed() : IntStream → Stream<Integer>
• collect(Collectors.toList()) : Stream<Integer> → ArrayList<Integer>
  • Stream의 데이터를 변형 등의 처리를 하고 원하는 자료형으로 변환
  • collect: 스트림의 최종연산으로, 매개변수로는 Collector를 필요로 함
  • Collectors.toList(): Collectors를 이용하여 스트림의 요소들을 List 객체로 변환
    *Collectors: 미리 작성된 다양한 Collector를 반환하는 static 메서드를 가지고 있다.

이렇게 int[]를 List<Integer>로 변환하는데 성공했는데,

다음에는 배열을 리스트로 변환하는 방법을 더 알아보고,

Arrays.asList()와 new ArrayList<>()로 생성된 List의 차이점도 포스팅 해야겠다.

참고 포스팅

자바 프로그래머가 자주 실수 하는 10가지 - 1

[JAVA] For과 Stream은 어떤 차이가 있는걸까?