내가 정리한 Java의 기초(1)

 

 

• 개발 언어의 역사.
  - A 언어
    ㄴ 첫 개발언어라는 의미. A Programming Language의 약자.
    ㄴ 1960'
    ㄴ 입/출력, 문맥.
    ㄴ 프로그램을 만들기 위해 기본적으로 필요한 기능 입/출력, 문맥 기능만 구현가능.
  
  - B 언어
    ㄴ Bell 사에서 개발.
    ㄴ 1960'
    ㄴ A언거 기능 + 기계식 데이터 타입, 연산기능, 메서드.
    ㄴ A언어 기능에 데이터를 담을 수 있는 타입이 생김, 데이터를 연산하고 묶어서 관리할 수 있는 메서드 구현이 가능.
  
  - C 언어
    ㄴ B언어에 비해 더 좋은 언어라는 의미.
    ㄴ 1970'
    ㄴ B언어 기능 + 자료형 데이터 타입, 자료구조.
    ㄴ B언어 기능에 다양한 데이터 타입을 정의하고 자료구조에 담을 수 있음.
  
  - Java
    ㄴ 어디서나 마시는 커피처럼 어디서나 동작 가능한 자바 커피에서 이름을 따옴.
    ㄴ 1990'
    ㄴ C언어 기능 + 공통 실행환경, 클래스, 객체.
    ㄴ C언어 기능에 여러 기기에서 실행가능하도록 도와주는 공통 실행환경, 데이터와 메서드를 담는 클래스를 통해 객체를 만듦.

 

• Why Java?
  - 공통 실행환경.
    ㄴ 여러 기기의 운영 체제에서 실행할 수 있는 언어.
    ㄴ 특히 애플리케이션(모바일, 서버 등) 개발에 적합.
  
  - 세상과 닮아있는 개발언어라 코드를 이해하기 쉽고 유지 보수가 쉬움.
    ㄴ 존재하는 물건을 "객체"라 부르는 세상을 닮도록 만든 객체언어.
    ㄴ 클래스를 통해 객체를 만듦.
  
  - 안정성이 높아서 프로그래밍 오류를 방지하고 보안상 안전.
    ㄴ 작성된 문맥을 바이트 코드로 변환하는 변환기(compiler)가 먼저 오류를 체크.
    ㄴ 지원하는 보안 기술이 많음.
  
  - 대규모 앱 개발 가능.
    ㄴ 네트워크 및 데이터베이스 연결, 통신 등의 작업을 처리하는 API를 제공.
  
  - 다양한 개발 도구와 라이브러리를 사용가능.
    ㄴ 앱 개발에 필요한 작업을 보다 쉽게 처리할 수 있음.
  
  

 

• JVM(Java Virtual Machine)
  - 여러가지의 기기 위에 Java 프로그램을 실행시킬 수 있는 가상의 기기를 만들어주는 것을 의미.

 

• JRE & JDK
  - JRE(Java Runtime Environment)
    ㄴ 자바 실행 환경.
    ㄴ .class 파일만 실행 가능.
  
  - JDK(Java Development Kit)
    ㄴ 자바 개발 키트.
    ㄴ JRE(JVM)의 기능을 포함하고 있음.
    ㄴ .java 파일들을 .class 파일들로 변환해 주는 Java Compiler(javac)의 기능이 있음.
    ㄴ 코드를 디버깅하는 jbd가 있음.
  
  * 디버깅(중단점 일시정지 + 코드 라인단위 수행)
    - 개발한 코드들을 한줄씩 객체와 메소드를 수행하면서 변수들도 변화는 과정을 코드를 따라가면서 변수를 볼 수 있는 기능.
    - 작성한 코드 라인에 중단점을 설정하고 디버그모드로 프로그램을 실행하면 프로그램이
      중단점의 코드라인을 수행할 때 프로그램 흐름이 일시정지되며 변수들을 볼 수 있게 도와줌.

 

• main 메서드에 대한 코드 해석하기.

public class Main {
	public static void main(String[] args) {
		System.out.println("Hello world!");
	}
}

• public class Main{ }
  - class 정의.
  - public : 클래스 경로 외부에서 실행시킬 수 있다고 표시해 주는 "접근 제어자".
                  클래스 경로 외부에서 호출 못하도록 막는 접근제어자는 private, protected 등도 있음.
  - class : 객체를 만드는 클래스라고 선언.
  - Main : 클래스명. 파일명과 일치시켜야함. Java컴파일러가 바이트코드 변환했을 때의 파일 확장명(.class)와 일치됨.
  
  
