2장_자바 기본 프로그래밍

메소드

//main( )을 포함한 모든 메소드(함수)는 클래스 내부에 설계되어야 한다.

public class MethodTest {
	public static int getPlus(int x) { //메소드 정의 : (형식) 매개변수 
    	// static 추가
		// 중괄호 안은 메모리가 허용되는 공간으로
        // 연산이 끝나면 메모리에서 사라짐
        // 따라서 그 메모리가 사라지기 전
        // 리턴 데이터 타입 int 공간에 복사해서 return 해줌.
		int y;				// 지역 변수는 메소드 실행이 끝나면 자동 소멸
		y = 3 * x + 2;
		return y;
	}
	
	public static void main(String[] args) { 
		// TODO Auto-generated method stub
		// 객체 생성 및 ob 참조 변수로 관리
		// MethodTest ob = new MethodTest();
        // -> static 추가시
        // MethodTest 객체를 생성하지 않아도 바로 getPlus 메소드 호출 가능
		
        int test;
		// 메소드 호출 : 인자(argument) or 실 매개변수
		// test = ob.getPlus(3);
		test = getPlus(3); //같은 공간에 있기 떄문에 동적 메모리 사용하지 않고 바로 실행 가능
		System.out.println(test);
	}
}

식별자

• 식별자 : 클래스, 변수, 상수, 메소드 등에 붙이는 이름
  • 특수문자, 탭은 식별자로 사용 불가, '_', '$' 는 사용가능
  • 유니코드 문자 사용 가능, 한글 사용 가능(잘 사용x)
  • 자바 언어의 키워드는 식별자로 사용 x
  • 식별자의 첫 번째 문자는 숫자로 사용 불가
  • 길이 제한 없음

자바의 데이터 타입

• 기본 데이터 타입 8개

  • boolean
  • char : 2byte (JAVA의 문자를 매핑 → 유니코드, C++ → ASCII)
  • byte : 1byte (자바의 char가 2byte인 관계로, 추가된 데이터 타입)
  • short : 2byte
  • int : 4byte
  • long : 8byte
  • float : 4byte
  • double : 8byte

• 레퍼런스 타입 3개

  • 클래스(class)에 대한 레퍼런스(참조)
  • 인터페이스(interface)에 대한 레퍼런스(참조)
  • 배열(array)에 대한 레퍼런스(참조)

String

• 문자열은 기본 데이터 타입이 아니다, 따로 String 클래스 제공

• String 클래스로 문자열 표현

  • 문자열 리터럴 = “JDK”, “한글”, “계속하세요”

  • 문자열이 섞인 + 연산 -> '문자열'

    public class TestStr {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		String toolName = "JDK";
    		System.out.println(toolName);
    		
    		//toolName + "1.8"; -> 그냥 쓰면 오류난다. 
    		//따라서 1.8 이 실수이지만 문자열과 연결하기 위해 println 에 포함시켜줌.
    		//여기는 toolName 에 할당되는것이 아니라 1.8 이라는 새로운 문장이 메모리에 만들어져 출력된다.
    		System.out.println(toolName + "1.8");
    		
    		//원래는 연결이 안되지만 덧셈을 연결 연산자로 수행하여 문자열이 된다. 
    		//새로 만들어진 toolName 의 해시코드 값이 할당 
    		toolName = toolName + 1.8;
    		System.out.println(toolName);
    	}
    }
    //result
    //JDK
    //JDK1.8
    //JDK1.8

리터럴

실세계 상수는 리터럴
자바에서 실수 즉 값을 변경하지 않도록 하는 키워드 final

int a = 3; 
final char ch = 'A';

⏹ 정수 리터럴

• 8진수 : 0으로 시작하는 숫자
  • int n = 015; //10진수로 13 ($8^{0} \times 5 + 8^{1} \times 1 = 15$)
• 16진수 : 0x로 시작하는 숫자
  • int n = 0x15; // 10진수로 21
