[Java] 명품 Java Programming 정리 - 2장

근이의 개발일기·2024년 8월 19일
Java
0

Java (2-1 객체지향프로그래밍 최지웅교수님)

목록 보기
3/9
post-thumbnail

자바프로그램의 기본 구조 예시

public class Hello { // **클래스**; public 선언하면 다른 클래스에서 접근 가능
	public static int sum(int n, int m){ // **메소드**: 클래스 내부에 정의된 함수
		return n+m;
	} //-> Java는 클래스 밖에 함수를 정의하지 못함
	
	public static void main(Stirng[] args){ // main 메소드에서 실행 시작 
	// ->String[] args로 실행 인자를 전달 받음
		int i = 20;
		int s;
		char a;
		
		s=sum(i,10);
		a-'?'
		//표준 출력 스트림 System.out의 println() 메소드 호출
		System.out.println(a); 
		System.out.println("Hello);
		System.out.println(s);
	} 
}

중요 식별자

  • 특수문자, 공백, 탭은 식별자로 사용 x
  • 주의! '_'나 '$'는 사용가능
  • 유니코드 문자 사용가능 한글 사용 가능
  • 자바의 키워드는 식별자로 x
  • 식별자의 첫번째 문자로 숫자는 사용 x
  • *true, false, null*은 식별자로 사용불가
  • 길이제한 없음
  • 대소문자를 구별함

이름규칙

  • 클래스 대문자로 시작
    이후 단어 첫번재 대문자
  • 변수메소드
    첫단어 동사로 소문자 시작
    이후 단어 첫번재 대문자
  • 상수이름
    모든문자 대문자표시

중요 자바의 데이터타입

  • primitive type 8개

    • 정수타입:
      byte: 8 비트 또는 1 바이트
      short: 16 비트 또는 2 바이트
      int: 32 비트 또는 4 바이트
      long: 64 비트 또는 8 바이트
    • 실수타입:
      float: 32 비트 또는 4 바이트
      double: 64 비트 또는 8 바이트
    • 문자타입:
      주의! char: 16 비트 또는 2 바이트 ++c → 증가한 문자 반환 / +c → 비트의 정수 반환
    • 논리타입:
      boolean: 크기가 정의되지 않음 1비트가 아닐수 있음 (주의! bool이 아니라 boolean으로 정의)
      주의! unsigned 키워드를 쓰지않고 toUnsignedString을 사용함

  • Reference type <- All of not primitive type
    -     배열에 대한 레퍼런스

  • 클래스에 대한 레퍼런스

  • 인터페이스에 대한 레퍼런스

  • 원시타입과 레퍼런스 타입은 문법이 다르게 동작함
    -> 분류 기준이 됨

  • 문자열이 섞인 연산 -> 문자열 연결
    ex) String toolName="JDE"
    toolName + 1.8 -> "JDE1.8"
    "("+3+","+5+")" → “(3,5)”

  • 주의! 3+5+”:” → ”8:” / “2+5는 “+2+5 → “2+5는 25” / “2+5는 “ +(2+5) →”2+5는 7”

  • 주의! arr[i][j]+’\t’ → 탭의 unicode 값을 더해주게 됨. 문자열만 된다는 것!!

+의 우선순위는 왼쪽에서 오른쪽인데, 문자열을 +와 함께 만나기 전까지는 일반임

반대로 문자열과 +를 먼저 만난다면 괄호 없이는 연산이 되지 않고 문자열로써 기능한다. 괄호를 쳐주어서 먼저 계산하도록 한다.

  • 리터럴: 프로그램에서 직접 표현한 값
    정수 실수 문자 논리 문자열 리터럴
    ex) 34, 42.195, '&', true, "hello"
    • 정수 리터럴
      10진수, 8진수, 16진수, 2진수 리터럴
      0으로 시작 8진수
      0x로 시작 16진수
      0b로 시작 2진수
      정수 리터럴은 int형으로 컴파일하는데
      long 타입 리터럴은 L이나 l을 붙여서 표시함
    • 실수 리터럴
      E-4 = 10^(-4)를 의미
      숫자뒤에 f나 d를 명시적으로 붙이기도 함
      실수 리터럴은 double형으로 컴파일 하는데
      float타입 리터럴은 f를 붙여서 표시함