• public static void main( )
  - main 메서드 정의.
  - public : 외부에서 실행시킬 수 있다고 표시해주는 "접근제어자".
  - static : Java 컴파일러가 바이트 코드로 변환할 때 미리 정의되는 메서드 표기. 앱 실행 시 한 번만 정의되며
                 static 메서드 또는 변수(데이터)끼리만 호출할 수 있음.
  - void : 메서드의 응답값을 정의하는 곳. void는 응답할 값이 없다는 정의. int는 정수, char는 문자, string은 문자열 등.
  
  
• (String [ ] args)
  - 메서드가 시작될 때 넘겨받을 데이터들(변수들).
  - String[ ] : 문자열 여러 개 데이터 타입.
  - args : 문자열 여러개 데이터의 이름(사용자가 정의한 값).
  
  
• System.out.print() : 출력창에 괄호 안으로 전달된 데이터를 출력.
• System.out.println() : 출력창에 괄호 안으로 전달된 데이터를 출력 후 줄 바꿈(sout).

System.out.print(7);
System.out.println(3);
System.out.println(3.14);
System.out.println("JAVA");

// 실행 결과
7
3
3.14
JAVA

 

• 변수(변하는 저장공간)
  - '수'로 끝나지만 숫자만 말하는 것이 아니라 하나의 값을 저장할 수 있는 저장공간을 의미.
  - 이름(변수명)을 붙여서 필요한 값을 저장해 둠.

int number = 10; // 1. 변수로 선언 및 초기화

number = 11; // 2. 변수의 값을 바꾼다. (덮어쓰기)

 

•  상수(변하지 않는 저장공간)
  - 저장효율을 위해 변하지 않을 값을 따로 저장하는 공간이 있기 때문.

final int number = 10; // 1. 상수로 선언 (데이터 타입 앞에 final 을 붙이면 됩니다.)

number = 11; // e2. 변수의 값을 바꾸려고하면 에러가 납니다!

 

• 기본형 변수
  - 논리형 변수 : boolean
    ㄴ True / False 값만 저장.

boolean flag = true; // 1. 논리형 변수 boolean 으로 선언 및 True 값으로 초기화

flag = false; // 2. False 값으로도 저장할 수 있습니다.

       - 문자형 변수 : char
         ㄴ 'A', '1'과 같은 문자 '하나'만 저장. 작은따옴표(' ')를 사용.
         ㄴ 문자 뒤에 \0(널문자)가 없음.

char alphabet = 'A'; // 문자 하나를 저장합니다.

       - 정수형 변수 : byte, short, int, long
         ㄴ 정수형 숫자값을 저장.

byte byteNumber = 127; // byte 는 -128 ~ 127 범위의 숫자만 저장 가능합니다.

short shortNumber = 32767; // short 는 -32,768~32,767 범위의 숫자만 저장 가능합니다. 2byte

int intNumber = 2147483647; // int 는 -21억~21억 범위의 숫자만 저장 가능합니다. 4byte

long longNumber = 2147483647L; // long 은 숫자뒤에 L 을 붙여서 표기하며 매우 큰수를 저장 가능합니다. 9백경 범위. 8byte

       - 실수형 변수 : float, double
         ㄴ 0.123, 0.9999와 같은 소수점 실수값을 저장.

float floatNumber = 0.123f; // float 는 4byte 로 3.4 * 10^38 범위를 표현하는 실수값
//long 범위 보다 큼

double doubleNumber = 0.123123123; // double 은 8byte 로 1.7 * 10^308 범위를 표현하는 실수값
//long 범위 보다 큼

 

• 참조형 변수
  - 문자열 변수 : String
    ㄴ "Apple", "텍스트"와 같은 문장을 저장. 큰따옴표를 사용하여 범위를 지정.
    ㄴ 문장의 끝에 \0(널문자)가 함께 저장됨(몇 개의 byte를 쓸지 모르기 때문에 끝을 표기).
  
  - 그 외 : Object, Array, List
    ㄴ 객체, 배열, 리스트와 같은 단일 저장공간에 담을 수 없는 값을 저장.
   

String message = "Hello World"; // 문자열을 저장합니다.

//////////////////

List<int> alphabet = [0,1,2,3]; // 기본형 변수 여러개를 저장합니다.

 

• 래퍼 클래스 변수(Wrapper Class)
  - 기본형 변수를 클래스로 한번 랩핑(감싸는)하는 변수.
  - 클래스가 객체지향 언어인 Java의 핵심기능이기 때문에 클래스로 변수를 관리하면 객체지향의 많은 기능을 사용할 수 있음.
  - 박싱 : 기본 타입에서 래퍼 클래스 변수를 감싸는 것.
  - 언박싱 : 래퍼 클래스 변수를 기본 타입 변수로 가져오는 것.

