• 추상 메서드의 집합
• 구현된 것이 전혀없는 설계도. 껍데기(모든 멤버가 public)

interface PlayingCard {
    public static final int SPADE = 4;
    final int DIAMOND = 3; // public static final
    static int HEART = 2; // public static final
    int CLOVER = 1; // public static final

    public abstract String getCardNumber();
    String getCardKind();  
    // public abstract String getCardKind();
    // public abstract를 생략한것
}

• 인터페이스의 조상은 인터페이스만 가능(object아님)
• 다중 상속이 가능 (추상메서드는 충돌해도 문제없음)

interface Fightable extends Movable, Attackable {}

interface Movable {
    void main(int x, int y);
}

interface Attackable {
    void attack(iUnit u);
}

인터페이스의 구현

• 인터페이스에 정의된 추상 메서드를 완성하는 것
• implements 키워드 사용
• 일부만 구현하는 경우 클래스 앞에 abstract 붙여야함 (추상클래스와 동일)

class 클래스이름 implements 인터페이스 이름 {
}

인터페이스 다형성

interface Fighteable {
  void move(int x, int y);
  void attack(Fightable f);
}


class Fighter extends Unit implements Fightable {
  public void move(int x, int y) { ... }
  public void attack(Fightable f) { ... }
}

// 부모 = new 자식
Unit u = new Fighter();
Fightable f = new Fighter();

f.move(100, 200);
f.attack(new Fighter());

공통점

• 추상메서드를 가지고 있다. (미완성 설계도) 차이점:
• 추상클래스 - 일반적인 클래스의 특징을 다 가지고 있음(instance variable, instance method, constructor) + abstract methods
• 인터페이스 - 추상메서드만 가능(생성자, iv, im 불가능)

- 추상클래스:

추상메서드를 가지고 있는 클래스

• 추상메서드 구현

  abstract class Player {
    abstract void play(int pos);
    abstract void stop();
  }
  

class AudioPlayer extends Player { void play(int pos) { 생략... } void stop() { 생략... } }

#### - 인터페이스:
추상메서드와 상수를 가지고 있는 것. 모든 메서드가 public

- 인터페이스 구현

interface Fightable { void move(int x, int y); void attack() }