주의! 그냥 float f = 3.14; (오류발생)→ float f = 3.14f;
0.123 = .123

  • 문자리터럴
    단일 인용부호로 문자표현 or
    \u다음에 4자리 16진수 숫자로 유니코드 표현or
    특수문자 리터럴은 백슬래시로 시작

    • 논리리터럴
      true와 false 2개뿐
      주의! 숫자 1 0 등의 정수가 참 거짓(boolean형)으로 사용할 수 없다.
      형변환에서 제외된다.
    • null리터럴 주의! 레퍼런스변수에만 대입사용 가능
    • 문자열리터럴은 string객체로 자동처리

  • 숫자에 '_'허용하여서 가독성을 높임

  • 맨앞맨뒤 . L 0x앞뒤에는 올수 없음

  • var 키워드: 변수타입선언을 생략하여 컴파일러가 타입추론

      • java 10부터 도입된 키워드
    • 지역변수의 선언에만 사용
    • 선언과 동시에 초기화가 필요함
    • 필드에서 사용불가
    • 지역변수의 의미
      • 지역변수(Local variable)는 특정한 범위(scope) 내에서만 유효한 변수를 말합니다. 이러한 변수는 메서드, 생성자, 초기화 블록 등의 블록 내에서 선언되며, 해당 블록을 벗어나면 사용할 수 없습니다.

  • 상수선언

    • final 키워드 사용
    • 선언시 초기값 지정
    • 실행중 값 변경불가
      • 선언과 동시에 초기화 안했다면 나중에 가능
      • but 초기화 했는데 그 값을나중에 바꿔줄 수 는 없음

  • java에서의 변수는 초기화하지 않고 사용하면 컴파일에러

    • 쓰레기 값조차 주지 않는다!

  • 변수, 리터럴, 상수 활용 예시

public class CircleArea {
	public static void main(Stirng[] args) { 
		final double PI = 3.14;
		
		double radius = 10.0;
		double circleArea = radius*radius*PI;
		
		System.out.println("원의 면적 = " + circleArea);
	}
}

타입 변환 (중요 parse함수)

  • 자동 타입변환
    • 작은 타입은 큰 타입을 자동 변환 → 컴파일러에 의해 이루어짐
    • 기존의 값을 최대한 보존할 수 있는 타입으로 자동 형변환한다.
    • 치환문(=)이나 수식 내에서 타입이 일치하지 않을 때 EX1) long m = 25; // 25는 int 타입, 25가 long으로 자동변환 EX2) double d = 3.14 * 10; // 실수 연산을 하기 위해 10이 10.0으로 자동변환 Untitled
  • 강제 타입 변환
    • 큰 타입이 작은 타입으로 변환할 때 자동 타입 변환이 이뤄지지 않음
    • 개발자가 필요하여 강제로 타입 변환을 지시
    • 주의! 강제 변환은 값 손실 우려 EX1) byte = (byte)n; //0x0000012C → 0x2C EX2) double d = 1.9; int n=(int)d; //n=1
  • 타입 변환 예시
    public class TypeConversion {
	public static void main(String[] args){
		byte b = 127;
		int i = 100;
		
		System.out.println(b+i); 
		System.out.println(char(0x12340041)); 
		System.out.println((byte(b+i));
		System.out.println((int)2.9+1.8); 
		System.out.println((int)(2.9+1.8));
		System.out.println((int)2.9+(int)1.8); //->2, ->1
	}
}
    • 출력 결과: 227 A -29 3.8 4 3
  • *중요* 문자열을 실수나 정수로 바꾸는 parse함수
    • int i = Integer.parseInt(String s); //Integer에 Int인 것 주의!! (대문자 주의)
    • double d = Double.parseDouble(String s);

중요 자바에서 키 입력: Scanner 클래스

  • System.in //System 클래스 안에 in이라는 변수
    • 키보드로부터 직접 읽는 자바의 표준 입력 스트림
    • 키 값을 바이트(문자 아님)로 리턴
    • 주의! 키 값을 바이트 데이터로 넘겨주므로 응용프로그램이 문자 정보로 변환해야함
  • Scanner 클래스로 쉽게 키 입력
    • System.in에게 키를 읽게 하고, 읽은 바이트를 문자, 정수, 실수, 불린, 문자열 등 다양한 타입으로 변환하여 리턴
      • java.util.Scanner 클래스
    • 객체 생성 방법
      import java.util.Scanner; //import문 필요
...
Scanner a = new Scanner(System.in); // Scanner 객체 생성
    • System.in에게 키를 읽게 하고, 원하는 타입으로 변환하여 리턴
    • 주의! close시에 keyboard 입력이 들어와도 스트림 자체가 끊기기에 더 이상 입력 받을 수 없음 → 다시 스캐너 생성 불가
  • Scanner를 이용한 키 입력

    • Scanner에서 키 입력 받기
      - Scanner는 입력되는 키 값을 공백으로 구분되는 아이템 단위로 읽음
      - 주의! 공백 문자: ‘\t’, ‘\f’, ‘\r’, ‘ ‘, ‘\n’
      - 개발자가 원하는 다양한 타입이 값으로 바꾸어 읽을 수 있음

      Scanner sc = new Scanner(System.in);
//ㄴ Scanner는 키 입력을 공백으로 구분된 토큰 단위로 끊어 읽는다.
// 사용자의 키 입력 예시: Kim Seoul 20 65.1 true
String name = sc.next(); //"Kim"
String city = sc.next(); //"Seoul"
int age = sc.nextInt(); //20
double weight = sc.nextDouble(); //65.1
boolean single = scanner.nextBoolean(); //true
  • Scanner 주요 메소드
    • String next(): 다음 토큰을 문자열로 리턴
    • byte nextByte(): 다음 토큰을 byte 타입으로 리턴
    • short nextShort(): 다음 토큰을 short 타입으로 리턴
    • int nextInt(): 다음 토큰을 int 타입으로 리턴
    • long nextLong(): 다음 토큰을 long 타입으로 리턴
    • float nextFloat(): 다음 토큰을 float 타입으로 리턴
    • double nextDouble(): 다음 토큰을 double 타입으로 리턴
    • boolean nextBoolean(): 다음 토큰을 boolean 타입으로 리턴
    • String nextLine(): ‘\n’을 포함하는 한 라인을 읽고 ‘\n’을 버린 나머지 문자열 리턴
    • void close(): Scanner의 사용종료
    • boolean hasNext(): 현재 입력된 토큰이 있으면 true, 아니면 입력 때까지 무한정 대기, 새로운 입력이 들어오면 다시 true리턴, crtl-z(EOF) 키가 입력되면 입력 끝이므로 false 리턴 ? 사용법
    • 주의! char형을 제외한 모든 primitive 타입을 읽어들여 반환한다. 만약, char형을 읽고 싶다면 java.lang.string의 charAt()을 이용해야한다.
      • EX) `char a = input.next().charAt(0);`
  • Scanner를 이용한 키 입력 연습 예시
