[JAVA] 주석, 함수, 변수, 식별자 작성규칙

자바 클래스명

• 첫문자는 대문자 -'syso' + ctrl + space = System.out.println();자동생성
  -'main' + ctrl + space = public static void main(String[] args) { }} 자동생성
  -콘솔 창 통해 결과 볼 수 있음 -메인으로 들어와서 (주석은 명령어가 아님. 보충설명 개념) System 명령어 읽음

주석

1. ctrl + / = 한 줄 라인 전체 주석 자동생성
ctrl + shift + c = 한 줄 라인 전체 주석 자동생성

2. Ctrl + Shift + / = 범위 주석 자동생성 but, 한 줄로 바뀜
해제 단축키 : Ctrl + Shift + |

=>주석 처리하고자 하는 범위의 문장 앞 뒤에 주석 기호를 둘러쌈
=>한 줄 또는 여러 줄에 걸친 주석 처리가 가능하며 주로 긴 문장의 설명을 작성하거나, 여러 줄에 코드를 주석 처리하는 용도로 사용
=> 단축키 : 원하는 라인 드래그 후 Ctrl+ + Shift + / --한줄로 바뀜, 해제 단축키 : Ctrl + Shift + | -- 해제해도 한줄 그대로. 그래서 잘 안씀
=>범위 주석 대신 사용 가능하며 특정 범위의 문장들을 블록 처리한 뒤 주석 처리시 각각 주석 처리
=> 해제 시에도 특점 범위 블록 지정 후 해제 가능

3. JavaDoc 주석 : /** 주석 처리할 문장 */
=> 일반적인 주석 처리 용도로는 사용하지 않고 자바 클래스 설명서를 작성하는 용도의 주석

*   이곳은 범위 주석 공간으로 
*   여러줄에 걸친 프로그램 설명을 작성하는 용도로 사용

4. 여러줄 주석(범위 주석) : /* 주석 처리할 문장 */

/**
 *  이곳은 JavaDoc 주석 공간으로
 *  자바 클래스 설명서를 제작하는 용도의 주석입니다.
*/

함수

변수 vs 상수

변수(Variable) : 데이터를 저장하는 메모리 공간
상수(Constant) : 항상 같은 값을 갖는 즉 변하지 않는 데이터
ex) 정수 5, 실수 3.14, 문자 'A', 문자열 "Hello, Java!" 등
=> 자바에서 사용하는 실제 데이터를 리터럴(Liternal) 이라고 함

자바에서 사용하는 데이터의 종류

1. 수치 데이터 - 정수형, 실수형, 문자형
2. 논리 데이터 - 참, 거짓 (True / False) 2가지
3. 문자열 데이터

public class Ex3 {

	public static void main(String[] args) {
		 
		System.out.println(1); //정수형 리터럴 -- 변하지 않는다
		System.out.println(3.14); //실수형 리터럴
		System.out.println('A'); // 문자형 리터럴 >> 문자 --문자 하나는 작은 따옴표로 묶기
		System.out.println(true); //논리형 리터럴 >> 참 --소문자
		System.out.println(false); //논리형 리터럴 >> 거짓	
		System.out.println(5L); //정수형(long형) 리터럴 => 접미사 L 붙임 --대문자L
		System.out.println(1.5f); //실수형(float형) 리터럴 => 접미사 F(f) 붙임 -- 주로 소문자f
		System.out.println("Hello, World!"); //문자열형(String) 리터럴
	}

}

변수(Variable)            

-데이터를 저장하는 메모리 공간                           
-변수 공간에는 한 번에 하나의 데이터만 저장 가능하며,             
새로운 데이터를 저장하면 기존의 데이터는 제거됨                  
-변수를 사용하기 위해서는 반드시 변수를 선언한 후에 저장 가능         
-데이터를 저장하는 작업을 변수의 초기화라고 함                  
=> 변수 초기화 작업 없이 변수 사용 불가능                   
-변수명을 작성할 때는 식별자 작성 규칙 따름 (무조건, 선택사항)       
                                            
< 변수 선언 기본 문법 >
데이터타입 변수명;                                  
                                            
