이전의 Java 포스팅을 이어가야하는데.. 하면서 깜빡깜빡하네요. 조만간 이어가도록 하겠습니다.

여튼 이번엔 프로그래머나 개발자라면 기본적으로 다루게 될 Java API와 관련하여 자신의 Local에서 Socket을 이용한 서버와 클라이언트의 Data를 주고받는 부분을 살펴보려 합니다.


[SocketServer.java]

/**
* Created by 진우 on 2016-07-09.
*/
public class SocketServer {
public static void main(String[] args) {
SocketServer serv = new SocketServer();
serv.startServer();
}

public void startServer() {
ServerSocket sockserv = null;
Socket sockcli = null;

try {
sockserv = new ServerSocket(9629);
while(true) {
System.out.println("Server is waiting for request.");

sockcli = sockserv.accept();
System.out.println("Server Socket is Accepted!");

InputStream stream = sockcli.getInputStream();
BufferedReader in = new BufferedReader(new InputStreamReader(stream));
String data = null;
StringBuilder receiveData = new StringBuilder();
while((data = in.readLine()) != null) {
receiveData.append(data);
}
System.out.println("Receive Data :"+receiveData);
in.close();
stream.close();
sockcli.close();
if(receiveData.toString().equals("End of TEST")) {
System.out.println("Stop Socket Server!");
break;
}
System.out.println("------");
}
} catch(Exception e) {
e.printStackTrace();
} finally {
if(sockserv != null) {
try {
sockserv.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}


먼저 서버에서는 Socket을 서버, 클라이언트용으로 두 개 만들어줍니다.

그리고 StartServer() 에서 포트를 9629로 하여 로컬에서 실행되도록 합니다.

while(true)문을 이용하여 Client로부터 End of Test 라는 메시지가 올 때까지 계속 실행되도록 합니다.

socket accept를 통해 클라이언트로부터 data를 받아들이고, data가 null일 때까지 계속 while문으로 받아서 receiveData에 append해줍니다.

그리고 다 받아서 while문을 빠져나오면, socket과 stream을 close 해주어 마무리해줍니다.


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

[SocketClient.java]

/**
* Created by 진우 on 2016-07-09.
*/
public class SocketClient {
public static void main(String[] args) {
SocketClient cli = new SocketClient();
cli.sendSocket();
}

public void sendSocket() {
for(int loop = 1; loop <= 5; loop++) {
sendSocketData("Just Test Client - Server (" + loop + ")");
}
sendSocketData("End of TEST");
}

public void sendSocketData(String data) {
Socket sock = null;
try {
System.out.println("Client is Connecting");

sock = new Socket("127.0.0.1", 9629);
System.out.println("Client:Connect status = "+sock.isConnected());
Thread.sleep(1500);
OutputStream stream = sock.getOutputStream();
BufferedOutputStream out = new BufferedOutputStream(stream);
byte[] bytes = data.getBytes();
out.write(bytes);

System.out.println("Client:Send data");
out.close();

} catch(Exception e) {
e.printStackTrace();
} finally {
if(sock != null) {
try {
sock.close();
} catch(Exception e) {
e.printStackTrace();
}
}
}
}
}


Client에서는 for문을 이용하여 서버에 5번 Data를 보내게 됩니다. 그리고 마지막으로 End of Test 라는 메시지를 보내어 서버가 이 메시지를 받았을 때 종료되도록 합니다.

sendSocketData()에서는 Socket을 생성하여 Local서버(127.0.0.1)에 9629포트에 보내도록 하고, Socket의 현재 상태(연결 되어 있는지 - sock.isConnected() 이용) 를 Client에서 출력해줍시다.

간격은 Thread를 이용하여 1.5초(1500mllis)로 하고, OutputStream을 이용하여 서버에 data를 보내줍니다.

그 후, client에서 Send data 메시지를 출력해 준 후, stream을 닫아줍니다.


network통신에서는 try - catch 문을 꼭 이용하여 Exception이 발생 했을 시를 체크해줍시다.



원래 Eclipse를 애용했었는데 요즘은 시대에 맞게 Intellij를 되도록 사용하려 합니다.

아직은 조금 서툰부분도 많습니다만 빨리 적응해야겠습니다.


WRITTEN BY
SiriusJ

,

접근 제한자는 public, protected, default, private 와 같이 네 가지 종류가 있습니다.


public 접근 제한자 외부 클래스가 자유롭게 사용할 수 있는 공개 멤버를 만듭니다.

protected 접근 제한자는 같은 패키지 또는 자식클래스에서 사용 할 수 있는 멤버를 만듭니다.

private 접근 제한자는 단어의 뜻 그대로 개인적인 것이라 외부에 노출되지 않는 멤버를 만듭니다

-> 위 세 가지 접근 제한자가 적용되지 않은 멤버는 default 접근 제한을 가지게 됩니다.

default 접근 제한자는 같은 패키지에 소속된 클래스에서만 사용할 수 있는 멤버를 만듭니다.


접근 제한 

적용 대상 

접근할 수 없는 클래스 

 public

클래스, 필드, 생성자, 메소드 

없음 

 protected

필드, 생성자, 메소드 

자식 클래스가 아닌 다른 패키지에 소속된 클래스 

 default

클래스, 필드, 생성자, 메소드 

다른 패키지에 소속된 클래스 

 private

필드, 생성자, 메소드 

모든 외부 클래스 


[클래스의 접근 제한]

클래스를 선언 시, 고려사항은 같은 패키지 내에서만 사용할 것인지, 다른 패키지에서도 사용할 수 있도록 할것인지를 결정하는 것입니다.

클래스에 적용할 수 있는 접근제한은 public 과 , default 단 두가지입니다.


예시)

//(1) default 접근 제한

class 클래스 { ... }

//(2) public 접근 제한

public class 클래스 { ... }


(1)

class A { }

class B { }

=> (1) 의 경우에는 같은 패키지 내에서는 A클래스와 B 클래스가 아무 제한 없이 사용할 수 있지만, 다른 패키지에서는 사용할 수 없도록 제한됩니다.

(2)

public class C { }

class D { }

==> (2) 의 경우에는 클래스를 선언 시, public 접근 제한자를 붙였다면 클래스는 public 접근 제한을 가지게 되고, 다른 패키지에서도 자유롭게 사용할 수 있습니다.

인터넷으로 배포되는 라이브러리 클래스들도 모두 public 접근 제한을 가지고 있습니다.


[생성자의 접근 제한]

객체를 생성하기 위해서는 new 연산자로 생성자를 호출해야 합니다. 하지만 생성자 또한 어디에서나 호출할 수 있는 것은 아닙니다. 생성자가 어떤 접근 제한을 갖느냐에 따라 호출가능 여부가 결정됩니다.

생성자는 public, protected, default, private 접근제한을 가질 수 있습니다.

ex)

public class ClassName {

public ClassName( ... ) { ... }

protected ClassName( ... ) { ... }

ClassName( ... ) { ... }

privaet ClassName( ... ) { ... }

}

접근 제한자 

생성자 

명 

 public

클래스( ... ) 

public 접근 제한은 모든 패키지에서 아무런 제한 없이 생성자를 호출할 수 있도록 합니다. 생성자가 public 접근 제한을 가진다면 클래스도 public 접근 제한을 가지는 것이 정상적입니다. 클래스가 default 접근 제한을 가진다면 클래스 사용이 같은 패키지로 한정되므로, 비록 생성자가 public 접근 제한을 가지더라도 같은 패키지에서만 생성자를 호출할 수 있습니다. 

 protected

클래스 ( ... ) 

protected 접근 제한은 default 접근 제한과 마찬가지로 같은 패키지에 속하는 클래스에서 생성자를 호출할 수 있도록 합니다. 차이점은 다른 패키지에 속한 클래스가 해당 클래스의 자식(child)클래스라면 생성자를 호출할 수 있습니다. 

 default

클래스 ( ... ) 

생성자를 선언할 때 public 또는 private 를 생략 했다면 생성자는 default 접근 제한을 가집니다. default 접근 제한은 같은 패키지에서는 아무런 제한 없이 생성자를 호출할 수 있으나, 다른 패키지에서는 생성자를 호출할 수 없도록 합니다. 

 private

클래스 ( ... ) 

private 접근 제한은 동일 패키지이건 다른 패키지이건 상관없이 생성자를 호출하지 못하도록 제한합니다. 즉, 클래스 외부에서 new 연산자로 객체를 만들 수 없습니다. 오로지 클래스 내부에서만 생성자를 호출할 수 있고, 객체를 만들 수 있습니다. 


[필드와 메소드의 접근 제한]

필드와 메소드를 선언할 때 고려사항은 클래스 내부에서만 사용할 것인지, 패키지 내에서만 사용할지 다른패키지에서도 사용할지를 결정해야 합니다. 이것은 필드와 메소드가 어떤 접근 제한을 갖느냐에 따라 결정됩니다.

필드와 메소드는 다음과 같이 public, protected, default, private 접근 제한을 가질 수 있습니다.

예시)

//필드 선언

[ public | protected | private ] [static] 타입 필드;

//메소드 선언

[ public | protected | private ] [static] 리턴 타입 메소드( ... ) { ... }

