클래스라는 개념을 이해하기 위한 예제 입니다.

흔히 객체지향 언어에서는 객체와 클래스라는 개념을 많이 사용하게 되는데,

그중 클래스에 대해서 간단하게 설명을 해볼까 합니다.

클래스는 쉽게 생각하여 데이터를 담아놓는 형태 또는 틀이라고 생각하면 됩니다.

아래 소스는 Student 소스 입니다.

Student.java

class Student
{
	public static void main( String[] args )
	{
		StudentForm s1 = new StudentForm();
		StudentForm s2 = new StudentForm();
		StudentForm s3 = new StudentForm();

		s1.setName( "철수" );
		s1.setAge( 20 );

		s2.setName( "영희" );
		s2.setAge( 30 );

		s3.setName( "길동" );
		s3.setAge( 40 );

		System.out.println( s1.getName() + " : " + s1.getAge() );
		System.out.println( s2.getName() + " : " + s2.getAge() );
		System.out.println( s3.getName() + " : " + s3.getAge() );
	}
}

Student 라는 클래스 에선 StudentForm 이라는 클래스를 선언하여 사용합니다.

그러면 StudentForm 클래스는 어떻게 생겼는지 살펴보겠습니다.

StudentForm.java

class StudentForm
{
	private String name;
	private int age;

	public String getName()
	{
		return name;
	}

	public int getAge()
	{
		return age;
	}

	public void setName( String name )
	{
		this.name = name;
	}

	public void setAge( int age )
	{
		this.age = age;
	}
}

StudentForm 은 매우 간단하게 생겼습니다.

StudentForm 안에 데이터로는 name, age 두개를 가지게 되며,

StudentForm 클래스로 생성되는 아이들에게는 모두 name 과 age 2개의 변수를 가지게 됩니다.

Student 에서 만들어진

StudentForm 타입의 s1, s2, s3 는 setName, setAge 로 인해서

각각의 다른 값을 가지게 되며,

getName, getAge 를 할때또한 각각의 값을 가져오게 됩니다.

1. 우선 5 x 5 크기의 빙고판에 1부터 25까지 숫자를 순서대로 넣는다.

2. 넣어져 있는 배열의 숫자를 마구 섞는다.

class Bingo
{
	private static int[][] arr = new int[5][5];

	public static void main( String args[] )
	{
		generate();
		swap( 50 );
		print();
	}

	private static void generate()
	{
		int cnt = 1;

		for( int i = 0; i < 5; i++ )
			for( int j = 0; j < 5; j++ )
				arr[i][j] = cnt++;
	}

	private static void swap( int shuffle )
	{
		int[] s = new int[4];
		int temp;

		for( int j = 0; j < shuffle; j++ )
		{
			for( int i = 0; i < 4; i++ )
				s[i] = rand();

			// Swap
			temp = arr[s[0]][s[1]];
			arr[s[0]][s[1]] = arr[s[2]][s[3]];
			arr[s[2]][s[3]] = temp;
		}
	}

	private static void print()
	{
		for( int i = 0; i < 5; i++ )
		{
			for( int j = 0; j < 5; j++ )
				System.out.print( arr[i][j] + "\t" );
			System.out.println();
		}
	}

	private static int rand()
	{
		return (int)( Math.random() * 5 );
	}
}

자바로 야구 게임을 만들어 보았다.