// 박싱 VS 언박싱

// 박싱
// Integer 래퍼 클래스 num 에 21 의 값을 저장
int number = 21;
Integer num = new Integet(number);

// 언박싱
int n = num.intValue(); // 래퍼 클래스들은 inValue() 같은 언박싱 메서드들을 제공해줍니다.

기본 타입	래퍼 클래스
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

 

• 아스키코드의 규칙으로 문자를 저장(표현)

//숫자 -> 문자

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		int asciiNumber = sc.nextInt();
		char ch = (char)asciiNumber; // 문자로 형변환을 해주면 숫자에 맞는 문자로 표현됩니다.

		System.out.println(ch);
	}

}

// 입력
97

// 출력
a

////////////////////////////////
// 문자 -> 숫자

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		char letter = sc.nextLine().charAt(0); // 첫번째 글자만 받아오기위해 charAt(0) 메서드를 사용합니다.
		int asciiNumber = (int)letter; // 숫자로 형변환을 해주면 저장되어있던 아스키 숫자값으로 표현됩니다.

		System.out.println(asciiNumber);
	}

}

// 입력
a

// 출력
97

 

• 참조형 변수 Stack & Heap 영역
  - 다른 기본형 변수가 실제 값을 저장하는 저장공간이라면 참조형 변수는 실제 값이 아닌 원본값의 주소값을 저장.
  - 참조형 변수는 즉 주소값을 저장하는 "주소형 변수"라고 부름.
  - 기본형 변수는 원본값이 Stack 영역에 있음. 참조형 변수는 원본값이 Heap 영역에 있음.
  - Stack 영역 : 정적으로 할당된 메모리 영역.
    ㄴ 크기가 몇 byte인지 정해져 있는 기본형 변수를 저장.
    ㄴ 크기가 정해져있는 참조형 변수의 주소값도 저장.
  
  - Heap 영역 : 동적으로 할당된 메모리 영역.
    ㄴ 크기가 계속 늘어날 수 있는 참조형 변수의 원본을 저장.

 

• 입력
  - Java 프로그램에서는 기본적으로 Scanner.in 객체의 next() 명령을 사용해서 입력받음.

Scanner sc = new Scanner(System.in); // Scanner 객체를 new 명령어로 생성합니다.
String input = sc.next();  // sc(Scanner)의 .next(); 를 실행하면 input 변수에 입력한 글자를 받을 수 있습니다.

 

• 출력
  - Java 프로그램에서는 기본적으로 System.out 객체의 println() 명령을 사용해서 출력.

Scanner sc = new Scanner(System.in);
String input = sc.next();  

System.out.println("입력값 : " + input);  // 입력한 글자를 출력합니다.

// 실행 결과
{입력}
입력값 : {입력}

 

• 형변환
  - Java 프로그래밍 중 문자열로 입력받은 변수를 숫자로 변환해서 계산을 하고 싶은 경우, 문자열에 숫자값을 추가하고 싶은 경우.
  - 주로 기본형 변수인 정수, 실수, 문자 들 사이에서 일어남.
  - 정수와 실수 간에 변환할 때는 ({ 원하는 타입 }) 명령을 통해 변환할 수 있음(캐스팅).
    ㄴ Double, Float to Int : (Int)캐스팅으로 시수를 정수로 치환하는 방법. 실수형의 소수점아래는 버려짐.

double doubleNumber = 10.101010;
float floatNumber = 10.1010

int intNumber;
intNumber = (int)doubleNumber; // double -> int 형변환
intNumber = (int)floatNumber; // float -> int 형변환

       - Int to Double, Float : (Double, Float) 캐스팅으로 정수형을 실수형으로 변환하는 방법.

int intNumber = 10;

double doubleNumber = (double)intNumber; // int -> double 형변환
float floatNumber = (float)intNumber;  // int -> float 형변환

 

• 자동 형변환
  - 형변환을 직접적으로 캐스팅하지 않아도 자동으로 형변환 되는 케이스가 있음.
  - 프로그램 실행 도중에 값을 저장하거나 계산할 때 자동으로 타입변환이 일어남.
  - 변수 타입별 크기 순서
    ㄴ byte(1) -> short(2) -> int(4) -> long(8) -> float(4) -> double(8)

//작은 크기의 타입에서 큰 크기의 타입으로 저장될 때.
byte byteNumber = 10;
int intNumber = byteNumber;    // byte -> int 형변환
System.out.println(intNumber); // 10

