자바8에서 컴파일 하고 실행을 그하위자바7등에서 실행시 발생하는 오류
이클립스 windows -> preference -> java -> installed jre에서 자바8로 변경.
해당 프로젝트의 속성에서 java compiler, java build path에서 library에서 jre8로 바꾸자...
3D프린팅,아두이노알고리즘프로그래밍,로봇제작,스프링프레임워크,스프링시큐리티,스프링소셜,NODE.JS,AngulerJS,안드로이드 마시멜로,아이폰 Swift,닷넷, C#, Xamarin 실무개발바교육,구로디지털단지역2분,초역세권
2014년 7월 31일 목요일
[오라클자바커뮤니티,자바컴파일, 자바실행오류,에러,자바학원]Unsupported major.minor version 52.0,오라클자바커뮤니티 JAVA교육학원
[오라클자바커뮤니티,자바컴파일, 자바실행오류,에러,자바학원]Unsupported major.minor version 52.0,오라클자바커뮤니티 JAVA교육학원
함수형 인터페이스(Functional Interface,@FunctionalInterface),마커인터페이스(Marker Interface),자바8람다식,익명함수,무명메소드
함수형 인터페이스(Functional Interface,@FunctionalInterface),마커인터페이스(Marker Interface),자바8람다식,익명함수,무명메소드
자바에서 마커인터페이스(marker interface)는 구현해야 되는 추상메소드가 없는 인터페이스를 의미한다. 단지 그 인터페이스를 구현했다고 기술한 클래스에 어떤 의미를 부여하기 위한것이다.
그리고 추상메소드가 하나뿐인 인터페이스를 Functional Interface라고 한다.
- java.lang.Runnable 함수형 인터페이스 이다.(void run() 추상메소드 하나 있다.)
- ActionListener interface역시 함수형 인터페이스이다.(actionPerformed() 추상메소드 하나 있다.)
- 이러한 함수형 인터페이스의 인스턴스를 생성하기 위해 익명 클래스등을 주로 사용했지만 람다식을 이용하면 아주 편하다.
- @FunctionalInterface 어노테이션은 JAVA8에서 추가되었으며 함수형 인터페이스 임을 나타낸다.
Runnable 인터페이스의 인스턴스를 람다식을 이용하여 아래처럼 얻을 수 있다.
Runnable r = () -> System.out.println("oraclejava community");
쓰레드를 생성할 때 아래처럼 람다식을 이용할 수도 있다.
new Thread(
() -> System.out.println("oraclejava community")
).start();
[예제]
package onj;
//@FunctionalInterface
interface OnjInterface2 {
public void work();
}
public class FInterfaceTest {
static void execute(OnjInterface2 worker) {
worker.work();
}
public static void main(String[] args) {
execute(new OnjInterface2() {
@Override
public void work() {
System.out.println("Woking... oraclejava community");
}
});
execute( ()->System.out.println("Woking... oraclejava community"));
}
}
[결과]
Woking... oraclejava community
Woking... oraclejava community
[JAVA8신기능,Lambda 식]자바8 람다식(JAVA8,JDK1.8,Lambda __EXPRESSION__),함수형 인터페이스,오라클자바커뮤니티 자바기초교육,JAVA학원교육
[JAVA8신기능,Lambda 식]자바8 람다식(JAVA8,JDK1.8,Lambda __EXPRESSION__),함수형 인터페이스,오라클자바커뮤니티 자바기초교육,JAVA학원교육
- 파이썬에서 먼저 지원, 자바8 업데이트에서 제공된 기능으로
- 기존의 반복이나 비교문들의 가독성을 대폭적으로 향상
- 람다식은 익명 함수에서 주로 사용한다.
- 프로그래밍에서 식별자 없이 실행할 수 있는 방법을 제공
- java.util.function 패키지에는 몇가지 미리정의된 함수형 인터페이스가 있다.
(http://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html)
Predicate: 하나의 매개변수를 주고 boolean형을 반환하는 인터페이스를 구현해줄 수 있다.
public interface Predicate<T> {
boolean test(T t);
}
Consumer: 하나의 매개변수를 주고 void 인터페이스를 구현
public interface Consumer<T> {
void accept(T t);
}
Function: Transform a T to a U
public interface Function<T, R> {
R apply(T t);
}
Supplier: Provide an instance of a T (such as a factory)
public interface Supplier<T, U, R> {
R apply(T t, U u);
}
UnaryOperator: A unary operator from T -> T
BinaryOperator: A binary operator from (T, T) -> T
- 형식
(arg1, arg2...) -> { body } //body에 표현식이 없거나 한개이상 올 수 있다.
(params) -> __EXPRESSION__
(params) -> statement
(params) -> { statements }
(int a, int b) -> { return a + b; }
() -> System.out.println("Hello World"); //파라미터없고 Hello World출력
(String s) -> { System.out.println(s); } //문자열을 입력받아 출력
() -> 8514790 //파라미터없고 8514790가 리턴
() -> { return 3.14 }; //파라미터없고 3.14리턴
[예제]
package onj;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.function.*;
class Developer {
private String skill;
private int carri;
public Developer(String skill, int carri) {
this.skill = skill;
this.carri = carri;
}
public String getSkill() {
return skill;
}
public void setSkill(String skill) {
this.skill = skill;
}
public int getCarri() {
return new Integer(carri);
}
public void setCarri(int carri) {
this.carri = carri;
}
@Override
public String toString() {
return getSkill() + "::" + getCarri();
}
}
public class LambdaTest {
public static void printAll(List<Developer> list) {
//아래와 동일
//list.forEach((x) -> System.out::println(x))
list.forEach(System.out::println);
}
public static void printDevOrderBySkill(List<Developer> list) {
Collections.sort(list, (
Developer d1, Developer d2) -> d1.getSkill().compareTo(d2.getSkill()));
list.forEach(System.out::println);
}
public static int sumAll(List<Integer> numbers, Predicate<Integer> p) {
int total = 0;
for(int number : numbers) {
if (p.test(number)) {
total += number;
}
}
return total;
}
public static void main(String[] args) {
//쓰레드 생성, 예전방법
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("oraclejava community thread1....");
}
}).start();
//쓰레드 생성, 람다식이용
new Thread( () -> System.out.println("oraclejava community thread2....")).start();
List<Developer> dev = new ArrayList();
dev.add(new Developer("JAVA", 10));
dev.add(new Developer("ORACLE", 15));
dev.add(new Developer("C#", 7));
dev.add(new Developer("ANDROID", 5));
printAll(dev);
System.out.println("---------------------------");
printDevOrderBySkill(dev);
System.out.println("---------------------------");
List<Integer> list = Arrays.asList(1,8,3,9,4,7);
int sum1 = sumAll(list, n -> true); //전부다 합
int sum2 = sumAll(list, n -> n % 2 == 0); //짝수 합
int sum3 = sumAll(list, n -> n > 5); //5보다큰수 합
//전부 출력
list.forEach(System.out::println);
System.out.println("모든 수 합 : " + sum1);
System.out.println("짝수 합 : " + sum2);
System.out.println("5보다큰수합 : " + sum3);
}
}
[결과]
oraclejava community thread1....
oraclejava community thread2....
JAVA::10
ORACLE::15
C#::7
ANDROID::5
---------------------------
ANDROID::5
C#::7
JAVA::10
ORACLE::15
---------------------------
1
8
3
9
4
7
모든 수 합 : 32
짝수 합 : 12
5보다큰수합 : 24
[JAVA8]자바8에새로도입된:: (더블콜론)연산자,double colon (::) operator, JAVA8람다식
[JAVA8]자바8에새로도입된:: (더블콜론)연산자,double colon (::) operator, JAVA8람다식
- 정규 메소드를 람다표현식으로 변환
[예]
List<Integer> list = Arrays.asList(1, 3, 2, 4, 7);
list.forEach(n -> System.out.println(n));
list.forEach((Integer n) -> System.out.println(n));
//위 람다식을 더블콜론 연산자를 이용하여 바꾸면 아래와 같다.
//아래 두문장은 동일하다.
list.forEach(System.out::println);
list.forEach((x) -> System.out::println(x));
[오라클자바커뮤니티,JAVA8강좌교육,자바8,JAVA8 forEach메소드]java.lang.Iterable,Collection Iterrator, 반복자, 컬렉션
[오라클자바커뮤니티,JAVA8강좌교육,자바8,JAVA8 forEach메소드]java.lang.Iterable,Collection Iterrator, 반복자, 컬렉션
emps.forEach((emp) -> myMethod.hello(emp));
자바7
for (Emp emp : emps) {
myMethod.hello(emp));
}
자바8 이전까지 Collection등을 순회할 때 Iterator(반복자)를 얻어 순회했지만 forEach로 가능
Java.lang.Iterable 인터페이스 메소드
forEach로 비즈니스 로직을 분리하여 재사용가능
package onj;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.function.Consumer;
import java.lang.Integer;
//Consumer implementation that can be reused
class OnJConsumer implements Consumer<Integer>{
public void accept(Integer i) {
System.out.println("Consumer impl i :: " + i);
}
}
public class ForEachTest {
public static void main(String[] args) {
List<Integer> myList = new ArrayList<Integer>();
for(int i=0; i<5; i++) myList.add(i);
//반복자를 얻어 Collection을 순회
Iterator<Integer> iter = myList.iterator();
while(iter.hasNext()){
Integer i = iter.next();
System.out.println("i ::" + i );
}
//이번에는 forEach문을 이용하자. Consumer는 자바에서 제공하는 함수형 인터페이스이다.
//파라미터를 받아서 void형 accept 메소드 구현
myList.forEach(new Consumer<Integer>() {
public void accept(Integer i) {
System.out.println("forEach i :: " + i );
}
});
//Consumer인터페이스를 구현한 클래스를 new후 forEach에 사용
OnJConsumer action = new OnJConsumer();
myList.forEach(action);
//이번에는 람다식으로...
myList.forEach( (i) -> System.out.println("람다식 i ::" + i ) );
//이번에는 더블콜론 연산자로...
System.out.println("--------------");
myList.forEach(System.out::println);
}
}
[결과]
i ::0
i ::1
i ::2
i ::3
i ::4
forEach i :: 0
forEach i :: 1
forEach i :: 2
forEach i :: 3
forEach i :: 4
Consumer impl i :: 0
Consumer impl i :: 1
Consumer impl i :: 2
Consumer impl i :: 3
Consumer impl i :: 4
람다식 i ::0
람다식 i ::1
람다식 i ::2
람다식 i ::3
람다식 i ::4
--------------
0
1
2
3
4
[자바8 컬렉션 탐색하기,for, forEach, iterator, 더블콜론연산자,Consumer등이용한 예제]
[자바8 컬렉션 탐색하기,for, forEach, iterator, 더블콜론연산자,Consumer등이용한
예제]
개발하다보면 컬렉션(List, Set, 배열등)에 넣은 값들을 많이 사용하는데...
아래 여러 방법으로 출력하는 예제를 참고하자.
package onj;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.function.Consumer;
import java.lang.Integer;
//Consumer implementation that can be reused
class OnJConsumer implements Consumer<Integer>{
public void accept(Integer i) {
System.out.println("Consumer impl i :: " + i);
}
}
public class ForEachTest {
public static void main(String[] args) {
List<Integer> myList = new ArrayList<Integer>();
for(int i=0; i<5; i++) myList.add(i);
//반복자를 얻어 Collection을 순회
Iterator<Integer> iter = myList.iterator();
while(iter.hasNext()){
Integer i = iter.next();
System.out.println("i ::" + i );
}
//개선된 for문으로
for(int i : myList) {
System.out.println("개선된 for문 i :: " + i );
}
//이번에는 forEach문을 이용하자. Consumer는 자바에서 제공하는 함수형 인터페이스이다.
//파라미터를 받아서 void형 accept 메소드 구현
myList.forEach(new Consumer<Integer>() {
public void accept(Integer i) {
System.out.println("forEach i :: " + i );
}
});
//Consumer인터페이스를 구현한 클래스를 new후 forEach에 사용
OnJConsumer action = new OnJConsumer();
myList.forEach(action);
//이번에는 forEach 람다식으로...
myList.forEach( (i) -> System.out.println("람다식 i ::" + i )
);
//이번에는 forEach 더블콜론 연산자로...
System.out.println("--------------");
myList.forEach(System.out::println);
}
}
[결과]
i ::0
i ::1
i ::2
i ::3
i ::4
개선된 for문 i :: 0
개선된 for문 i :: 1
개선된 for문 i :: 2
개선된 for문 i :: 3
개선된 for문 i :: 4
forEach i :: 0
forEach i :: 1
forEach i :: 2
forEach i :: 3
forEach i :: 4
Consumer impl i :: 0
Consumer impl i :: 1
Consumer impl i :: 2
Consumer impl i :: 3
Consumer impl i :: 4
람다식 i ::0
람다식 i ::1
람다식 i ::2
람다식 i ::3
람다식 i ::4
--------------
0
1
2
3
4
[오라클자바커뮤니티자바기초교육,JAVA8강좌,자바 컬렉션,람다식,forEach,더블콜론, TreeSet예제,Comparable,compareTo,iterator]
[오라클자바커뮤니티자바기초교육,JAVA8강좌,자바 컬렉션,람다식,forEach,더블콜론, TreeSet예제,Comparable,compareTo,iterator]
package day6;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
import java.util.function.Consumer;
class AddrBook2 implements Comparable{
String name;
String addr;
AddrBook2(String name, String addr) {
this.name = name;
this.addr = addr;
}
public String toString() {
return name + " / " + addr;
}
@Override
public int compareTo(Object o) {
return this.name.compareTo(((AddrBook2)o).name);
}
}
public class TreeSetTest3 {
Set treeset;
public TreeSetTest3() {
// Comparable을구현한객체를add 하므로/TreeSet의생성자에 this를 넣지 않음
treeset = new TreeSet();
}
public void test() {
treeset.add(new AddrBook2("나길동", "서울"));
treeset.add(new AddrBook2("하길동", "부산"));
treeset.add(new AddrBook2("김길동", "대구"));
treeset.add(new AddrBook2("최길동", "광주"));
printAll();
}
public void printAll() {
Iterator iter = treeset.iterator();
while (iter.hasNext())
System.out.println(iter.next());
treeset.forEach(new Consumer<AddrBook2>() {
public void accept(AddrBook2 addr) {
System.out.println("forEach s :: " + addr );
}
});
//이번에는 forEach 람다식으로...
System.out.println("--------------------");
treeset.forEach( (addr) -> System.out.println("람다식 Addr ::" + addr ) );
//이번에는 forEach 더블콜론 연산자로...
System.out.println("--------------");
treeset.forEach(System.out::println);
//이번에는 forEach 더블콜론 연산자, 람다식으로...
System.out.println("--------------");
treeset.forEach((addr) -> System.out.println(addr));
}
public static void main(String[] args) {
TreeSetTest3 tst = new TreeSetTest3();
tst.test();
}
}
[결과]
김길동 / 대구
나길동 / 서울
최길동 / 광주
하길동 / 부산
forEach s :: 김길동 / 대구
forEach s :: 나길동 / 서울
forEach s :: 최길동 / 광주
forEach s :: 하길동 / 부산
--------------------
람다식 Addr ::김길동 / 대구
람다식 Addr ::나길동 / 서울
람다식 Addr ::최길동 / 광주
람다식 Addr ::하길동 / 부산
--------------------
--------------
김길동 / 대구
나길동 / 서울
최길동 / 광주
하길동 / 부산
[오라클자바커뮤니티,자바자료구조 클래스, JCF, HashSet, TreeSet, SortedSet, JAVA TreeSet예제, Comparator, compare]
[오라클자바커뮤니티,자바자료구조 클래스, JCF, HashSet, TreeSet, SortedSet, JAVA TreeSet예제, Comparator, compare]
package day6;
import java.util.*;
class AddrBook {
String name;
String addr;
AddrBook(String name, String addr) {
this.name = name;
this.addr = addr;
}
public String toString() {
return name + " / " + addr;
}
}
public class TreeSetTest2 implements Comparator {
Set treeset;
public TreeSetTest2() {
// Comparable을구현않은객체를add 하므로/TreeSet의생성자에
// Comparator 객체를전달하여다른비교메소드를이용하라고알림
treeset = new TreeSet(this);
}
public void test() {
treeset.add(new AddrBook("나길동", "서울"));
treeset.add(new AddrBook("하길동", "부산"));
treeset.add(new AddrBook("김길동", "대구"));
treeset.add(new AddrBook("최길동", "광주"));
printAll();
}
public int compare(Object o1, Object o2) {
return (((AddrBook) o1).name).compareTo(((AddrBook) o2).name);
}
public void printAll() {
Iterator iter = treeset.iterator();
while (iter.hasNext())
System.out.println(iter.next());
}
public static void main(String[] args) {
TreeSetTest2 tst = new TreeSetTest2();
tst.test();
}
}
[결과]
김길동 / 대구
나길동 / 서울
최길동 / 광주
하길동 / 부산
자바 System.out, System.err 차이(자바표준출력, JAVA표준에러출력, 자바교육,자바학원교육잘하는곳)
자바 System.out, System.err 차이(자바표준출력, JAVA표준에러출력, 자바교육,자바학원교육잘하는곳)
public class ErrTest
{
public static
void main(String[] args) {
System.out.println("out.println 은 파일에 써집니다.");
System.err.println("err.println 은 파일에
안써집니다.");
}
}
C:\>javac ErrTest.java && java ErrTest
out.println 은 파일에 써집니다.
err.println 은 파일에 안써집니다.
C:\>javac ErrTest.java && java ErrTest < out.txt
err.println 은 파일에 안써집니다.
==> System.out 출력만 파일에 써진다.
[강좌#7]AWT기반의 채팅 프로그램 [자바개발자교육/자바교육/자바강좌/자바,Spring교육잘하는곳/자바,spring교육추천/자바실무교육/JAVA/JAVA교육/JAVA스프링학원/JAVA실무교육]
이번 강좌에는 Java Network Programming, Second Edition에 있는 채팅 프로그램을 만들어 보도록 하겠습니다. 이전 예제인 MuktiThreadEchoServer를 이해 하셨다면 그리 어렵지는 않으리라 생각 됩니다.
[먼저 실행 결과를 본후 소스 코드를 보도록 하겠습니다.]
서버의 실행
클라이언트1의 실행
클라이언트2의 실행
아래에는 그 소스 입니다.
[ChatServer.java]
import java.io.*;
import java.net.*;
import java.util.*;
import java.net.*;
import java.util.*;
public class ChatServer {
public static void main (String args[]) throws IOException {
if (args.length != 1)
throw new IllegalArgumentException ("Syntax: ChatServer <port>");</port>
public static void main (String args[]) throws IOException {
if (args.length != 1)
throw new IllegalArgumentException ("Syntax: ChatServer <port>");</port>
int port = Integer.parseInt (args[0]);
ServerSocket server = new ServerSocket (port); //지정한 포트에 서버 소켓을 생성하고 연결을 기다립니다.
ServerSocket server = new ServerSocket (port); //지정한 포트에 서버 소켓을 생성하고 연결을 기다립니다.
while (true) {
Socket client = server.accept (); //클라이언트가 연결을 했다면 큐에 쌓이는데 그 큐에서 연결 하나를 가지고 옵니다.
System.out.println ("Accepted from " + client.getInetAddress ());
ChatHandler handler = new ChatHandler (client); //ChatHandler는 Runnable 인터페이스를 구현했으므로 스레드 입니다.
//즉 클라이언트 하나를 상대하기 위해 스레드를 만들어 분기하는 거죠...
handler.start (); //스레드를 시작 합니다.
}
}
}
Socket client = server.accept (); //클라이언트가 연결을 했다면 큐에 쌓이는데 그 큐에서 연결 하나를 가지고 옵니다.
System.out.println ("Accepted from " + client.getInetAddress ());
ChatHandler handler = new ChatHandler (client); //ChatHandler는 Runnable 인터페이스를 구현했으므로 스레드 입니다.
//즉 클라이언트 하나를 상대하기 위해 스레드를 만들어 분기하는 거죠...
handler.start (); //스레드를 시작 합니다.
}
}
}
[ChatHandler.java]
import java.io.*;
import java.net.*;
import java.util.*;
import java.net.*;
import java.util.*;
public class ChatHandler implements Runnable {
protected Socket socket;
public ChatHandler (Socket socket) {
this.socket = socket;
}
protected Socket socket;
public ChatHandler (Socket socket) {
this.socket = socket;
}
protected DataInputStream dataIn;
protected DataOutputStream dataOut;
protected Thread listener;
protected DataOutputStream dataOut;
protected Thread listener;
//ChatServer에서 클라이언트의 연결을 accept한 후 부르는 start 메소드 입니다.
//
public synchronized void start () {
if (listener == null) {
try {
dataIn = new DataInputStream
(new BufferedInputStream (socket.getInputStream ()));
dataOut = new DataOutputStream
(new BufferedOutputStream (socket.getOutputStream ()));
listener = new Thread (this); //스레드를 만듭니다.
listener.start (); //스레드를 시작 하면 run 메소드가 호출되는 것은 아시죠?
} catch (IOException ignored) {
}
}
}
//
public synchronized void start () {
if (listener == null) {
try {
dataIn = new DataInputStream
(new BufferedInputStream (socket.getInputStream ()));
dataOut = new DataOutputStream
(new BufferedOutputStream (socket.getOutputStream ()));
listener = new Thread (this); //스레드를 만듭니다.
listener.start (); //스레드를 시작 하면 run 메소드가 호출되는 것은 아시죠?
} catch (IOException ignored) {
}
}
}
public synchronized void stop () {
if (listener != null) {
try {
if (listener != Thread.currentThread ())
listener.interrupt ();
listener = null;
dataOut.close ();
} catch (IOException ignored) {
}
}
}
if (listener != null) {
try {
if (listener != Thread.currentThread ())
listener.interrupt ();
listener = null;
dataOut.close ();
} catch (IOException ignored) {
}
}
}
protected static Vector handlers = new Vector ();
//run 메소드 안에 해당 쓰레드가 수행할 내용들이 있습니다.
public void run () {
try {
handlers.addElement (this); //클라이언트 하나의 연결을 벡터에 담습니다. 요즘은 ArrayList를 주로 사용 합니다.
while (!Thread.interrupted ()) {
String message = dataIn.readUTF ();
broadcast (message); //메소드를 호출 합니다. (클라이언트로 메시지를 보냄)
}
} catch (EOFException ignored) {
} catch (IOException ex) {
if (listener == Thread.currentThread ())
ex.printStackTrace ();
} finally {
handlers.removeElement (this);
}
stop ();
}
//run 메소드 안에 해당 쓰레드가 수행할 내용들이 있습니다.
public void run () {
try {
handlers.addElement (this); //클라이언트 하나의 연결을 벡터에 담습니다. 요즘은 ArrayList를 주로 사용 합니다.
while (!Thread.interrupted ()) {
String message = dataIn.readUTF ();
broadcast (message); //메소드를 호출 합니다. (클라이언트로 메시지를 보냄)
}
} catch (EOFException ignored) {
} catch (IOException ex) {
if (listener == Thread.currentThread ())
ex.printStackTrace ();
} finally {
handlers.removeElement (this);
}
stop ();
}
//아래에서 벡터에 있는 클라이언트의 연결 만큼 루프 돌면서 메시지를 보내고 있습니다. unicast현태로 broadcast를 흉내 내는거죠...
protected void broadcast (String message) {
synchronized (handlers) {
Enumeration enum = handlers.elements ();
while (enum.hasMoreElements ()) {
ChatHandler handler = (ChatHandler) enum.nextElement ();
protected void broadcast (String message) {
synchronized (handlers) {
Enumeration enum = handlers.elements ();
while (enum.hasMoreElements ()) {
ChatHandler handler = (ChatHandler) enum.nextElement ();
try {
handler.dataOut.writeUTF (message);
handler.dataOut.flush ();
} catch (IOException ex) {
handler.stop ();
}
}
}
}
}
handler.dataOut.writeUTF (message);
handler.dataOut.flush ();
} catch (IOException ex) {
handler.stop ();
}
}
}
}
}
[ChatClient.java]
import java.io.*;
import java.net.*;
import java.awt.*;
import java.awt.event.*;
import java.net.*;
import java.awt.*;
import java.awt.event.*;
public class ChatClient implements Runnable, WindowListener, ActionListener {
protected String host;
protected int port;
protected Frame frame;
protected TextArea output;
protected TextField input;
//생성자에서 UI 만듭니다. Main에서 new 할때 호출 됩니다.
public ChatClient (String host, int port) {
this.host = host;
this.port = port;
frame = new Frame ("ChatClient [" + host + ':' + port + "]");
frame.addWindowListener (this); //프레임(윈도우)이벤트 처리를 위한 리스너를 붙임, 윈도우가 Open된다든지, Close 될때 무언가를 하기 위해
output = new TextArea ();
output.setEditable (false);
input = new TextField ();
input.addActionListener (this); //텍스트 필드에서 엔터 쳤을때 이벤트를 받기 위해
frame.add ("Center", output);
frame.add ("South", input);
frame.pack ();
}
protected String host;
protected int port;
protected Frame frame;
protected TextArea output;
protected TextField input;
//생성자에서 UI 만듭니다. Main에서 new 할때 호출 됩니다.
public ChatClient (String host, int port) {
this.host = host;
this.port = port;
frame = new Frame ("ChatClient [" + host + ':' + port + "]");
frame.addWindowListener (this); //프레임(윈도우)이벤트 처리를 위한 리스너를 붙임, 윈도우가 Open된다든지, Close 될때 무언가를 하기 위해
output = new TextArea ();
output.setEditable (false);
input = new TextField ();
input.addActionListener (this); //텍스트 필드에서 엔터 쳤을때 이벤트를 받기 위해
frame.add ("Center", output);
frame.add ("South", input);
frame.pack ();
}
protected DataInputStream dataIn;
protected DataOutputStream dataOut;
protected Thread listener;
//메인에서 new 한 후 start 메소드를 호출 합니다.
public synchronized void start () throws IOException {
if (listener == null) {
Socket socket = new Socket (host, port);
try {
dataIn = new DataInputStream
(new BufferedInputStream (socket.getInputStream ()));
dataOut = new DataOutputStream
(new BufferedOutputStream (socket.getOutputStream ()));
}
catch (IOException ex) {
socket.close ();
throw ex;
}
protected DataOutputStream dataOut;
protected Thread listener;
//메인에서 new 한 후 start 메소드를 호출 합니다.
public synchronized void start () throws IOException {
if (listener == null) {
Socket socket = new Socket (host, port);
try {
dataIn = new DataInputStream
(new BufferedInputStream (socket.getInputStream ()));
dataOut = new DataOutputStream
(new BufferedOutputStream (socket.getOutputStream ()));
}
catch (IOException ex) {
socket.close ();
throw ex;
}
//스레드를 만들어 시작 합니다. 서버와의 지속적인 통신을 시작 합니다. (스레드가 어떤일을 하는지는 run 메소드를 보면 됩니다.)
listener = new Thread (this);
listener.start ();
frame.setVisible (true);
}
}
listener = new Thread (this);
listener.start ();
frame.setVisible (true);
}
}
public synchronized void stop () throws IOException {
frame.setVisible (false);
if (listener != null) {
listener.interrupt ();
listener = null;
dataOut.close ();
}
}
frame.setVisible (false);
if (listener != null) {
listener.interrupt ();
listener = null;
dataOut.close ();
}
}
//스레드에서 실행 될 메소드, 서버가 보내는 데이터를 읽어 화면에 뿌립니다.
public void run () {
try {
while (!Thread.interrupted ()) {
String line = dataIn.readUTF ();
output.append (line + "\n");
}
} catch (IOException ex) {
handleIOException (ex);
}
}
public void run () {
try {
while (!Thread.interrupted ()) {
String line = dataIn.readUTF ();
output.append (line + "\n");
}
} catch (IOException ex) {
handleIOException (ex);
}
}
protected synchronized void handleIOException (IOException ex) {
if (listener != null) {
output.append (ex + "\n");
input.setVisible (false);
frame.validate ();
if (listener != Thread.currentThread ())
listener.interrupt ();
listener = null;
try {
dataOut.close ();
} catch (IOException ignored) {
}
}
}
if (listener != null) {
output.append (ex + "\n");
input.setVisible (false);
frame.validate ();
if (listener != Thread.currentThread ())
listener.interrupt ();
listener = null;
try {
dataOut.close ();
} catch (IOException ignored) {
}
}
}
//처음 화면이 열렸을때
public void windowOpened (WindowEvent event) {
input.requestFocus ();
}
public void windowOpened (WindowEvent event) {
input.requestFocus ();
}
//사용자가 윈도우를 종료 했을때
public void windowClosing (WindowEvent event) {
try {
dataOut.writeUTF ("전 이만 나갑니다... Bye...");
stop ();
} catch (IOException ex) {
ex.printStackTrace ();
}
}
public void windowClosing (WindowEvent event) {
try {
dataOut.writeUTF ("전 이만 나갑니다... Bye...");
stop ();
} catch (IOException ex) {
ex.printStackTrace ();
}
}
public void windowClosed (WindowEvent event) {}
public void windowIconified (WindowEvent event) {}
public void windowDeiconified (WindowEvent event) {}
public void windowActivated (WindowEvent event) {}
public void windowDeactivated (WindowEvent event) {}
public void windowIconified (WindowEvent event) {}
public void windowDeiconified (WindowEvent event) {}
public void windowActivated (WindowEvent event) {}
public void windowDeactivated (WindowEvent event) {}
//텍스트 필드에서 엔터 쳤을때 호출 됩니다. 즉 서버로 메시지를 보내게 되겠죠....
public void actionPerformed (ActionEvent event) {
try {
input.selectAll ();
dataOut.writeUTF (event.getActionCommand ());
dataOut.flush ();
} catch (IOException ex) {
handleIOException (ex);
}
}
public void actionPerformed (ActionEvent event) {
try {
input.selectAll ();
dataOut.writeUTF (event.getActionCommand ());
dataOut.flush ();
} catch (IOException ex) {
handleIOException (ex);
}
}
//아래는 메인 함수 입니다. 실행 후 객체 만들어 start 메소드를 호출 합니다.
public static void main (String[] args) throws IOException {
if ((args.length != 1) || (args[0].indexOf (':') < 0))>
throw new IllegalArgumentException ("Syntax: ChatClient <host>:<port>");
int idx = args[0].indexOf (':');
String host = args[0].substring (0, idx);
int port = Integer.parseInt (args[0].substring (idx + 1));
ChatClient client = new ChatClient (host, port);
client.start ();
}
}</port></host>
public static void main (String[] args) throws IOException {
if ((args.length != 1) || (args[0].indexOf (':') < 0))>
throw new IllegalArgumentException ("Syntax: ChatClient <host>:<port>");
int idx = args[0].indexOf (':');
String host = args[0].substring (0, idx);
int port = Integer.parseInt (args[0].substring (idx + 1));
ChatClient client = new ChatClient (host, port);
client.start ();
}
}</port></host>
이번 강좌에서는 자바 AWT기반의 채팅 프로그램을 만들어 보았습니다. 혹시 의문 사항이나 질문 있으시면 Q/A에 올려 주세요~
감사합니다.
피드 구독하기:
글 (Atom)