Jaybon 의 지식창고

GUI - 윈도우와 같이 그림으로 이루어진 인터페이스

CLI - DOS와 같이 글자를 입력하는 인터페이스

-------------------------------

Z인덱스

최상위 컨테이너

웹브라우저에서 경고창이 뜨면 경고창이 최상위 컨테이너가된다

---------------------------------

SWING

SWING은  AWT와 달리 순수 자바 언어로 작성되었다.

스윙은 AWT에 구현된 이벤트 처리나 GUI 컴포넌트의 기본 원리를 바탕으로 작성되었기 때문에,

스윙을 사용하기 위해 AWT패키지가 필요하다.

SWING을 배워두면 안드로이드도 배우기 쉬워진다

모니터 자체를 창(window) - OS관할

그안의 화면 전체를 도화지(canvas)

도화지의 좌측최상단을 X = 0 , Y = 0

각각의 좌표값을 픽셀이라고한다

SWING의 기본 레이아웃은 border레이아웃

border안에 panal을 넣어서 플로우를 그 안에 넣어서 위치를 정한다

GUI 컴포넌트들은 다른 컴포넌트를 포함할 수 있는지 여부에 따라 순수 컴포넌트와 컨테이너로 분류된다.

컨테이너란 다른 GUI 컴포넌트를 포함할 수 있는 컴포넌트이다.

최상위 컨테이너는 JFrame, JDialog, JApplet이 있다

컴포넌트 (위젯)

Button, TextField, TextArea 등

자주쓰는 기능 (버튼 등)은 재사용을 하기 위해 미리 클래스화 하여 만들어 놓는 것

특징 - 이벤트가 달려있다 (클릭이나 건들였을 때 반응이 일어나도록 하는 것)

변형을 주고 싶으면 상속을 받아서 오버라이딩 하여 사용한다

컴포넌트는 컨테이너 안에서 존재 할 수 있다

컨테이너

컨테이너는 컴포넌트를 포함 할 수 있는 컴포넌트를 말한다

자바의 컨테이너는 Frame, Panel, Scrollpane

HTML의 BODY는 컨테이너, 도화지 역할

자바의 Frame은 HTML의 BODY와 같은 역할

자바의 panel은 HTML의 DIV역할

이벤트

컴포넌트를 건들이는 것을 알아차리는 주체는 OS이다

알아차린 OS의 리스너는 우리에게 Callback해준다

Callback시 context(해당 컴포넌트가 가진 모든 정보)를 돌려준다 

자바 이벤트분배스레드(Queue)는 context를 가지고 있다

리스너 - OS - 자바 이벤트분배스레드(Queue)

ex)
1.사용자가 마우스로 화면의 버튼을 클릭한다

2.이벤트 분배 스레드에게 마우스 클릭에 관한 정보를 보낸다

3.이벤트 분배 스레드는 이벤트 객체를 생성한다
이벤트 객체는 이벤트에 관한 여러 정보(context)를 담은 객체이다
이벤트 객체 내의 이벤트 소스는 위에서 클릭한 버튼자체이다

4.이벤트 분배 스레드는 타겟을 호출한다

커스터마이징

------------------------

Paint

setVisible시 그림을 그려줌

RePaint

setVisible상태에서 다른 것을 입력하거나 화면을 바꾸게 되면

RePaint로 해당 컴포넌트만 다시 그린다

-----------------------

1. 컨테이너 vs 컴포넌트

2. 레이아웃 4가지

3. 스윙 동작 구조

4. 리스너 등록 3가지 방법
    - 익명 클래스 만들기
    - 클래스 만들기(내부, 외부)
    - this

-----------------------

리스너 등록 3가지 방법

1. - 익명 클래스 만들기

package ch14;

import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;


// 익명 클래스로 타겟 생성
public class EventEx01 extends JFrame {
	
	public EventEx01() {
		setTitle("Action 이벤트 리스너 예제");
		
		// x버튼 클릭시 이벤트 분배스레드 끄기
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		Container c = getContentPane();
		
		c.setLayout(new FlowLayout());
		
		JButton btn = new JButton("Action");
		
		// 리스너 생성
		btn.addActionListener(new ActionListener() {
			
			// 타겟 (이벤트 분배 스레드가 콜백)
			@Override
			public void actionPerformed(ActionEvent e) {
				System.out.println("버튼클릭됨");
				
				// e는 context, e.getSource()는 이벤트 소스
				JButton b = (JButton) e.getSource();
				System.out.println(b.getText());
				b.setText("액션"); // RePaint()
			}
		});
		c.add(btn);
		setSize(350,150);
		setVisible(true);
	}