char charAlphabet = 'A';
intNumber = charAlphabet;   // char -> int 형변환
System.out.println(intNumber); // A의 유니코드 : 65

intNumber = 100;
long longNumber = intNumber; // int -> number 형변환
System.out.println(longNumber); // 100

intNumber = 200;
double doubleNumber = intNumber; // int -> double 형변환
System.out.println(doubleNumber); // 200.0  (소수점이 추가된 실수출력)

///////////////////////////////////////

//작은 크기의 타입이 큰 크기의 타입과 계산될 때.
int intNumber = 10;
double doubleNumber = 5.5;
double result = intNumber + doubleNumber; // result 에 15.5 저장됨 (int -> double)

intNumber = 10;
int iResult = intNumber / 4; // iResult 에 2 저장됨 (int형 연산 -> 소수점 버려짐)

intNumber = 10;
double dResult = intNumber / 4.0; // dResult 에 2.5 저장됨 (double형 연산 -> 소수점 저장)

 

• 연산자의 종류

산술 연산자	+    -    *    /    %    <<    >>	사칙 연산과 비트연산
비교 연산자	>    <    >=    <=    ==    !=	크고 작읍과 같고 다름을 비교
논리 연산자	&&    | |    !	AND와 OR으로 조건을 연결
대입 연산자	=    ++    --	우변의 값을 좌변에 저장, 연산 복합 대입
기타 연산자	(type)    ? :    instance of	형변환 연산자, 삼항 연산자, instance of 연산자

 

• 산술 연산자
  - 사칙 연산 및 비트연산을 포함.
  - 사칙 연산을 계산한 결괏값을 응답.

// 사칙 연산
System.out.println(4 + 2); // 6
System.out.println(4 - 2); // 2
System.out.println(4 * 2); // 8
System.out.println(4 / 2); // 2
System.out.println(5 / 2); // 2
System.out.println(2 / 4); // 0
System.out.println(4 % 2); // 0
System.out.println(5 % 2); // 1

// 우선 순위 연산
System.out.println(2 + 2 * 2); // 6
System.out.println((2 + 2) * 2); // 8
System.out.println(2 + (2 * 2)); // 6

// 변수를 이용한 연산
int a = 20;
int b = 10;
int c;

// 덧셈
c = a + b;
System.out.println(c); // 30

// 뺄셈
c = a - b;
System.out.println(c); // 10

// 곱셈
c = a * b;
System.out.println(c); // 200

// 나눗셈 (몫)
c = a / b;
System.out.println(c); // 2

// 나눗셈 (나머지) = 나머지 연산
c = a % b;
System.out.println(c); // 0

 

• 비교 연산자
  - 값의 크고/작음을 비교하거나 같고/다름을 비교하여 참(true)/거짓(false) 값인 boolean 값을 출력.

// 비교 연산자 (참이면 true, 거짓이면 false)
System.out.println(10 > 9); // 10 는 9 보다 크다 (참이면 true, 거짓이면 false)
System.out.println(10 >= 9); // 10 는 9 보다 크거나 같다 (true)
System.out.println(10 < 9); // 10 는 9 보다 작다 (false)
System.out.println(10 <= 9); // 10 는 9 보다 작거나 같다 (false)
System.out.println(10 == 10); // 10 는 10 와 같다 (true)
System.out.println(10 == 9); // 10 는 9 과 같다 (false)
System.out.println(10 != 10); // 10 는 10 와 같지 않다 (false)
System.out.println(10 != 9); // 10 는 9 과 같지 않다 (true)

 

• 논리 연산자
  - 비교 연산의 결괏값으로 받을 수 있는 boolean 값을 연결하는 연산자.
  - 조건을 연결하였을 때의 boolean 값들을 조합하여 참(true)/거짓(false) 값인 boolean 값을 출력.

// 논리 연산자
boolean flag1 = true;
boolean flag2 = true;
boolean flag3 = false;

System.out.println(flag1); // true
System.out.println(flag2); // true
System.out.println(flag3); // false

// 피연산자 중 하나라도 true 이면 true
System.out.println(flag1 || flag2); // true
System.out.println(flag1 || flag2 || flag3); // true
// 피연산자 모두 true 이면 true
System.out.println(flag1 && flag2); // true (flag1, flag2 모두 true 라서)
System.out.println(flag1 && flag2 && flag3); // false (flag3은 false 라서)

// And 연산
System.out.println((5 > 3) && (3 > 1)); // 5 는 3 보다 크고, 3 은 1 보다 크다 (true)
System.out.println((5 > 3) && (3 < 1)); // 5 는 3 보다 크고, 3 은 1 보다 작다 (false)