class Fighter implements Fightable { public void move(int x, int y){ 생략... } public void attack(){ 생략... } } ```

• 미완성 메서드를 가지고 있는 클래스 (=미완성 설계도)
• 여러 클래스에서 공통적으로 사용될 수 있는 부분을 추상클래스로 작성할 수 있다.

abstract class Player {
    abstract void play(int pos); 
    abstract void stop();
}

특징 - 추상클래스는 인스턴스 생성 불가

Player p = new Player(); // 에러 발생

• 이렇게 쓸 수 없다는 것.

그렇다면 추상클래스를 왜 쓸까요?

• 다른 클래스 작성에 도움을 주기 위해서.
• 상속을 통해 추상 메서드를 완성해야 인스턴스 생성가능

  class AudioPlayer extends Player {
    void play(int pos) { ... }
    void stop() { ... }
  }
  

AudioPlayer ap = new AudioPlayer(); // OK

= 이렇게 상속을 받고 써줘야 인스턴스 생성 가능


## 추상 메서드란?
- 미완성 메서드. 구현부가 없는 메서드
- 꼭 필요하지만 ** 자손마다 다르게 구현될 것으로 예상되는 경우** 사용함
- 반드시 다 구현해야 하는건 아님
- 일부만 구현하는 경우? 아래처럼 abstract를 써줘야함
- 추상 클래스도 생성자가 있어야 함

abstract class AbstractPlayer extends Player { void play(int pos) { ... }

// stop이 구현 안되어있으므로 클래스에 abstract써줘야함

}

예제.

abstract class Player { boolean pause; int currentPos;

Player() {
} // 생성자 있어야함

abstract void play(int pos); // 추상메서드
abstract void stop(); //추상 메서드

void play() {
    play(currentPos);
}

}

사용하려면?
- 위 추상클래스를 상속받는 자손을 구현하여 추상 메소드를 구현하고, 자손 객체를 생성한 후 play를 호출하면 됨.

AudioPlay라는 객체가 Player로 상속받아서 사용했다면
Player p = new AudioPlayer(); 이렇게 사용가능. - 다형성!!! Polymorphism

class SmartTv extends TV {
    ....
}

smartTv가 Tv부모객체를 상속받은 형태일때,

Tv t = new SmartTV();

와 같이 사용할 수 있는 것.

SmartTv s = new SmartTv(); //참조변수와 인스턴스 타입이 일치 Tv t = new SmartTv(); // 조상참조변수로 자손인스턴스 참조 SmartTv s = new Tv(); // 이건 에러. * 왼쪽이 리모콘이라고 생각하면 이해하기 쉬움

참조변수의 형 변환

사용할 수 있는 멤버의 갯수를 조절하는 것

class FireEngine extends Car {
}

FireEngine f = new FireEngine();
Car c = (Car) f
FireEngine f = (FireEngine) c // 형변환 실행에러 java.lang.classCastException

형변환 전에 instanceof 연산자로 형변환 가능여부를 *반드시 * 확인하고 변환해야 함

if (a instanceof b) { // a는 b의 child ?

}

//c가 fireEngine인지, c가 FireEngine의 child or 자기자신인지를 확인하는 것

if (c instance of FireEngine) {
}

System.out.println(fe instanceof Object); //true
System.out.println(fe instanceof Car); // true 
System.out.println(fe instanceof FireEngine); // true 

다형성의 장점

1) 다형적 매개변수: Polymorphism allows objects to be treated as instances of their parent class

  Product p = new TV();
  Product c = new Computer();

  class buy(Tv t) {
  }

  class buy(Computer c) {
  }

  // 이렇게 다 따로 오버로딩 해주는게 아니라 

  class buy(Product p) {
  }
  // 이렇게 하나로 써줄 수 있음 

2) 여러종류의 객체를 배열로 다루기

Product p[] = new Product[3];
p[0] = new Tv();
p[1] = new Computer();
p[2] = new Audio();

논리형 - boolean 문자형 - char / string 정수형 - int / long / byte(이진데이터) / short(c언어와의 호환을 위해 추가되었으나 잘 쓰이지 않음) 실수형 - float / double

출처- https://www.youtube.com/watch?v=yVxsi_CBLR0&list=PLW2UjW795-f6xWA2_MUhEVgPauhGl3xIp&index=18

1bit - 2진수 한 자리 1byte - 8bit

byte b = 3; (00000011; //이렇게 2진수로 저장) n비트로 표현할 수 있는 값의 갯수? 2n개 n비트로 표현할 수 있는 부호 없는 값의 갯수? 0 ~ 255 n비트로 표현할 수 있는 부호 있는 값의 갯수? -128 ~ 127

부호있는 정수의 범위

short 2 byte = 16bit -2의15 ~2의 15 - 1 char 0 ~ 2의16 - 1 등등....

Println / Printf

만약 지시자를 선택해서 출력하고 싶으면 printf()를 사용하면 된다 %b : boolean %d : 10진수 %o : 8진수 (%#o으로 써주면 접두사가 붙음. 01...) %x : 16진수 (%#x으로 써주면 접두사가 붙음. 0x...) %f : float %e, %E : 지수 exponent %c : character %s : string %g : 간략한 형식 (f 또는 e)

• 2진수는 없음 Integer.toBinaryString(정수) : 2진수를 문자열로 출력

system.out.printf("age: %d year: %d\n", 14, 2017);

float f = 123.4567890f;

system.out.printf("%f", f); 
// 123.456787 정밀도는 7자리. 그 외의 자리, 여기선 87은 의미 없음. 
// 정확한 값을 출력하고 싶으면 double사용하면 됨. 정밀도가 15자리임

system.out.printf("%e", f); 
// 1.234568e+02 지수 형식으로 출력, 마지막자리 반올림되어서 8로 나옴

System.out.printf("[%5d]%n", 10); // [   10] 앞의 세 자리는 빈 공간으로 체워짐
System.out.printf("[%-5d]%n", 10); // [10   ] 왼쪽 정렬
System.out.printf("[%05d]%n", 10); // [00010] 공백대신 0로 출력되도록

System.out.printf("[%5d]%n", 1234567); // [1234567] // 지정 자리수보다 큰 값이면, 값이 잘리는게 아니라 전부 나옴

double d = 1.23456789;
System.out.printf("[%14.10f]", d); //전제 14자리에, 소수점 10자리 => [  1.2345678900] 
System.out.printf("[%.6f]", d);  // [1.234568] 소수점 6자리

• 하나의 값을 저장할 수 있는 메모리 공간(RAM)

2. 변수의 선언 및 저장

• 변수타입 변수이름; ex) int age = 10; age라는 메모리 공간에 10이라는 값을 저장하는 것

3. 변수의 종류

클래스 변수, 인스턴스 변수, 지역 변수(꼭 초기화 해야 함)

4. 변수의 타입 (기본형 8가지)

문자 char 정수 byte, short, int, long
실수 float double 논리 boolean

5. 변수와 상수, 리터럴

변수(variable)는 저장한 값을 변경가능하지만 상수(constant)는 '한 번'만 저장 가능

• 변수 int score = 100;
• 상수 final int MAX = 100;
• 리터럴(literal) - 그 자체로 값을 의미하는 것 출처: 유투브 남궁석의 자바의 정석(https://www.youtube.com/watch?v=17FmvFm0E68&list=PLW2UjW795-f6xWA2_MUhEVgPauhGl3xIp&index=13)

리터럴의 접두사와 접미사 접미사 : 대/소문자 구분 없이 사용. float a = 1.4f; byte b = 127; byte b = 128; -> error, byte타입은 -128 ~ 127까지만 저장 가능 int i = 100; int bi = 0b0101; // 2진수 int oct = 0100; // 8진수 int hex = 0x100; // 16진수 long l = 10_000_000_000L; // L안붙이면 에러남. int범위를 벗어나는 값이기 때문에. _는 보기 편하라고 넣는 것임

float f = 3.14f; (f를 생략하면 double로 인식하여 오류가 남) double d = 3.14d; (d는 생략가능)

Quiz 10. => double 10.0 .10 => double 0.10 10f => float 10.0 1e3 => double 1000.0

변수와 리터럴의 타입 불일치

1) 가능한 케이스 : 범위가 변수 > 리터럴 int i = 'A'; // int의 저장범위가 char보다 크므로 가능함 long l = 103; // long > int double d = 3.14f; // double > float

2) 불가능한 케이스 : 범위가 변수 < 리터럴 int i = 30_000_000_000; //int의 범위(20억)를 벗어남 long l = 3.14f // long < float float f = 3.14 // float < double

3) byte, short변수에 int리터럴 저장 가능 byte b = 100; // byte범위 -128 ~ 127에 속하므로 byte b = 128; // 이건 범위를 벗어나서 오류

기본형과 참조형

기본형 Primitive Type

• boolean, char, byte, short, int, long, float, double 딱 8개 참조형 Reference type
• 기본형을 제외한 나머지(String, System등.. )
• 메모리 주소를 저장(4 byte or 8 byte) (32bit JVM에서는 4byte, 64bit JVM에서는 8byte)

참조형 변수 예제 Date today; today = new Date(); // today에 객체의 주소를 저장하는 것

객체지향

• C++, Java, python등에서 사용되는 개념

자동 메모리 관리

• 자바가 나오기 전에는 '사람'이 직접 메모리를 관리를 했어야 하지만, 자바에서는 Garbage Collector(GC)가 메모리를 알아서 정리해 준다

멀티 쓰레드 지원

• 하나의 프로그램에서 여러개의 작업을 가능하게 해줌

풍부한 라이브러리 제공

• 라이브러리? 프로그램을 개발하는데 자주 쓰이는 기능들을 제공해 주는 것

운영체제에 독립적

• 일반적으로 프로그래밍을 작성하면, 특정 운영체제에서만 운영이 가능함(=윈도우에서 작성한 프로그램은 리눅스에서 사용 불가능)
• 그치만 자바의 경우엔 어느 운영체제에서나 사용 가능
• 어째서? 자바 가상 머신 때문

자바 가상 머신(JVM - Java Virtual Machine)

자바 프로그램이 실행되는 가상 컴퓨터 한번 작성하면, 어디서든 실행 - Write once, Run anywhere

출처: https://www.tcpschool.com/java/java_intro_programming

자바는 운영체제별로 JVM이 개발되어 있어서, 자바 애플리케이션을 구현하고 나면 다른 운영체제에서도 실행함에 있어 전혀 문제가 되지 않는다.

• 프로그래밍 언어
• 실행 환경(JRE) + 개발도구(JDK) + 라이브러리(API)

자바는 어디에 쓰이나요?

• PC Application - ex. 개발도구인 인텔리제이, 이클립스 또한 자바로 만들어 짐
• Web Application
• Android Application
• Big Data - Hadoop
• Game, 과학, 소형기기 등 - ex. 마인크래프트

왜 굳이 자바를 배워야 하나요?

• 다양한 분야에서 활발히 사용됨
• 20년 이상 프로그래밍 1, 2위로 사용되는 언어
• 배우기 쉽고 풍부한 학습자료
• 모던 프로그래밍 언어 = 객체지향 + 함수형(자바 8부터 추가됨)
• 실무에 가장 많이 사용되는 언어

자바의 역사

• JDK 1996년 개발
• J2SE 1.2 1998 - J2SE(스탠다드) / J2ME(소형, 마이크로) / J2EE(대기업용)
• J2SE 5.0 2004
• JAVA SE8 2014 - 이 후 6개월마다 새로운 버전이 나오고 있음, 아직도 가장 많이 사용되는 버전
• JAVA SE 21

프로그래밍 언어로 작성된 소스 코드(.java)를 컴퓨터가 이해할 수 있는 기계어(.class)로 변환하는 소프트웨어 도구 를 의미한다.

컴파일 주요기능

• 사람이 작성한 code를(high-level language)를 기계어(low-level language)로 바꿔주는 과정
• Verifying syntax: 문법 검사(문장 끝에 세미콜론(;)을 붙였냐 하는걸 검사하는듯..?)
• Semantics of source code: 변수의 정의와 사용, 함수 호출 등을 분석
• Code optimizations: 최적화, 시간이 많이 소요되는 작업
• Generate machine code

Compilation vs Interpretion

interpretation

• 파이썬, 자바스크립트
• 실시간으로 에러를 알 수 있음
• compilation보다 느림

compilation

• 자바, C
• 다 작성하고 컴파일하는 것.

출처 https://devparker.tistory.com/110

면접 단골 질문 정리

인터페이스

사용하는 이유? 여러명의 개발자가 협업을 할때, 미리 정해놓는 '약속'같은 개념 만약 여러명이 프로젝트를 한다고 생각할때, 각자 알아서 하면 나중에 수정해야 하는 경우가 많으므로, 미리 그려놓는 설계도 라고 생각하면 편하다. 그냥 내가 만든 예시 - 아래와 같이 orderPizza라는 메서드를 구현하고 싶은 경우? A라는 사람이 interface로 정의해 놓으면 B라는 실체를 구현하는 사람이 parameter를 어떻게 쓸 지 고민없이 사용 가능함. 이렇게 미리 인터페이스를 정의한 경우에는 추후에 변수명을 바꾼다던가 변수타입을 바꾼다든가하는 추가적인 일이 필요없다는 말임. 인터페이스가 설계도 라는 말이 이해가 되지 않으신가요? 나는 이해됨,

interface I {
    public void orderPizza(string menu, int inch, int price);
}

class A implements I {
    public void orderPizza(string menu, int inch, int price) {
    }
}

인터페이스 특징

인터페이스가 구현된 클래스에서는(위에선 Class A) 인터페이스 내에 있는 메소드가 반드시 구현되어야 함 인터페이스 멤버는 무조건 public이여야 함 클래스는 여러개의 인터페이스를 구현할 수 있음 다중 상속 가능

class A implements IA, IB, IC {
}


interface IA {
    public class A();
}

interface IB extends IA{ 
    public class B();
}

class IB {
    public class A(){ }
    public class B(){ } 
    // 둘 다 반드시 구현되어야 함
}

추상클래스

추상메서드를 가진 클래스는 무조건 추상 클래스 추상메드는 상속받은 클래스에서 무조건 구현되어야 함.

• 때문에 추상클래스에는 final키워드를 붙일 수 없다

public abstract class animal {
    abstract void eat();
     abstract void sleep();
}

• Not able to create instance
• 즉 Animal a = new Animal() 이게 안 됨. 쉽게 이해하기 길에서 동물을 본 적 있나요? 고양이, 강아지는 봤지만 동물을 본 적은 없음. 그런 의미임

public abstract class 어류 extends 동물{ // 추상클래스'동물'을 상속받음 
}
public abstract class 포유류 extends 동물{ // 추상클래스'동물'을 상속받음 
}
public abstract class 조류 extends 동물{ // 추상클래스'동물'을 상속받음 
}

이렇게하면 어류도 포유류도 인스턴스를 생성할 수 없음

public class 고등어 extends 어류 { // 고등어는 추상클래스 '동물'을 상속받은 추상클래스'어류'를 상속받음 
}
public class 상어 extends 포유류 { // 추상클래스'포유류'를 상속받음 
}

public class 펭귄 extends 조류 { // 추상클래스'조류'를 상속받음 
}

이런식으로 정의되어 있다면, 고등어, 상어, 펭귄은 '물'에 사는 동물이라는 공통점이 있지만, 이를 상속할 수는 없음. 쉽게 말하면 위에서 아래로만 상속 가능.

public clas 고래 extends 포유류, 수생동물 {  -> 이렇게 사용 불가능
}

이럴 때 사용하는게 인터페이스!

public interface 물생활 {
    public abstract void 수영();
}

물생활 물 = new 물생활();
물.수영(); 

참고 자료. https://www.youtube.com/watch?v=SgjRG0dS66o

정리 Abstract vs Interface

공통점

선언만 있고 구현 내용이 없는 클래스 상속을 받은 하위클래스는 모든 메소드를 재정의해야 함(오버라이딩) 인스턴스화 불가능 Animal a = new Animal() 불가

차이점

추상클래스는 단일 상속 = extends a (추상클래스) 인터페이스는 다중 상속 = implements a, b, c(인터페이스) /

추상클래스는 상속받은 클래스의 기능을 이용하고 확장하는 것 인터페이스는 하위클래스에게 일종의 설계도를 제공하는 것. 다형성과 코드 사용성을 높일 수 있음.

그러므로 이참에 정리

[public] static void main(...

접근 제어자(Modifier)

public

• 말 그대로 모든 class에서 접근 가능한 메소드를 생성할때 사용

  private

• 외부 접근이 불가능함. 같은 클래스 내에서만 사용가능

  protected

• 상속 받은 클래스 또는 같은 패키지 내에서만 사용가능

  default / no modifier

• 같은 패키지 내에서만 사용가능

그렇다면 왜 굳이 사용할까??

이건 자바의 '특성'과도 관련이 있다. OOP의 장점인 캡슐화를 위해서!!!!

public class test {

    private String id;
    private Integer sum;

    //getter
    public String getId() {
        return id;
    }
    public String getSum() {
        return sum;
    }

    //setter
    public void set(String id) {
        this.id = id;
    }
    public void setSum(Integer a, Integer b) {
        this.sum = a + b;
    }
}

이런 코드를 많이 보셨을거다. id와 pw의 변수는 private으로 선언하여 '직접' 접근할 수 없게 해 두었고, 그 값을 가져오기 위해서는 getter를 사용해야 한다. 이렇게 구현하는 걸 '캡슐화' 라고 한다.

이렇게 해 두면 사용자가 직접 값을 변경할 수 없다.

Test test = new Test();
test.sum = 10; // error

이렇게 직접 바꿀수 없다는 뜻이 된다. 요런게 캡슐화

public [static] void

그렇다면 두번째, static은 뭘까?

1) static은 변수와 메소드로 사용 가능하다.

static string developer_kim = "Good";

public static class Hello() {
    System.out.println("hello!");
}

2) static으로 생성한 변수, 메소드는 메모리에 한 번 할당되어서 프로그램이 종료될때 해제된다. (가비지 컬렉터의 관리를 받는 Heap이 아니라 Static영역에 저장되므로) 이 말은 즉슨, 잘 사용하지도 않는 변수/메소드를 static으로 선언하는 경우 성능에 영향을 끼칠 수 있다는 의미가 된다. 왜냐면 그만큼 메모리를 잡아먹으니까! 근데 또 다른 한편으로는 자주 사용하는 인스턴스의 경우엔 static으로 만들어 놓고 사용한다면 성능에 좋다는 말이 된다. 즉, 잘 사용하면 득, 못 사용하면 실!

3) static은 메소드를 인스턴스 없이 실행할 수 있게 해 준다.

Test test = new Test();

이렇게 만들어서 접근하지 않아도 된다는 뜻이다. 근데 이 말은 반대로 객체지향의 특성을 깬다는 말이다. 붕어빵 틀에 붕어빵을 찍어내야되는데 왜 찍어내지 못하니!!

왜? 이건 왜 또 필요한걸까? 언제 써야 할까?

• 유틸함수를 생성시 사용하면 좋다. Math.round(), Math.max() 뭐 이런 유틸함수는 다 static함수이다.
• 자주 사용하는 함수 변수의 경우엔 사용하면 편하고 좋으다!

public static [void]

제일 쉬워 제일 좋아 이건 리턴값을 의미한다. void는 말 그대로 아무것도 리턴하지 않는다는 거고 저 자리에 String, Integer, Array, 객체 등등 써서 리턴 값으로 전달할 타입을 선언하는 것

이렇게 오늘도 깨알 공부 끝!

그래서, 새해니까, 호기롭게 자바 강의를 듣기 시작했다. 첫 강의는 여전히 variables '아 이건 겁나 쉽지 아 이걸 모를리가!!!?' 라는 마음가짐으로 인스타 둘러보기나 하며 무성의 하게 듣고 있다가 문득, 아 그럼 int와 Integer의 차이를 내가 "제대로" 설명할 수 있는가에 대한 의문이 들었다. 그래서 이 글을 쓰게 되었다 ^.^...

기본형(Primitive) vs 래퍼클래서(Wrapper Class)

기본형

• byte, string, char, short, int, long, float, double (8가지)
• Stack 메모리 공간에 저장

래퍼클래스

• Integer, Boolean, String, Character...
• 기본형을 클래스형으로 만든 것
• Heap 메모리 공간에 저장

래퍼클래스의 특징

• 기본형의 경우 값을 비교하지만, 참조형의 경우 '주소' 를 비교 즉, 값을 비교하는 경우 == 사용 할 수 없음, equals를 사용해야 합니다.

  Integer a = 1; 
  Integer b = 1; 
  a == b  => false

  2) 불변 -> 기존값을 변경할 수 없음.

3) String은 조금 특별한 래퍼클래스 == / equals 둘 다 사용가능

• 리터럴로 생성하는 경우(String a = "abcd") intern()함수가 호출되어 값이 Heap String pool에 저장됨. 이 경우 == 으로 비교가능
• new String("abcd")으로 생성하는 경우, Heap에 저장됨. 그러므로 new String("abcd") == "abcd"는 같지 않는 값으로 여겨짐.

참조 https://www.youtube.com/watch?v=eqltmFST-N8

래퍼클래스를 도대체 왜 써야하는데?

• 형 변환이 쉽다.
• null 비교가 용이하다(기본값이 null)

래퍼클래스와 꼭 함께 나오는 박스와 언박싱

• 박싱은 말그대로 기본형을 객체로 만드는 것
• 언박싱은 객체형을 기본형으로 만드는 것

래퍼클래스 - Call by Value

구현 코드 (HomeRoute)

import Hero from '../components/Hero';
import RepositoriesTable from '../components/repositories/RepositoriesTable';
import useRepositories from '../hooks/useRepositories';

function HomeRoute() {
  const { data: jsRepos } = useRepositories('stars:>10000 language:javascript');
  const { data: tsRepos } = useRepositories('stars:>10000 language:typescript');
  const { data: rustRepos } = useRepositories('stars:>10000 language:rust');
  const { data: goRepos } = useRepositories('stars:>10000 language:go');
  const { data: pythonRepos } = useRepositories('stars:>10000 language:python');
  const { data: javaRepos } = useRepositories('stars:>10000 language:java');

  return (
    <div>
      <Hero />
      <div className="container mx-auto py-8 grid grid-cols-1 gap-4 md:grid-cols-2">
        <RepositoriesTable
          label="Most Popular Javascript"
          repositories={jsRepos}
        />
        <RepositoriesTable
          label="Most Popular Typescript"
          repositories={tsRepos}
        />
        <RepositoriesTable label="Most Popular Rust" repositories={rustRepos} />
        <RepositoriesTable label="Most Popular Go" repositories={goRepos} />
        <RepositoriesTable
          label="Most Popular Python"
          repositories={pythonRepos}
        />
        <RepositoriesTable label="Most Popular Java" repositories={javaRepos} />
      </div>
    </div>
  );
}

export default HomeRoute;

구현 코드 (RepositoriesTable)

import { Link } from 'react-router-dom';
function RepositoriesTable({ label, repositories, id }) {
  const rendered =
    repositories &&
    repositories.map((repo, i) => {
      return (
        <div key={repo.id} className="p-0.5">
          <Link
            className="text-blue-500"
            to={`/repositories/${repo.full_name}`}
          >
            {repo.full_name}
          </Link>
        </div>
      );
    });
  return (
    <div className="border p-4 rounded">
      <h1 id={id || ''} className="text-lg font-bold border-b mb-1">
        {label}
      </h1>
      {rendered}
    </div>
  );
}
export default RepositoriesTable;

테스트 코드

import { setupServer } from 'msw/node';
import { rest } from 'msw';

export function createServer(handlerConfig) {
  const handlers = handlerConfig.map((config) => {
    return rest[config.method || 'get'](config.path, (req, res, ctx) => {
      return res(
        ctx.json(config.res(req, res, ctx)
        )
      );
    })
  });
  const server = setupServer(...handlers);

  beforeAll(() => {
    server.listen();
  });

  afterEach(() => {
    server.resetHandlers();  
  });

  afterAll(() => {
    server.close();
  });

}


import { render, screen } from '@testing-library/react';
import { setupServer } from 'msw/node';
import { rest} from 'msw';
import { MemoryRouter} from 'react-router-dom';
import HomeRoute from './HomeRoute'
import { createServer } from '../test/server';

// to make the handler test for multiple compenents ???  using createServer
createServer([
  {
    path: '/api/repositories',
    method: 'get', 
    res: (req) => { 
      const lauguage = req.url.searchParams.get('q').split("language:")[1];
      return {
        items: [
          { id:1, full_name: `${lauguage}_one`},
          { id:2, full_name: `${lauguage}_two` }
        ]
      }
    }
  }
]);

test('Renders two links for each language', async () => {

  render(
    <MemoryRouter> // homeroute에 link가 있어서 memoryrouter로 감싸준다
      <HomeRoute />
    </MemoryRouter>
  );

  // loop over each language
  const languages = ['javascript', 'typescript', 'rust', 'go', 'python', 'java'];

  for(let language of languages) {
    const links = await screen.findAllByRole('link', {
      name: new RegExp(`${language}_`)
    })
    expect(links).toHaveLength(2);
    expect(links[0]).toHaveTextContent(`${language}_one`)
    expect(links[1]).toHaveTextContent(`${language}_two`)
    expect(links[0]).toHaveAttribute('href', `/repositories/${language}_one`)
    expect(links[1]).toHaveAttribute('href', `/repositories/${language}_two`)
  }

});

Act Warning 해결하는 방법

• was not wrapped in act() 어쩌구 라는 경고가 떠도 굳이 act로 감쌀 필요가 없음. 방법 1이 가장 좋은 방법, 4가 가장 나쁜 방법임.

1) 데이터 fetching 후 findBy, findAllBy를 사용할 것

useEffect(() => {
    icons.getClass(name)
        .then((k) => setKlass(k))
        .catch(() => null);
}, [])

테스트 코드

test('', async () => {
    renderComponent();
    await screen.findByRole('img', { name: 'JavaScript'} );
 });

2) act 사용하여 해결

3) Jest.mock 사용 문제가 있는 부분이 FileIcon 렌더링 부분이라면, mock을 사용하여 문제가 되는 컴포넌트를 렌더링 하는걸 피할 것.

• 실제로 fileIcon을 import하는게 아니라, 가짜로 렌더링된 것 처럼 하는 것

  jest.mock('../tree/FileIcon', () => {
    return () => {
        return 'File Icon Component'
    };
  )}

  4) act + pause 사용 - 비추!

  아래는 자동으로 'act'를 호출함. act로 감쌀 필요가 사실 없음. screen.findBy screen.findAllby waitFor user.keyboard(async) user.click(async)

import { act } from '@testing-library/react'

test('', async () => {
    renderComponent();
    await act(async () => {
        await pause();
    });
 });

 const pause = () => new Promise(resolve => setTimeout(resolve, 100));

Data Fetching in Tests

1) 실제 네트워크로 요청하지 않음 - 느림 2) fake데이터로 테스트 할 것

• 테스트 하는 법 1) mock the file that contains the data fetching code. 2) 'Mock' axios를 위한 Library 사용 (msw library)

  rest.get('/api/repositories', (req, res, ctx) => {
  return res(
    ctx.json([
    ]),
  )
  })

참조 강의 - Udemy: React Testing Library and Jest: The Complete Guide https://www.udemy.com/course/react-testing-library-and-jest/learn/

Test 쉽게하기

screen.logTestingPlaygroundURL()

• testing-playground를 통해 테스트를 쉽게 도와준다

  npx rtl-book serve roles-notes.js

자주 사용하는 쿼리

• getByRole
• queryByRole
• findByRole

그렇다면 언제 어떻게 사용하는지?

• 요소가 있는지 확인할때는 getBy(1개), getAllBy(여러개)

  const element = screen.getByRole('listitem');
  expect(element).toBeInTheDocument();

• 요소가 없는지 확인할때는 queryBy, queryAllBy

  const element = screen.queryByRole('listitem');
  expect(element).not.toBeInTheDocument();

• 요소가 없는지 확인할때는 findBy, findAllBy 공식문서: Make sure an element eventually exists 무슨말이지? 라고 생각했는데 api를 통해 데이터를 가져오는 경우 사용하면 적합함

  function fakeFetchColors() {
  return Promise.resolve(
      ['red', 'green', 'blue']
  );
  }
  

function LoadColor() { const [colors, setColors] = useState([]);

useEffect(() => { fakeFetchColors().then(c=> setColors(c)); }, []);

const renderedColors = colors.map(color => { return

test('findBy or findAllBy when data fetching', async () => { render() // const els = screen.getAllByRole('listitem'); // 에러! fetch해서 데이터를 가져오는 경우엔 에러가 남. const els = screen.findAllByRole('listitem'); // 베리 굿!

expect(els).toHaveLength(3);

요소를 찾기 힘들 때 자주 사용하는 방식
>1. data-testid 
const rows = within(screen.getByTestId('users')).getAllByRole('row')
tr을 찾고 있음

>2. querySelector
const {container} = render(<userList users={users}/>);
const table = container.querySelector('table');
const rows = container.querySelectorAll('tbody tr');


예제
1) textbox에 값을 넣고 button을 클릭하는 경우

render(<UserForm onUserAdd={() => {}} /> const nameInput = screen.getByRole('textbox', {name: /name/i} ); const emailInput = screen.getByRole('textbox', {name: /email/i }); const button = screen.getByRole('button');

user.click(nameInput); user.keyboard('jane'); user.click(emailInput); user.keyboard('jane@jane.com'); user.click(button);

2) element가 여러개인 경우에는 aria-label or name을 사용하면 편함. ex. button 여러개

Email Search

//sign in //sign out

test('버튼들이 있는지 확인', () => { render( const signInButton = screen.getByRole('button', { name: /sign in/i // i는 대소문자 구별없이 찾기 위해 }); const signOutButton = screen.getByRole('button', { name: /sign out/i // i는 대소문자 구별없이 찾기 위해 }); expect(signInButton).toBeInTheDocument(); expect(signOutButton).toBeInTheDocument(); });

3) getby, queryby, findby 비교: 없는 요소(ex.textbox)를 찾고자 하면?
```// 통과되는 코드임
test('없는 요소 찾으려고 할때 테스트',  async () => 
{
  render(<colorList />)
  expect(() => screen.getByRole('textbox')).toThrow(); 
  expect(() => screen.queryByRole('textbox')).toEqual(null); 
  // 만약 textbox가 두개 이상있는데 위 처럼 써주면 throw error임. toThrow로 써줘야함
  let errorThrown = false;
  try {
      await screen.findByRole('textbox');  
  } catch(err) {
    errorThrown = true;
  }
  expect(errorThrown).toEqual(true);
});