< 변수 초기화 기본 문법 >                            
변수명 = 데이터; --대입연산자. 오른쪽 데이터를 왼쪽 변수에 집어넣음    
                                            
                                            
< 변수 사용법 >                                  
변수 사용을 위해서는 특정 작업에 변수명을 지정하면,               
해당된 변수에 지정된 값을 사용할 수 있다!            

//변수 선언 --데이터타입 변수명;
int a;  // int형(정수형) 데이터를 저장할 공간을 생성하고,
        // 이름을 a로 지정

//변수 초기화
a = 10; //int형 변수 a에 정수형 데이터(리터럴) 10을 저장(대입)
// => 주의! 변수 선언 없이 초기화 또는 접근 시 오류 발생함! -- 변수 선언 후 값 초기화 해야함
//		(a cannot be resolved to a variable)

System.out.println(a);
System.out.println('a');

데이터 타입을 정수형으로 했는데 실수를 넣으면 오류 → 데이터타입을 맞춰줌

식별자 작성 규칙

< 필수 >                                                                    
1. 첫 글자는 숫자 사용 불가                                                         
2. 특수문자는 $(달러) 또는 _(언더스코어)만 사용 가능                                         
3. 대소문자 구별                                                                
4. 키워드(예약어) 사용 불가                                                         
5. 공백 사용 불가                                                               

< 권장사항 >                                                                  
6. 의미가 있는 단어 사용                                                           
7. 변수명의 첫 단어는 소문자로 작성 --클래스명은 첫글자 대문자, 변수명은 첫글자 소문자(대문자 해도되긴함)            
  복합명사일 경우 두번째 단어부터는 첫글자를 모두 대문자로 작성                                    
=> Camel-case 표기법 사용                                                
ex)변수명 = studentName                                                
참고) 클래스명은 첫 단어의 첫글자를 대문자 표기                                         
=> Pascal-case 표기법                                                  
ex) 클래스명 = StudentName                                              
8. 길이 제한 없음                                                               
9. 한글 사용 가능하지만, 사용하지 않음           

// 1. 첫 글자는 숫자 사용 불가 int 7eleven; //사용불가                 
// => Invalid float literal number                       
		int sevenEleven;                                 
		                                                 
// 2. 특수문자는 $(달러) 또는 _(언더스코어)만 사용 가능                     
int $system; //사용 가능                                     
int my_name; //사용 가능                                     
int channel#5; // 사용 불가($ 또는_만 사용가능)                     
                                                         
//=> Syntax error on token "Invalid Character", = expecte
// 3. 대소문자 구별                                            
int age; //소문자 age와                                      
int AGE; //대문자 AGE는 다른 식별자로 취급됨                          
                                                         
// 4. 키워드(예약어) 사용 불가                                     
int int;                                                 
//키워드 int 사용불가                                           
int switch; //키워드 switch 사용불가 int char; //키워드 char 사용불가  
                                                         
// 5. 공백 사용 불가                                           
int my name; //사용 불가 -my만 인식, name에 데이터타입이 없다고 생각        
int my, name; // int형 변수 my와 int형 변수 name을 동시에 선언        
                                                         
//6. 한글 사용 가능(하지만 병수명으로 사용하지 않음)                         
int 나이;                                                  
*/                                                       
		                                                 
