국비 지원 개발자 과정_Day6

괄호()가 붙는 경우 3가지-메소드, 생성자, 캐스팅연산자

메소드-이름 뒤 ()

 

생성자-클래스명 뒤 ()

디폴트생성자(파라미터가 없는 생성자) / 파라미터가 있는 생성자(같은 이름의 생성자가 여러개 올 수 있다)

생성자는 전역변수의 초기화를 담당한다

 

캐스팅연산자-(b자료형)a자료형

 

Wrpper클래스

원시형에는 변수와 메소드를 소유할 수 없으니까 원시형에 대응하는 클래스가 필요하다 → Wrapper클래스 사용

 

&와 &&(|와 ||) 차이

&*(||)은 앞의 결과가 false(true)면 뒷부분 연산을 하지 않고 바로 결과를 냄

package dev_java.ch02;

public class P21 {
  int i = 1;
  int j = 0;

  void methodA() {
    j = ++i;
    System.out.println("methodA j: " + j); // 2
    j = i++;
    System.out.println("methodA j: " + j); // 2
    System.out.println("methodA i: " + i); // 3
  }

  void methodB() {
    j = --i;
    System.out.println("methodB j: " + j); // 2
    j = i--;
    System.out.println("methodB j: " + j); // 2
    System.out.println("methodB i: " + i); // 1
  }

  void methodC(int i, int j) { // call by value, 지변의 값은 호출될 때 결정됨
    j = i++;
    System.out.println("methodC j: " + j);
    System.out.println("methodC i: " + i);
  }

  void methodD(int i, int j) {
    j *= i;
    System.out.println("methodD j: " + j);
    System.out.println("methodD i: " + i);
  }

  public static void main(String[] args) {
    P21 p21 = new P21();
    p21.methodA();
    p21.methodB();
    p21.methodC(1, 3); //1, 2
    p21.methodD(1, 3); //3, 1
  }
}

 

package dev_java.ch02;

public class P21_1 {
  public static void main(String[] args) {
    int i = 1;
    
    switch (i) {
      case 0:
        ++i; // 실행문
      case 1:
        ++i;
        // break; //2, break가 있다면 연산 후 switch문을 빠져나감
      default: // case의 조건이 맞지 않을 경우 디폴트값이 실행됨
        ++i; // 3, break가 없다면 전부 연산, 디폴트엔 break 생략 가능
    } // end of switch

    // insert here-i는 얼마일까요?
    System.out.println(i);// 3, break문이 없어서 빠져나가지 않고 전부 실행됨!
  }
}

 

package dev_java.ch02;

public class P21_2 {
  public static void main(String[] args) {
    int i = 1;
    int j = 2;
    // &가 하나올 땐 첫 조건이 false여도 뒤의 조건을 본다(비효율적)
    // if ((i == --j) & (++i <= j)) {

    // &&가 두개올 땐 첫 조건이 false이면 뒤의 조건은 보지 않는다. (둘 다 true일때 true)
    if ((i == --j) && (++i <= j)) { // 1 == 1(true) && 2 <= 1(false)
      System.out.println("조건을 만족했습니다.");
    } else {
      System.out.println("조건을 만족하지 못했습니다.");
    }
    
    // insert here-i의 값은? j의 값은?
    System.out.println("i: " + i + ", j: " + j);
  }
}

// 조건을 만족하지 못했습니다.
// i: 2, j: 1

 

package dev_java.ch02;

public class P21_3 {
  public static void main(String[] args) {
    int i = 1;
    int j = 2;

    if ((i != --j) && (++i <= j)) { // 1 != 1(false) && 뒤의 조건은 보지 않음!
      System.out.println("조건을 만족했습니다.");
    } else {
      System.out.println("조건을 만족하지 못했습니다.");
    }
    // insert here-i의 값은? j의 값은?
    System.out.println("i: " + i + ", j: " + j);
  }
}

// 조건을 만족하지 못했습니다.
// i: 1, j: 1

 

package dev_java.ch02;

public class P21_4 {
  public static void main(String[] args) {
    int i = 1;
    int j = 2;
    // |가 하나올 땐 첫 조건이 true여도 뒤의 조건을 본다(비효율적)
    // if ((i == --j) | (++i <= j)) {

    // ||가 두개올 땐 첫 조건이 true이면 뒤의 조건은 보지 않는다.(하나라도 true면 true)
    if ((i == --j) || (++i <= j)) { // 1 == 1(true) || 뒤의 조건은 보지 않음!
      System.out.println("조건을 만족했습니다.");
    } else {
      System.out.println("조건을 만족하지 못했습니다.");
    }
    
    // insert here-i의 값은? j의 값은?
    System.out.println("i: " + i + ", j: " + j);
  }
}

