[Java]객체지향 (1) - 객체,클래스,메서드,static

객체 지향

80년 초 소프트웨어의 위기 - 빠른 변화를 못 쫓아감

해결책으로 객체지향 언어를 도입 (절차적 → 객체지향)

코드의 재사용성이 높고 유지보수가 용이, 중복 코드 제거

 

객체지향 언어 = 프로그래밍 언어 + 객체지향 개념(규칙)

 

oop ( object-oriented programming )

1. 캡슐화

2. 상속

3. 추상화

4. 다형성

 

클래스와 객체

클래스의 정의 : 클래스란 객체를 정의해 놓은 것

클래스의 용도 : 클래스는 객체를 생성하는 데 사용

 

객체의 정의 : 실제로 존재하는 것. 사물 또는 개념

객체의 용도 : 객체가 가지고 있는 기능과 속성에 다름

 

객체의 구성요소 - 속성과 기능

객체 = 속성(변수) + 기능(메서드)

 

객체와 인스턴스

객체 : 모든 인스턴스를 대표하는 일반적 용어

인스턴스 : 특정 클래스로부터 생성된 객체 ( Ex. Tv인스턴스 )

하나의 소스파일에는 하나의 클래스만 작성하는 것이 바람직하다.

 

객체의 생성과 사용

1. 객체의 생성

클래스명 변수명; → 클래스의 객체를 참조하기 위한 참조변수를 선언
변수명 = new 클래스명(); → 클래스의 객체를 생성 후 , 객체의 주소를 참조변수에 저장

Tv t; → Tv클래스 타입의 참조변수 t를 선언
t = new Tv(); → Tv인스턴스를 생성한 후 , 생성된 Tv인스턴스의 주소를 t에 저장
Tv t = new Tv(); → 한번에 적을수도 있다.

 

2. 객체의 사용

t.channel = 7; → Tv인스턴스의 멤버변수 channel의 값을 7로 한다.
t.channelDown(); → Tv인스턴스의 메서드 channelDown()을 호출한다.
System.out.println("현재 채널은 " + t.channel + " 입니다.");

하나의 인스턴스를 여러 개의 참조 변수가 가리키는 경우는 가능하다.

하지만, 여러 인스턴스를 하나의 참조 변수가 가리키는 경우는 불가능하다.

 

객체 배열

객체 배열 == 참조 변수 배열

Tv tv1,tv2,tv3; → Tv[] tvArr = new Tv[3]; ( 길이가 3인 Tv타입의 참조변수 배열 )

tvArr[0] = new Tv();
tvArr[1] = new Tv();
tvArr[2] = new Tv();
객체를 생성해서 배열의 각 요소에 저장

위 로직을 간단히 초기화하면 다음과 같다.

Tv[] tvArr = { new Tv(),new Tv(),new Tv() };

보다시피 , 객체 배열이라 하여 특별한 부분이 없다.

참조 변수 배열과 거의 유사하다.

---

클래스

클래스의 정의 (1)

클래스 == 데이터 + 함수

               ⓐ 설계도
클래스    ⓑ 데이터 + 함수
               ⓒ 사용자 정의 타입

변수  →  배열  →  구조체  →  클래스

1. 변수 : 하나의 데이터를 저장할 수 있는 공간

2. 배열 : 같은 종류의 여러 데이터를 하나로 저장할 수 있는 공간

3. 구조체 : 서로 관련된 여러 데이터(종류 관계 X)를 하나로 저장할 수 있는 공간

4. 클래스 : 데이터와 함수의 결합 (구조체 + 함수(메서드))

 

사용자 정의 타입 - 원하는 타입을 직접 만들 수 있다.

Time이라는 타입을 직접 생성한다고 가정을 해보자.

만약 객체를 생성 안 하면 다음과 같다.

int hour = 12;
int minute = 34;
int second = 56;

이걸 객체로 묶어서 객체지향적으로 생성하면 다음과 같다.

Time t = new Time();
t.hour = 12;
t.minute = 34;
t.second = 56;

 

선언 위치에 따른 변수의 종류

변수는 어디에 선언이 됐냐에 따라 종류 크게 3가지로 분류된다.

영역은 클래스 영역과 메서드 영역으로 나뉜다.

class Variables {
int iv; → 인스턴스 변수
static int cv; → 클래스 변수(static변수, 공유변수)

	void method(){
	int lv = 0; → 지역변수
	}
}