import java.util.Scanner; //full name으로 꼭 써주기

public class ScannerEx {
	public static void main(String args[]) {
		System.out.println("이름, 도시, 나이, 체중, 독신 여부를 빈칸으로 분리하여 입력하세요");
		Scanner scanner = new Scanner(System.in);
		
		String name = scanner.next();
		System.out.print("이름은" + name + ", ");
		
		String city = scanner.next();
		System.out.print("도시는" + city + ", ");
		
		int age = scanner.nextInt();
		System.out.print("나이는" + age + "살, ");
		
		double city = scanner.nextDouble();
		System.out.print("도시는" + weight + ", ");
		
		boolean single = scanner.nextBoolean();
		System.out.println("독신 여부는" + single + "입니다.");
		
		scanner.close();
  • 전부 입력받은 후에 구분동작을 통해 토큰을 가져간다. 질문은 먼저해주기 block상태에서 다음줄 실행하지 않기 떄문.
  • 입력을 기다리며 실행대기(Blocking)되어있음. 엔터키를 눌러서 stream에 들어오자 마자 실행
  • 입력이 몇개 들어올지 모르는 상황에는 while(scanner.hasNext()){ …scanner.next~(); …} 식으로 사용해준다.

식과 연산자 (*중요*** 비트연산)

  • 연산자 우선 순위

    • ++(postfix), —(postfix)

    • +(부호), -(부호), ++(prefix), —(prefix), ~, !

    • 형변환

    • *, /, %

    • +(덧셈), -(뺄셈)

    • >>, <<, >>>

    • <>, <=, >=, instanceof

    • ==, ≠

    • & (비트 AND)

    • ^ (비트 XOR / 논리 XOR)

    • | (비트 OR)

    • && (논리 AND )

    • || (논리 OR)

    • ? : (조건) ← 주의! 삼항 조건문의 조건은 괄호로 표시하기

    • =, +=, -=, *=, %=, &=, ^=, |=, <<=, >>=, >>>=

      왼쪽에서 오른쪽으로 처리 (단항연산자, 형변환, 대입연산자 제외)
      ex) int x=2, y=10, z=0;