// 조건을 만족했습니다.
// i: 1, j: 1

 

package dev_java.ch02;

public class P21_5 {
  public static void main(String[] args) {
    int i = 1;
    int j = 2;
    
    // |가 하나올 땐 첫 조건이 true여도 뒤의 조건을 본다
    if ((i == --j) | (++i <= j)) { // 1 == 1(true) || 2 <= 1(false)
      System.out.println("조건을 만족했습니다.");
    } else {
      System.out.println("조건을 만족하지 못했습니다.");
    }
    
    // insert here-i의 값은? j의 값은?
    System.out.println("i: " + i + ", j: " + j);
  }
}

// 조건을 만족했습니다.
// i: 2, j: 1

 

에러

문법에러(컴파일에러)

실행에러(런타임에러)

 

&&(AND, 논리곱)

피연산자가 모두 true일때만 true

 

||(OR, 논리합)

피연산자 중 하나라도 true면 true

 

&, &&의 공통점

두 조건이 모두 참(true)일때만 실행문이 실행된다.

True True = True

False True = False

True False = False

False False = False

 

&과 &&의 차이점

&은 앞 조건이 거짓(false)이더라도 뒤의 조건을 따진다.

&&은 앞의 조건이 거짓(false)인 경우 판정이 가능하므로, 굳이 뒤의 조건을 따지지 않는다(효율적)

 

반복문 종류

while, for, do-while

while은 조건 안 맞으면 실행x

do-while은 무조건 1번 실행된 후 조건식 판정(조건식이 뒤에 있으니까)

 

for문 안에서 선언된 변수는 for문 안에서만 사용이 가능하다.

package dev_java.ch02;

public class For1 {
  public static void main(String[] args) {
    for (int i = 1; i <= 3; i++) { // for문 안에서 선언한 i는 밖에서 사용 불가!
      System.out.println(i);
    } // end of for
    System.out.println();

    int i = 0;
    while (i <= 3) {
      System.out.println(i);
      // while문 사용시에는 조건식에 사용된 변수의 증감연산자가 있는지 반드시 확인할것!
      i++; // 증감연산자가 없으면 무한루프에 빠지니 주의!
    }
  }
}

// 1
// 2
// 3

// 0
// 1
// 2
// 3

 

package dev_java.ch02;

// 문제 1: 1부터 10까지의 합을 구하는 프로그램을 작성하시오.
public class Quiz1 {
  // 1씩 세는 변수 i, 합을 담을 변수 count 선언 및 초기화
  int i = 1; // 전역변수
  int count; // 초기화 생략, 디폴트값 0

  void methodA() { // for문
    for (; i <= 10; i++) { // 초기화(위의 전역변수가 있기에 생략함); 조건식; 증감연산자
      count += i;
    }
    System.out.println("count: " + count); //결과 55
    System.out.println();
  }

  void methodB() { // while문
    i = 1; // 다른 메소드의 영향 없애기위해 초기화
    count = 0; // 초기화
    while (i <= 10) {
      count += i;
      i++;
    }
    System.out.println("count: " + count); //결과 55
  }

  public static void main(String[] args) {
    Quiz1 quiz1 = new Quiz1();
    quiz1.methodA(); // 55
    quiz1.methodB(); // 55
  }
}

 

package dev_java.ch02;

// 문제 2: 1부터 10까지 세면서 짝수의 합을 구하는 프로그램을 작성하시오.
public class Quiz2 {
  int i = 1;
  int count;

  void methodA() { // for문
    for (; i <= 10; i++) {
      if (i % 2 == 0) { // 짝수일 경우
        count += i;
      }
    }
    System.out.printf("count: %d, i: %d %n", count, i); // 결과 30, i 11
    System.out.println();
  }

  void methodB() { // while문
    i = 1; // 초기화
    count = 0; // 초기화
    while (i <= 10) {
      if (i % 2 == 0) {
        count += i;
      }
      i++;
    }
    System.out.println(count); // 결과 30
  }

  public static void main(String[] args) {
    Quiz2 quiz2 = new Quiz2();
    quiz2.methodA(); // 30
    quiz2.methodB(); // 30
  }
}

 

package dev_java.ch02;

import java.util.Scanner;

// 문제 2_1: 사용자의 입력값까지의 짝수의 합을 더하는 코드, for문
public class Quiz2_1 {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    System.out.println("입력한 숫자까지의 짝수의 합을 계산합니다.");
    int user_end = scanner.nextInt(); // 바로 int로 받아줌
    int i = 1;
    int count = 0;

    for (; i <= user_end; i++) {
      if (i % 2 == 0) { // 짝수일 경우
        count += i;
      }
    }
    System.out.printf("count: %d, i: %d %n", count, i); //printf형식, 정수d
    scanner.close();
  }
}

