'전체 글'에 해당되는 글 384건
############### 필드 ##################
클래스를 벗어난 부분은 모두 필드임.(위나 아래나 동일)
필드 : 클래스에서 필요한 속성값
field 만들기
점점 정보들을 은닉화한다.(숨긴다) 외부에 공개되는 클래스는 극히 드문 추세(은닉화)
특히 필드들의 경우 '절대로' 직접 입력 출력을 할 수 없게 만들어준다.
인캡슐라이제이션 -> 메소드들을 필드마다 만들어서
getter, setter 만들어주기
getter : 필드의 값을 반환한다.
setter : 파라미터의 값을 필드에 저장한다.
빈칸에서 우측버튼 - source - generate getter, setter
############### this ##################
자기 자신을 참조하는 객체(만들어진 객체 자신)
static 메소드가 아니라면 0번째 매개변수로 자신을 참조하는 this가 있다고 보면 된다.
필드, 메소드는 점(.)으로 접근
this를 사용해야 하는 경우 : 매개변수명과 멤버변수의 필드명이 동일할 경우 this를 사용하지 않으면 원하는 결과를 얻지 못할 수 있다.
############### 메소드 ##################
메소드는 프로그래머가 준 값(파라미터, 인수)을 재료로 어떤 행동을 하고, 그 결과(리턴값, 반환값)로 생긴 것을 돌려주는 처리상자.
메소드는 코드를 재사용할 수 있게 해준다.(★재활용, 코드량 줄일수있음, 유지보수 유리) -> 가치를 높이는 것
메소드 : 기능을 수행하는 함수
main : 자바와 개발자간의 약속(규칙) -> 자바는 main 메소드를 실행함.
############### 매개변수(parameter)와 인자(argument) ##################
public static void numbering(int limit){
매개변수
}
public static void main(String[] args){
numbering(5)
인자
}
메소드의 입력 값은 매개변수(parameter)를 통해서 이루어진다.
매개변수와 인자값은 콤마(,)로 구분.
메소드는 접근제한자 method의리턴타입 이름(파라미터) 로 선언한다.
접근제한자: public, protected, private (외부;다른 클래스 의 접근을 제한함)
public: 어디서든 접근 가능
protected: 같은 패키지 내부에서만 접근 가능
private: 외부면 어디서든 접근 불가. 같은 클래스 내부에서만 사용이 가능.
메소드의 이름들은 똑같을 수 있다.
!!!!!!!!단!!!!!!!!
메소드의 파라미터의 종류와 갯수가 같으면 파라미터의 이름, return type과는 무관하게
중복된 메소드로 판정되어서 만들 수 없다.
즉 메소드의 이름이 같을려면 parameter의 data type이 다르거나 갯수가 달라야만한다.
클래스와 이름이 똑같은 메소드가 있다.
그 메소드는 생성자(Constructor)이다.
우리가 특별히 만들지 않아도 기본생성자라는 것이 존재하는데
우리의 필드값들을 각 데이터타입의 기본값으로 초기화해준다.
생성자에는 2가지 종류가 있다.
파라미터가 있는 생성자 vs 아무 파라미터도 없는 기본생성자
"하지만" 파라미터가 있는 생성자를 만들면 기본생성자를 재정의 하지 않으면 기본생성자는 사용을 할 수 없다!
기본 생성자의 경우에는 정의해줄 시에는 이게 기본 생성자로 생성되었다는 것을 알 수 있게 field값들을 넣어준다.
예시 -> Scanner
파라미터가 있는 생성자 만들기
Student(String name, String juminNum, int kor, int eng, int math) {
this.name = name;
this.juminNum = juminNum;
this.kor = kor;
this.eng = eng;
this.math = math;
}
Student() {
this.name = "입력 아직 안됨";
this.juminNum = "입력 아직 안됨";
this.kor = 0;
this.eng = 0;
this.math = 0;
}
############### 메소드의 정의와 호출 ##################
<예시>
int plus(int a, int b){ 정수값을 리턴값으로 담는 plus라는 메소드를 선언하고, a와 b라는 파라미터 변수를 인자로 받는다.
-> 메소드명 옆 ( ) 안에 필요한 파라미터를 적음. 파라미터 역시 변수이므로 데이터 타입과 변수명을 함께 적음
* 메소드를 클래스 내에서 호출할 때는 메소드 이름으로 바로 호출하고,
밖에서 호출 할때는 '객체.메소드명()' 을 작성하여 호출한다.
System.out.println(calc.plus(1,3));
############### return ##################
return : 결과값. return 뒤에 오는 값을 메소드 외부로 출력함. 동시에 메소드를 종료시킨다.
한가지 잊지 말아야 할 점은 return을 통해서 반환할 값의 데이터 형식을 메소드의 이름 옆에 명시해주어야 한다는 것이다.
output +=i ;
output = output + i ;
위 2개는 같은 의미.
자바는 붕어빵만드는 기계는 준비되어있고, 재료만 바꿔주면 됨.
static :
같은 클래스에서 생성된 객체들과 값을 공유하는 키워드. 공유공간.
static 필드는 생성자에서 초기화할 수 없다.
프로그램 시작시 제일먼저 시스템영역 메모리 불러온다. 메소드는 클래스변수를 곧장 가져가서 쓸것
응용프로그램 실행순서(static{...} -> main() -> 생성자() -> finalize())
void :
공허(비어있다) -> return 해줄 필요없을때, 반환 값이 없을때.
parameter :
필요한 값, 입력값
메소드는 여러개의 입력 값을 가질수있다.
그렇다면 복수의 리턴? -> 배열을 통하여 가능하다.
new를 써서 공간확보후 초기화해야함.
자동생성시 이름에 자동으로 2 붙을경우 수정해서 사용하면 됨.
1. 별의 갯수와 줄의 갯수 상관관계 파악
2. i는 줄의 수
3. lineNum, print 를 활용
4. 공백을 담당하는 j for문 따로!
5. 축구에서 후반 70분 = 후반 35분 개념!
import java.util.Scanner;
public class star {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.print("출력할 줄 수를 입력하세요: ");
int lineNum = scan.nextInt();
System.out.println("==별찍기 1번==");
for (int i = 1; i <= lineNum; i++) {
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
System.out.println();
}
System.out.println("==별찍기 2번==");
for (int i = 1; i <= lineNum; i++) {
for (int j = i; j <= lineNum; j++) {
System.out.print("*");
}
System.out.println();
}
System.out.println("==별찍기 3번==");
for (int i = 1; i <= lineNum; i++) {
for (int j = lineNum - 1; j >= i; j--) {
System.out.print(" ");
}
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
System.out.println();
}
System.out.println("==별찍기 4번==");
for (int i = 1; i <= lineNum; i++) {
for (int j = 1; j <= i - 1; j++) {
System.out.print(" ");
}
for (int j = i; j <= lineNum; j++) {
System.out.print("*");
}
System.out.println();
}
System.out.println("==별찍기 5번==");
for (int i = 1; i <= lineNum; i++) {
for (int j = i; j <= lineNum - 1; j++) {
System.out.print(" ");
}
for (int j = 1; j <= 2 * i - 1; j++) {
System.out.print("*");
}
System.out.println();
}
System.out.println("==별찍기 6번==");
for (int i = lineNum; i >= 1; i--) {
for (int j = i; j <= lineNum - 1; j++) {
System.out.print(" ");
}
for (int j = 1; j <= 2 * i - 1; j++) {
System.out.print("*");
}
System.out.println();
}
System.out.println("==별찍기 7번==");
for (int i = 1; i <= 2 * lineNum - 1; i++) {
if (i <= lineNum) {
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
} else {
int newLineNum = i - lineNum;
for (int j = lineNum - 1; j >= newLineNum; j--) {
System.out.print("*");
}
}
System.out.println();
}
System.out.println("==별찍기 8번==");
for (int i = 1; i <= 2 * lineNum - 1; i++) {
if (i <= lineNum) {
for (int j = lineNum - 1; j >= i; j--) {
System.out.print(" ");
}
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
} else {
int newLineNum = i - lineNum;
for (int j = 1; j <= newLineNum; j++) {
System.out.print(" ");
}
for (int j = lineNum - 1; j >= newLineNum; j--) {
System.out.print("*");
}
}
System.out.println();
}
System.out.println("==별찍기 9번==");
for (int i = 1; i <= 2 * lineNum - 1; i++) {
if (i <= lineNum) {
for (int j = lineNum - 1; j >= i; j--) {
System.out.print(" ");
}
for (int j = 1; j <= 2 * i - 1; j++) {
System.out.print("*");
}
} else {
int newLineNum = i - lineNum;
for (int j = 1; j <= newLineNum; j++) {
System.out.print(" ");
}
for (int j = 2 * (lineNum) - 2 * (newLineNum) - 1; j >= 1; j--) {
System.out.print("*");
}
}
System.out.println();
}
System.out.println("==별찍기 10번==");
for (int i = 1; i <= 2 * lineNum - 1; i++) {
if (i == 1 || i == 2 * lineNum - 1) {
for (int j = 1; j <= 2 * lineNum - 1; j++) {
System.out.print("*");
}
} else if (i <= lineNum) {
int topLine = i - 1;
for (int j = 1; j <= lineNum - topLine; j++) {
System.out.print("*");
}
for (int j = 1; j <= 2 * topLine - 1; j++) {
System.out.print(" ");
}
for (int j = 1; j <= lineNum - topLine; j++) {
System.out.print("*");
}
} else {
int lowerNum = i - lineNum + 1;
for (int j = 1; j <= lowerNum; j++)
System.out.print("*");
for (int j = 1; j <= 2 * lineNum - 1 - 2 * lowerNum; j++) {
System.out.print(" ");
}
for (int j = 1; j <= lowerNum; j++) {
System.out.print("*");
}
}
System.out.println();
}
scan.close();
}
}##################IF문##################
IF문이란 특정 조건을 만족할 때 실행이 되는 것을 뜻한다.
if(true or false) { if절
then절
} else {
}
{ } 을 코드 블락(중괄호) 이라고 한다.
else if도 위와 동일하게 실행
조건문의 중첩 : if문 안에 다시 if문이 등장
조건식에는 논리연산자인 && || ! 가 들어갈 수 있다.
여러개가 들어가면 앞의 2개씩 끊어서 그 결과값과 다음 값을 연산하게 된다.
<예시>
if(i <= 5){
처리할 명령들 A
}
else{
처리할 명령들 B
}
-> 변수 i 의 값이 5보다 작거나 같으면 A를 처리해라. 그렇지 않으면 B를 처리해라
##################Swith문##################
변수 하나가 여러가지 특정 값으로 나올 때 사용
switch(변수명){
case(변수)
실행 코드
break;
default
실행코드
break;
}
switch문은 조건식이 아닌 변수를 조건으로 잡아서 그 변수의 값에 맞는 case 문을 실행하게 된다.
switch문의 변수명에 문자가 들어가면 ' ' or " "를 써줘야 인식함.
case 문의 조건은 순서와 상관 없다.
break : switch 문의 실행이 즉시 중지. 해당코드블록을 무조건 종료시킴.
break를 적어주지 않는 다면 해당 조건을 만족하는 case 부터 break가 있는 case까지 모두 실행하게 된다.
(따라서 case와 break는 항상 같이 쓰임)
default : 주어진 케이스가 없는 경우 default 문이 실행된다는 것.
switch 문을 사용할 때 한가지 주의 할 것은 switch의 조건으로는 몇가지 제한된 데이터 타입만을 사용할 수 있다.
byte, short, char, int, enum, String, Character, Byte, Short, Integer
swtich 보다 if문을 많이 씀(switch는 조건 일일이 써야함, if문은 범위가 넓음)
################## 스트림 ##################
stream : 강, 물이 흐르는 길
자바에서의 스트림 역시 데이터가 흐르는 길을 의미, 프로그램에 입출력되는 데이터의 흐름.
입력 스트림과 출력 스트림이 있음.
문자 스트림(Reader/Writer)과 바이트 스트림(InputStream/OutStream)이 있음.
<스트림 사용법>
1. import.java.io.* 를 프로그램 코드의 가장 위에 적는다.
2. 스트림을 연다(스트림 객체를 생성한다)
3. 스트림을 통해 데이터를 흘려보낸다
4. 스트림을 닫는다
################## 파일 쓰고 읽기 ##################
자바프로그램에서는 파일을 읽고 쓸 때는 우선 파일을 열고, 파일에 내용을 적거나 읽고, 마지막으로 파일을 닫는 과정을 거친다.
파일의 내용이 문자열로 되어있으면 '텍스트 파일'
바이트(0,1)로 되어있으면 '바이너리 파일' ex)사진파일, 동영상파일
파일쓰기
자바에서는 텍스트 파일을 쓸때 FileWriter 라는 스트림 클래스의 객체를 만들어 사용함. 해당 객체는 파일에 내용을 쓸 때 사용하는 writer() 메소드와 파일을 닫을 때 사용하는 close() 메소드를 가지고 있다.
<예시>
FileWriter fw = new FileWriter("a.txt");
// 문자열로 된 파일(텍스트 파일)을 쓰는 스트림 클래스의 객체를 담는 fw(객체명)라는 변수에 "a.txt"란 파일을 쓰는 FileWriter 클래스의 객체를 새로 생성하여 저장한다
// "파일명"에 경로없이 이름만 쓰면 이클립스 실행시 저장하는 workspace 폴더에 해당 파일이 저장됨.
// "파일명"에 이름과 경로를 함께 쓰면 그 경로에 해당 파일이 저장됨.
fw.write("Hello!\n")
// fw 안의 write() 메소드를 호출하여 내용을 쓴다 Hello! 줄바꿈
fw.close();
// fw 안의 close() 메소드를 호출하여 파일을 닫는다파일읽기
자바에서는 텍스트 파일을 읽을때 FileReader 라는 스트림 클래스의 객체를 만들어 사용함. 해당 객체는 파일에 읽을때 사용하는 read() 메소드와 파일을 닫을 때 사용하는 close() 메소드를 가지고 있다.
<예시>
FileReader fr = new FileReader("a.txt");
// 문자열로 된 파일(텍스트 파일)을 쓰는 스트림 클래스의 객체를 담는 fr(객체명)라는 변수에 "a.txt"란 파일을 쓰는 FileReader 클래스의 객체를 새로 생성하여 저장한다
int i;
// 정수 값을 담는 i라는 변수를 선언한다
while((i=fr.read())!=-1){
// fr 안의 read() 메소드를 호출하여 파일을 읽고, 그 값을 변수 i에 저장하고 변수 i가 -1이 아닌 동안 {} 안을 반복해라
// read() 메소드는 읽어 온 문자를 int 형으로 변환하고, 읽어 온 데이터가 없으면 -1을 리턴한다.
char c = (char)i;
// 문자 값을 담는 c라는 변수를 선언하고 변수 i를 문자형으로 변환하여 저장한다.
}
fr.close();
// fr 안의 close() 메소드를 호출하여 파일을 닫는다
################## 키보드로 입력하기 ##################
자바프로그램(앱)이 실행중일 때 키보드로 직접 데이터를 입력받고 싶을 때가 있다. 이때는 Scanner클래스의 객체를 만들어 사용자가 입력한 값을 받도록 사용한다. 해당 객체는 읽어 올 데이터의 타입에 다른 메소드를 따로 사용함.
<Scanner 클래스가 제공하는 메소드>
next() -> space키로 띄어쓰기하기 전까지 입력된 문자들을 읽어온다.
nextInt() -> space키로 띄어쓰기하기 전까지 입력된 정수들을 읽어온다.
nextDouble() -> space키로 띄어쓰기하기 전까지 입력된 실수들을 읽어온다.
nextLine() -> Enter키로 줄바꿈하기 전까지 입력된 문자들을 읽어온다.
<예시>
import java.util.Scanner;
//java.util.Scanner 패키지의 클래스들을 여기서 사용한다.
Scanner sc = new Scanner(System.in);
//입력 클래스의 객체를 담는 sc라는 변수에, 키보드에서 입력받는 Scanner 클래스의 객체를 새로 생성하여 저장한다.
//System.in -> 사용자가 입력한 값
String s = sc.next();
//문자열 값을 담는 s라는 변수에 sc 안의 next() 메소드를 호출하여 문자열로 다음 값을 읽어 와서 저장한다.
Scanner 클래스를 사용할때 주의점은 java.util.Scanner를 임포트 해야 한다!!(java.io.* -> X)
각 데이터타입에 적합한 메소드를 scan에서 호출한다.
Scanner 클래스 중 숫자를 반환하는 메소드들은 중요한 버그가 있는데
숫자만 읽어오기 때문에 우리의 키보드 입력이 임시적으로 저장되는 버퍼 메모리에서
enter 키를 빼놓고 숫자만 메모리에서 가져오게 된다.
그렇게 되면 enter키가 버퍼 메모리에 남아있고 그 후에 나오는 string에 값을 넣기 위해 nextLine()을 입력하면
버퍼 메모리에 있는 enter키를 보고 입력이 끝났다고 생각해서
우리가 입력을 할수 없게 된다.
이러한 버그를 막으려면
String 변수명 = scan.nextLine() 을 사용하기 전
어떤 값을 입력하라고 알려주는 출력문 전줄에
scan.nextLine()을 사용해서
buffer 메모리를 비어준다.
string과 + 가 나오면 2개를 하나의 string으로 이어준다.
.hasNextInt()는 입력값이 생기기 전까지 실행을 유보시키는 역할을 한다. 만약 입력한 값이 int 형이 아닐 경우는 false를 리턴하고, int로 표현할 수 있는 형식의 숫자형인 경우는 true를 리턴한다.
################## Scanner vs. BufferedReader ##################
BufferedReader - java.io 패키지 내에 위치
1. 단순한 구조. BufferedReader의 사용 메소드는 read(int형)와 readLine(String) 두 개가 전부다.
2. BufferedReader는 String으로 출력하여 원하는 숫자나 문자로 parsing을 해줘야한다.(받아서 일일히 쪼개야 함)
3. BufferedReader는 space bar 혹은 특수문자를 모두 문자열로 입력받아 출력.
Scanner - java.util 패키지 내에 위치
1. 만능. Scanner는 단순히 읽어들이기만 하는 것이 아니라 parsing과 tokenizing을 할 수가 있다. 그렇기 때문에 지원하는 메소드가 상당히 많다.
2. Scanner는 메소드에 nextInt(), nextDouble(), nextLine()등 각자의 자료형에 따라서 선택해서 할 수 있다.
예들 들어 nexInt() - int형, nextDouble() - double형, next() - String()형 등을 사용하면 된다.
3. Scanner는 토큰을 제어할 수 있다. Scanner는 구분자로 구분지어서 따로 입력받을 수 있다.
* 파싱(parsing)이란?
컴퓨터 과학에서 파싱((syntactic) parsing)은 일련의 문자열을 의미있는 토큰(token)으로 분해하고 이들로 이루어진 파스 트리(parse tree)를 만드는 과정을 말한다.
로직을 짜다보면 문자열을 다뤄야 하거나 문자열을 잘라내어 일부만 쓰려는 경우가 많은데 구분자로 문자열을 쪼개는 작업을 파싱(Parsing)이라한다.
토큰은 전체 문자열을 구분자로 쪼갠 단위이고, 이때 구분되는 문자열 or 문자를 구분자라한다.
* 토크나이징(tokenizing)이란?
|
메소드 |
설명 |
|
String nextToken() |
파싱해서 구한 토큰을 반환 |
|
String nextToken(String delim) |
새로운 구분자 delim을 써서 구한 토큰을 반환 |
|
boolean hasMoreTokens() |
파싱된 문자열이 nextToken()메소드를 실행한 후에 아직 넘겨주지 않은 토큰이 있는지 여부를 반환 |
|
int countTokens() |
파싱한 결과로 구한 토큰이 모두 몇 개인지 반환 |
################## printf vs. println vs. print ##################
printf : 형식화된 출력.
println : 줄 출력 후 단락바꿈.
print : 단순 출력 후 가만히 있음.
################## 형식화된 출력 printf ##################
%b : boolean형식으로 출력
%d : 10진 정수의 형식으로 출력. (cf. %5d : 5자리 10진 정수의 형식으로 출력) cf. %x(16진법)
%f : 부동소수점의 형식으로 출력. (cf. %5.4f : 5자리 중 소수점 4자리의 형식으로 출력)
%c : 문자(character)로 출력.
%s : 문자열(String)로 출력.
공백 표시하기: 줄바꿈 -> \n, 탭 -> \t
printf(" ") 의 " " 안에 필요한 %문자를 넣고
%문자의 data type이 부합하는 변수를 "" 뒤에 , 을 적고 변수명을 적어주면 된다.
################## GUI ##################
Graphic User Interface : 시각적으로 어플리케이션을 제어할수 있는 환경.
################## 이클립스에서 입력 값 사용하기 ##################
파일을 선택하고 Run Configuration을 선택한다.
Arguments 탭에서 Program Arguments에 입력 값을 작성하면 콘솔에서 입력 값을 전달하는 것처럼 할 수 있다.
- 클래스의 시작은 대문자+명사 ex) System
- 메소드의 시작은 소문자+동사 ex) println
- 변수의 시작은 소문자+명사 : ex)firstName, lastName
- 상수는 모두 대문자 ex) PI = 3.14f;
- 변수의 이름은 글자의 길이제한 없음 ex) int = expectedAgeofPeopleFarEastAsia (가능)
- 예약어 사용 금지 ex) int byte=0; (불가능)
- 숫자로 시작 금지 ex) int randNum1; (가능) / int 1randNum;(불가능)
- 특수문자 금지 ex) int randNum★; (불가능)
변수명 정의할때 다음규칙을 따른다.
- 첫 문자는 항상 영문자 또는 _ 또는 $로 시작한다. 즉 숫자나 다른 특수 문자를 사용하면 안 된다.
- 영문자의 대문자와 소문자는 다른 변수로 취급한다. 관례적으로 클래스명에서는 대문자를 사용하고 객체명과 메소드에서는 소문자를 사용한다. (예) BOO, boo, Boo는 각기 다른 변수
- 예약어(Reserved Word)는 변수명으로 사용할 수 없다.
################## 산술 연산자 ##################
+ - * / %
+ - * / 은 초등학교 때 배웠던 4칙연산
% 는 나머지 연산자로써 몫이 아닌 나머지를 리턴한다.(배수, 약수, 홀수/짝수, 최대공약수 등에서 활용!!)
/ 는 좌측 피연산자를 우측 피연산자로 나누었을 때의 몫이다.
이중 + 연산자는 수학 뿐 아니라 문자나 문자열에서도 사용이 가능하다.
산술연산자는 1+2 2x3 과 같이 두항 이상이 필요한 이항연산자임.
################## 산술연산자의 형변환 ##################
1. int a=10; int b=3; System.out.println(a/b);
이경우 a를 b로 나누므로 값은 3.3333... 이 출력되어야 한다.
하지만 변수 a와 b 둘다 정수인 int 타입을 가지므로, 실수부분은 정보누락이 발생해 화면에는 3이 출력된다.
2. int a=10; float b=3F; System.out.println(a/b);
이경우 마찬가지로 10을 3.0으로 나누므로 3.33333... 이 출력된다.
비록 변수 a가 정수값인 int 타입이지만, 변수 b의 타입이 실수를 표현가능한 float 이기 때문에 자동형변환이 일어나 3.3333... 이 제대로 출력된다.
################## 단항(증감)연산자 ##################
+ : 양수를 표현한다. 사실상 생략되기에 의미는 없다.
- : -3과 같이 음수를 표현한다.
++ : 증가 연산자로, 이 연산자가 붙어있으면 값에 1을 증가시킨다. (++2 = 3)
-- : 감소 연산자로, 이 연산자가 붙어있으면 값에 1을 감소시킨다. (--2 = 1)
1, 2, 3과 같이 항이 하나뿐인 대상을 상대로는 단항연산자가 사용된다.
변수 앞에 ++ 혹은 -- 가 붙으면 전위연산자 ex. (++i) : +1된 i의 값을 출력.(식 전체를 평가하기 전에 피연산자의 값을 증가시킴.)
변수 뒤에 ++ 혹은 -- 가 붙으면 후위연산자 ex. (i++) : 일단 i의 값을 출력하고 그뒤에 1을 증가시킨다.(식 전체를 평가한 후에 피연산자의 값을 증가시킴.)
################## 연산의 우선순위 ##################
복잡한 연산을 시행할때는 java가 우선순위를 지정하고 처리한다. 외우지 말고 필요할때 와서 찾자.
분명하지 않으면 혼란스러울 것이다. 아래는 자바에서 제공하는 연산자들 간의 우선순위를 정리한 표이다.
| 1 | [ ] | → |
| () | ||
| . | ||
| 2 | ++ | ← |
| -- | ||
| +(양수) -(음수) | ||
| ~ | ||
| ! | ||
| (type) | ||
| new | ||
| 3 | * / % | → |
| 4 | +(더하기) -(빼기) | → |
| +(문자 결합 연산자) | ||
| 5 | << | → |
| >> | ||
| >>> | ||
| 6 | < <= | → |
| > >= | ||
| instanceof | ||
| 7 | == | → |
| != | ||
| 8 | & | → |
| & | ||
| 9 | ^ | → |
| ^ | ||
| 10 | | | → |
| | | ||
| 11 | && | → |
| 12 | || | → |
| 13 | ? : | ← |
| 14 | = | ← |
| *= /= += -= %= <<= >>= >>>= &= ^= |= |
################## 비교연산자 ##################
> < >= <= == !=
두 기본형 데이터 타입을 비교하여 조건에 맞으면 참, 틀리면 거짓이 나옴.
조건문을 보조하는 역할
비교와 Boolean
Boolean이란?
데이터타입의 일종으로, 출력되는 값이 'true' 'false' 두가지 뿐인것이 특징
= : 예로 a=1 이면 a에 1을 대입하는 연산자이다.
== : 비교연산자로 좌항과 우항의 값이 같으면 true, 다르면 false를 출력한다.
!= : 부정을 의미한다. 위와 정반대의 경우.
>, >= : 수학에서의 부등호와 완전히 같다.
.equals : 숫자가 아닌 문자열(string)을 비교할때 사용한다. == 과 같은 역할을 하나 문자열에 사용한다. 기본형 데이터에 대해서만 비교! ★★★String class는 equals() 메소드로 비교한다!★★★
################## 논리연산자 ##################
&& || !
조건문을 보조하는 역할
&&(AND 연산자) --> 2개다 참이면 참, 1개라도 거짓이면 거짓
||(OR 연산자) --> 1개라도 참이면 참, 2개다 거짓이면 거짓
!(부정(NOT) 연산자) --> 참은 거짓, 거짓은 참으로(Boolean의 값을 역전시키는 역할)
################## 비트연산자 ##################
정수형에 대해서만 사용가능
정수를 비트(이진법)로 바꾼 후 비교하거나 조작한다.
& 연산자(AND) : 비교하는 두 값의 비트 자릿수가 1일 때만 1, 그 외엔 0
| 연산자(OR) : 하나라도 1이면 1
^ 연산자(XOR) : 비교하는 두 값의 비트 자릿수가 다를 때만 1을 반환
~ 연산자 : 비트값 반전
* 시프트 연산자(<<, >>)
<<연산자 : 비트값을 왼쪽으로 이동시킴. ex) 6<<2 -> 0110(4비트)<<2 -> 1000
>>연산자 : 비트값을 오른쪽을 이동시킴. 앞에 부호를 따라감 ex) 0110>>2 -> 0001 / 1110>>2 -> 1011
>>>연산자 : 비트값을 오른쪽을 보내고 빈 자리는 0으로
################## 형변환 Type Conversion ##################
컴퓨터가 숫자 200을 저장할때
정수 200은 00000000 11001000
실수 200.0은 01000011 01001000
이렇게 같은 숫자지만 전혀 다르게 저장한다.
만약 우리가 200과 200.0 을 더하고 싶으면 한쪽의 데이터 타입을 다른 한쪽으로 맞춰줘야 컴퓨터는 계산을 처리할수 있을것이다.
################## 암시적 형 변환 implicit Conversion ##################
[ double a = 3.0F ] 를 살펴보자. 변수는 타입이 double 이지만, 상수는 float 이다. 하지만 이 코드는 오류가 발생하지 않는다.
데이터 타입 double 은 데이터 타입 float 보다 많은 수를 표현할수 있기 때문에 java가 자동으로 상수의 데이터타입을 double로 바꿔준다.
byte < short, char < int < long < float < double 순으로 형변환이 가능!
################## 명시적 형 변환 Explicit Conversion ##################
변수의 데이터타입이 더 많은 값을 표현할수 있으면, java가 상수의 데이터타입을 자동으로 바꿔줌.
[ float a = 100.0 ] 처럼 정보의 손실이 발생하는 경우는 자동형변환이 이루어지지 않는데,
이럴 경우는,
float a = (float)100.0; 처럼 명시해주면 해결됨!
int a = (int)100.1; 의 경우 double 데이터타입을 강제로 int로 명시해줄 경우 정보의 손실이 발생해 int가 표현가능한 100 으로 출력되는데,
이를 캐스트(cast)라고 하며, ( ) 를 사용하여 '(데이터 타입)' 이라고 값이나 변수 앞에 쓰면, 해당 데이터 타입으로 강제 변환할 수 있다. 이때 ( ) 를 '캐스트 연산자' 라고 부른다.
################## 문자 -> 숫자 ##################
1. String to Int
가장 많이 사용
자바 Integer클래스의 parseInt함수와 valueOf 함수로 변환 시켜줄 수 있다.
//Integer.paseInt(String값)
//Integer.valueOf(String값)
String s_num = "10";
int i_num = Integer.parseInt(s_num); //String -> Int 1번방식
int i_num2 = Integer.valueOf(s_num); //String -> Int 2번방식2. String to Double, Float
자바 Long, Double, Float 클래스의 parseLong함수와 valueOf 함수로 변환 시켜줄 수 있다.
//Double.valueOf(String값)
//Float.valueOf(String값)
String s_num = "10";
double d_num = Double.valueOf(s_num); //String -> Double
float f_num = Float.valueOf(s_num); //String -> Float3. String to Long, Short
잘쓰이진 않는다.
자바 Long, Short 클래스의 parseLong함수와 parseShort 함수로 변환 시켜줄 수 있다.
//Long.parseLong(String값)
//Short.parseShort(String값)
String s_num = "10";
long l_num = Long.parseLong(s_num); //String -> Long
short sh_num = Short.parseShort(s_num); //String -> Short
################## 숫자 -> 문자 ##################
1. Int to String
자바 String클래스의 valueOf, toString 함수로 변환 시켜줄 수 있다.
//String.valueOf(Int값)
//Integer.toString(Int값)
int i_num = 10;
String s_num;
s_num = String.valueOf(i_num); //문자 -> 숫자 1번방식
s_num = Integer.toString(i_num); //문자 -> 숫자 2번방식
s_num = ""+i_num; //문자 -> 숫자 3번방식2. Double Float to String
실수를 문자로 변환하는 예제. 정수형과 마찬가지로 valueOf, toString함수로 치환 시킬 수 있다.
//String.valueOf(Float값,Double값)
//Float.toString(Float값,Double값)
float f_num = 10.10;
double d_num = 10.10;
String s_num;
s_num = String.valueOf(f_num); //Float -> String 1번방식
s_num = Float.toString(f_num); //Float -> String 2번방식
s_num = String.valueOf(d_num); //Double -> String 1번방식
s_num = Double.toString(d_num); //Double -> String 2번방식################## 정수 <-> 실수 ##################
1. Double,Float to Int
실수를 정수로 치환하는 방법. (Int)캐스팅 방식으로 변환시킬 수 있는데
이때 실수형의 소수점아래자리는 버려짐.
//(int)실수값
double d_num = 10.101010;
float f_num = 10.1010
int i_num;
i_num = (int)d_num; //Double-> Int
i_num = (int)f_num; //Float -> Int2. Int to Double,Float
실수형을 정수형으로 변환하는 방법. 마찬가지로 (Double,Float)캐스팅으로 구현할 수 있다.
//(int)실수값
int i_num = 10;
double d_num = (double)i_num; //Int -> Double
float f_num = (float)i_num; //Int -> Float변수는 변하는 값을 의미한다. 그 대척점에 있는 것이 상수인데, 상수(常數, constant)란 변하지 않는 값을 의미한다.
상수
[ int a=10 ]
int a; 여기서 a에는 정수라면 어떤 값이든 넣을수 있다. 1을 할당하면 1이 되고, 10을 할당하면 10이 되는식이다. 이렇듯 변할수 있기에 a는 변수이다.
int a=10; 여기서 10은 무슨일을 해도 10이다. 이렇듯 변하지 않기에 10은 상수가 된다.
앞선 수업에서 변수에는 byte, int, long, double, float 등 다양한 데이터타입이 있다는것을 배웠다. 그럼 상수에도 데이터타입이 존재할까?
[ float a = 3.5 ] 코드를 살펴보자. float 데이터타입은 상수값에 실수가 와야하는데, 3.5는 실수임에도 오류가 발생한다.
뒤의 3.5는 데이터타입이 double 이기 때문이다. float 의 상수는 [ 3.5F ] 로 표현해줘야 float 데이터타입을 갖는다.
[ long a = 5012 ] 코드를 살펴보자. long 데이터타입은 정수값이라면 어떤 값이든 넣을수 있지만, 5012 역시 정수임에도 오류가 발생한다.
뒤의 5012는 데이터타입이 int 이기 때문이다. long 의 상수는 [ 5012L ] 로 표현해줘야 long 데이터타입을 갖는다.
이처럼 앞 뒤 데이터타입이 서로 다르면 오류가 발생한다. 여기서 우리는 상수 역시 별개의 데이터타입을 가짐을 확인할 수 있다.
################## 데이터의 단위 ##################
B - KB - MB - GB - TB - PB - EB - ZB
한 단위가 1024만큼 모이면 다음 단위로 넘어갑니다.
정수를 표현하는 데이터타입의 종류로는
byte, short, int, long 이렇게 네가지가 존재합니다.
byte 타입은 256가지 수를 표현할수 있으며, long 데이터 타입은 표현할수 있는 숫자가 가장 많습니다.
왜 간편하게 long으로 모든 변수를 퉁치지 않고 세분화해서 사용할까?
뒤쪽에있는 데이터타입은 더 많은 수를 표현할수있지만, 컴퓨터의 메모리 역시 더 많이 차지합니다.
자단위가 많지 않은 코드를 표현하고 싶을때 long 데이터타입을 사용하면 메모리의 낭비로 이어질 수 있습니다.
정수의 경우
int타입을 사용합니다. CPU의 처리속도가 가장 빠르고, 충분히 큰 수를 표현할수 있습니다.
실수의 경우
double 데이터타입을 사용합시다.
문자의 경우
char 데이터타입을 사용합시다.
################## 주석의 종류 [ / ] ##################
주석(comment)으로 코드에 부가적인 설명을 쓰거나 사용하지 않는 코드를 비활성화시키기 위해서 사용한다. 뒤에 따라오는 내용은 해석되지 않는다.
1. 한줄 주석 : // 문장
2. 여러줄 주석 : /* 문장 */
3. JavaDoc : /** 문장 */
################## 세미콜론 [ ; ] ##################
하나의 구문이 끝났음을 명시적으로 나타내는 기호다.
한줄에 여러구문을 사용하고 싶을 때 세미콜론이 유용하다. int a; a = 1; System.out.println(a+1); //2
코딩화면에서의 엔터는 실제 엔터가 아니라, 세미콜론 [ ; ] 을 사용해야만 다음 문장으로 넘어갑니다.
자바에서는 세미콜론을 생략할 수 없다.