	public static void main(String[] args) {
		new EventEx01();
	}
}

2. 클래스 만들기(내부, 외부)

package ch14;

import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;


// 외부 클래스로 리스너 타겟 생성
class MyActionListener implements ActionListener{
	
	@Override
	public void actionPerformed(ActionEvent e) {
		JButton b = (JButton) e.getSource();
		if (b.getText().equals("Action")) {
			b.setText("액션");
		} else {
			b.setText("Action");
		}
		
	}
}

public class EventEx011 extends JFrame {
	
	public EventEx011() {
		setTitle("Action 이벤트 리스너 예제");
		
		// x버튼 클릭시 이벤트 분배스레드 끄기
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		Container c = getContentPane();
		
		c.setLayout(new FlowLayout());
		
		JButton btn = new JButton("Action");
		
		// 리스너 생성
		btn.addActionListener(new MyActionListener());
		c.add(btn);
		setSize(350,150);
		setVisible(true);
	}

	public static void main(String[] args) {
		new EventEx011();
	}
}

3. this

package ch14;

import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;


// 메인 클래스에 ActionListener를 구현하고 this로 객체를 리스너의 타겟으로 만든다
public class EventEx012 extends JFrame implements ActionListener {
	
	public EventEx012() {
		setTitle("Action 이벤트 리스너 예제");
		
		// x버튼 클릭시 이벤트 분배스레드 끄기
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		Container c = getContentPane();
		
		c.setLayout(new FlowLayout());
		
		JButton btn = new JButton("Action");
		
		// 리스너 생성
		btn.addActionListener(this);
		c.add(btn);
		setSize(350,150);
		setVisible(true);
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		System.out.println("버튼 클릭됨");
	}
	
	public static void main(String[] args) {
		EventEx012 ex012 = new EventEx012();
	}
}

-----------------------

Frame

AWT는 아무것도 하지 않으면 프레임만 있는데
SWING은 기본적으로 프레임 안에 패널이 하나 들어가 있다

기본적으로 SWING은 border속성이기때문에 설정을 안해주면 버튼이
화면을 꽉 채운다 

플로우 레이아웃을 생성하고 그 곳에 버튼을 넣으면 아래와 같이 나온다

현재 X버튼을 눌러도 창만 꺼질 뿐 프로그램 자체는 꺼지지 않는 상태이다

X버튼 설정, FlowLayout

WindowBuilder (SWING 대신)

next next accept

COOLSMS 서비스에 가입하고 API 또는 SDK를 사용하여 문자를 보내본다

SDK 중 자바 코드를 다운로드

ZIP파일을 풀어서 IDE의 라이브러리 폴더에 넣고 빌드패스를 해준다

사이트의 EXAMPLE을 보고 복붙하여 조금만 수정하면 사용이 가능하다

package sms;

import java.util.HashMap;
import org.json.simple.JSONObject;
import net.nurigo.java_sdk.api.Message;
import net.nurigo.java_sdk.exceptions.CoolsmsException;

/**
 * @class ExampleSend
 * @brief This sample code demonstrate how to send sms through CoolSMS Rest API PHP
 */

// Message 객체 생성하여 send 메서드 사용하면 됨
public class ExampleSend {
  public static void main(String[] args) {
    String api_key = "";
    String api_secret = "";
    Message coolsms = new Message(api_key, api_secret);

    // 4 params(to, from, type, text) are mandatory. must be filled
    HashMap<String, String> params = new HashMap<String, String>();
    params.put("to", "");
    params.put("from", "");
    params.put("type", "LMS");
    params.put("text", "나의 첫번째 메시지 전송 프로그램 테스트");
    params.put("app_version", "test app 1.2"); // application name and version

    try {
      JSONObject obj = (JSONObject) coolsms.send(params);
      System.out.println(obj.toString());
    } catch (CoolsmsException e) {
      System.out.println(e.getMessage());
      System.out.println(e.getCode());
    }
  }
}

package simple;

public class Stringtest {
	
	// 배열 아님
	String str;
	
	// 스트링 배열
	String[] strArr;
	
	// 스트링을 배열로 저장해서 하나로 출력 동시접근가능
	StringBuilder sb;
	
