I am an amazing person.

7 minute read

목표

자바가 제공하는 제어문을 학습하세요.

학습할 것 (필수)

선택문

자바에는 선택 논리를 위한 선택문으로 if문과 switch문을 제공하고 있다.

  • if

  1. 단순 if

     if(조건식){  
     조건식이 true 이면 실행 될 부분;   
 }	

     int i = 0;
 if(i == 0)	// 한 줄일 경우 {}는 생략 가능
     System.out.println("i is zero");
		
 if(i == 0){	// 두 줄 이상일 경우 {} 로 묶어준다.
     System.out.println("i is zero");
     i++;
 }
    결과 
     i is zero
 i is zero

  2. 이중 if-else

     if(조건식){  
     조건식이 true 이면 실행 될 부분;   
 } else {  
     조건식이 false 이면 실행 될 부분;   
 }

     int a = 10;
 int odd = a % 2;
 if(odd == 0){
     System.out.println("a is even");
 } else {
     System.out.println("a is odd");
 }
    결과 
     a is even

  3. 다중 if-else if

     if(조건식1){  
     조건식1이 true 이면 실행 될 부분;   
 } else if(조건식2) {  
     조건식2이 true 이면 실행 될 부분;   
 } else {  
     조건식1과 조건식2 모두 false 일 경우 실행 될 부분;  
 }

     int grade = 98;
 if(grade >= 90){
     System.out.println("A");
 } else if(grade >= 80){
     System.out.println("B");
 } else if(grade >= 70){
     System.out.println("C");
 } else {
     System.out.println("D");
 }
    결과 
     A

  • switch

      switch(구분 기준값){
      case 판단 값:
          true일 때 실행 될 부분;
          break;
      case 판단 값:
          true일 때 실행 될 부분;
          break;
      ...
      default:
          아무 조건에 해당되지 않을 때 실행 될 부분;	
          break;
  }

      int grade = 98;
  switch(grade / 10){
      case 10:
      case 9:
          System.out.println("A");
          break;
      case 8:
          System.out.println("B");
          break;
      case 7:
          System.out.println("C");
          break;
      default:
          System.out.println("D");
          break;
  }
    결과 
      A

반복문

자바에는 반복 논리를 제공하기 위해 while, do-while, for문을 제공하고 있다. 모든 반복문들은 조건식이 만족하는 동안 지정된 부분을 반복 수행한다.

  • while
    조건식을 먼저 검사하는 반복문

      while(조건식) {
      조건식이 true 일 때 반복될 문장들;
      ...
      조건식이 true 일 때 반복될 문장들;
  }

      int a = 1, b = 2;
  while(a > b)
      System.out.println("a > b 는 false 이므로, 이 문장은 실행되지 않는다.");
	
  // 1부터 10까지의 합
  int sum = 0, cnt = 1;
  while(cnt <= 10){
      sum = sum + cnt;
      cnt = cnt + 1;
  }
  System.out.println("1부터 10까지의 합은 "+sum+"입니다.");
    결과 
      1부터 10까지의 합은 55입니다.

  • do-while
    while문과 달리 조건을 나중에 검사하는 반복문
    반복될 문장이 최소 한번은 실행된다.

      do {
      조건식이 true 일 때 반복될 문장들;	// 최소 한번은 실행 됨
      ...
  } while(조건식);

      int a = 1, b = 2;
  do {
      System.out.println("a > b 는 false 이나, 조건식이 나중에 검사하므로 한번 실행 된다.");
  } while(a > b);

  int sum = 0, cnt = 1;
  do{
      sum = sum + cnt;
      cnt = cnt + 1;
  } while(cnt <= 10);
  System.out.println("1부터 10까지의 합은 "+sum+"입니다.");
    결과 
      a > b 는 false 이나, 조건식이 나중에 검사하므로 한번 실행 된다.
  1부터 10까지의 합은 55입니다.

  • for
    지정된 횟수만큼 반복 수행하는 반복문
    초기식, 조건식, 증감식으로 구성된다.

      // 초기식: 주로 반복 변수의 초기화를 위해 사용. 처음 한 번만 수행
  // 조건식: 조건을 나타내며, 조건식이 참일 동안 반복 부분 수행
  // 증감식: 반복 부분을 수행한 후에 반드시 수행되는 문장. 주로 조건식에 변화를 주는 수식으로 구성
  for(초기식;조건식;증감식){
      조건식이 true 일 때 반복될 문장들;
  }

      int i, sum = 0;
  for(i = 1; i <= 10; i++){
      sum = sum + i;
  }
  System.out.println("1부터 10까지의 합은 "+sum+"입니다.");
    결과 
      1부터 10까지의 합은 55입니다.

  • for each
    동일한 for문을 사용하지만 조건식 부분이 다른 반복문

      for(타입 변수 : 루프를 돌릴 객체){ // 배열이나 컬렉션
      조건식이 true 일 때 반복될 문장들;
  }

      int[] arr = {1, 2, 3};
  for(int i = 0; i < arr.length; i++){
      System.out.println(arr[i]);
  }

  for(int i : arr){
      System.out.println(i);
  }
    결과 
      1
  2
  3
  1
  2
  3