• 10진수 : 0으로 시작하지 않는 숫자
  • int n = 23;
• 2진수 : 0b로 시작 (참조 : 자바는 2진수 입력이 가능)
  • int n = 0b0101; // 2진수 0101 → 10진수 5 할당됨

• 모든 정수타입 리터럴은 int 형으로 컴파일 한다

  • long 타입 리터럴은 숫자 뒤에 L 또는 l 을 붙인다.
    ex) 24L, 3578l

⏹ 실수 리터럴

• 소수점 형태나 지수(exponent)식으로 표현한 실수

  • 부동 소수점 : 1.23 또는 12.43 또는 0.012
  • 지수 형태 : 1.23e+00 또는 1.243e+01 또는 1.2e-2 = 1.2x10-2

• 숫자 뒤에 f(float)나 d(double)을 명시적으로 붙이기도 함

  • 0.1234 또는 0.1234D 또는 0.1234d → double 타입
  • 0.1234f 또는 0.1234F → float 타입
  • 1234D 또는 1234d → 1234.0과 같으며 double 타입
  • 1234F 또는 1234f → 1234.0과 같으며 float 타입

• 실수 리터럴 연산: double 타입으로 컴파일 되고 연산 (default)

⏹ 문자 리터럴

문자 한 자를 나타낸다.

• 단일 인용부호(' ') 로 문자 하나 표현 char a = 'a'

• \ 다음에 숫자는 8진수로서 0~337사이의 8진수만 가능

  • \102 -> 문자 ‘B’를 나타내는 8진수
  • \337 -> 문자 ‘β’를 나타내는 8진수

• \u 다음에 4자리 16진수, 2바이트의 유니코드

  • char c = \u0041; // 문자 'A'의 유니코드(0041)
  • char d = \uae00; // 한글문자 '글'의 유니코드(ae00)

• 특수기호는 \ 로 시작

  • 종류	의미	종류	의미
    '\b'	백스페이스	'\r'	캐리지 리턴
    '\t'	탭	'\"'	이중 인용부호
    '\n'	라인피드	'\''	단일 인용부호 (백슬래스 다음은 단순 문자열로 해석)
    '\f'	폼피드	'\'	백슬래시

⏹ 논리 리터럴

• true 또는 false 뿐
• boolean 타입 변수에 치환하거나 조건문에 사용

• boolean a = true;
   boolean b = 10 > 0; // 10>0가 참이므로 b 값은 true
   boolean c = 1; // 타입 불일치 오류
   // C/C++와 달리 자바에서 1 or 0을 참 or 거짓으로 사용 불가
   while(true) { // 무한 루프. while(1)로 사용하면 안 됨(C, C++ 스타일) ...
   }

기본 데이터 타입 이외 리터럴

⏹ null 리터럴

• 어떠한 레퍼런스 타입의 값으로도 사용 가능

• int n = null;(사용불가) //기본 데이터 타입에는 사용 불가
   String str = null;
   Grade kim = null; kim = new Grade

• Null 과 Zero(" ") 의 차이
  • Null : 휴지 자체가 없는 것
  • Zero : 휴지를 다 쓰고 휴지 심만 있는 상태

⏹ 문자열 리터럴

• 이중 인용부호로 묶어서 표현 : "Good", "Morning", "자바", "3.19", "26", "a"

• 자바에서 문자열은 객체이므로 기본 타입이 아님 → String 클래스 제공됨

• 문자열 리터럴은 String 객체로 자동 처리

• String str1 = "Welcome"; 
   String str2 = null; 
   System.out.println(str1);

Tip1 - 숫자 리터럴의 아무 위치에나 언더스코어(‘_’) 허용

컴파일러는 리터럴에서 ‘_’를 빼고 처리 -> 가독성을 높임

int price = 20_100; // 20100과 동일
long cardNumber = 1234_5678_1357_9998L; // 1234567813579998L와 같음
int age = 2______5; // 25와 동일