	// 스트링을 배열로 저장해서 하나로 출력하고 동시접근 불가(임계구역)
	StringBuffer sbf;
}

CLI : 윈도우 cmd창, git창 같은 것

GUI : 그래픽 유저 인터페이스

자바 GUI

AWT
- 버튼과 메뉴 등을 OS의 디자인을 빌려와서 사용
- 운영체제에 따라 화면이 달라진다

SWING
- 자바 자체디자인

X버튼에 대한 기능을 만들지 않았으므로 콘솔창에서 종료해야한다

문제

-- 박지성이 구매한 도서의 출판사와 같은 출판사에서 도서를 구매한 고객의 이름
SELECT DISTINCT C.NAME
FROM customer C, ORDERS O, BOOK B
WHERE c.custid = o.custid 
        AND o.bookid = b.bookid 
        AND b.publisher IN (
                            SELECT b.publisher
                            FROM customer C, ORDERS O, BOOK B
                            WHERE c.custid = o.custid AND o.bookid = b.bookid AND C.NAME = '박지성')
        AND C.NAME NOT LIKE '박지성';


-- 두 개 이상의 서로 다른 출판사에서 도서를 구매한 고객의 이름
SELECT C.NAME, COUNT(DISTINCT b.publisher)
FROM customer C, ORDERS O, BOOK B
WHERE c.custid = o.custid AND o.bookid = b.bookid
GROUP BY C.NAME
HAVING COUNT(DISTINCT b.publisher) >= 2;


-- 두 개 이상의 서로 다른 출판사에서 도서를 구매한 고객의 이름 - 상관쿼리
-- GROUP BY 를 사용한 쿼리는 상관쿼리로 바꿀 수 있다
    SELECT C1.NAME
    FROM customer C1 -- 하위쿼리에 C.NAME LIKE C1.NAME 이렇게 연결하면 GROUP BY를 안쓰고도 그룹함수를 쓸 수 있다.
    WHERE 2 <= (SELECT COUNT(DISTINCT B.PUBLISHER)
                FROM customer C, ORDERS O, BOOK B
                WHERE c.custid = o.custid AND o.bookid = b.bookid AND C.NAME = C1.NAME);


-- 전체 고객의 30% 이상이 구매한 도서
SELECT b.bookname, COUNT(b.bookname)
FROM ORDERS O, BOOK B
WHERE o.bookid = b.bookid
GROUP BY b.bookname
HAVING COUNT(b.bookname) >= (
                            SELECT (COUNT(*) * 0.3)
                            FROM customer
                            );
                        
                        
-- 전체 고객의 30% 이상이 구매한 도서 - 상관쿼리
SELECT B1.BOOKNAME
FROM BOOK B1
WHERE (SELECT COUNT(b.bookname)
        FROM ORDERS O, BOOK B
        WHERE o.bookid = b.bookid AND B.BOOKID = B1.BOOKID) >= ( SELECT (COUNT(*) * 0.3) FROM customer);


--새로운 도서 ('스포츠 세계', '대한미디어', 10000원)이 마당서점에 입고되었다. 삽입이 안될 경우 필요한 데이터가 더 있는지 찾아보자
-- PRIMARY KEY 가 필요함 31로 임의 삽입
INSERT INTO book(BOOKID, BOOKNAME, PUBLISHER, PRICE)
VALUES(31, '스포츠 세계', '대한미디어', 10000);


-- '삼성당'에서 출판한 도서를 삭제해야 한다
DELETE FROM BOOK
WHERE publisher = '삼성당';


-- '이상미디어'에서 출판한 도서를 삭제해야 한다. 삭제가 안 될 경우 원인을 생각해보자
DELETE FROM BOOK
WHERE publisher LIKE '이상미디어'; -- 자식 레코드가 있어서 삭제불가


--출판사 '대한미디어'가 '대한출판사'로 이름을 바꾸었다.
UPDATE book
SET publisher = '대한출판사' -- 값을 넣는것이기 때문에 LIKE쓰면 안된다
WHERE publisher LIKE '대한미디어'; -- 비교하는 것이기 때문에 LIKE써도 된다

-

package ch15;

class MyOuterClass {
	int outerNum = 10;
	
	public MyOuterClass() {
		MyInnerClass mc = new MyInnerClass();
		System.out.println(mc.innerNum);
	}

	class MyInnerClass {
		int innerNum = 20;
	}
}