발로 짰다..;

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Baseball
{
	private static int[] arr = new int[3];
	private static int[] answer = new int[3];
	private static int strike = 0;
	private static int ball = 0;
	private static int out = 0;

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

	public static void start()
	{
		while( true )
		{
			answer();
			input();
			check();
			print();
		}
	}

	public static void answer()
	{
		boolean flag = true;

		while( flag )
		{
			for( int j = 0; j < 3; j++ )
				for( int k = 0; k < 3; k++ )
					if( j != k && answer[j] == answer[k] )
						for( int i = 0; i < 3; i++ )
							answer[i] = (int)( Math.random() * 9 + 1 );
					else
						flag = false;
		}

		System.out.println( "\n\nAnswer : " + answer[0] + answer[1] + answer[2] + "\n" );
	}

	public static void input()
	{
		String inputStr = "";
		int inputNum = 0;

		BufferedReader in = new BufferedReader( new InputStreamReader( System.in ) );

		System.out.print( "input num : " );

		boolean input = true;
		while( input )
		{
			try
			{
				inputStr = in.readLine();
				inputStr = inputStr.replaceAll( " ", "" );
				inputNum = Integer.parseInt( inputStr );
				input = false;
			}
			catch( Exception e )
			{
				System.out.println( "Only Number.." );
			}
		}

		arr[0] = inputNum / 100;
		inputNum -= arr[0] * 100;
		arr[1] = inputNum / 10;
		inputNum -= arr[1] * 10;
		arr[2] = inputNum;
	}

	public static void check()
	{
		for( int i = 0; i < 3; i++ )
		{
			if( arr[i] == answer[i] )
				strike++;

			for( int k = 0; k < 3; k++ )
				if( i != k && arr[i] == answer[k] )
					ball++;
		}
		if( strike == 0 && ball == 0 )
			out++;
	}

	public static void print()
	{
		System.out.println( "Strike : " + strike );
		System.out.println( "Ball   : " + ball );
		System.out.println( "Out    : " + out );

		if( strike == 3 )
		{
			System.out.println( "\n\n############ Game Success ############" );
			System.exit( 1 );
		}
		else if( out == 10 )
		{
			System.out.println( "\n\n############ Game Failed ############" );
			System.exit( 1 );
		}
		strike = 0;
		ball = 0;
	}
}

오라클 디비 연결 예제

import java.sql.*;
import java.util.Scanner;

class OracleConnectSample
{
	public static void main( String[] args )
	{
		Connection conn = null;
		Statement stmt = null;
		ResultSet rs = null;

		try
		{
			Class.forName( "oracle.jdbc.driver.OracleDriver" );
			conn = DriverManager.getConnection( "jdbc:oracle:thin:@localhost:1521:orcl", "id", "pw" );
			stmt = conn.createStatement();
			rs = stmt.executeQuery( "SELECT * from CUST_PROD" );

			while( rs.next() )
			{
				String custId = rs.getString( "CUST_ID" );
				String prodCd = rs.getString( "PROD_CD" );
				int principal = rs.getInt( "PRINCIPAL" );
				String purchaseDay = rs.getString( "PURCHASE_DAY" );
				int term = rs.getInt( "TERM" );
			}
		}
		catch( SQLException sqle )
		{
			System.out.println( sqle.getMessage() );
		}
		catch( ClassNotFoundException cnfe )
		{
			System.out.println( cnfe.getMessage() );
		}

		finally
		{
			try
			{
				rs.close();
				stmt.close();
				conn.close();
			}
			catch( Exception ignoled )
			{
			}
		}
	}
}

소켓 프로그래밍 - Server & Client + Thread + 접속자 수 제한 예제
 
※ 최대 접속자 설정 가능
 
※ 최대 접속자 이상 접속시 메세지 출력후 Kick
 
※ 발코딩

Client.java

import java.io.*;
import java.net.*;
import java.util.Properties;

public class Client
{
	static Properties property = new Properties();
	static FileInputStream fis;

	public static void main( String args[] ) throws IOException
	{
		BufferedReader in = new BufferedReader( new InputStreamReader( System.in ) );
		// Properties
		try
		{
			fis = new FileInputStream( "Client.properties" );
			property = new Properties();
			property.load( fis );
		}
		catch( Exception e )
		{
			System.out.println( "!! Property FileInputStream Error !!" );
		}
		int port = Integer.parseInt( property.getProperty( "cl.port" ) );
		// END Properties

		// Constructor
		Socket socket = null;
		String recv_str = null;
		String send_str = null;
		String thread_name = null;
		String ip = "127.0.0.1"; // Server IP
		// END Constructor

		try
		{
			socket = new Socket( ip, port );
			System.out.println( "-- Server Connect --" );
		}
		catch( Exception e )
		{
			System.out.println( "-- Server COnnect Error --" );
		}

		DataInputStream read = new DataInputStream( socket.getInputStream() );
		DataOutputStream write = new DataOutputStream( socket.getOutputStream() );

		try
		{
			while( true )
			{
				recv_str = read.readUTF();

				if( recv_str.equals( "Bye" ) )
				{
					in.close();
					read.close();
					write.close();
					socket.close();

					System.out.println( "!! MAX CLIENT Bye Bye !!" );
					System.exit( 1 );
				}
				else if( recv_str.equals( "Client Start" ) )
				{
					recv_str = read.readUTF();
					thread_name = recv_str;
					// System.out.println("-- Connect " + recv_str + " --");
					recv_str = "";
				}
				System.out.print( thread_name + " Send : " );
				send_str = in.readLine();
				// /////////////////////////

				// send_str.replaceAll("++", "+");
				send_str = send_str.replaceAll( "++", "+" );
				System.out.println( "ss : " + send_str );

				// /////////////////////////
				write.writeUTF( send_str );
				recv_str = read.readUTF();
				System.out.println( "Server Answer : " + recv_str );

				if( send_str.equals( "quit" ) || send_str.equals( "exit" ) )
				{
					System.out.println( "\n-- Client Good Disconnect --" );
					socket.close();
					break;
				}
			}
		}
		catch( Exception e )
		{
			in.close();
			read.close();
			write.close();
			socket.close();
			System.out.println( "\n\n-- Client Bad Disconnect --\n" );
		}
	}
}