      z=x++2 + --y - 5 + x(y%2); // z는 11이다

    • postfix, prefix ++, --먼저 연산하고 *, /, %를 연산하고 그 후에 +, -를 계산한다.

    • 주의! x++의 값은 연산하고 나중에 계산해도 2로 평가됨, 그 이후의 x값이 3으로 평가

    1. z= 22 + 9 - 5 + 3(9%2);
    2. z= 4 + 9 - 5 + 3*1;
    3. z= 4 + 9 - 5 + 3;
    4. z= 11;
  • 산술연산자

    • +, -, *, /, % 산술 연산 예시

      import java.util.Scanner;

public class ArithmeticOperator {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		
		System.out.print("정수를 입력하세요: ");
		int time = scanner.nextInt();
		int second = time % 60;
		int minute = (time/60) % 60;
		int hour = (time/60) / 60;
		
		System.out.print(time + "초는 ");
		System.out.print(hour + "시간, ");
		System.out.print(minute + "분, ");
		System.out.print(second + "초 입니다 ");

    • 출력 결과:

      정수를 입력하세요: 5000

      5000초는 1시간, 23분, 20초입니다.

  • 증감 연산, 대입 연산

    • 대입 연산자(= ..등)와 증감 연산자(++, --) 사용 예시

      public class AssignmentIncDecOperator {
	public static void main(String[] args) {
		int a=3, b=3, c=3;
		
		//대입 연산자 사례
		a += 3;
		b *= 3;
		c %= 2;
		System.out.println("a= "+a+", b="+b+", c="+c);
		
		int d=3;
		//증감 연산자 사례
		a = d++;//a=3,d=4
		System.out.println("a= "+a+", d="+d);
		a=++d;//a=5,d=5
		System.out.println("a= "+a+", b="+b+", c="+c);
		a=d--;//a=5,d=4
		System.out.println("a= "+a+", b="+b+", c="+c);
		a=--d;//a=3,d=3
		System.out.println("a= "+a+", b="+b+", c="+c);
	}
}

    • 출력 결과:

      a=6, b=9, c=1

      a=3, d=4

      a=5, d=5

      a=5, d=4

      a=3, d=3

  • 비교 연산과 논리연산

    • 주의! 문자열은 비교연산자 대신 a와 b문자열을 비교한다면, a.equals(b)함수를 사용해야한다. 문자열의 ==연산자는 레퍼런스 값을 비교한다.

    • 그러나 문자열 리터럴은 같은 값이면 같은 레퍼런스 값을 같기에 ==가 맞아보일 때도 있지만 사실은 같은 레퍼런스를 가르킨다는 것을 알려줄 뿐이다.

      참고링크: https://studywithus.tistory.com/88

    • 비교 연산자(< ..등)와 논리 연산자(&& ..등) 사용 예시

      public class LogicalOperator {
	public static void main (String[] args) {
		//비교연산
		System.out.println('a' > 'b');
		System.out.println(3 >= 2);
		System.out.println(-1 < 0);
		System.out.println(3.45 <= 2);
		System.out.println(3 == 2);
		System.out.println(3 != 2);
		System.out.println(!(3 != 2));
		
		//비교 연산과 논리 연산 복합
		System.out.println((3>2) && (3>4));
		System.out.println((3 != 2) || (-1 > 0));
		System.out.println((3 != 2) ^ (-1 > 0));
	}
}

    • 출력 결과:

      false

      true

      ture

      false

      false

      true

      false

      false

      true

      true

  • 조건 연산자 ?:

    • 조건 연산 예시
      - 주의! 조건 연산에서 값을 저장하는 문장은 넣어줄 수 없다
      - 대입연산 이외의 논리식, 계산식 등의 식은 넣어줄 수 있음

      public class TernaryOperator {
	public static void main (String[] args) {
		int a = 3, b = 5;
		
		System.out.println("두 수의 차는 " + ((a>b)?(a-b):(b-a)));
	}
}

    • 출력결과:

      두 수의 차는 2

    • 주의! 위의 형태처럼 문자열과 +연산을 하여서 출력하기 위해서는 조건 연산형태에 괄호를 쳐주어야한다. 그렇지 않으면 컴파일 오류가 발생한다

  • 중요 비트 연산