// Or 연산
System.out.println((5 > 3) || (3 > 1)); // 5 는 3 보다 크거나, 3 은 1 보다 크다 (true)
System.out.println((5 > 3) || (3 < 1)); // 5 는 3 보다 크거나, 3 은 1 보다 작다 (true)
System.out.println((5 < 3) || (3 < 1)); // 5 는 3 보다 작거나, 3 은 1 보다 작다 (false)

// System.out.println(1 < 3 < 5); // 불가능한 코드

// 논리 부정 연산자
System.out.println(!flag1); // false (flag1 값의 반대)
System.out.println(!flag3); // true (flag3 값의 반대)
System.out.println(!(5 == 5)); // false
System.out.println(!(5 == 3)); // true

 

• 대입 연산자
  - 변수를 바로 연산해서 그 자리에서 저장하는 연산자.
  - 기본 대입 연산자인 = 와 다른 연산을 함께 쓰는 복합 대입 연산자가 있음(+=, -= 등).
  - 복합 대입 연산자는 기본 대입 연산자를 심플하게 작성하게 해 주는 것이지 기능은 같음.
  -  +=  1 은  ++  과 동일(피연산자에 1 더해주기).
  -  -=  1 은  --  와 동일(피연산자에 1 빼주기).

// 대입 연산자
int number = 10;
number = number + 2;
System.out.println(number); // 12

number = number - 2;
System.out.println(number); // 10

number = number * 2;
System.out.println(number); // 20

number = number / 2;
System.out.println(number); // 10

number = number % 2;
System.out.println(number); // 0

number = number++;
System.out.println(number); // 2

number = number--;
System.out.println(number); // 0

// 복합 대입 연산자
number = 10;

number += 2;
System.out.println(number); // 12

number -= 2;
System.out.println(number); // 10

number *= 2;
System.out.println(number); // 20

number /= 2;
System.out.println(number); // 10

number %= 2;
System.out.println(number); // 0

 

• 형변환 연산자

// 형변환 연산자
int intNumber = 93 + (int) 98.8; // 93 + 98

double doubleNumber = (double) 93 + 98.8; // 93.0 + 98.8

 

• 삼항 연산자
  - 비교 연산의 결괏값에 따라 응답할 값을 직접 지정할 수 있는 연산자.
  - 삼항 연산자는 3가지 피연산자가 존재하여 삼항 연산자라고 함(조건 / 참 결과 / 거짓 결과)
  -  ( 조건 )   ?   ( 참 결과 )   :   (거짓 결과) 

// 삼항 연산자
int x = 1;
int y = 9;

boolean b = (x == y) ? true : false;
System.out.println(b); // false

String s = (x != y) ? "정답" : "땡";
System.out.println(s); // 땡

int max = (x > y) ? x : y;
System.out.println(max); // 9

int min = (x < y) ? x : y;
System.out.println(min); // 1

 

• 연산자 우선순위
  - 산술 > 비교 > 논리 > 대입

// 연산자 우선순위
int x = 2;
int y = 9;
int z = 10;

boolean result = x < y && y < z; // <,> 비교연산자 계산 후 && 논리 연산자 계산
System.out.println(result); // true

result = x + 10 < y && y < z; // +10 산술연산자 계산 후 <,> 비교연산자 계산 후 && 논리 연산자 계산
System.out.println(result); // false

result = x + 2 * 3 > y; // 산술연산자 곱센 > 덧셈 순으로 계산 후 > 비교연산자 계산
System.out.println(result); // false (8>9)

result = (x + 2) * 3 > y; // 괄호안 덧셈 연산 후 괄호 밖 곱셈 계산 후 > 비교연산자 계산
System.out.println(result); // true (12>9)

 

• 산술변환
  - 연산 전에 피연산자의 타입을 일치시키는 것(둘 중에 저장공간 크기가 더 큰 타입으로 일치).
  - 피연산자의 타입이 int 보다 작은 short 타입이면 int로 변환.
  - 피연산자의 타입이 long 보다 작은 int, short 타입이면 Long으로 변환.
  - 피연산자의 타입이 float 보다 작은 long, int, short 타입이면 float으로 변환.
  - 피연산자의 타입이 double 보다 작은 float, long, int, short 타입이면 double로 변환.

// 산술변환 
public class Main {