4) getby, queryby, findby 비교: 있는 요소(ex.textbox)를 찾고자 하면?

test('있는 요소 찾으려고 할때 테스트',  async () => 
{
  render(<colorList />)
  expect(screen.getByRole('list')).toBeInTheDocument();
  expect(screen.queryByRole('list')).toBeInTheDocument();
  expect(await screen.findByRole('list')).toBeInTheDocument();
});

• findBy의 경우 async, await 사용하는 특징이 있음! 왜인지 모르는데 그냥 쓰자..

5) getAllBy, queryAllBy, findAllBy 비교

test('AllBy 테스트',  async () => 
{
  render(<colorList />)
  //listitem은 li를 의미하는 것
  expect(screen.getAllByRole('listitem')).toHaveLength(3); 
  expect(screen.queryAllByRole('list')).toHaveLength(3); 
  expect(await screen.findAllByRole('list')).toHaveLength(3); 
});

6) 다이나믹한 value 인 경우? RegExp사용하여 테스트

test('Displays information about the repository', () => {
  const repository = {
    language: 'Javascript',
    stargazers_count: 5,
    forks: 30,
    open_issues: 1
  }

  render(<RepositoriesSummary repository={repository} />);
  const language = screen.getByText('Javascript');
  const stars = screen.getByText(5);
  const forks = screen.getByText('30 Forks');
  const open_issues = screen.getByText('1 issues need help');
  expect(language).toBeInTheDocument();
  expect(stars).toBeInTheDocument();
  expect(forks).toBeInTheDocument();
  expect(open_issues).toBeInTheDocument();

  for (let key in repository) {
    const value = repository[key];
    const element = screen.getByText(new RegExp(value));
    expect(element).toBeInTheDocument();
  }

});