    • 비트 논리 연산

      • 비트끼리 AND, OR, XOR, NOT 연산
      • a & b : AND 연산 → 두비트 모두 1이면 1, 그렇지 않으면 0
      • a | b : OR 연산 → 두비트 모두 0이면 0, 그렇지 않으면 1
      • a ^ b : XOR 연산 → 두 비트가 다르면 1, 같으면 0
      • 주의! ~a : NOT 연산 → 1을 0으로, 0을 1로 변환
      • ㄴ boolean식과 함께 사용할 수 없음

    • 비트 시프트 연산

      • 비트를 오른쪽이나 왼쪽으로 이동
      • a >> b : a의 각 비트를 오른쪽으로 b번 시프트한다. 최상위 비트의 빈자리는 시프트 전의 최상위 비트로 다시 채운다. 산술적 오른쪽 시프트라고 한다.
      • a >>> b : a의 각 비트를 오른쪽으로 b번 시프트한다. 최상위 비트의 빈자리는 항상 0으로 채운다. 논리적 오른쪽 시프트라고 한다.
      • a << b : a의 각 비트를 왼쪽으로 b번 시프트한다. 최하위 비트는 빈자리는 항상 0으로 채운다. 산술적 왼쪽 시프트라고 한다.

    • 시프트 연산자의 사례

      Untitled

    • 주의! byte의 예외적 형변환 허용

    • 자동형변환: 작은 size가 자동으로 큰 size가 되는 것

    • literal int는 원칙적으로 byte로 자동형변환이 되지 않음

    • 그러나 byte안에 정상적으로 저장되는 값까지 허용해줌

      ㄴ강제 형변환을 해준 것과 같은 원리

    • 비트단위로 0111 1111까지만 허용 → 127까지 허용

      • EX)
      • byte a=5; (O): compiler는 5를 int로 평가 → 원래는 에러가 나야하는데 값으로만 평가해서 허용해줌
      • byte a=127; (O): 127까지 허용해줌
      • byte a=1+1; (O): 계산을 하고 나도 여전히 int literal
      • byte a=0xff; (X): 0111 1111까지만 허용해줌
      • int b=5; byte a=b; (X): 변수가 오면 compiler 입장에서 값을 알 수 없기에 int취급하여서 허용되지 않음

    • 비트 논리 연산과 비트 시프트 연산 사용 예시

      public class BitOperator {
	public static void main(String[] args) {
		short a = (short)0x55ff;
		short b = (short)0x00ff;
		
		//비트 논리 연산
		System.out.println("[비트 연산 결과]");
		System.out.printf("%04x\n", (short)(a & b));
		System.out.printf("%04x\n", (short)(a | b));
		System.out.printf("%04x\n", (short)(a ^ b));
		System.out.printf("%04x\n", (short)(~a));
		
		byte c = 20; //0x14
		byte d = -8; //0xf8
		System.out.println("[시프트 연산 결과]");
		System.out.println(c << 2);
		System.out.println(c >> 2);
		System.out.println(d >> 2);
		System.out.printf("%x\n", (d>>>2));
	}
}

    • 연산 결과:

      [비트 연산 결과]

00ff

55ff

5500

aa00

[시프트 연산 결과]

80

5

-2

3ffffffe
      • 주의! 음수를 쉬프트할 때 주의할 것! d>>>2여기서 이미 정수 리터럴 2와 연산하기에 d는 int형으로 변환됨. 논리 우측 시프트 연산에서 32비트 int로 확장될 때, 나머지 비트는 부호 비트를 유지하기 위해 부호 비트와 동일한 값으로 채워진다. 그래서 최종적으로 32비트 int로 변환된 값은 다음과 같이 표시된다:
        • 11111111111111111111111111111000 // -8을 나타내는 32비트 int
        • 그런 다음, 이 값을 2비트 오른쪽으로 논리 우측 시프트하면 다음과 같이 됩니다:
        • 00111111111111111111111111111110 // 32비트 int에서 2비트 우측 시프트한 값
        • 이 값은 16진수로 표현하면 "0x3FFFFFFE"가 됩니다.

      Compiler의 형변환

    • Compiler가 식을 평가하고 하나의 Type 통일하여서 평가함

    • Compiler → 우선순위 정하기 → 데이터 타입 확인 → 암묵적 형변환

조건문