Server.java

import java.io.*;
import java.io.ObjectInputStream.GetField;
import java.net.*;
import java.util.Properties;
import bsh.*;

public class Server implements Runnable
{
	// Constructor Setting
	String send_str = null;
	String recv_str = null;
	String sys_msg = null;
	public Socket accept = null;
	public ServerSocket serverSocket = null;
	DataInputStream read = null;
	DataOutputStream write = null;
	// END Constructor Setting

	// Properties Constructor Setting
	static Properties property = new Properties();
	static FileInputStream fis;
	// END Properties Constructor
	// Setting-----------------------------------------------------------------------------------

	// Environment Valuable Setting
	static int MAX_CLIENT; // Client MAX Connect
	static int count; // Thread Count
	static int port; // Server Port Setting

	// END Environment Valuable Setting

	public static void main( String args[] ) throws IOException
	{
		// Properties
		try
		{
			fis = new FileInputStream( "Server.properties" );
			property = new Properties();
			property.load( fis );
		}
		catch( Exception e )
		{
			System.out.println( "!! Property FileInputStream Error !!" );
		}
		MAX_CLIENT = Integer.parseInt( property.getProperty( "sv.MAX_CLIENT" ) );
		port = Integer.parseInt( property.getProperty( "sv.port" ) );
		// END Properties

		try
		{
			ServerSocket serverSocket = new ServerSocket( port );
			Server Server_Copy;
			System.out.println( "-- Server Running --" );
			while( true )
			{
				// Server Status
				count = Thread.activeCount() - 1; // Thread Count

				// END Server Status
				Server_Copy = new Server();
				Server_Copy.serverSocket = serverSocket;
				Server_Copy.accept = serverSocket.accept();
				Thread Thread_Copy = new Thread( Server_Copy );
				Thread_Copy.start();
			}
		}
		catch( Exception e )
		{
			e.printStackTrace();
		}
	} // END main

	@SuppressWarnings( "deprecation" )
	public void run()
	{
		while( true )
		{ // while (1)
			try
			{
				System.out.println( "-- Waiting Client --" );
				System.out.println( "-- Client Connect : " + accept.getInetAddress().getHostName() + " --" );
			}
			catch( Exception e )
			{
				System.out.println( "!! ServerSocket Accept Error !!" );
			}

			try
			{
				read = new DataInputStream( accept.getInputStream() ); // read
																	   // stream
																	   // connect
				write = new DataOutputStream( accept.getOutputStream() ); // write
																		  // stream
																		  // connect
			}
			catch( Exception e )
			{

			}

			// MAX Client Check
			System.out.println( "MAX_CLIENT = " + MAX_CLIENT + " count = " + count );
			if( MAX_CLIENT + 1 <= count )
			{
				System.out.println( "!! MAX Client Close !!" );
				try
				{
					sys_msg = "Bye";
					write.writeUTF( sys_msg );
					accept.close();
					Thread.currentThread().stop();
				}
				catch( Exception e )
				{
					System.out.println( "!! MAX Client Close Error !!" );
				}
				break;
			}
			// END MAX Client Check

			while( true )
			{ // while (2)
				try
				{
					sys_msg = "Client Start";
					write.writeUTF( sys_msg );
					write.writeUTF( Thread.currentThread().getName() );
				}
				catch( Exception e )
				{

				}
				try
				{
					recv_str = read.readUTF();

					if( recv_str.equals( "exit" ) || recv_str.equals( "quit" ) )
					{
						read.close();
						write.close();
						accept.close();
						break;
					}
					else
					{
						// Receive String
						System.out.println( Thread.currentThread().getName() + " Say : " + recv_str );
						System.out.println( "-- Server Answer Send --" );
						try
						{

							// External Class (BeanShell) Load
							Interpreter inter = new Interpreter();
							write.writeUTF( inter.eval( recv_str ).toString() );
							// END External Class (BeanShell) Load

						}
						catch( Exception ee )
						{
							System.out.println( "!! Result Send Error !!" );
						}
					}

				}
				catch( IOException e )
				{
					System.out.println( "!! Client Disconnect !!" );
					try
					{
						read.close();
						write.close();
						accept.close();
						break;
					}
					catch( Exception ee )
					{
						System.out.println( "!! Server Close Error !!" );
						break;
					}
				}
			} // END while (2)
			new Thread( this ).stop();
			break;
		} // END while (1)
	} // END run
} // END server class

