📚 TIL 7일차

오늘 주요 사항 (5/23, 화요일)

1. 일간회고(TIL)
2. Java 문법 학습

미리보기를 비워두기엔 좀 그래서 TIL/WIL에는 내가 직접 찍고 보정한 사진을 쓰고 있는데, 다른 사람들은 심플한 미리보기 이미지를 직접 만드는 것 같다!

내가 너무 감성 블로거가 되어가는 건 아닌지...

일간회고(TIL)에 대한 고민

아침에 특강을 들으면서 내가 일간회고(TIL)를 작성하는 방식에 대해 되돌아보는 시간을 잠깐 가졌다. 자습을 할 때는 공부한 내용을 요약-정리만 하는게 현재의 가장 큰 문제인 것 같다. 회고라기 보다는 강의노트를 쓰는 느낌.

공부를 하면서 정리하다 보면 피곤해져서... 하루의 끝으로 갈 수록 힘이 빠지는 경향이 있는데, 내 주관을 담아서 코드를 직접 작성해보거나, 이해가 안되는 부분을 더 파고 들어보는 것도 방법이 될 수 있을 것 같다.

그리고 회고를 쓰는 것에 집중해서 여기에 너무 힘을 빼는 건 아닌지에 대한 고민도 빼놓을 수 없다. 간결하게 적었던 시절도 있었지만, 내가 적었던 일지나 회고를 다시 돌아볼 때 기억이 잘 나지 않았고, 다른 작업을 할 때도 큰 도움이 되지 않았던 적이 많았다. 이를 보완하기 위해 기억이 강하게 남아있을 때 최대한 상세하게 적도록 하고 있다. 그런데 상세하게 적다보니 남들보다 시간이 많이 걸린다는 문제가 생겨버린 것이다... 상세하게 적는 건 포기하고 싶지 않아서, 매일 다양한 방안에 대해 고민해보면서 좋은 합의점을 찾을 수 있었으면 좋겠다.

(한 줄 요약: 한동안 TIL로 실험하게 될 것 같다)

상수 (final)

일반적으로 상수를 정의할 때 사용하는 키워드인 final에 대한 정리를 해보았다.

원래는 키워드만 메모해두려고 했는데... 인터넷에 돌아다니는 예제에서 위화감이 느껴져서(?) static final이 왜 관례가 되었는지에 대한 학습도 추가적으로 해보았다.

[Java] final: 왜 static final이라고 써요?

그저 final 키워드를 잊지 말자! 는 의도로 시작했지만 외우는 걸 넘어서서 용도까지 추가로 학습할 수 있었던... 유익한 시간 👀...

클래스

인스턴스 멤버 & 클래스 멤버

이런 것까지 신경쓰면서 코드를 작성한 적은 없어서 도움이 많이 되었다. 예시도 직접 작성해보면서 열심히 정리했기 때문에 페이지를 따로 분리했다 (ㅎㅎ)

[Java] 인스턴스 멤버 & 클래스 멤버

this와 this()

📌 this = 객체(인스턴스) 자신

int value;

public Example(int value) {
	
    this.value = value;
}

반환 타입이 객체(인스턴스) 자신의 클래스 타입이라면, this를 사용해 인스턴스 스스로의 주소를 반환할 수 있다.

public Example returnInstance() {

	return this;
}

📌 this() = 객체(인스턴스) 자신의 생성자를 호출

⚠️ this() 키워드를 사용해서 다른 생성자를 호출할 때는 반드시 해당 생성자의 첫 줄에 작성되어야한다. 그렇지 않으면 컴파일 오류가 발생한다.

String tag;	// 상품명
int cost;	// 가격
int count;	// 개수

public Mart(String tag) {

	/* 
    * 아래처럼 한 줄로 해결할 수 있다.
	this.tag = tag;
    this.cost = 10000;
    this.count = 1;
    */
    
    // 생성자를 호출
    this(tag, 10000, 1);
}

public Mart(String tag, int cost, int count) {

	this.tag = tag;
    this.cost = cost;
    this.count = count;
}

super와 super()

📌 super = 부모 클래스의 멤버를 참조

/* 부모 클래스 */

String tag;	// 상품명
int cost;	// 가격
int count; 	// 개수


/* 자식 클래스 */

String tag = "Melon";	// 상품명
int cost = 10000;		// 가격
int count = 1;		 	// 개수

public void buyProduct(String tag, int cost, int count) {
	
	super.tag = tag;		// tag는 부모 필드에 set
    super.cost = cost;		// cost도 부모 필드에 set
    this.count = count;		// count는 자식 필드에 set

}

📌 super() = 부모 클래스의 생성자를 호출

⚠️ this() 키워드와 마찬가지로, super() 키워드를 사용해서 다른 생성자를 호출할 때는 반드시 해당 생성자의 첫 줄에 작성되어야한다. 그렇지 않으면 컴파일 오류가 발생한다.