클래스 영역은 클래스의 시작과 끝까지가 영역이며 , 메서드는 메서드 영역의 시작부터 끝까지이다.

클래스 영역에는 선언문만 가능하다. 변수 선언 , 메서드 선언만 가능하다.

해당 순서가 다른 거는 상관이 없다. 일반적으로는 변수 선언을 먼저 하는 편이다.

변수의 종류	선언위치	생성시기
클래스 변수 (class variable)	클래스 영역	클래스가 메모리에 올라갈 때
인스턴스 변수 (instance variable)		인스턴스가 생성되었을 때
지역변수 (local variable)	클래스 영역 이외의 영역 (메서드 생성자, 초기화 블럭 내부)	변수 선언문이 수행되었을 때

지역변수(local variable)의 범위(scope)는 해당 변수 선언된 메서드가 끝날 때까지 유효하다.

메서드 종료 시 자동으로 제거된다.

클래스 변수(class variable)와 인스턴스 변수(instance variable)는 클래스 전체의 영역에서 사용이 가능하다.

인스턴스 변수는 객체를 생성을 했을 때 만들어진다.

인스턴스 변수(instance variable)를 묶어놓은 것이 객체라고 볼 수도 있다.

클래스 변수(cl)와 인스턴스 변수(iv)의 가장 큰 차이점은 클래스 변수는 객체 생성을 안 해도 된다는 점이다.

쉽게 말해 클래스 변수는 아무 때나 사용이 가능하다. 인스턴스 변수는 객체 생성을 해야지만 사용할 수 있다.

영역 →  ① 클래스 영역 - iv , cv(static + iv)
              ② 메서드 영역 - lv

인스턴스 변수(iv)는 참조 변수가 없어지면 가비지 컬렉터에 의해서 자동으로 사라진다.

 

클래스 변수와 인스턴스 변수

cv와 iv의 차이점은 인스턴스 변수는 개별적인 속성이고 클래스 변수는 공통적인 속성이라는 점이다.