// 10을 입력할 경우
// 입력한 숫자까지의 짝수의 합을 계산합니다.
// 10
// count: 30, i: 11

 

package dev_java.ch02;

import java.util.Scanner;

// 문제 2_2: 사용자의 입력값까지의 짝수의 합을 더하는 코드, while
public class Quiz2_2 {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    System.out.println("입력한 숫자까지의 짝수의 합을 계산합니다.");
    int user_end = scanner.nextInt(); // 바로 int로 받아줌
    int i = 1;
    int count = 0;

    while (i <= user_end) {
      if (i % 2 == 0) { // 짝수일 경우
        count += i;
      }
      i++;
    }
    System.out.printf("count: %d, i: %d %n", count, i);
    scanner.close();
  }
}

// 10을 입력할 경우
// 입력한 숫자까지의 짝수의 합을 계산합니다.
// 10
// count: 30, i: 11

 

package dev_java.ch02;

// 문제 3: 1부터 100까지 세면서 5의 배수이면 fizz를 출력하고
// 7의 배수이면 buzz를 출력하고
// 5와 7의 공배수이면 fizzbuzz를 출력하고
// 나머지는 숫자를 출력하는 프로그램을 작성하시오.
public class Quiz3 {
  void methodA() { // if문 사용
    System.out.println("=====methodA=====");
    for (int i = 1; i <= 100; i++) {
      if (i % 5 == 0 && i % 7 == 0) { // 순서가 중요, 5와 7의 공배수가 먼저 나와야함
        System.out.println("fizzbuzz");
      } else if (i % 5 == 0) { // if는 위의 조건이 맞아도 다시 조건을 봄
        System.out.println("fizz");
      } else if (i % 7 == 0) { // else if는 위의 조건이 맞지 않았다면 조건을 따져봄
        System.out.println("buzz");
      } else {
        System.out.println(i);
      }
    }
  }

  void methodB() { // switch문 사용, if문에비해 비효율적
    System.out.println("=====methodB=====");
    for (int i = 1; i <= 100; i++) {
      switch (i % 35) {
        case 0:
          System.out.println("fizzbuzz");
          break;
        case 5:
        case 10:
        case 15:
        case 20:
        case 25:
        case 30:
          System.out.println("fizz");
          break;
        case 7:
        case 14:
        case 21:
        case 28:
          System.out.println("buzz");
          break;
        default:
          System.out.println(i);
      } // end of switch
    } // end of for
  } // end of methodB

  public static void main(String[] args) {
    Quiz3 quiz3 = new Quiz3();
    quiz3.methodA(); // for문 사용
    quiz3.methodB(); // switch문 사용
  }
}

// 1 2 3 4 fizz 6 buzz 8 9 fizz
// 11 12 13 buzz fizz 16 17 18 19 fizz
// buzz 22 23 24 fizz 26 27 buzz 29 fizz
// 31 32 33 34 fizzbuzz 36 37 38 39 fizz
// 41 buzz 43 44 fizz 46 47 48 buzz fizz
// 51 52 53 54 fizz buzz 57 58 59 fizz
// 61 62 buzz 64 fizz 66 67 68 69 fizzbuzz
// 71 72 73 74 fizz 76 buzz 78 79 fizz
// 81 82 83 buzz fizz 86 87 88 89 fizz
// buzz 92 93 94 fizz 96 97 buzz 99 fizz

 

package dev_java.ch02;

// 문제 4: 구구단 2~9단 출력
public class Quiz4 {
  int i;
  int dan;

  void methodA() {
    for (dan = 2; dan < 10; dan++) {
      for (i = 1; i < 10; i++) {
        System.out.println(dan + " x " + i + " = " + dan * i);
      }
    }
  }

  public static void main(String[] args) {
    Quiz4 quiz4 = new Quiz4();
    quiz4.methodA();
  }
}

// 2 x 1 = 2
// 2 x 2 = 4
// 2 x 3 = 6
// 2 x 4 = 8
// 2 x 5 = 10
// 2 x 6 = 12
// 2 x 7 = 14
// 2 x 8 = 16
// 2 x 9 = 18
// .
// .
// .
// 9 x 1 = 9
// 9 x 2 = 18
// 9 x 3 = 27
// 9 x 4 = 36
// 9 x 5 = 45
// 9 x 6 = 54
// 9 x 7 = 63
// 9 x 8 = 72
// 9 x 9 = 81

 

 

call by value

호출하는 곳에서 초기화(값을 넘겨줌)

메소드를 호출하는 호출자의 변수와 호출당하는 수신자의 파라미터는 복사된 서로 다른 변수

값만 전달하기에 수신자의 파라미터를 수정해도 호출자의 변수에 영향 없음

 

call by reference

참조 주소를 직접 전달