허용되지 않은 4가지 경우

int x = 15_; // 오류. 리터럴 끝에 사용할 수 없다.
double pi = 3_.14; // 오류. 소수점(.) 앞뒤에 사용할 수 없다.
long idNum = 981231_1234567_L; // 오류. _L(_F) 앞에 사용할 수 없다.
int y = 0_x15; // 오류. 0x 중간이나 끝에 사용할 수 없다. 0x_15(오류)

Tip2 - var 키워드를 사용하여 변수 타입 생략

• var 키워드
  • 지역 변수의 선언에만 사용
  • 변수 타입 선언 생략 : 컴파일러가 변수 타입 추론

var price = 200; 	//price 는 int 타입 결정
var name = "kitae"; 	//name 은 String 타입으로 결정
var pi = 3.14; 	//pi는 double 타입으로 결정
var point = new Point(); 	//point 는 Point 타입으로 결정
var v = new Vector<Integer>();	//v는 Vetor<integer> 타입으로 결정

• 변수 선언문에 반드시 초깃값 지정

var name;  //컴파일 오류. 변수 name 의 타입을 추론할 수 없음

타입 변환

⏹ 자동 타입 변환

// 25는 int(4byte) 타입. 컴파일러에 의해 
// 25가 long(8vyte) 타입으로 자동 변환되는 사례, 25L 로 수정한다. (정보손실 방지를 위해)
long m = 25; 

// 실수 연산을 하기 위해 10이 10.0으로 자동 변환
double d = 3.14 * 10; 

⏹ 강제 타입 변환

// 자동 타입 변환이 안 되는 경우 : 큰 타입이 작은 타입으로 변환할 때

int n = 300;
byte b = n; //컴파일오류.int 타입이 byte(1byte)로 자동변환 안됨

// 강제 타입 변환 : () 안에 변환할 타입 지정

double d = 1.9; 
int n = (int)d;  //n=1

자바의 IO

• 자바의 기본적인 데이터 입출력 API 는 java.io 패키지에서 제공하고 있다.
• 바이트 단위 입출력을 위한 최상위 입출력 스트림 클래스
  • 입력 스트림, 출력 스트림
• 스트림(정보)의 2가지 종류 (스트림 : 실제로는 0과 1로 된 정보)
  • 바이트 기반 스트림 : 그림, 멀티미디어, 문자 등 모든 종류의 데이트를 주고 받음.
  • 문자 기반 스트림 : 아스키 코드나 유니코드를 기준으로 정보를 읽고 해석,
    즉 문자만 해석 가능 -> Reader, Writer

⏹ Console 입 출력

• 자바에서 System.in 은 표준 입력 스트림으로서, System 클래스의 in 정적 필드를 사용해 콘솔로부터 데이터를 입력받는다.
• 읽은 키의 값은 바이트 데이터로 리턴
  • Stream.in 의 문제점 : 바이트 데이터를 문자 정보로 변환해서 사용해야한다.
  • System.in 은 입력 스트림 타입의 필드이기 때문에 다음과 같이 InputStream 변수 is 로 참조 가능
  • InputStream is = System.in;

⏹ 보조 스트림 : InputStreamReader

• 보조 스트림 : '입력 스트림' 은 0과 1로 된 데이터 이므로 곧바로 '프로그램'에서 사용할 수 없음
  • 스트림이 해당 역할을 수행할 수 있게 "문자/이미지/영상 등" 으로 변경 후 제공 또는 반대의 기능을 제공하는 스트림