클라이언트에서 1+2를 보내면
 
서버에서 연산하여 결과를 보내줌
 
※ 두번째 예제라 발코딩함
 
※ 스레드로 다중 접속 가능(19개 제한)

Q1_Client.java

import java.io.*;
import java.net.*;

public class Q1_Client
{
	public static void main( String args[] ) throws IOException
	{
		BufferedReader in = new BufferedReader( new InputStreamReader( System.in ) );

		Socket sock = null; // 접속할 소켓
		DataInputStream read; // READ 스트림
		DataOutputStream write; // WRITE 스트림

		// int recv_int; // 서버로부터 받을 변수값
		String send_str = "", recv_str = ""; // 서버에게 보낼 문자열

		try
		{
			sock = new Socket( "127.0.0.1", 60000 );
			// 소켓과 스트림결합
			read = new DataInputStream( sock.getInputStream() ); // READ STREAM
																 // 연결
			write = new DataOutputStream( sock.getOutputStream() ); // WRITE
																	// STREAM 연결

			System.out.println( "*************** 접속성공! ***************" );

			// 서버로부터 정수형 값을 받는과정
			// recv_int = read.readInt();
			// System.out.println("서버왈 : " + recv_int);

			while( true )
			{
				// 서버에게 문자열 값을 전달하는과정
				System.out.print( "연산식 : " );
				send_str = in.readLine();

				try
				{
					write.writeUTF( send_str );
				}
				catch( Exception e )
				{
				}
				// 결과 받기
				try
				{
					recv_str = read.readUTF();
				}
				catch( Exception e )
				{

				}
				System.out.println( "결과값 : " + recv_str );
			}
		}
		catch( IOException e )
		{
			e.printStackTrace();
		}
	}
}

Q1_Server.java

import java.io.*;
import java.net.*;

public class Q1_Server implements Runnable
{

	public static void main( String args[] ) throws IOException
	{
		ServerSocket serverSock = new ServerSocket( 60000 );
		System.out.println( "클라이언트의 접속을 기다리기 시작합니다." );
		for( int i = 0; i < 19; i++ )
		{
			new Connection( serverSock );
		}
	}

	static class Connection extends Thread
	{
		private ServerSocket serverSock;

		public Connection( ServerSocket serverSock )
		{
			this.serverSock = serverSock;
			start();
		}