public class InnerEx01 {
	public static void main(String[] args) {
		MyOuterClass moc = new MyOuterClass();
		MyOuterClass.MyInnerClass d = moc.new MyInnerClass();
	}
}

package Chat;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Vector;

public class MySocketServer {

	ServerSocket serverSocket;
	Vector<NewSocketThread> vt; // 어레이리스트와 비슷하지만 여러곳에서 동시접근 시 queue를 이용하여 순서대로 처리한다

	public MySocketServer() throws Exception {
		vt = new Vector<>(); // 새 벡터 객체 생성

		serverSocket = new ServerSocket(3000);

		while (true) {

			// socket 을 보관해놔야한다 - 메시지 보내야할 소켓을 기억해야 하기 때문
			// 요청을 대기 - 연결이 되면 소켓을 리턴하고 서버소켓에 연결된 선을 끊는다
			Socket socket = serverSocket.accept();
			System.out.println("요청이 들어옴");

			// 스레드를 돌리기 위한 객체 생성(socket을 받는다)
			// 각각 스레드는 자기가 연결해야할 socket을 객체 안에 들고 있게 된다
			NewSocketThread nt = new NewSocketThread(socket);

			// 새 스레드에 nt객체(타겟)을 넣는다
			Thread newWorker = new Thread(nt);

			// 스레드를 실행한다
			newWorker.start();

			// 벡터배열에 nt객체를 추가한다
			vt.add(nt);

		}
	}

	// 딴곳에 쓸일이없이 클래스 내부에서만 쓸거라면 내부클래스 생성
	// 새로운 스레드에게 버퍼를 연결할 수 있게 socket을 전달
	class NewSocketThread implements Runnable {

		Socket socket; // MySocketServer()에서 서버소켓이 받은 소켓을 저장
		BufferedReader br;
		BufferedWriter bw;

		public NewSocketThread(Socket socket) {
			this.socket = socket; // 받은 소켓을 저장
		}