 접근 제한자

생성자 

명 

 public

필드

메소드 ( ... ) 

public 접근 제한은 모든 패키지에서 아무런 제한 없이 필드와 메소드를 사용할 수 있도록 해줍니다. 필드와 메소드가 public 접근 제한을 가질 경우 클래스도 public 접근 제한을 가져야 합니다. 클래스가 default 접근 제한을 가지게 되면 같은 패키지 안에서만 클래스가 사용되기 때문입니다. 

 protected

필드

메소드 ( ... ) 

protected 접근 제한은 default 접근 제한과 마찬가지로 같은 패키지에 속하는 클래스에서 필드와 메소드를 사용할 수 있도록 합니다. 차이점은, 다른 패키지에 속한 클래스가 해당 클래스의 잣기 클래스라면 필드와 메소드를 사용할 수 있습니다. 

 default

필드

메소드 ( ... ) 

필드와 메소드를 선언할 때 public 또는 private 를 생략했다면 default 접근제한ㅇ르 가집니다. default 접근 제한은 같은 패키지에서는 아무런 제한 없이 필드와 메소드를 사용할 수 있으나, 다른 패키지에서는 필드와 메소드를 사용할 수 없도록 합니다. 

 private

필드

메소드 ( ... ) 

private 접근 제한은 동일 패키지이건 다른 패키지이건 상관 없이 필드와 메소드를 사용하지 못하도록 제한합니다. 오로지 클래스 내부에서만 사용할 수 있습니다. 



WRITTEN BY
SiriusJ

,

[final 필드]

final의 의미는 최종적이란 뜻을 가지고 있습니다.

final필드는 초기값이 저장되면 이것이 최종적인 값이 되어서 프로그램 실행 도중에 수정할 수 없다는 것입니다. final 필드는 다음과 같이 선언됩니다.


final 타입 필드 [ = 초기값];


ex)