		public void run()
		{
			// ServerSocket serverSock = null;
			Socket acp_sock = null;
			String recv_str = null;
			double digit1 = 0, digit2 = 0;
			String result = "";

			try
			{
				// System.out.println("클라이언트의 접속을 기다리기 시작합니다.");
				while( true )
				{
					acp_sock = serverSock.accept(); // 접속수락 소켓

					// 스트림을 소켓과 결합
					DataInputStream read = new DataInputStream( acp_sock.getInputStream() ); // READ
																							 // STREAM
																							 // 연결
					DataOutputStream write = new DataOutputStream( acp_sock.getOutputStream() ); // WRITE
																								 // STREAM
																								 // 연결
					System.out.println( "클라이언트 접속: " + acp_sock.getInetAddress().getHostName() );

					System.out.println( "클라이언트로부터 응답을 기다립니다." );

					while( true )
					{
						// 클라이언트로부터 STRING형 정보를 받는과정
						try
						{
							recv_str = read.readUTF();
						}
						catch( Exception e )
						{
							// recv_str 값이 null일때 접속 종료
							System.out.println( "*************** 접속종료 ***************" );
							break;
						}

						System.out.println( "클라이언트에서 온 메세지 : " + recv_str );
						// /////////////////////
						try
						{
							if( recv_str.indexOf( "+" ) != -1 )
							{
								digit1 = Integer.parseInt( recv_str.substring( 0, recv_str.indexOf( "+" ) ).trim() );
								digit2 = Integer.parseInt( recv_str.substring( recv_str.indexOf( "+" ) + 1, recv_str.length() ).trim() );
								result = digit1 + " + " + digit2 + " = " + ( digit1 + digit2 );
							}
							else if( recv_str.indexOf( "-" ) != -1 )
							{
								digit1 = Integer.parseInt( recv_str.substring( 0, recv_str.indexOf( "-" ) ).trim() );
								digit2 = Integer.parseInt( recv_str.substring( recv_str.indexOf( "-" ) + 1, recv_str.length() ).trim() );
								result = digit1 + " - " + digit2 + " = " + ( digit1 - digit2 );

							}
							else if( recv_str.indexOf( "/" ) != -1 )
							{
								digit1 = Integer.parseInt( recv_str.substring( 0, recv_str.indexOf( "/" ) ).trim() );
								digit2 = Integer.parseInt( recv_str.substring( recv_str.indexOf( "/" ) + 1, recv_str.length() ).trim() );
								// 0으로 나눌 수 없음
								if( digit2 == 0 )
								{
									result = "에러 \"0으로 나눌수 없습니다\"";
								}
								else
								{
									result = digit1 + " / " + digit2 + " = " + ( digit1 / digit2 );
								}

							}
							else if( recv_str.indexOf( "*" ) != -1 )
							{
								digit1 = Integer.parseInt( recv_str.substring( 0, recv_str.indexOf( "*" ) ).trim() );
								digit2 = Integer.parseInt( recv_str.substring( recv_str.indexOf( "*" ) + 1, recv_str.length() ).trim() );
								result = digit1 + " * " + digit2 + " = " + ( digit1 * digit2 );
							}
							else if( recv_str.indexOf( "+" ) == -1 || recv_str.indexOf( "-" ) == -1 || recv_str.indexOf( "*" ) == -1
							        || recv_str.indexOf( "/" ) == -1 )
							{
								result = "연산식이 없습니다.";
							}
						}
						catch( Exception e )
						{
							result = "연산식에 오류가 있습니다.";
						}
						// /////////////////////

						try
						{
							write.writeUTF( result );
						}
						catch( Exception e )
						{
							// System.out.println("3333333");
						}
					}
				}
			}
			catch( IOException e )
			{
				e.printStackTrace();
			}
			finally
			{
				// acp_sock.close();
			}
		}
	}

	@Override
	public void run()
	{
		// TODO Auto-generated method stub

	}
}

클라이언트에서 1 + 2 를 보내면

서버에서 처리후 결과를 보내어 줌.

Q1_Client.java

import java.io.*;
import java.net.*;

public class Q1_Client
{
	public static void main( String args[] ) throws IOException
	{
		BufferedReader in = new BufferedReader( new InputStreamReader( System.in ) );

		Socket sock = null; // 접속할 소켓
		DataInputStream read; // READ 스트림
		DataOutputStream write; // WRITE 스트림

		// int recv_int; // 서버로부터 받을 변수값
		String send_str = "", recv_str = ""; // 서버에게 보낼 문자열

		try
		{
			sock = new Socket( "127.0.0.1", 60000 );
			// 소켓과 스트림결합
			read = new DataInputStream( sock.getInputStream() ); // READ STREAM
																 // 연결
			write = new DataOutputStream( sock.getOutputStream() ); // WRITE
																	// STREAM 연결

			System.out.println( "*************** 접속성공! ***************" );

			// 서버로부터 정수형 값을 받는과정
			// recv_int = read.readInt();
			// System.out.println("서버왈 : " + recv_int);

			while( true )
			{
				// 서버에게 문자열 값을 전달하는과정
				System.out.print( "연산식 : " );
				send_str = in.readLine();

				try
				{
					write.writeUTF( send_str );
				}
				catch( Exception e )
				{
				}
				// 결과 받기
				try
				{
					recv_str = read.readUTF();
				}
				catch( Exception e )
				{

				}
				System.out.println( "결과값 : " + recv_str );
			}
		}
		catch( IOException e )
		{
			e.printStackTrace();
		}
	}
}