class Card {
String kind; → 무늬
int number; → 숫자

static int width = 100; → 폭
static int height = 250; → 높이

카드마다 무늬와 숫자는 다르다. 하지만 카드의 폭과 높이는 모두 일치해야 한다.

그러므로 공톡적인 폭과 높이는 static으로 cv로 선언하고 , 개별적인 부분은 iv로 선언을 해야 한다.

Card c = new Card();
c.kind = "HEART";
c.number = 5;
Card.width = 200;
Card.height = 300;

객체를 사용할 때 cv도 물론 참조 변수를 사용해 객체를 사용할 수 있지만,

cv를 사용할 때는 참조 변수가 아닌 Class이름을 사용해 객체를 사용해주는 게 바람직하다.

---

메서드

메서드란?

1. 문장들을 묶어놓은 것

- 작업 단위로 문장들을 묶어서 이름 붙인 것

2. 값(입력)을 받아서 처리하고, 결과를 반환(출력)

▶ 메서드의 장점
- 코드의 중복을 줄일 수 있다.
- 코드의 관리가 쉽다.
- 코드를 재사용할 수 있다.
- 코드가 간결해서 이해하기 쉬워진다.

▶ 메서드의 작성
- 반복적으로 수행되는 여러 문장을 메서드로 작성
- 하나의 메서드는 한 가지 기능만 수행하도록 작성

 

메서드 = 선언부 + 구현부

반환타입 메서드이름 (타입 변수명, 타입 변수명, ...)  →  선언부
{
      메서드 호출시 수행될 코드                     → 구현부
}

매개 변수의 입력값은 여러 개가 가능하지만 메서드의 출력 값은 오직 한 개다.

그러므로 여러 개의 결과가 필요하다면 배열 또는 객체를 사용해 출력을 해야 한다.

출력하는 값이 없다면 반환 타입에 void를 사용하면 된다.

 

지역변수(lv) : 메서드 내에 선언된 변수

int add(int x , int y){
	int result = x + y;
    return result;
}

int multiply(int x , int y){
	int result = x * y;
    return result;
}

서로 다른 메서드의 변수는 해당 메서드 내에서만 유효하기 때문에 , 다른 메서드의 변수 이름과 겹쳐도 상관없다.

 

메서드의 호출

메서드 이름(값 1 , 값 2 ,... )  →  메서드를 호출하는 방법

 

메서드의 실행 흐름

MyMath mm = new MyMath();  →  먼저 인스턴스를 생성한다. (객체 생성)
long value = mm.add(1L,2L);  →  메서드를 호출한다.

long add(long a, long b){
	long result = a + b;
    return result;
}

 

return문

실행 중인 메서드를 종료하고 호출한 곳으로 되돌아간다.

int multiply(int x, int y){
	int result = x * y;
    return resuly;  →  반환 타입이 void가 아니므로 생략불가
}

int max(int a,int b){
if(a>b)
	return a;  →  조건식이 참일 때만 실행된다.
}

반환 타입이 void일 경우 return이 생략이 가능하다.

하지만 반환 타입이 void가 아닌 경우, 반드시 return문이 필요하다.

max 메서드 같은 경우는 return문이 있지만 return문이 없다고 에러가 난다.

조건식이 참일 때만 return문이 있고 , 거짓일 때 return 하는 값이 없어서 에러가 나는 것이다.

거짓일 때 return문도 입력해주면 에러가 없어진다.

 

호출 스택(call stack)

스택(stack)은 밑이 막힌 상자와 같다. 상자 안에 책을 쌓으면 차곡차곡 쌓이는 개념이다.

그럼 호출 스택은 무엇일까

메서드 수행에 필요한 메모리가 제공되는 공간이다.

메서드가 호출되면 호출 스택에 메모리 할당이 되고 종료되면 해제가 된다.

아래 있는 메서드가 위의 메서드를 호출한 것이다.

맨 위의 메서드 하나만 실행 중이며 나머지는 대기 중인 상태이다.

 

기본형 매개변수 - 변수의 값을 읽기만 할 수 있다.(read only)

참조형 매개변수 - 변수의 값을 변경할 수 있다.(read & write)

 

반환 타입이 참조형이라는 뜻은 객체의 주소 또는 객체를 반환한다는 뜻이다.

---

Static

static 메서드와 인스턴스 메서드

▶ 인스턴스 메서드
- 인스턴스 생성 후, '참조변수.메서드이름()'으로 호출
- 인스턴스 멤버(iv, im)와 관련된 작업을 하는 메서드
- 메서드 내에서 인스턴스 변수(iv) 사용 가능

▶ static 메서드 ( 클래스 메서드 )
- 객체 생성 없이 '클래스이름.메서드이름()'으로 호출
- 인스턴스 멤버(iv, im)와 관련 없는 작업을 하는 메서드
- 메서드 내에서 인스턴스 변수(iv) 사용불가

크게 보면 인스턴스 변수(iv)를 사용하냐 사용하지 않느냐로 나뉘는 것이다.

사용하면 인스턴스 메서드 , 사용 안 하면 static메서드로 보면 된다.

System.out.println(MyMath2.add(200L,100L);  →  클래스메서드 호출 (객체생성 없이 호출가능)
MyMath2 mm = new MyMath2();  →  인스턴스 생성 (객체 생성)
mm.a = 200L; → iv
mm.b = 100L; → iv
System.out.println(mm.add());  →  인스턴스메서드 호출 (생성 후 호출)

메서드에 static을 붙이는지 안 붙이는지 결정하는 방법은 다음과 같다.

인스턴스 변수(iv)를 사용하면 static을 못 붙이고, 사용 안 하면 static을 붙이는 것이다.

iv의 사용 여부에 따라 결정되는 것이다.

 

메서드 간의 호출과 참조

▶ static 메서드는 인스턴스 변수(iv)를 사용할 수 없다.

class TestClass {
	int iv;  →  인스턴스 변수
    static int cv;  →  클래스 변수
    
    void instanceMethod(){  →  인스턴스 메서드
    	System.out.println(iv);  →  인스턴스 변수를 사용할 수 있다.
        System.out.println(cv);  →  클래스 변수를 사용할 수 있다.
    }
    
    static void staticMethod(){  →  static메서드
    	System.out.println(iv);  →  Error! 인스턴스 변수를 사용할 수 없다.
        System.out.println(cv);  →  클래스 변수는 사용할 수 있다.
    }
}

▶ static 메서드는 인스턴스 메서드(im)를 호출할 수 없다.

Class TestClass {
	void instanceMethod(){}  →  인스턴스메서드
    static void staticMethod() {}  →  static메서드
    
    void instanceMethod2() {  →  인스턴스메서드
    	instanceMethod();  →  다른 인스턴스메서드를 호출한다.
    	staticMethod();  →  static메서드를 호출한다.
    }
    
    static void staticMethod2() {  →  static메서드
    	instanceMethod();  →  Error! 인스턴스메서드를 호출할 수 없다.
        staticMethod();  →  static메서드는 호출 할 수 있다.
    }
}

 

오버로딩 (overloading)

- 한 클래스 안에 같은 이름의 메서드 여러 개 정의하는 것

오버로딩의 대표적인 예는 println이다. println() , println(boolean x) , println(char x) 등

println이라는 메서드 하나로 여러 가지를 할 수 있다.

오버로딩이 성립하기 위한 조건
1. 메서드 이름이 같아야 한다.
2. 매개변수의 개수 또는 타입이 달라야 한다.
3. 반환 타입은 영향 없다.

 

생성자 (constructor)

- 인스턴스가 생성될 때마다 호출되는 '인스턴스 초기화 메서드' → (iv 초기화 메서드)

- 인스턴스 생성 시 수행할 작업(iv 초기화)에 사용

생성자를 만드는 규칙
1. 생성자 이름이 클래스 이름과 같아야 한다.
2. 리턴 값이 없다. ( void 안 붙임 )
3. 모든 클래스는 반드시 생성자를 가져야 한다.

 

기본 생성자 (default constructor)

- 매개변수가 없는 생성자

- 생성자가 하나도 없을 때만, 컴파일러가 자동 추가

클래스이름() {}  →  기본 생성자
Point() {}  →  Point클래스의 기본 생성자

 

생성자 this()

- 생성자에서 다른 생성자 호출할 때 사용

- 다른 생성자 호출 시 첫 줄에서만 사용 가능

 

참조변수 this

- 인스턴스 자신을 가리키는 참조변수

- 인스턴스 메서드(생성자 포함)에서 사용 가능

- 지역변수(lv)와 인스턴스 변수(iv)를 구별할 때 사용

 

참조변수 this와 생성자 this()
this → 인스턴스 자신을 가리키는 참조변수. 인스턴스의 주소가 저장되어 있다.
            모든 인스턴스 메서드에 지역변수로 숨겨진 채로 존재한다.
this() , this(매개변수) → 생성자, 같은 클래의 다른 생성자를 호출할 때 사용한다.

[ this와 this()는 비슷하게 생겼을 뿐 완전히 다른 것이다. this는 '참조 변수'이고, this()는 '생성자'이다. ]

 

변수의 초기화

- 지역변수(lv)는 수동 초기화해야 함 (사용 전 필수)

- 멤버 변수(iv, cv)는 자동 초기화된다.

class InitTest {
	int x;  →  인스턴스 변수
    int y = x;  →  인스턴스 변수
    
    void method1() {
    	int i;  →  지역변수
        int j = i;  →  Error! 지역변수를 초기화하지 않고 사용
    }
}

 

멤버 변수의 초기화

1. 명시적 초기화 ( = )

class Car {
	int door = 4;  →  기본형(primitive type) 변수의 초기화
        Engine e = new Engine();  →  참조형(reference type) 변수의 초기화

 

2. 초기화 블럭 ( 복잡한 초기화 )

iv - 인스턴스 초기화 블럭 : { }

cv - 클래스 초기화 블럭 : static { }

 

3. 생성자 ( iv 초기화 , 복잡한 초기화 )

Car(Strint color , String gearType , int door) {  →  매개변수있는 생성자
	this.color = color;
        this.gearType = gearType;
        this.door = door;

cv , iv 초기화
자동초기화	0
간단초기화	=
복잡초기화	{ } , static{ } , 생성자

 

멤버변수 초기화 - static { }

1. 명시적 초기화 (=) ( 간단 초기화 )

2. 초기화 블럭 - { } , static { } ( cv초기화 ) 

3. 생성자 ( iv초기화 )

class StaticBlockTest {
	static int[] arr = new int [10]; → 명시적 초기화
    
    static { → 클래스 초기화 블럭 - 배열 arr을 난수로 채운다.
    	for(int i = 0;i<arr.length;i++){
        	arr[i] = (int)(Math.random()*10)+1;
        }
    }

 

▶ 클래스 변수 초기화 시점 : 클래스가 처음 로딩될 때 단 한번 ( 메모리에 올라갈 때 )
▶ 인스턴스 변수 초기화 시점 : 인스턴스가 생성될 때마다

초기화 순서
① cv → iv
② 자동 ( 0 ) → 간단 ( = ) → 복잡( static{} , 생성자 )