명령어 정리

• 깃 초기화 git init

• 소스 가져오기(local) git clone [깃 주소]

• 브랜치 생성(local) git branch [브랜치명]

• 브랜치 확인 git branch (local) git branch -r (remote) git branch -a (all)

• 브랜치 변경(local) git checkout [브랜치명]

• 브랜치 삭제(local) git branch -d [브랜치명]

• 브랜치 삭제(remote) git push origin -d 원격저장소의 브랜치가 삭제됨(주의)

• 모든 파일 스테이지 상태로 올리기(local) git add . (특정파일만 올리고 싶으면 . 대신 파일명 작성)

• commit (local) git commit -m '[commit message]'

• push git push origin [브랜치명] : remote [브랜치명]에 변경 내용을 반영한다는 의미

• 만약 remote repository가 업데이트 안되는경우 git fetch --prune

여러개의 로컬 브랜치와 여러개의 원격 브랜치가 있는 경우 로컬 브랜치 a, b / 원격 브랜치 a 만약 로컬 브랜치 b 에서 작업하고 원격 브랜치 a 에 올리고 싶다면?

1) git checkout a 2) git merge b (a에 b내용을 합침) 3) git push origin a (원격 a에 올림)

쉽게 말해 로컬에서 수정한 내용을 브랜치를 만들어 올리려면? 로컬에서 우선 해당 브랜치를 생성, 커밋을 하고 푸시하면 됨

