※ 차례 ※
1. 접근지정자
2. public static void main(String[] args)
3. 변수와 형변환
4. BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
5. printf 출력문
6. 윤년 구하는 공식
7. 소문자는 대문자로, 대문자는 소문자로 변환 공식
8. if문
9. Scanner sc = new Scanner(System.in);
10. 3개의 수 중 작은수에서 큰수 순서 출력 공식
11. 반복문
12. switch문
13. 배열
14. Selection Sort (공식)
15. 확장 for문 : 배열형태 (컬렉션)에서만 사용가능
16. Random rd = new Random();
17. String Class
18. 배열의 배열
19. 선언 위치에 따른 변수의 종류
20. 같은 패키지 내에서는 클래스 이름 틀려야 한다.
21. 오버로딩(Overloading)
22. 생성자
23. 초기화 블럭
24. 인수 전달 방법
25. 상속
26. 오버라이드(Override)
27. String Class (2)
28. String을 보조해주는 class
29. Integer(int)
30. 자주 사용하는 String의 메소드
31. Wrapper 클래스
32. Calendar 클래스
33. Singleton
34. final (상수)
35. 추상 클래스 (abstract class)
36. 상속관계에서 Upcast & Downcast
37. 내부 클래스 (inner class)
38. 인터페이스 (Interface)
39. 컬렉션 프레임워크 (Collection Framwork)
40. 배열 정렬
41. Generic (제너릭)
42. 예외 처리 (Exception)
43. @SuppressWarnings("unused")
44. 스레드 (Thread)
45. 스트림 (Stream)
46. AWT(Abstract Window Toolkit)
47. Class 클래스
48. 정규화 표현식
49. Network
50. JDBC
1. 접근지정자
public : 다른 모든 클래스에서 접근 허용.
default : (package-private) 같은 패키지의 클래스에서만 접근 허용.
protected : 같은 패키지 또는 자식 클래스에서 접근 허용.
private : 클래스 내에서만 접근 허용. (상속받은 서브 클래스에서 접근 불가)
2. public static void main(String[] args)
static : 자기 스스로 메모리 상에 올라간다.
void : 반환값(return) 없음.
main : (메소드) 출입문처럼 반드시 있어야 함.
※ method : 어떤 일을 처리하는 실행문들을 모아 놓은 블록. (첫글자 반드시 소문자)
※ class : 객체를 생성하기 위한 필드와 메소드 정의된 것. 객체의 설계도. (첫글자 반드시 대문자)
※ object : 물리적으로 존재하거나 추상적으로 생각할 수 있는 것 중 자신의 속성을 가지고 다른 것과
식별 가능한 것.
args : 매개변수.
3. 변수와 형변환
compile : 컴퓨터가 이해할 수 있도록 0과 1로 이루어진 기계어로 변환하는 과정
compile 오류 : 실행자체가 안됨 (빨간줄)
runtime 오류 : 실행되지만 안됨 (int에 22억 넣을 때)
variable : 하나의 값 저장할 수 있는 메모리 공간. 프로그램에 의해 수시로 값 변동 가능.
로컬 변수(지역 변수) : 메소드 블록 내 선언된 변수. 메모리 실행 끝나면 자동으로 사라짐.
변수 선언 : 어떤 식별자, 어떤 데이터 가진 변수라는 것 알림.
할당 : 변수에 값 넣거나 저장
참조 : 변수에 접근.
변수는 메모리 공간을 따로쓴다.
int(byte<short<char(음수X)<int<long) : 정수자료형 (범위 : 약 -21억~+21억)
float,double : 실수자료형
암시적형변환(자동 타입 변환) : 자동으로 타입 변환. 값의 허용 범위 작은 타입이 큰 타입으로 저장될
때 발생.
명시적형변환(강제 타입 변환) : 강제로 타입 변환. 값의 허용 범위 큰 타입이 작은 타입으로 쪼개어
저장하는 것.
boolean: true/false(1byte)
byte : 1byte -128~127
short : 2byte
int : 4byte
long : 8byte
float : 4byte(단정도:3.14f)
double : 8byte(배정도:3.14)
char : 2byte
문자상수 : 'a' - 하나의 문자 저장
산술연산자
+ - * / % ++(+1) --(-1)
관계형 연산자
<, >, <=, >=
등가연산자
==, !=
논리연산자
&&(and), ||(or), !(not)
if (a!=0 && b!=0) (||안됨)
삼항연산자
조건?참일때값:거짓일때값;
대입연산자
=, +=, -+, *=, /= (빈도적음)
비트연산자 (이진수연산자)
&, |, ^, ~, >>, <<, >>>
---------------------------
int a=10; (4byte)
float b; (4byte)
b=a; //10.0 - 암시적 형변환
b=(float)a; //10.0 - 명시적 형변환
a=b; //X
a=(int)b; //O - 명시적 형변환
4. BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.in : 키보드로 입력한 1byte문자. (System은 많이써서 자바랭에 임포트되어 있다.)
InputStreamReader : 1byte문자를 2byte로 변환.
BufferedReader : 메모리에 저장공간을 만들어 입출력 속도를 빠르게 함.
선언 - 입력 - 연산 - 출력 구조.
float 오류 - 이진수의 오류.
5. printf 출력문
\n : 줄바꿈
\t : 탭
%b : boolean 형식
%d : 정수 형식
%o : 8진수 정수 형식
%x, %X : 16진수 정수 형식
%f : 실수 형식
%g : 실수 형식
%c : 문자 형식
%s : 문자열 형식
%n : 줄바꿈
%e, %E : 지수 표현식 형식
6. 윤년 구하는 공식
String str = num1%4==0 && num1%100!=0 || num1%400==0?"윤년":"평년";
7. 소문자는 대문자로, 대문자는 소문자로 변환 공식
char ch, result;
result = ch>=65 && ch<=90?(char)(ch+32):(ch>='a'&& ch<='z'?(char)(ch-32):ch);
8. if문
if(조건문) {
참
}
if(조건문) {
참
}else {
참 이외에
}
if(조건문) {
참
}else if(조건문) {
참
}else if(조건문) {
참
}else {
참 이외에
}
9. Scanner sc = new Scanner(System.in);
Scanner : 단락문자의 패턴을 이용해 분류, 기본 패턴은 공백
System.out.print("이름 국어 영어 수학?"); //suzi 60 40 80
System.out.print("이름,국어,영어,수학?"); //suzi,60,40,80
sc.close() : 원래 Scanner를 닫아줘야 하는데 안닫아도 상관없다.
10. 3개의 수 중 작은수에서 큰수 순서 출력 공식
int num1,num2,num3,temp;
if(num1>num2) {
temp = num1;
num1 = num2;
num2 = temp;
}
if(num2>num3) {
temp = num2;
num2 = num3;
num3 = temp;
}
if(num1>num2) {
temp = num1;
num1 = num2;
num2 = temp;
}
또는
if(num1>num2) {
temp = num1;
num1 = num2;
num2 = temp;
}
if(num1>num3) {
temp = num1;
num1 = num3;
num3 = temp;
}
if(num2>num3) {
temp = num2;
num2 = num3;
num3 = temp;
}
11. 반복문
for(변수초기값;최대값;증가값) {
수식
}
변수초기값
while(최대값){
증가값
수식
}
(몇 번 돌려야 할 지 결정되지 않았을 때 while문 쓴다. 데이터 갯수 모를때.
변수초기값 기본 0으로 시작하는게 정석. 최대값에 90% =이 없다.)
변수초기값
do {
증가값
수식
}while(최대값);
12. switch문
switch(조건문) {
case 참조건1:
참
break;
case 참조건2:
참
break;
case 참조건3:
참
break;
default:
참 이외에
}
13. 배열
int num[] = new int[7];
int [] num = new int[5];
num.length : 배열의 개수
int=0, double=0.0, string=null : 배열 초기값
14. Selection Sort (공식)
for(i=0;i<num.length-1;i++) {
for(j=i+1;j<num.length;j++) {
//System.out.println(i + ":" + j);
if(num[i]>num[j]) {// >오름차순, <내림차순
temp = num[i];
num[i] = num[j];
num[j] = temp;
}
}
}
Bubble Sort
for(i=1;i<num.length;i++) {
for(j=0;j<num.length-i;j++) {
//System.out.println(i + ":" + j);
if (num[j]>num[j+1]) {// >오름차순
temp = num[j];
num[j] = num[j+1];
num[j+1] = temp;
}
}
}
15. 확장 for문 : 배열형태 (컬렉션)에서만 사용가능
for(자료형 변수 : 선언된변수) {
수식
}
16. Random rd = new Random();
배열 = rd.nextInt(5) + 1;
1~5 랜덤 객체 생성
17. String Class
String substring(int beginIndex) : 해당 문자열의 전달된 인덱스부터 끝까지를 새로운 문자열로 반환함.
String substring(int begin, int end) : 해당 문자열의 전달된 시작 인덱스부터 마지막 인덱스까지를
새로운 문자열로 반환함.
String trim() : 해당 문자열의 맨 앞과 맨 뒤에 포함된 모든 공백 문자를 제거함.
18. 배열의 배열
int[][] arr = new int[6][6];
19. 선언 위치에 따른 변수의 종류
public class test {
public int instance; // 인스턴스 변수(전역 변수)
public static int class; // 클래스 변수
public void method() {//instance 메소드
int local; // 지역 변수(로컬 변수)
}
public static void method() {//class 메소드
}
}
- 클래스 변수
선언위치 : 클래스영역
생성시기(메모리 할당 시기) : 클래스가 메모리에 올라갈 때(딱 1번만 올라간다. new를 통해 메모리 할당
받지 않아도 사용 가능.) - 한 클래스의 모든 인스턴스들이 공통적인 값을 가져야 할 때, 종료 될 때 까지
유지되는 클래스 변수는 public 을 붙이면 같은 프로그램 내에서 어디서든 접근할 수 있는 전역 변수가
된다.
- 인스턴스 변수
선언위치 : 클래스영역
생성시기(메모리 할당 시기) : 인스턴스가 생성될 때(클래스 메소드에서는 접근할 수 없지만 new를 통해
객체 생성하고 객체 통해서 접근 가능.) - 각각 고유한 값을 가진다.(instance 변수는 초기화 되어있다.
- int는 0)
- 지역 변수
선언위치 : 클래스 이외의 영역(메소드, 생성자, 초기화 블럭)
생성시기(메모리 할당 시기) : 변수 선언문이 수행 되었을 때 - 메소드 내에서만 사용가능하고 메소드가
끝나면 소멸되어 사용할 수 없다.
static
(1) 자기가 스스로 메모리에 올라감(메모리 할당을 받음)
(2) 객체가 100번 생성되도 메모리 공간은 1개를 사용함(스스로 올라간 그 하나)
20. 같은 패키지 내에서는 클래스 이름 틀려야 한다.
클래스는 클래스 밖 뿐만 아니라 클래스 안과 메소드 안에도 만들 수 있다.
21. 오버로딩(Overloading)
오버로딩(Overloading) : 같은 클래스에서 같은 이름의 메소드를 여러개 가지면서 매개변수의
유형과 개수가 다르도록 하는 기술(메소드 중복 정의).
22. 생성자
public class Test5 {
private int x;
public Test5() {//기본생성자 (생략된 생성자의 모습, 무조건 public)
this(100);//생성자 안에서 오버로딩생성자 불러오기
System.out.println("기본생성자...");
x = 20;
System.out.println("x: " + x);
}
public Test5(int x) {//생성자 오버로딩
//this();//생성자 안에서 기본생성자 불러오기 (무조건 문장선두만 가능, 오로지 한번만)
System.out.println("오버로딩된 생성자");
this.x = x;
System.out.println("x: " + x);
}
public static void main(String[] args) {
Test5 ob = new Test5();//기본생성자 호출
//System.out.println(ob.x);
Test5 ob1 = new Test5(50);//오버로딩된 생성자 호출
//System.out.println(ob1.x);
}
}
- 결과
오버로딩된 생성자
x: 100
기본생성자...
x: 20
오버로딩된 생성자
x: 50
생성자
(1) 메모리할당(객체생성)
(2) 변수 초기화
생성자의 이름은 클래스의 이름과 동일, 리턴값이 없기 때문에 property(자리값)가 없다.
메소드처럼 중복정의가 가능. 생성자 안에서 생성자를 호출할 수 있다. 단, 제일 선두에서 한 번만 호출
가능!
기본생성자로 객체 생성 시, 메소드를 통해서 초기화 가능.
오버로딩생성자로 객체 생성시, 초기화도 한 번에 가능.
오버로딩생성자 생성시 기본생성자 쓰려면 명시적으로 기본생성자를 올려놔야함.
오버로딩생성자만 객체생성하려면 기본생성자 명시적인거 지워야함.
23. 초기화 블럭
public class Test7 {
int a = 5;
{//초기화 블럭 (객체생성해야 올라감)
System.out.println("초기화 블럭a : " + a);
a = 10;
System.out.println("초기화 블럭a : " + a);
}
//System.out.println("aaa"); 이건 안됨!
static int b; //class변수
static {//static 블럭
b = 20;
System.out.println("static 블럭b : "+ b);
}
//final int C=30;//상수 (항상 일정한 수, 프로그램 종료까지 바뀌지 않음, 반드시 초기화)
//예를들어 파이 3.14
final int C;
public Test7() {
System.out.println("생성자....");
C = 100;
System.out.println("C: " + C);
}
public static void main(String[] args) {
Test7 ob1 = new Test7();
System.out.println("-----------------------");
Test7 ob2 = new Test7();//static 안나온다. 처음 1번만 실행. 처음객체 공용으로 사용.
}
}
- 결과
static 블럭b : 20
초기화 블럭a : 5
초기화 블럭a : 10
생성자....
C: 100
-----------------------
초기화 블럭a : 5
초기화 블럭a : 10
생성자....
C: 100
초기화 블럭 : 객체생성해야 올라감
상수 : 항상 일정한 수, 프로그램 종료까지 바뀌지 않음, 반드시 초기화
24. 인수 전달 방법
(1) 값에 의한 전달(call by value) : Stack영역에서 Heap영역으로 값 자체가 넘어감.
메소드 실행전 변수와 실행 후 변수가 달라진다. 매개변수를 변경시켜도 넣은 변수는 그대로다.
(2) 참조에 의한 전달(call by reference) : Heap영역의 값을 넘길 때 주소가 넘어감. - Static 들어가
있다.
주소값을 대입시켜서 대입된 주소를 변경하면 static으로 올라가 변경전 주소도 같이 바뀐다.
※ 자바 메모리 구조
↑낮은 주소
- 메소드 영역 : 클래스 정보, 클래스 변수(static variable) 저장되는 영역
- 힙(heap) 영역 : 인스턴스 변수(new 객체 생성) 저장되는 영역 (낮은 주소 → 높은 주소)
- 스택(stack) 영역 : 메소드 호출될 때 메소드의 스택 프레임(메소드 호출 정보), 지역 변수, 매개변수
저장되는 영역 (후입선출(LIFO,Last-In First-Out),높은 주소 → 낮은 주소)
↓높은 주소
25. 상속
상속(부모->자식) 6조건
(1) 부모꺼는 내꺼다.
(2) private,default 선언한것은 상속받지만 접근은 안된다. (생성자, 초기화 블록 상속되지 않음.)
(3) protected 선언한것은 상속이 된다. (부모 클래스의 필드, 메소드만 상속)
(4) 내꺼는 내꺼다. 자식꺼는 부모가 절대 사용할수 없다.
(5) 부모도 가지고있고 나도 같은 객체를 가지고있으면 내꺼쓴다.
(6) 단일 상속만 가능하다.
super키워드는 this처럼 부모클래스의 멤버 이름과 자식 클래스의 멤버 이름 같을 경우 사용.
this.변수 - 현재 내 클래스의 초기화된 변수 호출
super.변수 - 부모 클래스의 초기화된 변수 호출
this() 메소드가 같은 클래스의 다른 생성자를 호출할 때 사용된다면, super() 메소드는 부모 클래스의
생성자를 호출할 때 사용.
자바의 모든 클래스는 Object 클래스를 무조건 상속 받는다!!
Hashcode : 주소번지
(ex.
User ob1 = new User();
System.out.println("ob1: " + ob1);
결과 : ob1: com.day9.User@33909752
com.day9.User@7852e922에서 7852e922는 주소번지
)
26. 오버라이드(Override)
오버라이드(Override) : 상속관계에 있는 상위 클래스의 메소드를 하위 클래스에서 재정의하여 사용.
(메소드 재정의)
- 오버라이드 3가지 방법
(1) 직접 코딩
@Override : 어노테이션 - 틀렸나 감시
메소드 재정의, 이름 부모꺼와 같도록, 클래스가 틀려서 이름 같아도됨.
(2) 마우스 우클릭 - Source - Override
(3) wr 컨트롤 스페이스 - 오버라이드 메소드
27. String Class (2)
String Class : String은 자료형은 아닌 Class다. 자료형처럼 사용되고 있다.
왜? 사용하는 빈도가 매우 높고 저장하는 데이터가 매우 크다. (심지어 백과사전도 들어감) 그래서 용량이
커서 Stack이 아닌 Heap에 저장.
String의 불변의 법칙 : 데이터 저장하면 지우거나 수정불가.
String특징 : 내용이 같으면 Call By Reference 이뤄짐. (용량 커서)
내용 같았다가 다른 내용을 초기화하고 다시 같은 내용을 초기화 하면 Call By Reference 이뤄짐. 여기서
이전에 초기화한 내용들은 쓰레기 값이 됨. Garbage Collecter가 쓰레기 모음.
(ex.
String ob1 = "Seoul";
System.out.println(ob1);
결과 : Seoul
String은 자료형 흉내, 원래는 Hashcode 보여줘야 함.
String은 비교하는게 따로 있다.
ob1==ob3 주소 비교, ob1.equals(ob3) 들어간값 비교
object equals(); : 주소비교
string equals(); : 데이터비교 - 오버라이드
String ob3 = new String("Seoul");
System.out.println("ob1==ob3: " + (ob1==ob3));
결과 : false
System.out.println("ob1.equals(ob3): " + ob1.equals(ob3));
결과 : true
String toString() - Object의 toString() 오버라이드 - 형변환
System.out.println(ob3.toString());
결과 : Seoul
)
28. String을 보조해주는 class
StringBuffer : 동기화를 지원 (느림)
StringBuilder : 동기화를 지원안함 (빠름)
자바랭에 이미 있어서 import 안함.
29. Integer(int)
Integer(int) : int의 클래스버전! 랩퍼클래스!
int는 Stack에 저장하고 Integer는 Heap에 저장
int a = 24;
System.out.println(a); //24
System.out.println(Integer.toString(a)); //24(문자)
System.out.println(Integer.toString(a,2)); //11000(2진수)
System.out.println(Integer.toString(a,16)); //18(16진수)
Object의 toString() 오버라이드함.
30. 자주 사용하는 String의 메소드
- String[] split(String regex) : 해당 문자열을 전달된 정규 표현식(regular expression)에 따라 나눠서
반환함.
- equalsIgnoreCase() : 대소문자 구분없이 구분
- int indexOf(int ch) / int indexOf(String str) : 해당 문자열에서 특정 문자나 문자열이 처음으로
등장하는 위치의 인덱스를 반환함.
int indexOf(int ch, int fromIndex) / int indexOf(String str, int fromIndex) : 해당 문자열에서 특정
문자나 문자열이 전달된 인덱스 이후에 처음으로 등장하는 위치의 인덱스를 반환함.
int lastIndexOf(int ch) : 해당 문자열에서 특정 문자가 마지막으로 등장하는 위치의 인덱스를 반환함.
int lastIndexOf(int ch, int fromIndex) : 해당 문자열에서 특정 문자가 전달된 인덱스 이후에 마지막으로
등장하는 위치의 인덱스를 반환함.
해당 문자열에 없으면 -1 돌려준다.
- replaceAll("aa","AA") : aa를 AA로 교체.
regex : 정규화 표현식
\\s : 정규화 표현식 공백
\\s* : 정규화 표현식 공백 없음
- trim() : 해당 문자열의 맨 앞과 맨 뒤에 포함된 모든 공백 문자를 제거함.
- char charAt(int index) : 해당 문자열의 특정 인덱스에 해당하는 문자를 반환함.
" ".charAt() : 스트링의 메소드
' '.charAt() : 캐릭터의 메소드
- startsWith("abc") : abc로 시작하는 문자인지 확인 후 true / false 반환
- length() : 해당 문자열의 길이를 반환함.
isEmpty() : 해당 문자열의 길이가 0이면 true를 반환하고, 아니면 false를 반환함.
- int compareTo(String str) : 해당 문자열을 인수로 전달된 문자열과 사전 편찬 순으로 비교함. 1 / -1 반환.
int compareToIgnoreCase(String str) : 해당 문자열을 인수로 전달된 문자열과 대소문자를 구분하지 않고
사전 편찬 순으로 비교함.
d=100, e=101 아스키값
31. Wrapper 클래스
자료형 데이터를 객체(클래스)로 사용할 수 있게 함.
자료형 : (stack영역) boolean, byte, char, short, int, long, float, double
레퍼런스 자료형 : (heap영역) Boolean, Byte, Character, Short, Integer, Long, Float, Double
들어간 값에 메소드 통해 명령하기 위해 클래스 만듦.
Auto-Boxing : stack -> heap
Auto-UnBoxing : heap -> stack
(ex.
int n1 = 10;
int n2;
Integer num1;
Integer num2 = new Integer(20);
num1 = n1; //Auto-Boxing
n2 = num2; //Auto-UnBoxing
System.out.println(n1 + ":" + num1); //10:10
System.out.println(n2 + ":" + num2); //20:20
)
- 자료형
int a = 10;
float b;
b = a;(10.0) Ok (암시적 형변환)
a = b;(10) err
a = (int)b; Ok (명시적 형변환)
--------------------------------------
- 상속
부모(b) - 자식(a) : 부모가 더 크다
부모(b) = 자식(a); Ok (Upcast : 능력 줄어든다.)
자식(a) = 부모(b); err
자식(a) = (자식)부모(b); Ok (Downcast : 능력 늘어난다.)
변수는 Upcast로 부모것 찍을 수 있으나 메소드는 무조건 내것만 쓴다. 부모는 자식꺼 못 쓴다.
32. Calendar 클래스
Calendar now = Calendar.getInstance();
now.get();
now.set();
위 2가지 방법도 있다.
System.out.printf("%tF\n",now); //2021-02-04
System.out.printf("%tT\n",now); //11:51:02
System.out.printf("%1$tF %1$tT\n",now); //2021-02-04 11:52:39
33. Singleton
Singleton : 객체를 계속 생성하는 것이 아니라 하나의 객체만 생성하고 공유해서 사용하는 방법
class Sing {
private static Sing ob;
public static Sing getInstance() {
if(ob==null) {
ob = new Sing();
}
return ob;
}
}
public class Test4 {
public static void main(String[] args) {
Sing ob1 = Sing.getInstance();
Sing ob2 = Sing.getInstance();
if(ob1==ob2)
System.out.println("동일한 객체");
else
System.out.println("안 동일한 객체");
}
}
결과 : 동일한 객체
34. final (상수)
instance 변수에 final을 붙이면 : (상수) 단 한번만 초기화 가능
메소드에 final을 붙이면 : Override가 불가능
클래스에 final을 붙이면 : 상속이 불가능
(ex.
public final double PI; //intstance 변수 static쓰면 초기화 블록도 static
{//초기화블록
PI = 3.14;
}
public final void write(String title) {//메소드에 final, 오버라이드 불가
}
final class SuperC {//클래스에 final, 상속 불가
}
)
35. 추상 클래스 (abstract class)
추상 클래스 : 하나 이상의 추상 메소드를 포함하는 클래스.
- 메모리의 낭비없이 클래스를 미리 설계.
- 메소드를 재정의해서 사용한다.
- 추상 클래스는 반드시 1개 이상의 추상메소드를 가져야 한다.
- 통일성이 있다. 복잡하다.
- 이미 만들어진것 쓴다. 추상클래스보다 인터페이스 더 많이 사용.
추상 클래스는 동작이 정의되어 있지 않은 추상 메소드를 포함하고 있으므로, 인스턴스를 생성할 수 없다.
추상 클래스는 먼저 상속을 통해 자식 클래스를 만들고, 만든 자식 클래스에서 추상 클래스의 모든 추상
메소드를 오버라이딩하고 나서야 비로소 자식 클래스의 인스턴스를 생성할 수 있게 된다.
추상 클래스는 추상 메소드를 포함하고 있다는 점을 제외하면, 일반 클래스와 모든 점이 같다. 즉, 생성자와
필드, 일반 메소드도 포함할 수 있다.
abstract class ShapeClass {
abstract public void draw(); //추상메소드 정의만 해야함. 접근지정자도 생략할 수 있음.
}
class Circ extends ShapeClass {
@Override
public void draw() {//메소드 재정의하면 의도가 있다.
System.out.println("원을 그린다..");
}
}
class Rect extends ShapeClass {
@Override
public void draw() {
System.out.println("사각형을 그린다..");
}
}
class Tri extends ShapeClass {
@Override
public void draw() {
System.out.println("삼각형을 그린다..");
}
}
public class Test1 {
public static void main(String[] args) {
//ShapeClass s = new ShapeClass(); //추상 클래스는 인스턴스를 생성할 수 없음.
//추상 클래스의 추상 메소드를 오버라이딩해야만 비로소 인스턴스를 생성할 수 있다.
Circ c = new Circ();
Rect r = new Rect();
Tri t = new Tri();
c.draw();
r.draw();
t.draw();
}
}
결과 :
원을 그린다..
사각형을 그린다..
삼각형을 그린다..
36. 상속관계에서 Upcast & Downcast
같은 클래스라면 call by reference 일어나지만,
TestA a = new TestA();
TestB b;
b=a;
b=(TestB)a;
서로 관련 없는 클래스라 안된다. 컴파일 오류 난다.
자식클래스로 객체생성하면 부모와 자식 모두 객체생성된다.
자식클래스 ob1 = new 자식클래스();
부모클래스 ob2 = ob1; //Upcast
((자식클래스)ob2).자식메소드(); //Downcast
ob2.오버라이드한자식메소드(); //하늘두쪽나도 자식이 오버라이드한 메소드 쓴다.
ob2.자식메소드(); //안됨. 자식껀 자식만 쓴다.
ob2.부모메소드(); //부모메소드것 쓴다.
37. 내부 클래스 (inner class)
내부 클래스 : 하나의 클래스 내부에 선언된 또 다른 클래스. 외부 클래스(outer class)에 대해 두 개의
클래스가 서로 긴밀한 관계를 맺고 있을 때 선언할 수 있다.
장점
- 내부 클래스에서 외부 클래스의 멤버에 손쉽게 접근할 수 있게 됩니다.
- 서로 관련 있는 클래스를 논리적으로 묶어서 표현함으로써, 코드의 캡슐화를 증가시킵니다.
- 외부에서는 내부 클래스에 접근할 수 없으므로, 코드의 복잡성을 줄일 수 있습니다.
(1) 내부클래스(Inner) (인스턴스 클래스,instance class) : 외부 클래스(outer class)의 인스턴스 변수나
인스턴스 메소드에 사용될 목적으로 선언.
class Outer1 {
static int a=10;
int b=20;
/*public Outer1(int a) { //오버로딩 객체 생성
Inner1 ob = new Inner1(a); //안의 클래스 객체 생성
}*/
//nested class //밀접한 관계 있을때
public class Inner1 {
int c=30;
/*int a;
public Inner1(int a) { 초기화
this.a = a;
}*/
public void write() {
System.out.println(a);
System.out.println(b);
System.out.println(c);
}
}
public void print() {
Inner1 ob = new Inner1();
ob.write();
}
}
public class Test5 {
public static void main(String[] args) {
//접근방법1
Outer1 out = new Outer1();
out.print();
//접근방법2
Outer1.Inner1 in = out.new Inner1();
in.write();
}
}
결과 :
10
20
30
10
20
30
(2) 내부클래스 (Local class) : 외부 클래스의 메소드나 초기화 블록에 선언된 클래스, 선언된 블록 내에서
만 사용할 수 있다.
class Outer2 {
static int a=10;
int b=20;
public void write() {
int c=30;
final int d=40;
class Local {
public void print() {
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
}
}
Local ob = new Local();
ob.print();
}
}
public class Test6 {
public static void main(String[] args) {
Outer2 out = new Outer2();
out.write();
}
}
결과 :
10
20
30
40
(3) 내부클래스 (중첩) (정적 클래스,static class) : 외부 클래스(outer class)의 클래스 메소드에 사용될
목적으로 선언
class Outer3 {
static int a=10;
int b=20;
//nested class
public static class Inner3 {
int c=30;
public void write() {
System.out.println(a);
//System.out.println(b);
System.out.println(c);
//내부에서 외부의 객체를 생성할 수 있다.
Outer3 ob = new Outer3();
System.out.println(ob.b);
}
}
public void print() {
Inner3 ob = new Inner3();
ob.write();
}
}
public class Test7 {
public static void main(String[] args) {
//접근방법1
Outer3 out = new Outer3();
out.print();
//접근방법2
Outer3.Inner3 in = new Outer3.Inner3();
in.write();
}
}
결과 :
10
30
20
10
30
20
(4) 내부클래스 (annonymous,익명의클래스,무명의클래스) : 다른 내부 클래스와는 달리 이름을 가지지 않는
클래스. 클래스의 선언과 동시에 객체를 생성하므로, 단 하나의 객체만을 생성하는 일회용 클래스. 따라서
생성자를 선언할 수도 없으며, 오로지 단 하나의 클래스나 단 하나의 인터페이스를 상속받거나 구현할 수
있을 뿐이다. 매우 제한적인 용도에 사용되며, 구현해야 하는 메소드가 매우 적은 클래스를 구현할 때 사용.
메모리의 낭비 막고 논스톱 작업 처리 위함.
무명클래스의 꽃은 안드로이드.
public class Test8 {
public Object getTitle() {
//return "클래스"; //Upcast (String -> Object)
return new Object() {//무명의 클래스는 호출안해도 스스로 호출됨. //클래스,인터페이스
@Override
public String toString() {//반드시 오버라이드 //코딩하고 반환값하여 빠져나가게.
return "익명의 클래스";
}
};
}
public static void main(String[] args) {
Test8 ob = new Test8();
//Object str = ob.getTitle(); 너무 오브젝트 크다.
//String str = (String)ob.getTitle(); //Downcast (Object -> String)
//System.out.println(str);
System.out.println(ob.getTitle());
}
}
결과 : 익명의 클래스
- 문법
//익명 클래스는 선언과 동시에 생성하여 참조변수에 대입함.
클래스이름 참조변수이름 = new 클래스이름(){
// 메소드의 선언
};
38. 인터페이스 (Interface)
인터페이스 : 다른 클래스를 작성할 때 기본이 되는 틀을 제공하면서, 다른 클래스 사이의 중간 매개 역할
까지 담당하는 일종의 추상 클래스를 의미.
(1) 추상 클래스의 일종으로 선언만 있고 내용이 없다.
(2) final변수(상수)만 정의할 수 있고 추상 메소드만 정의한다.(추상 클래스는 추상 메소드뿐만 아니라
생성자, 필드, 일반 메소드도 포함할 수 있다.)
(3) interface를 구현할 때는 implements를 사용한다.
(4) 하나 이상의 interface 구현한 경우에는 interface의 모든 메소드를 반드시 재정의 해야한다.
(5) interface가 다른 interface를 상속 받을 수 있으며 이때는 extends를 사용한다.
(6) 또한 이 때 interface는 다중 상속이 가능하다.
(interface는 클래스다.)
-문법
접근제어자 interface 인터페이스이름 {
public static final 타입 상수이름 = 값;
...
public abstract 타입 메소드이름(매개변수목록);
...
}
인터페이스의 모든 필드는 public static final이어야 하며, 모든 메소드는 public abstract이어야 한다.
이 부분은 모든 인터페이스에 공통으로 적용되는 부분이므로 이 제어자는 생략할 수 있다.
- 문법
class 클래스이름 extend 상위클래스이름 implements 인터페이스이름,인터페이스이름 { ... }
인터페이스는 인터페이스로부터만 상속을 받을 수 있으며, 여러 인터페이스를 상속받을 수 있습니다.
(ex.
interface ItemFruit extends FruitA,Fruit {
...
}
)
장점
- 대규모 프로젝트 개발 시 일관되고 정형화된 개발을 위한 표준화가 가능.
- 클래스의 작성과 인터페이스의 구현을 동시에 진행할 수 있으므로, 개발 시간을 단축할 수 있다.
- 클래스와 클래스 간의 관계를 인터페이스로 연결하면, 클래스마다 독립적인 프로그래밍이 가능.
interface Fruit {//메소드만 정의 가능
//final 상수만 선언가능
String Won = "원";//public static final 이 생략
int getPrice(); //public abstract 이 생략
public String getName(); //abstract 이 생략 (대부분 이렇게 쓴다.)
}
class FruitImpl implements Fruit { //Interface 구현
@Override
public int getPrice() {
return 1000;
}
@Override
public String getName() {
return "사과";
}
public String getItems() {//자기 자신만의 메소드도 만들 수 있다.
return "과일";
}
}
public class Test1 {
public static void main(String[] args) {
FruitImpl ob1 = new FruitImpl();
//Fruit ob1 = new FruitImpl(); //Upcast //부모 자식 메소드 동일하면 이렇게 사용가능!!!
System.out.println(ob1.getItems()); //자식꺼 안쓰면 위 Fruit ob1 = new FruitImpl(); 에러 안남.
System.out.println(ob1.getName());
System.out.println(ob1.getPrice() + Fruit.Won); //super 올라가 객체생성되어 사용가능 물론 Static이라 올 라갔겠지만..
Fruit ob2 = ob1;//Upcast
System.out.println(ob2.getName()); //메소드 오버라이드 하는 순간 내꺼쓴다!!!
//System.out.println(ob2.getItems()); //부모가 자식꺼 못쓴다. 내껀 내꺼다!!!
}
}
결과 :
과일
사과
1000원
사과
39. 컬렉션 프레임워크 (Collection Framwork)
컬렉션 프레임워크 (Collection Framwork) (방법론) : 다수의 데이터를 쉽고 효과적으로 처리할 수 있는
표준화된 방법을 제공하는 클래스의 집합. 즉, 데이터를 저장하는 자료 구조와 데이터를 처리하는 알고리즘을
구조화하여 클래스로 구현해 놓은 것. 이러한 컬렉션 프레임워크는 자바의 인터페이스(interface)를 사용하여
구현됨.
자료 처리를 위한 클래스. Collection 기본 자료형은 Object.
배열 단점 : 고정크기, 중간에 삽입 또는 삭제가 안됨.
- 주요 인터페이스의 간략한 특징 (이미 구현한(implements) 클래스, 저장소)
인터페이스 / 설명 / 구현 클래스
List<E> / 순서가 있는 데이터의 집합으로, 데이터의 중복을 허용함. / Vector(동기화 지원,느림),
ArrayList(동기화 지원 안함,빠름),LinkedList,Stack,Queue
Set<E> / 순서가 없는 데이터의 집합으로, 데이터의 중복을 허용하지 않음. / HashSet,TreeSet
Map<K,V> / 키와 값의 한 쌍으로 이루어지는 데이터의 집합으로, 순서가 없음. 이때 키는 중복을 허용하지
않지만, 값은 중복될 수 있음. / HashMap(동기화 지원 안함,빠름),TreeMap(정렬해서 보여줌),
Hashtable(동기화 지원,느림),Properties
(List,Set은 Collection 인터페이스를 상속받지만, 구조상의 차이로 인해 Map 인터페이스는 별도로 정의)
- Vector 클래스의 메소드
firstElement() : 첫 번째 요소
get(인덱스번호) : 방 번호로 데이터 가져오기
lastElement() : 마지막 요소
capacity() : 용량 (Vector의 초기용량 : 10,데이터 추가 시 저절로 용량증가)
size() : 데이터의 요소 갯수
add(배열변수or문자or숫자or캐릭터) : 데이터 추가
add(인덱스번호,추가할문자) : 해당 인덱스번호에 데이터 추가
set(인덱스번호,변경할문자) : 데이터 변경
insertElementAt(삽입할문자,인덱스번호) : 데이터 삽입
indexOf(검색할문자) : 해당 문자 인덱스번호 검색, 검색 실패시 -1 반환
remove(인덱스번호or문자) : 데이터 삭제
trimToSize() : Vector의 빈 공간 삭제
clear() : 모든 데이터 삭제 (이후 trimToSize()도 해주기)
removeAll(벡터변수) : 모든 데이터 삭제 (이후 trimToSize()도 해주기)
addAll(컬렉션클래스변수) : 해당 변수의 컬렉션에 담긴 데이터 추가 (Collection안에 Collections 넣을 수
있다.)
출력 시에
for문, 확장 for문, Iterator
- Collection 인터페이스 제공 주요 메소드
Iterator<E> iterator() : 해당 컬렉션의 반복자(iterator)를 반환함
sort() : 오름차순
binarySearch(벡터변수,검색할문자) : 해당 문자 인덱스번호 오름차순 검색
sort(벡터변수,Collections.reverseOrder()) : 내림차순
binarySearch(벡터변수,검색할문자,Collections.reverseOrder()) : 해당 문자 인덱스번호 내림차순 검색
Iterator(반복자) - (전용출력기)빠르게 꺼낼 수 있다. move 개념으로 다시 출력하면 it 데이터가 비어
있어서 안나옴
(ex.
Vector<String> v = new Vector<>();
v.add로 데이터 들어간 상태
Iterator<String> it = v.iterator();
while(it.hasNext()) {//it변수가 데이터 가지고 있을때까지 반복하라.
String str = it.next();
System.out.print(str + " ");
}
)
ListIterator<타입> 변수 = 리스트변수or벡터변수.listIterator(); : copy개념으로 다시 출력하면 it 데이터
또 출력됨
(ex.
ArrayList<String> lists = new ArrayList<>();
ListIterator<String> it2 = lists.listIterator();
while(it2.hasPrevious()) {//역으로 출력 (활용도 높지않음)
System.out.print(it2.previous() + " ");
}
)
- Set 클래스의 메소드
add(문자) : 데이터 추가
- Stack 클래스 : List 컬렉션 클래스의 Vector 클래스를 상속받아, 전형적인 스택 메모리 구조의 클래스를
제공. 거꾸로 보여줌 (후입선출,가장 나중에 저장된(push)데이터가 가장 먼저 인출(pop)되는 구조)
push(문자) : 데이터 추가
add(문자) : 데이터 추가
pop() : 데이터 인출 및 제거
peek() : 데이터 인출
- Queue 인터페이스 : 큐 메모리 구조는 별도의 인터페이스 형태로 제공. 하위 인터페이스(Deque<E>,
BlockingDeque<E>,BlockingQueue<E>,TransferQueue<E>). 그중에서도 Deque 인터페이스를 구현한 LinkedList
클래스가 큐 메모리 구조를 구현하는 데 가장 많이 사용. 들어간 순서 그대로 보여줌 (선입선출,가장 먼저
저장된(push) 데이터가 가장 먼저 인출(pop)되는 구조,데이터 무브 개념)
offer(문자) : 데이터 추가
add(문자) : 데이터 추가
poll() : 데이터 인출 및 제거
peek() : 데이터 인출
- Map<key,value>
key는 중복값을 가질 수 없다(key는 자료형은 Set(interface)). key가 중복값을 갖게되면 수정.
key는 iterator가 없다. 하지만 Set의 iterator 쓴다!
- Map 클래스의 메소드
put(key,value) : 데이터 삽입, 이미 있는 데이터는 수정
get(key) : key값에 해당하는 value 가져옴
containsKey(key) : key가 존재하는지 검사 (자주씀)
containsValue(value) : value가 존재하는지 검사 (잘 안씀)
remove(key) : key값에 해당하는 데이터 삭제
Set의 iterator로 출력
(ex.
Map<String, String> h = new Hashtable<>();
Iterator<String> it = h.keySet().iterator();
while(it.hasNext()) {
String key = it.next(); //key값 가져옴
String value = h.get(key); //key주면 value값 가져옴
System.out.println(key + ":" + value);
}
)
40. 배열 정렬
Arrays.sort(배열변수)
(ex.
String[] str = {"나","마","라","가","다","바"}; //배열
Arrays.sort(str); //배열 정렬
for(String ss : str) {
System.out.print(ss + " ");
}
결과 : 가 나 다 라 마 바
)
41. Generic (제너릭)
Generic (제너릭) : 데이터의 타입(data type)을 일반화한다(generalize)는 것을 의미. 클래스나 메소드에서
사용할 내부 데이터 타입을 컴파일 시에 미리 지정하는 방법.
List나 Map에서 사용하는 기능, 이런 구조로 만들어진다. T는 class U는 메소드. 거의 안 쓴다.
장점
(1) 클래스나 메소드 내부에서 사용되는 객체의 타입 안정성을 높일 수 있다.
(2) 반환값에 대한 타입 변환 및 타입 검사에 들어가는 노력을 줄일 수 있다.
(ex.
class Box<T> {//T가 자료형
private T t; //T는 타입 변수(type variable)라고 하며, 임의의 참조형 타입, 꼭 'T'뿐만 아니라
//어떠한 문자를 사용해도 상관없으며, 여러 개의 타입 변수는 쉼표(,)로 구분하여 명시할 수 있다.
public void set(T t) {//setter
this.t = t;
}
public T get() {//getter
return t;
}
}
public class Test1 {
public static void main(String[] args) {
//타입 명시하지 않으면 Object
Box b1 = new Box(); //Object
b1.set(30); //Object //Upcast
Integer i = (Integer)b1.get(); //Downcast
System.out.println(i);
//위와 같이 선언된 제네릭 클래스(generic class)를 생성할 때에는 타입 변수 자리에
//사용할 실제 타입을 명시해야 함.
Box<Integer> b2 = new Box<Integer>();
//b2.set(10); //Auto-Boxing (Stack -> Heap)
b2.set(new Integer(10));
i = b2.get(); //cast 할필요 없음.
System.out.println(i);
Box<String> b3 = new Box<String>();
b3.set("서울");
String str = b3.get();
System.out.println(str);
}
}
)
- 타입 변수의 제한
제네릭은 'T'와 같은 타입 변수(type variable)를 사용하여 타입을 제한. 이때 extends 키워드를 사용하면
타입 변수에 특정 타입만을 사용하도록 제한
(ex.
class AnimalList<T extends LandAnimal> { ... } //클래스의 타입 변수에 제한을 걸어 놓으면 클래스
//내부에서 사용된 모든 타입 변수에 제한이 걸립
interface WarmBlood { ... }
...
class AnimalList<T extends WarmBlood> { ... } //implements 키워드를 사용해서는 안됨.
class AnimalList<T extends LandAnimal & WarmBlood> { ... } //클래스와 인터페이스를 동시에 상속받고
//구현해야 한다면 엠퍼센트(&) 기호를 사용.
)
42. 예외 처리 (Exception)
컴퓨터 시스템이 동작하는 도중에 예상하지 못한 사태가 발생하여 실행 중인 프로그램이 영향을 받는 것을
오류(error)와 예외(exception).
오류(error) : 시스템 레벨에서 프로그램에 심각한 문제를 야기하여 실행 중인 프로그램을 종료. 개발자가
미리 예측하여 처리할 수 없는 것이 대부분이므로, 오류에 대한 처리는 할 수 없다.
예외(exception) : 오류와 마찬가지로 실행 중인 프로그램을 비정상적으로 종료시키지만, 발생할 수 있는
상황을 미리 예측하여 처리할 수 있다. 개발자는 예외 처리(exception handling)를 통해 예외 상황을 처리할
수 있도록 코드의 흐름을 바꿀 필요가 있다.
에러났을 때 어떻게 처리할까?
- 문법
try {
예외를 처리하길 원하는 실행 코드;
} catch (예외클래스 e1) {//예외클래스 사용 순서는 아래로 갈수록 부모가 되도록 만들기
e1 예외가 발생할 경우에 실행될 코드;
} catch (예외클래스 e2) {
e2 예외가 발생할 경우에 실행될 코드;
} catch (예외클래스 e3) {
System.out.println("~한 오류다."); //오류에 대한 직접적인 메시지
System.out.println(e); //에러정보
e.printStackTrace(); //오리지널 에러정보
}
...
finally {//잘 안씀. 주로 잘못된 거 초기화 할때 씀.
예외 발생 여부와 상관없이 무조건 실행될 코드;
}
- 예외 클래스
InputMismatchException : 정수 입력 에러
NumberFormatException : 숫자 입력 불가능 에러
ArithmeticException : 0으로 나눌 수 없는 에러
IOException : I/O 오류가 발생하는 경우에 throw되는 예외. Exception클래스의 자식 클래스.
Exception : (1) RuntimeException 클래스(RuntimeException 클래스를 상속받는 자식 클래스들은 주로
치명적인 예외 상황을 발생시키지 않는 예외들)와 (2) 그 외의 Exception 클래스의 자식 클래스로 구분
(주로 많이 쓴다.)
- 사용자 정의 오류 : throw로 예외를 의도적으로 발생시킴. 메소드의 throws Exception 기술. 반드시
try문으로 감싸줌.
public void method() throws Exception {
try {
throw new Exception("오류 메시지 입력");
} catch (Exception e) {
System.out.println(호출된 메소드에서 예외가 처리됨.); //도착 안할 것이다.
System.out.println(e.toString);
}
}
- Exception 비서실 만들기
class MyException extends Exception {//비서실 클래스
//완충작업, Exception사장 비서실 역할
public MyException(String msg) {//요구 넣기 //오버로딩 생성자
super(msg);
}
}
public class Test5 {
private int value;
public void setValue(int value) throws MyException {//비서실 클래스 입력
if(value<0)
throw new MyException("수는 0보다 작을수 없다");
else
this.value = value;
}
public int getValue() {
return value;
}
public static void main(String[] args) {
Test5 ob = new Test5();
try {
ob.setValue(-20);
} catch (MyException e) {
System.out.println(e.toString());//문자로 바꿔찍어라.
//e.printStackTrace();
}
System.out.println(ob.getValue());
}
}
결과 :
com.day16.MyException: 수는 0보다 작을수 없다
0
43. @SuppressWarnings("unused")
사용하지 않는 변수에 대해 경고하지 마라.
@SuppressWarning : 컴파일러가 일반적으로 경고하는 내용 중 이건 하지말라고 제외시킬 때 쓰임.
(1) all : 모든 경고를 억제
(2) cast : 캐스트 연산자 관련 경고 억제
(3) dep-ann : 사용하지 말아야 할 주석 관련 경고 억제
(4) deprecation : 사용하지 말아야 할 메소드 관련 경고 억제
(5) fallthrough : switch문에서의 break 누락 관련 경고 억제
(6) finally : 반환하지 않는 finally 블럭 관련 경고 억제
(7) null : null 분석 관련 경고 억제
(8) rawtypes : 제네릭을 사용하는 클래스 매개 변수가 불특정일 때의 경고 억제
(9) unchecked : 검증되지 않은 연산자 관련 경고 억제
(10) unused : 사용하지 않는 코드 관련 경고 억제
44. 스레드 (Thread)
프로세스(process)란 단순히 실행 중인 프로그램(program). 즉, 사용자가 작성한 프로그램이 운영체제에
의해 메모리 공간을 할당받아 실행 중인 것. 프로세스는 프로그램에 사용되는 데이터, 메모리 등의 자원,
스레드로 구성.
스레드(thread)란 프로세스(process) 내에서 실제로 작업을 수행하는 주체. 모든 프로세스에는 한 개 이상의
스레드가 존재하여 작업을 수행. 두 개 이상의 스레드를 가지는 프로세스를 멀티스레드 프로세스
(multi-threaded process).
- 스레드의 생성과 실행
(1) Runnable 인터페이스를 구현하는 방법
(2) Thread 클래스를 상속받는 방법
Thread 클래스를 상속받으면 다른 클래스를 상속받을 수 없으므로, 일반적으로 Runnable 인터페이스를 구현
하는 방법으로 스레드를 생성.
- 예시
class ThreadWithClass extends Thread {
@Override
public void run() {
for (int i=0;i<5;i++) {
System.out.println(getName()); //현재 실행 중인 스레드의 이름을 반환함. this.getName()도 가능.
try {
Thread.sleep(10); //0.01초간 스레드를 멈춤. sleep(10);만 써도 됨.
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class ThreadWithRunnable implements Runnable {
@Override
public void run() {
for (int i=0;i<5;i++) {
System.out.println(Thread.currentThread().getName()); //현재 실행 중인 스레드의 이름을 반환함.
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Thread01 {
public static void main(String[] args){
ThreadWithClass thread1 = new ThreadWithClass(); //Thread 클래스를 상속받는 방법
Thread thread2 = new Thread(new ThreadWithRunnable()); //Runnable 인터페이스를 구현하는 방법
thread1.start(); //스레드의 실행
thread2.start(); //스레드의 실행
}
}
결과 :
Thread-0
Thread-1
Thread-0
Thread-1
Thread-0
Thread-1
Thread-0
Thread-1
Thread-0
Thread-1
- 스레드의 우선순위
static int MIN_PRIORITY : 스레드가 가질 수 있는 최소 우선순위를 명시함. - 1
static int NORM_PRIORITY : 스레드가 생성될 때 가지는 기본 우선순위를 명시함. - 5(기본)
static int MAX_PRIORITY : 스레드가 가질 수 있는 최대 우선순위를 명시함. - 10
MyThread ob = new MyThread();
ob.getPriority(); : 우선순위 출력
ob.setPriority(Thread.MIN_PRIORITY); : 우선순위 변경
main() 메소드를 실행하는 스레드의 우선순위는 언제나 5. 그래서 main() 메소드 안에 스레드에게 우선순위
주지 않으면 우선순위 5로 설정된다.
- 데몬 스레드 (Daemon Thread)
데몬 스레드(deamon thread)란 다른 일반 스레드의 작업을 돕는 보조적인 역할을 하는 스레드. 따라서
데몬 스레드는 일반 스레드가 모두 종료되면 더는 할 일이 없으므로, 데몬 스레드 역시 자동으로 종료.
이러한 데몬 스레드는 일정 시간마다 자동으로 수행되는 저장 및 화면 갱신 등에 이용.
다른 Thread의 도움을 주는 Thread로 다른 Thread(Main Thread)가 종료되면 Daemon Thread가 종료되지 않더
라도 프로세스가 종료된다.
System.out.println("main 시작...");
Thread t1 = new Thread(new MyThread5());
Thread t2 = new Thread(new MyThread5());
t1.setDaemon(true);
t2.setDaemon(true); //하나 비활성화 해도 Daemon효과 못본다. 즉 비교대상은 main thread.
t1.start();
t2.start();
try {
Thread.sleep(1000); //main thread
} catch (Exception e) {
}
try {
t1.join(); //t1이 종료할때까지 main 기다려라
t2.join();
} catch (Exception e) {
}
System.out.println("main 종료...");
Thread t1 = Thread.currentThread(); : 현재의 스레드 넣을 수 있다.
t1.isAlive(); : 스레드가 살아있는지 true/false 값 반환.
t1.interrupt(); : 스레드 중지, 순서대로 스레드가 실행되어 순환되도록 하는 기능중 하나.
- 동기화 블록 (synchronized)
synchronized : 현재 데이터를 사용하고 있는 해당 스레드를 제외하고 나머지 스레드들은 데이터에 접근 할
수 없도록 막아준다.
(1) 메소드에서 사용하는 경우 : public synchronized void method() {...}
(2) 객체 변수에 사용하는 경우(block문)
private Object obj = new Object();
public void method() {
synchronized(obj) {...}
}
wait(); : 현재스레드 일시 정지
notifyAll(); : 현재스레드 다시 실행
- 반복 작업
TimerTask : 반복할 작업
Timer : 반복할 시간
Stack에 객체생성 없이 객체생성
public class Test10 extends Thread {
private int num = 0;
public Test10() {
TimerTask task = new TimerTask() {
@Override
public void run() {//반복할 작업을 기술
num = 0;
}
};
//같은구조
/*Comparator<String> comp = new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return 0;
}
};*/
Timer t = new Timer();
Calendar d = Calendar.getInstance();
/*
//예시
//내일 0시 0분 -초부터 하루에 한번씩 반복
d.add(Calendar.DATE, 1);
d.set(Calendar.HOUR, 0);//오후1시:13
d.set(Calendar.MINUTE, 0);//
d.set(Calendar.SECOND, 0);
d.set(Calendar.MILLISECOND, 0);
t.schedule(task, d.getTime(),1000*60*60*24);//밀리세컨*초*분*시
*/
t.schedule(task, d.getTime(), 5000);//d시간 읽어서 그 시간부터 5초마다 task 실행
}
@Override
public void run() {
while(true) {
System.out.println(num++);
try {
sleep(1000);
} catch (Exception e) {
}
}
}
public static void main(String[] args) {
//Test10 ob = new Test10();
//ob.start();
//ob 안쓰니 이렇게 객체생성!
//Stack 객체생성 안함.
new Test10().start();
}
}
결과 :
1
2
3
4
0
1
2
3
4
...
- 스레드 그룹 (thread group)
스레드 그룹(thread group)이란 서로 관련이 있는 스레드를 하나의 그룹으로 묶어 다루기 위한 장치.
System.out.println(Thread.currentThread().getThreadGroup()); //java.lang.ThreadGroup[name=main,maxpri=10]
System.out.println(t1); //Thread[Thread-0,5,main] - Thread-0(Thread 이름),5순위,main그룹
ThreadGroup tg = new ThreadGroup("sg"); //스레드 그룹 이름 : sg
Thread t2 = new Thread(tg,"t2"); //(스레드그룹변수,스레드이름)
Thread t3 = new Thread(tg,"t3");
System.out.println(t2); //Thread[t2,5,sg]
System.out.println(t3); //Thread[t3,5,sg]
45. 스트림 (Stream)
자바에서는 파일이나 콘솔의 입출력을 직접 다루지 않고, 스트림(stream)이라는 흐름을 통해 다룬다.
스트림(stream)이란 실제의 입력이나 출력이 표현된 데이터의 이상화된 흐름. 즉, 스트림은 운영체제에 의해
생성되는 가상의 연결 고리를 의미하며, 중간 매개자 역할.
- 입출력 스트림
스트림은 한 방향으로만 통신할 수 있으므로, 입력과 출력을 동시에 처리할 수는 없다. 따라서 스트림은
사용 목적에 따라 입력 스트림과 출력 스트림으로 구분.
Stream : 데이터 입출력시 모든 데이터를 형태와 상관없이 일련된 흐름으로 전송해주는 객체.
(1) in
int data
while((data = System.in.read())!=-1) {//1byte씩 읽음 //data 있을때까지 while로 받음(데이터 없을 때 -1 반환).
char ch = (char)data;
System.out.print(ch);
}
(2) out
OutputStream os = System.out; //묶는 이유는 능력 극대화
byte[] b = new byte[3]; //buffer
b[0] = 65; //A
b[1] = 97; //a
b[2] = 122; //z
os.write(b); //Aaz
os.close(); //닫음
(3) InputStreamReader : 1byte Stream을 2byte Stream으로 변환해주는 Stream. 독자적 사용X. 넘겨주는
역할만 한다. 브릿지 class.
Reader rd = new InputStreamReader(System.in); //보급형 그릇
int data;
while((data=rd.read())!=-1) {
char ch = (char)data;
System.out.print(ch);
}
(4) OutputStreamReader
Reader rd = new InputStreamReader(System.in);
Writer wr = new OutputStreamWriter(System.out);
int data;
while((data=rd.read())!=-1) {
wr.write(data); //데이터가 꽉차지 않으면 안 보낸다.
wr.flush(); //그 때 강제로 내보냄.
}
(5) FileInputStream : 파읽 읽음
FileInputStream fis = new FileInputStream("d:\\doc\\test.txt"); //경로 설정
int data;
while((data=fis.read())!=-1) {
//System.out.print((char)data); //못 읽음
//System.out.print(data);//유니코드 나옴
System.out.write(data);
System.out.flush();
}
fis.close();//닫는 습관 들이기
(6) FileOutputStream : 파일 출력
FileOutputStream fos = new FileOutputStream("d:\\doc\\out.txt"); //경로 설정
int data;
while((data=System.in.read())!=-1) {
fos.write(data);
fos.flush();
}
fos.close();
(7) 파일 복사 : FileInputStream,FileOutputStream 활용
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str1,str2;
int data;
try {
System.out.print("원본파일?: "); //d:\\doc\\test.txt
str1 = br.readLine();
System.out.print("대상파일?: "); //d:\\doc\\out1.txt
str2 = br.readLine();
FileInputStream fis = new FileInputStream(str1);
FileOutputStream fos = new FileOutputStream(str2);
while((data=fis.read())!=-1) {
fos.write(data);
fos.flush();
}
fis.close();
fos.close();
System.out.println("복사 완료!!");
} catch (Exception e) {
System.out.println(e.toString());
}
(8) 파일 복사 : File 활용
public class Test8 {
public boolean fileCopy(String file1,String file2) {//복사할 파일,적용할 파일
File f = new File(file1); //파일정보 읽음
if(!f.exists()) {//파일 있는지 //중간체크
return false;
}
try {//웹에서도 나온다! 기억하기!
//FileInputStream fis = new FileInputStream(file1);
FileInputStream fis = new FileInputStream(f);
FileOutputStream fos = new FileOutputStream(file2);
int data = 0;
byte[] buffer = new byte[1024];//한번에 내보낼수 있는 양 //크게 줄 필요 없다.
while((data=fis.read(buffer, 0, 1024))!=-1) {//0부터 1023 한꺼번에 읽어내라. //꺼내는것 결국 1바이 트
fos.write(buffer, 0, data);//내보내기
}
fos.close();
fis.close();
} catch (Exception e) {
System.out.println(e.toString());
return false;
}
return true; //왜? 호출했으니까!
}
public static void main(String[] args) {
Test8 ob = new Test8();
if(ob.fileCopy("d:\\doc\\test.txt", "d:\\doc\\out2.txt")) {
System.out.println("파일 복사 성공!!");
}else {
System.out.println("파일 복사 실패!!");
}
}
}
(9) FileInputStream,BufferedReader 활용하여 파일 읽기
FileInputStream fis = new FileInputStream("d:\\doc\\test.txt");
BufferedReader br = new BufferedReader(new InputStreamReader(fis));
String str; //버퍼드리더가 스트링으로 읽어서
while((str = br.readLine())!=null) {
System.out.println(str);
}
fis.close();
(10) FileOutputStream,PrintStream 활용하여 파일 출력 - BufferedReader 사용
FileOutputStream fos = new FileOutputStream("d:\\doc\\out3.txt");
PrintStream ps = new PrintStream(fos); //fos가 할수 없는 일 ps가 감싸 파일 내보냄.
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str;
while((str=br.readLine())!=null) {
//fos.write(str); //안됨
ps.println(str);
}
ps.close();
fos.close();
(11) FileOutputStream,PrintStream 활용하여 파일 출력 - PrintStream의 println() 사용
FileOutputStream fos;
PrintStream ps;
fos = new FileOutputStream("d:\\doc\\out4.txt");//,false
ps = new PrintStream(fos);
ps.println("배수지");
ps.println("정인선");
ps.println("유인나");
ps.close();
fos.close();
//fos = new FileOutputStream("d:\\doc\\out4.txt");//객체가 달라 덮어쓴다
fos = new FileOutputStream("d:\\doc\\out4.txt",true);//누적 //이름 틀리면 새로 만듦. //잘 안씀.
ps = new PrintStream(fos);
ps.println("설인아");
ps.println("한민용");
ps.close();
fos.close();
(12) File : 파일 및 폴더를 관리할 수 있도록 기능을 제공해주는 클래스. 파일의 복사, 이름변경 등의
조작을 할 경우에만 사용한다. 파일의 내용을 입출력할 수 있는 메소드는 없다.
File f = new File("d:\\doc\\test.txt");
System.out.println("파일명: " + f.getName());
System.out.println("파일길이: " + f.length());
System.out.println("파일절대경로: " + f.getAbsolutePath());
System.out.println("표준경로: " + f.getCanonicalPath()); //대문자
System.out.println("만든날: " + new Date(f.lastModified())); //간단히 날짜 가져옴
System.out.println("파일경로: " + f.getParent());
System.out.println("읽기속성: " + f.canRead()); //파일의 속성들어가 읽기속성
System.out.println("쓰기속성: " + f.canWrite());
//현재 작업경로
String p = System.getProperty("user.dir"); //"user.dir" 현재사용 디렉터리 읽어 넣어라
System.out.println("현재 작업경로: " + p);
(13) 폴더 만들고 파일 출력 : File,FileOutputStream,in
String str1 = "d:\\doc\\temp\\java\\test.txt";
// 012 3456 7890 2...
//방법1
/*String path = str1.substring(0,str1.lastIndexOf("\\"));
System.out.println(path);
File f = new File(path);
if(!f.exists()) {
f.mkdirs();//여러단계 만들어서 s붙음 //디렉토리 생성
}*/
//방법2
File f = new File(str1);
if(!f.getParentFile().exists()) {
f.getParentFile().mkdirs();//여러단계 만들어서 s붙음 //디렉토리 생성
}
//공통
try {
FileOutputStream fos = new FileOutputStream(str1);//파일 생성
System.out.println("문자열: ");
int data;
while((data=System.in.read())!=-1) {
fos.write(data);
fos.flush();
}
fos.close();
} catch (Exception e) {
System.out.println(e.toString());
}
(14) FileFilter (interface) : 자바로 폴더와 파일정보 보기, 탐색기 만들기
class MyFileList implements FileFilter {
private File f;
public MyFileList(String filePath) {//한번 객체생성때 2개 객체생성 (MyFileList와 File 클래스)
f = new File(filePath);
}
public void result() {
try {
if(!f.exists()) {
System.out.println("파일이 없다!!");
return; //아래코딩 실행X (stop) 메소드 빠져나감.
}
System.out.println("절대경로: " + f.getAbsolutePath());
System.out.println("파일크기: " + f.length());
if(f.isDirectory()) {
File[] lists = f.listFiles(this); //폴더와 파일 내용 읽어 배열에 폴더 이름 넣음 //accept에서 온것
for(int i=0;i<lists.length;i++) {
System.out.print(lists[i].getName());//이름
System.out.println("\t" + lists[i].length());//사이즈
}
}
File[] root = File.listRoots(); //내 드라이브 보임 (usb포함)
for(int i=0;i<root.length;i++) {
System.out.println(root[i].getPath());
}
} catch (Exception e) {
}
}
@Override
public boolean accept(File pathname) {//파일경로 주면 파일 디렉토리 내용읽어 리턴 ->this
//return pathname.isFile();
//return pathname.isDirectory();
return pathname.isFile()||pathname.isDirectory();
}
}
public class Test14 {
public static void main(String[] args) {
MyFileList mf = new MyFileList("c:\\");//filePath로
mf.result();
}
}
결과 :
절대경로: c:\
파일크기: 12288
$Recycle.Bin 8192
$WinREAgent 0
ADE 0
agentlog.txt 375
app 0
BluetoothExchangeFolder 0
Boot 8192
bootmgr 414038
BOOTNXT 1
BOOTSECT.BAK 8192
bootTel.dat 112
Config.Msi 376832
custom.dmp 65536
Documents and Settings 4096
Down 0
Download 0
DumpStack.log 8192
DumpStack.log.tmp 8192
found.000 4096
graph.log 3908
hiberfil.sys 3402014720
HP Universal Print Driver 0
image 0
Intel 0
Kings 0
MSOCache 0
New Folder 0
Nexon 4096
NVIDIA 0
OneDriveTemp 0
os_abb3.log 3508
PerfLogs 0
Program Files 12288
Program Files (x86) 16384
ProgramData 12288
Recovery 0
sampledb.dmp 151552
swapfile.sys 268435456
System Volume Information 4096
Temp 4096
upload 4096
Users 4096
Windows 32768
프린트 0
C:\
D:\
E:\
F:\
- 객체의 직렬화 : 메모리에 생성된 클래스 instance 변수의 현재상태를 그대로 보존해서 파일에 저장하거나
네트워크를 통해 전달할 수 있는 기능을 제공. byte 단위로만 데이터를 송수신.
장점 : 객체 자체의 내용을 입출력 형식에 구애받지 않고 객체를 파일에 저장함으로써 영속성을 제공할 수
있고, 네트워크를 통해 손쉽게 교환할 수 있다.
implements Serializable로 구현(직렬화 구현, List, Map과 함께 구현되어 있다.). 메소드가 없다.
(1) 파일 출력 : Hashtable,FileOutputStream,ObjectOutputStream 활용
Hashtable<String, String> h = new Hashtable<>();
//직렬화
h.put("1", "배수지");
h.put("2", "유인나");
h.put("3", "정인선");
try {
FileOutputStream fos = new FileOutputStream("d:\\doc\\data.txt");//파일 저장
ObjectOutputStream oos = new ObjectOutputStream(fos); //fos감싸 메모리 내용 읽어
//Object로 Upcast되어 저장.
oos.writeObject(h);//메모리 올라간 h 저장
oos.close();
fos.close();
System.out.println("직렬화 완료!!");
} catch (Exception e) {
}
- 역 직렬화 : 다른 사람이 만든 파일로 이 코딩으로 꺼낼 수 있다.
(1) 파일 읽기 : Hashtable,FileInputStream,ObjectInputStream 활용
try {
//역 직렬화
//다른 사람이 만든 파일로 이 코딩으로 꺼낼 수 있다.
FileInputStream fis = new FileInputStream("d:\\doc\\data.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
Hashtable<String, String> h2 =
(Hashtable<String, String>) ois.readObject(); //Hashtable 형태로 형변환
Iterator<String> it = h2.keySet().iterator();
while(it.hasNext()) {
String key = it.next();
String value = h2.get(key);
System.out.println(key + ":" + value);
}
ois.close();
fis.close();
System.out.println("역 직렬화 완료!!");
} catch (Exception e) {
}
- Externalizable : Serializable interface의 하위 interface로 Serializable interface와 같은 기능을 하되
조금 더 완벽한 제어가 가능. 메소드가 있다. writeExternal(), readExternal() 메소드를 정의. 자주사용X.
class DataTest implements Externalizable {
String name;
int age;
public DataTest() {}//기본생성자로 객체 생성하여 내부 메소드 읽음
//읽을때 객체
public DataTest(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return name + ":" + age;
}
@Override //역직렬화(복원)
public void readExternal(ObjectInput in)//파일에서 읽은 데이터 in으로
throws IOException, ClassNotFoundException {
name = (String)in.readObject();
age = in.readInt();
System.out.println("readExternal...");
}
@Override //직렬화
public void writeExternal(ObjectOutput out)//파일로 가져감
throws IOException {
out.writeObject(name);
out.writeInt(age);
System.out.println("writeExternal...");
}
}
public class Test1 {
public static void main(String[] args) {
try {
DataTest ob = new DataTest("배수지", 25); //꺼낼때 객체
FileOutputStream fos = new FileOutputStream("d:\\doc\\dataTest.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(ob);
fos.close();
oos.close();
FileInputStream fis = new FileInputStream("d:\\doc\\dataTest.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
DataTest dt = (DataTest)ois.readObject();
System.out.println(dt.toString());
fis.close();
ois.close();
} catch (Exception e) {
}
}
}
결과 :
writeExternal...
readExternal...
배수지:25
- RandomAccessFile : 이 클래스는 파일만을 대상으로 하며, 임의의 지점에서 입출력을 동시에 수행할 수 있다.
RandomAccessFile 클래스의 생성자에는 인수로 파일의 이름뿐만 아니라 파일 모드까지 함께 전달해야 함.
CD<-->tape.
"r" : 파일을 오로지 읽는 것만 가능한 모드로 개방함.
"rw" : 파일을 읽고 쓰는 것이 모두 가능한 모드로 개방함. 만약 파일이 없으면 새로운 파일을 생성함.
getFilePointer() : 파일 포인터의 현재 위치를 확인.
seek() : 파일 포인터의 위치를 변경.
File f = File.createTempFile("imsi", ".tmp"); //히든파일
f.deleteOnExit(); //프로그램 종료하면 삭제
FileOutputStream fos = new FileOutputStream(f);
for(int i=1;i<=100;i++) {
fos.write(i);
}
fos.close();
RandomAccessFile raf = new RandomAccessFile(f, "rw"); //f 읽고쓰게끔 만듦.
raf.seek(99);
System.out.println("seek(99): " + raf.readByte());
for(int i=0;i<100;i++) {
raf.seek(i);
System.out.println(raf.readByte());
}
- FileWriter 활용하여 파일 출력
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
FileWriter fw = new FileWriter("d:\\doc\\writ.txt");
BufferedWriter bw = new BufferedWriter(fw);
System.out.println("문자열:");
String str;
while((str = br.readLine())!=null) {
bw.write(str);
bw.newLine(); //enter 줄바꿈
}
bw.close();
fw.close();
- FileReader 활용하여 파일 읽음
FileReader fr = new FileReader("d:\\doc\\test.txt");
BufferedReader br = new BufferedReader(fr); //이렇게 써도 된다.
String str;
while((str=br.readLine())!=null) {
System.out.println(str);
}
fr.close();
- DataInputStream,DataOutputStream : 자바의 기본 8개 자료형을 직접 저장하고 읽을 수 있게 함.
플랫폼(OS)과는 무관하게 데이터를 저장할 수 있다.
FileOutputStream fos = new FileOutputStream("d:\\doc\\out5.txt");
DataOutputStream dos = new DataOutputStream(fos);
dos.writeUTF("대한민국");
dos.writeByte(10);
dos.writeChar('a');
dos.writeInt(20);
fos.close();
dos.close();
FileInputStream fis = new FileInputStream("d:\\doc\\out5.txt");
DataInputStream dis = new DataInputStream(fis);
System.out.println(dis.readUTF()); //순서대로 꺼내야 함
System.out.println(dis.readByte());
System.out.println(dis.readChar());
System.out.println(dis.readInt());
fis.close();
dis.close();
- StringReader,StringWriter
int ch;
String str = "Hello...";
StringReader sr = new StringReader(str);
StringWriter sw = new StringWriter();
while((ch=sr.read())!=-1) {//sr을 유니코드로 반환
sw.write(ch);
}
System.out.println(sw.toString());
//StringBuffer, StringBuilder : Stream이 아닌 class
StringBuffer sb = sw.getBuffer(); //쓴다면 이방법을 씀.
System.out.println(sb.toString());
sr.close();
sw.close();
결과 :
Hello...
Hello...
- private transient String pw; //transient : 특정 데이터 파일 저장하지 마라
46. AWT(Abstract Window Toolkit)
(1) AWT
- GUI프로그래밍(윈도우 프로그래밍)을 위한 도구
- Java로 구현하지 않고 OS의 컴포넌트를 그대로 사용(OS 종속적)
- 중량 컴포넌트(heavy weingt component)
(2) Swing
- AWT를 확장한 GUI프로그래밍 도구
- AWT보다 더 많은 종류의 컴포넌트 제공
- OS의 컴포넌트를 사용하지 않고 Java로 구현
- 경량 컴포넌트(light weight component)
(3) AWT의 구성
- AWT관련 패키지는 모두 java.awt로 시작
- AWT컴포넌트의 최상위 조상은 java.awt.Component 클래스(메뉴 관련 컴포넌트 제외)
(4) Container
- 다른 컴포넌트를 포함할 수 있는 컴포넌트
- 독립적인 컨테이너: 독립 사용 가능, 다른 컴포넌트나 종속적 컨테이너를 포함 가능
- 종속적인 컨테이너: 독립 사용 불가(다른 컨테이너에 포함)
- add()를 사용해서 추가
- 컨테이너에 담기는 컴포넌트는 컨테이너의 설정을 따름(변경 가능)
- 컨테이너 : 다른 컴포넌트를 포함할 수 있는 특별한 GUI 컴포넌트. 컨테이너가 되기 위해서는
java.awt.Container 클래스를 상속받아야만 함.
(1) AWT 컨테이너 컴포넌트 : Frame, Panel, Applet, Dialog, Window
(2) Swing 컨테이너 컴포넌트 : JFrame, JPanel, JApplet, JDialog, JWindow
- Java FX : JavaFx란 크로스 플랫폼에서 실행하는 리치 클라이언트 애플리케이션(Rich Client Application)
을 개발하기 위한 그래픽과 미디어 패키지이다. JavaFx는 자바 표준 UI 였던 라이브러리였던 Swing을 대체
하기 위해 만들어졌으며 더 가볍고 더 강력해진 라이브러리다. JDK 11부터는 JavaFx는 별도로 분리되었기
때문에 설치 및 설정이 필요하다.
47. Class 클래스
Class 클래스 (클래스라는 클래스가 있다.) : 특정 class나 interface에 관한 정보를 검색할(읽어올) 수 있는 메소드를 포함하고 있다.
class Test {
public void write() {
System.out.println("테스트...");
}
}
public class Test3 {
public static void main(String[] args) {
try {
//Class<?> c
Class c = Class.forName("com.day21.Test"); //Object자료형
//객체생성 안해 forName 많이쓴다.
Object ob = c.newInstance(); //객체생성 코딩
Test t =(Test)ob;
t.write();
} catch (Exception e) {
}
}
}
결과 : 테스트...
- 생성자, 필드(변수), 메소드 정보 출력
public class Test4 {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.print("클래스명[java.lang.String]: ");
String str = br.readLine();
Class cls = Class.forName(str); //많이 쓴다.
//생성자 정보
Constructor[] c = cls.getConstructors();
System.out.println("생성자....");
for(int i=0;i<c.length;i++) {
System.out.println(c[i]);
}
//찍기:java.lang.String / java.io.BufferedReader
//필드 정보(변수)
Field[] f = cls.getFields();
System.out.println("필드....");
for(int i=0;i<f.length;i++) {
System.out.println(f[i]);
}
//메소드 정보
Method[] m = cls.getMethods();
System.out.println("메소드....");
for(int i=0;i<m.length;i++) {
System.out.println(m[i]);
}
}
}
48. 정규화 표현식
정규화 표현식 : 다른 언어에서도 공통으로 사용하는 표현식. java.util.regex.
회사에 이미 있어서 외울필요 없다.
c[a-z]* : c 로 시작하는 영어단어 (c,ca,cabc)
c[a-z] : c 로 시작하는 두글자의 영어단어(ca, cb)
c[a-zA-Z0-9] :ca, cA, c4
c. : c로 시작하는 두글자(ca, cB, c&)
c.* : c 로 시작하는 모든문자
c.*t : ct, chhhhhht, c7777777t : c로시작 t로끝남.
[b|c].* 또는 [b,c].* 또는 [b-c].* : b, c, b나c로시작하는 여러문자
[^b|c].* 또는 [^b,c].* 또는 [^b-c].* : b 또는 c 로 시작하지 않는 여러문자
.*c.* : c가포함된 모든 문자열
[\\d]+ 또는 [0-9]+ : 하나 이상의 숫자
String[] str = {"bat","baby","bonus","c","cA","ca","c.","c0","car","cambat",
"count","data","disc"};
Pattern p;
p = Pattern.compile("c[a-z]*"); //c로 시작하는 소문자
for(String s : str) {
Matcher m = p.matcher(s); //값을 넣어 p 구조와 일치하는지?
if(m.matches()) {
System.out.print(s + " ");
}
}
결과 : c ca car cambat count
- 메일 확인
String[] mails = {"aaa@aaa.com","@aaa.co.kr",".@bbb.com",
"aaa@vvv.co.kr","sss.co.kr","abc@aaa"};
//[\\w]+ : 한글자 이상의 영,숫자 여러개
//@ : @
//(\\.[\\w]+) : 괄호 안에 있는 것은 반드시 한 번은 나와야 함.
// \\. : 도트는 반드시 와야 함.
String pat = "[\\w]+@[\\w]+(\\.[\\w]+)+";
for(String s : mails) {
if(Pattern.matches(pat, s)) {
System.out.print(s + " ");
}
}
결과 : aaa@aaa.com aaa@vvv.co.kr
49. Network
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String host;
System.out.print("호스트[www.naver.com]: ");
host = br.readLine();
try {
InetAddress ia = InetAddress.getByName(host);
System.out.println("ip주소: " + ia.getHostAddress());
System.out.println("호스트이름: " + ia.getHostName());
} catch (Exception e) {
}
결과 :
호스트[www.naver.com]: www.naver.com
ip주소: 125.209.222.142
호스트이름: www.naver.com
50. JDBC
JDBC : DB에 접근할 수 있도록 Java에서 제공하는 API이다.
(1) DriverManager가 Connection을 생성
(2) Connection이 Statement생성(sql 구문을 실행하는 인터페이스) - 종류 3가지
(3) Statement가 sql을 실행
- ResultSet : TABLE 받을수 있는 인터페이스 (자료형이면서 데이터저장), 저장공간
[출처]
- http://tcpschool.com/
코딩교육 티씨피스쿨
4차산업혁명, 코딩교육, 소프트웨어교육, 코딩기초, SW코딩, 기초코딩부터 자바 파이썬 등
tcpschool.com
댓글