[Person.java]

public class Person {

final String nation = "Korea";

final String num;

String name;


public Person(String num, String name) {

this.num = num;

this.name = name;

}

}


[PersonExample.java]

public class PersonExample {

public static void main(String[] args) {

Person p1 = new Person("123-123", "최진우");


System.out.println(p1.nation);

System.out.println(p1.num);

System.out.println(p1.name);


//p1.nation = "USA"';        -> final 필드는 값 수정 불가

//p1.num = "456-456";      -> final 필드는 값 수정 불가

p1.name = "지누";

}

}


[상수 (static final) ]

일반적으로 불변의 값을 상수라고 부릅니다.

이런 불변의 값을 저장하는 필드를 자바에서 상수(constant) 라고 합니다.

final과 차이를 살펴보겠습니다.

final필드는 한 번 초기화 되면 수정할 수 없는 필드라고 하였습니다. 그러나 final필드를 상수라 하지는 않습니다.

왜냐하면 불변의 값은 객체마다 저장할 필요가 없는 공용성을 띠고 있으며, 여러가지 값으로 초기화 될 수 없기 때문입니다.

final 필드는 객체마다 저장되고, 생성자의 매개값을 통해서 여러가지 값을 가질 수 있기 때문에 상수가 될 수 없습니다. 상수는 static 이면서, final 이어야 합니다. static final 필드는 객체마다 저장되지 않고, 클래스에만 포함됩니다.