• 보조 스트림은 자체적으로 입출력을 수행할 수 없기 떄문에
• 입력 소스와 바로 연결되는 InputStream, FileInputStream, Reader, FileReader
• 출력 소스와 바로 연결되는 OutputStream, FileOutputStream, Writer, FileWriter 등 연결해서 입출력 수행.

  • //보조 스트림 생성시 자신이 연결될 스트림을 다음과 같이 생성자의 매개 밗으로 받는다.
    보조 스트림 변수 = new 보조 스트림(연결 스트림)
    //
    //'콘솔 입력 스트림'을 '문자 변환 보조 스트림' 인 InputStreamReader 에 연결하는 코드
    InputStream is = System.in //System.in 은 바이트로 된 정보
    InputStreamReader reader = new InputStreamReader(is);
    //시스템으로 들어온것(is)은 0과 1로 된것이라 reader 를 통해 문자로 변환시켜줌

• Reader : 문자 입력 보조 스트림
  • InputStream 으로 전달되는 바이트 정보를. '문자 입력 스트림'인 Reader 를 이용하여 문자로 변환시키는 보조 스트림
    

Scanner 클래스

• 기존의 java.io 패키지의 클래스들을 이용하면 문자열" 은 입/출력이 가능하지만 기본 타입(정수, 실수 등)값을 바로 읽을 수 없다.
• java.util 패키지의 Scanner 클래스를 이용해야 한다.
• System.in 으로 읽어들인 바이트 데이터를 문자, 정수, 실수, Boolean, 문자열 등 타입으로 변환

  • //Scanner 객체 생성
    import java.util.Scanner; 
    Scanner a = new Scanner(System.in); // Scanner 객체 생성, 참조 변수 a

    //Scanner 에서 키 입력 받기
    //Scanner는 키 입력을 공백으로 구분된 토큰 단위로 버퍼에 보관되어있던 정보들을 끊어서 읽는다.
    '\t','\f','\r','\n',' '

    

    import java.util.Scanner; //Scanner 사용을 위해 반드시 추가
     public class ScannerEx {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		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 weight = scanner.nextDouble(); //실수 읽기
    		System.out.print("체중은 " + weight + ", ");
    	 
    		boolean single = scanner.nextBoolean(); //논리값 읽기
    		System.out.print("독신 여부는 " + single + ", ");
      
        	System.out.println(age+(int)weight); //결과값 85 나옴.
    	
    		scanner.close(); //scanner 닫기 (메모리 해지)
    	}
    }
    //result
    //이름, 도시, 나이, 체중, 독신 여부를 빈칸으로 분리하여 입력
    //Kim Seoul 20 65.1 true
    //이름은 Kim, 도시는 Seoul, 나이는 20, 체중은 65.1, 독신 여부는 true
    //만약 Kim 만 입력하고 Enter 치면 Scanner 에 보관된 정보가 Kim 뿐이므로
    //Kim 만 출력

식과 연산자

• 연산 : 주어진 식을 계산하여 결과를 얻어내는 과정

⏹ 연산자 우선순위

• 같은 우선순위 연산자
  • 왼쪽에서 오른쪽으로 처리
  • 예외) 대입 연산자, --, ++, ! 형 변환은 오른쪽에서 왼쪽
• 괄호는 최우선순위
  • 괄호가 다시 괄호를 포함한 경우는 가장 안쪽 괄호부터 먼저 처리
• 연산자

⏹ 증감 연산

a = 1;
b = ++a;
b = a++;

• 둘다 a = a + 1 // 단독으로 사용될떄는 동일한 수식
  • ++a : a 값을 먼저 증가시켜주고 증가된 2 를 b 에 대입
  • a++ : a 부터 생각을 해서 ++ 이 적용되기 전 a=1 이라는 값을 먼저 b에 넣고 그 줄의 연산을 벗어나면 a=2

⏹ 논리 연산

• !a : true false 반전
• a ^ b : 같으면 false, 다르면 true
• a || b : 하나라도 true 이면 true
• a && b : 둘다 true 이면 true

⏹ 비교 연산

• 20 <= age < 30 // 오류

⏹ 비트 연산

• 비트 논리 연산 : 비트끼리 AND, OR, XOR, NOT 연산
  

• 비트 시프트 연산 : 비트를 오른쪽이나 왼쪽으로 이동
  

왼쪽 shift(<<)