/*                                                       
* 데이터타입(Data Type) = 자료형                                 
* - 사용할 데이터의 종류를 구분해 놓은 것                                
* - 기본 데이터 타입(Primitive Type = 기본형)                      
*   참조 데이터 타입(Reference Type= 참조형)

bit

-0 또는 1이 들어갈 수 있는 공간 -컴에서 사용하는 최소 단위 -1byte = 8bit

	1Byte(8bit)	2Byte(16bit)	4Byte(32bit)	8Byte(64bit)
논리형	boolean(1byte)
정수형	byte(1byte)	short(2byte)	int(4byte)	long (8byte)
실수형			float(4byte)	double(8byte)
문자형		char(2byte)

<정수형 데이터타입 표현 범위>                                       
메모리 크기에 따라 표현 가능한 정수의 범위가 달라짐                           
byte(1Byte = 8bit) : 2^8 = 256 = -128 ~ +127            
hort(2Byte = 16bit) : 2^16 = 65536 = 32768 ~ +32767     
int(4Byte = 32bit) : 2^32 = 약 -21억 ~ 약 +21억⇒ 정수의 기본형태   
long(8Byte = 64bit) : 2^64 = 약-922경~ +922경

<변수 선언 및 초기화를 동시에 수행하는 방법>

데이터타입 변수명 = 데이터;

 

// byte 타입 변수 b 선언                                                             
// 변수 선언 방법 :  데이터타입 변수명;                                                      
byte b;                                                                        
//byte 타입 변수 b에 정수 100 저장                                                      
// 변수의 초기화: 변수명= 데이터                                                           
b = 100;                                                                       
                                                                               
//위의 두 문장(선언 및 초기화)을 한 문장으로 결합                                                 
byte b=100;                                                                    
                                                                               
//byte 타입 변수 b의 값을 화면에 출력                                                      
System.out.println(b);                                                         
                                                                               
b=127;                                                                         
b=128; // 오류 발생 -- byte 타입에 표현 가능한 정수 범위는 -128~127                             
//Type mismatch : cannot convert from int to byte                              
b=-128;                                                                        
System.out.println(b);                                                         
                                                                               
//short 타입 변수 s르 선언하고 정수 128 저장                                                
short s=128;                                                                   
System.out.println(s);                                                         
                                                                               
s=32767;                                                                       
s=32768;                                                                       
// => 오류발생 --short 타입 저장 가능한 수 -32768 ~ +32767                                 
                                                                               
//int형 변수 i를 선언하고 정수 32768 저장 후 출력 --short보다 저장 가능한 수가 더 많다.                   
int i = 32768;                                                                 
System.out.println(i);                                                         
                                                                               
i=2147483647;                                                                  
i=2147483648; //표현 가능한 범위의 1만 커도 오류 발생                                         
                                                                               
long l = 2147483648;                                                           
// => The literal 2147483648 of type int is out of range                       
// => 정수에 접미사(L)가 없으면 기본적으로 int형의 기본 범위를 사용                                    
// 최대치가 2147483648 까지만 표기 가능                                                   
// => int 범위를 벗어나는 리터럴은 반드시 접미사 'L'을 붙여서	                                   
//		long 타입으로 표기해야한다.                                                      
long l = 2147483648L; //접미사 'L'을 붙여서 오류 방지                                     
                                                                               
//i = 2147483648L; // int i를 변수 선언을 미리 했고, 데이터타입은 long 타입이라 미스매치               
// => Type mismatch : cannot convert from long to int                          
// => 오류 발생 --long 타입 정수는 int ㅍ일 변수에 저장할 수 없음. 즉, 양쪽의 타입이 같아야함                 
                                                                               
//long 타입 리터럴은 접미사 L을 붙이면 되는데                                                  
//int 타입보다 크지 않은 정수도 L을 붙이면 long 타입으로 취급됨                                      
i=5; //오류발생x                                                                   
i = 5L; //오류발생o                                                                
// => 정수 5는 int 범위에 포함되지만, L을 붙이면 저장 불가                                        
                                                                               
//실수 데이터타입                                                                     
double d = 3.14; //실수형 데이터타입(double) 변수 d에 3.14 초기화                            
float f = 3.14; //오류 발생                                                        
// => 접미사가 없으면 double 타입으로 인식되므로 float 타입 변수 저장 불가                             
float f = 3.14f;                                                               
System.out.println(d);                                                         
System.out.println(f);                                                         
                                                                               
//논리형 데이터타입                                                                    
//boolean 데이터타입 : 특수한 값인 true 또는 false만 사용 가능                                  
boolean bool = true;                                                           
boolean bool = 1; //타입이 다른 값을 넣으려고 하면 오류 발생 --true/false만 가능                   
System.out.println(bool);                                                      
bool = false;                                                                  
System.out.println(bool);