그리고 한 번 초기값이 저장되면 변경할 수 없습니다.

static final 타입 상수 [ = 초기값];


예시)

static final 타입 상수;

static {

상수 = 초기값;

}


ex)

static final double  PI = 3.14159;

static double EARTH_SURFACE_AREA;

-> (상수 이름은 모두 대문자로 작성하는 것이 관례입니다.)



WRITTEN BY
SiriusJ

,

전체 프로그램에서 단 하나의 객체만 만들도록 보장해야 하는 경우가 있습니다.

단 하나만 생성된다고 해서 이 객체를 싱글톤(Singleton)이라 합니다. 싱글톤을 만들려면 클래스 외부에서 new 연산자로 생성자를 호출할 수 없도록 막아야 합니다. (생성자를 호출한 만큼 객체가 생성되므로)

생성자를 외부에서 호출할 수 없도록 하려면 생성자 앞에 private 접근 제한자를 붙여주면 됩니다.


예시)

[싱글톤을 만드는 코드]

public class 클래스 {

//정적 필드

private static 클래스 singleton = new 클래스();


//생성자

private 클래스() {}


//정적 메소드

static 클래스 getInstance() {

return singleton;

}

}


(싱글톤 객체는 힙(heap)영역에 들어있습니다.)

==> 외부에서 객체를 얻는 유일한 방법은 getInstance() 메소드를 호출하는 방법입니다

getInstance() 메소드는 단 하나의 객체만 리턴하기 때문에 아래 코드에서 변수1과 변수2는 동일한 객체를 참조합니다.


ex)

클래스 변수1 = 클래스.getInstance();

클래스 변수2 = 클래스.getInstance();



ex) [Singleton.java]

public class Singleton {

private static Singleton singleton = new Singleton();

private Singleton() { }


static Singleton getInstance() {

return singleton;

}

}


[SingletonExample.java]

public class SingletonExample {

public static void main(String[] args) {

/*

Singleton obj1 = new Singleton();        //컴파일 에러

*/

Singleton obj1 = Singleton.getInstance();

Singleton obj2 = Singleton.getInstance();


if(obj1 == obj2) {

System.out.println("같은 Singleton객체입니다.");

} else {

System.out.println("다른 Singleton객체입니다.");

}

}

}


[결과]

==> 같은 Singleton객체입니다.



WRITTEN BY
SiriusJ

,

[정적 멤버와 static]

정적(static)은 '고정된'이란 의미를 가지고 있다. 정적 멤버는 클래스에 고정된 멤버로서 객체를 생성하지 않고 사용할 수 있는 필드와 메소드를 말합니다. 

이들을 각각 정적 필드, 정적 메소드라고 부릅니다.

또한 정적멤버는 객체(인스턴스)에 소속된 멤버가 아니라 클래스에 소속된 멤버이기 때문에 클래스 멤버라고도 합니다.


[정적 멤버 선언]

정적 필드와 정적 메소드를 선언하는 방법은 필드와 메소드 선언 시 static 키워드를 추가적으로 붙이면 된다.

예시)

public class 클래스 {

//정적 필드

static 타입 필드 [= 초기값];


//정적 메소드

static 리턴 타입 메소드 (매개변수선언, ...) {

...

}

}


->ex)

public class Calculator {

String color;                    //color는 변할 수 있음.

static double pi = 3.14159;        //어디에서건 파이 값은 동일함.

static int plus(int x, int y) {            //정적 메소드

return x + y;

}

}


