Download Java_study

Java 소스 정리(하이퍼링크)
1. 기본데이터타입(형변환)
37. JTree 와 JTable 클래스
2. 아스키제어문자 및 문자(엔터문자)
38. TCP통신(InetAddress,Socket, rverSocket)
3. Wrapper 클래스(4byte)
4. 기본 입출력
5. 파일의 입출력
6. 1byte 입출력
7. 텍스트 입출력(Scanner 클래스)
8. 객체 입출력
9. 연산자 우선순위
10. 문자열 나누기
11. 문자열 검색
12. 문자열의 NULL값
13. 문자열에서 문자 추출하기
14. 문자열 객체 변경하기(StringBuffer)
15. String으로부터 문자배열 만들기
16. 기본클래스(접근제한자, 지정예약어)
17. 자바 4 대 클래스
18. 상속과 다양성
19. abstract(추상적) 와 interface
20. 스래드 Multi-Thread
21. 예외와 예외처리
22. Package
23. assertion
24. Collection 과 APIs
25. Frame 클래스와 Label
26. Layout Manager
27. Panel 클래스
28. 주변 클래스들
29. AWT 관련 컴포넌트
30. Event 생성방법
31. Event 활용 범위
32. Graphics의 paint 메서드 사용 방법
33. Applet 작성법
34. Applet의Image와 Sound
35. Swing(JFC) 컴포넌트
36. JApplet 작성법
1.기본데이타타입(Primitive Data Type) <처음으로>
byte(1), char(2), int(4), long(8), float(4), double(8), boolean(1)
▣ 정수형
◈ 1 byte -128~127
◈ 2 short -32768~32767
◈ 4 int -2147483648 ~
◈ 8 long
2147483647
-922 경 ~ 922 경 long e = 1232312L;
◈ 2 char 0 ~ 65535 (계산으로 되면 아스키코드로 된다)
▣ 실수형
◈ 4 float
◈ 8 double
▣ 논리형
◈ 1 boolean 형변환 불가 반드시 초기화 값
형변환
Promotion : 자동 형변환 Casting : 강제 형변환
a= Byte.parseByte(변수) //byte 로 변환
b = Integer.parseInt(변수) //정수로 변환
c = Float.parseFloat(변수) //float 로 변환
그밖에 API 에서 parse 레퍼 클래스를 확인 가능
문자형 저장
String
2.아스키 제어문자 및 문자<처음으로>
0 ‘\0’ null
8 ‘\b’ backspace
9 ‘\t’ tab
10 ‘\n’ 밑으로
13 ‘\r’ 처음으로
엔터키 ‘\n\r’
27 esc
48 ~ 57 '0' ~'9'
65 ~ 90'A' ~'Z'
97 ~ 122'a' ~'z'
3. Wrapper 클래스 (4byte) <처음으로>
데이터법위의 주소를 나타낸다
지역 변수는 초기값을 지정해 줘야한다
변수는 {} 밖으로 나오면 변수는 살아진다.
4. 기본입출력<처음으로>
System.err.println = 에러출력
System.in.read() = 입력
System.out.println = 출력
System.out.write(65);
//아스키코드를 입력하면 해당 문자가 버퍼에 저장된다.(write Method)
System.out.flush();
//버퍼에 저장된 문자를 불러온다.
배열을 사용하여 입출력
byte[] by = new byte[]{'j', 'a','v','a'};
System.out.write(by,0 ,4);
//Autoflush 사용안해도 배열로 하면 가능하다
문자열 입력(반드시예의처리)
byte[] by = new byte[10];
System.out.println("과목 =");
System.in.read(by);
System.out.println("결과="+new String(by));
문자 및 숫자 입력
System.in.read(); //아스키 입력방법
System.in.read()-48; //or 'o' 숫자입력방법
(char)System.in.read(); //문자입력방법
※ 단 키 하나에 한번 저장된다. 그러므로 byte[] 배열을 사용한다.
5. 파일 입출력<처음으로>
String a = File.pathSeparator; //답= ; 파일구분자
char b= File.pathSeparatorChar;//답= ;
String c= File.separator; //답 = \
char d= File.separatorChar;
//어떤 운영체제에서도 사용할수 있도록 하는 구분자
File f = new File("Exam_01.java");
//존재하든, 존재 안하든 매개변수 한개만있으면 현재 폴더에서 찾게된다.
File f2 =
new File("E:\\웹연습\\java\\공부방\\Day016\\src\\Exam_02.java");
//절대경로로 해도 된다.
File dir = new File("E:\\웹연습\\java\\공부방\\Day016\\src"); //디렉토리로
입력가능
File f3 = new File(dir,"Exam_03.java");
//디렉토리 사용하여 파일 검색
boolean b = f.exists(); //파일 존재 여부 확인
System.out.println("read ? " + f.canRead()); //읽을수 있는가
System.out.println("write ? "+ f.canWrite()); // 쓸수 있는가
try{
boolean bool = f1.createNewFile();//파일이 없으면 생성한다.
System.out.println("bool = "+bool);
}catch(IOException e){}
try{
File ff = new File(".");
File f2 = File.createTempFile("teme", ".txt", ff); //임시 파일 만들기
System.out.println("f2 ="+f2);
f2.delete(); // 즉시 지운다.
}catch(IOException e){}
f1.deleteOnExit();
//deleteOnExit () 프로그램이 끝날때 지워라
System.out.println("f abs path = " + f.getAbsolutePath()); //절대 경로
System.out.println("f 상대경로는 " + f.getCanonicalPath());//상대경로
System.out.println("f 상대경로는 " + f.getCanonicalFile());//상대경로
System.out.println("name = "+f.getName()); //파일이름
System.out.println("parent = " + f.getParent()); //파일 상위
System.out.println("path" + f.getPath()); //전부
System.out.println("fff is dir = " + fff.isDirectory()); //디렉토리인가
System.out.println("f is File = " + f.isFile()); //파일인가
System.out.println("f is hidden =" + f.isHidden());//숨긴 파일인가
System.out.println("f is lastModified" +
new Date(f.lastModified())); //최종 수정일 DATA 사용
f.setLastModified(new Date().getTime());
//setLastModified 최종 수정일 변경
System.out.println("f is lastModified" +
new Date(f.lastModified()));
System.out.println("f is size =" + f.length() + "bytes");
//파일 바이트용량을 가지고 온다
String[] s = fff.list();
///해동 디렉토리안에 들어있는 파일리스트를 가지고 온다.
for(String i : s){
System.out.println(i);
}
File[] roots = File.listRoots(); //드라이버(루트) 리스트를 가지고 온다.
for(File i: roots){
System.out.println(i);
}
File f2 = new File("AAA");
System.out.println(f2.mkdir()); //디렉토리를 생성함 생성하면 true 값
File f3 = new File("bbb/ccc/ddd");
System.out.println(f3.mkdirs());
//하위디렉토리와 함께 생성할때 사용 True 값 전달
f.setReadOnly(); //읽기 전용으로 변경
전달
6. 1byte 입출력<처음으로>
•
1byte 출력
import java.io.*;
public class Exam_05 {
public static void main(String [] ar) throws IOException{
FileOutputStream fos1 = new FileOutputStream(FileDescriptor.out); //기본출력스트림으로
대상을 콘솔로
File f= new File("aaa.txt");
FileOutputStream fos2 = new FileOutputStream(f,true);
//기본출력스트림으로 대상을 파일로 뒤에
boolean 값이 들어오면 연결해서 출력할것인지
byte[] by = new byte[]{'H','e','l','l','e',' ','j','a','v','a'};
//System.out.println("Hello java");
fos1.write(by);//바이트 배열로 //콘솔
fos1.write(by,6,4);//바이트 배열로 //콘솔 6칸부터4칸을 출력
fos2.write(by);//바이트배열로 //파일
fos1.write(65); //A출력
fos1.close();
fos1.close();
}
}
import java.io.*;
public class Exam_06 {
public static void main(String[] ar) throws IOException{
FileOutputStream fos1
= new FileOutputStream(FileDescriptor.out);
BufferedOutputStream bos1
= new BufferedOutputStream(fos1, 2048);
//로컬 2048 파일 1024 네트워크 512 적당
DataOutputStream dos1 = new DataOutputStream(bos1);
//각각의 자료형으로 출력할때
FileOutputStream fos2
= new FileOutputStream(new File("bbb.txt"),false);
BufferedOutputStream bos2 = new BufferedOutputStream(fos2,1024);
DataOutputStream dos2 = new DataOutputStream(bos2);
dos1.writeInt(20);
dos1.writeDouble(12.34);
dos1.flush(); //해당 버퍼에서 나오게한다.
dos1.writeChar('A');
dos1.writeByte('\n'); //한칸 뛰움
dos1.writeByte('B');
dos1.close(); //스트림을 닫는다.
dos2.writeInt(20);
dos2.writeDouble(12.34);
dos2.flush(); //해당 버퍼에서 나오게한다.
dos2.writeChar('A');
dos2.writeByte('\n'); //한칸 뛰움
dos2.writeByte('B');
dos2.close(); //스트림을 닫는다.
}
}
•
1byte 입력
import java.io.*;
public class Exam_07 {
public static void main(String[] ar) throws IOException{
FileInputStream fis1
= new FileInputStream(FileDescriptor.in);
FileInputStream fis2
= new FileInputStream(new File("aaa.txt"));
System.out.print("문자 = ");
char ch =(char)fis1.read(); //문자 한글자
System.in.read();
System.out.print("문자열 = ");
byte[] by = new byte[1024];
fis1.read(by); //문자는 배열
System.out.println();
System.out.println("ch = " + ch);
System.out.println("by = " + new String(by).trim());
//문자열 사이의 공백을 없앤다
fis1.close();
while(true){
int x = fis2.read(); //한바이트로 입력
if(x==-1) break; //파일안에 글의 끝을 나타낸다.
System.out.print((char)x); //인트로 받은 것을 char 변경
}
fis2.close();
}
}
import java.io.*;
public class Exam_09 {
public static void main(String[] ar) throws IOException{
File f = new File("bbb.txt");
FileInputStream fis
= new FileInputStream(f);
BufferedInputStream bis
= new BufferedInputStream(fis, 1024);
DataInputStream dis
= new DataInputStream(bis);
int a = dis.readInt();
double b = dis.readDouble();
char c = dis.readChar();
byte d = dis.readByte();
byte e = dis.readByte();
/*while(true){
int x = dis.read(); //한바이트로 입력
if(x==-1) break; //파일안에 글의 끝을 나타낸다.
System.out.print((char)x); //인트로 받은 것을 char 변경
}*/
dis.close();
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);
System.out.println("d = " + d);
System.out.println("e = " + (char)e);
}
}
7. 텍스트 입출력<처음으로>
텍스트입력과출력
•
텍스트 출력
import java.io.*;
public class Exam_10 {
public static void main(String[] ar) throws IOException{
//한글(2byte) 할때는 텍스트 출력으로 사용 한다
OutputStreamWriter osw
= new OutputStreamWriter(System.out);
//반드스 1byte 메개변수를 사용해야한다.
BufferedWriter bw = new BufferedWriter(osw, 1024);
PrintWriter pw = new PrintWriter(bw);
File f = new File("ccc.html");
try{
boolean bool = f.createNewFile();
}catch(IOException e){}
FileWriter fw = new FileWriter(f);
BufferedWriter bw1 = new BufferedWriter(fw,1024);
PrintWriter pw1 = new PrintWriter(bw1);
pw.println(10);
pw.println("test 안녕하세요");
pw1.println(10);
pw1.println("text 안녕하세요");
pw.close();
pw1.close();
}
}
•
텍스트 입력
import java.io.*;
public class Exam_11 {
public static void main(String[] ar) throws IOException {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
// BufferedReader in
= new BufferedReader(new InputStreamReader(System.in));
File f = new File("ccc.txt");
FileReader fr = new FileReader(f);
// new FileReader(파일객체 or 문자열);
BufferedReader br1 = new BufferedReader(fr);
System.out.print("문자열 = ");
String str = br.readLine();
System.out.println("str = " + str);
System.out.print("숫자 = ");
int x = Integer.parseInt(br.readLine());
System.out.println("x = " + x);
System.out.println("================================");
while(true) {
String s = br1.readLine();
if(s == null) break;
System.out.println("s = " + s);
} //출력부분
br.close();
br1.close();
}
}
*java.util.Scanner 클래스
import java.io.*;
import java.util.*;
public class Exam_12 {
public static void main(String [] ar) throws IOException{
Scanner in = new Scanner(System.in);
System.out.print("문자열 = ");
String str = in.next();
System.out.print("숫자 = ");
int x = in.nextInt();
System.out.print("더블 숫자 = ");
double y = in.nextDouble();
System.out.println("str = " + str);
System.out.println("x = " + x);
System.out.println("y = " + y);
String input = "1 fish 2 fish red fish blue fish";
Scanner s = new Scanner(input).useDelimiter("\\s*fish\\s*");
//API참고
System.out.println(s.nextInt());
System.out.println(s.nextInt());
System.out.println(s.next());
System.out.println(s.next());
s.close();
}
}
import java.io.*;
import java.util.*;
public class Exam_13 {
public static void main(String [] ar) throws IOException{
if(ar.length < 1) System.exit(0); //ar배열이 없으면 종료
String str = "";
for(int i = 0; i < ar.length; ++i){
str += ar[i] + " ";
}
//System.out.println(str);
Scanner in = new Scanner(str);
int i = 0;
int tot = 0;
while(in.hasNext()){
i++;
//System.out.println(in.next());
tot += in.nextInt();
}
System.out.println("총 개수 = " + i + "개");
System.out.println("총 합
= " + tot + "점");
System.out.println("평 균
= " + tot/i + "점");
//뛰어 쓰기는 useDelimiter 사용안해도 기본으로 된다.
}
}
8. 객체 입출력<처음으로>
//직열화
•
객체 출력
import java.io.*;
class AAA implements
Serializable {
//반드시 객체를 직열화 시킴
int x= 100;
int y = 200;
int z = 300;
//읽는 쪽에도 동일 클래스가 있어야 한다.
}
public class Exam_14 {
public static void main(String [] ar) throws IOException{
AAA ap = new AAA();
File f = new File("ddd.txt");
FileOutputStream fos = new FileOutputStream(f);
BufferedOutputStream bos
= new BufferedOutputStream(fos, 1024);
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(ap);
oos.close();
System.out.println("출력완료");
}
}
•
객체 입력
import java.io.*;
public class Exam_15 {
public static void main(String [] ar) throws IOException {
File f = new File("ddd.txt");
FileInputStream fis = new FileInputStream(f);
BufferedInputStream bis
= new BufferedInputStream(fis,1024);
ObjectInputStream ois = new ObjectInputStream(bis);
Object obj = null;
try{
obj = ois.readObject();
} catch(ClassNotFoundException e){}
AAA ap = (AAA)obj;
System.out.println(ap.x);
System.out.println(ap.y);
System.out.println(ap.z);
}
}
9. 연산자 우선순위<처음으로>
최우선 연산자 - 단항연산자 - 산술 연산자 - 쉬프트 연산자 - 관계 연산자 - 논리연산자 - 삼항연산자 배정대입연산자 - 증감 후위 연산자 - 순차연산자
1. .(점) , [], ()
2. !(논리부정), ~(비트부정), +,-(부호연산), ++,-- , 현변환연산 “(cast 자료형)”,
Tvpe 비교 : “instanceof" 예) Boolean bool = ex instanceof object
3. *, /, %(나머지) , +, 4. <<, >>, >>> 비트를 뽑을 때
※ >>> : unsigned right shift 연산자
이동하면 앞자리는 무조건 0 으로 지정해줘라
5. > < >= <= , == !=
6. 비트 연산자 : 비트로 변경하여 “&”-and, "|"-or, "^"-XOR
논리 연산자 : && -and ||-or
비교할 때 비트연산자를 사용하면 앞에서 상황판단이 가능해도 뒤에 까지 계산한다.
7. 조건항 ? 항 1 : 항 2
8. 배정 대입 연산자 “+=“ 등
9. ,(콤마) 예)byte b = 10, a = 20
10. 문자열 나누기<처음으로>
String str = "ABC|DEF|GHI|JKL";
StringTokenizer tokens = new StringTokenizer(str,"|");
// import java.util.*; 사용하여 해당 글자를 토대로 문자열을 나눈다
for(int i = 1;tokens.hasMoreTokens(); i++){
System.out.println("문자열 " + i + ":" + tokens.nextToken());
}
}
String str1 = "ABC|DEF|GHI|JKL";
String[] str2 = str1.split("|");
// split 을 이용한 문자열 나누기
for(int i = 0 ;i < str2.length : i++){
System.out.println("문자열 " + i + ":" + str2[i]);
}
11. 문자열 검사<처음으로>
a. equals(b); //문자열 a 와 b 가 같은가?
- 대소문자를 무시하고 비교 위해서는 equalsIgnoreCase()를 사용한다.
※ int -> String 로 변경
Integer.toString(int);
String str = "abc";
char[] data = {'a', 'b', 'c'};
String str = new String(data);
12. 문자열의 NULL 값<처음으로>
public class StringTest {
public static void main(String[] args) throws java.io.IOException {
String a;
String b=null;
if (b == null) {
System.out.println("b 는 아무것도 참조하지 않습니다...");
}
//아래의 경우 Compile 시 NullPointEXception 이 발생한다.
//System.out.println("b=null 일때 b 의 길이 -->"+b.length());
//아래의 두경우 모두 a 가 초기화 되지 않았다는 오류발생
//if (a == "1234"){
//System.out.println("a 는 '1234'와 같습니다...");
//}
//if (a == null) {
// System.out.println("a 는 아무것도 참조하지 않습니다...");
//}
/////////////////////////////////////////////////////////
if (c == null) { System.out.println("c 는 아무것도 참조하지 않습니다..."); }
if (c == "") { System.out.println("c 는 \"\" 입니다...");}
if (c == " ") { System.out.println("c 는 \" \" 입니다...");}
if (c.equals(null)){ System.out.println("c 는 아무것도 참조하지 않습니다...");}
if (c.equals("")){ System.out.println("c 는 \"\" 입니다...");}
if (c.equals(" ")) { System.out.println("c 는 \" \" 입니다...");
}
//아래의 경우 c 가 ""이므로 NullPointException 이 발생한다.
//if (c.compareTo("")==0){
// System.out.println("c 는 \"\" 입니다...");
//}
System.out.println("\"\"의 길이 -->"+c.length());
/////////////////////////////////////////////////////////
String d=" ";
System.out.println(d.hashCode());
if (d == null) { System.out.println("d 는 아무것도 참조하지 않습니다..."); }
if (d == "") { System.out.println("d 는 \"\" 입니다...");}
if (d == " ") { System.out.println("d 는 \" \" 입니다...");}
if (d.equals(null)){ System.out.println("d 는 아무것도 참조하지 않습니다...");}
if (d.equals("")){ System.out.println("d 는 \"\" 입니다...");}
if (d.equals(" ")) { System.out.println("d 는 \" \" 입니다...");}
// 이 경우에도 NullPointException 이 발생한다.(주의)
//if (d.compareTo(" ")==0){
// System.out.println("d 는 \" \" 입니다...");
//}
System.out.println("\" \"의 길이 -->"+d.length());
d = d.trim();
System.out.println("trim 후 \" \"의 길이 -->"+d.length());
}
}
13. 문자열에서 문자 추출하기 <처음으로>
- charAt() : 변위(처음 부터 얼마나 떨어져 있나)를 인자로 사용
- length() : 문자열의 길이를 돌려줌
(배열의 경우엔 데이터 멤버인 length 를 사용)
- indexOf() : 문자의 위치를 찾아 변위값을 돌려줌, 못찾을경우엔 –1 Return
String text = “I love korea”;
int I = text.indexOf(‘o’); //’o’가 있는 첫번째 색인 찾아줌
int j = text.lastIndexOf(‘o’);//가장끝의 ‘o’를 찾아줌
int k= text.indexOf(‘o’,3); //startIndex 인 3 이후 부터 검색
int l = text.indexOf(“Korea”); //Korea 가 있는 첫번째 색인
int m = text.indexOf(“Korea”,3); //startIndex 인 3 이후 부터 검색
- subString() : 문자열 추출
String s = “I love Korea”;
String lastWord = s.subString(7); // 7 번째 색인 이후 전부
String seg = s.subString(7,11);//7~11 번째 색인의 문자 Return
14. 문자열 객체 변경하기(StringBuffer) <처음으로>
- replace() : 문자열을 대체시킴
String text = “I love Korea”;
String newText = text.replace(‘ ‘, ‘/’);
//앞에 있는 인수는 바뀔 문자 두번째 있는 인수는 바꿀 문자
- trim() : 문자열 앞뒤의 공백제거
String text = “ I love Korea “;
String newText = text.trim();
StringBuffer
- String 객체는 객체를 조합하여 수정하는등 변경을 가할수 없는 불변문자열
StringBuffer 는 직접 변경을 가할수 있는 가변문자열 임. 문자열 변환작업
(추가, 작제, 대체등…)에 용이함
자바에서 String 에 대한 작업을 수행할때 내부적으로는 StringBuffer 사용
문자열을 포함할수도, 안할수도 있는 메모리 공간의 버퍼로 구성
- 생성방법
StringBuffer sb = new StringBuffer(“I love Korea”); //아래와 같은 효과
StringBuffer sb = null; //객체참조변수 sb 는 아무것도 참조하지 않는다.
sb = new StringBuffer(I love Korea);
- StringBuffer 의 용량
StringBuffer sb = new StringBuffer(“I love Korea”);
int myLength = sb.length(); //12
int myCapacity = sb.capacity(); //24
StringBuffer sb = new StringBuffer(50); //용량을 지정
용량을 작게 잡았는데, 큰 문자열이 들어온다면 자동으로 확장하게 되어
(별도의 메모리가 할당) 시간이 걸리게 된다.
- StringBuffer 길이 변경하기
StringBuffer sb = new StringBuffer(“I love Korea”);
sb.setLength(6); //I love, 잘린 부분은 없어짐
sb.setLength(12); //길이를 증가
//I love \u0000(6 개)와 같이 \u0000 으로 채워진다.
- 객체추가
StringBuffer sb = new StringBuffer(“I love Korea”);
sb.append(“ me too!”);
혹은 다른 StringBuffer 객체에 할당도 가능
StringBuffer sb2 = sb.append(me too!”);
- 기본데이터 유형 붙이기
StringBuffer sb = new StringBuffer(“I love Korea”);
int I=99;
StringBuffer sb = sb.append(I); //I love Korea99
sb.append(12,45); //I love Korea9912.45
StringBuffer sb = new StringBuffer(“I love Korea”);
char[] c = {‘A’,’B’,’C’};
sb.append(c,1,2); //I love KoreaBC
- 문자열 삽입하기
StringBuffer sb = new StringBuffer(“I love Korea”);
sb.insert(0, “Oh~”); //Oh~I love Korea
- 문자대체하기
StringBuffer sb = new StringBuffer(“I love Korea”);
sb.setCharAt(2, ‘L’); //I Love Korea
- 문자열 뒤집기
StringBuffer sb = new StringBuffer(“I love Korea”);
sb.reverse(); //aeroK evol I
- StringBuffer 를 String 객체로 만들기
StringBuffer sb = new StringBuffer(“I love Korea”);
String s = sb.toString();
- String 은 값이 변경될 때마다 새로운 String 객체를 생성한다. 즉, 하나의 String 객체는 사실상
더 이상 변경이 되지 않는 것이다. 반면, StringBuffer 는 하나의 객체에 새로이 값을 추가하고
변경할
수
있는
장점이
있다.
그러므로
하나의
문자열에
잦은
변경이
있는
경우에는
StringBuffer 를 사용함이 잦은 객체 생성을 막고, 메모리 효율성을 높일 수 있다고 말할 수 있다.
15. String 으로부터 문자배열 만들기 <처음으로>
- toCharArray() : char 유형의 배열을 만든다.
char[] charArray = text.toCharArray();
- getChars(int p1, int p2, char[] p3, int p4) : 문자열을 문자배열로 추출
p1 : 처음색인, p2 : 마지막색인, p3 : 배열이름, p4 : 배열의 시작색인
String text = “I love Korea”;
char[] charArray = new char[3];
text.getChars(0, text.length()-1, charArray, 0);
- getBytes() : String 을 현재 시스템의 인코딩을 따라 8 비트로 변환하여 문자
를 byte 형태로 추출
String text = “I love Korea”;
byte[] byteArray = text.getBytes();
char[] 유형의 배열을 String 객체로 만들기
- copyValueOf() : static Method
char[] c = {‘A’,’B’,’C’};
String text = String.copyValueOf(c);
16. 기본클래스(접근제한자, 지정예약어)<처음으로>
this 정의 : 클래스 내부에서 자신의 클래스를 지칭하는 객체
this() 정의 : 생성자 내부에서 자신 클래스의 또 다른 생성자를 지칭하는 메서드
메서드의 0 번째 매개변수
자신_클래스명 this this 는 예약어
0 번째 매개변수는 표기할 수 없다.
클래스는 생성자가 필요한다. 생성자는 클래스명과 동일 생성자는 여러개 가능하나 매개변수가
달라야한다. 생략하면 기본 클래스가 자동으로 설정된다.
예)
public class Bog(){
Bog(){}//생략되어있다.
}
public static void main(String[]ar){
Bog 변수 = new Bog()
}
Garbage Collection
null 호출 되면 만약 한 개라도 참소되면 호출이 되지 않는다.
접근 제한자
- private : 하나의 클래스 내에서만 사용 가능한 멤버를 지정할 때 사용하는 제한자
- package : 동일 파일 + 동일 폴더
- protected : 동일 파일 + 동일 폴더 + 상속
- public : 객체를 가진 모든 영역
멤버 필드(Member Field)
-형식 : 접근제한자 지정예약어 자료형 필드명 = 값
멤버 메서드(Member Method)
-형식 : 접근제한자 지정예약어 결과형리턴값
메서드명(매개변수들) throws 예외클래스들 {
내용부…
}
지정예약어
static 필드 : 데이터 값의 공유를 위해 선언하는 공간 (멤버필드로만 가능)
-클래스 이름으로 접근 가능
-객체 발생 전 메모리 할당
static 초기화 영역 : static 멤버 필드의 값을 초기화 하기 위한 영역
생성자에서 초기화 하지 않고 시작할 때 형식에 따라 사용
형식) static { 초기화 구문… }
static 메서드 : static 필드 컨트롤 목적
final 필드 : 상수 값을 저장하기 위한 공간으로 값이 변경될 수 없음
-지역변수나 멤버 필드 모두 가능
final 메서드 : 상속 시 오버라이딩 되지 않아야 할 메서드를 지정
-만약 overriding 하게 되면 에러 발생
transient : 직렬화 되지 않는 멤버 Data 지정
instanceof : 특정 클래스의 instance 여부를 체크
ex) A ap = new A();
boolean a = ap instanceof a;
ap 가 a 의 인스턴스인가?
17.자바 4 대 클래스 <처음으로>
1. 중첩 클래스(Inner Class)
-클래스 내부에 또 다른 클래스를 가짐으로 클래스 관리의 효율을 높인 것
(static 포함불가)
중첩 클래스의 형식과 생성파일
형식) class Outer { class Inner { … } }
생성파일) Outer.class, Outer$Inner.class
중첩 클래스 객체 생성
Outer.Inner oi = new Outer().new Inner();
예)
class Outer{
private int x= 100;
private static int y = 200;
public Outer(){}
public void disp(){
System.out.println("x = "+x);
System.out.println("y = "+y);
}
class Inner{
private int a= 100;
public Inner(){}
public void disp_in(){
System.out.println("a = "+a);
disp();
}
class Other_Inner{};
}
}
public class Exam_01 {
public static void main(String [] ar){
Outer ot = new Outer();
Outer.Inner oa = ot.new Inner();
oa.disp_in();
}
}
2. 정적 중첩 클래스(static Inner Class)
-중첩 클래스 내부에 static 멤버를 포함할 수 있는 형태(Outer 의 non-static 멤버 포함 불가)
정적 중첩 클래스의 형식과 생성파일
-형식) class Outer { static class Inner {…} }
-생성파일) Outer.class, Outer$Inner.class
정적 중첩 클래스 객체 생성
-Outer.Inner oi = new Outer.Inner();
예)
class Outer1{
private int x = 100;
private static int y = 200;
public Outer1(){}
public void disp(){
System.out.println("x = "+x);
System.out.println("y = "+y);
}
static class Inner1{
private int a= 10;
static int b = 20;
public void disp_in(){
System.out.println("a = "+a);
System.out.println("b = "+b);
//System.out.println("x = "+x); non-static
System.out.println("y = "+y);
}
}
}
public class Exam_02 {
public static void main(String[] ar){
Outer1.Inner1 oi = new Outer1.Inner1();
oi.disp_in();
System.out.println("b = "+ Outer1.Inner1.b);
}
}
3. 지역 중첩 클래스(local Inner class)
메서드 실행 시에 사용되는 클래스를 정의한 형식으로 접근자나 지정어를 가질 수 없다.
지역 중첩 클래스의 형식 및 생성 파일
-형식) class Outer { method() { class Inner { … } } }
-생성파일) Outer.class, Outer$숫자 Inner.class
객체 생성은 외부에서 할 수 없다.
class Outer2{
private int x = 100;
private static int y = 200;
public void disp(){
class Inner2{
private int a =10;
//private static int b =20;
public void disp_in(){
System.out.println("a = " + a);
System.out.println("x = " + x);
System.out.println("y = " + y);
}
}
Inner2 in = new Inner2();
in.disp_in();
}
}
public class Exam_03 {
public static void main(String[]ar){
Outer2 ot = new Outer2();
//Outer2.Inner2 oi = ot.new Inner2();
ot.disp();
}
}
4. 익명 중첩 클래스(anonymous Inner class)
•
익명 중첩 클래스(Anonymous Inner Class)
–
기존 클래스의 특정 메서드를 오버라이딩 하여 원하는 형태로 재정의 하여
사용하는 방식
–
•
외부 멤버 중 final 만 포함할 수 있다.
익명 중첩 클래스의 형식 및 생성파일
–
형식) class Inner { … }
class Outer { method() { new Inner() {…}}}
–
•
생성파일) Outer.class, Outer$숫자.class
new Inner() 자체가 객체 생성임.
class Inner3{
public void aaa(){
System.out.println("aaa");
}
public void bbb(){
System.out.println("bbb");
}
public void ccc(){
System.out.println("ccc");
}
}
public class Exam_04 {
public static void main(String[]ar){
final int x = 100;
Inner3 in = new Inner3(){
public void bbb(){
System.out.println("ddd");
System.out.println("x = " + x);
ddd();//ddd()는 재정할 클래스에서 사용
//재정
}
public void ddd(){
System.out.println("ddd");
}
};
in.aaa();
in.bbb();
in.ccc();
//in.ddd(); 안됨
}
}
18. 상속과 다양성 <처음으로>
1.
Object와 super
모든 자바 클래스(단 interface)는 Object에서 상속 받는다.
클래스를 만들어도 Object에서 상속 받는다.
★최상의 클래스 : java.lang.Object
참고
getClass() 해당 객체의 클래스이름를 돌려줍니다.
toString() 문자열로 바꾸어줍니다.(생략과 같음)
class A extends Object 이 자동으로 된다.
•
포함 Object의 단점 : 객체명의 접근
상속의 예
Class A extends b
•
자바에서 생략된 형태들
–
import, = import java.lang.*;
–
default생성자,= class aaa{ aaa(){} }
–
this, = this.x
–
0번째매개변수, = 이로인데 this사용 가능함 public void disp(/*aaa this */)
–
toString(), = 클래스 이름
–
Object, = 상속
–
super() 상속 받은 상위클래스를 호출하함 this() 마찬가지로 {} 사이 처음에 들어
와야한다. 매개변스로도 접근가능 매개변스가 없으면 생략가능
private 접극자를 사용하면 상속을 받아도 사용을 못한다.
•
필드의 상속과 접근자 : protected 습관적으로 사용한다.
•
super와 this 예약어를 통한 접근
( 생략 시 자동 this 인식 하위에 동일한 변수가 없을
때는 두개의 예약어를 다 사용가능한다.)
메서드의 상속과 메서드 재정의
–
메서드 오버라이딩 : 접근자와 예외전가
메서드 오버로딩 : 매개변수 개수와 자료형
class FF {
private int x;
private int y;
public void setXY(int x){
this.x = x;
this.y =100;
}
public void setXY(int x, int y){
//오버로딩
같은 메소드를 사용한때 매개변수의 개수가 다르면 사용 가능가다
this.x = x;
this.y = y;
}
}
class HH extends FF {
public void setXY(int x){
//상속관계에서 상위클래스의 또같은 메소드를 사용한다. 오버라이딩
}
}
public class Exam_09 {
public static void main (String [] ar){
FF fp = new FF();
fp.setXY(100, 200);//오버로딩
}
}
class GG{
public void aaa(){
System.out.println("GG");
}
}
class JJ extends GG{
public void aaa(){
System.out.println("JJ");
}
}
public class Exam_10 {
public static void main(String[]ar){
JJ jp = new JJ();
jp.aaa();
}
}
final 메서드의 제약
final class GG{//상속을 못하게
public final void aaa(){//상속이 가능하면 오버라이딩을 못하게
System.out.println("GG");
}
}
class JJ extends GG{
public void aaa(){
System.out.println("JJ");
}
}
public class Exam_11 {
public static void main(String[]ar){
JJ jp = new JJ();
jp.aaa();
}
}
접근제약의 규칙
1.오버라이딩 할 때 상위클래스보다 접근자가 같거나 높아야한다.
private < package < protected < public
2. 오버라이딩 할 때 상위클래스에서 예의전가가 안되어 있는데 하위클래스에서 하지 못한다.
다양성?
- 부모 객체를 통해 자식 객체를 표현하는 방법
class TT{
protected int x =100;
}
class RR extends TT{
int y = 300;
}
class WW extends TT{
int z= 400;
}
public class Exam_12 {
public static void main(String[]ar){
TT rp = new RR();
System.out.println("rp.x=" + rp.x);
TT wp = new WW();
System.out.println("wp.x=" + wp.x);
}
}
예)
class AAAA{
public String toString(){
return "AAAA";
}
}
class BBBB{
public String toString(){
return "BBBB";
}
}
public class Exam_13 {
public static void main(String[]ar){
Object[] obj = new Object[2]; //부모이름으로 관리
obj[0] = new AAAA();
obj[1] = new BBBB();
for(int i = 0; i < obj.length; ++i){
System.out.println("obj["+i+"]="+obj[i]);
}
}
•
멤버 필드의 다형성 표현
– 부모 객체의 필드만 사용 가능 하이클래스의 변수를 사용 못함
– 하이 클래스 이름 출력 등에서 사용 한다.
•
멤버 메서드의 다형성 표현
– 자식 객체의 메서드를 먼저 수행
– 자식 객체에 해당 메서드가 없다면 부모 객체의 메서드 실행
class FFFF{
int x = 100;
int y = 200;
public void aaa(){
System.out.println("aaa");
}
}
class HHHH extends FFFF{
int x = 300;
int z = 400;
public void aaa(){
System.out.println("aaaaaa");
}
public void xxx(){
System.out.println("xxx");
}
}
public class Exam_14 {
public static void main(String[]ar){
FFFF ff = new HHHH();
System.out.println(ff.x); //ffff.x 출력 HHHH.z 는 사용 못함 필드는 상위클래스
ff.aaa(); ///HHHH.aaa(); 를 실행한다. 메서도는 자식클래스
ff.xxx(); ////사용 못함
}
}
19. abstract(추상적) 와 interface<처음으로>
= 디자인 개념
•
abstract 메서드
–
메서드의 내용부가 정의 되지 않은 형태로 모델 개념의 메서드
public abstract void aaa();
{}내용정의부를 사용하지 못한다. 단지 디자인 하는것과 같다.
–
반드시 오버라이딩 되어야 사용 가능
abstract class AA{
public abstract void aaa(); //추상클래스
protected int x=100;
}
class BB extends AA{
public void aaa(){
}
}
public class Exam_01 {
public static void main(String[]ar){
//AA ap = new AA(); abstract 됨
BB bp = new BB();
System.out.println(bp.x);
}
}
•
abstract 클래스
–
abstract 메서드를 포함하고 있는 클래스로 다형성 표현으로 사용
–
객체를 발생시킬 수 없는 것을 제외하면 일반 클래스와 동일
abstract class AA{
public abstract void aaa();
protected int x=100;
}
class BB extends AA{
public void aaa(){
System.out.println("aaa");
}
}
public class Exam_01 {
public static void main(String[]ar){
//AA ap = new AA(); abstract 됨
BB bp = new BB();
AA Ap = new BB();
Ap.aaa();
System.out.println(bp.x);
}
}
•
interface : (최상위에만 사용)
–
abstract 클래스의 한 종류로 포함 멤버의 제약을 가짐(순수 디자인 목적)
–
다중 상속이 가능한 유일한 클래스 abstract 다른점
Inner 클래스만 {} 사용 가능하다
-
다른 종족 상속 받을려면
class BBBB implements aaa {}
예)
interface E {}
interface F extends E{}
interface G{}
interface H extends E,G{}
class J {}
class I implements E,G{}
class K extends I implements E, G{}
•
interface의 포함 멤버(자동 지정)
–
public static final 멤버 필드
–
public abstract 멤버 메서드 (다양성)
–
public static inner 클래스
20. 스래드Multi-Thread<처음으로>
Multi-Thread와 API
Thread의 정의
•
시작점과 진행 그리고 종료점을 가지는 일련된 하나의 작업 흐름
–
Thread 생성 클래스 : Thread, Runnable
•
class A extends Thread{//단일상속
public void run(){//main Method 이다
System.out.println("A");
}
}
class B extends Object implements Runnable{//다중상속
public void run(){//main Method 이다
System.out.println("B");
}
}
public class Exam_01 {
public static void main(String[]ar){
System.out.println("main start!");
A ap = new A();
//ap.run();//Method 호출이지 스래드가 아님
ap.start();//Thread{
B bp = new B();
Thread th = new Thread(bp);
//bp.run();//Method 호출
th.start();
for(int i = 1; i<100;i++){
System.out.print(i);
if(i% 10 ==0) System.out.println();
else System.out.print("\t");
}
}
}
주요 메소드
activeCount
() 몇 개의 Thread가 시행 되는지 알려준다.
int x = Thread.activeCount();
System.out.println("Thread는 "+ x + "가 실행되고 있습니다..");
currentThread
() 현재 실행되는 thread 객체의 값으로 넘겨온다
System.out.println("cur Thread = "+Thread.currentThread());
//결과 Thread[Thread-0,5,main] 0번째 스래드이름, 우선순위 5(기본),어떤스래드로 했는가)
getName
() 이 thread의 이름을 돌려줍니다.. Thread-0
() 이 thread의 우선 순위를 돌려줍니다. 기본 5
getPriority
enumerate (Thread
[] tarray) 현재 동작하는 Thread 객체의 값을 배열로 가지고 온다
Thread[] th = new Thread[Thread.activeCount()];
Thread.enumerate(th);
for(int i = 0; i < th.length; ++i){
System.out.println("i"+th[i]);
}
setPriority
(int newPriority) 이 thread의 우선 순위를 변경합니다.
A ap = new A()
ap.setPriority(10); or ap.setPriority(Thread.MIN_PRIORITY);
interrupt
()
이 thread에 끼어듭니다. (중지)
Thread.currentThread().interrupt();
객체.interrupt();
interrupted
isAlive
()
currentThread
() 가 끼어들어지고 있는지 어떤지를 조사합니다.
() 이 thread가 생존하고 있을지 어떨지를 판정합니다.
isDaemon
() 이 thread가 demon thread일지 어떨지를 판정합니다.
ap.setDaemon(true);
isInterrupted
join
() 이 thread가 종료하는 것을 대기합니다.
sleep
yield
()interrupt가 종료되었는지 검사
(long millis) 전체 스래드를 대기(지연) 시킴
() (양보)
현재 실행중의 thread 오브젝트를 일시적으로 휴지시켜, 다른 thread를 실행할 수 있도록 합
니다.
시간프로그램
import java.util.*;
import java.text.*;
class AAA extends Thread {
public void run(){
while(true){
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd
HH:mm:ss");
Date d = new Date();
String str = format.format(d);
System.out.println("현재 시간 : "+ str);
try{
Thread.sleep(1000);
}catch(InterruptedException e){}
}
}
}
public class Exam_03 {
public static void main(String[] ar){
System.out.println("Main Start!");
AAA ap = new AAA();
ap.setDaemon(false);
ap.start();
try{
ap.join(5000);//이 객체만 사용해라
Thread.sleep(5000); //현제 스래드 시간 지연
}catch(InterruptedException e){}
System.out.println("Main End!");
}
}
동기화(지역으로 사용가능) 중요함
class K extends Thread{
private int x = 100;
public void setX(int x){
this.x +=x;
}
public
synchronized int getX(){
return x;
}
public void run(){
setX(200);
System.out.println("x= "+getX());
}
}
지역
synchronized (this){
setX(200);
System.out.println("x= "+getX());
}
21. 예외와 예외처리 <처음으로>
Throw 예외를 강제로 발생 시킴
public static void main(String[] ar) throws Exception {
:
:
if(su1 > 100){
System.out.println("예외 발생 : ");
Exception ex = new Exception(" >100");
throw ex;
}
:
:
결과>
예외 발생 :
Exception in thread "main" java.lang.Exception:
>100
at Exam_05.main(Exam_05.java:10)
throws 예외전가
class O {
public void aaa() throws Exception{
throw new Exception("aaa()");
}
public void bbb()throws Exception {
aaa();
}
}
public class Exam_06 {
public static void main(String[]ar)throws Exception{
O op = new O();
op.bbb();
}
}
결과
Exception in thread "main" java.lang.Exception: aaa()
at O.aaa(Exam_06.java:3)
at O.bbb(Exam_06.java:6)
at Exam_06.main(Exam_06.java:14)
try~catch~finally 예외처리
정상종료, 예외보고, 계속 실행, 대안적 결과
try{
System.out.print("su1 =");
su1 = Integer.parseInt(in.readLine());
System.out.print("su2 =");
su2 = Integer.parseInt(in.readLine());
}catch(NumberFormatException e){///암기 NumberFormatException
System.out.println("숫자 포맷이 잘못되었네요");
System.exit(0);
} finally{ //반드시 실행할 것
System.out.println("aaa처리 완료!");
}
사용자 정의 예외
-
Exception 클래스 상속
22. package <처음으로>
•
package 란?
–
•
package 선언
–
•
주석을 제외한 상태에서 파일의 최고 상위에 위치 (package 경로.경로.경로….)
package 컴파일(도스)
–
•
유사 클래스를 묶어서 관리하는 폴더의 개념
javac –d//디렉토리옵션// 저장경로 파일명.java
사용법 : import 및 절대경로명
package ksh.util;
public class Exam_10 {
public void aaa(){
System.out.println("Exam_10");
}
}
import ksh.util.*;
public class Exam_11 {
public static void main(String[] ar){
Exam_10 ex = new Exam_10();
// ksh.util.Exam_10 ex = new ksh.util.Exam_10(); import를 사용 현재폴더에서 사용하지만
절대경로를 사용하면 바로 찾아들어간다.
ex.aaa();
}
}
23. assertion <처음으로>
•
assertion 이란? 개발시 사용 예외처리랑 다르다
–
특정 구문 실행 시 결과를 단정지어 표현하는 방법(원하는 결과와 다를 경우 에러
발생) trace와같은거
•
형식 : assert [boolean검증] : 에러구문;
•
실행 옵션 : java –ea|-da|-esa 클래스명
•
지정 옵션 :
-ea:클래스, -ea:…, -ea:<package명>…
import java.io.*;
public class Exam_10 {
public static void main(String[]ar)throws IOException{
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
System.out.print("x = ");
int x = Integer.parseInt(in.readLine());
assert x>5 :"if문 테스트위한 거니깐 5보다 크게 넣어!";
if(x > 5){
System.out.println("5보다 큰 영역입니다.");
}else{
System.out.println("5보다 작다.");
}
}
}
24. Collection과 APIs<처음으로>
•
Collection 관련 APIs : Set, Map, List 무한배열
Set:정렬이 안된다. 중첩객체를 허용안됨 (복주머니)
import java.util.*;
abstract class ABCD {//추상클래스
public abstract void disp();
}
class AB extends ABCD { //추상클래스 상속
public void disp(){
System.out.println("AB");
}
}
class CD extends ABCD {
public void disp(){
System.out.println("CD");
}
}
public class Exam_12 {
public static void main(String[] ar){
AB a = new AB();
CD b = new CD();
//String c = new String("C");//String 객체
HashSet hs = new HashSet();//해시셋에 등록
hs.add(a); //a객체 등록
hs.add(b); //b객체 등록
//hs.add(c);
Iterator it = hs.iterator();
while(it.hasNext()){ //Returns true if the iteration has more elements
=(ABCD)it.next(); (ABCD)객체로 변경해서 다음 요소로 넘어간다.
obj.disp();
//System.out.println("obj = "+obj);
}
}
}
ABCD obj
remove()
Removes from the underlying collection the last element returned by the iterator
Map : 정렬이 안된다. 중첩객체는 된다. (객체에 번호를 메기는것과같다)
import java.util.*;
class EF{}
class GH{}
public class Exam_13 {
public static void main(String[] ar){
EF a = new EF();
GH b = new GH();
String c= new String("c");
Hashtable
ht = new Hashtable(); //Hashtable 객체를 만든다.
ht.put("EF", a); //객체요소를 넣는다. 이름값과 자료를 넣는다.
ht.put("GH", b);
ht.put("ST", c);
Enumeration enu = ht.elements();
//elements()으로 요소의값을 불러올때 사용
while(enu.hasMoreElements()){ //다음 요소가 있으면 참
Object obj = enu.nextElement(); //다음 요소의값을 저장
System.out.println("obj =" + obj);
}
Object obj = ht.get("EF");
System.out.println("obj =" + obj);
Enumeration enu1 = ht.keys(); //키(이름)을 불러온다.
while(enu1.hasMoreElements()){ //다음 요소가 있으면 참
String name = (String)enu1.nextElement(); //다음 요소의키값을 저장
Object obj1 = ht.get(name); //키값에 해당하는 자료를 저장
System.out.println(name +"=" + obj1);
}
}
}
List : 정렬, 중첩객체다 된다. (기차처럼)
import java.util.*;
class IJ{}
class KL{}
public class Exam_14 {
public static void main(String[] ar){
IJ a = new IJ();
KL b = new KL();
String c= new String("c");
Vector vc = new Vector();
ArrayList al = new ArrayList();
vc.add(a); vc.add(b); vc.add(c);
al.add(a); al.add(b); al.add(c);
for(int i = 0; i < vc.size(); ++i){
Object obj = vc.elementAt(i);//키값을 불러온다.
System.out.println(i+ "=" + obj);
}
System.out.println();
for(int i = 0; i < al.size(); ++i){
Object obj = al.get(i);//키값을 불러온다
System.out.println(i+ "=" + obj);
}
}
}
•
Wrapper 클래스들
•
Class라는 클래스
클래스가 있는 확인할 때 사용
forName() 클래스이름을 구한다.
try{
Class cl = Class.forName("Exam_12");
System.out.println(cl.getMethods());
}catch(ClassNotFoundException e){
System.out.println("찾을수 없습니다.");
}
Runtime 클래스
프로세스를 실행할 때 사용
public class Exam_16 {
public static void main(String[] ar) throws Exception{
Runtime rt = Runtime.getRuntime();
Process pro = rt.exec("explorer.exe http://www.naver.com");
pro.destroy();
}
}
•
String 클래스
public class Exam_17 {
public static void main(String[] ar)throws Exception{
String str = new String("Hello java!");
char a = str.charAt(6); //int 자리의 문자를 가지고 온다.
System.out.println(a);
boolean b= str.endsWith("!");// 해당 글자로 끝나는지 알아본다.
System.out.println(b);
boolean e= str.startsWith("e");// 해당 글자로 끝나는지 알아본다.
System.out.println(e);
boolean c= str.equalsIgnoreCase("hello java!");
//대소문자 구문하지않고 같은지 알아본다.
System.out.println(c);
byte[] d = str.getBytes("ISO8859_1");
//문자열을 배열로 문자로 저장한다
for(int i = 0; i<d.length; i++){
System.out.print((char)d[i]+"\t");
}
System.out.println();
System.out.println(str.indexOf("o"));
//해당 글자가 문자열에 몇 번째 위치하는가
System.out.println();
System.out.println(str.lastIndexOf("a"));
//해당 글자가 뒤있는것을 검사 문자열에 몇 번째 위치하는가
System.out.println();
System.out.println(str.length());
//글자의 개수를 반환한다.
System.out.println();
System.out.println(str.substring(6,10));
//6에서부터 10까지 문자열 자라서 반환한다.
System.out.println();
System.out.println(str.toUpperCase());
//모두를 대문자로 toLowerCase() 는 소문자로
System.out.println(str.trim());
//앞뒤의 공백을 없엔다.
String str2 = "ABCD";
str2.substring(2,3);
System.out.println(str2);
///substring 을 사용해도 str2는 변하지 않는다.
StringBuffer str3 = new StringBuffer("ABCD");
str3.append("E");
System.out.println(str3);
//StringBuffer 사용하면 자기 자신이 변한다.
}
}
•
Date와 Calendar 클래스
Date클래스
2000년 들어오면서 2000년 까지 포현하지 못하여 사용을 권장하지 않습니다.
import java.util.*;
public class Exam_18 {
public static void main(String [] ar){
Date d = new Date();
System.out.println("d = "+d);
System.out.println("year = "+d.getYear());
System.out.println("month = "+d.getMonth());
System.out.println("date = " + d.getDate());
System.out.println("hour = " + d.getHours());
System.out.println("minute = "+d.getMinutes());
System.out.println("second = " + d.getSeconds());
}
}
Calendar클래스
Calendar ca = Calendar.getInstance();
System.out.println("ca = " + ca);
System.out.println("year = " + ca.get(Calendar.YEAR) );
System.out.println("Month = " + (ca.get(Calendar.MONTH)+1));
System.out.println("date = " + ca.get(Calendar.DAY_OF_MONTH) );
System.out.println("hour = " + ca.get(Calendar.HOUR_OF_DAY) );
System.out.println("minute = " + ca.get(Calendar.MINUTE) );
System.out.println("second = " + ca.get(Calendar.SECOND) );
추상클래스이기 때문에 GregorianCalendar 을 사용한다. API 참고
•
SimpleDateFormat 클래스
Date dd = new Date();
impleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String str = format.format(dd);
System.out.println("현제시간은 " + str);
기타유틸 : Scanner//인트로 입력할 때 사용, Locale, Properties, Random//특정범위내의
수를 랜덤으로 반환한다.
Timer, TimeZone
•
StringTokenizer 클래스
import java.util.*;
public class Exam_19 {
public static void main(String [] ar){
String str = "aaa,bbb,ccc,ddd,eee,fff:ggg:hhh:iii";
StringTokenizer stk = new StringTokenizer(str, ",:", false);
//해당 문자열이 어떤 문자에 대해 나눈다.
while(stk.hasMoreTokens()){
System.out.println(stk.nextToken());
}
}
}
•
For문의 확대, Generic & Auto-boxing
import java.util.*;
public class Exam_21 {
public static void main(String[]ar){
ArrayList<Integer> al = new ArrayList();
al.add(1);
al.add(2);
al.add(3);
int sum = 0;
for (Integer i : al){
sum +=i;
}
System.out.println(sum);
}
}
25. Frame 클래스와 Label<처음으로>
•
Frame 클래스 : GUI의 Base Form
Frame 객체 생성
import java.awt.*;
public class Exam_01 {
public static void main(String[] ar){
Frame f = new Frame();
Frame f1 = new Frame("제목");
f.setVisible(true);
f1.setVisible(true);
//디폴트가 false이고 true어야 화면에 보인다.
f.setSize(300, 200);
f1.setSize(400,300);
Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
//화면(해상동) 크기를 저장하는 방법
Dimension f_size = f.getSize();
Dimension f1_size = f1.getSize();
//프레임 크기를 저장하는 방법
int xpos1 = (int)(screen.getWidth() /2 -f_size.getWidth() /2);
int ypos1 = (int)(screen.getHeight() /2 -f_size.getHeight() /2);
f.setLocation(xpos1, ypos1);
//프래임을 중앙에 나오게 한다.
int xpos2 = (int)(screen.getWidth() /2 -f1_size.getWidth() /2);
int ypos2 = (int)(screen.getHeight() /2 -f1_size.getHeight() /2);
f1.setLocation(xpos2, ypos2);
//프래임을 중앙에 나오게 한다.
f.setResizable(false);
f1.setResizable(false);
//크기 설정이 안됨
//f.setLocation(, 200);
//f1.setLocation(300,300);
}
}
Frame 클래스 상속
import java.awt.*;
class Exam__sub extends Frame {
private Label lb = new Label("레이어");
public Exam__sub(String title){
super(title);
super.setSize(300,200);
Dimension screen =
Toolkit.getDefaultToolkit().getScreenSize();
Dimension frm = super.getSize();
int xpos = (int)(screen.getWidth() /2 -frm.getWidth() /2);
int ypos = (int)(screen.getHeight() /2 -frm.getHeight() /2);
super.setLocation(xpos, ypos);
super.setResizable(false);
super.setVisible(true);
}
public void init(){//화면 초기화 작업
this.add(lb);
}
}
public class Exam_ {
public static void main(String[] ar){
Exam__sub ex = new Exam__sub("제목");
}
}
2. Frame 상속계열 클래스들(API참고)
Component 클래스의 메서드
Container 클래스의 메서드(Componentf를 상속)
Window 클래스의 메서드 (Container를 상속)
26. Layout Manager <처음으로>
FlowLayout Manager
import java.awt.*;
class Exam_04_sub extends Frame {
private Button bt1 = new Button("1");
private Button bt2 = new Button("2");
private Button bt3 = new Button("3");
private Button bt4 = new Button("4");
private Button bt5 = new Button("5");
private Button bt6 = new Button("6");
private FlowLayout f1 = new FlowLayout(FlowLayout.LEFT); //기본이 center이다
public Exam_04_sub(String title){
super(title);
this.init();
super.setSize(300,200);
Dimension screen =
Toolkit.getDefaultToolkit().getScreenSize();
Dimension frm = super.getSize();
int xpos = (int)(screen.getWidth() /2 -frm.getWidth() /2);
int ypos = (int)(screen.getHeight() /2 -frm.getHeight() /2);
super.setLocation(xpos, ypos);
super.setResizable(true);
super.setVisible(true);
}
public void init(){
this.setLayout(f1);
this.add(bt1);
this.add(bt2);
this.add(bt3);
this.add(bt4);
this.add(bt5);
this.add(bt6);
}
}
public class Exam_04 {
public static void main(String[] ar){
Exam_04_sub ex = new Exam_04_sub("제목");
}
}
GridLayout Manager
import java.awt.*;
class Exam_05_sub extends Frame{
private Button bt1 = new Button("1");
private Button bt2 = new Button("2");
private Button bt3 = new Button("3");
private Button bt4 = new Button("4");
private Button bt5 = new Button("5");
private Button bt6 = new Button("6");
private GridLayout g1 = new GridLayout(3, 2, 10, 10);
//몇행 몇열 x여백, y여백
public Exam_05_sub(String title){
super(title);
this.init();
super.setSize(300,200);
Dimension scrren = Toolkit.getDefaultToolkit().getScreenSize();
Dimension frm = super.getSize();
int xpos = (int)(scrren.getWidth()/2-frm.getWidth()/2);
int ypos = (int)(scrren.getHeight()/2-frm.getHeight()/2);
super.setLocation(xpos,ypos);
super.setResizable(false);
super.setVisible(true);
}
public void init(){
this.setLayout(g1);
this.add(bt1);
this.add(bt2);
this.add(bt3);
this.add(bt4);
this.add(bt5);
this.add(bt6);
}
}
public class Exam_05 {
public static void main(String[]ar){
Exam_05_sub ex = new Exam_05_sub("제목");
}
}
BorderLayout Manager
import java.awt.*;
class Exam_06_sub extends Frame{
private Button bt1 = new Button("1");
private Button bt2 = new Button("2");
private Button bt3 = new Button("3");
private Button bt4 = new Button("4");
private Button bt5 = new Button("5");
private BorderLayout bl = new BorderLayout(10,10);
//여백이 가능하다
public Exam_06_sub(String title){
super(title);
this.init();
super.setSize(300,200);
Dimension scrren =
Toolkit.getDefaultToolkit().getScreenSize();
Dimension frm = super.getSize();
int xpos = (int)(scrren.getWidth()/2-frm.getWidth()/2);
int ypos = (int)(scrren.getHeight()/2-frm.getHeight()/2);
super.setLocation(xpos,ypos);
super.setResizable(false);
super.setVisible(true);
}
public void init(){
this.setLayout(bl);
this.add("North", bt1); //위치값을 반드시 기록
this.add("South", bt2);
this.add("West", bt3);
this.add("East", bt4);
this.add("Center", bt5);
}
}
public class Exam_06 {
public static void main(String[]ar){
Exam_06_sub ex = new Exam_06_sub("제목");
}
}
CardLayout Manager
import java.awt.*;
class Exam_07_sub extends Frame{
private Button bt1 = new Button("1");
private Button bt2 = new Button("2");
private Button bt3 = new Button("3");
private CardLayout cl = new CardLayout();
public Exam_07_sub(String title){
super(title);
this.init();
super.setSize(300,200);
Dimension scrren =
Toolkit.getDefaultToolkit().getScreenSize();
Dimension frm = super.getSize();
int xpos = (int)(scrren.getWidth()/2-frm.getWidth()/2);
int ypos = (int)(scrren.getHeight()/2-frm.getHeight()/2);
super.setLocation(xpos,ypos);
super.setResizable(false);
super.setVisible(true);
try{
Thread.sleep(2000);
}catch(InterruptedException e){}
cl.show(this,"bb");
try{
Thread.sleep(2000);
}catch(InterruptedException e){}
cl.show(this,"cc");
try{
Thread.sleep(2000);
}catch(InterruptedException e){}
cl.show(this,"aa");
}
public void init(){
this.setLayout(cl);
this.add("aa",bt1);
this.add("bb",bt2);
this.add("cc",bt3);//겹쳐서 나오기때문 부르기 위한 이름을 지정해야한다.
}
}
public class Exam_07 {
public static void main(String[]ar){
Exam_07_sub ex = new Exam_07_sub("제목");
}
}
GridBagLayout Manager
import java.awt.*;
class Exam_08_sub extends Frame{
private Button bt1 = new Button("AAA");
private Button bt2 = new Button("BBB");
private Button bt3 = new Button("CCC");
private Button bt4 = new Button("EEE");
private Button bt5 = new Button("DDD");
private Button bt6 = new Button("FFF");
private Button bt7 = new Button("GGG");
private GridBagLayout gb = new GridBagLayout();
private GridBagConstraints gc = new GridBagConstraints();
public Exam_08_sub(String title){
super(title);
this.init();
super.setSize(300,200);
Dimension scrren =
Toolkit.getDefaultToolkit().getScreenSize();
Dimension frm = super.getSize();
int xpos = (int)(scrren.getWidth()/2-frm.getWidth()/2);
int ypos = (int)(scrren.getHeight()/2-frm.getHeight()/2);
super.setLocation(xpos,ypos);
super.setResizable(false);
super.setVisible(true);
}
public void init(){
this.setLayout(gb);
gc.gridx = 0;
gc.gridy = 0;
gb.setConstraints(bt1,gc);
this.add(bt1);
gc.gridx = 1;
gc.gridy = 1;
gb.setConstraints(bt2,gc);
this.add(bt2);
gc.gridx = 2;
gc.gridy = 2;
gb.setConstraints(bt3,gc);
this.add(bt3);
gc.gridx = 3;
gc.gridy = 2;
gb.setConstraints(bt5,gc);
this.add(bt5);
gc.gridx = 2;
gc.gridy = 1;
gc.gridwidth =2;
gb.setConstraints(bt4,gc);
this.add(bt4);
}
}
public class Exam_08 {
public static void main(String[]ar){
Exam_08_sub ex = new Exam_08_sub("제목");
}
}
27. Panel 클래스 <처음으로>
java.awt.Panel 클래스
import java.awt.*;
class Exam_03_sub extends Frame{
private Button yes_bt = new Button("확인");
private Button no1_bt = new Button("취소1");
private Button no2_bt = new Button("취소2");
private Panel p = new Panel();//패널에 패널을 넣을 수 있다.
private Panel p1 = new Panel();
private BorderLayout bl= new BorderLayout();
private GridLayout gl = new GridLayout(1,2);
private GridLayout gl2 = new GridLayout(2,1);
public Exam_03_sub(String title){
super(title);
this.init();
super.setSize(300,200);
Dimension screen =
Toolkit.getDefaultToolkit().getScreenSize();
Dimension frm = super.getSize();
int xpos = (int)(screen.getWidth()/2-frm.getWidth()/2);
int ypos = (int)(screen.getHeight()/2-frm.getHeight()/2);
super.setLocation(xpos, ypos);
super.setResizable(false);
super.setVisible(true);
}
public void init(){
this.setLayout(bl);
p.setLayout(gl);
p.add(yes_bt);
p1.setLayout(gl2);
p1.add(no1_bt);
p1.add(no2_bt);
p.add(p1);
this.add("South", p);//패널을 넣는다.
}
}
public class Exam_03 {
public static void main(String [] ar){
Exam_03_sub ex = new Exam_03_sub("제목");
}
}
28.주변 클래스들<처음으로>
import java.awt.*;
class Exam_04_sub extends Frame {
private Color cc= new Color(125, 78,234); //색상 설정하기
private Button bt = new Button("학인");
private GridBagLayout gb1 = new GridBagLayout();
private Cursor cur = new Cursor(Cursor.HAND_CURSOR);//커서설정하기
private Cursor cur2 = new Cursor(Cursor.TEXT_CURSOR);
private Font fn = new Font("휴먼옛체",Font.BOLD, 20); //폰트를 설정한다.
public Exam_04_sub(String title){
super(title);
Toolkit tk = Toolkit.getDefaultToolkit();
Image img = tk.getImage("aaa.gif"); //다이틀 아이콘 변경하기
this.setIconImage(img);
this.init();
super.setSize(300,200);
Dimension screen =
Toolkit.getDefaultToolkit().getScreenSize();
Dimension frm = super.getSize();
Dimension a = new Dimension(100,200); //폭과 넓이를 관리한다.
int xpos = (int)(screen.getWidth()/2 - frm.getWidth()/2);
int ypos = (int)(screen.getHeight()/2 - frm.getHeight()/2);
super.setLocation(xpos, ypos);
super.setResizable(false);
super.setVisible(true);
}
public void init(){
this.setBackground(cc); //배경색지정하기
this.setLayout(gb1);
bt.setCursor(cur);//버튼위에 올라가면 커서 모양 바꾸기
this.add(bt);
bt.setFont(fn); //버튼에 폰트 지정하기
bt.setBackground(Color.BLACK);//버튼색상지정하기
bt.setForeground(Color.white);
this.setCursor(cur2);//커서 지저하기
}
}
public class Exam_04 {
public static void main(String [] ar){
Exam_04_sub ex = new Exam_04_sub("제목");
}
}
29.AWT 관련 컴포넌트<처음으로>
p.setPreferredSize(new Dimension(80,10));
//크기 수정하기
Java.awt.Label 클래스
private Label lb = new Label("전하기", Label.CENTER)
//레이어글자의 정렬할수있다.;
Java.awt.Button 클래스
private Button bt = new Button("학인");
private Button [] bt = new Button[12];
Java.awt.Checkbox 클래스
private Label fri_lb = new Label("좋아하는 과일은?");
private Checkbox a_cb = new Checkbox("바나나"); //체크박스 생성
private Checkbox b_cb = new Checkbox("딸기");
private Checkbox c_cb = new Checkbox("파인애플");
Java.awt.CheckboxGroup 클래스
private Label sex_lb = new Label("당신의 성별은 ?");
private CheckboxGroup cg = new CheckboxGroup();
//라디오 버튼으로 하기위한 그룹으로
private Checkbox man_cb = new Checkbox("남성", cg, true);
//라디오 버튼 true 선택된상태
private Checkbox woman_cb = new Checkbox("여성", cg, false);
Java.awt Choice 클래스
private Label blood_lb = new Label("혈액형은 ?");
private Choice blood_ch = new Choice();
//리스트 추가는 add를 사용 하면된다.
blood_ch.add("A형");
Java.awt.List 클래스
private Label alpha_lb = new Label("앞파벳몰록", Label.CENTER);
private List
alpha_li = new List(5, true);//true 여러개 선택할수 있다
Java.awt.TextField & TextArea 클래스
private TextField title_tf = new TextField();
private TextArea contents_ta = new TextArea();
Java.awt.Dialog & FileDialog 클래스
private Dialog dlg = new Dialog(this, "경고", false);
//(누구에게(소속), 제목,
모델속성(프레임으로 이동이 가능한가 프레임이 닫혀야 가능한가)
//메세지를 뛰울때 사용하며 팝업 같은것을 말한다.
//프래임처럼 속성을 사용한다. dlg.setVisible(true);
private FileDialog fdlg =
new FileDialog(this, "저장", FileDialog.SAVE);
//(누구에게(소속), 제목, 모델속성(저장할것인지, 열기를 할것인지)
//내용부와 크기를 지정할 필요가없다. 기본으로 지정된다.
Java.awt.Menu, MenuItem 클래스
import java.awt.*;
class Exam_15_sub extends Frame {
private
private
private
private
private
private
MenuBar mb = new MenuBar();
Menu file = new Menu("FILE");
MenuItem fnew = new MenuItem("NEW");
MenuItem fopen = new MenuItem("OPEN");
MenuItem fsave = new MenuItem("SAVE");
MenuItem fexit = new MenuItem("EXIT");
private
private
private
private
private
private
Menu edit = new Menu("EDIT");
Menu ecolor = new Menu("COLOR");
CheckboxMenuItem red_cb = new CheckboxMenuItem("RED");
CheckboxMenuItem green_cb = new CheckboxMenuItem("GREEN");
CheckboxMenuItem blue_cb = new CheckboxMenuItem("BLUE");
Menu esize = new Menu("SIZE");
private Menu help = new Menu("HELP");
private MenuItem hver = new MenuItem("VERSION");
public Exam_15_sub(String title){
//기본 폼~생략
}
public void init(){
file.add(fnew);
file.addSeparator(); //분할선
file.add(fopen);
file.add(fsave);
file.addSeparator(); //분할선
file.add(fexit);
mb.add(file);
ecolor.add(red_cb);
ecolor.add(green_cb);
ecolor.add(blue_cb);
edit.add(ecolor);
edit.addSeparator(); //분할선
edit.add(esize);
mb.add(edit);
help.add(hver);
mb.add(help);
this.setMenuBar(mb);
}
}
public class Exam_15 {
public static void main(String[] ar){
Exam_15_sub ex = new Exam_15_sub("제목");
}
}
30. Event 구현방법<처음으로>
import java.awt.*;
import java.awt.event.*;
class Exam_01_sub extends Frame implements ActionListener{
//폼클래스와 Listener과 함께 사용 가능하다.
public void actionPerformed(ActionEvent e){}
private Button bt = new Button("확인");
private GridBagLayout gbl = new GridBagLayout();
public Exam_01_sub(String title){
super(title);
super.setSize(300,200);
this. init();
this.start();
Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
Dimension frm = super.getSize();
int xpos = (int)(screen.getWidth()/2-frm.getWidth()/2);
int ypos = (int)(screen.getHeight()/2-frm.getHeight()/2);
super.setLocation(xpos, ypos);
super.setResizable(false);
super.setVisible(true);
}
public void init(){
this.setLayout(gbl);
this.add(bt);
}
public void start(){
A ap = new A();
bt.addActionListener(ap);
B bp = new B();
bt.addMouseListener(bp);
bt.addActionListener(this);
MouseAdapter ma = new MouseAdapter(){
public void mouseClicked(MoueseEvent e){
System.exit(0);
}//익명 중첩 클래스를 사용하여 구현하는 방법
};
}
}
public class Exam_01 {
public static void main(String [] ar){
Exam_01_sub ex = new Exam_01_sub("제목");
}
}
class A implements ActionListener{
public void actionPerformed(ActionEvent e){
//클래스를 호출을 메소드를 불러오기 위하여 호출 인터페이스이다.
//Listener 클래스를 구현하는 방법
//해당 메소드를 모두 재정해야한다.(인터페이스)
System.exit(0);
}
}
class B extends MouseAdapter{
public void mouseClicked(MouseEvent e){
//해당 이벤트의 메소드를 찾아 적는다.
//Adapter 클래스로 구현하는 방법
//해당 메소드를 모두 재정할필요는없다. (필요한 메소드만 사용가능하다)
System.exit(0);
}
}
31. Event 활용 범위<처음으로>
ActionListener : 버튼클릭, 메뉴선택 등
WindowAdapter와 WindowListener : Frame 관련
MouseAdapter와 MouseListener : 마우스 클릭 등 마우스 관련
MouseMotionAdapter와 MouseMotionListener : 마우스 움직임 관련
import java.awt.*;
import java.awt.event.*;
class Exam_02_sub extends Frame implements MouseListener,
MouseMotionListener, ActionListener{
private MenuBar mb = new MenuBar();
private Menu file = new Menu("FILE");
private MenuItem fopen = new MenuItem("OPEN");
private MenuItem fsave = new MenuItem("SAVE");
private FileDialog fdig1 = new FileDialog(this, "내꺼 열기",
FileDialog.LOAD);
private FileDialog fdig2 = new FileDialog(this, "내꺼 저장",
FileDialog.SAVE);
private Label lb = new Label("x = 000, y = 000");
private Button bt = new Button("확인");
private BorderLayout bl = new BorderLayout();
public Exam_02_sub(String title){
super(title);
this.init();
this.start();
super.setSize(300,200);
Dimension screen =
Toolkit.getDefaultToolkit().getScreenSize();
Dimension frm = super.getSize();
int xpos = (int)(screen.getWidth() /2 -frm.getWidth() /2);
int ypos = (int)(screen.getHeight() /2 -frm.getHeight() /2);
super.setLocation(xpos, ypos);
super.setResizable(false);
super.setVisible(true);
}
public void init(){
file.add(fopen);
file.add(fsave);
mb.add(file);
this.setMenuBar(mb);
this.setLayout(bl);
this.add("North", lb);
this.add("South", bt);
}
public void start(){
WindowAdapter wa = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
//Window의 닫기 버튼을 누르면 실행 됨
}
};
/*this.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
//Window의 닫기 버튼을 누르면 실행 됨
}
});*/
fopen.addActionListener(this);//액션 실행
fsave.addActionListener(this);
bt.addMouseListener(this);
this.addMouseMotionListener(this);
}
public void actionPerformed(ActionEvent e){
if (e.getSource()==fopen){
//어떤것이 들어왔는지 확인
fdig1.setVisible(true);
}else if(e.getSource()==fsave){
fdig2.setVisible(true);
}
}
//==================================================
public void mouseClicked(MouseEvent e) {}
public void mouseEntered(MouseEvent e) {
//마우스가 폼객체에 있는가?
if(e.getSource()==bt){
bt.setLabel("버튼위에 마우스가 있네요!");
}
}
public void mouseExited(MouseEvent e) {
//마우스가 폼객체에서 빠저나갔느냐?
if(e.getSource()==bt){
bt.setLabel("확인");
}
}
public void mousePressed(MouseEvent e) {}
public void mouseReleased(MouseEvent e) {}
//마우스 이벤트 메소드===================================
//===================================================
public void mouseDragged(MouseEvent e) {
if(e.getSource()== this){
int x = e.getX();
int y = e.getY();
//마우스 좌표를 저장한다.
lb.setText("x = " + x + ", y =" + y);
}
}
public void mouseMoved(MouseEvent e) {}
//마우스가 움직일때
}
//마우스 모션 이벤트 메소드================================
public class Exam_02 {
public static void main(String[] ar){
Exam_02_sub ex = new Exam_02_sub("제목");
}
}
KeyAdapter와 KeyListener : 키 관련
FocusAdapter와 FocusListener : 포커스 관련
ItemListener : List나 Choice에서의 아이템 관련
import java.awt.*;
import java.awt.event.*;
class Exam_04_sub extends Frame implements FocusListener, KeyListener,
ItemListener {
private TextField tf1 = new TextField();
private TextField tf2 = new TextField();
private Label lb1 = new Label("NONE : ", Label.RIGHT);
private Label lb2 = new Label("NONE");
private Choice ch = new Choice();
private Label lb3 = new Label("NONE");
private
private
private
private
private
GridLayout
Panel p1 =
GridLayout
Panel p2 =
GridLayout
gl = new GridLayout(4, 1);
new Panel();
gl1 = new GridLayout(1,2,5,5);
new Panel();
gl2 = new GridLayout(1,2,5,5);
public Exam_04_sub(String title){
super(title);
this.init();
this.start();
super.setSize(250,120);
Dimension screen =
Toolkit.getDefaultToolkit().getScreenSize();
Dimension frm = super.getSize();
int xpos = (int)(screen.getWidth() /2 -frm.getWidth() /2);
int ypos = (int)(screen.getHeight() /2 -frm.getHeight() /2);
super.setLocation(xpos, ypos);
super.setResizable(false);
super.setVisible(true);
}
public void init(){
this. setLayout(gl);
p1.setLayout(gl1);
p1.add(tf1);
p1.add(tf2);
this.add(p1);
p2.setLayout(gl2);
p2.add(lb1);
p2.add(lb2);
this.add(p2);
for(char c = 'A'; c<='Z'; c++){
String str = "" + c+ c+ c;
ch.add(str);
}
this.add(ch);
this.add(lb3);
}
public void start(){
tf1.addFocusListener(this);
tf2.addFocusListener(this);
tf1.addKeyListener(this);
tf2.addKeyListener(this);
ch.addItemListener(this);
}
public void focusGained(FocusEvent e){
//포커스 활성화
if(e.getSource()== tf1){
lb1.setText("첫번째 TextField위치 : ");
}else if(e.getSource()== tf2){
lb1.setText("두번째 TextField위치 : ");
}
}
public void focusLost(FocusEvent e){
//포커스 비활성화
}
public void keyPressed(KeyEvent e) {
// 키를 누를때 처리
}
public void keyReleased(KeyEvent e) {
// 키를 누르고 때면 처리
if(e.getSource()== tf1){
int cnt = tf1.getText().trim().length();
lb2.setText(cnt + "개");
}else if(e.getSource()== tf2){
lb1.setText("두번째 TextField위치 : ");
int cnt = tf2.getText().trim().length();
lb2.setText(cnt + "개");
}
}
public void keyTyped(KeyEvent e) {
// 키타입을 조사
}
public void itemStateChanged(ItemEvent e) {
//아이템 이벤트
if(e.getSource()==ch){
String str = ch.getSelectedItem();
lb3.setText("선택된 내용 = " + str);
}
}
}
public class Exam_04 {
public static void main(String[] ar){
Exam_04_sub ex = new Exam_04_sub("제목");
}
}
32. Graphics의 paint 메서드 사용 방법<처음으로>
public void update(Graphics g){
g.clearRect(0,0,200,300);
paint(g);
} //화명 실행할 때 초기화 작업
public void paint(Graphics g){
int x = (int)(Math.random()*200);
int y = (int)(Math.random()*300);
g.drawLine(x,x,y,y);
//직선
} //그래픽스 요소를 수정한다.
public void actionPerformed(ActionEvent e) {
if(e.getSource()==bt){
this.repaint();
}
}
//repaint 할때 사용하는 예(버튼) 다시지정할때 예(이미지크기) 재정하여 다시
불러온다.
public void paint(Graphics g){
g.drawLine(50,50,100,100);
g.setColor(Color.RED);
g.drawRect(50, 50, 100, 100);
g.setColor(Color.BLUE);
g.fillRect(160, 50, 100, 100);
//속색상이 채워진 사각형
g.setColor(Color.GREEN);
int[] x= {80, 100, 50};
int[] y= {30,90,85};
g.drawPolygon(x, y, 3);
//다각형 x, y는 배열로 지정해준다.
g.setColor(Color.CYAN);
g.setFont(new Font("굴림체", Font.BOLD, 20));
g.drawString("여기는 그래픽!", 100, 100);
//글자 그래픽
Toolkit tk = Toolkit.getDefaultToolkit();
Image img = tk.getImage("1.jpg");
g.drawImage(img, 50,50, 100,100, this);
//이미지
(이미지, x, y, width, height, this)
}
33. Applet 작성방법<처음으로>
<html> 작성
<html>
<head>
<title>그림판</title>
</head>
<body>
<center>
<h2>아래의 내용은 애플릿</ht><p>
<applet codebase="./bin" code="Exam_02.class"
width="400" height="400">
</applet>
</center>
</body>
</html>
<java> 작성
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class Exam_01 extends Applet {
private static String str = "";
public void init(){
str += "init() --> ";
}
public void start(){
str += "start() --> ";
}
public void paint(Graphics g){
str +="paint() --> ";
g.drawString(str, 0 , 100);
}
public void stop(){
str += "stop() -->";
}
public void destroy(){}
}
//메인을 사용 하지않는다.
// import java.applet.*;
// Applet를 상속받는다.
//class는 public를 사용해야한다.
//주기를 생각하라
//awt 보다는 swing 사용하는것이 좋다.
//위치를 나타내는
//객체.getDocumentBase -> html 위치를 나타내는 것
//객체.getCodeBase ->자바의 위치를 나타내는 것
34. Applet의Image와 Sound<처음으로>
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class Exam_03 extends Applet implements ActionListener{
private Image play_img, stop_img, cur_img;
private AudioClip snd;
private Button play_bt = new Button("PLAY");
private Button stop_bt = new Button("STOP");
private BorderLayout bl = new BorderLayout();
private Panel p = new Panel();
private FlowLayout fl = new FlowLayout();
public void init(){
snd = this.getAudioClip(this.getCodeBase(), "aaa.mid");
play_img = this.getImage(this.getCodeBase(), "play_img.jpg");
stop_img = this.getImage(this.getCodeBase(), "stop_img.jpg");
cur_img = stop_img;
this.setLayout(bl);
p.setLayout(fl);
p.add(play_bt);
p.add(stop_bt);
this.add("South",p);
}
public void start(){
play_bt.addActionListener(this);
stop_bt.addActionListener(this);
}
public void paint(Graphics g){
g.drawImage(cur_img, 50, 50,200,100, this);
}
@Override
public void actionPerformed(ActionEvent e) {
if(e.getSource()==play_bt){
cur_img = play_img;
snd.loop();
this.repaint();
}else if(e.getSource()== stop_bt ){
cur_img = stop_img;
snd.stop();
this.repaint();
}
}
}
35. Swing(JFC) 컴포넌트<처음으로>
기본폼
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
class Exam_01_sub extends JFrame{
public Exam_01_sub(String title){
super(title);
this.init();
this.start();
this.setSize(300,200);
Dimension screen =
Toolkit.getDefaultToolkit().getScreenSize();
Dimension frm = this.getSize();
int xpos = (int)(screen.getWidth()/2 - frm.getWidth()/2);
int ypos = (int)(screen.getHeight()/2 - frm.getHeight()/2);
this.setLocation(xpos, ypos);
this.setVisible(true);
this.setResizable(false);
}
public void init(){
Container con = this.getContentPane();
//프래임 포장(작업영역)
}
public void start(){
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//창닫기 버튼 사용
}
}
public class Exam_01 {
public static void main(String[] ar){
Exam_01_sub ex = new Exam_01_sub("제목");
}
}
Border 컨포넌트
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;
class Exam_02_sub extends JFrame{
private JButton jbt1 = new
private JButton jbt2 = new
private JButton jbt3 = new
private JButton jbt4 = new
private JButton jbt5 = new
private JButton jbt6 = new
private JButton jbt7 = new
private JButton jbt8 = new
JButton("EMPTY");
JButton("LINE");
JButton("ETCHED");
JButton("BEVEL");
JButton("SOFTBEVEL");
JButton("MATTE");
JButton("TITLED");
JButton("COMPOUND");
private GridLayout gl = new GridLayout(4,2,5,5);
public Exam_02_sub(String title){
super(title);
this.init();
this.start();
this.setSize(300,300);
Dimension screen =
Toolkit.getDefaultToolkit().getScreenSize();
Dimension frm = this.getSize();
int xpos = (int)(screen.getWidth()/2 - frm.getWidth()/2);
int ypos = (int)(screen.getHeight()/2 - frm.getHeight()/2);
this.setLocation(xpos, ypos);
this.setVisible(true);
this.setResizable(false);
}
public void init(){
Container con = this.getContentPane();
//프래임 포장(작업영역)
con.setLayout(gl);
EmptyBorder b1 = new EmptyBorder(5,3,5,3);
//평평한 테두리,
jbt1.setBorder(b1);
con.add(jbt1);
LineBorder b2 = new LineBorder(Color.RED, 3);
jbt2.setBorder(b2);
con.add(jbt2);
EtchedBorder b3 = new EtchedBorder();
//홈이 파잇는 테두리
jbt3.setBorder(b3);
con.add(jbt3);
BevelBorder b4 = new BevelBorder(BevelBorder.LOWERED);
jbt4.setBorder(b4);
con.add(jbt4);
SoftBevelBorder b5 = new
SoftBevelBorder(SoftBevelBorder.RAISED);
jbt5.setBorder(b5);
con.add(jbt5);
MatteBorder b6 = new MatteBorder(5,10,15,20, Color.BLUE);
jbt6.setBorder(b6);
con.add(jbt6);
TitledBorder b7 = new TitledBorder("제목");
jbt7.setBorder(b7);
con.add(jbt7);
SoftBevelBorder b8 = new
SoftBevelBorder(SoftBevelBorder.RAISED);
TitledBorder b9 = new TitledBorder("제목임");
CompoundBorder b10 = new CompoundBorder(b8, b9);
jbt8.setBorder(b10);
con.add(jbt8);
}
public void start(){
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//창닫기 버튼 사용
}
}
public class Exam_02 {
public static void main(String[] ar){
Exam_02_sub ex = new Exam_02_sub("제목");
}
}
JToggleButton 클래스
import
import
import
import
import
java.awt.*;
java.awt.event.*;
javax.swing.*;
javax.swing.border.*;
javax.swing.event.*;
class Exam_03_sub extends JFrame{
private
private
private
private
ImageIcon
ImageIcon
ImageIcon
ImageIcon
ii1
ii2
ii3
ii4
=
=
=
=
new
new
new
new
ImageIcon("a.gif");
ImageIcon("b.gif");
ImageIcon("c.gif");
ImageIcon("d.dif");
//아이콘을 가지고 온다.
private
private
private
private
JToggleButton
JToggleButton
JToggleButton
JToggleButton
jtb1
jtb2
jtb3
jtb4
=
=
=
=
new
new
new
new
JToggleButton("1",ii1);
JToggleButton("2",ii2);
JToggleButton("3",ii3);
JToggleButton("4",ii4);
//아이콘으로 사용이 가능하다\
private ButtonGroup bg = new ButtonGroup();
private GridLayout gl = new GridLayout(1,4,5,5);
public Exam_03_sub(String title){
super(title);
this.init();
this.start();
this.setSize(300,200);
Dimension screen =
Toolkit.getDefaultToolkit().getScreenSize();
Dimension frm = this.getSize();
int xpos = (int)(screen.getWidth()/2 - frm.getWidth()/2);
int ypos = (int)(screen.getHeight()/2 - frm.getHeight()/2);
this.setLocation(xpos, ypos);
this.setVisible(true);
this.setResizable(false);
}
public void init(){
Container con = this.getContentPane();
//프래임 포장(작업영역)
con.setLayout(gl);
bg.add(jtb1);
bg.add(jtb2);
bg.add(jtb3);
bg.add(jtb4);
con.add(jtb1);
con.add(jtb2);
con.add(jtb3);
con.add(jtb4);
jtb4.setHorizontalTextPosition(SwingConstants.CENTER);
jtb4.setVerticalTextPosition(SwingConstants.BOTTOM);
//아이콘의 위치에서 어디에 위치할것인가
jtb1.setToolTipText("1번입니다.");
jtb2.setToolTipText("2번입니다.");
jtb3.setToolTipText("3번입니다.");
jtb4.setToolTipText("4번입니다.");
jtb1.setMnemonic('1');
jtb2.setMnemonic('2');
jtb3.setMnemonic('3');
jtb4.setMnemonic('4');
//단축키를 설정한다. Alt 사용해서 한다.
jtb2.setSelectedIcon(ii1);
//선택했을때의 아이콘
jtb2.setRolloverIcon(ii2);
//올려노왔을때의 아이콘
}
public void start(){
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//창닫기 버튼 사용
}
}
public class Exam_03 {
public static void main(String[] ar){
Exam_03_sub ex = new Exam_03_sub("제목");
}
}
JColorChooser
Color cc= JColorChooser.showDialog(this,"색상선택!", Color.BLACK);
//칼라 다이로그가 나타난다.
//System.out.print(cc);
JFileChooser
private JFileChooser jfc = new JFileChooser(".");
int x = jfc.showOpenDialog(this);
//jfc.showSaveDialog(this);
//열기 저장 다이로그로 나타난다.
//선택한 버튼의 위치에때라 순서를 가지고 있다.(int)
//System.out.println("x = " + x);
JOptionPane
//JOptionPane.showMessageDialog(this, "경고입니다.!", "경고!",
JOptionPane.WARNING_MESSAGE);
//경고 메세지 출력 다이로그(느낌표)
int x = JOptionPane.showConfirmDialog(this, "정말 삭제하시겠습니까?",
"삭제", JOptionPane.YES_NO_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE);
//질문 다이로크를 출력(물음표)
//선택한 버튼의 위치에때라 순서를 가지고 있다.(int)
String str = JOptionPane.showInputDialog(this, "이름", "입력!",
JOptionPane.QUESTION_MESSAGE);
System.out.print(str);
//글자 입력 다이로그를 선택하고 문자열로 리턴한다.
JDesktopPane
JInternalFrame
private BorderLayout bl = new BorderLayout();
private JDesktopPane pane = new JDesktopPane();
private JInternalFrame jif1 = new JInternalFrame("1번",
true,true,true,true);
private JInternalFrame jif2 = new JInternalFrame("2번",
true,true,true,true);
private JInternalFrame jif3 = new JInternalFrame("3번",
true,true,true,true);
//프래임 안에 프래임 생성할때 사용
public void init(){
Container con = this.getContentPane();
//프래임 포장(작업영역)
con.setLayout(bl);
con.add("Center", pane);
pane.add(jif1);
pane.add(jif2);
pane.add(jif3);
jif1.setBounds(0,0, 200,150);
jif2.setBounds(20,20, 200,150);
jif3.setBounds(40,40, 200,150);
//위치설정
}
JSplitPane
private JTree tree = new JTree();
private JTextArea jta = new JTextArea();
private JSplitPane jsp = new JSplitPane();
private BorderLayout bl = new BorderLayout();
public void init(){
Container con = this.getContentPane();
//프래임 포장(작업영역)
con.setLayout(bl);
jsp.setLeftComponent(tree);
jsp.setRightComponent(jta);
con.add("Center",jsp);
}
JTabbedPane
JToolbar
private BorderLayout bl = new BorderLayout();
private JToolBar jtb = new JToolBar();
private JButton jbt1 = new JButton("1번");
private JButton jbt2 = new JButton("2번");
private JButton jbt3 = new JButton("3번");
private JButton jbt4 = new JButton("4번");
private JTabbedPane jtp = new JTabbedPane();
private JPanel jp1 = new JPanel();
private JPanel jp2 = new JPanel();
private JPanel jp3 = new JPanel();
private JPanel jp4 = new JPanel();
public void init(){
Container con = this.getContentPane();
//프래임 포장(작업영역)
con.setLayout(bl);
jtb.add(jbt1);
jtb.add(jbt2);
jtb.addSeparator();
jtb.add(jbt3);
jtb.add(jbt4);
con.add("North", jtb);
jp1.setBackground(Color.black);
jp2.setBackground(Color.red);
jp3.setBackground(Color.green);
jp4.setBackground(Color.blue);
jtp.addTab("1번패널", jp1);
jtp.addTab("2번패널", jp2);
jtp.addTab("3번패널", jp3);
jtp.addTab("4번패널", jp4);
con.add("Center", jtp);
}
36. JApplet 작성법 <처음으로>
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Exam_01 extends JApplet{
private JMenuBar mb = new JMenuBar();
private JMenu file = new JMenu("FILE");
private JMenuItem fnew = new JMenuItem("NEW");
public void init(){
file.add(fnew);
mb.add(file);
this.setJMenuBar(mb);
}
public
public
public
public
void
void
void
void
start(){}
paint(Graphics g){}
stop(){}
destroy(){}
}
<html>
<head>
<title>제목</title>
</head>
<body>
<center>
<applet code="Exam_01.class" width="300" height="200">
</applet>
</center>
<body>
</html>
37. JTree 와 JTable 클래스 <처음으로>
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.table.*;
import javax.swing.tree.*;
class Exam_02_sub extends JFrame{
private BorderLayout bl = new BorderLayout();
private JSplitPane jsp = new JSplitPane();
private JTree jt;
private JTable jtb;
public Exam_02_sub(String title){
super(title);
this.init();
this.start();
this.setSize(400,400);
Dimension screen =
Toolkit.getDefaultToolkit().getScreenSize();
Dimension frm = this.getSize();
int xpos = (int)(screen.getWidth()/2 - frm.getWidth()/2);
int ypos = (int)(screen.getHeight()/2 - frm.getHeight()/2);
this.setLocation(xpos, ypos);
this.setVisible(true);
this.setResizable(false);
}
public void init(){
Container con = this.getContentPane();
//프래임 포장(작업영역)
con.setLayout(bl);
DefaultMutableTreeNode
DefaultMutableTreeNode("ROOT");
DefaultMutableTreeNode
DefaultMutableTreeNode
DefaultMutableTreeNode
root = new
c = new DefaultMutableTreeNode("C:");
d = new DefaultMutableTreeNode("D:");
e = new DefaultMutableTreeNode("E:");
jt = new JTree(root);
root.add(c);
root.add(d);
root.add(e);
jsp.setLeftComponent(jt);
Vector header = new Vector();
header.add("번호");
header.add("이름");
header.add("주민번호");
Vector data = new Vector();
Vector imsi = new Vector();
imsi.add(1);
imsi.add("강명찬");
imsi.add("111111-1111111");
data.add(imsi);
imsi = new Vector();
imsi.add(2);
imsi.add("강명찬");
imsi.add("111111-1111111");
data.add(imsi);
imsi = new Vector();
imsi.add(3);
imsi.add("강명찬");
imsi.add("111111-1111111");
data.add(imsi);
imsi = new Vector();
imsi.add(4);
imsi.add("강명찬");
imsi.add("111111-1111111");
data.add(imsi);
jtb = new JTable(data,header);
JScrollPane jsp1 = new JScrollPane(jtb);
jsp1.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
//스크롤바 항상 보이기
jsp.setRightComponent(jsp1);
con.add("Center", jsp);
}
public void start(){
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//창닫기 버튼 사용
}
}
public class Exam_02 {
public static void main(String[] ar){
Exam_02_sub ex = new Exam_02_sub("제목");
}
}
DefaultMutableTreeNode imsi
=(DefaultMutableTreeNode) e.getPath().getLastPathComponent();
//선택한 가장 마지막 경로를 가지고 온다.
imsi.removeAllChildren();
//하부멤버를 모두 지운다.
tree.setSelectionPath(e.getPath());
//선택한곳으로 이동한다.
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (Exception ee) {
//인도우 형식의 Look and Feel 로 해준다.
38. TCP통신(InetAddress, Socket, ServerSocket) <처음으로>
InetAddress 클래스
import java.io.*;
import java.net.*;
public class Exam_02 {
public static void main(String[] ar){
InetAddress ia = null; //자신의 IP주소
InetAddress ia1 = null; //다른 주소에 따른 IP주소
InetAddress[] ia2 = null; //다른 주소에 따른 모든 IP주소
try {
ia = InetAddress.getLocalHost();
ia1 = InetAddress.getByName("www.naver.co.kr");
ia2 = InetAddress.getAllByName("www.daum.net");
}catch(UnknownHostException e){}
System.out.println("1 ="+ia.getHostAddress());
System.out.println("1 ="+ia.getHostName());
System.out.println("2 ="+ia1.getHostAddress());
System.out.println("2 ="+ia1.getHostName());
System.out.println();
for(int i = 0; i<ia2.length; ++i){
System.out.println("3 ="+ia2[i].getHostAddress());
System.out.println("3 ="+ia2[i].getHostName());
}
}
}
Socket 클래스
import java.io.*;
import java.net.*;
public class Exam_03 {
public static void main(String[] ar){
Socket soc = null;
InetAddress ia = null;
try {
ia = InetAddress.getByName("www.daum.net");
}catch(UnknownHostException e){}
try{
soc = new Socket(ia,80);
String request
= "GET http://www.daum.net/index.html HTTP1/0\r\n\n";//요청
//출력
OutputStreamWriter osw = new
OutputStreamWriter(soc.getOutputStream());
BufferedWriter bos = new BufferedWriter(osw,512);
PrintWriter pw = new PrintWriter(bos);
pw.println(request);
pw.flush();
//입력
InputStreamReader isr = new
InputStreamReader(soc.getInputStream());
BufferedReader br = new BufferedReader(isr,512);
while(true){
String str = br.readLine();
if(str == null) break;
System.out.println(str);
}
pw.close();
br.close();
}catch(IOException e){}
}
}
ServerSocket 클래스
import java.io.*;
import java.net.*;
public class Round24_Ex04 {
public static void main(String[] ar) {
// TCP의 열려져 있는 포트 확인하기
ServerSocket ss = null;
for (int i = 1; i <= 65535; i++) {
try {
ss = new ServerSocket(i);
ss.close();
} catch (IOException ee) {
System.out.println(i + "번 TCP 포트가 열려
있습니다.");
}
}
}
}