오늘의 요약
1. I/O ( Input/Output )
* 어디서부터 시작해서 어디서부터 끝날지 항상 생각해야 함
(1) 스트림( Stream ): '데이터의 흐름'
Data Source (근원지) ===> Data Destination (목적지)
* 방향이란 것은 바뀌지 않는다. 즉, 한 번 굳어진 객체는 방향을 바꿀 수 없다.
(2) 스트림 특징
* 마셜링( 데이터를 자르는 행위 )
* 언마셜링( 데이터를 조립하는 행위 )
1) FIFO ( First In First Out )
2) 지연성
* 데이터를 입력하고 난 뒤 커서가 깜빡이는 것을 보면 데이터가 지연되고 있음을 알 수 있음
3) 단방향성
4) 유연성
* 바이트스트림을 문자스트림으로 바꿀 수 있어서 유연하다고 하는 거임
(3) 표준입력/표준출력
키보드( System.in ) -----> 모니터( System.out )
(4) 구분
1) 전송단위
<1> 바이트 스트림 ( 1 byte stream )
ex: XXXStream
<2> 문자 스트림 ( 2 byte stream )
ex: XXXReader, XXXWriter
2) 특성
<1> 근본 스트림 ( node stream )
* 노드는 근원지나 목적지에 바로 연결이 되니까, 최우선은 노드다. 고로, 중요한건 노드다!
<2> 다리 스트림 ( bridge stream ) // 1byte를 2byte로 바꿔줌
InputStreamReader (인풋스트림을 Reader로 바꾸겠다는 스트림)
OutputStreamWriter (아웃풋스트림을 Writer로 바꾸겠다는 스트림)
<3> 목적 스트림 ( filter stream ) (==응용 스트림)
3) 입출력
<1> 입력 스트림
ex: XXXInputStream, XXXReader
<2> 출력 스트림
ex: XXXOutputStream, XXXWriter
(5) 주요 스트림 클래스
1) InputStream / OutputStream (== node stream)
2) Reader / Writer (== node stream)
3) FileInputStream / FileOutputStream (== node stream)
4) FileReader / FileWriter (== node stream)
5) InputStreamReader / OutputStreamWriter (== bridge stream)
6) BufferedInputStream / BufferedOutputStream (== filter stream)
7) BufferedReader / PrintWriter (== filter stream)
// Buffered 는 일종의 쇼핑카트라고 생각하면 됨, 가득 차지 않으면 웹에 출력이 안됨, 덜 찼어도 비워주는 걸 flush();라고 함
* PrintWriter의 장점
1. autoFlush가 됨
2. bridge가 끼지 않아도 됨
3. 메소드가 굉장히 많음
8) DataInputStream / DataOutputStream (== filter stream)
// UTF 인풋을 읽고 쓸 수 있음, readUTF라는 기능이 있음
9) ByteArrayInputStream / ByteArrayOutputStream (== filter stream)
// 문자가 아닌 경우에는 무조건 얘를 사용해야 함
10) CharArrayReader / CharArrayWriter (== filter stream)
// 문자열, 캐릭터 배열에 사용하는 스트림 클래스
11) ObjectInputStream / ObjectOutputStream (== filter stream)
// 강력하지만 위험함, 따라서 데이터들을 잘라서 복구를 못하게끔 하려고 transient를 사용함
` * garbage collector 를 위해 close 해줄 때, 나중에 선언된 것(filter)을 먼저 close 해주는 것이 좋다
cf)
java.io.File => 디렉토리와 파일을 모델링한 클래스A.java
import java.io.*;
class A {
InputStream is = System.in; // node, byte, 입력
InputStreamReader isr = new InputStreamReader(is); // bridge, character, 입력
BufferedReader brKey = new BufferedReader(isr); // filter, character, 입력
PrintStream ps = System.out; // node, byte, 출력
void m1(){ // keyboard --> monitor
ps.print("기억하는 영화는? ");
String line = "";
try{
line = brKey.readLine();
ps.println("읽은 값: " + line);
}catch(IOException ie){
}
}
void m2(){ // file --> monitor
BufferedReader brFile = null; // filter, character, 입력
FileReader fr = null; // node, character, 입력
try{
fr = new FileReader("../01/D.java");
brFile = new BufferedReader(fr);
String line = "";
while((line = brFile.readLine()) != null){
ps.println(line);
}
}catch(FileNotFoundException fe){
}catch(IOException ie){}
}
public static void main(String []args){
A a = new A();
//a.m1();
a.m2();
}
}B.java
import java.io.*;
class B {
String fname = "result.txt";
BufferedReader brKey = new BufferedReader(new InputStreamReader(System.in)); // 읽어서
FileWriter fw;
PrintWriter pw; // 씀
B(){
try{
fw = new FileWriter(fname);
pw = new PrintWriter(fw, true);
}catch(IOException ie){}
}
void m1(){ // Keyboard --> File
String line = "";
try{
line = brKey.readLine();
pw.println(line);
System.out.println("파일 쓰기 완료!");
}catch(IOException ie){}
}
public static void main(String args[]){
B b = new B();
b.m1();
}
}C.java
import java.io.*;
class C {
FileInputStream fis; // node
BufferedInputStream bis; // filter
//PrintStream ps = System.out; // node
FileOutputStream fos; // node
BufferedOutputStream bos; // filter
C(){
try{ // 현재폴더 : C:\PYH\00_java\day015\01_복습\01
fis = new FileInputStream("../01/DiscordSetup.exe");
bis = new BufferedInputStream(fis, 2048);
fos = new FileOutputStream("DiscordSetup.exe");
bos = new BufferedOutputStream(fos, 2048);
}catch(FileNotFoundException fe){}
}
void m1(){
byte bs[] = new byte[512];
int su = 0;
try{
while((su = bis.read(bs)) != -1){
bos.write(bs, 0, su);
}
bos.flush();
System.out.println("파일 복사(DiscordSetup.exe) 완료!");
}catch(IOException ie){
}finally{
try{
if(bis != null) bis.close();
if(bos != null) bos.close();
if(fis != null) fis.close();
if(fos != null) fos.close();
}catch(IOException ie){}
}
}
public static void main(String[] args){
C c = new C();
c.m1();
}
}에러(Error)
Exception in thread "main" java.lang.NullPointerException:
NullPointerException 뜻은 자신이 넘겨주려는 변수가 null(0)인데 그것이 아닌 것 처럼 사용하려고 해서 에러가 생긴 것이다.
- 다만, 여기서는 fis = new FileInputStream("경로") 에서 경로가 올바르지 않아 파일을 못 찾아서 생긴 것이다. 참고하자!
D.java
import java.io.*;
//File Class
class D {
void m1() throws IOException { // 파일 생성
File f = new File("a.txt"); // 실제 생성X
if(f.createNewFile()){
pln("파일 생성 완료!");
}
}
void m2(){ // 디렉토리 생성
File f = new File("aa/bb/cc");
f.mkdirs();
pln("디렉토리 생성 완료!");
}
void m3(){ // 파일 존재 파악
File f = new File("A.java");
if(f.exists()){
if(f.isDirectory()){
pln("디렉토리가 존재함");
}else{
pln("파일이 존재함");
}
}else{
pln("존재X");
}
}
void m4(){ // 파일 존재 파악 후 리스트업
// C:\PYH\00_java\day015\01_복습\01
File f = new File("../../"); // C:\PYH\00_java\day015
if(!f.isFile()){
File childs[] = f.listFiles();
for(File child: childs) {
if(child.isFile()){
pln("[F] " + child.getName());
}else{
pln("[D] " + child.getName());
}
}
}
}
void m5(){ // 파일 삭제
File f = new File("A.class");
f.delete();
}
void pln(String str){
System.out.println(str);
}
public static void main(String[] args) throws IOException {
D d = new D();
//d.m1();
//d.m2();
//d.m3();
//d.m4();
d.m5();
}
}맞춤형 필기 요약
1. HW + OS + JVM + App1, App2 ....
- CPU: 두뇌
- RAM(메모리): 책상
- HDD/SSD: 책꽂이
- MainBoard: 방
- Card(Graphic, Sound, Ran, ..)
- 본체/주변기기
2. JVM
(1) JDK = jdk + jre
(2) 환경변수
- JAVA_HOME => C:\Program Files\Java\jdk-15
- Path => %JAVA_HOME%\bin
- classpath => .
(3) API(Application Programming Interface)
- 참조문서
3. 실행 메커니즘
- 작성(.java) -> 컴파일(javac.exe) -> 실행(java.exe)
ex) javac A.java ex) java A
- .java(for Human) -> .class(for JVM)
4. 클래스 구조
(1) 패키지 선언
(2) 임포트 구문
(3) 클래스 선언 {
(4)멤버변수
(5) 생성자
(6) 메소드
}
cf) 패키지 컴파일/실행
#> javac -d . XX.java
#> java aa.bb.XX
ex) day002/A.java
5. 주석( Comment )
(1) 1라인
//
(2) 여러라인
/*
*/
(3) 문서화주석
/**
*/
#>javadoc -d ./doc *.java
ex) day002/B.java
6. 실행 순서
ex) day002/C.java
class C {
C() { // 정의하는 것
System.out.println("C()-1");
m1(); // 메소드 호출
System.out.println("C()-2");
}
void m1() { // void는 반환타입, 리턴타입임, 이건 메소드 정의
System.out.println("m1()-1");
m2();
System.out.println("m1()-2");
}
void m2() {
System.out.println("m2()-1");
}
public static void main(String[] args)
{
System.out.println("main()-1");
C c = new C(); // 호출하는 것, new를 붙이는 건 생성자를 호출 할 때 사용하는 문법임
// 타입 변수 = new C(); 라고 하는 이유는 주어를 만들어서 다른 메소드도 실행시켜 주려고 주어를 부여하는 것임
System.out.println("main()-2");
c.m2(); // 이것처럼!
System.out.println("main()-3");
}
}
7. 객체 지향 용어
(1) 클래스(Class): 객체를 만드는 틀
ex) 붕어빵틀
(2) 객체(Object): 클래스를 통해 생성된 구현물 or 모든 것
ex) 붕어빵
(3) 생성자(Constructor): 클래스명과 똑같고 소괄호로 호출하는 특징이 있음, 객체가 생성될 때 하는 일(기능)
ex) 붕어빵틀()
(4) 메쏘드(Method): 객체가 할 수 있는 일(기능)
ex) 배부르게한다()
(5) 속성(Attribute == 멤버변수) : 객체의 특성
(존재 이유: 다양한 객체를 만들기 위해서)
ex) String 앙꼬; (슈크림 붕어빵, 아이스크림 붕어빵)
// (추가용어!) 메모리에 올라와 있는 무엇을 인스턴스라고 함
8. 클래스 붕어빵
ex) day002/붕어빵.java,신.java
// 여기서, 5번 코딩을 하려면 클래스명을 다 다르게 지정해주어야 한다. 그럴려면 몇가지 조건이 필요하다.
9. 변수=변데이터(Variable) // 큰 의미의 변수
(1) 유효범위
1) 멤버변수(==전역) // 의 특징
<1> 클래스소속
<2> 객체소속
// ex) 현실에서 아름다운 여인이라는 말을 자바에서는 여인.아름다운으로 바꿀 수 있다.
ex) day004/A.java
2) 지역변수 // 의 특징
<1> 선언초기화
<2> 파라미터 (매개변수==아규먼트)
ex) day004/B.java
(2) 소유( static 여부에 따라 달라짐 )
1) 클래스 소유 ( static 이 붙은 것은 클래스 소유 ) // == 정적(Static) == 바뀌지 않음 == 클래스의 변수 == 공유 변수
2) 객체 소유 ( no static 인 것은 객체 소유 ) // == 동적(Dynamic) == 바뀜 == 객체의 변수 == 인스턴스 (찍어낸 결과물, 객체와 뉘앙스가 다름,
// 그러나 디바이스를 벗어날 수 없기 때문에 이 디바이스를 벗어나지 않는 한 두개는 같은 개념으로 간주한다.
// 메모리 관점에서 객체관점이 많음)
ex) day004/A.java
(3) 변경( final 여부 )
1) 상수 ( Constance )
2) 변수 ( Variable ) // 작은 의미의 변수
ex) day004/C.java
(4) 메모리 저장방식
1) 기본형(==원시데이터변수==primitive type) 8가지
<1> call by value : 호출하면 값이 바로 튀어나오는 것
<2> 형태 : 소문자로 시작
<3> 종류 // 얘네끼리 연산을 하는데 연산하면 같은 형태로만 해야 함
// ▶ 순으로 형변환이 됨
byte(1) ▶ short(2) ▶ int(4) ▶ long(8) ▶ float(4) ▶ double(8)
char(2) ▶
boolean(1)
// 얘는 형변환을 유일하게 할 수 없음, 얘만 씀, 독보적인 아이임
<4> 담을 수 있는 값의 범위
1> byte: -2^7 ~ 2^7-1 (경우의수: 2^8) // -128~127
2> short: -2^15 ~ 2^15-1 (경우의수: 2^16)
3> char: 0 ~ 2^16-1 (경우의수: 2^16) // ASCII 코드에는 음수가 없음
4> int: -2^31 ~ 2^31-1 (경우의수: 2^32)
5> long: -2^63 ~ 2^63-1 (경우의수: 2^64) // 전 지구상의 모든 돈의 단위를 long이 저장할 수 있음
6> float
7> double
8> boolean: false | true
ex) day004/D.java, E.java(재미로)
<5> 형변환(Type Casting)
1> 자동(암시적/Implicit) by JVM
// 형변환을 표시해줘야하는데 자동으로 JVM에 의해 형변환이 되기 때문에 자동 형변환이라고 함
-> 범위가 작은 Type ▶ 큰 Type
2> 강제(명시적/Explicit) by 개발자
ex) day004/F.java
<6> 예외 형변환
-> 정수형타입(byte, short, char, int)끼리의 연산의 결과는 무조건 int로 나옴 // 그룹임, 얘네끼리의 연산은 결과가 무조건 int로 나옴
// char 부분은 아직 이해가 잘 안감
ex) day004/G.java
<7> 초기값
-> 정수(0, 0L), 실수(0.0f, 0.0) // 0L에서 L, 0.0f에서 f를, 0.0d에서 d를 생략해주지만, 있다고 생각하는게 좋다
ex) day004/H.java
<8> 존재이유: 기본 8가지 변수를 뽑아놓은 이유가, 실행의 효율성을 위해서다.
// 자세한 이유는 하단에 있음
int -> Integer // 오른쪽은 Heap에 만들어지는 것
double -> Double // 오른쪽은 Heap에 만들어지는 것
boolean -> Boolean // 오른쪽은 Heap에 만들어지는 것
// 위처럼 하는게 비효율적인 것인거다.
// 자바는 완벽한 객체지향 언어, 이 말인 즉슨, 모든 타입을 객체화 시킬 수 있다
2) 참조형(==레퍼런스변수==reference type)
<1> call by reference
<2> 형태 : 대문자로 시작
<3> 종류 : 기본형(8가지)를 제외한 모든 타입(무한대)
<4> 초기값 : null
<5> 형변환
Object
▲
Human
▲
Superman
cf) 배열변수
-> 배열을 저장하는 변수
10. 제어 ( 비유: 부메랑 )
어떤 프로그램이 실행되고 있을 때,
어느 한 시점에서의 CPU연산은 어떤 특정 코드부분을 실행하고 있을 것이다
그 코드부분을 '제어점'이라 하고, 그 제어점을 집합을 '제어'라 한다
즉, 프로그램의 실행흐름(Line)을 제어라 한다.
JVM -> main() -> ... -> main() -> JVM
// 제어는 반드시 회귀한다
ex) day005/A.java
11. 제어문
(1) 조건문
1) if(boolean형){} 문
2) if(boolean형){} else{} 문
3) if(boolean형){}.. else if(boolean형){}.. else{} 문
4) switch(정수형){ case: ... default: } 문
=> 정수형+String(jdk7~), break, default위치, case블럭 생략 가능
// 주의사항 1. 중간에 break가 나와야한다.
// 2. default 위치는 관계가 없다, 그러나 기본적인 문법으로 적는 것이 생각의 흐름상 옳다.
// 3. case 블럭은 생략 가능하다.
// 4. 정수형만 파라미터 변수로 사용 가능하다. (byte, short, char, int)
// 5. jdk7 부터 string 타입을 지원해준다. 예전에 구축해놓은 시스템일 경우 사용할 수 없다는 것을 알아두자.
// if의 중괄호가 없을 때는 if가 써져있는 첫번째 세미콜론까지가 if의 body가 되는 것이다.
ex) day005/B.java, C.java, D.java
(2) 반복문
-> 초기식(밖), 조건식(안), 증감식(안)를 모두 갖추어야 '유한루프'가 돌게 됨
// 무한루프를 돌리는 경우는 롤에서 서버 돌릴 때 유저들이 로그인하는 것을 대기탈 때 해야하는데,
// 계속 돌면 오류가 나므로, 쉬는 타임이 있어야 한다. 안 그러면 컴퓨터는 최선을 다하기 때문에 금방 망가진다.
1) while(boolean형){} // 신사, 앞뒤사정을 따지고 그 다음에 주먹을 날린다.
2) do{} while(boolean형); // 조폭, 앞뒤사정을 따지지 않고 먼저 주먹을 날린다.
3) for(초기식;조건식;증감식){} // 신사, 똑같은 신사인 while로 바꿀 수 있다.
// for문 안쓰고 while 쓰는 경우는 무한루프 돌릴 때 주로 사용한다. for문은 조건식에 (;;) 해야 true가 되기 때문에 안 예뻐서 보통 while을 사용한다.
ex) day006/A.java
12. 제어의 이동
(1) continue
1) 반복블럭안에서만 사용 가능
2) (조건에 맞으면) '건너뛴다'
cf) labeled continue 문
ex) day007/A.java
(2) break
1) 반복블럭이나 스위치블럭 안에서만 사용 가능
2) 자기를 둘러싼 첫번째 블럭을 '나간다'
cf) labeled break 문
ex) day007/B.java, C.java
(3) return
1) 어디에서나 사용 가능
2) 호출한 곳 or 놈으로 '되돌린다'
ex) day007/D.java, E.java
13. 연산자( Operator )
(1) (데이터들을) 연산하게 하는 '기호'
(2) 종류
1) 산술 ex) +, -, *, /, %
cf) 연산자 오버라이딩
-> 양쪽 데이터 중 하나이상이 String 타입이면 +는 결합연산자
2) 증감 ex) ++, --
3) 대입 ex) =
4) 산술대입 ex) +=, -=, *=, /=, %=
5) 비트 ex) &, |, ^, ~, 시프트(<<,>>,>>>)
6) 비교 ex) ==, !=, <, >, <=, >=
7) 논리 ex) &, &&, |, ||
// &&이나 ||인 경우, 앞에 나온 결과값이 논리적으로 확정이되면 되면 그 뒤에건 계산 및 비교를 안함으로써 약삭빠르고 효율적인 방향으로 가는 것임,
// 약삭빠르고 원칙을 중시하지 않으면 커플임을 기억!
8) 논리대입 ex) &=, |=
9) 조건 ex) A? B:C
10) instanceof ex) 객체 instanceof 클래스
// instanceof는 무조건 클래스, 참조형만 사용할 수 있다. 참조형으로 변환한 8가지를 기억하라 ex) Integer, String 등등
ex) day007/F.java
14. 배열(Array)
같은 타입의 데이터 '저장소'로써 생성될 때 크기가 고정되는 '객체'
- 배열의 크기는 배열의 갯수, 배열의 번호는 배열의 인덱스라 한다.
- 배열은 같은 타입만 저장할 수 있다.
- 한번 생성되면 배열의 방을 늘리거나 줄일 수 없다.
- 배열 작성 시 하단 내용 중 아무거나 상관없다.
1) String []items;
2) String[] items;
3) String [] items;
4) String items[];
(1) 선언
type 배열변수[]; //ex) String items[];
(2) 생성
배열변수 = new type[크기]; //ex) items = new String[4];
(3) 초기화
배열변수[인덱스] = 데이터; //ex) items[0] = "봄";
(4) 선언 및 생성
type 배열변수[] = new type[크기]; //ex) String items[] = new String[4];
(5) 선언 및 생성 및 초기화
type 배열변수[] = {데이터1, 데이터2, ...};
//ex) String items[] = {"봄", "여름", "가을", "겨울"};
ex) day007/G.java
(6) 배열의 default 값
- byte, short, char, int: 0
- long: 0L
- float: 0.0f
- double: 0.0
- boolean: false
- 참조형: null
ex) day007/H.java
(7) 형변환
형변환이 가능한 데이터라면 형변환되어져서 입력 됨
//ex) int is[] = {b, s, c, i, (int)f};
ex) day007/I.java
(8) 이차원
일차원 배열을 데이터로 갖는 배열
ex) day008/A.java
(9) N차원
(N-1)차원을 배열을 데이터로 갖는 배열
ex) day008/A.java
15. 컬렉션(Collection)계열 ( 가변배열 == 자료구조(Data Structure) )
같은 타입의 '참조형'데이터 '저장소'로써 그 크기가 변할 수 있는 '객체'
(1) 종류
* 인터페이스는 자기 자신을 쓰는게 아니라 자식을 쓰는 개념
1) java.util.Collection
| |
java.util.List java.util.Set
| |
..... .....
2) java.util.Map
|
java.util.Hashtable, ....
(2) 특징
1) List
- 중복을 허용
- 순서를 보존
// 배열하고 상당히 유사하나, 집어넣으면 집어넣을 수록 사이즈가 커짐, 이게 바로 가변 배열이기 때문
ex) day008/B.java
2) Set ( 비유: 집합 )
- 중복을 허용 X
- 순서를 보존 X
// 정렬(sorting) 기능 사용 시 강력하다
ex) day008/C.java
3) Map ( 비유: 1:1 함수 )
- 한쌍으로 저장(key와 value)
- 순서를 보존 X
- key는 중복허용X, value는 중복허용O
ex) day008/C.java
cf) AutoBoxing: ( 기본형 -> Wrapper class )
16. OOP ( Object Oriented Programming ) 특성
(1) 상속성( Inheritance )
부모의 '모든 것'을 자식에서 '상속받는 것' (=='사용할 수 있는 것')
- 다른 생성자가 하나도 없을 경우에만 JVM이 기본생성자(default constructor)를 만들어준다.
- 자식 객체가 생성되려면 먼저 부모객체가 생성되어야 함
- 모든 생성자의 첫라인에는 super();가 생략되어 있음 (단, 다른 super(..)가 있다면 예외)
- 모든 객체는 Object의 자식이다. (묵시적 상속)
ex) class A extends Object
- 자식 메소드에서 부모 메소드의 내용을 바꿀 수 있음, =오버라이딩(Overriding)
// 세상의 어떤 객체라도 Object로 형변환이 가능하다, 왜냐하면 Object는 모든 것이기 때문이다.
- 형변환은 상속관계에서만 가능
-> 자동
-> 강제
ex) day009/A.java
(2) 다형성( Polymorphism )
같은 타입 객체의 '동일한 메소드가 다른 일을 하는 것(=특성)'
// 오버라이딩을 함으로써 객체의 다형성을 얻을 수 있다.
ex) day009/B.java
(3) (속성값의)은닉성( Information Hiding )
속성값(데이터)을 외부 객체로부터 '숨기는 것'
// 접근제한을 둬야 하는 정보에, private을 속성해주면 정보를 숨길 수 있다.
ex) day009/C.java
(4) (메소드의)캡슐화( Encapsulelation )
- 속성(데이터)과 메서드를 하나로 묶어 외부에 감추기도 하고 보이게도 하는 것
- 메소드의 형태(리턴타입, 이름, 파라미터)만 알면 그 내용을 몰라도 호출해서 사용할 수 있는 것
// 내용은 모르면서 이 메소드의 생성자나 형태만 알면 사용할 수 있는 것을 캡슐화라고 한다. ex) 콘택600
ex) day009/C.java, D.java
17. (메소드)오버라이딩( Overriding )
(1) '상속관계'에서 부모의 메소드의 일(내용)을 자식에서 '바꾸는 것'
// 오버라이딩이란, 덮어쓰는 것을 얘기한다.
(2) 조건
1) 메소드 이름이 같아야 함
2) 반환타입이 일치해야 함
3) 생성자는 불가
// 생성자를 호출하려면 클래스명과 이름이 똑같아야 하는데, 오버라이딩을 하려면 부모와 자식간의 이름이 똑같아야 한다. 고로 논리적으로 맞지 않는 말이다.
4) 파라미터의 타입, 순서, 갯수가 모두 일치해야 함
// 파라미터 변수의 변수명은 중요하지 않다. 변수명이 달라도 오버라이딩 할 수 있다.
5) 자식메소드의 접근제한자가 부모메소드의 접근제한자보다 같거나 넓어야 한다.
// 접근제한자 : 클래스의 구조에서 생성자, 메소드, 멤버변수 모두 접근제한자(default)가 존재하는 것이다.
// 추후 공부할 것이지만, 접근범위가 넓은 순서는 다음과 같다. public > protected > default > private 순임
ex) day010/A.java
18. 오버로딩 ( Overloading )
(1) 정의: (호출 시 그 형태에 매핑되서 호출되도록) 파라미터의 종류나 순서나 갯수가 다른 '같은 이름의 메소드나 생성자를 여러개 정의하는 것'
// 김치찌개를 만들 여러가지 재료(참치, 삼겹살, 스팸, 꽁치 등)를 미리 준비해둬서 어떤 김치찌개를 만들지 그때 그때 상황에 따라 정하는 행위
// 메소드와 생성자를 똑같은 이름으로 조금씩 다른 기능, 변수를 받아 만든 뒤 나중에 쓸 수 있게 준비해두는 것
(2) 종류
1) 생성자
2) 메소드
(3) 특징
1) 반환타입과 관계없음
2) 접근제한자와 관계없음
3) 상속관계라면 다른 클래스에서도 오버로딩 가능
4) 형변환이 가능한 파라미터라도 오버로딩으로 인정
ex) day010/B.java
19. this 와 super
(1) this
1) 정의: 자신의 '객체' 또는 '생성자'를 의미하는 대명사
// 정의를 내려보는 연습을 계속 해볼 것,
// 다른 사람의 의견을 반영한다면 근본적으로 이해하기에는 바람직하지 못하다.
2) 사용예
<1> 지역변수와 이름이 같은 멤버변수를 해당 지역에서 접근할 때
<2> 자신의 생성자를 호출할 때
<3> 자신의 객체를 다른 클래스에게 넘길 때
ex) day010/C.java
(2) super
1) 정의: 부모의 '객체' 또는 '생성자'를 의미하는 대명사
2) 사용예
<1> 부모의 생성자를 호출할 때
<2> 이름이 같은 부모의 멤버를 자식에서 접근할 때
// 프로그램에서는 주어가 항상 있어야 하는데, '나=this'는 생략할 수 있다.
<3> 오버라이딩 되기 전의 부모메소드를 자식에서 호출할 때
ex) day010/D.java
20. 제한자( Modifier )
클래스, 인터페이스, 변수, 생성자, 메소드 앞에 붙어서 그 기능을 '제한'하는 예약어
(1) 접근제한자( Access Modifier )
1) 종류
<1> public: 제한이 없음, 모든 곳에서 접근 가능
<2> protected: 같은 패키지 안 or 상속 관계의 부모자원에 접근 가능
<3> default ( package == friendly ): 같은 패키지 안에서만 접근 가능
<4> private: 자신의 클래스 안에서만 접근 가능
2) 특징
<1> 클래스나 인터페이스 앞의 접근제한자는 public 과 default 만 가능
<2> public 클래스는 파일이름과 이름이 같아야 함, 따라서 한 java 파일 내 public 클래스는 최대 한 개만 올 수 있다.
3) 범위
- 넓은 순위 : public > protected > default > private
- 강력 순위 : public < protected < default < private
ex) day011/A.java
(2) 소유제한자( static )
붙으면 클래스 소유, 안 붙으면 객체 소유
1) 멤버와 메소드에만 붙을 수 있음
2) static 메소드에서는 자원접근 시 자신의 클래스를 생략 가능
3) 자원접근 시 클래스 이름으로 접근
4) static 자원은 메모리에 1개 생성되어, 해당 클래스의 모든 객체에게 공유됨
-> 설정값 변경 시, 만약 내 스코어를 상대에게 공유할 때 많이 사용함
-> 멀티쓰레드에 굉장히 취약하므로 남발하여 사용하면 좋지 않다.
ex) day011/B.java, C.java
(3) 수정제한자( final )
붙으면 수정을 못하게 함
1) 클래스, 변수(멤버, 지역), 메소드 앞에 붙을 수 있음
2) 클래스에 붙으면 자식을 '못 낳고', 변수에 붙으면 초기값을 '못 바꾸고', 메소드 앞에 붙으면 '오버라이딩을 못하게 함'
3) 지역변수에도 붙을 수 있음
-> 상식적으로 String 클래스는 final 이므로 자식을 낳을 수 없다.
ex) day011/D.java
(4) 추상제한자( abstract )
붙으면 추상화(化)가 됨
-> 다형성 때문에 사용함, 근데 현재로서는 자세하게 알지 못해도 괜찮음
1) 클래스와 메소드 앞에서만 붙을 수 있음
2) 하나 이상의 '추상메소드'만 가지고 있어도, 그 클래스는 '추상클래스'가 의무적으로 되어야 함
3) 추상클래스의 객체는 완벽한 자식클래스를 만들어서, 그 객체를 '형변환'하여 생성함
cf) 추상클래스 : abstract 가 붙은 클래스
추상메소드 : abstract 가 붙은 메소드
ex) day011/E.java
(5) 기타제한자
synchronized (쓰레드), transient (보안), native (OS 자원),
21. 식별자( Identifier )
'프로그래머 임의로' 설정하는 패키지, 클래스, 변수, 메소드 '이름'
(1) 규칙
1) 숫자가 맨 앞에 나올 수 없음
2) 특수문자는 _와 $만 가능 (맨 앞에 나와도 됨)
3) 길이의 제약은 없음
ex) day011/F.java
(2) 관례
1) 클래스와 인터페이스 이름은 첫문자를 대문자로 시작
2) 상수는 전체 문자를 대문자
3) 패키지, 변수, 메소드 이름의 첫문자는 소문자로 시작
4) 2개 이상의 단어 조합은 다음 단어의 첫문자를 '대문자'로 하거나 '_'로 처리
5) _와 $는 자제함
6) 의미있는 단어로 생성함
22. 패키지( Package )
비슷한 종류의 '기능'이나 '업무'를 가진 클래스와 인터페이스들의 묶음
(1) 형태
클래스 최상단에 package 라는 예약어 를 사용
( ex : package soo.aa.bb; )
-> 안드로이드 앱에서는 폴더구조가 2개의 depth 이상 이루어져야 한다.
(2) 컴파일
#> javac -d . XXX.java // 상대 경로 : 현재 디렉토리 생성
#> javac -d ./classes XXX.java // 상대 경로 : 하위 디렉토리 생성
#> javac -d ../ XXX.java // 상대 경로 : 상위 디렉토리에 생성
#> javac -d C:\SOO XXX.java // 절대 경로
ex) day012/A.java
(3) 실행
#> java soo.aa.bb.A // 패키지 최상단 디렉토리로 이동 후 실행
(4) 압축
#> jar -cvf p.jar soo
ex) day012/AUser.java
(5) classpath ( *** ) // 기본적으로 패키지에 포함되지 않은 java 소스 파일을 컴파일할 때 classpath를 설정하게 된다.
1) -classpath 법 ( 유효범위 : javac.exe, java.exe )
<1> 디렉토리
#> javac -classpath C:\SOO\Java\day11\classes AUser.java
#> java -classpath .;C:\SOO\Java\day11\classes AUser
<2> jar
#> javac -classpath C:\SOO\Java\day11\jar\p.jar AUser.java
#> java -classpath .;C:\SOO\Java\day11\jar\p.jar AUser
2) set classpath 법 ( 유효범위 : cmd )
<1> 디렉토리
#> set classpath=%classpath%;C:\SOO\Java\day11\classes
#> javac AUser.java
#> java AUser
<2> jar
#> set classpath=%classpath%;C:\SOO\Java\day11\jar\p.jar
#> javac AUser.java
#> java AUser
3) 환경변수 법 ( 유효범위 : OS )
<1> 디렉토리
.;C:\SOO\Java\day11\classes
<2> jar
.;C:\SOO\Java\day11\jar\p.jar
cf1) build path ( in eclipse )
cf2) javadoc -d ./doc *.java // API 문서화
23. 인터페이스 ( interface )
-> 인터페이스를 왜 쓰는걸까? :
- JDK7 이하: '상수'와 '추상메소드'로 구성된 '껍데기'
- JDK8 이상: '상수'와 '추상메소드'와 'static 메소드'와 'default 메소드'로 구성된 '껍데기'
(1) 생략
1) interface 앞에는 abstract 생략
2) 멤버변수 앞에는 public static final 생략 됨
3) 메소드 앞에는 public abstract 생략 됨
4) static 메소드에는 public 생략됨
5) default 메소드에는 public 생략됨 // 인터페이스에서만 정의하는 default 메소드
ex) day012/A.java, AChild.java, AUser.java
(2) 특징
1) 객체는 완벽한 자식 클래스를 만들어서 그 객체 생성 후 형변환해서 만듬
2) interface 의 static 메소드는 인터페이스 이름으로만 접근 가능, 객체로는 접근 불가능
3) 자식클래스를 만들때에는 implements 사용
( 다중상속가능 : class BChild implements B1, B2, ... )
4) 인터페이스 끼리의 상속은 extends 사용
( 다중상속가능 : interface B3 extends B1, B2, ... )
5) 일반적인 자식클래스의 형태
class Superman extends Human implements B1, B2, ...
ex) day012/B.java
24. 추상클래스와 인터페이스 차이점
(1) 공통점
- 추상메소드를 가질 수 있음
- 완벽한 자식객체를 생성해서 형변환
(2) 차이점
- 클래스이고 인터페이스 근본 특성
- 추상클래스는 일반메소드와 일반멤버변수와 생성자를 가질 수 있음
25. 예외 처리
(1) 예외( Exception )
프로그램이 정상적으로 진행되지 못하게 하는 '돌발 상황'
ex) 숫자가 아닌 형태의 문자를 숫자로 바꾸려할 때
채팅하나가 상대방이 나가버린 경우
온라인 게임하고 있는 데
- 게임서버가 다운된 경우
- 전원케이블이 빠짐
- 번개가 쳐서 집안 전기 끊김
(2) 예외처리목적
프로그램 진행시 발생할 수 있는 '돌발상황'을 예외로 '미리 정해놓고',
해당하는 예외가 발생했을 경우 적절한 조치를 취해서,
프로그램이 '정상적으로 작동'하도록 하는 것
(3) 계층도
Object
|
Throwable
| |
Error Exception
| |
CompileException RuntimeException
CheckedException
ex) day013/A.java
(4) 특징
1) throw 로 예외를 발생시킴
2) throws 로 예외발생가능성을 표식할 수 있음 ( == 떠넘길 수 있음 )
3) try catch 로 잡을 수 있음 ( == 적극적으로 때려 잡음 )
4) '생성자'나 '메소드'에서만 발생할 수 있음
5) 상위 Exception 으로도 처리가 가능
(5) 처리방법( ***** )
1) 때려 잡는 법
try{
예외발생구문(생성자 or 메소드)
}catch(예외타입 예외객체){
처리 로직
}
2) 떠넘기는 법
throws 예외타입
(6) try절안에 2개 이상의 예외 발생
1) 예외들이 상속관계O
[순서존재O] 하위예외부터 잡아 줌
catch(MyException me)
catch(Exception e)
2) 상속관계X
[순서존재X] 아무예외나 먼저 잡아주면 됨
catch(MyException me)
catch(YourException ye)
ex) day013/B.java
(7) 2이상의 예외를 떠넘길 때
(ex: throws MyException, YourException, ... )
ex) day13/C.java
(8) finally절
1) 항상 수행되는 절
( 심지어.. return 을 만나더라도 수행하고 리턴 됨 )
2) try절이 나오면..
catch절이 나오거나, finally절이 나오거나,
아니면.. 둘다 나오거나 해야 함
3) 얘는 못이김
System.exit(-1); //비정상종료
System.exit(0); //정상종료
ex) day013/D.java
26. 내부 클래스 ( Inner Class <-> Outer Class )
클래스 안의 클래스
(1) 객체 생성 방법 (외클 = 외부클래스, 내클 = 내부클래스
1) 외클.내클 변수 = new 외클().new 내클(); // static 사용하지 않을 때
2) 외클.내클 변수 = new 외클.내클(); // static 사용할 때
ex) day014/A.java
(2) main 위치
1) 제3클래스나 외부클래스에 있을 때는 동일하게 사용 가능
2) static 내부클래스에서만 main을 정의할 수 있으나 호출은 어려움, 하지만 일반 메소드는 사용 가능
( 이유 : static 내부클래스에서만 static 자원(멤버/메소드)을 정의할 수 있기 때문 )
3) static 내부클래스에서는 외부클래스의 static 자원만 접근 가능 (B.java 예제 참조)
ex) day014/A.java
(3) 쓰는 이유 (*****)
외부 클래스의 자원(심지어 private 자원도 포함)을 '자기 것'처럼 사용하기 위해서
ex) day014/B.java
27. 쓰레드 ( Thread )
프로세스를 구성하는 '제어의 흐름'
(1) Process 와 Thread
1) Process: 프로그램의 '실행 단위'
2) Thread: Process 를 구성하는 '작업 단위'
(2) 장점
쓰레드 '경량 프로세스'라고 불림
이유는 프로세스의 공통 Resource 를 공유하기 때문임
(3) 생성법
1) java.lang.Thread 상속법 // 클래스
2) java.lang.Runnable 상속법 // 인터페이스
ex) day014/C.java
(4) 시작
쓰레드객체.start();
(5) 비유: '피고용인 Employee'
ex) day014/D.java
(6) LifeCycle
1) 5가지 상태
2) 각 상태는 '메소드'나 '스케줄러'나 '시간'에 의해 이동함
3) 한 번 죽으면 다시는 살아나지 못함
// Scheduler 로 직접 핸들링을 할 순 없으나, 스케쥴러가 뽑아갈 수 있도록 우선순위를 부여할 수는 있다
(7) Priority
1) Ready 상태의 쓰레드 중에서
우선적으로 CPU를 점유할 수 있는 쓰레드를 판별하기 위한 LEVEL 값
2) 범위
1 ~ 10
3) 상수
MAX_PRIORITY : 10
MIN_PRIORITY : 1
NORM_PRIORITY : 5
ex) day014/E.java
(8) 동기화
1) 비유: 화장실의 문고리
// static을 많이 사용할 수록 데이터의 무결성이 해쳐질 수 있음 (무결성 : 데이터의 결함이 없는 성질)
2) 하나 이상의 쓰레드가 어떤 연산 or 로직에 동시 접근했을 때,
그 연산에 대한 값의 무결성을 보장하기 위해서 수행 영역에 대한 lock을 걸어주는 것
3) 예
int i = 0;
i++;
# CPU의 연산 단계 #
<1> 현재 i값을 읽음 i==0 i==0
<2> i값을 증가 i==0 i==0
<3> 증가된 i값을 i에 저장 i==1 i==1
4) 방법
1> synchronized void m(){
동기화가 필요한 로직;
}
2> synchronized(this){
동기화가 필요한 로직;
}
ex) day014/F.java
28. I/O ( Input/Output )
// 어디서부터 시작해서 어디서부터 끝날지 항상 생각해야 함
(1) 스트림( Stream ): '데이터의 흐름'
Data Source (근원지) ===> Data Destination (목적지)
// 방향이란 것은 바뀌지 않는다. 즉, 한 번 굳어진 객체는 방향을 바꿀 수 없다.
(2) 스트림 특징
// 마셜링( 데이터를 자르는 행위 )
// 언마셜링( 데이터를 조립하는 행위 )
1) FIFO ( First In First Out )
2) 지연성
// 데이터를 입력하고 난 뒤 커서가 깜빡이는 것을 보면 데이터가 지연되고 있음을 알 수 있음
3) 단방향성
4) 유연성
(3) 표준입력/표준출력
키보드( System.in ) -----> 모니터( System.out )
(4) 구분
1) 전송단위
<1> 바이트 스트림 ( 1 byte stream )
ex: XXXStream
<2> 문자 스트림 ( 2 byte stream )
ex: XXXReader, XXXWriter
2) 특성
<1> 근본 스트림 ( node stream )
<2> 다리 스트림 ( bridge stream ) // 1byte를 2byte로 바꿔줌
InputStreamReader (인풋스트림을 Reader로 바꾸겠다는 스트림)
OutputStreamWriter (아웃풋스트림을 Writer로 바꾸겠다는 스트림)
<3> 목적 스트림 ( filter stream ) (==응용 스트림)
ex) day015/A.java, B.java
3) 입출력
<1> 입력 스트림
ex: XXXInputStream, XXXReader
<2> 출력 스트림
ex: XXXOutputStream, XXXWriter
(5) 주요 스트림 클래스
1) InputStream / OutputStream (== node stream)
2) Reader / Writer (== node stream)
3) FileInputStream / FileOutputStream (== node stream)
4) FileReader / FileWriter (== node stream)
5) InputStreamReader / OutputStreamWriter (== bridge stream)
6) BufferedInputStream / BufferedOutputStream (== filter stream)
7) BufferedReader / PrintWriter (== filter stream)
// Buffered 는 일종의 쇼핑카트라고 생각하면 됨, 가득 차지 않으면 웹에 출력이 안됨, 덜 찼어도 비워주는 걸 flush();라고 함
* PrintWriter의 장점
1. autoFlush가 됨
2. bridge가 끼지 않아도 됨
3. 메소드가 굉장히 많음
8) DataInputStream / DataOutputStream (== filter stream)
// UTF 인풋을 읽고 쓸 수 있음, readUTF라는 기능이 있음
9) ByteArrayInputStream / ByteArrayOutputStream (== filter stream)
// 문자가 아닌 경우에는 무조건 얘를 사용해야 함
10) CharArrayReader / CharArrayWriter (== filter stream)
// 문자열, 캐릭터 배열에 사용하는 스트림 클래스
11) ObjectInputStream / ObjectOutputStream (== filter stream)
// 강력하지만 위험함, 따라서 데이터들을 잘라서 복구를 못하게끔 하려고 transient를 사용함
` // garbage collector 를 위해 close 해줄 때, 나중에 선언된 것(filter)을 먼저 close 해주는 것이 좋다
cf)
java.io.File => 디렉토리와 파일을 모델링한 클래스
휘발방지