	public static void main(String[] args) {

		short x = 10;
		int y = 20;

		int z = x + y; // 결과값은 더 큰 표현타입인 int 타입의 변수로만 저장할 수 있습니다.

		long lx = 30L;
		long lz = z + lx; // 결과값은 더 큰 표현타입인 long 타입의 변수로만 저장할 수 있습니다.

		float fx = x; // 결과값은 더 큰 표현타입인 float 타입의 변수로만 저장할 수 있습니다.
		float fy = y; // 결과값은 더 큰 표현타입인 float 타입의 변수로만 저장할 수 있습니다.
		float fz = z; // 결과값은 더 큰 표현타입인 float 타입의 변수로만 저장할 수 있습니다.
		System.out.println(lz);
		System.out.println(fx);
		System.out.println(fy);
		System.out.println(fz);
	}

}

 

• 비트 연산
  - bit의 자릿수를 옮기는 것.
  -  << (왼쪽으로 자리수 옮기기),  >> (오른쪽으로 자리수 옮기기).

// 비트 연산

// 참고, 3의 이진수값은 11(2) 입니다. 12의 이진수값은 1100(2) 입니다.
// (2) 표기는 이 숫자가 이진수값이라는 표식 입니다.

System.out.println(3 << 2); 
// 3의 이진수값인 11(2) 에서 왼쪽으로 2번 옮겨져서 1100(2) 인 12값이 됩니다.


System.out.println(3 >> 1); 
// 3의 이진수값인 11(2) 에서 오른쪽으로 1번 옮겨져서 1(2) 인 1 값이 됩니다.

 

• 조건문 - if
  -  if( 조건 )   { 연산 }  의 형태로 사용.

// 조건문
boolean flag = true;

if (flag) {
	System.out.println("flag 값은 true 입니다."); // flag 값은 true 입니다. 출력
}

// 조건문 with else
boolean flag = false;

if (flag) {
	System.out.println("flag 값은 true 입니다."); // 미출력
} else {
	System.out.println("flag 값은 false 입니다."); // flag 값은 false 입니다. 출력
}

// 조건문 with else if
int number = 2;

if (number == 1) {
	System.out.println("number 값은 1 입니다."); // 미출력
} else if (number == 2) {
	System.out.println("number 값은 2 입니다."); // number 값은 2 입니다. 출력
} else {
	System.out.println("number 값은 모르는 값입니다."); // 미출력
}

// 중첩 조건문
boolean flag = true;
int number = 2;

if (flag) {
	if (number == 1) {
		 System.out.println("flag 값은 true, number 값은 1 입니다."); // 미출력
  } else if (number == 2) {
		 System.out.println("flag 값은 true, number 값은 2 입니다."); // flag 값은 true, number 값은 2 입니다. 출력
	}
} else {
	if (number == 1) {
		 System.out.println("flag 값은 false, number 값은 1 입니다."); // 미출력
  } else if (number == 2) {
		 System.out.println("flag 값은 false, number 값은 2 입니다."); // 미출력
	}
}

 

• 중첩 if문을 활용한 가위바위보

// 조건문으로 가위바위보 만들기

import java.util.Objects;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		System.out.print("A 입력 : ");
		String aHand = sc.nextLine(); // A 입력

		System.out.print("B 입력 : ");
		String bHand = sc.nextLine(); // B 입력

		if (Objects.equals(aHand, "가위")) { // 값을 비교하는 Obects.equals() 메서드 사용
			if (Objects.equals(bHand, "가위")) {
				System.out.println("A 와 B 는 비겼습니다."); // A 와 B 의 입력값을 비교해서 결과 출력
			} else if (Objects.equals(bHand, "바위")) {
				System.out.println("B 가 이겼습니다.");
			} else if (Objects.equals(bHand, "보")) {
				System.out.println("A 가 이겼습니다.");
			} else {
				System.out.println(" B 유저 값을 잘못 입력하셨습니다.");
			}
		} else if (Objects.equals(aHand, "바위")) {
			if (Objects.equals(bHand, "가위")) {
				System.out.println("A 가 이겼습니다.");
			} else if (Objects.equals(bHand, "바위")) {
				System.out.println("A 와 B 는 비겼습니다.");
			} else if (Objects.equals(bHand, "보")) {
				System.out.println("B 가 이겼습니다.");
			}
		} else if (Objects.equals(aHand, "보")) {
			if (Objects.equals(bHand, "가위")) {
				System.out.println("B 가 이겼습니다.");
			} else if (Objects.equals(bHand, "바위")) {
				System.out.println("A 가 이겼습니다.");
			} else if (Objects.equals(bHand, "보")) {
				System.out.println("A 와 B 는 비겼습니다.");
			}
		}

	}
}

// 입/출력 예시
// A 입력 : 가위
// B 입력 : 보
// A 가 이겼습니다.

 