/* 부모 클래스 생성자 */

public Warehouse(String tag, int cost, int count) {

	this.tag = tag;
    this.cost = cost;
    this.count = count;

}


/* 자식 클래스 생성자 */
public Mart(String tag, int cost, int count) {

	super(tag, cost, count);
    
}

다형성: instance of

instance of는 객체 타입을 확인하는 연산자로, 형변환 가능 여부를 확인해 참(True) 혹은 거짓(False)를 반환한다. 주로 상속 관계(다형성)에서 부모 객체인지, 자식 객체인지 확인하는데 사용된다.

{대상 객체 명} instanceof {클래스 명}의 형태로 사용할 수 있다.

class Parent {}
class Child extends Parent {}

public class Main {

	public static void main(String[] args) {

		Parent p = new Parent();
        Child c = new Child();
        
        system.out.println(p instanceof Parent);	// 결과: true, 부모 본인
        system.out.println(c instanceof Parent);	// 결과: true, 자식 is-a 부모 O
        system.out.println(p instanceof Child);		// 결과: false, 자식 is-a 부모 X
        system.out.println(c instanceof Child);		// 결과: true, 자식 본인
        
	}
}

이해가 힘들다면 "instancof는 해당 클래스가 자기집이 맞는지 확인해 준다"고 생각하면 이해가 쉽다.

package와 import

📌 package = 클래스의 일부분이면서 클래스를 식별해 주는 용도

C++, C#의 namecase와도 유사한 개념이라고 한다. 패키지를 선언할 때는 아래와 같은 형태로 사용한다.

package {상위패키지}.{하위패키지};

pacakge week2.day7;

public class Camp {
	public void running() {
    	System.out.println("Help!");
    }
}

선언한 package에 작성된 클래스를 해당 package 바깥에서 사용하려면, import가 필요하다.

📌 import = 다른 패키지에 있는 클래스를 사용하기 위해 사용

C++, C#의 using과도 유사한 개념이라고 한다. 패키지를 임포트 할 때는 아래와 같은 형태로 사용한다.

import {상위패키지}.{하위패키지}.{클래스명};
import {상위패키지}.{하위패키지}.*;

package week2.main;

import week2.day7.Camp;

public class Main {
	public static void main(String[] args) {
        Camp camp = new Camp();
        camp.running(); // "Help!" 출력
        
	}
}

import 할 때, 클래스명은 생략하고 *를 사용하여 표현하면, 패키지에 포함된 모든 클래스를 사용할 수 있다.

인터페이스

먼저 (1) 인터페이스를 생성하고 → 그 (2) 인터페이스를 implements 키워드를 사용해 구현한다.

(1) 인터페이스 생성

• 모든 멤버변수는 public static final 이어야한다. (생략 가능)
• 모든 메서드는 public abstract 이어야한다. (생략 가능, static 메서드와 default 메서드는 예외)

public interface MarketInterface {

	public static final String tag = "MELON";
	public int value = 10000;
    int count = 10;
    
    public abstract void sell() {}
    void buy() {}
}

(2) 인터페이스 구현

• 인터페이스를 구현할 때는 implements 키워드를 사용한다.

public class Mart implements MarketInterface { 
	
    // 추상 메서드 오버라이딩
	@Override
	public void sell() {
		// sell something...
	}
    
    @Override
    public void buy() {
    	// buy something...        
    }
}

인터페이스 : 상속

인터페이스 간의 상속이 가능하다. 이 때는 클래스 상속과 동일하게 extends 키워드를 사용하고, 다중 상속이 가능하다.

인터페이스 C에는 아무것도 선언 되어있지 않지만, 인터페이스 A와 B를 상속받았기 때문에, 결과적으로 C만 상속받으면 A와 B에서 선언된 추상 메서드를 구현할 수 있다.

interface A {
    void a();
}
interface B {
    void b();
}

// 인터페이스 A와 B를 다중 상속 받은 인터페이스 C
interface C extends A, B { }

public class Example implements C {

	// 인터페이스 A의 추상 메서드 a()
    @Override
    public void a() {
        System.out.println("Test : A");
    }

	// 인터페이스 B의 추상 메서드 b()
    @Override
    public void b() {
		System.out.println("Test : B");
    }
}

인터페이스의 구현과 상속은 일반 클래스 상속과도 함께 사용될 수 있다!

public class Child extends Parents implements ExInterface { }

상속과 추상을 모두 적용하면 클래스의 머리 부분은 위와 같은 형태가 된다

☕️ 오늘도 1일 1커피 완료!

공부한 내용들은 따로 글 파서 적어두고, 여기에는 링크만 걸어둘까? 라는 고민을 매일 하고 있다. (아무래도 가독성이 별로인 것 같아서)