		@Override
		public void run() {
			try {

				// 소켓에서 데이터를 받기 위한 버퍼
				br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

				// 소켓에 데이터를 쓰기 위한 버퍼
				bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

				String msg = "";

				// 버퍼에서 받은 데이터를 msg로 넣고 msg가 null이 아니면 내용을 실행한다
				while ((msg = br.readLine()) != null) {
					System.out.println("클라이언트 : " + msg);

					// 클라이언트들에게 누군가가 보낸 메시지를 다시 보낸다
					for (NewSocketThread newSocketThread : vt) {

						// 메시지를 보낸 당사자를 제외하고 나머지 클라이언트들에게 보낸다
						if (newSocketThread != this) {
							newSocketThread.bw.write(msg + "\n");
							newSocketThread.bw.flush(); // 버퍼를 비우는 것
						}
					}
				}

			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) {

		try {
			new MySocketServer(); // 소켓 서버 가동
		} catch (Exception e) {
			e.printStackTrace();
		}

	}
}

package Chat;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class MySocketClient {
	
	// 소켓 통신을 위한 변수 생성
	Socket socket;

	public MySocketClient() throws Exception {
		
		// 소켓 객체 생성 - ip주소와 포트를 입력한다
		socket = new Socket("192.168.0.85", 3000);
		
		// 서버에서 보낸 데이터를 읽어들이는 쓰레드의 타겟을 생성한다
		ReadThread rt = new ReadThread();
		
		// 타겟을 쓰레드에 넣는다
		Thread newWorker = new Thread(rt);
		
		// 쓰레드 실행
		newWorker.start();
		
		// 소켓에 데이터를 보낼 bw 객체 생성
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

		// 키보드로 받은 데이터를 읽어들일 버퍼 keyboardIn 생성
		BufferedReader keyboardIn = new BufferedReader(new InputStreamReader(System.in));

		String outPutMsg = "";

		// 메인쓰레드는 여기서 무한루프
		while ((outPutMsg = keyboardIn.readLine()) != null) {
			bw.write(outPutMsg + "\n");
			bw.flush();
		}

	}
	
	// 쓰레드 실행을 위한 런 메서드를 포함한 러너블 클래스
	class ReadThread implements Runnable {
		
		@Override
		public void run() {
			try {
				
				BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
				
				String inputMsg = "";
				
				// 상대방이 보낸 데이터를 서버가 이 클라이언트로 보내면 br로 읽어서 실행
				while ((inputMsg = br.readLine()) != null) {
					System.out.println("상대방 : " + inputMsg);
				}
			} catch (Exception e) {
				e.printStackTrace();
			}

		}
	}

	public static void main(String[] args) {
		try {
			new MySocketClient(); // 클라이언트 메서드 실행
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

-

finally

package Chat;

interface StarUnit {
	int getHp();
}

abstract class Protoss implements StarUnit{
	abstract int getSh();
}

abstract class Zerg implements StarUnit {}

class Zealot extends Protoss {
	int sh = 100;
	int hp = 100;
	
	@Override
	public int getSh() {
		return sh;
	}
	
	@Override
	public int getHp() {
		return hp;
	}
}

class Ultra extends Zerg {
	int hp = 100;
	
	@Override
	public int getHp() {
		return hp;
	}
	
}

public class FinallyEx01 {
	
	// 상태체크 (hp, sh)
	static void check(StarUnit unit) {
		try {
			Zealot z = (Zealot)unit;
			System.out.println("쉴드" + z.getSh());			
			System.out.println("체력" + z.getHp());			
		} catch (Exception e) {
			// 저그
			Ultra u = (Ultra)unit;
			System.out.println("저그는 쉴드가 없습니다.");
			System.out.println("남은 체력은 : " + u.getHp());
		} finally { // try 들어가면 무조건 실행된다
			System.out.println("나는 무조건 실행돼");
		}
	}
	
	public static void main(String[] args) {
		check(new Ultra());
	}
}

-

서버소켓 클래스

- 이름만 서버소켓이지 단순한 소켓이다
- 가장 중요한 기능 
0. accept요청을 대기하다가 연결을 받게 된다
1. 새로운 소켓 생성
2. 서버 소켓과 연결된 선을 끊는다 (기존 소켓을 없애는게 아니다?)
3. 새로운 클라이언트 소켓에 연결
4. 다시 accept 요청을 대기

소켓이 만들어 질 때 마다 새로운 스레드가 필요하다

package ch15;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class MySocketServer {
	
	ServerSocket serverSocket;
	Socket socket;
	
	public MySocketServer() {
		try {
			
			serverSocket = new ServerSocket(15000); // 서버 소켓 생성 (연결을 받는)
			socket = serverSocket.accept(); // 요청을 대기 - 연결이 되면 소켓을 리턴하고 서버소켓에 연결된 선을 끊는다

			BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			
			String msg = "";
			while ((msg = br.readLine()) != null) {
				System.out.println("sender : " + msg);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		
	}
}

package ch15;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class MySocketServer {
	
	ServerSocket serverSocket;
	Socket socket;
	BufferedReader br;
	
	public MySocketServer() {
		try {
			
			serverSocket = new ServerSocket(15000); // 서버 소켓 생성 (연결을 받는)
			socket = serverSocket.accept(); // 요청을 대기 - 연결이 되면 소켓을 리턴하고 서버소켓에 연결된 선을 끊는다

			br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			
			String msg = "";
			while ((msg = br.readLine()) != null) {
				System.out.println("sender : " + msg);
			}
			
		} catch (Exception e) { // 소켓연결이 끊기면 catch로 와지면서 while을 벗어나게 된다 
			e.printStackTrace();
		}

		try {
			br.close();
			socket.close();
			serverSocket.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		
	}
}

package ch15;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class MySocketServer {

	ServerSocket serverSocket;
	Socket socket;
	BufferedReader br;

	// throws는 함수의 모든 내용이 try catch가 필요한 경우 사용하면 된다
	public MySocketServer() throws Exception { // throws 는 함수를 호출한 자에게 던지는 것이다

		serverSocket = new ServerSocket(15000); // 서버 소켓 생성 (연결을 받는)
		socket = serverSocket.accept(); // 요청을 대기 - 연결이 되면 소켓을 리턴하고 서버소켓에 연결된 선을 끊는다

		br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

		String msg = "";
		while ((msg = br.readLine()) != null) {
			System.out.println("sender : " + msg);
		}

		br.close();
		socket.close();
		serverSocket.close();
	}

	public static void main(String[] args) {
		
		try { // main이 함수를 호출 했기 때문에 여기서 트라이캐치를 사용
			new MySocketServer();
		} catch (Exception e) {
			// TODO: handle exception
		}
	}
}

package ch15;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class MySocketServer {

	ServerSocket serverSocket;
	Socket socket;
	BufferedReader br;

	// throws는 함수의 모든 내용이 try catch가 필요한 경우 사용하면 된다
	public MySocketServer() throws Exception { // throws 는 함수를 호출한 자에게 던지는 것이다

		serverSocket = new ServerSocket(15000); // 서버 소켓 생성 (연결을 받는)
		socket = serverSocket.accept(); // 요청을 대기 - 연결이 되면 소켓을 리턴하고 서버소켓에 연결된 선을 끊는다
		System.out.println("요청이 들어옴");
		br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

		String msg = "";
		while ((msg = br.readLine()) != null) {
			System.out.println("sender : " + msg);
		}

		br.close();
		socket.close();
		serverSocket.close();
	}

	public static void main(String[] args) {
		
		try { // main이 함수를 호출 했기 때문에 여기서 트라이캐치를 사용
			new MySocketServer();
		} catch (Exception e) {
			// TODO: handle exception
		}
	}
}

package ch15;

import java.io.PrintWriter;
import java.net.Socket;

public class MySocketClient {
	
	Socket socket;
	
	public MySocketClient() throws Exception {
		socket = new Socket("localhost", 15000); // 서버소켓의 accept() 함수를 호출
		//"localhost" 또는 127.0.0.1 는 약속된 내용
		
		PrintWriter pw = new PrintWriter(socket.getOutputStream(), true); // autoFlush기능이 있다
		
	}
	
	public static void main(String[] args) {
		try {
			new MySocketClient();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

package ch15;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class MySocketServer {

	ServerSocket serverSocket; // 서버소켓은 연결요청을 대기하다가 연결이 되면 소켓을 리턴하고 서버소켓에 연결된 선을 끊는다
	Socket socket; // 서버소켓이 리턴한 소켓을 받는 역할
	BufferedReader br; // 스트림이 연결되면 BufferedReader로 데이터를 받는다

	// throws는 함수의 모든 내용이 try catch가 필요한 경우 사용하면 된다
	public MySocketServer() throws Exception { // throws 는 함수를 호출한 자(여기서는 main)에게 던지는 것이다

		serverSocket = new ServerSocket(15000); // 서버 소켓 생성 (연결을 받는)
		socket = serverSocket.accept(); // 요청을 대기 - 연결이 되면 소켓을 리턴하고 서버소켓에 연결된 선을 끊는다
		System.out.println("요청이 들어옴");
		br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

		String msg = "";
		while ((msg = br.readLine()) != null) { // br로 데이터를 받고 msg에 넣은 후 null값인지 확인한다
			System.out.println("상대방 : " + msg); // 받은 메시지를 출력한다
		}

		// 사용이 끝난 인스턴스를 닫는다
		br.close();
		socket.close();
		serverSocket.close();
	}

	public static void main(String[] args) {
		
		try { // main이 함수를 호출 했기 때문에 여기서 트라이캐치를 사용
			new MySocketServer(); // 소켓서버 가동 메서드 실행;
		} catch (Exception e) {}
	}
}

package ch15;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class MySocketClient {
	
	Socket socket; // 소켓 생성
	BufferedReader br; // 키보드로 내가 입력한 메시지를 받기위한 br
	BufferedWriter bw; // 내가 입력한 메시지를 소켓으로 보내기 위한 bw 
	
	public MySocketClient() throws Exception {
		
		//스트림
		//"localhost" 또는 127.0.0.1 는 약속된 내용 - 내 컴퓨터의 내부 주소
		socket = new Socket("192.168.0.115", 15000); // 서버소켓의 accept() 함수를 호출
		
		// 소켓 - 버퍼드라이터 연결
		bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
		
		// 키보드 - 버퍼드리더 연결
		br = new BufferedReader(new InputStreamReader(System.in));
		
		String msg = "";
		
		// 키보드로 입력한 메시지를 확인하여 null이 아니면 bw에 적고 flush
		while ((msg = br.readLine()) != null) {
			bw.write(msg + "\n"); // "\n"은 상대방 소켓에서 읽어들이기 위해서 필요한 것이라 넣은 것
			System.out.println("내 메시지 : " + msg);
			bw.flush(); // 버퍼는 꽉차지 않으면 플러시 되지 않기 때문에 수동으로 플러시 시켜준다
		}
		
		// 인스턴스 닫기
		bw.close();
		br.close();
		socket.close();
		
	}
	
	public static void main(String[] args) {
		try {
			new MySocketClient(); // 클라이언트 메서드 실행
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}