• 조건문 - switch 문
  - switch(피연산자) / case(조건)
  - if문 보다 좀 더 가독성이 좋은 조건문 표현식.
  -  switch(피연산자)   { case(조건) : (연산) }  형태로 많이 쓰임.
  - switch 피연산자가 case 조건을 만족하면 case: 뒤에 명시되어 있는 연산을 수행.
  - case(조건) : (연산) 은 여러 개를 설정할 수 있음.
  - 각 case의 연산문 마지막에는 break; 를 꼭 넣어줘야 함.
  - switch문 중괄호 안의 제일 마지막에  default: (연산)  을 명시하여 case 조건들이 모두 만족하지 않을 때 수행할 연산을 정해줌.
  - default: (연산) 은 아무것도 만족하지 않을 때 수행하는 것이라서 없다면 생략 가능.

// switch/case 문 

int month = 8;
String monthString = "";
switch (month) {
    case 1:  monthString = "1월";
             break;
    case 2:  monthString = "2월";
             break;
    case 3:  monthString = "3월";
             break;
    case 4:  monthString = "4월";
             break;
    case 5:  monthString = "5월";
             break;
    case 6:  monthString = "6월";
             break;
    case 7:  monthString = "7월";
             break;
    case 8:  monthString = "8월"; 
             break;
    case 9:  monthString = "9월";
             break;
    case 10: monthString = "10월";
             break;
    case 11: monthString = "11월";
             break;
    case 12: monthString = "12월";
             break;
    default: monthString = "알수 없음";
}
System.out.println(monthString); // 8월 출력

 

• if문과 switch문의 차이점
  1. 복합조건
    - if문은 복합조건을 지원 / switch문은 피연산자 한 개에 대한 조건만 지원.
  
  2. 코드중복
  - if문은 상대적으로 코드중복이 많음 / switch문은 코드중복이 적음.

// if vs switch
// switch 문 실습코드를 if 문으로 바꿔보겠습니다.

// switch 
int month = 8;
String monthString = "";
switch (month) {
    case 1:  monthString = "1월";
             break;
    case 2:  monthString = "2월";
             break;
    case 3:  monthString = "3월";
             break;
    case 4:  monthString = "4월";
             break;
    case 5:  monthString = "5월";
             break;
    case 6:  monthString = "6월";
             break;
    case 7:  monthString = "7월";
             break;
    case 8:  monthString = "8월"; 
             break;
    case 9:  monthString = "9월";
             break;
    case 10: monthString = "10월";
             break;
    case 11: monthString = "11월";
             break;
    case 12: monthString = "12월";
             break;
    default: monthString = "알수 없음";
}
System.out.println(monthString); // 8월 출력

// if 로 변환
if (month == 1) {
	monthString = "1월";
} else if (month == 2) {
	monthString = "2월";
} else if (month == 3) {
	monthString = "3월";
} else if (month == 4) {
	monthString = "4월";
} else if (month == 5) {
	monthString = "5월";
} else if (month == 6) {
	monthString = "6월";
} else if (month == 7) {
	monthString = "7월";
} else if (month == 8) {
	monthString = "8월";
} else if (month == 9) {
	monthString = "9월";
} else if (month == 10) {
	monthString = "10월";
} else if (month == 11) {
	monthString = "11월";
} else if (month == 12) {
	monthString = "12월";
} else {
	monthString = "알수 없음";
}
System.out.println(monthString); // 8월 출력

 

• 반복문 - for
  -  for  ( 초기값;   조건문;   증가연산)   { (연산) }  형태로 사용.
  - 특정 조건은 초기값과 조건문을 통해 정의.
  - 반복할 때마다 값을 증가시키려면 증가연산을 정의.
  - 초기값이 조건문을 만족할 때까지 (연산)을 수행하면서 회차마다 증가연산을 수행.

// for 문

for(int i=0; i < 4; i++) { // 변수 i 값은 0 ~ 3 까지 반복
    System.out.println(i + "번째 출력"); // i 변수와 문자열 합치기
}

// 출력
0번째 출력
1번째 출력
2번째 출력
3번째 출력

 

• 향상된 for문
  - for 소괄호 안에 값이 3개나 들어가기 때문에 이걸 2개로 줄여주는 방법.
  - 연속된 변수목록을 출력할 때 쓰임.
  -  for  (변수 타입   변수 명  :  목록변수)  { (연산) }  형태로 사용.
  - 변수 타입과 변수 명은 for 문 안에서 연산을 수행할 변수를 정의.
  - 목록변수는 값 여러 개를 하나의 변수로 저장하고 싶을 때 사용.

// 향상된 for 문