Q1_Server.java

import java.net.*;
import java.io.*;

public class Q1_Server
{
	public static void main( String args[] ) throws IOException
	{
		ServerSocket serv_sock;
		Socket acp_sock = null;
		DataInputStream read;
		DataOutputStream write;
		String recv_str = null;
		double digit1 = 0, digit2 = 0;
		String result = "";

		try
		{
			serv_sock = new ServerSocket( 60000, 10 );
			// System.out.println("클라이언트의 접속을 기다리기 시작합니다.");
			while( true )
			{
				System.out.println( "클라이언트의 접속을 기다리기 시작합니다." );
				acp_sock = serv_sock.accept(); // 접속수락 소켓

				// 스트림을 소켓과 결합
				read = new DataInputStream( acp_sock.getInputStream() ); // READ
																		 // STREAM
																		 // 연결
				write = new DataOutputStream( acp_sock.getOutputStream() ); // WRITE
																			// STREAM
																			// 연결
				System.out.println( "클라이언트 접속: " + acp_sock.getInetAddress().getHostName() );
				System.out.println( "클라이언트로부터 응답을 기다립니다." );

				while( true )
				{
					// 클라이언트로부터 STRING형 정보를 받는과정
					try
					{
						recv_str = read.readUTF();
					}
					catch( Exception e )
					{
						// recv_str 값이 null일때 접속 종료
						System.out.println( "*************** 접속종료 ***************" );
						break;
					}

					System.out.println( "클라이언트에서 온 메세지 : " + recv_str );
					// /////////////////////
					try
					{
						if( recv_str.indexOf( "+" ) != -1 )
						{
							digit1 = Integer.parseInt( recv_str.substring( 0, recv_str.indexOf( "+" ) ).trim() );
							digit2 = Integer.parseInt( recv_str.substring( recv_str.indexOf( "+" ) + 1, recv_str.length() ).trim() );
							result = digit1 + " + " + digit2 + " = " + ( digit1 + digit2 );
						}
						else if( recv_str.indexOf( "-" ) != -1 )
						{
							digit1 = Integer.parseInt( recv_str.substring( 0, recv_str.indexOf( "-" ) ).trim() );
							digit2 = Integer.parseInt( recv_str.substring( recv_str.indexOf( "-" ) + 1, recv_str.length() ).trim() );
							result = digit1 + " - " + digit2 + " = " + ( digit1 - digit2 );

						}
						else if( recv_str.indexOf( "/" ) != -1 )
						{
							digit1 = Integer.parseInt( recv_str.substring( 0, recv_str.indexOf( "/" ) ).trim() );
							digit2 = Integer.parseInt( recv_str.substring( recv_str.indexOf( "/" ) + 1, recv_str.length() ).trim() );
							// 0으로 나눌 수 없음
							if( digit2 == 0 )
							{
								result = "에러 \"0으로 나눌수 없습니다\"";
							}
							else
							{
								result = digit1 + " / " + digit2 + " = " + ( digit1 / digit2 );
							}

						}
						else if( recv_str.indexOf( "*" ) != -1 )
						{
							digit1 = Integer.parseInt( recv_str.substring( 0, recv_str.indexOf( "*" ) ).trim() );
							digit2 = Integer.parseInt( recv_str.substring( recv_str.indexOf( "*" ) + 1, recv_str.length() ).trim() );
							result = digit1 + " * " + digit2 + " = " + ( digit1 * digit2 );
						}
						else if( recv_str.indexOf( "+" ) == -1 || recv_str.indexOf( "-" ) == -1 || recv_str.indexOf( "*" ) == -1
						        || recv_str.indexOf( "/" ) == -1 )
						{
							result = "연산식이 없습니다.";
						}
					}
					catch( Exception e )
					{
						result = "연산식에 오류가 있습니다.";
					}
					// /////////////////////

					try
					{
						write.writeUTF( result );
					}
					catch( Exception e )
					{

					}
				}
			}
		}
		catch( IOException e )
		{
			e.printStackTrace();
		}
		finally
		{
			acp_sock.close();
		}
	}
}