회사에서 작업하는 방식 정리

1) git clone 2) git branch [브랜치명]
3) git checkout [브랜치명] -작업 작업 작업 작업 작업 4) git add. 5) git commit -m "message" 6) git checkout main -작업한 내용을 올리기 전에 최신버전을 받아와야 함 7) git pull origin main 8) git checkout [브랜치명] 최신화된 main branch merger(병합) 하기 9) git merge main -이 과정에서 conflict 발생 가능함 10) git push origin [브랜치명]

오류 정리

오류 1 hint: You have divergent branches and need to specify how to reconcile them. 해결 방안 git config --global pull.ff true

도커를 쓰는 이유?

빨리, 어디서든 사용할 수 있게 하는 컨테이너 왜? 과거 어플리케이션들은 한 컴퓨터안에서 운영. 한 서비스안에서 문제가 발생해도, 같은 OS를 공유하기에 다른 서비스에도 영향을 주기도 함 이 문제 때문에, OS를 독립적으로 사용하기 위한 '가상화'개념 등장 그러나, 각 서비스들의 독립성이 유지되긴하나 Os위에 또 다른 guest os가 설치되므로 무거움....
이 문제를 해결하기 위해 최소한의 환경요소만 묶어서 컨테이너를 만들어서 적은 용량만으로 운영가능하도록 한 기술을 사용하도록 함. 이것이 바로 도커!