제어의 이동

  • break

  1. break
    switch문이나 반복문을 벗어나는데 사용
    switch문이나 반복문 내에서 break문이 수행되면 실행을 중단하고 switch문이나 반복문을 벗어나 다음의 첫 문장으로 제어가 이동된다.

     int sum = 0, i = 0;
 while(true){
     if(10 < i) break;
     sum = sum + i;
     i++;
 }
 System.out.println("1부터 10까지의 합은 "+sum+"입니다.");
    결과 
     1부터 10까지의 합은 55입니다.

  2. break label
    break와 label을 이용하여 제어를 이동시킬 수 있다.

     // 구구단 출력
 int i = 2, j;
 Loop : while(true){
     j = 1;
     InnerLoop : while(true){
         if(j > 9)   break;	// j가 9보다 크면 InnerLoop를 벗어난다.
         if(i > 9)   break Loop;	// i가 9보다 크면 Loop를 벗어난다.
         System.out.println(i + " * " + j + " = " + i*j);
         j++;
     }
     System.out.println();
     i++;
 }
    결과 
     2 * 1 = 2
 2 * 2 = 4
 2 * 3 = 6
 2 * 4 = 8
 2 * 5 = 10
 2 * 6 = 12
 2 * 7 = 14
 2 * 8 = 16
 2 * 9 = 18

 3 * 1 = 3
 3 * 2 = 6
 3 * 3 = 9
 3 * 4 = 12
 3 * 5 = 15
 3 * 6 = 18
 3 * 7 = 21
 3 * 8 = 24
 3 * 9 = 27

 4 * 1 = 4
 4 * 2 = 8
 4 * 3 = 12
 4 * 4 = 16
 4 * 5 = 20
 4 * 6 = 24
 4 * 7 = 28
 4 * 8 = 32
 4 * 9 = 36

 5 * 1 = 5
 5 * 2 = 10
 5 * 3 = 15
 5 * 4 = 20
 5 * 5 = 25
 5 * 6 = 30
 5 * 7 = 35
 5 * 8 = 40
 5 * 9 = 45

 6 * 1 = 6
 6 * 2 = 12
 6 * 3 = 18
 6 * 4 = 24
 6 * 5 = 30
 6 * 6 = 36
 6 * 7 = 42
 6 * 8 = 48
 6 * 9 = 54

 7 * 1 = 7
 7 * 2 = 14
 7 * 3 = 21
 7 * 4 = 28
 7 * 5 = 35
 7 * 6 = 42
 7 * 7 = 49
 7 * 8 = 56
 7 * 9 = 63

 8 * 1 = 8
 8 * 2 = 16
 8 * 3 = 24
 8 * 4 = 32
 8 * 5 = 40
 8 * 6 = 48
 8 * 7 = 56
 8 * 8 = 64
 8 * 9 = 72

 9 * 1 = 9
 9 * 2 = 18
 9 * 3 = 27
 9 * 4 = 36
 9 * 5 = 45
 9 * 6 = 54
 9 * 7 = 63
 9 * 8 = 72
 9 * 9 = 81

  • continue
    반복문의 특정 지점에서 제어를 반복문의 처음으로 보내기 위해 continue를 쓴다.

      int sum = 0, i;
  for(i = 1; i <= 10; i++){
      if(i % 2 == 1)  continue;   // 홀수인 경우 증감부분으로 이동한다.
      sum = sum + i;
  }
  System.out.println("1부터 10까지의 짝수의 합은 "+sum+"입니다.");
    결과 
      1부터 10까지의 짝수의 합은 30입니다.