• 부호와 관계 없이 비트 값들을 왼쪽으로 이동시킨 후에 오른쪽의 빈 공간에는 모두 0으로 채운다.
• $(a = 5)$ $\times$ $2^{n=2}$ = $20(b)$
  

오른쪽 shift(>>)

• 비트 값들을 오른쪽으로 이동시킨 후에 왼쪽 빈 공간에는
• 양수는 모두 0 으로, 음수는 모두 1 로 채운다
• $(a = 20)$ $\times$ $(\frac{1}{2})^{n=2}$ = $5(b)$
• $(a = -8)$ $\times$ $(\frac{1}{2})^{n=2}$ = $-2$
  

오른쪽 shift (>>>)

• 비트 값들을 오른쪽으로 이동시킨 후에 왼쪽 빈 공간은 모두 0 으로 채운다
  

부호 절댓값 방식

(최상위 비트 0일때 양수, 1일때 음수)
2진수 00000011 = 10진수 3
2진수 10000011 = 10진수 -3

1의 보수 방식

(13 을 2진수로 바꾼뒤 비트를 반전시키기)
-13 을 1의 보수 방식으로 표현하기
13 을 2진수로 바꾸기 : 00001101
이것을 11111111 - x 에 대입
11111111 - 00001101 = 11110010 (1의 보수로써 -13)

2의 보수 방식

(13 을 2진수로 바꾼뒤 비트를 반전시켜 + 1을 한 결과값)
13을 2진수로 바꾸기 : 00001101
100000000 - x 에 대입
100000000 - 00001101 = 11110011 (2의 보수로써 -13)

public class BitOperator {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		short a = (short)0x55ff;  //0x : 16진수 의미
		short b = (short)0x00ff;
		//비트 논리 연산 
		System.out.println("Bitwise Operation Results]");
        // 2진수로 보관되어있는 a와 b를 비트연산
        //5500 가 정수가 아닌 16진수임을 나타내기 위해서 % 와 x 사이에 # 추가
		System.out.printf("%#04x\n", (short)(a & b));  //%x->ff 라고 나옴, 값이 없기 떄문
		System.out.printf("%#04x\n", (short)(a | b)); //%04x 라 하면 ff 앞에 두자리 0으로 
		System.out.printf("%#04x\n", (short)(a ^ b)); //채우므로 따라서 총 4자리 확보
		System.out.printf("%#04x\n", (short)(~a));
		
		byte c = 20; //0x14
		byte d = -8; //0xf8
		
		//비트 시프트 연산 
		System.out.println("[Shift Operation Results]");
		System.out.println(c << 2); //c를 2비트 왼쪽 시프트 
		System.out.println(c >> 2); //c를 2비트 오른쪽 시프트. 0삽입(양수)
		System.out.println(d >> 2); //d를 2비트 오른쪽 시프트. 1삽입(음수)
		System.out.printf("%x\n", (d >>> 2));
	}
}
//result
//Bitwise Operation Results
//0xff
//0x55ff
//0x5500
//0xaa00
//[Shift Operation Results]
//80
//5
//-2
//3ffffffe

조건문

⏹ if 문

if(조건식) {
	실행문장
}

⏹ if-else 문

if(조건식) {
	실행문장1
}
else {
	실행문장2
}

⏹ 다중 if-else 문

if(조건식1) {
	실행문장1
}

...

else if(조건식 m) {
	실행문장 m
}
else {
	실행문장 n
}

⏹ switch 문

//switch 문에서는 {} 반드시 쓰기
switch(식) { //식은 문자, 정수, 문자열 리터럴 사용 가능 (실수 리터럴 불가)
	case 값 1:
    	실행 문장 1;
        break; //break 문을 만나면 switch 문을 벗어남
        
    ...
    
    case 값 m:
    	실행 문장 m;
        break;
    default:
    	실행문장 n; //default 에도 break 가 있어야 되는데 마지막 문장이기 떄문에 생략
}