클래스 (Class) part.1
Class를 배우기 전에...
java 는 JVM(Java Virtual Machine) 이 있다.
JVM(Java Virtual Machine)은 OS 이다.
이것은 어떤 의미일까?
C 나 C++등의 언어은 프로그램을 만들때
운영체제가 가진 기능을 불러다가 쓸 수 있게 만드는 것이다.
이런 각각의 운영체제가 가진 조각들, 기능들을 API라고 말한다.
프로그램을 다른 운영체제에
맞게끔 바꿔주는 것을 '포팅'이라고 말한다.
이런 포팅은 너무 번거롭고 비용이 많이든다.
그래서 생각해 낸 방법이 메모리에 프로그램 전용의 운영체제를 설치한다면
이미 있는 운영체제가 무엇이든 상관없이
똑같은 프로그램을 어디에서나 쓸 수 있도록 해줄 수 있을 것이다.
java의 자바가상머신 JVM(Java Virtual Machine) 이 바로 그런 역할을 한다.
도스에서 자바 파일을 컴파일 할 때 이런 명령어를 친다.
javac 파일 .java
이는 java로 만든 파일을 jvm이라는
자바가상머신에서 실행할 수 있도록 컴파일 해주는 것이다.
c나 c++은 운영체제 안에서 바로 실행이 가능하지만
java는 가상 머신 안에있는
실행파일을 운영체제로 실행할 수있도록 해줘야한다.
그게 java라는 프로그램이다.
Class (Part.1)
1. 특징
1) 묶음 : 변수, 메서드
2) 캡슐화 단위 : 편리, 보안, 최소 단위
3) 설계도(추상적) -> 인스턴스 : 실제 클레스가 사용할 수 있는 실행공간, 메모리 공간을 인스턴스라고 한다.
4) 데이터 타입의 역할도 한다.
Loding 하드디스크에 파일을 메모리로 옮긴다.
메모리에 올라가서 실행할 수 있는 공간이 인스턴스이다.
자 이제 본격적으로 인스턴스를 알아보자.
<인스턴스 만들기>
new 옆에는 어떠한 이름으로 클래스(설계도)를 만들것인지 쓴다.
'new +클래스 이름'은 새로운 메모리 공간을 만들겠다는 뜻이다.
new를 쓰면 계속 인스턴스로 만들어준다.
.은 접근연산자이다.
new ClassDemo1().iValue=10; 처럼 메모리만 만들어 놓고 어딘지 지정을 안해놓으면 안된다.
인스턴스는 ClassDemo1 area1 = new ClassDemo1(); 이런 식으로
반드시 주소를 저장해놓아야 재사용이 가능하다.
class ClassDemo1{
int iValue;
double dValue;
}
public class ClassTest1{
public static void main(String[] args){
//인스턴스 만들기
//new 새로운 메모리 공간을 만들겠다는 뜻이다. new를 쓰면 계속 인스턴스로 만들어준다.
//new 옆에는 어떠한 이름으로 설계도를 만들것인지 쓴다.
//.은 접근연산자이다.
// new ClassDemo1().iValue=10; 처럼 메모리만 만들어 놓고 어딘지 지정을 안해놓으면 안된다.
// 인스턴스는 반드시 주소를 저장해놓아야 재사용이 가능하다.
// new를 쓰면 계속 인스턴스로 만들어준다.
ClassDemo1 area1 = new ClassDemo1();
area1.iValue = 10;
area1.dValue = 3.14;
System.out.println(area1.iValue + ", " + area1.dValue);
ClassDemo1 area2 = new ClassDemo1();
area2.iValue = 20;
area1 = area2;
area1.iValue = 100;
System.out.println("area1.iValue=" + area2.iValue);
//area1.Value = area2.iValue 같음
}
}
※결과값
10,3.14
area1.iValue=100
2. 변수의 종류
1) 선언된 위치에 따라서 구분
클래스 : 인스턴스 변수 (멤버변수 : 클래스안에 있는 실제 멤버, 재산)
메서드 : 변수 (지역변수)
2) 저장되는 내용에 따라서 구분
- 값 : 변수 (기본 데이터 타입)
- 주소 : 참조 변수 (객체 데이터 타입)
※ 주소를 저장하는 변수에 값을 저장하는 변수를 사용할 수없고 값을 저장하는 변수에는 주소를 저장할 수 없다.
<객체와 Class>
객체지향은 왜 나왔을까?
객체 (Object)
OOP(객체지향 프로그래밍 언어 Object-Oriented Programming)
객체지향프로그래밍 이전에는?
구조적(절차적) 절차지향 프로그래밍으로 대표되는 C언어 등이 전부였다.
이런 절차지향 프로그램은 한덩어리로 프로그램을 짜야한다.
윈도우 나오기 전 DOS 시절에는 프로그램을 혼자 짜는 것이 가능했다.
그러나 윈도우 이후 프로그램의 덩치가 커진 이후는
한 덩어리로 프로그램을 짜는 것이 어려워졌다.
객체지향 프로그램은 덩치가 커진 프로그램도 생산과 관리가 편리하도록
각각의 기능을 따로 따로 분리해서 조립할 수 있도록 만들었다.
객체 안에 클래스가 포함되었다고 생각하면 좋지만,
처음에는 클래스와 객체를 같다고 인식하는 것이 편하다.
객체는 반드시 하나의 독립된 기능이 있어야하며,
다른 곳에서도 분리해 쓸 수 있게끔 해야한다.
예를 들어 자동차의 문이나 타이어는 객체이지만,
자동차 유리파편 조금을 띁는 것은 객체가 아니다.
그렇다면 객체지향 프로그래밍의 특징은 무엇일까?
<객체지향 프로그램의 특징>
1.Inheritance(상속성)
- 소스 없이 실행파일만 있어도 예전에 만든기능을 물려받아서 다시 쓸 수 있는 기능
- 재사용, 비용절감, 시간절감
- 가장 화려하고 어려움
2.Polymorphism (다형성)
-하나의 객체를 가지고 여러기능을 쓸 수 있도록 하는 것
3.InCapSulation (캡슐화)
- 편리함, 보안, 더 이상 쪼갤 수 없는 최소단위
객체지향의 특징과 java에서 class의 특징과 같기 때문에 객체와 클래스가 같다고 소개한다.
3. 메서드
1) 메서드의 역할
동작(기능)을 구현합니다.
2) 만드는 방법
리턴타입 메서드명(...){
기능 구현
}
3) 사용방법
메서드명(...)
메서드는 왜 쓸까?
public class MethodTest1{
public static void main(String[] args){
System.out.println("********************");
System.out.println("채팅프로그램");
System.out.println("********************");
System.out.println("1.방만들기");
System.out.println("2.나가기");
System.out.println("입력 : ");
System.out.println("********************");
}
}
이런 코드가 있다.
여기서 별을 관리하기 편하게하려면 어떻게 해야할까?
<인자가 없는 방식>
public class MethodTest1 {
int iValue;
//리턴타입을 알 수 없으면 void
void line(){
for(int cnt=0; cnt<20; cnt++){
System.out.print("*");
}
System.out.println();
}
public static void main(String[] args){
//line method를 사용하기 위해 인스턴스를 생성
MethodTest1 test1 = new MethodTest1();
//메소드 호출
test1.line();
System.out.println("채팅프로그램");
//메소드 호출
test1.line();
System.out.println("1.방만들기");
System.out.println("2.나가기");
System.out.println("입력 : ");
//메소드 호출
test1.line();
}
}
※ 결과값
[java] ********************
[java] 채팅프로그램
[java] *************************
[java] 1.방만들기
[java] 2.나가기
[java] 입력 :
[java] ******************************
왜 메인 메소드는 인스턴스 하지 않을까?
메인 메소드는 특별한 메소드기 때문에 인스턴스 생성을 하지않는다. (추후에 다룬다)
class가 100개 1000개 있어도 메인메소드는 하나다.
main이라는 메소드는 따로 인스턴스하지 않아도 따로 메모리가 생성된다.
다른 클래스에 메소드 호출하여 특정기능을 쓰는 방식은 아래와 같이 진행된다.
*메소드 호출 : 해당하는 메소드를 메모리 위치로 건너가 실행시켜준다. 요청했기 때문에 다른 쪽 메모리로 점프한다. 실행이 끝나면 현재 실행위치가 다시 원위치로 돌아간다.
*모듈화(module) : 클래스와 메소드를 분리해서 호출하듯 별도의 기능을 따로 분리하는 것을 모듈화라고 한다.
*인터럽트(interrupt) : 잠깐 하던 일을 방해받으므로 부탁받은 일을 하고 다시 하던일을 계속한다.
예) 라면을 끓이고 있는데 전화가 온다. 그럼 잠깐 전화를 받으면 서 라면을 끓인다.
인터럽트가 걸렸을 때 스택이라는 메모리로 잠시 쌀아 놓는다.
*매개변수(parameter) : 인자를 받아주기 위한 목적으로 만든 변수
4) 호출방식
a. 인자(인수)자 없는 방식
- () 괄호할 때 무언가가 있는 방식
- 괄호 안에 아무것도 없기 때문에 아무것도 다시들고 가지 않는다.
b. 인자가 있는 방식
- ()괄호안에 값을 실인자 혹은 인자라고 한다.
- 실인자 혹은 인자는 호출할 때 무언가 넘어가는 값이다.
- 인자있는 매개변수가 있는 경우 인자없는 매개변수를 사용 할 수 없다.
- 매개변수는 실인자의 형식, 순서 갯수가 똑같이 맞춰서 사용해야한다.
c. 리턴값(반환값)이 있는 방식
- 돌아올 때 값이 있는 방식을 리턴값(반환이)있는 방식이라고 한다.
5) return
- 값을 반환한다. 값을 반환할 때는 반드시 1개만 가능하다.
- return에서 연산을 할 경우 연산된값 1개를 전달한다.
- 메서드의 강제종료 (리턴을 메서드 중간에 쓰면 강제종료되어 값이 넘어간다.)
- void 란 값이 없이 빈손으로 돌아간다는 뜻이다.
<인자가 있는 방식>
public class MethodTest1 {
int iValue;
//리턴타입을 알 수 없으면 void
//인자를 받아주기 위한 목적으로 만든 변수를 매개변수(parameter) 라고 하는데 메소드 괄호안에 넣어주며 끝맺음을 할 필요가 없다.
void line(int count, char type){
for(int cnt=0; cnt<count; cnt++){
System.out.print(type);
}
System.out.println();
}
// 메인 메소드는 특별한 메소드기 때문에 인스턴스 생성을 하지않는다. (추후에 다룬다)
//class가 100개 1000개 있어도 메인메소드는 하나다.
public static void main(String[] args){
//MethodTest1를 사용하기 위한 인스턴스 생성
MethodTest1 test1 = new MethodTest1();
//메소드 호출
//인자(argument) 넣음
test1.line(20, '*');
System.out.println("채팅프로그램");
//메소드 호출
test1.line(25, '-');
System.out.println("1.방만들기");
System.out.println("2.나가기");
System.out.println("입력 : ");
//메소드 호출
test1.line(30, '=');
//매개변수는 실인자의 형식, 순서 갯수가 똑같이 맞춰서 사용해야한다.
//test1.line(); 인자있는 매개변수가 있는 경우 인자없는 매개변수를 사용 할 수 없다.
}
}
※ 결과값
[java] ********************
[java] 채팅프로그램
[java] -------------------------
[java] 1.방만들기
[java] 2.나가기
[java] 입력 :
[java] ===========================
<리턴값이 있는 방식>
public class MethodTest2{
//선언된 위치가 다르기 때문에 변수명을 다른 위치로 해도 상관없다.
void calc(int num1, int num2){
int sum = num1 + num2;
System.out.println("결과 : " + sum);
}
public static void main(String[] args){
int num1=10, num2=15;
System.out.println("두 수의 합계");
MethodTest2 test = new MethodTest2();
test.calc(num1, num2);
}
}
여기서 메인에서 연산된 num1, num2의 값을 받고 싶어서
위와 같이 코드를 바꾸어 보았다.
그러나 돌아오는 값이 없기 때문에 되지 않는다.
public class MethodTest2{
//선언된 위치가 다르기 때문에 변수명을 다른 위치로 해도 상관없다.
// 리턴하는 값이 있을 경우 돌아오는 형식(타입)을 맞춰 준다.
//4) 메인에서 받은 (num1, num2)를 전달받아 계산
int calc(int num1, int num2){
int sum = num1 + num2;
//'return + 값'은 돌아갈 때 무조건 리턴이 가진 값을 가져가는 것이다.
//5) (int num1, int num2) 값을 다시 메인메소드로 돌려줌
return sum;
}
public static void main(String[] args){
int num1=10, num2=15;
System.out.println("두 수의 합계");
//1) 메소드를 쓸 수 있도록 메모리를 할당하도록 인스턴스 선언
MethodTest2 test = new MethodTest2();
//2) num1, num2는 자체데이터이다.
//3) (num1, num2)의 값을 calc로 보냄
//6) return으로 받아온 (num1, num2의 값을) hap 변수에 저장
int hap = test.calc(num1, num2);
//7) 출력
System.out.println("결과 : " + hap);
}
}
※ 결과값
[java] 두 수의 합계
[java] 결과 : 25
코드를 좀 더 줄인다면 이렇게 만들 수 있다.
public class MethodTest2{
//선언된 위치가 다르기 때문에 변수명을 다른 위치로 해도 상관없다.
// 리턴하는 값이 있을 경우 돌아오는 형식(타입)을 맞춰 준다.
//4) 메인에서 받은 (num1, num2)를 전달받아 계산
int calc(int num1, int num2){
//5) (int num1, int num2) 값을 다시 메인메소드로 돌려줌
return (num1 + num2);
}
public static void main(String[] args){
int num1=10, num2=15;
System.out.println("두 수의 합계");
//1) 메소드를 쓸 수 있도록 메모리를 할당하도록 인스턴스 선언
MethodTest2 test = new MethodTest2();
//2) num1, num2는 자체데이터이다.
//3) (num1, num2)의 값을 calc로 보냄
//6) return으로 받아온 (num1, num2의 값을) test.calc(num1, num2)에서 출력
System.out.println("결과 : " + test.calc(num1, num2))
}
}
※결과값
두 수의 합계
결과 : 25
<java에서의 메서드와 함수>
메서드 : 클래스 밖에 있는 기능
함수 : 클래스 안에 있는 기능
java에서는 클래스 안에 모든 함수가 있기 때문에 메서드라고 말한다.
4. 메서드의 오버로딩(Overloading) : 중복 정의
- 객체지향 프로그램에만 가지고 있는 특징이다.
- 사용자로 하여금 훨씬 편리한 환경을 제공해준다.
- 반드시 비슷한 기능끼리를 같은 이름으로 묶어줘야 효과가 극대화된다.
- print(), println() 도 오버로딩의 예이다. 오버로딩이 되어 있어 출력을 할 수 있었다.
1) 다형성을 지원
- 객체의 특징 중에 다형성을 지원하는 문법이다.
- 하나의 이름으로 여러개의 메서드, 기능을 수행할 수 있게 함.
2) 매개변수
- 반드시 ()괄호에 들어간 매개변수로만 구별이 가능하다. (갯수,형식, 순서)
<예제>
public class OverloadTest{
void display(){
System.out.println("출력 내용이 없음");
}
void display(int i){
System.out.println(i);
}
void display(int i, double d){
System.out.println(i + ", " + d);
}
void display(double d, int i){
System.out.println(d + ", " + i);
}
public static void main(String[] args){
OverloadTest test = new OverloadTest();
test.display(100);
test.display();
test.display(200, 3.14);
test.display(4.5, 300);
}
}
<결과>
100
출력 내용이 없음
200, 3.14
4.5, 300
5. 생성자 (Constructor)
생성자 메서드는 일회용이기 때문에 리턴타입 자체를 사용하지 않는다. 보내주면 끝이다. 이점을 유의하자.
1) 인스턴스를 생성
- 메서드는 내가 원하는 기능을 만들 수 있는 반면, 생성자는 인스턴스를 생성하는 용도 밖에 없다.
- 인스턴스를 생성해주는 전용 메서드를 생성자 메서드라고한다.
2) 호출시점
- 인스턴스를 생성할 때(new를 사용할 때) 단 한번만 호출가능하다.
- 코드를 한 번만 쓸 수있다는 것이 아니다.
처음에 인스턴스를 생성한 그 초기화한 값을 또 쓸 수 없다는 이야기이다.
3) 초기화전용
- 처음 초기화 할 때만 사용한다.
4) 작성방법
메서드명(...){
초기화 기능
}
5) 클래스이름과동일하게 메서드명 작성
생성자가 있어야지만 클래스의 인스턴스를 만들 수 있다.
6) 모든 클래스는 예외없이 기본생성자(default constructor)를 가지고있다.
Q. 만약에 다른 생성자를 만들경우 기본생성자는 어떻게 되나요?
만약에 다른 생성자를 만들경우 더 이상 기본 생성자는 제공되지 않는다.
기본생성자란 모든 클래스에 기본적으로 존재하는 생성자를 말한다.
기본생성자는 매개변수가 없는 모양으로 나타나 있다.
아무것도 없을 경우에는 기본생성자가 보이지 않지만
다른 생성자를 만들면 기본 생성자가 사라진다.
그러므로 다른 생성자를 만들 경우 기본 생성자도 만들어 주어야 한다.
모든 생성자는 인스턴스변수의 값을 0으로 초기화해준다.
그러므로 인스터스 변수의 초기값을 따로 설정하지 않아도 사용할 수 있다.
여기서 초기값은 문자는 '공백', 정수는 '0', 실수는 '0.0'으로 되어있다.
※ 클래스는 변수와 메서드를 묶어준다.
변수에 바로 값을 넣는 것이 바람직하지 않은 이유는 두 가지이다.
1. 관리 : 값을 넣은 변수의 이름을 다 파악해야한다.
2. 보안 : 잘못된 값이 아닌지 검사 할 틈이 없다.
그렇기 때문에 메서드를 통해 우회적으로 값을 넣는다.
<예제1>
class ConsDemo1{
int iValue;
double dValue;
//생성자 메서드는 리턴타입이 없고 클래스 이름이 같아야 한다.
//생성자를 쓰면 별도로 따로 메서드를 쓸 필요가 없다.
//1.iValue 와 dValue 의 값을 초기화한다.
ConsDemo1(int i, double d){
//검증
iValue = i;
dValue = d;
}
void setValue(int i, double d){
//검증
iValue = i;
dValue = d;
}
void print(){
System.out.println(iValue + ", " + dValue);
}
}
public class ConsTest1{
public static void main (String[] args){
//2.인스턴스에서 생성자를 호출하여 초기화한 변수를 사용한다.
ConsDemo1 demo1 = new ConsDemo1(10, 10.0);
//demo1.iValue = 10;
//demo1.dValue = 10.0;
//처음 값을 넣어 초기화
//demo1.setValue(10, 10.0);
demo1.print();
System.out.println(demo1.iValue + ", " + demo1.dValue);
//demo1.setValue(20, 20.0);
//3. 인스턴스에서
ConsDemo1 demo2 = new ConsDemo1(20, 20.0);
}
}
※ 결과값
10,10.0
10,10.0
<예제2>
class ConsDemo2{
int iValue;
/*
눈에 보이지 않지만 생성자가 있다.
ConsDemo2(){
}
*/
//기본생성자는 별도의 생성자가 생기면 제공되지 않는다.
ConsDemo2(int i){
iValue = i;
}
}
public class ConsTest2{
public void main(String[] args){
//ConsDemo2 demo = new ConsDemo2();
//메서드 호출
ConsDemo2 demo = new ConsDemo2(10);
}
}
<예제3>
class ConsDemo2{
// 변수의 특징 임시입력장소,선언할 때 초기화 해야
int iValue;
int dValue;
//기본생성자는 별도의 생성자가 생기면 제공되지 않는다.
ConsDemo2(int i){
iValue = i;
}
ConsDemo2(){
}
}
public class ConsTest2{
public void main(String[] args){
/*
//ConsDemo2 demo = new ConsDemo2();
ConsDemo2 demo = new ConsDemo2();
//인스턴스에서도 인자값을 넣어 호출할 수 있다.
ConsDemo2 demo = new ConsDemo2(10);
*/
int i ;
//System.out.println(i); 그냥하면 오류 남으로
//ConsDemo2()생성자를 불러주는 인스턴스를 만든다.
ConsDemo2 demo = new ConsDemo2();
//생성자 값이 없는 경우 기본으로 변수의 값을 초기화해줘서
//인스턴스 변수의 초기값은 자연스럽게 0이 된다.
System.out.println(demo.iValue);
}
}
※결과값
0
6. Garbage Collection
Garbage Collection은 왜 필요할까요?
인스턴스 : 설게도에 의해서 만들어진 실제 공간
Garbage : 불필요한 인스턴스 (메모리)
이런 Garbage은 메모리 상에 없어지지 않고 남는다.
Garbage Collection은 Garbage 모아서 메모리를 다시 쓸 수 있도록 하기위한 것이다.
메모리 관리는 프로그램에서 매우 중요하지만 개발자가 일일히 메모리를 관리하기란 매우 민감하고 골치아프다.
JVM(자바가상머신)에는 개발자 대신 메모리를 다시 쓸 수 있도록 하는 Garbage Collection 기능이 있다.
JVM(자바가상머신)는 Garbage가 많이 쌓여있을 때 알아서 메모리 청소를 한다.
개발자가 Garbage Collection을 이용할 일은 없을까요?
개발자가 직접 판단해서 JVM(자바가상머신)에게 Garbage를 Garbage Collection하여 청소해달라고 할 때도 있다.
System.gc()는 JVM에게 Garbage Collection을 해달라고 요청하는 명령어이다.
finalize()는 Garbage Collection과 가장 밀접한 메서드이다.
finalize()는 JVM이 알아서 Garbage Collection하기 전에 내가 미처 마무리하지 못한 작업들을 호출해준다. Garbage가 사라지기 직전에 호출되는 메서드이다.
finalize()는 외형만 껍데기만 있는 메서드이며 개발자가 원하는 내용을 고쳐서 넣을 수 있다.
※ callback 메서드
- 개발자가 메서드를 호출하는 것이 아니라 시스템이 필요할 때 호출이 되는 메서드이다.
<예제>
class Fdemo{
int count;
Fdemo(int i){
count = i;
}
//finalize메서드의 형식은 반드시 아래와 같이 해야한다.
protected void finalize(){
System.out.println("GC가동중 : " + count);
}
}
public class FinalizeTest{
public static void main(String[] args){
for(int i = 0; i<1000000; i++){
new Fdemo(i);
}
}
}
<결과값>
GC가동중 : 233221
GC가동중 : 235048
... (중략) ...
GC가동중 : 660742
GC가동중 : 775969
7. this
1) 현재 실행중인 인스턴스의 주소값을 저장
- 매개변수의 이름과 인스턴스변수의 이름이 같은 경우
주소값을 알려주기 위해 반드시 this. 를 써야한다.
2) 참조변수 : 인스턴스에 주소를 저장하는 변수
3) read only : 메모리가 할당된 주소값을 마음대로 할당할 수 없다.
4) this() : 현재 실행중인 생성자의주소
this의 사용 예제를 살펴보자
먼저, this를 생략할 수 있는 경우를 살펴보자
<예제>
class ThisDemo1{
int iValue;
double dValue;
ThisDemo1(int i, double d){
//여기서 this.은 인스턴스의 주소값을 가리킨다.
iValue = i;
dValue = d;
/*
this.iValue = i;
this.dValue = d;
*/
}
void display(){
System.out.println(iValue + ", " + dValue);
//System.out.println(this.iValue + ", " + this.dValue); 처럼 this. 를 생략하고 쓸 수 있다.
}
}
public class ThisTest1{
public static void main(String[] args){
//눈에 보이지 않는 인자가 숨겨져있다. ((인스턴스의 주소값), 10, 10.0)
//시스템이 알아서 넣어놓은 참조변수가 this이다. 눈에는 보이지 않는다.
ThisDemo1 d1 = new ThisDemo1(10, 10.0);
ThisDemo1 d2 = new ThisDemo1(20, 20.0);
ThisDemo1 d3 = new ThisDemo1(20, 30.0);
d1.display();
d2.display();
d3.display();
}
}
※결과값
10, 10.0
20, 20.0
20, 30.0
매개변수의 이름과 인스턴스변수의 이름이 같은 경우는 어떨까?
<예제>
class ThisDemo1{
int iValue;
double dValue;
ThisDemo1(int iValue, double dValue){
//여기서 this.은 인스턴스의 주소값을 가리킨다.
//매개변수의 이름과 인스턴스변수의 이름이 같은 경우 주소값을 알려주기 위해 반드시 this. 를 써야한다.
iValue = iValue;
dValue = dValue;
}
void display(){
System.out.println(this.iValue + ", " + this.dValue);
//System.out.println(iValue + ", " + dValue); 처럼 this. 를 생략하고 쓸 수 있다.
}
}
public class ThisTest1{
public static void main(String[] args){
//눈에 보이지 않는 인자가 숨겨져있다. ((인스턴스의 주소값), 10, 10.0)
//시스템이 알아서 넣어놓은 참조변수가 this이다. 눈에는 보이지 않는다.
ThisDemo1 d1 = new ThisDemo1(10, 10.0);
ThisDemo1 d2 = new ThisDemo1(20, 20.0);
ThisDemo1 d3 = new ThisDemo1(20, 30.0);
d1.display();
d2.display();
d3.display();
}
}
※ 결과값
0, 0.0
0, 0.0
0, 0.0
매개변수의 이름과 인스턴스변수의
이름이 같기 때문에 주소값을 찾지 못하는 것이다.
이처럼 매개변수의 이름과 인스턴스 변수의 이름이 같은 경우
주소값을 알려주기 위해 반드시 this. 를 써야한다.
<예제>
class ThisDemo1{
int iValue;
double dValue;
ThisDemo1(int iValue, double dValue){
//여기서 this.은 인스턴스의 주소값을 가리킨다.
//매개변수의 이름과 인스턴스변수의 이름이 같은 경우 주소값을 알려주기 위해 반드시 this. 를 써야한다.
this.iValue = iValue;
this.dValue = dValue;
}
void display(){
System.out.println(this.iValue + ", " + this.dValue);
//System.out.println(iValue + ", " + dValue); 처럼 this. 를 생략하고 쓸 수 있다.
}
}
public class ThisTest1{
public static void main(String[] args){
//눈에 보이지 않는 인자가 숨겨져있다. ((인스턴스의 주소값), 10, 10.0)
//시스템이 알아서 넣어놓은 참조변수가 this이다. 눈에는 보이지 않는다.
ThisDemo1 d1 = new ThisDemo1(10, 10.0);
ThisDemo1 d2 = new ThisDemo1(20, 20.0);
ThisDemo1 d3 = new ThisDemo1(20, 30.0);
d1.display();
d2.display();
d3.display();
}
}
※ 결과값
10, 10.0
20, 20.0
20, 30.0
[참고] JAVA API 문서 찾기
자주쓰는 java.lang.System.out.println() 구문을 살펴보자.
java.lang.System.out.println()
java // '폴더 경로' 이다.
lang // '폴더 경로(패키지)' 이다.
System // 'class'
Out // 인스턴스 변수이지만 Class 안에 있는 변수이다.
// 참조변수 역할을 할 수 있도록 한다.
// class 안에 있는 변수이기에 객체라고 말한다.
println() // '메서드'
. // 접근하기 위한 접근연산자
※ '참조변수'란?
인스턴스에 주소를 저장하는 변수
jdk java9 메뉴얼에서 System 을 찾아보자
http://docs.oracle.com/javase/9/docs/api/index.html?overview-summary.html
왼쪽 상단
java.base -> java.lang
왼쪽 하단
System
-> System 이 무엇을 의미하느지 알 수 있다.
[참고2] 이클립스를 사용할 때 알아두어야 할 것
워크스페이스 : 여러개의 프로젝트(프로그램)들을 묶어서 관리하는 가장 큰 단위
프로젝트(프로그램) : java 등등...
'개발 > Java' 카테고리의 다른 글
| [java] 클래스 (Class) part.2 (0) | 2017.10.24 |
|---|---|
| [java] 배열 (Array) (0) | 2017.10.19 |
| [java] 제어문(Control Statement) : 조건문과 반복문 (0) | 2017.10.18 |
| [java] Dos에서 Java 컴파일 하기 (0) | 2017.10.18 |
| [java] 연산자(Operator) (0) | 2017.10.18 |