과제 (옵션)

과제 0. JUnit 5 학습하세요.

  • 인텔리J, 이클립스, VS Code에서 JUnit 5로 테스트 코드 작성하는 방법에 익숙해 질 것.
  • 이미 JUnit 알고 계신분들은 다른 것 아무거나!
  • 더 자바, 테스트 강의도 있으니 참고하세요~

더 자바, 테스트 강의 정리

  • JUnit이란? 자바 프로그래밍 언어용 유닛 테스트 프레임워크

    Spring Boot 2.2 이후 버전은 기본으로 JUnit 5 의존성이 추가 된다. maven dependencies에서 .junit.jupiter 가 있으면 JUnit5가 정상 추가 됨을 확인 할 수 있다.

    아래의 dependency 추가 시, JUnit5를 사용할 수 있다.

      <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-engine</artifactId>
      <version>5.5.2</version>
      <scope>test</scope>
  </dependency>

    JUnit5부터는 클래스나 테스트 메서드가 자바의 리플렉션을 사용해 private하거나 default한 메소드에 접근 및 실행이 가능해져 public일 필요가 없어졌다.

  • 기본 애노테이션

    • @Test main 메소드처럼 IDE에서 직접 실행 가능
    • @BeforeAll / @AfterAll 클래스의 모든 메소드 실행 시, 시작 전/끝난 후 실행
    • @BeforeEach / @AfterEach 테스트 메소드 실행 시, 시작 전/끝난 후 실행
    • @Disabled 테스트를 실행하지 않음
      package me.ysmiler.inflearnthejavatest;

  import org.junit.jupiter.api.*;
  import static org.junit.jupiter.api.Assertions.*;

  class StudyTest {
      @Test
      void create(){
          Study study = new Study();
          assertNotNull(study);
          System.out.println("create");
      }

      @Test
      void create1(){
          System.out.println("create1");
      }

      @BeforeAll
      static void beforeAll(){
          System.out.println("before all");
      }

      @AfterAll
      static void afterAll(){
          System.out.println("after all");
      }

      @BeforeEach
      void beforeEach(){
          System.out.println("before each");
      }

      @AfterEach
      void afterEach(){
          System.out.println("after each");
      }
  }
    결과 
      before all

  before each
  create
  after each


  before each
  create1
  after each

  after all
## 과제 (옵션)

과제 1. live-study 대시 보드를 만드는 코드를 작성하세요.

  • 깃헙 이슈 1번부터 18번까지 댓글을 순회하며 댓글을 남긴 사용자를 체크 할 것.
  • 참여율을 계산하세요. 총 18회에 중에 몇 %를 참여했는지 소숫점 두자리가지 보여줄 것.
  • Github 자바 라이브러리를 사용하면 편리합니다.
  • 깃헙 API를 익명으로 호출하는데 제한이 있기 때문에 본인의 깃헙 프로젝트에 이슈를 만들고 테스트를 하시면 더 자주 테스트할 수 있습니다.

과제 2. LinkedList를 구현하세요.

  • LinkedList에 대해 공부하세요.
  • 정수를 저장하는 ListNode 클래스를 구현하세요.
  • ListNode add(ListNode head, ListNode nodeToAdd, int position)를 구현하세요.
  • ListNode remove(ListNode head, int positionToRemove)를 구현하세요.
  • boolean contains(ListNode head, ListNode nodeTocheck)를 구현하세요.

과제 3. Stack을 구현하세요.

  • int 배열을 사용해서 정수를 저장하는 Stack을 구현하세요.
  • void push(int data)를 구현하세요.
  • int pop()을 구현하세요.

과제 4. 앞서 만든 ListNode를 사용해서 Stack을 구현하세요.

  • ListNode head를 가지고 있는 ListNodeStack 클래스를 구현하세요.
  • void push(int data)를 구현하세요.
  • int pop()을 구현하세요.

과제 5. Queue를 구현하세요.

  • 배열을 사용해서 한번
  • ListNode를 사용해서 한번.

JUnit 참고 - 더 자바, 애플리케이션을 테스트하는 다양한 방법 live-study with whiteship

You May Also Enjoy