[정적 멤버 사용]

클래스가 메모리로 로딩되면, 정적 멤버를 바로 사용할 수 있는데, 클래스 이름과 함께 도트(.) 연산자로 접근할 수 있습니다.

예시) 

클래스.필드;

클래스.메소드(매개값, ...);


->ex)

public class Calculator {

static double pi = 3.14159;

static int plus(int x, int y) { 

return x + y;

}

static int minus(int x, int y) { 

return x - y;

}

}


public class CalcTest {

public static void main(String[] args) {                //main 실행
    double result1 = 10 * 10 * Calculator.pi;

int result2 = Calculator.plus(10, 5);

int result3 = Calculator.minus(10, 5);


System.out.println("result1 = " + result1);

System.out.println("result2 = " + result2);

System.out.println("result3 = " + result3);

}

}


[정적 초기화 블록]

정적 블록은 클래스가 메모리로 로딩될 때 자동적으로 실행됩니다. 정적 블록은 클래스 내부에 여러 개가 선언되어도 상관없습니다. 클래스가 메모리로 로딩될 때 선언된 순서대로 실행됩니다.

예시)

static {

....

}


->ex)

[Television.java]

public class Television {

static String company = "Samsung";

static String model = "LCD";

static  String info;


static {

info = company + "-" + model;

}

}


[TvExample.java]

public class TvExample {

public static void main(String[] args) {
    System.out.println(Television.info);

}

}


[결과 값]

==> Samsung-LCD


[정적 메소드와 블록 선언 시 주의할 점]

정적 메소드와 정적 블록을 선언 시 주의할 점은 객체가 없어도 실행된다는 특징 때문에, 이들 내부에 인스턴스 필드나 인스턴스 메소드를 사용할 수 없습니다. 또한 객체 자신의 참조인 this 키워드도 사용이 불가능 합니다.


ex)

public class ClassName {

//인스턴스 필드와 메소드

int field1;

void method1() { ... }


//정적 필드와 메소드

static int field2;

static void method2() { ... }


//정적 블록

static {

field1 = 10;         (x)       ->컴파일 에러

method1();          (x)       ->컴파일 에러

field2 = 10;         (0)

method2();          (0)

}

//정적 메소드

static void method3 {

this.field1 = 10;        (x)       ->컴파일 에러

this.method1();         (x)       ->컴파일 에러

field2 = 10;              (0)

method2();               (0)

}

}


==> 정적 메소드와 정적 블록에서 인스턴스 멤버를 사용하고 싶다면 아래와 같이 객체를 먼저 생성 후, 참조 변수로 접근해야 합니다.

{Method3 정적 메소드]

static void Method3() {

ClassName obj = new ClassName();

obj.field1 = 10;

obj.method1();

}


'Programming > JAVA' 카테고리의 다른 글

Java - (11) final 필드와 상수  (0) 2016.05.15
Java - (10) 싱글톤(Singleton)  (0) 2016.05.15
Java - (8) 메소드 (Method)  (0) 2016.05.15
Java - (7) 생성자 오버로딩(Overloading)  (0) 2016.05.04
Java - (6) 객체와 클래스(Class)  (0) 2016.05.04

WRITTEN BY
SiriusJ

,

: 메소드는 객체의 동작에 해당하는 중괄호 { } 블록을 말합니다. 중괄호 블록은 이름을 가지고 있는데, 이것이 메소드 이름입니다. 메소드를 호출하게 되면 중괄호 블록에 있는 모든 코드들이 일괄적으로 실행되며, 메소드는 객체 간의 데이터 전달의 수단으로 사용됩니다.


[메소드 선언]

리턴타입 메소드 이름 ([매개변수 선언, ...]) {

실행할 코드를 작성하는 곳                <- 메소드 실행블록

...

}


예시 )

int sumFunc( int num1, int num2) {

int result;

result = num1 + num2;

return result;

}


와 같이 작성할 수 있습니다.


[리턴 타입]