1) 컨테이너 생성

docker run [option] image [command] [arg..] ex) docker run httpd -> httpd 기반(web server)으로 컨테이너 만들고 실행 ex) docker run --name ws2 httpd -> 또 다른 httpd기반 컨테이너 만드는데, 이름이 ws2임

2) 컨테이너 목록 출력

docker ps (실행중인 컨테이너만) docker ps -a (모든 컨테이너)

3) 컨테이너 실행/중지

docker start ws2 docker stop ws2

4) 컨테이너 로그

docker logs ws2 docker logs -f ws2 (실시간으로 출력하고 싶은 경우)

5) 컨테이너 삭제

docker rm ws2 (stop으로 중지하고 지워주어야함) docker rm --force ws2 (stop & delete)

6) 이미지 삭제

docker rmi ws2

Port forwarding docker run -p 8000:80 http (-p: short for publish) 호스트의 8000번 포트와 컨테이너의 80번 포트가 연결

컨테이너 내부 실행

docker exec [options] container command [arg...] docker exec -it ws3 pwd /bin/sh docker exec -it ws3 pwd /bin/bash

• 컨테이너 내 sh(또는 bash) 실행
• -it는 옵션인데 이걸 써줘야 지속적으로 실행이 된다고 보면 됨 (i:interactive, t:tty)

호스트와 컨테이너의 파일시스템 연결

이렇게 내 컴퓨터의 index.html과 container 내부와 index.html이 동기화(?) 된다면 container이 사라져도 문제 없음 docker run -p:8888:80 -v ~/Desktop/htdocs:/usr/local/apache2/htdocs/ httpd (-v: volume, 내 컴퓨터의 /Desktop/htdocs와 /usr/local/apache2/htdocs 연결했다는 뜻, 즉 내 컴퓨터의 htdocs의 index.html파일을 변경해도 container의 index.html이 변경되어 반영됨)

출처: 생활코딩 docker 입문수업