int[] numbers = {3,6,9,12,15};
for(int number: numbers) {
    System.out.print(number + " "); 
}

// 출력
3 6 9 12 15

////////////////////////

// 만약 기존 for 문으로 구현한다면?

int[] numbers = {3,6,9,12,15};
for(int i = 0; i < numbers.length; i++) { // 배열에 .length 를 붙이면 길이값이 응답됩니다.
    System.out.println(numbers[i]);
}

// 출력
3 6 9 12 15

 

• 반복문 - while문, do-while문
  - for문과 동일하게 특정 조건에 따라 연산을 반복해서 수행하고 싶을 때 사용하는 문맥.
  - 다만 초기값 없이 조건문만 명시하여 반복.
  -  while(조건문)   { (연산) }  형태로 사용(while문).
    ㄴ 위처럼 while문으로 사용하면 조건문을 만족해야지만 연산이 반복수행함.
    ㄴ 한번 반복할 때마다 조건문을 체크해서 조건문이 false이면 반복을 중단.
  -  do { (연산) }   while(조건문)  형태로 사용(do-while문).
    ㄴ 위처럼 do-while 문으로 사용하면 최초 1회 연산수행 후 조건문을 체크하여 더 반복할지 결정.
    ㄴ 반복하게 된다면 그 이후에는 한번 반복할 때마다 조건문을 체크해서 조건문이 false이면 반복을 중단.

// while 문

int number = 0;
while(number < 3) {
		number++;
    System.out.println(number + "출력"); 
}

// 출력
1출력
2출력
3출력

//////////////////////

// do-while 문

int number = 4;
do {
    System.out.println(number + "출력"); 
} while(number < 3); // 연산을 한번 수행 후 조건문 체크

// 출력
4출력

 

• break 명령
  - break; 명령을 호출하면 가장 가까운 블록의 for문 또는 while문, switch문을 중단.

// break 명령 범위

for (int i = 0; i < 10; i++) {
	System.out.println("i: " + i);
	if (i == 2) {
		break; // i 가 2일때 가장 바깥 반복문이 종료됩니다.
	}
	for (int j = 0; j < 10; j++) {
		System.out.println("j: " + j);
		if (j == 2) {
			break; // j 가 2일때 가장 안쪽 반복문이 종료됩니다.
		}
	}
}

// 출력
i: 0 // 바깥 반복문 부터 수행 시작
j: 0 // 안쪽 반복문 1회차 수행
j: 1
j: 2 // j 가 2일때 안쪽 반복문 break;
i: 1 // 바깥 반복문은 아직 break; 호출이 안됬으므로 다음 반복수행
j: 0 // 안쪽 반복문 2회차 수행
j: 1
j: 2 // j 가 2일때 안쪽 반복문 두번째 break;
i: 2 // i 가 2일때 바깥 반복문도 break; 호출되어 종료

 

• continue 명령
  - for문 또는 while문에서 해당 순서를 패스하고 싶을 때 continue 명령을 사용.

// continue 명령

int number = 0;
while(number < 3) {
		number++;
		if (number == 2) {
			continue;  // 2일때 반복 패스
		}
    System.out.println(number + "출력"); 
}

// 출력
1출력
3출력

 

• 조건문과 반복문을 활용한 구구단

// 구구단 생성기

for (int i = 2; i <= 9; i++) { // 구구단 첫번째 지수 i
	for (int j = 2; j <= 9; j++) { // 구구단 두번째 지수 j
		System.out.println(i + "곱하기" + j + "는" + (i * j) + "입니다.");
	}
}

// 출력
2곱하기2는4입니다.
2곱하기3는6입니다.
2곱하기4는8입니다.
... 중략 ...
9곱하기8는72입니다.
9곱하기9는81입니다.

/////////////////////////////

// 선택적 구구단 생성기

Scanner sc = new Scanner(System.in);
int passNum = sc.nextInt(); // 출력제외할 구구단수 값
for (int i = 2; i <= 9; i++) {
	if (i == passNum) {
		continue;
	}
	for (int j = 2; j <= 9; j++) {
		System.out.println(i + "곱하기" + j + "는" + (i * j) + "입니다.");
	}
}

// 입력
2

// 출력 - 입력값인 2단은 건너띄고 구구단 출력
3곱하기2는6입니다.
3곱하기3는9입니다.
3곱하기4는12입니다.
... 중략 ...
9곱하기8는72입니다.
9곱하기9는81입니다.

 

 

 

 

• 유지할 점
  - 파이썬과 다른 자바만의 문법들을 더 익히기.
  - 인텔리제이의 사용법을 더 익숙하게 만들기.