메소드가 실행 후 리턴하는 값의 타입을 말합니다. 각각의 메소드는 리턴값이 있을 수도 있고, 없을 수도 있습니다. 메소드가 실행 후 결과를 호출한 곳에 넘겨줄 경우에는 리턴값이 있어야 합니다.

아래 예시를 통해 참고하겠습니다.


public class Test1 {
public static void main(String[] args) {
int sum;
Scanner sc = new Scanner(System.in);

int num1 = sc.nextInt();
int num2 = sc.nextInt();
sum = sumFunc(num1, num2);

//sum = sumFunc(sc.nextInt(), sc.nextInt()); 로 위의 3줄을 대체될 수 있음
System.out.println("sum=" + sum);
sc.close();
}

public static int sumFunc(int num1, int num2) {
int result;
result = num1 + num2;
return result;
}
}

-> 사용자로부터 두 수를 입력받아 더한 값을 결과로 출력하는 단순한 코드입니다.


[리턴값이 없는 메소드]

void 로 선언된 리턴값이 없는 메소드에서도 return문을 사용할 수 있습니다. 다음과 같이 return문을 사용하면 메소드 실행을 강제 종료 시키게 됩니다.


다음은 gas값이 0보다 클 경우 계속해서 while문을 실행하고, 0일경우 return을 실행하여 run() 메소드를 즉시 종료합니다. 이 때, return문 대신 break문을 사용할 수도 있습니다.


[CarTest.java]

/**
* Created by 진우 on 2016-05-15.
*/
public class CarTest {
public static void main(String[] args) {
Car myCar = new Car();

myCar.setGas(5);

boolean gasState = myCar.isLeftGas();
if(gasState) {
System.out.println("출발합니다.");
myCar.run();
}

if(myCar.isLeftGas()) {
System.out.println("gas를 주입할 필요가 없습니다.");
} else {
System.out.println("gas를 주입하세요.");
}
}
}


[Car.java]

/**
* Created by 진우 on 2016-05-15.
*/
public class Car {
//필드
int gas;

//생성자


//메소드
void setGas(int gas) {
this.gas = gas;
}

boolean isLeftGas() {
if(gas == 0) {
System.out.println("gas가 없습니다.");
return false;
}
System.out.println("gas 가 있습니다.");
return true;
}

void run() {
while(true) {
if(gas > 0) {
System.out.println("달립니다. (gas 잔량:"+gas+")");
gas -= 1;
} else {
System.out.println("멈춥니다. (gas잔량:" + gas + ")");
return;
}
}
}
}


[결과 값] - CarTest의 main 실행화면


WRITTEN BY
SiriusJ

,

외부에서 제공되는 다양한 데이터들을 이용해서 객체를 초기화하려면 생성자도 다양화 될 필요가 있습니다. 예를 들어 Car 객체를 생성할 때 외부에서 제공되는 데이터가 없다면 기본 생성자로 Car 객체를 생성해야하고, 외부에서 model 데이터가 제공되거나 model과 color가 제공될 경우에도 Car 객체를 생성할 수 있어야 합니다.

그래서 자바는 다양한 방법으로 객체를 생성할 수 있도록 생성자 오버로딩(Overloading) 을 제공합니다. 

생성자 오버로딩이란 매개 변수를 달리하는 생성자를 여러 개 선언하는 것을 말합니다.


ex)

public class Car {

Car() { .. }

Car(String model) { ... }

Car(String model, String color) { ... }

Car(String model, String color, int speed) { ... }

}

등과 같이 생성자를 여러 개 선언할 수 있습니다.


하지만 예를 들어

Car(String model, String color) { .. }

Car(String color, String model) { .. }

은 오버로딩이라 할 수 없습니다. 

(매개변수의 타입과 갯수, 선언된 순서가 똑같을 경우에,  매개 변수의 이름만 바꾸는 경우)


여튼, 예시와 같이 생성자를 선언했을 때, 아래 예시와 같이 다양한 방법으로 Car 객체를 생성할 수 있습니다.