주소를 직접 넘기기에 호출자의 변수와 수신자의 파라미터는 완전히 동일한 변수

메서드내에서 파라미터를 수정하면 그대로 원본 변수에도 반영됨

 

this는 파라미터 안의 지변과 해당 클래스의 전역변수를 구별하기 위한 것(this.i는 전역변수 i)

 

중복선언(오버로딩)

파라미터의 개수 혹은 타입이 달라야함(이름은 상관없음)

 

생성자(Constructor)

메소드와 유사하게 클래스 내에 선언되지만 리턴값이 없다(void도 적지 않는다)

생성자의 이름은 반드시 클래스의 이름과 같아야한다.

생성자를 만들지 않으면 디폴트 생성자(파라미터가 없는 기본 생성자)가 생긴다.

생성자는 오버로딩이 가능하므로 매개변수(파라미터) 타입과 개수를 다르게하여 여러 개의 생성자를 만들 수 있다.

생성자는 인스턴스 생성에 필요한 초기화 명령을 실행하기위해 사용한다.

생성자는 전역변수(멤버변수)의 초기화를 담당한다

package dev_java.ch02;

public class MemberInit {
  int i;
  int hap;

  // 디폴트 생성자라고 부른다-디폴트 생성자는 파라미터를 결정해줄 필요 없으니
  // 생략하면 JVM이 대신 생성해줘 전역변수들을 초기화시킴
  public MemberInit() {
    System.out.println("디폴트 생성자 호출 성공 " + i + ", " + hap); // 전역변수 i와 hap
  }

  public MemberInit(int i, int hap) {
    this.i = i;
    this.hap = hap;
    System.out.println("파라미터가 두 개인 생성자 호출 성공 " + this.i + ", " + this.hap); // 전역변수 i와 hap
  }

  public static void main(String[] args) {
    MemberInit m1 = new MemberInit(); // 9번 생성자 호출(메소드 오버로딩 메카니즘에 따른다)
    MemberInit m2 = new MemberInit(1, 0); // 13번 생성자 호출
  }
}

// 디폴트 생성자 호출 성공 0, 0
// 파라미터가 두 개인 생성자 호출 성공 1, 0

 

package dev_java.ch02;

import java.util.Random;
import java.util.Scanner;

// 문제5: 0부터 9사이의 임의의 수를 채번하고 그 숫자를 맞추는 게임을 구현하시오(기회는 5번)
// 힌트는 낮춰라, 높여라, 맞으면 축하합니다
public class Nansu1 {
  public static void main(String[] args) {
    Random random = new Random();
    Scanner scanner = new Scanner(System.in);
    int com = random.nextInt(10); // int 0~9
    int i = 0;
    System.out.println("0부터 9사이의 정수를 입력하세요. 종료하려면 10을 입력하세요.");

    while (i < 5) { //기회는 5번
      int user = scanner.nextInt();
      if (user == 10) {
        System.out.println("종료합니다.");
        System.exit(0);
      } else if (user == com) {
        System.out.println("축하합니다! 정답은 " + com + "입니다!");
        break;
      } else if (user < com) { // 정답이 입력값보다 클 때
        i++;
        System.out.println("더 높은 값입니다. 남은 시도 횟수: " + (5 - i));
      } else if (user > com) {
        i++;
        System.out.println("더 낮은 값입니다. 남은 시도 횟수: " + (5 - i));
      }
    }
    scanner.close();
  }
}

 

package dev_java.ch02;

import java.util.Random;
import java.util.Scanner;

// 문제5_1: 0부터 9사이의 임의의 수를 채번하고 그 숫자를 맞추는 게임을 구현하시오(기회는 5번)
// 힌트는 낮춰라, 높여라, 맞으면 축하합니다 -> 메인과 메소드 분리
public class Nansu2 {
  Random random = new Random();
  Scanner scanner = new Scanner(System.in);
  int com = random.nextInt(10); // int 0~9

  void methodA() {
    System.out.println("0부터 9사이의 정수를 입력하세요. 종료하려면 10을 입력하세요.");
    int i = 0;
    while (i < 5) {
      int user = scanner.nextInt();
      if (user == 10) {
        System.out.println("종료합니다.");
        System.exit(0);
      } else if (user == com) {
        System.out.println("축하합니다! 정답은 " + com + "입니다!");
        break;
      } else if (user < com) { // 정답이 입력값보다 클 때
        i++;
        System.out.println("더 높은 값입니다. 남은 시도 횟수: " + (5 - i));
      } else if (user > com) {
        i++;
        System.out.println("더 낮은 값입니다. 남은 시도 횟수: " + (5 - i));
      }
    }
    scanner.close();
  }

  public static void main(String[] args) {
    Nansu2 n2 = new Nansu2();
    n2.methodA();
  }
}