  • 단순 if문
    import java.util.Scanner;

public class SuccessOrFail {
	public static void main(String[] args) {
		Scanener scanner = new Scanner(System.in);
		
		System.out.print("점수를 입력하시오: ");
		int score = scanner.nextInt();
		if(score >= 80)
			System.out.println("축하합니다! 합격입니다.");
			
		scanner.close();
	}
}
    • 출력 결과: 점수를 입력하시오: 95 축하합니다! 합격입니다.
  • if-else

    • if는 가장 가까운 else구문과 짝을 이룬다.

      ex) if(~)
			if(~~)
			else(~~)

      주의! 두번째줄 if와 세번째 줄 else가 짝을 이룸 

      ex) if(~){
			if(~~)
			}
		else(~)

      첫번째줄 if와 4번째 줄 else가 짝을 이룸

      import java.util.Scanner;

public class MultipleOfThree {
	public static void main (String[] args) {
		Scanner in = new Scanner(System.in);
		
		System.out.print("수를 입력하시오: ");
		int number = in.nextInt();
		
		if(number % 3 == 0)
			System.out.println("3의 배수입니다.");
		else
			System.out.println("3의 배수가 아닙니다.");
		scanner.close();
	}
}

    • 출력 결과:

      수를 입력하시오: 129

      3의 배수입니다.

  • 다중 if-else
    import java.util.Scanner;
public class Grading {
	public static void main(String[] args) {
		char grade;
		Scanner scanner = new Scanner(System.in);
		
		System.out.print("점수를 입력하세요(0~100): ");
		int score = scanner.nextInt(); //점수 읽기
		if(score >= 90)
			grade = 'A';
		else if(score >= 80)
			grade = 'B';
		else if(score >= 70)
			grade = 'C';
		else if(score >= 60)
			grade = 'D';
		else
			grade = 'F';
		System.out.println("학점은 "+grade+"입니다.");
		
		scanner.close();
	}
}
    • 출력 결과: 점수를 입력하세요(0~100): 89 학점은 B입니다.
  • 중첩 if-else문
    import java.util.Scanner;
public class Nestedlf {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		
		System.out.print("점수를 입력하세요(0~100): ");
		int score = scanner.nextInt();
		
		System.out.print("학년을 입력하세요(1~4): ");
		int year = scanner.nextInt();
		
		if(score >= 60) {
			if(year != 4)
				System.out.println("합격!");
			else if(score >= 70)
				System.out.println("합격!");
			else
				System.out.println("불합격!");
		}
		else
			System.out.println("불합격!");
			
		scanner.close();
	}
}
    • 출력 결과: 점수를 입력하세요(0~100): 65 학년을 입력하세요(1~4): 4 불합격!
  • switch문
    import java.util.Scanner;
public class GradingSwitch {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		
		char grade;
		System.out.print("점수를 입력하세요(0~100): ");
		int score = scanner.nextInt();
		switch (score/10) {
		case 10:
		case 9:
			grade = 'A';
			break;
		case 8:
			grade = 'B';
			break;
		case 7:
			grade = 'C';
			break;
		case 6:
			grade = 'D';
			break;
		default:
			grade = 'F';
		}
		System.out.println("학점은 " + grade + "입니다.");
		scanner.close();
	}
}
    • 결과 출력: 점수를 입력하세요(0~100): 89 학점은 B입니다.
  • switch문 활용

    • 주의! case문의 값
      - 문자, 정수, 문자열 리터럴만 허용
      - 실수 리터럴은 허용되지 않음

      import java.util.Scanner;
public class CoffeePrice {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		
		System.out.print("무슨 커피 드릴까요? ");
		String order = scanner.next();
		int price=0;
		switch (order) {
			case "에스프레소":
			case "카푸치노":
			case "카페라떼":
				price = 3500;
				break;
			case "아메리카노":
				price = 2000;
				break;
			default:
				System.out.println("메뉴에 없습니다!");
		}
		if(price != 0)
			System.out.print(order + "는 " + price + "원입니다");
		scanner.close();
	}
}

    • 출력 결과:

      무슨 커피 드릴까요? 에스프레소

      에스프레소는 3500원입니다

원본 노션 링크

https://believed-poinsettia-f0f.notion.site/3-6258a40eb499419892b4bc7e96d1a8f9?pvs=4

profile
근이의 개발일기
SSU 21 CSE
이전 포스트

[Java] 명품 Java programming 정리 - 1장

다음 포스트

[Java] 명품 Java Programming 정리 - 3장

0개의 댓글