ex2)

Car car1 = new Car();

Car car2 = new Car("소나타");

Car car3 = new Car("소나타", "흰색");

Car car4 = new Car("소나타", "흰색", 120);


-> 위의 예시 ex) 와 비교하여 살펴보면 

new Car()는 기본 생성자로 객체를 생성하고, new Car("소나타")는 Car(String model) 생성자로 객체를 생성합니다.

이하 다른 부분 또한 비교하면 금방 알 수 있으실겁니다.


WRITTEN BY
SiriusJ

,

객체지향 프로그래밍에서, 메모리에서 사용하고 싶은 객체가 있다면 우선 설계도로 해당 객체를 만드는 작업이 필요할 것입니다. 이 설계도가 바로 클래스(class) 입니다.

클래스에는 객체를 생성하기 위한 필드와 메소드가 정의되어 있게 됩니다. 클래스로부터 만들어진 객체를 해당 클래스의 인스턴스(instance) 라고 합니다.

그리고 클래스로부터 객체를 만드는 과정을 인스턴스화 라고 합니다.


객체지향 프로그래밍 개발은 세가지 단계로 이루어 집니다.

1) 클래스 설계

2) 설계된 클래스를 가지고 사용할 객체를 생성

3) 생성된 객체를 이용


[Class 선언]

public class 클래스이름 {

...

}

여기서, public class 키워드는 클래스를 선언 시 사용하며 반드시 소문자로 작성해야 합니다.

클래스 이름 뒤에는 반드시 중괄호{ } 를 붙여주어야 합니다.

(* 클래스 이름은 맨 앞 알파벳은 대문자로 해주는 것이 관례라고 합니다 :D )


ex) 

(Student.java

public class Student {

}


(Test.java)

public class Test {

public static void main(String[] args) {

Student s1 = new Student();            //new연산자로 Student클래스 객체를 생성

System.out.println("new로 생성한 s1 변수가 Student 객체를 참조!");

Student s2 = new Student();

System.out.println("new로 생성한 또 다른 s2 변수가 Student 객체를 참조!");

}

}

와 같이 파일을 만들어 주고 실행하면, 화면에 다음과 같이 출력이 될 것입니다.

결과)

new로 생성한 s1 변수가 Student 객체를 참조!

new로 생성한 또 다른 s2 변수가 Student 객체를 참조!


[클래스의 구성 멤버]

public class ClassName {

int fieldName;                //필드

ClassName() { ... }            //생성자

void methodName() { ... }  //메소드

}


1) 필드 : 객체의 데이터가 저장되는 곳

- 객체의 고유 데이터, 상태 정보등을 저장하는 곳입니다. 선언 형태는 변수와 유사하지만 필드를 변수라 부르지는 않습니다. 변수는 생성자와 메소드 내에서만 사용되고 생성자와 메소드가 실행종료되면 자동 소멸됩니다.

하지만 필드는 생성자와 메소드 전체에서 사용되며 객체가 소멸되지 않는 한 객체와 함께 존재합니다.


2) 생성자 : 객체 생성 시 초기화 역할 담당

- 생성자는 new 연산자로 호출되는 특별한 중괄호 { } 블록입니다. 필드를 초기화하거나, 메소드를 호출하여 객체를 사용할 준비를 하게 됩니다. 생성자는 메소드와 비슷하게 생겼지만, 클래스 이름으로 되어있고 리턴타입이 없습니다.


3) 메소드 : 객체의 동작에 해당하는 실행 블록

- 객체의 동작에 해당하는 중괄호 { } 블록을 말합니다. 중괄호 블록은 이름을 가지고 있는데, 이것이 메소드 이름입니다.

메소드를 호출하면 중괄호 블록내에 있는 모든 코드들이 일괄적으로 실행됩니다.

메소드는 객체간의 데이터 전달의 수단으로 사용되며 외부로부터 매개값을 받을수도 있고, 실행 후 어떤 값을 리턴할 수도 있습니다.


WRITTEN BY
SiriusJ

,