[ 자바 BEGINNING ]
1. 자바의 역사
2. 자바의 특징
(1) 플랫폼(OS)의 독립성
(2) 완벽한 객체 지향 언어
(3) 멀티 쓰레드
(4) 자동 메모리 관리 (by 가비지 컬렉터)
(5) 확장성 / 재사용성( reuse )
(6) 보안성 / 견고성
(7) 예외처리가 쉽다.
3. 개발환경셋팅
(1) java.sun.com에서 JDK다운
(2) 인스톨(개발환경[JDK]과 실행환경[JRE] 2가지 프로그램 설치)
(3) path와 classpath 잡기
-> 바탕화면 -> 내컴퓨터 -> 고급 -> 시스템변수에 다음을 추가!
1) path : C:\Program Files\Java\jdk1.5.0_15\bin
2) classpath : .;
(4) 환경셋팅 Testing
1) javac
2) java -version
(5) API(Application Programming Interface) 를 다운 받아서
압축을 풀고, 즐겨찾기 한다.
-> C:\SOO\JAVA\BEGIN\자료실\jdk-1_5_0-doc\docs\api\index.html
4. 클래스의 구조
(1) package 선언
(2) import 구문
(3) class 선언
{
(4) 멤버변수
(5) 생성자
(6) 메소드
}
ex) day01/Test1~2.java
5. 주석 ( comment )
(1) // 라인1
(2) /*
라인1
라인2,..
*/
(3) /**
라인1
라인2.... // 다음에 여쭤 보세요..
*/
6. 자바 프로그램밍 실행 절차
- '자바실행.ppt' 참조
/*
class 로딩시점에서 static 메소드와
static 멤버변수가 함께 로딩된다.
static 메소드 안에서는 static 메소드나
static 변수만을 접근할 수 있다.
( but, 객체가 만들어지면 접근가능하다. )
*/
ex) day01/Test3.java
/*
숙제1 - 오늘 배운 개념을 생각하면서 수업예제를
10번씩 코딩하고, 자기나름데로 변형해서 10번씩
코딩해 온다.
*/
우리는 개미다... 자바는 코끼리다..
//////////////////////// 100 미터 전방 끝 /////////////////
7. 객체 지향 용어
(1) 클래스(class)
(2) 객체(Object)
(3) 메소드(Method)
(4) 속성(Field) == 멤버변수
(5) 생성자(Constructor)
cf1) 객체를 만들어야 하는 이유
실생활의 업무를 소프트웨어(자바프로그램)으로
그대로 옮겨놓기 위해서는 그 구성요소인 객체를
생성해야 하므로
즉, 객체는 모든것(everything)을 표현 가능하므로..
cf2) 메소드와 비교한 생성자의 차이점
1) 클래스와 동일한 단어
2) 반환타입이 없다.
3) 호출될 때 항상 new가 연산자를 써줘야 한다.
4) 생성자가 하나도 없는 경우에만 JVM이 default 생성자를
자동으로 생성해 준다.
..........
8. 클래스 설계
ex) day02/붕어빵관리자.java
/*
위의 클래스를 참고하여 어떠한 대상(객체)을 설정해서
클래스를 설계하여 출력(메소드/속성)하시요..
*/
9. OOP의 특징
(1) 상속성 (Inheritance) ( 중요도 - 울트라 ***** )
-> 자식객체가 부모객체의 모든 것을 상속받는 것
( 사용할 수 있는 것 )
ex) day02/Human.java
1) 모든 클래스는 ( )클래스의 자식이다.
2) 객체의 타입캐스팅(형변환)도 반드시 ( )관계여야 한다.
<1>
<2>
3) 메소드 오버라이딩(재정의)도 반드시 ( )관계여야 한다.
4) ( )객체가 만들어지려면 반드시 내부적으로
( )객체가 먼저 생성되어야 한다.
// overriding과 super 는 나중에 따로 떼내서 자세히..
cf) 자바에서에서의 관계
(1) has a relationship : 클래스(객체)와 속성과의 관계
ex) 붕어빵 has a 앙꼬
(2) is a relationshiop : 부모와 자식클래스(객체)와의 관계
ex) SuperMan is a SuperMan (O)
SuperMan is a Human (O)
Human is a SuperMan (X)
Human is a Object (O)
/*
숙제2
오늘 배운 개념을 생각하면서, 부모클래스와
자식클래스를 만들어서 상속의 특징들을 검증하시요..
*/
(2) 다형성 (Polymorphism)
-> 메소드의 기능이 다양해지는 것
ex) day03/도형.java
(3) 은닉성 (Information Hiding)
-> 외부 프로그램(class)에게 정보(속성값)를 감추는 것
ex) day03/계좌.java , 해커.java
(4) 캡슐화 (Encapsulation)
-> 메소드(기능)의 모듈(modul)화
ex) day03/합.java
cf) public > protected > default(friendly) > private
///////////////////// 10 미터 전방 /////////////////////////
10. 자바의 변수(Variable)
(1) 유효범위를 기준으로 ..
1) 멤버(전역)변수
<1> 해당 ( )내에서 유효
<2> 멤버변수는 자동으로 ( )가 초기화를 해준다.
ex) day03/VT1.java
2) (메소드) 지역변수
<1> 해당 ( )에서만 유효
<2> 반드시 프로그래머가 직접 ( )를 해 줘야된다.
<3> 형태별 종류
1> 메소드 선언(과 초기화) 변수
2> ( ) 변수
ex) day03/VT2~3.java
(2) 변수 Type(형)을 기준으로..
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
<4> 담을 수 있는 값(수)의 범위
1> byte : -2^7 ~ 2^7-1 (경우의 수 : 2^8)
2> short: -2^15 ~ 2^15-1(경우의 수 : 2^16)
3> char : 0 ~ 2^16-1 (경우의 수 : 2^16)
4> int : -2^31 ~ 2^31-1(경우의 수 : 2^32)
5> long : -2^63 ~ 2^63-1(경우의 수 : 2^64)
6> float
7> double
8> boolean : false/true
ex) day03/VT4.java
<5> 자동형 변환 방향
-> XXX type -> YYY type
cf) short 과 char 사이의 형변환 -> 강제 형변환
<6> 형변환의 필요성
-> 연산시 같은 type 끼리만 연산되기 때문
ex) day03/VT5.java
<7> 초기값
-> 정수(0), 실수(0.0), 불린(false)
ex) day03/VT6.java
<8> 존재 이유 : 실행의 효율성 때문이다.
<9> 예외 연산 형변환
정수형(byte, short, char, int) 산술연산시에는
그 연산 결과 타입(형)이 무조건 ( )로 나온다.
ex) day03/VT7~8.java
<10> 컴퓨터에서의 소수 연산 오차
ex) day03/VT9.java
cf) float f = 100.123f;
double d = 200.123;
double result = f + d;
pln("result : " + result);
2) 참조형(reference type / object type) 변수
<1> call by reference
<2> 형태 : (일반적으로) 대문자로 시작
<3> 종류
8가지 기본형을 제외한 모든 type
<4> 초기값 : null
<5> 자동형변환 ( 자식 -> 부모 )
ex) Object
|
Human
|
SuperMan
<6> 일반적인 형태의 자동형변환
Human h = new SuperMan(); //자동형변환
SuperMan s = (SuperMan)h; //강제형변환
cf) 참조형 변수는 4 byte를 사용한다.
ex) day03/VT10.java
(3) 소속을 기준으로 ..
1) 클래스 소유 변수 - static 이 붙으면
2) 객체 소유 변수 - static 이 붙지 않으면
ex) day03/VT11.java
(4) 초기화값의 변화가능유무를 기준으로...
1) 상수 - final 이 붙으면 ..
2) 변수 - final 이 붙지 않으면 ..
cf) 상수는 선언과 동시에 초기화를 해야 한다.
ex) day03/VT12.java
/*
숙제3
1. 오늘 배운 개념을 생각하면서, 수업예제를 5번씩 코딩/실행해
온다.
append) 수업예제를 자기의 방법으로 변경해서 한개씩 예제를
만들어 보세요..
2. 임의의 숫자값을 입력받아서 총점과 평균을 구하는 JAVA
프로그램을 짜오세요.(선택!!)
( 참고 : day03\숙제예\Avg.java )
*/
11. 제한자 ( modifier )
(1) 설명
클래스, 인터페이스, 변수, 상수, 메소드, 생성자 앞에
붙어서 기능을 제한하는 keyword
(2) 종류
1) 접근 제한자(Access Modifier)
<1> public : 접근 제한이 없음
ex) day04/AM1.java , A.java
<2> protected : 같은 패키지 안 or 상속관계
ex) day04/AM3.java , C.java
cf) 참고
다른 패키지의 클래스가 상위클래스일 경우..
생성자를 접근(호출)시 super()로 접근한다..
<3> default : 같은 패키지 안
ex) day04/AM2.java
<4> private : 같은 클래스 안
ex) day04/AM4.java
cf) public > protected > default > private
2) 소유 제한자 ( static )
<1> 설명
붙으면 ( )에 소유되고,
붙지 않으면 ( )에 소유된다.
<2> 특징
1> 클래스 이름앞에 붙을 수 없다. (내부 클래스에선 예외)
2> 생성자 앞에 붙을 수 ( ).
3> static 변수는 지역변수로 선언될 수 ( ).
4> static 메소드에서는 다른 static 메소드나, static 변수
만을 직접 호출할 수 있다.
5> 클래스이름으로 접근한다.
6> static 자원은 모든 객체에게 '공유'되어지는 자원이다.
ex) day04/ST1.java
3) 수정 제한자 ( final )
<1> 설명 : 붙으면 수정을 못한다.
<2> 특징
1> class 앞에 붙으면 ( )를 못하게 함
2> 변수(지역/멤버) 앞에 붙으면 ( )를 못바꾸게 함
3> method 앞에 붙으면 ( )를 오버라이딩을 못하게 함
4> 생성자(constructor)에는 붙을 수 ( ).
5> 부모클래스의 상수와 동일한 일반변수를
자식클래스에서 선언하면 그것을 부모상수에
영향을 받지 않는다.
ex) day04/FT1.java
4) 추상 제한자 ( abstract )
<1> 설명 : 붙으면 추상화(化)가 된다.
<2> 붙는 여부
1> class 앞에 붙으면 추상클래스가 됨
2> method 앞에 붙으면 추상메소드가 됨
3> variable 앞에 붙을 수 없다.
4> constructor 앞에 붙을 수 없다.
( 생성자는 오버라이딩이 안되기 때문 )
<3> 특징
1> 추상클래스 란?
-> abstract 가 붙어 있는 클래스
2> 추상메소드 란?
-> abstract 가 붙어 있으면서 구현되지 않은 메소드
== (메소드 body가 없는) 메소드
3> 추상클래스의 객체는 하위클래스를 만들어
하위클래스의 객체를 만들어 형변환해서 만들어 짐
4> 하나 이상의 추상메소드가 가진 클래스는
반드시 추상클래스가 되어야 한다.
5> 하위클래스는 상위클래스를 추상메소드를 반드시
모두 구현(재정의)해야 한다.
ex) day04/AT1.java
5) 기타 제한자
synchronized (쓰레드), transient (보안)
native (System 자원 사용), volatile
/////////////////////////// 숙제 //////////////////////////////
오늘 배운 개념을 생각하면서, 수업예제를 3번씩 코딩/실행해
온다.
- 수업예제를 자기의 방법으로 변경해서 예제를 만들도록 노력..
- 변경하고나면 반드시 컴파일/실행
////////////////////////////////////////////////////////////////
12. 식별자( Identifier )
(1) 설명
개발자가 임의로 만드는 패키지, 클래스, 메소드, 변수
이름을 의미함
즉, 식별자 <-> 예약어(JVM에서 예약한 단어)
(2) 규칙
1) 식별자의 첫문자는 숫자여서는 안된다.
2) 문자와 숫자, 특수문자(_, $)의 조합으로 만들 수 있다.
3) _와 $는 첫문자여도 가능하다.
4) 길이의 제한은 없다.
ex) day05/IT1.java
(3) 관례
1) 의미있는 단어를 사용한다.
2) 클래스/인터페이스 이름의 첫문자는 대문자로 한다.
3) 메소드/변수/패키지 이름은 첫문자를 소문자로 한다.
4) 단어와 단어의 결합으로 된 식별자는 다음 단어의
첫문자를 대문자로 하거나 _로 연결한다.
5) $는 잘 사용하지 않는다.
6) 상수는 모든 문자를 대문자로 한다.
13. 오버라이딩과 오버로딩
(1) (메소드) 오버라이딩(재정의)
1) 설명
상속관계에 있는 클래스에서 부모 메소드 내용(기능)을
자식클래스에서 바꾸는 것
2) 조건
<1> 반환타입이 같아야 한다.
<2> 부모메소드의 접근제한자보다 자식메소드의
접근제한자가 같거나 넓어야 한다.
<3> 인수(파라미터)의 종류와 순서도 같아야 한다.
ex) day05/OverRa.java
(2) 오버로딩
1) 설명
호출시 그 해당 메소드나 생성자에 매핑되어
호출되도록 인수의 종류와 순서가 다른,
같은 이름의 메소드나 생성자를 정의하는 것
2) 종류
<1> 생성자 오버로딩
<2> 메소드 오버로딩
3) 조건
<1> 인수의 종류나 순서가 달라야 한다.
<2> 반환타입과는 관계가 없다.
<3> 상속과 관계가 없다.
<4> 형변환이 가능한 인자라도 오버로딩으로 인정한다.
cf) 자동형변환이 가능한 인자는 자동형변환되어
해당 생성자나 메소드에 매핑된다.
ex) day05/OverLo.java
14. this 와 super
(1) this
1) 설명 : 자기 자신의 객체를 지칭하는 대명사
2) 일반적 사용
<1> 메소드 안에서 지역변수와 이름이 같은 멤버변수를
접근할 때
<2> 자기 자신의 주소값을 다른 클래스에게 넘길 때
ex) day05/TT1~3.java
(2) super
1) 설명 : 부모 클래스의 객체 or 클래스를 지칭하는 대명사
2) 일반적 사용
<1> 부모 클래스의 생성자를 호출(부모 클래스)
<2> 오버라이딩 하기전의 부모 메소드를 호출 (부모 객체)
<3> 동일한 단어의 부모 변수를 접근할 때(부모 객체)
ex) day05/ST1.java
15. 인터페이스 (interface)
(1) 설명
모든 메소드가 추상메소드, 모든 속성이 상수(대문자)
로 구성된 틀
즉, 추상메소드와 상수로만 구성된 '껍데기'
(2) 생김새
ex) day05/Inter1.java
(3) 특징
1) 접근제한자는 ()과 ()만 가능하다.
( public 이면 이름이 ()과 같아야 한다.)
2) interface 앞에는 abstract 생략
method 앞에는 abstract 생략
멤버변수 앞에는 final 과 static 생략
3) 하위(구현)클래스에서 오버라이딩할 때에는
접근제한자는 public 으로 해야 한다.
4) 인터페이스 객체는 반드시 하위(구현)클래스를
만들어 그 객체를 형변환하여 생성한다.
5) 하위(구현/자식) 클래스로 하여금 인터페이스는
다중상속을 가능하게 한다.
6) 하위클래스 제작시 implements 라는 예약어를 사용한다.
7) static 변수는 존재할 수 있지만,
static 메소드는 존재하지 않는다.
8) 인터페이스끼리도 다중상속(extends)이 가능하다.
9) class 와 interface 도 다중상속(implements)이 가능하다.
10) 인터페이스에는 생성자가 없다.
ex) day05/Inter1~2.java
(4) 추상클래스와 비교
1) 공통점
<1> 추상메소드가 있을 수 있다.
<2> 반드시 자식(구현)클래스를 만들어서
그 객체로부터 형변환하여 객체를 생성한다.
2) 차이점
<1> "클래스"이고, "인터페이스" 이다.
<2> 추상클래스는 다중상속이 불가능하다.
<3> 추상클래스는 일반변수와 일반메소드가 포함될 수 있다.
16. 인터페이스와 추상클래스를 사용하는 목적( 다형성 )
구현메소드의 내용을 알 필요없이 인터페이스나 추상클래스의
내용만 알면 개발자가 구현클래스를 이용해서 프로그램을
작성할 수 있음
즉, 타 소프트웨어와 독립적인 프로그램을 작성할 수 있다.
( JDBC / RMI / EJB spec .. 각 종 드라이버 )
ex) day05/Vehicle.java , Terminator3.java
cf) 인터페이스는 "껍데기" 이다.
인터페이스는 "통로" 다.
인터페이스는 "메뉴판" 이다
////////////////////// 숙제 //////////////////////////////////
오늘 배운 개념을 생각하면서, 수업예제를 3번씩 코딩/실행해
온다.
- 수업예제를 자기의 방법으로 변경해서 예제를 만들도록 노력..
- 변경하고나면 반드시 컴파일/실행
////////////////////////// 월요일 ////////////////////////////
17. 패키지 ( package )
(1) 설명
비슷한 종류의 기능을 가진 클래스/인터페이스들의 묶음
(2) 생김새
자바 파일을 최상단에 package 라는 keyword를 사용
(3) 컴파일 방법
#> javac -d . XXX.java // 상대경로
#> javac -d ./classes XXX.java // 상대경로
#> javac -d E:\TESTING XXX.java // 절대경로
(4) 실행법
#> java aa.bb.PT1
ex) PT1.java
(5) 압축법
#> jar -cvf XXX.jar aa
(6) classpath ( ********** )
1) 설명
클래스를 메모리에 로딩하기 위해서는 JVM에서
해당 클래스를 찾아야 하는 데, 그 찾는 경로를
바로 classpath 라 한다.
2) 특징
컴파일되어 만들어진 패키지를 classpath 걸어주면,
System 의 어느 위치에서든지, 우리가 만든 클래스들을
사용할 수 있다.
일반적으로 패키지 디렉토리를 classpath 거는 방법
보다 패키지를 압축해서 그 압축파일(.jar)을
classpath 걸어주는 방법이 많이 사용된다.
3) classpath 거는 방법 ( 울트라 수퍼 무한대 * )
<1> 컨솔창에서 -classpath 옵션을 이용하는 법
( 유효 범위 : javac.exe, java.exe )
1> 디렉토리 이용
#>javac -classpath C:\~\day06 PT1Test.java
#>java -classpath .;C:\~\day06 PT1Test
2> jar 이용
#>javac -classpath C:\SOO\JAVA\soo.jar PT1Test.java
#>java -classpath .;C:\SOO\JAVA\soo.jar PT1Test
<2> 컨솔창에서 set classpath 를 이용하는 법
( 유효 범위 : 해당 컨솔창 )
1> 디렉토리 이용
#>set classpath=%classpath%C:\SOO\JAVA\BEGIN\day06
#>javac PT1Test.java
#>java PT1Test
2> jar 이용
#>set classpath=%classpath%C:\SOO\JAVA\soo.jar
#>javac PT1Test.java
#>java PT1Test
<3> 바탕화면 -> 내컴퓨터 -> 고급 -> 환경변수 법
( 유효 범위 : OS 시스템 )
1> 디렉토리 이용
classpath => .;C:\SOO\JAVA\BEGIN\day06
2> jar 이용
classpath => .;C:\SOO\JAVA\soo.jar
<4> 자동 클래스패스 디렉토리 이용법
( 유효 범위 : JVM 시스템 )
1> 디렉토리 이용
-> 안됨!!
2> jar 이용
C:\~\jdk1.5.0_15\jre\lib\ext 하위에
XXX.jar 를 붙여넣는 법
cf) bat 파일을 만드는 법
/////////////////////// 1미터 전방 끝 ///////////////////////
18. 연산자 ( Operator )
(1) 설명 : 변수들을 연산하게 하는 기호
(2) 종류
1) 산술 연산자
ex) +, -, *, /, %
2) 증감 연산자
ex) ++, --
3) 대입 연산자
ex) =
4) 산술할당(대입) 연산자
ex) +=, -=, *=, /=, %=
5) 비트 연산자
ex) &, |, ^, ~, 시프트연산자(<<, >>, >>>)
6) 비교 연산자
ex) ==, !=, <, >, <=, >=
7) 논리 연산자
ex) &&, &, ||, |, !
8) 논리할당(대입) 연산자
ex) &=, |=
9) 조건 연산자
ex) 삼항 연산자 ( A? B:C )
10) instanceof 연산자
ex) 객체변수 instanceof 클래스이름
ex) day06/OperatorTest.java
19. 조건문
(1) if(boolean형){} 문
(2) if(boolean형){}.. else if(boolean형){}.. 문
(3) if(boolean형){}.. else if(boolean형){}.. else{} 문
(4) switch(정수형){case.. default} 문
주의) 정수형 , break , default 위치, case{}블럭이 없음,
labled break문
ex) day06/IfTest1.java ,SwitchTest1.java
////////////////////////// 숙제 //////////////////////////////
1. 오늘 배운 개념을 생각하면서, 수업예제를 3번씩 코딩/실행해
온다.
2. if 문과 switch 문을 만들어 서로 호환을 해보자.
3. 점수를 입력하면 해당학점을 출력하는 프로그램을 만드세요.
#> 점수를 입력하세요.. : 80
#> 당신의 학점은 B 입니다.
참고) Input.java
/////////////////////////////////////////////////////////////////
20. 반복문
-> 초기식(loop밖), 조건식, 증감식(loop안) 으로 구성
(1) while(boolean형){}
-> 조건을 미리 판단하므로 loop가 한번도 수행되지 않을 수 있음
ex) day07/WhileTest1.java
(2) do{} while(boolean형);
-> 조건을 나중에 판단하므로 적어도 한번은 loop 수행
ex) day07/DoWhileTest1.java
(3) for(초기식;조건식;증감식){}
ex) day07/ForTest1~6.java
/////////////////////////// 숙제 ////////////////////////////////
* * * *
* * * *
* * * *
* * * *
*
* *
* * *
* * * *
*
* *
* * *
* * * *
* * * *
* * *
* *
*
*
* * *
* * * *
* * * * * *
////////////////////////////////////////////////////////////////
21. 제어의 이동 ( 수퍼 울트라 * )
(1) 제어 란?
어떤 프로그램이 실행되고 있을 때
어느 한 시점에서의 CPU 연산은 어떤 특정 코드부분을
을 실행하고 있을 것이다.
그 코드부분을 제어점이라하고 그 제어점들의 집합을
제어라 한다.
즉, 프로그램의 실행흐름을 제어라 말할 수 있다.
(2) 제어 경로의 일반화
JVM -> main() -> ........ -> main() -> JVM
(3) 제어권
CPU 연산을 실행할 수 있는 권한
(4) 제어의 이동 예약어( ***** )
1) break
<1> 반복문 : 자기를 둘러싼 반복블럭(루프)를 나간다.
<2> switch문 : 자기를 둘러싼 switch블럭을 나간다.
참고) labled break 문
ex) day08/BreakTest1~2.java
2) continue
(해당 조건에 맞으면) 건너뛴다.
참고) labled continue 문
ex) day08/ContinueTest1~2.java
3) return
(메소드를) 호출한 놈/곳(소프트웨어/메소드)에게 제어권을 넘긴다.
ex) day08/ReturnTest1~2.java
22. 예외 처리
(1) 예외(Exception)
프로그램이 정상적으로 진행되지 못하게 하는 돌발상황
ex) 프로그램 실행 중 전원이 갑자기 꺼짐,
파일을 읽는 중 삭제되는 경우,
숫자가 아닌 문자를 숫자로 바꿀 때,
채팅하다가 상대방이 갑자기 나가버린 경우, ...
(2) 예외 관련 class계층도
Object
|
Throwable
| |
Error Exception
| |
CheckedException RuntimeException
cf) Error 는 자바 시스템관련 문제시 발생하는 문제이기
때문에 프로그래머가 잡을 수 없다.
Exception 만 프로그래머가 잡을 수 있는 데,
CheckedException 은 컴파일러가 컴파일시 체킹하는
예외이고, RuntimeException 은 실행시에 체킹하는
예외로써.. 처리를 안하더라도 컴파일이 정상적으로
수행된다.
예) CheckedException -> IOException, ..
RuntimeException -> NumberFormatException, ...
ex) day08/ExcepTest1.java
(3) 예외처리의 목적
프로그램 진행시 발생할 수 있는 돌발상황을 예외로
미리 정해놓고, 해당하는 상황의 예외가 발생했을 경우
적절한 조치를 취해서 프로그램이 정상적으로 작동하도록
하는 것이다.
ex) day08/ExcepTest2.java
(4) 예외의 특징
1) 예외는 메소드 or 생성자에서만 발생한다.
2) 클래스 설계시 예외를 발생시킬 때는 throw 라는
예약어를 사용한다.
3) 예외가 발생하는 메소드 or 생성자에는
throws 예약어로 예외를 호출하는 놈/곳으로 넘기거나
( == 예외를 처리해야 한다는 명시를 하거나 )
try~catch 절로 잡아야 한다.
4) 예외는 자신의 Exception 또는 그 상위 Exception 으로
잡을 수 있다.
ex) day08/ExcepTest3.java , ExcepTest4.java
(5) 예외처리의 방법
1) 첫번째 방법 (예외를 잡아버리는 방법)
try
{
예외를 발생시키는 구문
(예외발생 메소드/생성자)
}
catch (발생된 예외 객체)
{
예외 발생시 처리 로직
(넘어온 예외 객체를 이용)
}
2) 두번째 방법 (예외를 (호출한 놈/곳으로) 넘기는 방법)
throws 절로 넘기는 방법
(6) try블럭에 두개 이상의 Exception 발생시 처리
1) 상속관계의 Exception 이라면
( 더욱 구체적인 Exception 처리를 하기 위해 )
하위 Exception 부터 잡아준다.
2) 상속관계가 아닌 Exception 이라면
-> catch() 절의 위치는 상관이 없다.
ex) day8/ExcepTest6.java
(7) finally 절
1) 설명 :
( try{}가 수행되고 나서 or
try{}와 catch{}절이 수행되고 나서)
항상 수행되는 절이다.
2) 특징
<1> try{}절이 먼저 기술되어야 나올 수 있다.
<2> try{}절이 기술되면 반드시 catch()절 or
finally{}절이 나오던지 아니면
둘다 나오던지해야 한다.
<3> 심지어는 return 을 만나더라도 수행된다.
예외) System.exit(숫자) 를 만나면 예외
ex) day8/ExcepTest7.java
// 자신의 Exception 클래스를 만들어서 예외를 테스팅해보세요..
23. 묵(암)시적인 import 와 extends
(1) 모든 자바프로그램 상단에는 import java.lang.*; 생략!
(2) extends 가 기술되지 않은
모든 자바클래스에는 extends Object 가 생략!
24. 메모리 구조
(1) 영역
1) stack : 질서 정연한 구조
2) heap : 무질서 구조
3) static : 공유되어지는 공간
(2) 영역별 역할
1) stack (변수 할당 공간)
변수가 선언되면 stack 의 한부분에 그 변수를
위한 주소가 할당되고 그 값은 null 로 초기화
된 상태로 존재한다.
( ex: String str; int i; )
2) heap (객체 할당 공간)
new 연산자에 의해 객체가 생성될 때
heap의 어느 한 주소에 객체가 만들어지고
그 주소값은 stack 에 할당된 변수에 저장된다.
( ex: str = new String("자바"); )
cf) 기본형 데이터일 경우에는 stack 에 할당된
변수에 직접 값이 할당된다.
( ex: i = 100; )
3) static ( 클래스/인터페이스/static 자원 할당 공간 )
25. 가비지 컬렉터
(1) 설명
JVM(자바가상머신)에 포함된 자동메모리관리 소프트웨어
(2) 기능
더 이상 자바프로그램 진행상 쓰이지 않는 불필요
객체들(가비지-쓰레기)을 메모리에서 제거한다.
(3) 특징
1) 일정한 cycle 형식으로 구동된다.
2) 해당 대상객체(가비지)의 주소값을 저장하고 있는
변수가 주소값을 잃어버려도(null) 프로그램 수행상
필요하다고 판단되면 컬렉팅을 하지 않는다.
즉, 또 다른 객체에서 참조하고 있는 경우에는
절대 컬렉팅되지 않는다.
3) 가비지 컬렉터는 프로그램가 핸들링할 수 없다.
하지만, 구동을 촉구하는 메소드는 존재한다.
( ex: System.gc(); )
ex) day09/GCTest1.java
26. 배열( Array - '여관' )
(1) 설명
같은 타입(Type)의 참조형 or 기본형 데이터를 저장하는
저장소로서, 생성될 때 그 크기가 고정되는 '객체'
(2) 선언
type 배열변수[];
( ex: int is[], int[] is, int []is, int [] is,
String strs[] )
(3) 생성
new type[저장소크기]
( ex: is = new int[5], strs = new String[3] )
(4) 배열방의 default 초기값
1) 기본형
<1> 정수(byte, short, char, int, long) -> 0, 0L
<2> 실수(float, double) -> 0.0f, 0.0
<3> 불린(boolean) -> false
2) 참조형(레퍼런스형) -> null
ex) day09/ArrayTest1.java
(5) 초기화
확보된 공간(방)에 데이터를 넣는 것
( ex: strs[0]="봄";, is[0]=10; )
ex) day09/ArrayTest2.java
(6) 선언/생성
type 배열변수[] = new type[저장소크기];
( ex: int is[] = new int[3]; String strs[] = new String[3])
(7) 선언/생성/초기화
type 배열변수[] = {데이터1, 데이터2, 데이터3, ..};
( ex: int is[] = {10, 20, 30}
String strs[] = {"봄", "여름", "가을", "겨울"})
cf) "선언/생성/초기화"를 함께 할때는 선언을 따로 분리
할 수 없다.
ex) day09/ArrayTest3.java
(8) 배열값의 형변환
( ex: short ss[] = {b, s, (short)i}
Object objs[] = {new String("감자"), new Object()})
ex) day09/ArrayTest4.java
(9) 이차원배열
'일차원배열'을 하나의 '데이터'로 취급하는 배열
ex) day09/ArrayTest5.java
(10) 삼차원배열
'이차원배열'을 하나의 '데이터'로 취급하는 배열
///////////////////////// 숙제 ///////////////////////////////
숙제 : 배열을 써서 lotto 게임을 짜오세요..
참고) RandomTest.java 참고
//////////////////////////////////////////////////////////////
27. 객체의 관계
(1) is a 관계 ( 상속관계 or 자신 )
class SuperMan extends Human
1) SuperMan is a SuperMan ( O )
2) Human is a Human ( O )
3) SuperMan is a Human ( O )
4) Human is a SuperMan ( X )
5) Human is a Object ( O )
(2) has a 관계
class Human{
String name = "홍길동";
int age = 25;
}
1) Human has a name ( O )
2) Human has a age ( O )
3) name has a Human ( X )
4) SuperMan has a Human ( X )
28. 검증문 ( assertion ) //SCJP 때문에 함
(1) 설명
조건(true/false) 을 쉽게 검증하기위해 JDK1.4버젼
부터 지원되는 명령문
(2) 사용법
1) 코딩법
<1> assert 조건 : String객체;
<2> assert 조건;
2) 컴파일
#>javac -source 1.4 XXX.java
3) 실 행
#> java -ea XXX
(3) 결과
1) 조건(true/false)이 참인 경우는 assert 문이
수행되지 않고, 거짓일 때만 AssertionError 와
String객체 내용이 출력된다.
2) 정상컴파일(javac XXX.java)와 정상실행(java XXX)
을 할 때에는 assert문의 조건은 영향을 끼치지 않는다.
(4) 사용 이유
따라서, 개발자가 개발시 어떠한 조건을 판단하는 데
쓸데 없는 코딩을 없앨 수 있다.
ex) day10/AssertTest.java
29. 내부 클래스 (inner class) //여러분이 합니다...
(1) 설명
클래스 내부에 포함되어있는 또 다른 클래스
(2) 용도
(3) 특징
(4) 형태
(5) 객체 생성법
/////////////////////// JAVA 기본 문법 끝 ///////////////////
30. 주요 클래스
(1) java.lang.Object ( ***** )
1) 모든 클래스의 부모 클래스(가장 상위 클래스)
2) 주요메소드
toString(), getClass(), equals(Object obj)
ex) day10/ObjectTest.java
(2) java.lang.Math
1) 수학 계산시 사용
2) static 상수 (E, PI) 와 static 메소드만으로 구성
ex) day10/MathTest.java
(3) java.lang.String 클래스 ( 불변 클래스 ***** )
1) final 클래스 (자식을 낳지 못한다.)
2) 상수( CASE_INSENSITIVE_ORDER )
-> 대소문자를 무시한 순서값을 가진 Comparator
객체를 반환
ex) day10/StringTest1.java
3) 다양한 생성자(13개)와 메소드 존재
ex) day10/StringTest2.java
//숙제 : String 메소드들을 Testing 해 보세요.
4) Object 의 overiding 메소드
<1> toString()
<2> equals()
ex) day10/StringTest3.java
5) new 로 생성한 객체는 무조건 새로운 객체가
생성되고, ""로 생성한 객체는 메모리상에 동일한
내용의 ""로 이미 생성된 객체가 있다면 그 객체를
참조한다.
6) String 은 불변클래스
-> 메소드나 연산을 할 경우 자신이 생성될 때의
내용이 절대 변하지 않고, 새로운 객체를 생성한다.
ex) day10/StringTest4.java
(4) java.lang.StringBuffer 클래스 ( 가변 클래스 *** )
1) final 클래스
2) 생성자 4개와 다양한 핸들링 메소드 존재
3) String 의 "창고" 역할
<1> String 의 내용을 추가/입력/삭제/수정 할 때
(창고의 내용 변화시) 변화된 String 객체가
새로 생성되지 않는다.
즉, 기존의 StringBuffer 객체 내용이 변화한다.
<2> 결국, String 을 가공할 때에 쓸데없는 중간
객체가 덜 생성되기 때문에 String 보다 효율적인
프로그램이 가능하다.
ex) day10/SBTest.java
(5) java.lang.StringBuilder 클래스 // JDK 5.0 이상부터 지원
-> StringBuffer 클래스와 같은 기능인데, 빠르다.
이유는 StringBuffer에 있는 멀티쓰레드에 의한
동기화 메커니즘이 빠져 있기 때문이다.
(6) java.util.StringTokenizer 클래스
1) String 을 delimeter String 를 기준으로 잘라서
작은 단위의 문자열(Token)을 리턴 역할
2) 생성자 3개
3) 주요 메소드
nextToken(), hasMoreTokens()
ex) day10/STTest.java
/////////////////////////////////////////////////////////////
숙제 : 가위/바위/보 game 을 만들어 오세요.
/////////////////////////////////////////////////////////////
(7) java.lang.래퍼(Wrapper) 클래스 ( ***** )
1) 기본형 8가지를 클래스화 시킨 클래스
2) 대문자 시작
3) Boolean, Byte, Short, Character,
Integer, Long, Float, Double
4) 객체 직렬화(Serializable)가 가능한 클래스
5) final 클래스
6) 장점 : 메소드나 속성을 사용할 수 있다.
단점 : 무겁다
ex) day10/WrapperTest.java
(8) java.util.Calendar 클래스
1) 추상클래스
2) 날짜와 시간관련 다수의 field 존재
3) 생성자 2개와 다수의 날짜관련 핸들링 메소드 존재
ex) day10/CalendarTest.java
/////////////////////////////////////////////////////////////
숙제 : 컨솔 달력을 만들어 오세요.
/////////////////////////////////////////////////////////////
(9) java.util.Date 클래스
1) 생성자 6개, field는 없음
2) 다수의 시간관련 핸들링 메소드
3) Calendar 와 비슷한 기능을 가진 클래스
ex) day10/DateTest.java
(10) java.util.Random 클래스
1) 생성자 2개와 다수의 메소드
2) 임의의 기본형(boolean, int, float , double)
데이터를 리턴
-> Math.random() 보다 더 다양한 type값 리턴
(11) Collection 계열 클래스 ( ***** )
1) 설명
(모든) 참조(Object)형의 데이터를 저장할 수 있는 가변
배열 클래스
2) 상속도
<1> java.util.Collection
| |
java.util.List java.util.Set
| |
ArrayList/Vector java.util.SortedSet
|
TreeSet
<2> java.util.Map
|
Hashtable/HashMap/TreeMap
3) 특징 ( SCJP )
<1> List
1> 중복을 허용
2> 순서를 보존
<2> Set (수학에서 집합)
1> 중복을 허용하지 않음
2> 순서를 보존하지 않음 (순서에 무관)
<3> Map (수학에서 일대일 대응)
1> key 와 value 의 한쌍으로 저장
2> key값은 중복을 허용하지 않고,
value값은 중복을 허용함
3> 순서를 보존하지 않음
4> key가 중복되면 기존의 value값이
현재의 value값으로 대체(덮어씀) 됨
cf) jdk 5.0 버젼 이상부터는 기본형을 넣으면
Wrapper 클래스객체로 자동변환되어 저장된다.
( Auto Boxing )
4) 주요 클래스
<1> Vector ( implements List )
1> 필드 4개, 생성자 4개, 메소드 다수
2> 쓰레드에 대한 동기화 메커니즘이 적용된 클래스
ex) VectorTest1~5.java, Boxing.java
<2> ArrayList ( implements List )
1> 필드 1개, 3개, 메소드 다수
2> 동기화 메커니즘이 없는 대신 Vector 보다 가볍다.
<3> TreeSet ( implements Set)
1> 생성자 4개, 다수의 메소드
2> SortedSet 상속으로 정렬기능이 추가
ex) TreeSetTest.java
<4> Hashtable ( implements Map )
1> 생성자 4개, 다수의 메소드
2> 쓰레드에 대한 동기화 메커니즘이 적용된 클래스
ex) HashtableTest.java
HashtableTest2.java (제너릭으로 바꿔라..)
cf) jdk 5.0 이상에서 지원되는 기술
- AutoBoxing / UnBoxing
- 제너릭
//////////////////////////////////////////////////////////////
1. 세미 프로젝트 ( 가위바위보/달력/MyLifeTime )
2. 복습 ( 주요 클래스 수업 쏘스를 변형하면서 코딩/실행 API )
///////////////////// 내일 - 쓰레드 /////////////////////////
(12) java.lang.Thread 클래스
1) 설명
프로세스를 구성하는 제어의 흐름
2) Process 와 Thread 의 차이
<1> Process : 프로그램의 실행 단위
<2> Thread : Process 를 구성하는 작업 단위
ex) day12/ThreadTest1.java
3) 장점
쓰레드는 경량프로세스라고 일컬어 질 정도로 가볍다.
이유는 프로세스의 공통 resource 를 공유하기 때문에
그렇다.
4) Thread 를 생성하는 2가지 방법
<1> java.lang.Thread 클래스를 상속받는 방법
ex) day12/ThreadTest2.java
<2> java.lang.Runnable 인터페이스를 구현하는 방법
ex) day12/ThreadTest3.java
5) 쓰레드 시작 메소드
쓰레드객체.start();
6) 비유 : 고용인
(예)
<1> 파일공유[소리바다/프루나] 프로그램에서
여러파일을 동시에 다운로드하는 것
<2> word에서 입력과 동시에 오타를 처리하는 것
<3> 웹브라우져에서 다운로드 받으면서 웹서핑을
하는 것
<4> 스타크래프트의 인물들, 배경음악
ex) day12/Restaurant.java
7) Thread의 Priority
<1> 설명
Ready 상태의 쓰레드중에서, 우선적으로 CPU를
점유할 수 있는 쓰레드를 판별하기 위한 LEVEL값
<2> 범위
1 ~ 10 ( 총 10개 )
<3> 상수
1> MAX_PRIORITY
2> MIN_PRIORITY
3> NORM_PRIORITY
ex) day12/ThreadTest4.java
8) Thread 의 LifeCycle
<1> 라이프 싸이클은 5가지 상태로 구성된다.
<2> 상태이동은 메소드나 스케쥴러에 의해서만
가능하다.
<3> 소멸상태는 run()의 {}가 수행완료되면 자동으로
이동된다.
( 단, main쓰레드에서는 main()의 {}가 수행완료되면
자동으로 소멸상태로 이동된다. )
<4> wait() / notify() / notifyAll() 은 항상
synchronized 블럭안에서 사용되어야 한다.
(그렇지않으면, IllegalMonitorStateException
발생된다.)
<5> wait() / sleep() 사용시에는
InterruptedException 잡아줘야 한다.
cf) 쓰레드의 LifeCycle.ppt 참고
9) 주요 메소드
<1> sleep(시간);
- 쓰레드의 흐름을 ready상태로 보냈다가
지정된 시간이 지나면 running 상태로 이동
cf) 시간단위 : millisecond (ms)
<2> join()
- 자식쓰레드에 join()을 적용하면 부모쓰레드가
그 자식이 죽을 때까지 기다린다.
cf) 탄생 시킨 쓰레드 : 부모 쓰레드
ex) day12/ThreadTest5.java
<3> yeild()
1> 만나면 ready상태로 들어갔다가 스케쥴러에
의해 실행될 쓰레드가 다시 선택되어진다.
2> 양보받는 쓰레드가 양보하는 쓰레드보다 우선
순위가 같거나 높은 경우에 양보(CUP점유)를
하게 보일 수 있다.
3> 결국, 다음 실행될 쓰레드는 스케쥴러에게 달려
있다.
ex) day12/ThreadTest6.java
cf) 자식쓰레드에서 자식쓰레드를 생성
ex) day12/ThreadTest7.java
10) 쓰레드의 동기화
<1> 설명
하나 이상의 쓰레드가 어떤 연산에 동시에 접근했을 때,
그 연산에 대한 값을 무결성을 보장하기 위해서 수행
영역에 대한 lock을 걸어주는 것
<2> 비유
화장실의 문꼬리
<3> 예
i++;
# CPU 연산 단계 #
1> 현재의 i을 읽는다. i==0; i==0
2> i값을 증가시킨다. i==0;
3> 증가된 i값을 i변수에 저장한다.
<4> 방법
synchronized 제한자를 메소드나 어떤 영역(블럭)에
써주면 그 영역에 대해서 동기화처리가 되어진다.
1> synchronized void methodA(){연산들}
2> void methodA(){
{synchronized(this){연산들}}
연산들;
}
ex) day12/ThreadTest8.java
<5> 특징
1> synchronized 로 감싸진 영역을 동기화블럭이라
고 한다. 동기화 블럭에서는 동시에 오직 하나의
쓰레드만이 작업을 수행할 수 있다.
2> synchronized 는 추상메소드 앞에는 붙을 수 없다.
ex) day12/ThreadTest9.java
////////////////////////////////////////////////////////////////
숙제: 복습 ( 주요 클래스 수업 쏘스를 변형하면서 코딩/실행 API )
///////////////////////// 수업끝 ////////////////////////////////
31. JDK 5.0에 추가된 기술
(1) 제너릭( Generic )
(ex: Vector<String> v = new Vector<String>() )
(2) 오토박싱/언박싱( Autoboxing / Unboxing )
(ex1: Integer iObj = 10 ) - Autoboxing
(ex2: int i = new Integer(10) ) - Unboxing
(3) 포멧을 이용한 출력
String x = "하나";
String y = "둘";
System.out.printf("x : %s ,하하 y : %s%n", x, y);
ex) day13/FormatOut.java
(4) 인핸스트 루프( Enhanced Loop )
ex) day13/NewFor1~4.java
cf) Map 계열은 되지 않는다.
(5) Enumeration
ex1) day13/OldConstantUser.java
ex2) day13/NewConstantUser.java
cf1) 상수를 이용하는 데 단점들
<1> 상수가 많아지면 상수정의클래스를 만들어야 한다.
<2> 상수의 이름이 길어진다.
( ex: MENU[클래스이름대변]_FILE )
<3> 대입되는 상수의 특별한 의미가 없다.
<4> 반복을 돌리기 어렵다.
<5> switch문에서 정수형변수를 따로 정의해 줘야 한다.
(6) static import
ex) day13/StaticImport.java, SooMenu2.java
(7) Varargs (인자값을 넘길 때 유용한 기술)
ex) day13/NewPara.java
(8) StringBuilder
-> StringBuffer 의 비동기버젼 클래스
////////////////////////// BEGIN 끝 //////////////////////////